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

ISC003 Explicitly concatenated string should be implicitly concatenated

Author: DimitriPapadopoulos

src/zarr/array.py

@@ -350,8 +350,7 @@ async def _write_chunk_to_store(
     async def resize(self, new_shape: ChunkCoords) -> AsyncArray:
         if len(new_shape) != len(self.metadata.shape):
             raise ValueError(
-                "The new shape must have the same number of dimensions "
-                + f"(={len(self.metadata.shape)})."
+                f"The new shape must have the same number of dimensions (={len(self.metadata.shape)})."
             )
 
         new_metadata = replace(self.metadata, shape=new_shape)

src/zarr/codecs/crc32c_.py

@@ -41,8 +41,7 @@ async def decode(
         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 inner_bytes
 

src/zarr/codecs/pipeline.py

@@ -62,31 +62,26 @@ def from_list(cls, codecs: List[Codec]) -> CodecPipeline:
             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."
             )
 
         return CodecPipeline(

src/zarr/codecs/sharding.py

@@ -280,8 +280,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.")
@@ -293,8 +292,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(

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

@@ -26,10 +26,9 @@ def __init__(self, url: Union[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)