@@ -16,6 +16,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   and stored spike-waveform subsets provide their waveform sample count.
 - TSV, JSON, text and `params.py` files are written atomically, so a crash during a save no longer
   truncates the file it was replacing, for instance `cluster_group.tsv`.
+- #57 a blank `dat_path` in `params.py` is now read as "no raw data file" instead of resolving to
+  the dataset directory.
 
 ## [2.7.0] 2025-12-10
 
 
@@ -322,13 +322,10 @@ def __init__(self, **kwargs):
         assert isinstance(self.dir_path, Path)
         assert self.dir_path.exists()
 
-        # Set dat_path.
-        if not self.dat_path:  # pragma: no cover
-            self.dat_path = []
-        elif not isinstance(self.dat_path, (list, tuple)):
-            self.dat_path = [self.dat_path]
-        assert isinstance(self.dat_path, (list, tuple))
-        self.dat_path = [Path(p).resolve() if not Path(p).is_symlink() else p for p in self.dat_path]
+        # Set dat_path. Blank entries mean "no raw data file", see _clean_dat_path().
+        self.dat_path = [
+            Path(p).resolve() if not Path(p).is_symlink() else p
+            for p in _clean_dat_path(self.dat_path)]
 
         self.dtype = getattr(self, 'dtype', np.int16)
         if not self.sample_rate:  # pragma: no cover
@@ -1416,6 +1413,23 @@ def close(self):
             _close_memmap(k, v)
 
 
+def _clean_dat_path(dat_path):
+    """Normalize a raw data path specification into a list of non-empty paths.
+
+    A blank `dat_path` means the dataset has no raw data file at all. Some sorters write
+    `dat_path = ''` in `params.py` when the recording has no file on disk, for instance
+    SpikeInterface with a simulated or in-memory recording. Such entries have to be dropped
+    rather than resolved, because `Path('')` is `Path('.')`, which would silently turn the
+    missing raw data file into the dataset directory itself.
+
+    """
+    if not dat_path:
+        return []
+    if not isinstance(dat_path, (list, tuple)):
+        dat_path = [dat_path]
+    return [p for p in dat_path if str(p).strip()]
+
+
 def _make_abs_path(p, dir_path):
     p = Path(p)
     if not op.isabs(p):
@@ -1438,9 +1452,8 @@ def get_template_params(params_path):
     assert params['dir_path'].is_dir()
     assert params['dir_path'].exists()
 
-    if isinstance(params['dat_path'], str):
-        params['dat_path'] = [params['dat_path']]
-    params['dat_path'] = [_make_abs_path(_, params['dir_path']) for _ in params['dat_path']]
+    params['dat_path'] = [
+        _make_abs_path(_, params['dir_path']) for _ in _clean_dat_path(params['dat_path'])]
     return params
 
 
 
@@ -14,7 +14,7 @@
 
 # from phylib.utils import Bunch
 from phylib.utils.testing import captured_output
-from ..model import from_sparse, load_model
+from ..model import from_sparse, get_template_params, load_model
 
 logger = logging.getLogger(__name__)
 
@@ -135,6 +135,46 @@ def test_model_save(template_model_full):
     m.save_spike_clusters(m.spike_clusters)
 
 
+def _set_dat_path(params_path, value):
+    """Replace the `dat_path` assignment of a `params.py` file by a literal value."""
+    lines = params_path.read_text().splitlines()
+    lines = [
+        'dat_path = %s' % value if line.startswith('dat_path') else line for line in lines]
+    params_path.write_text('\n'.join(lines) + '\n')
+
+
+def test_model_blank_dat_path(template_path):
+    # Regression test for #57: a dataset with no raw data file on disk has a blank `dat_path`
+    # in params.py. `Path('')` is `Path('.')`, so a blank entry used to resolve to the dataset
+    # directory instead of being dropped.
+    _set_dat_path(template_path, "''")
+    assert get_template_params(template_path)['dat_path'] == []
+
+    model = load_model(template_path)
+    try:
+        assert model.dat_path == []
+        assert model.traces is None
+        with captured_output() as (stdout, stderr):
+            model.describe()
+        assert stdout.getvalue().splitlines()[0].strip() == 'Data files'
+    finally:
+        model.close()
+
+
+def test_model_blank_dat_path_in_list(template_path):
+    # Blank entries are dropped from a list too, and the real file is kept.
+    _set_dat_path(template_path, "['', 'sim_binary.dat']")
+    dat_path = get_template_params(template_path)['dat_path']
+    assert [p.name for p in dat_path] == ['sim_binary.dat']
+
+    model = load_model(template_path)
+    try:
+        assert [p.name for p in model.dat_path] == ['sim_binary.dat']
+        assert model.traces is not None
+    finally:
+        model.close()
+
+
 def test_model_reload_curated_dataset_without_templates(template_path):
     model = load_model(template_path)
     model.save_spikes_subset_waveforms(10, 16)
 
