scrub out set-range logic

Author: d-v-b

src/zarr/abc/store.py

@@ -22,7 +22,6 @@
     "Store",
     "SupportsDeleteSync",
     "SupportsGetSync",
-    "SupportsSetRangeSync",
     "SupportsSetSync",
     "SupportsSyncStore",
     "set_or_delete",
@@ -726,20 +725,13 @@ class SupportsSetSync(Protocol):
     def set_sync(self, key: str, value: Buffer) -> None: ...
 
 
-@runtime_checkable
-class SupportsSetRangeSync(Protocol):
-    def set_range_sync(self, key: str, value: Buffer, start: int) -> None: ...
-
-
 @runtime_checkable
 class SupportsDeleteSync(Protocol):
     def delete_sync(self, key: str) -> None: ...
 
 
 @runtime_checkable
-class SupportsSyncStore(
-    SupportsGetSync, SupportsSetSync, SupportsSetRangeSync, SupportsDeleteSync, Protocol
-): ...
+class SupportsSyncStore(SupportsGetSync, SupportsSetSync, SupportsDeleteSync, Protocol): ...
 
 
 async def set_or_delete(byte_setter: ByteSetter, value: Buffer | None) -> None:

src/zarr/storage/_common.py

@@ -10,7 +10,6 @@
     Store,
     SupportsDeleteSync,
     SupportsGetSync,
-    SupportsSetRangeSync,
     SupportsSetSync,
 )
 from zarr.core.buffer import Buffer, default_buffer_prototype
@@ -258,14 +257,6 @@ def set_sync(self, value: Buffer) -> None:
             raise TypeError(f"Store {type(self.store).__name__} does not support synchronous set.")
         self.store.set_sync(self.path, value)
 
-    def set_range_sync(self, value: Buffer, start: int) -> None:
-        """Synchronous byte-range write."""
-        if not isinstance(self.store, SupportsSetRangeSync):
-            raise TypeError(
-                f"Store {type(self.store).__name__} does not support synchronous set_range."
-            )
-        self.store.set_range_sync(self.path, value, start)
-
     def delete_sync(self) -> None:
         """Synchronous delete — delegates to ``self.store.delete_sync(self.path)``."""
         if not isinstance(self.store, SupportsDeleteSync):

src/zarr/storage/_local.py

@@ -85,19 +85,6 @@ def _put(path: Path, value: Buffer, exclusive: bool = False) -> int:
         return f.write(view)
 
 
