Apply Sourcery suggestions and fix typos

Author: DimitriPapadopoulos

src/zarr/abc/metadata.py

@@ -28,8 +28,6 @@ def to_dict(self) -> dict[str, JSON]:
             value = getattr(self, key)
             if isinstance(value, Metadata):
                 out_dict[field.name] = getattr(self, field.name).to_dict()
-            elif isinstance(value, str):
-                out_dict[key] = value
             elif isinstance(value, Sequence):
                 out_dict[key] = tuple(v.to_dict() if isinstance(v, Metadata) else v for v in value)
             else:

src/zarr/codecs/sharding.py

@@ -113,7 +113,7 @@ class _ShardIndex(NamedTuple):
 
     @property
     def chunks_per_shard(self) -> ChunkCoords:
-        result = tuple(self.offsets_and_lengths.shape[0:-1])
+        result = tuple(self.offsets_and_lengths.shape[:-1])
         # The cast is required until https://github.com/numpy/numpy/pull/27211 is merged
         return cast("ChunkCoords", result)
 
@@ -409,8 +409,8 @@ def validate(self, *, shape: ChunkCoords, dtype: np.dtype[Any], chunk_grid: Chun
             )
         if not isinstance(chunk_grid, RegularChunkGrid):
             raise TypeError("Sharding is only compatible with regular chunk grids.")