@@ -15,8 +15,9 @@
 import logging
 import os
 from pathlib import Path
+import secrets
+import stat
 import subprocess
-import tempfile
 from textwrap import dedent
 
 import numpy as np
@@ -31,15 +32,12 @@
 #------------------------------------------------------------------------------
 
 def _copy_file_mode(src, dst):
-    """Give `src` the permissions `dst` has, or the permissions a new file would get."""
+    """Give `src` the permissions of `dst` when `dst` exists."""
     try:
-        mode = os.stat(dst).st_mode & 0o777
-    except OSError:
-        # The destination does not exist yet: reproduce what open() would have done, since
-        # tempfile creates its files with 0600 and saving must not make the file private.
-        umask = os.umask(0)
-        os.umask(umask)
-        mode = 0o666 & ~umask
+        mode = stat.S_IMODE(os.stat(dst).st_mode)
+    except FileNotFoundError:
+        # The exclusive open used for a new temporary file already applied the process umask.
+        return
     os.chmod(src, mode)
 
 
@@ -56,11 +54,22 @@ def _atomic_open(path, mode='w', **kwargs):
     """
     path = Path(path)
     ensure_dir_exists(path.parent)
+    if not mode.startswith('w'):
+        raise ValueError("_atomic_open() only supports write modes")
+    exclusive_mode = 'x' + mode[1:]
     # NOTE: the temporary file is hidden and does not end in a data file extension, so that a
     # file left behind by a hard kill is not picked up by the globs used to discover datasets.
-    fd, tmp = tempfile.mkstemp(dir=str(path.parent), prefix='.' + path.name + '.', suffix='.tmp')
+    # Opening it with `x` both prevents a name collision and lets the OS apply the current umask,
+    # without temporarily changing that process-global setting.
+    while True:
+        tmp = path.parent / ('.%s.%s.tmp' % (path.name, secrets.token_hex(16)))
+        try:
+            f = open(tmp, exclusive_mode, **kwargs)
+            break
+        except FileExistsError:  # pragma: no cover - cryptographically unlikely
+            continue
     try:
-        with os.fdopen(fd, mode, **kwargs) as f:
+        with f:
             yield f
             f.flush()
             os.fsync(f.fileno())
 
@@ -154,18 +154,22 @@ def test_atomic_open(tempdir):
     # The temporary file must not be left behind.
     assert sorted(p.name for p in path.parent.iterdir()) == ['test.txt']
 
-    # A new file gets the permissions open() would have given it, not the 0600 of a
-    # temporary file.
-    umask = os.umask(0)
-    os.umask(umask)
-    assert stat.S_IMODE(path.stat().st_mode) == 0o666 & ~umask
+    # A new file gets the permissions open() would have given it, without reading or changing
+    # the process-global umask. Compare it with an ordinary file created in the same directory.
+    control = path.parent / 'control.txt'
+    control.write_text('control')
+    assert stat.S_IMODE(path.stat().st_mode) == stat.S_IMODE(control.stat().st_mode)
+    control.unlink()
 
     # The permissions of an existing file are preserved.
-    path.chmod(0o640)
+    expected_mode = stat.S_IMODE(path.stat().st_mode)
+    if os.name != 'nt':
+        path.chmod(0o640)
+        expected_mode = 0o640
     with _atomic_open(path) as f:
         f.write('world')
     assert read_text(path) == 'world'
-    assert stat.S_IMODE(path.stat().st_mode) == 0o640
+    assert stat.S_IMODE(path.stat().st_mode) == expected_mode
 
     # A failure half-way through leaves the previous file untouched and no leftovers.
     with raises(_Boom):
@@ -175,6 +179,11 @@ def test_atomic_open(tempdir):
     assert read_text(path) == 'world'
     assert sorted(p.name for p in path.parent.iterdir()) == ['test.txt']
 
+    # Binary writes use the same atomic and cleanup path, ready for numpy saves.
+    with _atomic_open(path, mode='wb') as f:
+        f.write(b'bytes')
+    assert path.read_bytes() == b'bytes'
+
 
 @mark.parametrize('writer', ['write_tsv', '_write_tsv_simple'])
 def test_write_tsv_atomic(tempdir, monkeypatch, writer):