Apply ruff/flake8-return rule RET504

RET504 Unnecessary assignment before `return` statement

Author: DimitriPapadopoulos

src/zarr/codecs/transpose.py

@@ -96,16 +96,14 @@ async def _decode_single(
         chunk_spec: ArraySpec,
     ) -> NDBuffer:
         inverse_order = np.argsort(self.order)
-        chunk_array = chunk_array.transpose(inverse_order)
-        return chunk_array
+        return chunk_array.transpose(inverse_order)
 
     async def _encode_single(
         self,
         chunk_array: NDBuffer,
         _chunk_spec: ArraySpec,
     ) -> NDBuffer | None:
-        chunk_array = chunk_array.transpose(self.order)
-        return chunk_array
+        return chunk_array.transpose(self.order)
 
     def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:
         return input_byte_length

src/zarr/core/array.py

@@ -331,8 +331,7 @@ def from_dict(
         data: dict[str, JSON],
     ) -> AsyncArray:
         metadata = parse_array_metadata(data)
-        async_array = cls(metadata=metadata, store_path=store_path)
-        return async_array
+        return cls(metadata=metadata, store_path=store_path)
 
     @classmethod
     async def open(

src/zarr/core/group.py

@@ -204,11 +204,10 @@ def from_dict(
         store_path: StorePath,
         data: dict[str, Any],
     ) -> AsyncGroup:
-        group = cls(
+        return cls(
             metadata=GroupMetadata.from_dict(data),
             store_path=store_path,
         )
-        return group
 
     async def getitem(
         self,
@@ -890,8 +889,7 @@ def members(self, max_depth: int | None = 0) -> tuple[tuple[str, Array | Group],
         """
         _members = self._sync_iter(self._async_group.members(max_depth=max_depth))
 
-        result = tuple((kv[0], _parse_async_node(kv[1])) for kv in _members)
-        return result
+        return tuple((kv[0], _parse_async_node(kv[1])) for kv in _members)
 
     def __contains__(self, member: str) -> bool:
         return self._sync(self._async_group.contains(member))

src/zarr/store/common.py

@@ -23,8 +23,7 @@ def _dereference_path(root: str, path: str) -> str:
     assert isinstance(path, str)
     root = root.rstrip("/")
     path = f"{root}/{path}" if root else path
-    path = path.rstrip("/")
-    return path
+    return path.rstrip("/")
 
 
 class StorePath:
@@ -66,7 +65,7 @@ def __repr__(self) -> str:
 
     def __eq__(self, other: object) -> bool:
         try:
-            return bool(self.store == other.store and self.path == other.path)  # type: ignore[attr-defined]
+            return self.store == other.store and self.path == other.path  # type: ignore[attr-defined]
         except Exception:
             pass
         return False
@@ -265,8 +264,7 @@ async def contains_array(store_path: StorePath, zarr_format: ZarrFormat) -> bool
             except (ValueError, KeyError):
                 return False
     elif zarr_format == 2:
-        result = await (store_path / ZARRAY_JSON).exists()
-        return result
+        return await (store_path / ZARRAY_JSON).exists()
     msg = f"Invalid zarr_format provided. Got {zarr_format}, expected 2 or 3"
     raise ValueError(msg)
 

src/zarr/store/memory.py

@@ -80,8 +80,7 @@ async def get_partial_values(
         async def _get(key: str, byte_range: tuple[int, int | None]) -> Buffer | None:
             return await self.get(key, prototype=prototype, byte_range=byte_range)
 
-        vals = await concurrent_map(key_ranges, _get, limit=None)
-        return vals
+        return await concurrent_map(key_ranges, _get, limit=None)
 
     async def exists(self, key: str) -> bool:
         return key in self._store_dict

src/zarr/testing/strategies.py

@@ -166,5 +166,4 @@ def key_ranges(keys: SearchStrategy = node_names) -> SearchStrategy[list]:
         st.none() | st.integers(min_value=0), st.none() | st.integers(min_value=0)
     )
     key_tuple = st.tuples(keys, byte_ranges)
-    key_range_st = st.lists(key_tuple, min_size=1, max_size=10)
-    return key_range_st
+    return st.lists(key_tuple, min_size=1, max_size=10)