Check the source identity when a Proxy adopts a cache

Same shape, dtype and partitioning is not the same bytes: a replaced remote
frame keeps its layout while every cached chunk, and every offset it was
fetched by, goes stale.  blosc2.open() already refetched in that case, but the
hand-built form the FsspecNDSource docstring recommends went straight to the
Proxy and skipped the check.

So the Proxy stamps its cache with whatever identity the source can name itself
by, and refuses one built against other bytes.  Sources that have no identity to
give are still adopted on geometry alone, as documented.  This also takes over
the stamping _lazy_fsspec_proxy() was doing by hand.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: FrancescAlted

src/blosc2/proxy.py

@@ -307,6 +307,11 @@ def __init__(
         self._schunk_cache = getattr(self._cache, "schunk", self._cache)
         if self.urlpath is None:
             self.urlpath = getattr(self._schunk_cache, "urlpath", None)
+        # Geometry alone cannot tell a replaced source from the one the cache was
+        # filled from, so record whatever identity the source can name itself by
+        stamp = getattr(self.src, "stamp", None)
+        if stamp is not None:
+            self._schunk_cache.vlmeta["fsspec-stamp"] = stamp
         if vlmeta:
             for key in vlmeta:
                 self._schunk_cache.vlmeta[key] = vlmeta[key]
@@ -357,6 +362,16 @@ def _reopen_cache(self, urlpath: str):
                 f"the cache at {urlpath} was built for a different source: it holds {here}, "
                 f"the source is {there} ({fields})"
             )
+        # Same geometry is not the same bytes: a replaced remote frame keeps its
+        # layout while every cached chunk, and every offset it was fetched by,
+        # goes stale.  Only for sources that can name themselves; the rest are
+        # adopted on geometry alone, as documented.
+        stamp = getattr(self.src, "stamp", None)
+        if stamp is not None and schunk.vlmeta.get("fsspec-stamp") != stamp:
+            raise ValueError(
+                f"the cache at {urlpath} was built against different remote bytes; "
+                f"pass mode='w' to fetch them anew"
+            )
         return cached
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> bool:

src/blosc2/schunk.py

@@ -1964,7 +1964,9 @@ def _lazy_fsspec_proxy(
         # The remote frame was replaced, which makes every cached chunk -- and
         # every offset they were fetched by -- meaningless
         blosc2.remove_urlpath(path)
-    return blosc2.Proxy(src, urlpath=path, mode="a", vlmeta={"fsspec-stamp": src.stamp})
+    # Proxy stamps the cache with src.stamp itself, and refuses one built against
+    # other bytes; removing it above is what turns that refusal into a refetch
+    return blosc2.Proxy(src, urlpath=path, mode="a")
 
 
 def _cache_stamp(path: str):

tests/test_fsspec.py

@@ -660,3 +660,22 @@ def test_lazy_open_never_opens_a_handle(monkeypatch):
 
     b = blosc2.open("memory://ranges.b2nd", lazy=True)
     assert np.array_equal(b[100:200], a[100:200])
+
+
+def test_handbuilt_proxy_rejects_a_stale_cache(tmp_path):
+    # The FsspecNDSource docstring recommends wrapping it in a Proxy by hand, which
+    # bypasses the refetch blosc2.open() does; same geometry is not the same bytes
+    memfs = fsspec.filesystem("memory")
+    cache = str(tmp_path / "hand.b2nd")
+    memfs.pipe_file("/hand.b2nd", blosc2.arange(100, dtype="i4", chunks=(10,)).to_cframe())
+    p = blosc2.Proxy(blosc2.FsspecNDSource("memory://hand.b2nd"), urlpath=cache, mode="a")
+    assert np.array_equal(p[:10], np.arange(10, dtype="i4"))
+    del p
+
+    other = blosc2.arange(100, 200, dtype="i4", chunks=(10,))
+    memfs.pipe_file("/hand.b2nd", other.to_cframe())
+    with pytest.raises(ValueError, match="different remote bytes"):
+        blosc2.Proxy(blosc2.FsspecNDSource("memory://hand.b2nd"), urlpath=cache, mode="a")
+
+    p = blosc2.Proxy(blosc2.FsspecNDSource("memory://hand.b2nd"), urlpath=cache, mode="w")
+    assert np.array_equal(p[:], other[:])