Relax DictStore and TreeStore path suffix requirements

Author: FrancescAlted

src/blosc2/ctable_storage.py

@@ -157,17 +157,11 @@ class FileTableStorage(TableStorage):
     def __init__(self, urlpath: str, mode: str) -> None:
         if mode not in ("r", "a", "w"):
             raise ValueError(f"mode must be 'r', 'a', or 'w'; got {mode!r}")
-        self._root = self._normalize_root(urlpath)
+        self._root = urlpath
         self._mode = mode
         self._meta: blosc2.SChunk | None = None
         self._store: blosc2.TreeStore | None = None
 
-    @staticmethod
-    def _normalize_root(urlpath: str) -> str:
-        if urlpath.endswith((".b2d", ".b2z")):
-            return urlpath
-        return f"{urlpath}.b2d"
-
     # ------------------------------------------------------------------
     # Key helpers
     # ------------------------------------------------------------------

src/blosc2/dict_store.py

@@ -29,7 +29,7 @@ class DictStore:
     """
     Directory-based storage for compressed data using Blosc2.
 
-    Manages arrays in a directory (.b2d) or zip (.b2z) format.
+    Manages arrays in a directory or zip-file backed format.
 
     Supports the following types:
 
@@ -46,10 +46,11 @@ class DictStore:
     Parameters
     ----------
     localpath : str
-        Local path for the directory (".b2d") or file (".b2z"); other extensions
-        are not supported. If a directory is specified, it will be treated as
-        a Blosc2 directory format (B2DIR). If a file is specified, it
-        will be treated as a Blosc2 zip format (B2ZIP).
+        Local path for the directory or zip file. Paths ending in ``.b2d`` and
+        ``.b2z`` remain the recommended conventions. If the path already exists,
+        directories are treated as Blosc2 directory format (B2DIR) and files as
+        Blosc2 zip format (B2ZIP). For new extensionless paths, directory-backed
+        storage is used by default.
     mode : str, optional
         File mode ('r', 'w', 'a'). Default is 'a'.
     mmap_mode : str or None, optional
@@ -117,8 +118,6 @@ def __init__(
         See :class:`DictStore` for full documentation of parameters.
         """
         self.localpath = localpath if isinstance(localpath, str | bytes) else str(localpath)
-        if not self.localpath.endswith((".b2z", ".b2d")):
-            raise ValueError(f"localpath must have a .b2z or .b2d extension; you passed: {self.localpath}")
         if mode not in ("r", "w", "a"):
             raise ValueError("For DictStore containers, mode must be 'r', 'w', or 'a'")
         if mmap_mode not in (None, "r"):