-def _put_range(path: Path, value: Buffer, start: int) -> None:
-    view = value.as_buffer_like()
-    file_size = path.stat().st_size
-    if start + len(view) > file_size:
-        raise ValueError(
-            f"set_range would write beyond the end of the stored value: "
-            f"start={start}, len(value)={len(view)}, stored size={file_size}"
-        )
-    with path.open("r+b") as f:
-        f.seek(start)
-        f.write(view)
-
-
 class LocalStore(Store):
     """
     Store for the local file system.
@@ -241,12 +228,6 @@ def set_sync(self, key: str, value: Buffer) -> None:
         path = self.root / key
         _put(path, value)
 
-    def set_range_sync(self, key: str, value: Buffer, start: int) -> None:
-        self._ensure_open_sync()
-        self._check_writable()
-        path = self.root / key
-        _put_range(path, value, start)
-
     def delete_sync(self, key: str) -> None:
         self._ensure_open_sync()
         self._check_writable()

src/zarr/storage/_memory.py

@@ -172,26 +172,6 @@ async def set(self, key: str, value: Buffer, byte_range: tuple[int, int] | None
         else:
             self._store_dict[key] = value
 
-    def _set_range_impl(self, key: str, value: Buffer, start: int) -> None:
-        buf = self._store_dict[key]
-        target = buf.as_numpy_array()
-        if start + len(value) > len(target):
-            raise ValueError(
-                f"set_range would write beyond the end of the stored value: "
-                f"start={start}, len(value)={len(value)}, stored size={len(target)}"
-            )
-        if not target.flags.writeable:
-            target = target.copy()
-            self._store_dict[key] = buf.__class__(target)
-        target[start : start + len(value)] = value.as_numpy_array()
-
-    def set_range_sync(self, key: str, value: Buffer, start: int) -> None:
-        """Synchronous byte-range write."""
-        self._check_writable()
-        if not self._is_open:
-            self._is_open = True
-        self._set_range_impl(key, value, start)
-
     async def set_if_not_exists(self, key: str, value: Buffer) -> None:
         # docstring inherited
         self._check_writable()

src/zarr/testing/store.py

@@ -6,8 +6,6 @@
 from abc import abstractmethod
 from typing import TYPE_CHECKING, Generic, Self, TypeVar
 
-import numpy as np
-
 from zarr.storage import WrapperStore
 
 if TYPE_CHECKING:
@@ -25,7 +23,6 @@
     SuffixByteRequest,
     SupportsDeleteSync,
     SupportsGetSync,
-    SupportsSetRangeSync,
     SupportsSetSync,
 )
 from zarr.core.buffer import Buffer, default_buffer_prototype
@@ -58,13 +55,6 @@ def _require_set_sync(store: S) -> SupportsSetSync:
             pytest.skip("store does not implement SupportsSetSync")
         return store  # type: ignore[unreachable]
 
-    @staticmethod
-    def _require_set_range_sync(store: S) -> SupportsSetRangeSync:
-        """Skip unless *store* implements :class:`SupportsSetRangeSync`."""
-        if not isinstance(store, SupportsSetRangeSync):
-            pytest.skip("store does not implement SupportsSetRangeSync")
-        return store  # type: ignore[unreachable]
-
     @staticmethod
     def _require_delete_sync(store: S) -> SupportsDeleteSync:
         """Skip unless *store* implements :class:`SupportsDeleteSync`."""
@@ -658,61 +648,6 @@ def test_delete_sync_missing(self, store: S) -> None:
         # should not raise
         deleter.delete_sync("nonexistent_sync")
 
-    # -------------------------------------------------------------------
-    # set_range (sync only — set_range is exclusively a sync-path API)
-    # -------------------------------------------------------------------
-
-    def test_set_range_sync(self, store: S) -> None:
-        setter = self._require_set_sync(store)
-        ranger = self._require_set_range_sync(store)
-        getter = self._require_get_sync(store)
-        data_buf = self.buffer_cls.from_bytes(b"hello world")
-        key = "range_sync_key"
-        setter.set_sync(key, data_buf)
-        patch = default_buffer_prototype().buffer.from_bytes(b"WORLD")
-        ranger.set_range_sync(key, patch, 6)
-        result = getter.get_sync(key)
-        assert result is not None
-        assert result.to_bytes() == b"hello WORLD"
-
-    def test_set_range_sync_preserves_other_bytes(self, store: S) -> None:
-        setter = self._require_set_sync(store)
-        ranger = self._require_set_range_sync(store)
-        getter = self._require_get_sync(store)
-        data = np.arange(100, dtype="uint8")
-        data_buf = default_buffer_prototype().buffer.from_array_like(data)
-        key = "range_preserve"
-        setter.set_sync(key, data_buf)
-        patch = np.full(10, 255, dtype="uint8")
-        patch_buf = default_buffer_prototype().buffer.from_array_like(patch)
-        ranger.set_range_sync(key, patch_buf, 50)
-        result = getter.get_sync(key)
-        assert result is not None
-        result_arr = np.frombuffer(result.to_bytes(), dtype="uint8")
-        expected = data.copy()
-        expected[50:60] = 255
-        np.testing.assert_array_equal(result_arr, expected)
-
-    def test_set_range_sync_beyond_end_raises(self, store: S) -> None:
-        setter = self._require_set_sync(store)
-        ranger = self._require_set_range_sync(store)
-        data_buf = self.buffer_cls.from_bytes(b"hello")
-        key = "range_oob"
-        setter.set_sync(key, data_buf)
-        patch = default_buffer_prototype().buffer.from_bytes(b"world!")
-        with pytest.raises(ValueError, match="set_range would write beyond"):
-            ranger.set_range_sync(key, patch, 0)
-
-    def test_set_range_sync_start_beyond_end_raises(self, store: S) -> None:
-        setter = self._require_set_sync(store)
-        ranger = self._require_set_range_sync(store)
-        data_buf = self.buffer_cls.from_bytes(b"hello")
-        key = "range_oob2"
-        setter.set_sync(key, data_buf)
-        patch = default_buffer_prototype().buffer.from_bytes(b"x")
-        with pytest.raises(ValueError, match="set_range would write beyond"):
-            ranger.set_range_sync(key, patch, 10)
-
 
 class LatencyStore(WrapperStore[Store]):
     """