Add persistent store-type meta to EmbedStore, DictStore and TreeStore

   Each container now writes a type-identifying metalayer into its
   underlying SChunk (embed.b2e) at creation time: "b2embed" for
   EmbedStore, "b2dict" for DictStore, and "b2tree" for TreeStore.
   The meta is read back on open and exposed via `store.storage.meta`.

   `blosc2.open()` (_open_special_store) now checks this metalayer first
   to dispatch to the right constructor, taking priority over the file
   extension heuristic. This also fixes the latent bug where a .b2z file
   created with DictStore would have been opened as a TreeStore.

   Tests added to verify meta presence and persistence for all three
   store types, including after close/reopen and via `blosc2.open()`.

   Related with #546.

Author: FrancescAlted

src/blosc2/schunk.py

@@ -9,6 +9,7 @@
 
 import os
 import pathlib
+import zipfile
 from collections import namedtuple
 from collections.abc import Iterator, Mapping, MutableMapping
 from dataclasses import asdict, replace
@@ -1486,20 +1487,52 @@ def __dealloc__(self):
         super().__dealloc__()
 
 
-def _open_special_store(urlpath, mode, offset, **kwargs):
+def _meta_from_store(urlpath, offset):
+    """Try to read the SChunk meta from a store path (b2e, b2d, or b2z)."""
+
+    def _open_meta(path, off=0):
+        try:
+            return blosc2.blosc2_ext.open(path, mode="r", offset=off).meta
+        except Exception:
+            return None
+
+    if urlpath.endswith(".b2e") and offset == 0:
+        return _open_meta(urlpath)
+    if urlpath.endswith(".b2d") and 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):
+        try:
+            with open(urlpath, "rb") as f, zipfile.ZipFile(f) as zf:
+                for info in zf.infolist():
+                    if info.filename == "embed.b2e":
+                        f.seek(info.header_offset)
+                        local_header = f.read(30)
+                        filename_len = int.from_bytes(local_header[26:28], "little")
+                        extra_len = int.from_bytes(local_header[28:30], "little")
+                        data_offset = info.header_offset + 30 + filename_len + extra_len
+                        return _open_meta(urlpath, data_offset)
+        except Exception:
+            pass
+    return None
+
+
+def _store_from_extension(urlpath, mode, offset, **kwargs):
+    """Dispatch to the right store constructor based on file extension."""
     if urlpath.endswith(".b2d"):
         if offset != 0:
             raise ValueError("Offset must be 0 for DictStore")
         from blosc2.dict_store import DictStore
 
         return DictStore(urlpath, mode=mode, **kwargs)
-    elif urlpath.endswith(".b2z"):
+    if urlpath.endswith(".b2z"):
         if offset != 0:
             raise ValueError("Offset must be 0 for TreeStore")
         from blosc2.tree_store import TreeStore
 
         return TreeStore(urlpath, mode=mode, **kwargs)
-    elif urlpath.endswith(".b2e"):
+    if urlpath.endswith(".b2e"):
         if offset != 0:
             raise ValueError("Offset must be 0 for EmbedStore")
         from blosc2.embed_store import EmbedStore
@@ -1508,6 +1541,32 @@ def _open_special_store(urlpath, mode, offset, **kwargs):
     return None
 
 
+def _open_special_store(urlpath, mode, offset, **kwargs):
+    # Meta-based detection has priority over extension
+    schunk_meta = _meta_from_store(urlpath, offset)
+    if schunk_meta is not None:
+        if "b2embed" in schunk_meta:
+            if offset != 0:
+                raise ValueError("Offset must be 0 for EmbedStore")
+            from blosc2.embed_store import EmbedStore
+
+            return EmbedStore(urlpath, mode=mode, **kwargs)
+        if "b2dict" in schunk_meta:
+            if offset != 0:
+                raise ValueError("Offset must be 0 for DictStore")
+            from blosc2.dict_store import DictStore
+
+            return DictStore(urlpath, mode=mode, **kwargs)
+        if "b2tree" in schunk_meta:
+            if offset != 0:
+                raise ValueError("Offset must be 0 for TreeStore")
+            from blosc2.tree_store import TreeStore
+
+            return TreeStore(urlpath, mode=mode, **kwargs)
+
+    return _store_from_extension(urlpath, mode, offset, **kwargs)
+
+
 def _set_default_dparams(kwargs):
     dparams = kwargs.get("dparams")
     if dparams is None:

tests/test_dict_store.py

@@ -449,6 +449,7 @@ def test_open_context_manager(populated_dict_store):
     # Test opening via blosc2.open as a context manager
     with blosc2.open(path, mode="r", mmap_mode="r") as dstore:
         assert isinstance(dstore, DictStore)
+        assert "b2dict" in dstore.storage.meta
         assert "/node1" in dstore
         assert np.array_equal(dstore["/node1"][:], np.array([1, 2, 3]))
 

tests/test_embed_store.py

@@ -220,6 +220,7 @@ def test_open_context_manager(cleanup_files):
     # Test opening via blosc2.open as a context manager
     with blosc2.open(path, mode="r", mmap_mode="r") as estore_read:
         assert isinstance(estore_read, blosc2.EmbedStore)
+        assert "b2embed" in estore_read.storage.meta
         assert "/node1" in estore_read
         assert np.array_equal(estore_read["/node1"][:], np.arange(10))
 

tests/test_tree_store.py

@@ -935,6 +935,7 @@ def test_open_context_manager(populated_tree_store):
     # Test opening via blosc2.open as a context manager
     with blosc2.open(path, mode="r", mmap_mode="r") as tstore:
         assert isinstance(tstore, TreeStore)
+        assert "b2tree" in tstore.storage.meta
         assert "/child0/data" in tstore
         assert np.array_equal(tstore["/child0/data"][:], np.array([1, 2, 3]))