Aplly ruff/flake8-implicit-str-concat rule ISC003

ISC003 Explicitly concatenated string should be implicitly concatenated

Author: DimitriPapadopoulos

src/zarr/codecs/crc32c_.py

@@ -42,8 +42,7 @@ async def decode_single(
         stored_checksum = bytes(crc32_bytes)
         if computed_checksum != stored_checksum:
             raise ValueError(
-                "Stored and computed checksum do not match. "
-                + f"Stored: {stored_checksum!r}. Computed: {computed_checksum!r}."
+                f"Stored and computed checksum do not match. Stored: {stored_checksum!r}. Computed: {computed_checksum!r}."
             )
         return Buffer.from_array_like(inner_bytes)
 

src/zarr/codecs/pipeline.py

@@ -104,31 +104,26 @@ def codecs_from_list(
             if prev_codec is not None:
                 if isinstance(codec, ArrayBytesCodec) and isinstance(prev_codec, ArrayBytesCodec):
                     raise ValueError(
-                        f"ArrayBytesCodec '{type(codec)}' cannot follow after "
-                        + f"ArrayBytesCodec '{type(prev_codec)}' because exactly "
-                        + "1 ArrayBytesCodec is allowed."
+                        f"ArrayBytesCodec '{type(codec)}' cannot follow after ArrayBytesCodec '{type(prev_codec)}' because exactly 1 ArrayBytesCodec is allowed."
                     )
                 if isinstance(codec, ArrayBytesCodec) and isinstance(prev_codec, BytesBytesCodec):
                     raise ValueError(
-                        f"ArrayBytesCodec '{type(codec)}' cannot follow after "
-                        + f"BytesBytesCodec '{type(prev_codec)}'."
+                        f"ArrayBytesCodec '{type(codec)}' cannot follow after BytesBytesCodec '{type(prev_codec)}'."
                     )
                 if isinstance(codec, ArrayArrayCodec) and isinstance(prev_codec, ArrayBytesCodec):
                     raise ValueError(
-                        f"ArrayArrayCodec '{type(codec)}' cannot follow after "
-                        + f"ArrayBytesCodec '{type(prev_codec)}'."
+                        f"ArrayArrayCodec '{type(codec)}' cannot follow after ArrayBytesCodec '{type(prev_codec)}'."
                     )
                 if isinstance(codec, ArrayArrayCodec) and isinstance(prev_codec, BytesBytesCodec):
                     raise ValueError(
-                        f"ArrayArrayCodec '{type(codec)}' cannot follow after "
-                        + f"BytesBytesCodec '{type(prev_codec)}'."
+                        f"ArrayArrayCodec '{type(codec)}' cannot follow after BytesBytesCodec '{type(prev_codec)}'."
                     )
             prev_codec = codec
 
         if any(isinstance(codec, ShardingCodec) for codec in codecs) and len(codecs) > 1:
             warn(
                 "Combining a `sharding_indexed` codec disables partial reads and "
-                + "writes, which may lead to inefficient performance.",
+                "writes, which may lead to inefficient performance.",
                 stacklevel=3,
             )
 

src/zarr/codecs/sharding.py

@@ -360,8 +360,7 @@ def evolve(self, array_spec: ArraySpec) -> Self:
     def validate(self, array_metadata: ArrayMetadata) -> None:
         if len(self.chunk_shape) != array_metadata.ndim:
             raise ValueError(
-                "The shard's `chunk_shape` and array's `shape` need to have the "
-                + "same number of dimensions."
+                "The shard's `chunk_shape` and array's `shape` need to have the same number of dimensions."
             )
         if not isinstance(array_metadata.chunk_grid, RegularChunkGrid):
             raise ValueError("Sharding is only compatible with regular chunk grids.")
@@ -374,8 +373,7 @@ def validate(self, array_metadata: ArrayMetadata) -> None:
             )
         ):
             raise ValueError(
-                "The array's `chunk_shape` needs to be divisible by the "
-                + "shard's inner `chunk_shape`."
+                "The array's `chunk_shape` needs to be divisible by the shard's inner `chunk_shape`."
             )
 
     async def decode_single(

src/zarr/codecs/transpose.py

@@ -45,17 +45,15 @@ def to_dict(self) -> dict[str, JSON]:
     def evolve(self, array_spec: ArraySpec) -> Self:
         if len(self.order) != array_spec.ndim:
             raise ValueError(
-                "The `order` tuple needs have as many entries as "
-                + f"there are dimensions in the array. Got {self.order}."
+                f"The `order` tuple needs have as many entries as there are dimensions in the array. Got {self.order}."
             )
         if len(self.order) != len(set(self.order)):
             raise ValueError(
                 f"There must not be duplicates in the `order` tuple. Got {self.order}."
             )
         if not all(0 <= x < array_spec.ndim for x in self.order):
             raise ValueError(
-                "All entries in the `order` tuple must be between 0 and "
-                + f"the number of dimensions in the array. Got {self.order}."
+                f"All entries in the `order` tuple must be between 0 and the number of dimensions in the array. Got {self.order}."
             )
         order = tuple(self.order)
 

src/zarr/store/remote.py

@@ -25,10 +25,9 @@ def __init__(self, url: UPath | str, **storage_options: dict[str, Any]):
         if isinstance(url, str):
             self.root = UPath(url, **storage_options)
         else:
-            assert len(storage_options) == 0, (
-                "If constructed with a UPath object, no additional "
-                + "storage_options are allowed."
-            )
+            assert (
+                len(storage_options) == 0
+            ), "If constructed with a UPath object, no additional storage_options are allowed."
             self.root = url.rstrip("/")
         # test instantiate file system
         fs, _ = fsspec.core.url_to_fs(str(self.root), asynchronous=True, **self.root._kwargs)