cleanup

Author: aldenks

src/zarr/abc/store.py

@@ -16,19 +16,10 @@
 
     from zarr.core.buffer import Buffer, BufferPrototype
 
-__all__ = [
-    "ByteGetter",
-    "ByteSetter",
-    "Store",
-    "SupportsDeleteSync",
-    "SupportsGetSync",
-    "SupportsSetSync",
-    "SupportsSyncStore",
-    "set_or_delete",
-]
-
-
-@dataclass(frozen=True, slots=True)
+__all__ = ["ByteGetter", "ByteSetter", "Store", "set_or_delete"]
+
+
+@dataclass
 class RangeByteRequest:
     """Request a specific byte range"""
 
@@ -38,15 +29,15 @@ class RangeByteRequest:
     """The end of the byte range request (exclusive)."""
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass
 class OffsetByteRequest:
     """Request all bytes starting from a given byte offset"""
 
     offset: int
     """The byte offset for the offset range request."""
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass
 class SuffixByteRequest:
     """Request up to the last `n` bytes"""
 
@@ -721,31 +712,6 @@ async def delete(self) -> None: ...
     async def set_if_not_exists(self, default: Buffer) -> None: ...
 
 
-@runtime_checkable
-class SupportsGetSync(Protocol):
-    def get_sync(
-        self,
-        key: str,
-        *,
-        prototype: BufferPrototype | None = None,
-        byte_range: ByteRequest | None = None,
-    ) -> Buffer | None: ...
-
-
-@runtime_checkable
-class SupportsSetSync(Protocol):
-    def set_sync(self, key: str, value: Buffer) -> None: ...
-
-
-@runtime_checkable
-class SupportsDeleteSync(Protocol):
-    def delete_sync(self, key: str) -> None: ...
-
-
-@runtime_checkable
-class SupportsSyncStore(SupportsGetSync, SupportsSetSync, SupportsDeleteSync, Protocol): ...
-
-
 async def set_or_delete(byte_setter: ByteSetter, value: Buffer | None) -> None:
     """Set or delete a value in a byte setter
 

src/zarr/codecs/sharding.py

@@ -129,7 +129,9 @@ class _ShardIndex(NamedTuple):
 
     @property
     def chunks_per_shard(self) -> tuple[int, ...]:
-        return tuple(self.offsets_and_lengths.shape[0:-1])
+        result = tuple(self.offsets_and_lengths.shape[0:-1])
+        # The cast is required until https://github.com/numpy/numpy/pull/27211 is merged
+        return cast("tuple[int, ...]", result)
 
     def _localize_chunk(self, chunk_coords: tuple[int, ...]) -> tuple[int, ...]:
         return tuple(
@@ -302,9 +304,7 @@ def to_dict_vectorized(
 
 @dataclass(frozen=True)
 class ShardingCodec(
-    ArrayBytesCodec,
-    ArrayBytesCodecPartialDecodeMixin,
-    ArrayBytesCodecPartialEncodeMixin,
+    ArrayBytesCodec, ArrayBytesCodecPartialDecodeMixin, ArrayBytesCodecPartialEncodeMixin
 ):
     """Sharding codec"""
 
@@ -486,7 +486,9 @@ async def _decode_partial_single(
         if self._is_total_shard(all_chunk_coords, chunks_per_shard):
             # read entire shard
             shard_dict_maybe = await self._load_full_shard_maybe(
-                byte_getter, chunk_spec.prototype, chunks_per_shard
+                byte_getter=byte_getter,
+                prototype=chunk_spec.prototype,
+                chunks_per_shard=chunks_per_shard,
             )
         else:
             # read some chunks within the shard
@@ -584,9 +586,7 @@ async def _encode_partial_single(
 
         indexer = list(
             get_indexer(
-                selection,
-                shape=shard_shape,
-                chunk_grid=RegularChunkGrid(chunk_shape=chunk_shape),
+                selection, shape=shard_shape, chunk_grid=RegularChunkGrid(chunk_shape=chunk_shape)
             )
         )
 
@@ -702,8 +702,7 @@ def _shard_index_size(self, chunks_per_shard: tuple[int, ...]) -> int:
             get_pipeline_class()
             .from_codecs(self.index_codecs)
             .compute_encoded_size(
-                16 * product(chunks_per_shard),
-                self._get_index_chunk_spec(chunks_per_shard),
+                16 * product(chunks_per_shard), self._get_index_chunk_spec(chunks_per_shard)
             )
         )
 
@@ -748,8 +747,7 @@ async def _load_shard_index_maybe(
             )
         else:
             index_bytes = await byte_getter.get(
-                prototype=numpy_buffer_prototype(),
-                byte_range=SuffixByteRequest(shard_index_size),
+                prototype=numpy_buffer_prototype(), byte_range=SuffixByteRequest(shard_index_size)
             )
         if index_bytes is not None:
             return await self._decode_shard_index(index_bytes, chunks_per_shard)

src/zarr/storage/_common.py

@@ -5,13 +5,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, Self, TypeAlias
 
-from zarr.abc.store import (
-    ByteRequest,
-    Store,
-    SupportsDeleteSync,
-    SupportsGetSync,
-    SupportsSetSync,
-)
+from zarr.abc.store import ByteRequest, Store
 from zarr.core.buffer import Buffer, default_buffer_prototype
 from zarr.core.common import (
     ANY_ACCESS_MODE,
@@ -260,37 +254,6 @@ async def is_empty(self) -> bool:
         """
         return await self.store.is_empty(self.path)
 