-        if not all(
-            s % c == 0
+        if any(
+            s % c != 0
             for s, c in zip(
                 chunk_grid.chunk_shape,
                 self.chunk_shape,

src/zarr/core/array.py

@@ -650,7 +650,7 @@ async def _create(
                 overwrite=overwrite,
             )
         else:
-            raise ValueError(f"Insupported zarr_format. Got: {zarr_format}")
+            raise ValueError(f"Unsupported zarr_format. Got: {zarr_format}")
 
         if data is not None:
             # insert user-provided data

src/zarr/core/buffer/core.py

@@ -115,7 +115,7 @@ def check_item_key_is_1d_contiguous(key: Any) -> None:
         raise TypeError(
             f"Item key has incorrect type (expected slice, got {key.__class__.__name__})"
         )
-    if not (key.step is None or key.step == 1):
+    if key.step is not None and key.step != 1:
         raise ValueError("slice must be contiguous")
 
 

src/zarr/core/common.py

@@ -145,7 +145,7 @@ def parse_shapelike(data: int | Iterable[int]) -> tuple[int, ...]:
     if not all(isinstance(v, int) for v in data_tuple):
         msg = f"Expected an iterable of integers. Got {data} instead."
         raise TypeError(msg)
-    if not all(v > -1 for v in data_tuple):
+    if any(v < 0 for v in data_tuple):
         msg = f"Expected all values to be non-negative. Got {data} instead."
         raise ValueError(msg)
     return data_tuple

src/zarr/core/indexing.py

@@ -436,7 +436,7 @@ def replace_ellipsis(selection: Any, shape: ChunkCoords) -> SelectionNormalized:
     selection = ensure_tuple(selection)
 
     # count number of ellipsis present
-    n_ellipsis = sum(1 for i in selection if i is Ellipsis)
+    n_ellipsis = selection.count(Ellipsis)
 
     if n_ellipsis > 1:
         # more than 1 is an error

src/zarr/core/metadata/v2.py

@@ -249,11 +249,11 @@ def parse_filters(data: object) -> tuple[numcodecs.abc.Codec, ...] | None:
     """
     Parse a potential tuple of filters
     """
-    out: list[numcodecs.abc.Codec] = []
 
     if data is None:
         return data
     if isinstance(data, Iterable):
+        out: list[numcodecs.abc.Codec] = []
         for idx, val in enumerate(data):
             if isinstance(val, numcodecs.abc.Codec):
                 out.append(val)

src/zarr/core/metadata/v3.py

@@ -107,11 +107,11 @@ def validate_codecs(codecs: tuple[Codec, ...], dtype: DataType) -> None:
     # we need to have special codecs if we are decoding vlen strings or bytestrings
     # TODO: use codec ID instead of class name
     codec_class_name = abc.__class__.__name__
-    if dtype == DataType.string and not codec_class_name == "VLenUTF8Codec":
+    if dtype == DataType.string and codec_class_name != "VLenUTF8Codec":
         raise ValueError(
             f"For string dtype, ArrayBytesCodec must be `VLenUTF8Codec`, got `{codec_class_name}`."
         )
-    if dtype == DataType.bytes and not codec_class_name == "VLenBytesCodec":
+    if dtype == DataType.bytes and codec_class_name != "VLenBytesCodec":
         raise ValueError(
             f"For bytes dtype, ArrayBytesCodec must be `VLenBytesCodec`, got `{codec_class_name}`."
         )
@@ -574,9 +574,8 @@ def parse_fill_value(
             and np.isclose(np.imag(fill_value), np.imag(casted_value), equal_nan=True)
         ):
             raise ValueError(f"fill value {fill_value!r} is not valid for dtype {data_type}")
-    else:
-        if fill_value != casted_value:
-            raise ValueError(f"fill value {fill_value!r} is not valid for dtype {data_type}")
+    elif fill_value != casted_value:
+        raise ValueError(f"fill value {fill_value!r} is not valid for dtype {data_type}")
 
     return casted_value
 

src/zarr/registry.py

@@ -179,9 +179,9 @@ def _parse_bytes_bytes_codec(data: dict[str, JSON] | Codec) -> BytesBytesCodec:
         if not isinstance(result, BytesBytesCodec):
             msg = f"Expected a dict representation of a BytesBytesCodec; got a dict representation of a {type(result)} instead."
             raise TypeError(msg)
+    elif not isinstance(data, BytesBytesCodec):
+        raise TypeError(f"Expected a BytesBytesCodec. Got {type(data)} instead.")
     else:
-        if not isinstance(data, BytesBytesCodec):
-            raise TypeError(f"Expected a BytesBytesCodec. Got {type(data)} instead.")
         result = data
     return result
 
@@ -199,9 +199,9 @@ def _parse_array_bytes_codec(data: dict[str, JSON] | Codec) -> ArrayBytesCodec:
         if not isinstance(result, ArrayBytesCodec):
             msg = f"Expected a dict representation of a ArrayBytesCodec; got a dict representation of a {type(result)} instead."
             raise TypeError(msg)
+    elif not isinstance(data, ArrayBytesCodec):
+        raise TypeError(f"Expected a ArrayBytesCodec. Got {type(data)} instead.")
     else:
-        if not isinstance(data, ArrayBytesCodec):
-            raise TypeError(f"Expected a ArrayBytesCodec. Got {type(data)} instead.")
         result = data
     return result
 
@@ -219,9 +219,9 @@ def _parse_array_array_codec(data: dict[str, JSON] | Codec) -> ArrayArrayCodec:
         if not isinstance(result, ArrayArrayCodec):
             msg = f"Expected a dict representation of a ArrayArrayCodec; got a dict representation of a {type(result)} instead."
             raise TypeError(msg)
+    elif not isinstance(data, ArrayArrayCodec):
+        raise TypeError(f"Expected a ArrayArrayCodec. Got {type(data)} instead.")
     else:
-        if not isinstance(data, ArrayArrayCodec):
-            raise TypeError(f"Expected a ArrayArrayCodec. Got {type(data)} instead.")
         result = data
     return result
 

src/zarr/storage/_fsspec.py

@@ -355,7 +355,7 @@ async def set_partial_values(
     async def list(self) -> AsyncIterator[str]:
         # docstring inherited
         allfiles = await self.fs._find(self.path, detail=False, withdirs=False)
-        for onefile in (a.removeprefix(self.path + "/") for a in allfiles):
+        for onefile in (a.removeprefix(f"{self.path}/") for a in allfiles):
             yield onefile
 
     async def list_dir(self, prefix: str) -> AsyncIterator[str]:
@@ -365,7 +365,7 @@ async def list_dir(self, prefix: str) -> AsyncIterator[str]:
             allfiles = await self.fs._ls(prefix, detail=False)
         except FileNotFoundError:
             return
-        for onefile in (a.replace(prefix + "/", "") for a in allfiles):
+        for onefile in (a.replace(f"{prefix}/", "") for a in allfiles):
             yield onefile.removeprefix(self.path).removeprefix("/")
 
     async def list_prefix(self, prefix: str) -> AsyncIterator[str]:

src/zarr/testing/stateful.py

@@ -127,7 +127,7 @@ def add_array(
     #     array_path = data.draw(st.sampled_from(self.all_arrays), label="Array move source")
     #     to_group = data.draw(st.sampled_from(self.all_groups), label="Array move destination")
 
-    #     # fixme renaiming to self?
+    #     # fixme renaming to self?
     #     array_name = os.path.basename(array_path)
     #     assume(self.model.can_add(to_group, array_name))
     #     new_path = f"{to_group}/{array_name}".lstrip("/")
@@ -144,7 +144,7 @@ def add_array(
 
     #     from_group_name = os.path.basename(from_group)
     #     assume(self.model.can_add(to_group, from_group_name))
-    #     # fixme renaiming to self?
+    #     # fixme renaming to self?
     #     new_path = f"{to_group}/{from_group_name}".lstrip("/")
     #     note(f"moving group '{from_group}' -> '{new_path}'")
     #     self.model.rename(from_group, new_path)

src/zarr/testing/store.py

@@ -372,8 +372,8 @@ async def test_list(self, store: S) -> None:
         prefix = "foo"
         data = self.buffer_cls.from_bytes(b"")
         store_dict = {
-            prefix + "/zarr.json": data,
-            **{prefix + f"/c/{idx}": data for idx in range(10)},
+            f"{prefix}/zarr.json": data,
+            **{f"{prefix}/c/{idx}": data for idx in range(10)},
         }
         await store._set_many(store_dict.items())
         expected_sorted = sorted(store_dict.keys())
@@ -436,8 +436,8 @@ async def test_list_empty_path(self, store: S) -> None:
     async def test_list_dir(self, store: S) -> None:
         root = "foo"
         store_dict = {
-            root + "/zarr.json": self.buffer_cls.from_bytes(b"bar"),
-            root + "/c/1": self.buffer_cls.from_bytes(b"\x01"),
+            f"{root}/zarr.json": self.buffer_cls.from_bytes(b"bar"),
+            f"{root}/c/1": self.buffer_cls.from_bytes(b"\x01"),
         }
 
         assert await _collect_aiterator(store.list_dir("")) == ()
@@ -446,7 +446,7 @@ async def test_list_dir(self, store: S) -> None:
         await store._set_many(store_dict.items())
 
         keys_observed = await _collect_aiterator(store.list_dir(root))
-        keys_expected = {k.removeprefix(root + "/").split("/")[0] for k in store_dict}
+        keys_expected = {k.removeprefix(f"{root}/").split("/")[0] for k in store_dict}
 
         assert sorted(keys_observed) == sorted(keys_expected)
 

src/zarr/testing/strategies.py

@@ -289,7 +289,7 @@ def arrays(
         assert a.fill_value is not None
     assert a.name is not None
     assert a.path == normalize_path(array_path)
-    assert a.name == "/" + a.path
+    assert a.name == f"/{a.path}"
     assert isinstance(root[array_path], Array)
     assert nparray.shape == a.shape
     assert chunk_shape == a.chunks

tests/conftest.py

@@ -47,7 +47,7 @@ async def parse_store(
     if store == "fsspec":
         return await FsspecStore.open(url=path)
     if store == "zip":
-        return await ZipStore.open(path + "/zarr.zip", mode="w")
+        return await ZipStore.open(f"{path}/zarr.zip", mode="w")
     raise AssertionError
 
 
@@ -101,7 +101,7 @@ async def store2(request: pytest.FixtureRequest, tmpdir: LEGACY_PATH) -> Store:
 def sync_store(request: pytest.FixtureRequest, tmp_path: LEGACY_PATH) -> Store:
     result = sync(parse_store(request.param, str(tmp_path)))
     if not isinstance(result, Store):
-        raise TypeError("Wrong store class returned by test fixture! got " + result + " instead")
+        raise TypeError(f"Wrong store class returned by test fixture! got {result} instead")
     return result
 
 

tests/test_api.py

@@ -1174,7 +1174,7 @@ async def test_open_falls_back_to_open_group_async(zarr_format: ZarrFormat) -> N
 def test_open_modes_creates_group(tmp_path: pathlib.Path, mode: str) -> None:
     # https://github.com/zarr-developers/zarr-python/issues/2490
     zarr_dir = tmp_path / f"mode-{mode}-test.zarr"
-    if mode in ["r", "r+"]:
+    if mode in {"r", "r+"}:
         # Expect FileNotFoundError to be raised if 'r' or 'r+' mode
         with pytest.raises(FileNotFoundError):
             zarr.open(store=zarr_dir, mode=mode)

tests/test_array.py

@@ -1470,7 +1470,7 @@ async def test_name(store: Store, zarr_format: ZarrFormat, path: str | None) ->
         else:
             expected_path = path
         assert arr.path == expected_path
-        assert arr.name == "/" + expected_path
+        assert arr.name == f"/{expected_path}"
 
         # test that implicit groups were created
         path_parts = expected_path.split("/")

tests/test_codec_entrypoints.py

@@ -25,7 +25,7 @@ def set_path() -> Generator[None, None, None]:
 @pytest.mark.usefixtures("set_path")
 @pytest.mark.parametrize("codec_name", ["TestEntrypointCodec", "TestEntrypointGroup.Codec"])
 def test_entrypoint_codec(codec_name: str) -> None:
-    config.set({"codecs.test": "package_with_entrypoint." + codec_name})
+    config.set({"codecs.test": f"package_with_entrypoint.{codec_name}"})
     cls_test = zarr.registry.get_codec_class("test")
     assert cls_test.__qualname__ == codec_name
 
@@ -42,7 +42,7 @@ def test_entrypoint_pipeline() -> None:
 def test_entrypoint_buffer(buffer_name: str) -> None:
     config.set(
         {
-            "buffer": "package_with_entrypoint." + buffer_name,
+            "buffer": f"package_with_entrypoint.{buffer_name}",
             "ndbuffer": "package_with_entrypoint.TestEntrypointNDBuffer",
         }
     )

tests/test_indexing.py

@@ -1598,7 +1598,7 @@ def test_get_selections_with_fields(store: StorePath) -> None:
             assert_array_equal(expect, actual)
 
         # basic selection with slice
-        expect = a[fields][0:2]
+        expect = a[fields][:2]
         actual = z.get_basic_selection(slice(0, 2), fields=fields)
         assert_array_equal(expect, actual)
         # alternative API
@@ -1724,8 +1724,8 @@ def test_set_selections_with_fields(store: StorePath) -> None:
             # basic selection with slice
             a[:] = ("", 0, 0)
             z[:] = ("", 0, 0)
-            a[key][0:2] = v[key][0:2]
-            z.set_basic_selection(slice(0, 2), v[key][0:2], fields=fields)
+            a[key][:2] = v[key][:2]
+            z.set_basic_selection(slice(0, 2), v[key][:2], fields=fields)
             assert_array_equal(a, z[:])
 
             # orthogonal selection