@@ -152,7 +151,16 @@ def __init__(
 
     def _setup_paths_and_dirs(self, tmpdir: str | None):
         """Set up working directories and paths."""
-        self.is_zip_store = self.localpath.endswith(".b2z")
+        localpath_exists = os.path.exists(self.localpath)
+        if localpath_exists:
+            self.is_zip_store = os.path.isfile(self.localpath)
+        elif self.localpath.endswith(".b2z"):
+            self.is_zip_store = True
+        elif self.localpath.endswith(".b2d"):
+            self.is_zip_store = False
+        else:
+            # Default extensionless new stores to directory-backed layout.
+            self.is_zip_store = False
         if self.is_zip_store:
             if tmpdir is None:
                 self._temp_dir_obj = tempfile.TemporaryDirectory()
@@ -161,11 +169,14 @@ def _setup_paths_and_dirs(self, tmpdir: str | None):
                 self.working_dir = tmpdir
                 os.makedirs(tmpdir, exist_ok=True)
             self.b2z_path = self.localpath
-        else:  # .b2d
+        else:
             self.working_dir = self.localpath
             if self.mode in ("w", "a"):
                 os.makedirs(self.working_dir, exist_ok=True)
-            self.b2z_path = self.localpath[:-4] + ".b2z"
+            if self.localpath.endswith(".b2d"):
+                self.b2z_path = self.localpath[:-4] + ".b2z"
+            else:
+                self.b2z_path = self.localpath + ".b2z"
 
         self.estore_path = os.path.join(self.working_dir, "embed.b2e")
 

src/blosc2/schunk.py

@@ -1529,11 +1529,11 @@ def _open_meta(path, off=0):
 
     if urlpath.endswith(".b2e") and offset == 0:
         return _open_meta(urlpath)
-    if urlpath.endswith(".b2d") and os.path.isdir(urlpath):
+    if os.path.isdir(urlpath):
         embed_path = os.path.join(urlpath, "embed.b2e")
         if os.path.exists(embed_path):
             return _open_meta(embed_path)
-    if urlpath.endswith(".b2z") and os.path.isfile(urlpath):
+    if os.path.isfile(urlpath) and not urlpath.endswith(".b2e"):
         try:
             with open(urlpath, "rb") as f, zipfile.ZipFile(f) as zf:
                 for info in zf.infolist():

tests/ctable/test_schema_mutations.py

@@ -145,11 +145,11 @@ def test_blosc2_open_raw_treestore_for_unknown_manifest_kind():
     assert np.array_equal(opened["/payload"][:], np.arange(3))
 
 
-def test_extensionless_ctable_path_resolves_to_b2d_store():
+def test_extensionless_ctable_path_uses_extensionless_store():
     path = os.path.join(TABLE_ROOT, "alias_ctable")
     t = CTable(Row, urlpath=path, mode="w", new_data=DATA10)
     t.close()
-    assert os.path.exists(path + ".b2d")
+    assert os.path.isdir(path)
     opened = blosc2.open(path, mode="r")
     assert isinstance(opened, CTable)
     np.testing.assert_array_equal(opened["id"].to_numpy(), np.arange(10))

tests/test_dict_store.py

@@ -114,6 +114,23 @@ def test_to_b2z_and_reopen(populated_dict_store):
         assert np.all(dstore_read["/nodeB"][:] == np.arange(6))
 
 
+def test_extensionless_dict_store_defaults_to_directory(tmp_path):
+    path = tmp_path / "test_dstore_extless"
+
+    with DictStore(str(path), mode="w") as dstore:
+        dstore["/node1"] = np.arange(4)
+
+    assert path.is_dir()
+    assert (path / "embed.b2e").exists()
+
+    with DictStore(str(path), mode="r") as dstore:
+        assert np.array_equal(dstore["/node1"][:], np.arange(4))
+
+    opened = blosc2.open(str(path), mode="r")
+    assert isinstance(opened, DictStore)
+    assert np.array_equal(opened["/node1"][:], np.arange(4))
+
+
 def test_to_b2z_from_readonly_b2d():
     b2d_path = "test_to_b2z_from_readonly.b2d"
     b2z_path = "test_to_b2z_from_readonly.b2z"

tests/test_tree_store.py

@@ -1057,6 +1057,23 @@ def test_open_context_manager(populated_tree_store):
         assert np.array_equal(tstore["/child0/data"][:], np.array([1, 2, 3]))
 
 
+def test_extensionless_tree_store_defaults_to_directory(tmp_path):
+    path = tmp_path / "test_tstore_extless"
+
+    with TreeStore(str(path), mode="w") as tstore:
+        tstore["/group/node"] = np.arange(6)
+
+    assert path.is_dir()
+    assert (path / "embed.b2e").exists()
+
+    with TreeStore(str(path), mode="r") as tstore:
+        assert np.array_equal(tstore["/group/node"][:], np.arange(6))
+
+    opened = blosc2.open(str(path), mode="r")
+    assert isinstance(opened, TreeStore)
+    assert np.array_equal(opened["/group/node"][:], np.arange(6))
+
+
 @pytest.mark.parametrize("storage_type", ["b2d", "b2z"])
 def test_mmap_mode_read_access(storage_type, tmp_path):
     path = tmp_path / f"test_tstore_mmap.{storage_type}"