-    # -------------------------------------------------------------------
-    # Synchronous IO delegation
-    # -------------------------------------------------------------------
-
-    def get_sync(
-        self,
-        *,
-        prototype: BufferPrototype | None = None,
-        byte_range: ByteRequest | None = None,
-    ) -> Buffer | None:
-        """Synchronous read — delegates to ``self.store.get_sync(self.path, ...)``."""
-        if not isinstance(self.store, SupportsGetSync):
-            raise TypeError(f"Store {type(self.store).__name__} does not support synchronous get.")
-        if prototype is None:
-            prototype = default_buffer_prototype()
-        return self.store.get_sync(self.path, prototype=prototype, byte_range=byte_range)
-
-    def set_sync(self, value: Buffer) -> None:
-        """Synchronous write — delegates to ``self.store.set_sync(self.path, value)``."""
-        if not isinstance(self.store, SupportsSetSync):
-            raise TypeError(f"Store {type(self.store).__name__} does not support synchronous set.")
-        self.store.set_sync(self.path, value)
-
-    def delete_sync(self) -> None:
-        """Synchronous delete — delegates to ``self.store.delete_sync(self.path)``."""
-        if not isinstance(self.store, SupportsDeleteSync):
-            raise TypeError(
-                f"Store {type(self.store).__name__} does not support synchronous delete."
-            )
-        self.store.delete_sync(self.path)
-
     def __truediv__(self, other: str) -> StorePath:
         """Combine this store path with another path"""
         return self.__class__(self.store, _dereference_path(self.path, other))

tests/test_codecs/test_sharding.py

@@ -112,9 +112,7 @@ def test_sharding_scalar(
     indirect=["array_fixture"],
 )
 def test_sharding_partial(
-    store: Store,
-    array_fixture: npt.NDArray[Any],
-    index_location: ShardingCodecIndexLocation,
+    store: Store, array_fixture: npt.NDArray[Any], index_location: ShardingCodecIndexLocation
 ) -> None:
     data = array_fixture
     spath = StorePath(store)
@@ -150,9 +148,7 @@ def test_sharding_partial(
     indirect=["array_fixture"],
 )
 def test_sharding_partial_readwrite(
-    store: Store,
-    array_fixture: npt.NDArray[Any],
-    index_location: ShardingCodecIndexLocation,
+    store: Store, array_fixture: npt.NDArray[Any], index_location: ShardingCodecIndexLocation
 ) -> None:
     data = array_fixture
     spath = StorePath(store)
@@ -184,9 +180,7 @@ def test_sharding_partial_readwrite(
 @pytest.mark.parametrize("index_location", ["start", "end"])
 @pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
 def test_sharding_partial_read(
-    store: Store,
-    array_fixture: npt.NDArray[Any],
-    index_location: ShardingCodecIndexLocation,
+    store: Store, array_fixture: npt.NDArray[Any], index_location: ShardingCodecIndexLocation
 ) -> None:
     data = array_fixture
     spath = StorePath(store)
@@ -476,9 +470,7 @@ async def fail_chunk_reads(prototype: Any, key_ranges: Any, **kwargs: Any) -> li
 @pytest.mark.parametrize("index_location", ["start", "end"])
 @pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
 def test_sharding_partial_overwrite(
-    store: Store,
-    array_fixture: npt.NDArray[Any],
-    index_location: ShardingCodecIndexLocation,
+    store: Store, array_fixture: npt.NDArray[Any], index_location: ShardingCodecIndexLocation
 ) -> None:
     data = array_fixture[:10, :10, :10]
     spath = StorePath(store)
@@ -653,6 +645,7 @@ async def test_delete_empty_shards(store: Store) -> None:
         compressors=None,
         fill_value=1,
     )
+    print(a.metadata.to_dict())
     await _AsyncArrayProxy(a)[:, :].set(np.zeros((16, 16)))
     await _AsyncArrayProxy(a)[8:, :].set(np.ones((8, 16)))
     await _AsyncArrayProxy(a)[:, 8:].set(np.ones((16, 8)))
@@ -697,6 +690,7 @@ async def test_sharding_with_empty_inner_chunk(
     )
     data[:4, :4] = fill_value
     await a.setitem(..., data)
+    print("read data")
     data_read = await a.getitem(...)
     assert np.array_equal(data_read, data)
 
@@ -708,9 +702,7 @@ async def test_sharding_with_empty_inner_chunk(
 )
 @pytest.mark.parametrize("chunks_per_shard", [(5, 2), (2, 5), (5, 5)])
 async def test_sharding_with_chunks_per_shard(
-    store: Store,
-    index_location: ShardingCodecIndexLocation,
-    chunks_per_shard: tuple[int],
+    store: Store, index_location: ShardingCodecIndexLocation, chunks_per_shard: tuple[int]
 ) -> None:
     chunk_shape = (2, 1)
     shape = tuple(x * y for x, y in zip(chunks_per_shard, chunk_shape, strict=False))