Make ruff fixes for Python 3.10

Author: dstansby

zarr/_storage/store.py

@@ -352,7 +352,7 @@ def set_partial_values(self, key_start_values):
         Also, start may only be beyond the current value if other values fill the gap.
         start may be negative to start writing start bytes from the current
         end of the file, ending the file with the new value."""
-        unique_keys = set(next(zip(*key_start_values)))
+        unique_keys = set(next(zip(*key_start_values, strict=False)))
         values = {}
         for key in unique_keys:
             old_value = self.get(key)

zarr/_storage/v3_storage_transformers.py

@@ -32,7 +32,8 @@ class _ShardIndex(NamedTuple):
 
     def __localize_chunk__(self, chunk: Tuple[int, ...]) -> Tuple[int, ...]:
         return tuple(
-            chunk_i % shard_i for chunk_i, shard_i in zip(chunk, self.store.chunks_per_shard)
+            chunk_i % shard_i
+            for chunk_i, shard_i in zip(chunk, self.store.chunks_per_shard, strict=False)
         )
 
     def is_all_empty(self) -> bool:
@@ -137,7 +138,8 @@ def _key_to_shard(self, chunk_key: str) -> Tuple[str, Tuple[int, ...]]:
             tuple(map(int, chunk_string.split(self.dimension_separator))) if chunk_string else (0,)
         )
         shard_key_tuple = (
-            subkey // shard_i for subkey, shard_i in zip(chunk_subkeys, self.chunks_per_shard)
+            subkey // shard_i
+            for subkey, shard_i in zip(chunk_subkeys, self.chunks_per_shard, strict=False)
         )
         shard_key = prefix + "c" + self.dimension_separator.join(map(str, shard_key_tuple))
         return shard_key, chunk_subkeys
@@ -167,7 +169,7 @@ def _get_chunks_in_shard(self, shard_key: str) -> Iterator[Tuple[int, ...]]:
             yield tuple(
                 shard_key_i * shards_i + offset_i
                 for shard_key_i, offset_i, shards_i in zip(
-                    shard_key_tuple, chunk_offset, self.chunks_per_shard
+                    shard_key_tuple, chunk_offset, self.chunks_per_shard, strict=False
                 )
             )
 
@@ -240,7 +242,9 @@ def __setitem__(self, key, value):
                             for _, chunk_slice in valid_chunk_slices
                         ]
                     )
-                    for chunk_value, (chunk_to_read, _) in zip(chunk_values, valid_chunk_slices):
+                    for chunk_value, (chunk_to_read, _) in zip(
+                        chunk_values, valid_chunk_slices, strict=False
+                    ):
                         new_content[chunk_to_read] = chunk_value
                 else:
                     if full_shard_value is None:

zarr/convenience.py

@@ -1013,9 +1013,12 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
                 # everything into memory
                 shape = ds.shape
                 chunks = ds.chunks
-                chunk_offsets = [range(0, s, c) for s, c in zip(shape, chunks)]
+                chunk_offsets = [range(0, s, c) for s, c in zip(shape, chunks, strict=False)]
                 for offset in itertools.product(*chunk_offsets):
-                    sel = tuple(slice(o, min(s, o + c)) for o, s, c in zip(offset, shape, chunks))
+                    sel = tuple(
+                        slice(o, min(s, o + c))
+                        for o, s, c in zip(offset, shape, chunks, strict=False)
+                    )
                     ds[sel] = source[sel]
                 n_bytes_copied += ds.size * ds.dtype.itemsize
 

zarr/core.py

@@ -477,7 +477,7 @@ def _cdata_shape(self):
         if self._shape == ():
             return (1,)
         else:
-            return tuple(math.ceil(s / c) for s, c in zip(self._shape, self._chunks))
+            return tuple(math.ceil(s / c) for s, c in zip(self._shape, self._chunks, strict=False))
 
     @property
     def cdata_shape(self):
@@ -1339,7 +1339,7 @@ def _get_selection(self, indexer, out=None, fields=None):
 
         if math.prod(out_shape) > 0:
             # allow storage to get multiple items at once
-            lchunk_coords, lchunk_selection, lout_selection = zip(*indexer)
+            lchunk_coords, lchunk_selection, lout_selection = zip(*indexer, strict=False)
             self._chunk_getitems(
                 lchunk_coords,
                 lchunk_selection,
@@ -1990,7 +1990,7 @@ def _set_selection(self, indexer, value, fields=None):
                 # put data
                 self._chunk_setitem(chunk_coords, chunk_selection, chunk_value, fields=fields)
         else:
-            lchunk_coords, lchunk_selection, lout_selection = zip(*indexer)
+            lchunk_coords, lchunk_selection, lout_selection = zip(*indexer, strict=False)
             chunk_values = []
             for out_selection in lout_selection:
                 if sel_shape == ():
@@ -2170,15 +2170,19 @@ def _chunk_getitems(
         elif hasattr(self.chunk_store, "get_partial_values"):
             partial_read_decode = False
             values = self.chunk_store.get_partial_values([(ckey, (0, None)) for ckey in ckeys])
-            cdatas = {key: value for key, value in zip(ckeys, values) if value is not None}
+            cdatas = {
+                key: value for key, value in zip(ckeys, values, strict=False) if value is not None
+            }
         else:
             partial_read_decode = False
             contexts = {}
             if not isinstance(self._meta_array, np.ndarray):
                 contexts = ConstantMap(ckeys, constant=Context(meta_array=self._meta_array))
             cdatas = self.chunk_store.getitems(ckeys, contexts=contexts)
 
-        for ckey, chunk_select, out_select in zip(ckeys, lchunk_selection, lout_selection):
+        for ckey, chunk_select, out_select in zip(
+            ckeys, lchunk_selection, lout_selection, strict=False
+        ):
             if ckey in cdatas:
                 self._process_chunk(
                     out,
@@ -2203,7 +2207,7 @@ def _chunk_setitems(self, lchunk_coords, lchunk_selection, values, fields=None):
         ckeys = map(self._chunk_key, lchunk_coords)
         cdatas = {
             key: self._process_for_setitem(key, sel, val, fields=fields)
-            for key, sel, val in zip(ckeys, lchunk_selection, values)
+            for key, sel, val in zip(ckeys, lchunk_selection, values, strict=False)
         }
         to_store = {}
         if not self.write_empty_chunks:
@@ -2636,7 +2640,7 @@ def _resize_nosync(self, *args):
 
         # determine the new number and arrangement of chunks
         chunks = self._chunks
-        new_cdata_shape = tuple(math.ceil(s / c) for s, c in zip(new_shape, chunks))
+        new_cdata_shape = tuple(math.ceil(s / c) for s, c in zip(new_shape, chunks, strict=False))
 
         # remove any chunks not within range
         #   The idea is that, along each dimension,
@@ -2647,13 +2651,13 @@ def _resize_nosync(self, *args):
         chunk_store = self.chunk_store
         old_cdata_shape_working_list = list(old_cdata_shape)
         for idx_cdata, (val_old_cdata, val_new_cdata) in enumerate(
-            zip(old_cdata_shape_working_list, new_cdata_shape)
+            zip(old_cdata_shape_working_list, new_cdata_shape, strict=False)
         ):
             for cidx in itertools.product(
                 *[
                     range(n_new, n_old) if (idx == idx_cdata) else range(n_old)
                     for idx, (n_old, n_new) in enumerate(
-                        zip(old_cdata_shape_working_list, new_cdata_shape)
+                        zip(old_cdata_shape_working_list, new_cdata_shape, strict=False)
                     )
                 ]
             ):

zarr/indexing.py

@@ -331,7 +331,9 @@ def __init__(self, selection, array):
 
         # setup per-dimension indexers
         dim_indexers = []
-        for dim_sel, dim_len, dim_chunk_len in zip(selection, array._shape, array._chunks):
+        for dim_sel, dim_len, dim_chunk_len in zip(
+            selection, array._shape, array._chunks, strict=False
+        ):
             if is_integer(dim_sel):
                 dim_indexer = IntDimIndexer(dim_sel, dim_len, dim_chunk_len)
 
@@ -552,7 +554,7 @@ def ix_(selection, shape):
             if isinstance(dim_sel, slice)
             else [dim_sel] if is_integer(dim_sel) else dim_sel
         )
-        for dim_sel, dim_len in zip(selection, shape)
+        for dim_sel, dim_len in zip(selection, shape, strict=False)
     ]
 
     # now get numpy to convert to a coordinate selection
@@ -597,7 +599,9 @@ def __init__(self, selection, array):
 
         # setup per-dimension indexers
         dim_indexers = []
-        for dim_sel, dim_len, dim_chunk_len in zip(selection, array._shape, array._chunks):
+        for dim_sel, dim_len, dim_chunk_len in zip(
+            selection, array._shape, array._chunks, strict=False
+        ):
             if is_integer(dim_sel):
                 dim_indexer = IntDimIndexer(dim_sel, dim_len, dim_chunk_len)
 
@@ -683,7 +687,9 @@ def __init__(self, selection, array):
 
         # setup per-dimension indexers
         dim_indexers = []
-        for dim_sel, dim_len, dim_chunk_size in zip(selection, array._shape, array._chunks):
+        for dim_sel, dim_len, dim_chunk_size in zip(
+            selection, array._shape, array._chunks, strict=False
+        ):
             dim_numchunks = int(np.ceil(dim_len / dim_chunk_size))
 
             if is_integer(dim_sel):
@@ -790,7 +796,7 @@ def __init__(self, selection, array):
             )
 
         # handle wraparound, boundscheck
-        for dim_sel, dim_len in zip(selection, array.shape):
+        for dim_sel, dim_len in zip(selection, array.shape, strict=False):
             # handle wraparound
             wraparound_indices(dim_sel, dim_len)
 
@@ -799,7 +805,8 @@ def __init__(self, selection, array):
 
         # compute chunk index for each point in the selection
         chunks_multi_index = tuple(
-            dim_sel // dim_chunk_len for (dim_sel, dim_chunk_len) in zip(selection, array._chunks)
+            dim_sel // dim_chunk_len
+            for (dim_sel, dim_chunk_len) in zip(selection, array._chunks, strict=False)
         )
 
         # broadcast selection - this will raise error if array dimensions don't match
@@ -856,11 +863,13 @@ def __iter__(self):
 
             chunk_offsets = tuple(
                 dim_chunk_ix * dim_chunk_len
-                for dim_chunk_ix, dim_chunk_len in zip(chunk_coords, self.array._chunks)
+                for dim_chunk_ix, dim_chunk_len in zip(
+                    chunk_coords, self.array._chunks, strict=False
+                )
             )
             chunk_selection = tuple(
                 dim_sel[start:stop] - dim_chunk_offset
-                for (dim_sel, dim_chunk_offset) in zip(self.selection, chunk_offsets)
+                for (dim_sel, dim_chunk_offset) in zip(self.selection, chunk_offsets, strict=False)
             )
 
             yield ChunkProjection(chunk_coords, chunk_selection, out_selection)
@@ -1040,7 +1049,7 @@ def __init__(self, selection, arr_shape):
         selection_shape = np.empty(self.arr_shape)[tuple(selection)].shape
         if any(
             selection_dim < 0 or selection_dim > arr_dim
-            for selection_dim, arr_dim in zip(selection_shape, self.arr_shape)
+            for selection_dim, arr_dim in zip(selection_shape, self.arr_shape, strict=False)
         ):
             raise IndexError(
                 "a selection index is out of range for the dimension"
@@ -1057,7 +1066,7 @@ def __init__(self, selection, arr_shape):
 
         chunk_loc_slices = []
         last_dim_slice = None if selection[-1].step > 1 else selection.pop()
-        for arr_shape_i, sl in zip(arr_shape, selection):
+        for arr_shape_i, sl in zip(arr_shape, selection, strict=False):
             dim_chunk_loc_slices = []
             assert isinstance(sl, slice)
             for x in slice_to_range(sl, arr_shape_i):

zarr/tests/test_core.py

@@ -1384,7 +1384,7 @@ def compare_arrays(expected, actual, item_dtype):
             assert isinstance(actual, np.ndarray)
             assert actual.dtype == object
             assert actual.shape == expected.shape
-            for ev, av in zip(expected.flat, actual.flat):
+            for ev, av in zip(expected.flat, actual.flat, strict=False):
                 assert isinstance(av, np.ndarray)
                 assert_array_equal(ev, av)
                 assert av.dtype == item_dtype

zarr/tests/test_hierarchy.py

@@ -647,7 +647,9 @@ def test_getitem_contains_iterators(self):
         values = list(g1.values())
         if g1._version == 3:
             # v3 are not automatically sorted by key
-            items, values = zip(*sorted(zip(items, values), key=lambda x: x[0]))
+            items, values = zip(
+                *sorted(zip(items, values, strict=False), key=lambda x: x[0]), strict=False
+            )
         assert "a" == items[0][0]
         assert g1["a"] == items[0][1]
         assert g1["a"] == values[0]
@@ -659,7 +661,9 @@ def test_getitem_contains_iterators(self):
         values = list(g1["foo"].values())
         if g1._version == 3:
             # v3 are not automatically sorted by key
-            items, values = zip(*sorted(zip(items, values), key=lambda x: x[0]))
+            items, values = zip(
+                *sorted(zip(items, values, strict=False), key=lambda x: x[0]), strict=False
+            )
         assert "bar" == items[0][0]
         assert g1["foo"]["bar"] == items[0][1]
         assert g1["foo"]["bar"] == values[0]

zarr/tests/test_indexing.py

@@ -1092,7 +1092,9 @@ def test_get_block_selection_1d():
     z = zarr.create(shape=a.shape, chunks=100, dtype=a.dtype)
     z[:] = a
 
-    for selection, expected_idx in zip(block_selections_1d, block_selections_1d_array_projection):
+    for selection, expected_idx in zip(
+        block_selections_1d, block_selections_1d_array_projection, strict=False
+    ):
         _test_get_block_selection(a, z, selection, expected_idx)
 
     bad_selections = block_selections_1d_bad + [
@@ -1144,7 +1146,9 @@ def test_get_block_selection_2d():
     z = zarr.create(shape=a.shape, chunks=(300, 3), dtype=a.dtype)
     z[:] = a
 
-    for selection, expected_idx in zip(block_selections_2d, block_selections_2d_array_projection):
+    for selection, expected_idx in zip(
+        block_selections_2d, block_selections_2d_array_projection, strict=False
+    ):
         _test_get_block_selection(a, z, selection, expected_idx)
 
     with pytest.raises(IndexError):
@@ -1179,7 +1183,9 @@ def test_set_block_selection_1d():
     a = np.empty(v.shape, dtype=v.dtype)
     z = zarr.create(shape=a.shape, chunks=100, dtype=a.dtype)
 
-    for selection, expected_idx in zip(block_selections_1d, block_selections_1d_array_projection):
+    for selection, expected_idx in zip(
+        block_selections_1d, block_selections_1d_array_projection, strict=False
+    ):
         _test_set_block_selection(v, a, z, selection, expected_idx)
 
     for selection in block_selections_1d_bad:
@@ -1195,7 +1201,9 @@ def test_set_block_selection_2d():
     a = np.empty(v.shape, dtype=v.dtype)
     z = zarr.create(shape=a.shape, chunks=(300, 3), dtype=a.dtype)
 
-    for selection, expected_idx in zip(block_selections_2d, block_selections_2d_array_projection):
+    for selection, expected_idx in zip(
+        block_selections_2d, block_selections_2d_array_projection, strict=False
+    ):
         _test_set_block_selection(v, a, z, selection, expected_idx)
 
     with pytest.raises(IndexError):
@@ -1720,7 +1728,8 @@ def test_accessed_chunks(shape, chunks, ops):
     for ii, (optype, slices) in enumerate(ops):
         # Resolve the slices into the accessed chunks for each dimension
         chunks_per_dim = [
-            np.unique(np.arange(N, dtype=int)[sl] // C) for N, C, sl in zip(shape, chunks, slices)
+            np.unique(np.arange(N, dtype=int)[sl] // C)
+            for N, C, sl in zip(shape, chunks, slices, strict=False)
         ]
 
         # Combine and generate the cartesian product to determine the chunks keys that

zarr/tests/test_storage.py

@@ -1622,9 +1622,10 @@ def test_filters(self):
                 (None, does_not_raise()),
                 ([], does_not_raise()),
                 ([AsType("f4", "f8")], pytest.raises(ValueError)),
-            ]
+            ],
+            strict=False,
         )
-        for filters, error in zip(all_filters, all_errors):
+        for filters, error in zip(all_filters, all_errors, strict=False):
             store = self.create_store()
             with error:
                 init_array(store, shape=1000, chunks=100, filters=filters)
@@ -1761,9 +1762,10 @@ def test_filters(self):
                 (None, does_not_raise()),
                 ([], does_not_raise()),
                 ([AsType("f4", "f8")], pytest.raises(ValueError)),
-            ]
+            ],
+            strict=False,
         )
-        for filters, error in zip(all_filters, all_errors):
+        for filters, error in zip(all_filters, all_errors, strict=False):
             store = self.create_store()
             with error:
                 init_array(store, shape=1000, chunks=100, filters=filters)
@@ -2476,7 +2478,7 @@ def test_iterators_with_prefix(self):
             assert 4 == len(store)
             keys = [prefix + "a", prefix + "b", prefix + "c/d", prefix + "c/e/f"]
             values = [b"aaa", b"bbb", b"ddd", b"fff"]
-            items = list(zip(keys, values))
+            items = list(zip(keys, values, strict=False))
             assert set(keys) == set(store)
             assert set(keys) == set(store.keys())
             assert set(values) == set(store.values())