chunk_metadata -> chunk_spec

Author: normanrz

zarr/v3/abc/codec.py

@@ -33,11 +33,11 @@ def from_metadata(cls, codec_metadata: CodecMetadata) -> Codec:
         pass
 
     @abstractmethod
-    def compute_encoded_size(self, input_byte_length: int, chunk_metadata: ArraySpec) -> int:
+    def compute_encoded_size(self, input_byte_length: int, chunk_spec: ArraySpec) -> int:
         pass
 
-    def resolve_metadata(self, chunk_metadata: ArraySpec) -> ArraySpec:
-        return chunk_metadata
+    def resolve_metadata(self, chunk_spec: ArraySpec) -> ArraySpec:
+        return chunk_spec
 
     def evolve(self, *, ndim: int, data_type: DataType) -> Codec:
         return self
@@ -51,7 +51,7 @@ class ArrayArrayCodec(Codec):
     async def decode(
         self,
         chunk_array: np.ndarray,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> np.ndarray:
         pass
@@ -60,7 +60,7 @@ async def decode(
     async def encode(
         self,
         chunk_array: np.ndarray,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> Optional[np.ndarray]:
         pass
@@ -71,7 +71,7 @@ class ArrayBytesCodec(Codec):
     async def decode(
         self,
         chunk_array: BytesLike,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> np.ndarray:
         pass
@@ -80,7 +80,7 @@ async def decode(
     async def encode(
         self,
         chunk_array: np.ndarray,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
         pass
@@ -92,7 +92,7 @@ async def decode_partial(
         self,
         store_path: StorePath,
         selection: SliceSelection,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> Optional[np.ndarray]:
         pass
@@ -105,7 +105,7 @@ async def encode_partial(
         store_path: StorePath,
         chunk_array: np.ndarray,
         selection: SliceSelection,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> None:
         pass
@@ -116,7 +116,7 @@ class BytesBytesCodec(Codec):
     async def decode(
         self,
         chunk_array: BytesLike,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> BytesLike:
         pass
@@ -125,7 +125,7 @@ async def decode(
     async def encode(
         self,
         chunk_array: BytesLike,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
         pass

zarr/v3/array.py

@@ -257,14 +257,14 @@ async def _read_chunk(
         out_selection: SliceSelection,
         out: np.ndarray,
     ):
-        chunk_metadata = self.metadata.get_chunk_metadata(chunk_coords)
+        chunk_spec = self.metadata.get_chunk_spec(chunk_coords)
         chunk_key_encoding = self.metadata.chunk_key_encoding
         chunk_key = chunk_key_encoding.encode_chunk_key(chunk_coords)
         store_path = self.store_path / chunk_key
 
         if self.codec_pipeline.supports_partial_decode:
             chunk_array = await self.codec_pipeline.decode_partial(
-                store_path, chunk_selection, chunk_metadata, self.runtime_configuration
+                store_path, chunk_selection, chunk_spec, self.runtime_configuration
             )
             if chunk_array is not None:
                 out[out_selection] = chunk_array
@@ -274,7 +274,7 @@ async def _read_chunk(
             chunk_bytes = await store_path.get_async()
             if chunk_bytes is not None:
                 chunk_array = await self.codec_pipeline.decode(
-                    chunk_bytes, chunk_metadata, self.runtime_configuration
+                    chunk_bytes, chunk_spec, self.runtime_configuration
                 )
                 tmp = chunk_array[chunk_selection]
                 out[out_selection] = tmp
@@ -326,7 +326,7 @@ async def _write_chunk(
         chunk_selection: SliceSelection,
         out_selection: SliceSelection,
     ):
-        chunk_metadata = self.metadata.get_chunk_metadata(chunk_coords)
+        chunk_spec = self.metadata.get_array_spec(chunk_coords)
         chunk_key_encoding = self.metadata.chunk_key_encoding
         chunk_key = chunk_key_encoding.encode_chunk_key(chunk_coords)
         store_path = self.store_path / chunk_key
@@ -341,15 +341,15 @@ async def _write_chunk(
                 chunk_array.fill(value)
             else:
                 chunk_array = value[out_selection]
-            await self._write_chunk_to_store(store_path, chunk_array, chunk_metadata)
+            await self._write_chunk_to_store(store_path, chunk_array, chunk_spec)
 
         elif self.codec_pipeline.supports_partial_encode:
             # print("encode_partial", chunk_coords, chunk_selection, repr(self))
             await self.codec_pipeline.encode_partial(
                 store_path,
                 value[out_selection],
                 chunk_selection,
-                chunk_metadata,
+                chunk_spec,
                 self.runtime_configuration,
             )
         else:
@@ -367,22 +367,22 @@ async def _write_chunk(
             else:
                 chunk_array = (
                     await self.codec_pipeline.decode(
-                        chunk_bytes, chunk_metadata, self.runtime_configuration
+                        chunk_bytes, chunk_spec, self.runtime_configuration
                     )
                 ).copy()  # make a writable copy
             chunk_array[chunk_selection] = value[out_selection]
 
-            await self._write_chunk_to_store(store_path, chunk_array, chunk_metadata)
+            await self._write_chunk_to_store(store_path, chunk_array, chunk_spec)
 
     async def _write_chunk_to_store(
-        self, store_path: StorePath, chunk_array: np.ndarray, chunk_metadata: ArraySpec
+        self, store_path: StorePath, chunk_array: np.ndarray, chunk_spec: ArraySpec
     ):
         if np.all(chunk_array == self.metadata.fill_value):
             # chunks that only contain fill_value will be removed
             await store_path.delete_async()
         else:
             chunk_bytes = await self.codec_pipeline.encode(
-                chunk_array, chunk_metadata, self.runtime_configuration
+                chunk_array, chunk_spec, self.runtime_configuration
             )
             if chunk_bytes is None:
                 await store_path.delete_async()

zarr/v3/codecs/__init__.py

@@ -115,7 +115,7 @@ def supports_partial_encode(self) -> bool:
             self.array_bytes_codec, ArrayBytesCodecPartialEncodeMixin
         )
 
-    def all_codecs(self) -> Iterator[Codec]:
+    def __iter__(self) -> Iterator[Codec]:
         for aa_codec in self.array_array_codecs:
             yield aa_codec
 
@@ -125,7 +125,7 @@ def all_codecs(self) -> Iterator[Codec]:
             yield bb_codec
 
     def validate(self, array_metadata: ArrayMetadata) -> None:
-        for codec in self.all_codecs():
+        for codec in self:
             codec.validate(array_metadata)
 
     def _codecs_with_resolved_metadata(
@@ -177,13 +177,13 @@ async def decode_partial(
         self,
         store_path: StorePath,
         selection: SliceSelection,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> Optional[np.ndarray]:
         assert self.supports_partial_decode
         assert isinstance(self.array_bytes_codec, ArrayBytesCodecPartialDecodeMixin)
         return await self.array_bytes_codec.decode_partial(
-            store_path, selection, chunk_metadata, runtime_configuration
+            store_path, selection, chunk_spec, runtime_configuration
         )
 
     async def encode(
@@ -227,17 +227,17 @@ async def encode_partial(
         store_path: StorePath,
         chunk_array: np.ndarray,
         selection: SliceSelection,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         runtime_configuration: RuntimeConfiguration,
     ) -> None:
         assert self.supports_partial_encode
         assert isinstance(self.array_bytes_codec, ArrayBytesCodecPartialEncodeMixin)
         await self.array_bytes_codec.encode_partial(
-            store_path, chunk_array, selection, chunk_metadata, runtime_configuration
+            store_path, chunk_array, selection, chunk_spec, runtime_configuration
         )
 
     def compute_encoded_size(self, byte_length: int, array_spec: ArraySpec) -> int:
-        for codec in self.all_codecs():
+        for codec in self:
             byte_length = codec.compute_encoded_size(byte_length, array_spec)
             array_spec = codec.resolve_metadata(array_spec)
         return byte_length

zarr/v3/codecs/blosc.py

@@ -86,21 +86,21 @@ def get_blosc_codec(self) -> Blosc:
     async def decode(
         self,
         chunk_bytes: bytes,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> BytesLike:
         return await to_thread(self.get_blosc_codec().decode, chunk_bytes)
 
     async def encode(
         self,
         chunk_bytes: bytes,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
-        chunk_array = np.frombuffer(chunk_bytes, dtype=chunk_metadata.dtype)
+        chunk_array = np.frombuffer(chunk_bytes, dtype=chunk_spec.dtype)
         return await to_thread(self.get_blosc_codec().encode, chunk_array)
 
-    def compute_encoded_size(self, _input_byte_length: int, _chunk_metadata: ArraySpec) -> int:
+    def compute_encoded_size(self, _input_byte_length: int, _chunk_spec: ArraySpec) -> int:
         raise NotImplementedError
 
 

zarr/v3/codecs/bytes.py

@@ -64,30 +64,30 @@ def _get_byteorder(self, array: np.ndarray) -> Endian:
     async def decode(
         self,
         chunk_bytes: BytesLike,
-        chunk_metadata: ArraySpec,
+        chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> np.ndarray:
-        if chunk_metadata.dtype.itemsize > 0:
+        if chunk_spec.dtype.itemsize > 0:
             if self.configuration.endian == "little":
                 prefix = "<"
             else:
                 prefix = ">"
-            dtype = np.dtype(f"{prefix}{chunk_metadata.data_type.to_numpy_shortname()}")
+            dtype = np.dtype(f"{prefix}{chunk_spec.data_type.to_numpy_shortname()}")
         else:
-            dtype = np.dtype(f"|{chunk_metadata.data_type.to_numpy_shortname()}")
+            dtype = np.dtype(f"|{chunk_spec.data_type.to_numpy_shortname()}")
         chunk_array = np.frombuffer(chunk_bytes, dtype)
 
         # ensure correct chunk shape
-        if chunk_array.shape != chunk_metadata.chunk_shape:
+        if chunk_array.shape != chunk_spec.shape:
             chunk_array = chunk_array.reshape(
-                chunk_metadata.chunk_shape,
+                chunk_spec.shape,
             )
         return chunk_array
 
     async def encode(
         self,
         chunk_array: np.ndarray,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
         if chunk_array.dtype.itemsize > 1:
@@ -97,7 +97,7 @@ async def encode(
                 chunk_array = chunk_array.astype(new_dtype)
         return chunk_array.tobytes()
 
-    def compute_encoded_size(self, input_byte_length: int, _chunk_metadata: ArraySpec) -> int:
+    def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:
         return input_byte_length
 
 

zarr/v3/codecs/crc32c_.py

@@ -40,7 +40,7 @@ def get_metadata_class(cls) -> Type[Crc32cCodecMetadata]:
     async def decode(
         self,
         chunk_bytes: bytes,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> BytesLike:
         crc32_bytes = chunk_bytes[-4:]
@@ -52,12 +52,12 @@ async def decode(
     async def encode(
         self,
         chunk_bytes: bytes,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
         return chunk_bytes + np.uint32(crc32c(chunk_bytes)).tobytes()
 
-    def compute_encoded_size(self, input_byte_length: int, _chunk_metadata: ArraySpec) -> int:
+    def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:
         return input_byte_length + 4
 
 

zarr/v3/codecs/gzip.py

@@ -47,23 +47,23 @@ def get_metadata_class(cls) -> Type[GzipCodecMetadata]:
     async def decode(
         self,
         chunk_bytes: bytes,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> BytesLike:
         return await to_thread(GZip(self.configuration.level).decode, chunk_bytes)
 
     async def encode(
         self,
         chunk_bytes: bytes,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
         _runtime_configuration: RuntimeConfiguration,
     ) -> Optional[BytesLike]:
         return await to_thread(GZip(self.configuration.level).encode, chunk_bytes)
 
     def compute_encoded_size(
         self,
         _input_byte_length: int,
-        _chunk_metadata: ArraySpec,
+        _chunk_spec: ArraySpec,
     ) -> int:
         raise NotImplementedError