chore: lint

Author: d-v-b

src/zarr/codecs/sharding.py

@@ -536,7 +536,6 @@ def _encode_sync(
             morton_order_iter(chunks_per_shard)
         )
 
-        chunk_spec = self._get_chunk_spec(shard_spec)
         skip_empty = not shard_spec.config.write_empty_chunks
         fill_value = shard_spec.fill_value
         if fill_value is None:

src/zarr/core/codec_pipeline.py

@@ -8,8 +8,6 @@
 from typing import TYPE_CHECKING, Any
 from warnings import warn
 
-import numpy as np
-
 from zarr.abc.codec import (
     ArrayArrayCodec,
     ArrayBytesCodec,
@@ -21,8 +19,6 @@
     GetResult,
     SupportsSyncCodec,
 )
-from zarr.core.array_spec import ArraySpec
-from zarr.core.buffer import numpy_buffer_prototype
 from zarr.core.common import concurrent_map
 from zarr.core.config import config
 from zarr.core.indexing import SelectorTuple, is_scalar
@@ -33,7 +29,8 @@
     from collections.abc import Iterable, Iterator
     from typing import Self
 
-    from zarr.abc.store import ByteGetter, ByteSetter, RangeByteRequest
+    from zarr.abc.store import ByteGetter, ByteSetter
+    from zarr.core.array_spec import ArraySpec
     from zarr.core.buffer import Buffer, BufferPrototype, NDBuffer
     from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar, ZDType
     from zarr.core.metadata.v3 import ChunkGridMetadata
@@ -799,9 +796,7 @@ def from_codecs(cls, codecs: Iterable[Codec], *, batch_size: int | None = None)
         )
 
     def evolve_from_array_spec(self, array_spec: ArraySpec) -> Self:
-        evolved_codecs = tuple(
-            c.evolve_from_array_spec(array_spec=array_spec) for c in self.codecs
-        )
+        evolved_codecs = tuple(c.evolve_from_array_spec(array_spec=array_spec) for c in self.codecs)
         aa, ab, bb = codecs_from_list(evolved_codecs)
 
         try:
@@ -924,8 +919,7 @@ def _merge_chunk_array(
             chunk_value = value[out_selection]
             if drop_axes:
                 item = tuple(
-                    None if idx in drop_axes else slice(None)
-                    for idx in range(chunk_spec.ndim)
+                    None if idx in drop_axes else slice(None) for idx in range(chunk_spec.ndim)
                 )
                 chunk_value = chunk_value[item]
         chunk_array[chunk_selection] = chunk_value
@@ -967,9 +961,7 @@ def _decode_one(raw: Buffer | None, chunk_spec: ArraySpec) -> NDBuffer | None:
             if raw is None:
                 return None
             chunk_shape = (
-                chunk_spec.shape
-                if chunk_spec.shape != transform.array_spec.shape
-                else None
+                chunk_spec.shape if chunk_spec.shape != transform.array_spec.shape else None
             )
             return transform.decode_chunk(raw, chunk_shape=chunk_shape)
 
@@ -978,7 +970,9 @@ def _decode_one(raw: Buffer | None, chunk_spec: ArraySpec) -> NDBuffer | None:
             with ThreadPoolExecutor(max_workers=n_workers) as pool:
                 decoded_list = list(pool.map(_decode_one, raw_buffers, specs))
         else:
-            decoded_list = [_decode_one(raw, spec) for raw, spec in zip(raw_buffers, specs, strict=True)]
+            decoded_list = [
+                _decode_one(raw, spec) for raw, spec in zip(raw_buffers, specs, strict=True)
+            ]
 
         # Phase 3: scatter (sequential, writes to shared output buffer)
         results: list[GetResult] = []
@@ -1030,9 +1024,7 @@ def _process_one(
             _, chunk_spec, chunk_selection, out_selection, is_complete = batch[idx]
             existing_bytes = existing_buffers[idx]
             chunk_shape = (
-                chunk_spec.shape
-                if chunk_spec.shape != transform.array_spec.shape
-                else None
+                chunk_spec.shape if chunk_spec.shape != transform.array_spec.shape else None
             )
 
             existing_chunk_array: NDBuffer | None = None
@@ -1099,19 +1091,14 @@ async def read(
 
         # Async fallback: fetch all chunks, decode via async codec API, scatter
         chunk_bytes_batch = await concurrent_map(
-            [
-                (byte_getter, array_spec.prototype)
-                for byte_getter, array_spec, *_ in batch
-            ],
+            [(byte_getter, array_spec.prototype) for byte_getter, array_spec, *_ in batch],
             lambda byte_getter, prototype: byte_getter.get(prototype),
             config.get("async.concurrency"),
         )
         chunk_array_batch = await self.decode(
             [
                 (chunk_bytes, chunk_spec)
-                for chunk_bytes, (_, chunk_spec, *_) in zip(
-                    chunk_bytes_batch, batch, strict=False
-                )
+                for chunk_bytes, (_, chunk_spec, *_) in zip(chunk_bytes_batch, batch, strict=False)
             ],
         )
         results: list[GetResult] = []
@@ -1175,9 +1162,7 @@ async def _read_key(
         chunk_array_decoded = await self.decode(
             [
                 (chunk_bytes, chunk_spec)
-                for chunk_bytes, (_, chunk_spec, *_) in zip(
-                    chunk_bytes_batch, batch, strict=False
-                )
+                for chunk_bytes, (_, chunk_spec, *_) in zip(chunk_bytes_batch, batch, strict=False)
             ],
         )
 
@@ -1200,9 +1185,7 @@ async def _read_key(
             ) in zip(chunk_array_decoded, batch, strict=False)
         ]
         chunk_array_batch: list[NDBuffer | None] = []
-        for chunk_array, (_, chunk_spec, *_) in zip(
-            chunk_array_merged, batch, strict=False
-        ):
+        for chunk_array, (_, chunk_spec, *_) in zip(chunk_array_merged, batch, strict=False):
             if chunk_array is None:
                 chunk_array_batch.append(None)  # type: ignore[unreachable]
             else:
@@ -1216,9 +1199,7 @@ async def _read_key(
         chunk_bytes_batch = await self.encode(
             [
                 (chunk_array, chunk_spec)
-                for chunk_array, (_, chunk_spec, *_) in zip(
-                    chunk_array_batch, batch, strict=False
-                )
+                for chunk_array, (_, chunk_spec, *_) in zip(chunk_array_batch, batch, strict=False)
             ],
         )
 
@@ -1231,9 +1212,7 @@ async def _write_key(byte_setter: ByteSetter, chunk_bytes: Buffer | None) -> Non
         await concurrent_map(
             [
                 (byte_setter, chunk_bytes)
-                for chunk_bytes, (byte_setter, *_) in zip(
-                    chunk_bytes_batch, batch, strict=False
-                )
+                for chunk_bytes, (byte_setter, *_) in zip(chunk_bytes_batch, batch, strict=False)
             ],
             _write_key,
             config.get("async.concurrency"),