Make zips strict unless it is causing errors

In which case set them to explicit False

Author: Armavica

asv_bench/benchmarks/groupby.py

@@ -174,7 +174,7 @@ def setup(self, use_cftime, use_flox):
         # GH9426 - deep-copying CFTime object arrays is weirdly slow
         asda = xr.DataArray(time)
         labeled_time = []
-        for year, month in zip(asda.dt.year, asda.dt.month):
+        for year, month in zip(asda.dt.year, asda.dt.month, strict=True):
             labeled_time.append(cftime.datetime(year, month, 1))
 
         self.da = xr.DataArray(

properties/test_pandas_roundtrip.py

@@ -80,7 +80,7 @@ def test_roundtrip_dataarray(data, arr) -> None:
             tuple
         )
     )
-    coords = {name: np.arange(n) for (name, n) in zip(names, arr.shape)}
+    coords = {name: np.arange(n) for (name, n) in zip(names, arr.shape, strict=True)}
     original = xr.DataArray(arr, dims=names, coords=coords)
     roundtripped = xr.DataArray(original.to_pandas())
     xr.testing.assert_identical(original, roundtripped)

xarray/backends/api.py

@@ -1585,8 +1585,9 @@ def save_mfdataset(
                 multifile=True,
                 **kwargs,
             )
-            for ds, path, group in zip(datasets, paths, groups)
-        ]
+            for ds, path, group in zip(datasets, paths, groups, strict=True)
+        ],
+        strict=True,
     )
 
     try:
@@ -1600,7 +1601,10 @@ def save_mfdataset(
         import dask
 
         return dask.delayed(
-            [dask.delayed(_finalize_store)(w, s) for w, s in zip(writes, stores)]
+            [
+                dask.delayed(_finalize_store)(w, s)
+                for w, s in zip(writes, stores, strict=True)
+            ]
         )
 
 

xarray/backends/common.py

@@ -431,7 +431,7 @@ def set_dimensions(self, variables, unlimited_dims=None):
         for v in unlimited_dims:  # put unlimited_dims first
             dims[v] = None
         for v in variables.values():
-            dims.update(dict(zip(v.dims, v.shape)))
+            dims.update(dict(zip(v.dims, v.shape, strict=True)))
 
         for dim, length in dims.items():
             if dim in existing_dims and length != existing_dims[dim]:

xarray/backends/h5netcdf_.py

@@ -208,7 +208,9 @@ def open_store_variable(self, name, var):
             "shuffle": var.shuffle,
         }
         if var.chunks:
-            encoding["preferred_chunks"] = dict(zip(var.dimensions, var.chunks))
+            encoding["preferred_chunks"] = dict(
+                zip(var.dimensions, var.chunks, strict=True)
+            )
         # Convert h5py-style compression options to NetCDF4-Python
         # style, if possible
         if var.compression == "gzip":

xarray/backends/netCDF4_.py

@@ -278,7 +278,7 @@ def _extract_nc4_variable_encoding(
         chunksizes = encoding["chunksizes"]
         chunks_too_big = any(
             c > d and dim not in unlimited_dims
-            for c, d, dim in zip(chunksizes, variable.shape, variable.dims)
+            for c, d, dim in zip(chunksizes, variable.shape, variable.dims, strict=True)
         )
         has_original_shape = "original_shape" in encoding
         changed_shape = (
@@ -446,7 +446,9 @@ def open_store_variable(self, name: str, var):
             else:
                 encoding["contiguous"] = False
                 encoding["chunksizes"] = tuple(chunking)
-                encoding["preferred_chunks"] = dict(zip(var.dimensions, chunking))
+                encoding["preferred_chunks"] = dict(
+                    zip(var.dimensions, chunking, strict=True)
+                )
         # TODO: figure out how to round-trip "endian-ness" without raising
         # warnings from netCDF4
         # encoding['endian'] = var.endian()

xarray/backends/zarr.py

@@ -186,7 +186,7 @@ def _determine_zarr_chunks(enc_chunks, var_chunks, ndim, name, safe_chunks):
     # TODO: incorporate synchronizer to allow writes from multiple dask
     # threads
     if var_chunks and enc_chunks_tuple:
-        for zchunk, dchunks in zip(enc_chunks_tuple, var_chunks):
+        for zchunk, dchunks in zip(enc_chunks_tuple, var_chunks, strict=True):
             for dchunk in dchunks[:-1]:
                 if dchunk % zchunk:
                     base_error = (
@@ -548,7 +548,7 @@ def open_store_variable(self, name, zarr_array=None):
 
         encoding = {
             "chunks": zarr_array.chunks,
-            "preferred_chunks": dict(zip(dimensions, zarr_array.chunks)),
+            "preferred_chunks": dict(zip(dimensions, zarr_array.chunks, strict=True)),
             "compressor": zarr_array.compressor,
             "filters": zarr_array.filters,
         }
@@ -576,7 +576,7 @@ def get_dimensions(self):
         dimensions = {}
         for k, v in self.zarr_group.arrays():
             dim_names, _ = _get_zarr_dims_and_attrs(v, DIMENSION_KEY, try_nczarr)
-            for d, s in zip(dim_names, v.shape):
+            for d, s in zip(dim_names, v.shape, strict=True):
                 if d in dimensions and dimensions[d] != s:
                     raise ValueError(
                         f"found conflicting lengths for dimension {d} "

xarray/coding/calendar_ops.py

@@ -207,7 +207,7 @@ def convert_calendar(
                 _convert_to_new_calendar_with_new_day_of_year(
                     date, newdoy, calendar, use_cftime
                 )
-                for date, newdoy in zip(time.variable._data.array, new_doy)
+                for date, newdoy in zip(time.variable._data.array, new_doy, strict=True)
             ],
             dims=(dim,),
             name=dim,

xarray/core/alignment.py

@@ -405,14 +405,15 @@ def align_indexes(self) -> None:
                     zip(
                         [joined_index] + matching_indexes,
                         [joined_index_vars] + matching_index_vars,
+                        strict=True,
                     )
                 )
                 need_reindex = self._need_reindex(dims, cmp_indexes)
             else:
                 if len(matching_indexes) > 1:
                     need_reindex = self._need_reindex(
                         dims,
-                        list(zip(matching_indexes, matching_index_vars)),
+                        list(zip(matching_indexes, matching_index_vars, strict=True)),
                     )
                 else:
                     need_reindex = False
@@ -557,7 +558,7 @@ def reindex_all(self) -> None:
         self.results = tuple(
             self._reindex_one(obj, matching_indexes)
             for obj, matching_indexes in zip(
-                self.objects, self.objects_matching_indexes
+                self.objects, self.objects_matching_indexes, strict=True
             )
         )
 
@@ -952,7 +953,7 @@ def is_alignable(obj):
         fill_value=fill_value,
     )
 
-    for position, key, aligned_obj in zip(positions, keys, aligned):
+    for position, key, aligned_obj in zip(positions, keys, aligned, strict=True):
         if key is no_key:
             out[position] = aligned_obj
         else:

xarray/core/combine.py

@@ -139,7 +139,8 @@ def _infer_concat_order_from_coords(datasets):
                 # Append positions along extra dimension to structure which
                 # encodes the multi-dimensional concatenation order
                 tile_ids = [
-                    tile_id + (position,) for tile_id, position in zip(tile_ids, order)
+                    tile_id + (position,)
+                    for tile_id, position in zip(tile_ids, order, strict=True)
                 ]
 
     if len(datasets) > 1 and not concat_dims:
@@ -148,7 +149,7 @@ def _infer_concat_order_from_coords(datasets):
             "order the datasets for concatenation"
         )
 
-    combined_ids = dict(zip(tile_ids, datasets))
+    combined_ids = dict(zip(tile_ids, datasets, strict=True))
 
     return combined_ids, concat_dims
 
@@ -349,7 +350,7 @@ def _nested_combine(
         combined_ids = _infer_concat_order_from_positions(datasets)
     else:
         # Already sorted so just use the ids already passed
-        combined_ids = dict(zip(ids, datasets))
+        combined_ids = dict(zip(ids, datasets, strict=True))
 
     # Check that the inferred shape is combinable
     _check_shape_tile_ids(combined_ids)

xarray/core/common.py

@@ -254,7 +254,7 @@ def sizes(self: Any) -> Mapping[Hashable, int]:
         --------
         Dataset.sizes
         """
-        return Frozen(dict(zip(self.dims, self.shape)))
+        return Frozen(dict(zip(self.dims, self.shape, strict=True)))
 
 
 class AttrAccessMixin:

xarray/core/computation.py

@@ -326,7 +326,7 @@ def apply_dataarray_vfunc(
                 variable, coords=coords, indexes=indexes, name=name, fastpath=True
             )
             for variable, coords, indexes in zip(
-                result_var, result_coords, result_indexes
+                result_var, result_coords, result_indexes, strict=True
             )
         )
     else:
@@ -407,7 +407,7 @@ def _unpack_dict_tuples(
 ) -> tuple[dict[Hashable, Variable], ...]:
     out: tuple[dict[Hashable, Variable], ...] = tuple({} for _ in range(num_outputs))
     for name, values in result_vars.items():
-        for value, results_dict in zip(values, out):
+        for value, results_dict in zip(values, out, strict=True):
             results_dict[name] = value
     return out
 
@@ -422,7 +422,7 @@ def _check_core_dims(signature, variable_args, name):
     """
     missing = []
     for i, (core_dims, variable_arg) in enumerate(
-        zip(signature.input_core_dims, variable_args)
+        zip(signature.input_core_dims, variable_args, strict=True)
     ):
         # Check whether all the dims are on the variable. Note that we need the
         # `hasattr` to check for a dims property, to protect against the case where
@@ -454,7 +454,7 @@ def apply_dict_of_variables_vfunc(
     grouped_by_name = collect_dict_values(args, names, fill_value)
 
     result_vars = {}
-    for name, variable_args in zip(names, grouped_by_name):
+    for name, variable_args in zip(names, grouped_by_name, strict=True):
         core_dim_present = _check_core_dims(signature, variable_args, name)
         if core_dim_present is True:
             result_vars[name] = func(*variable_args)
@@ -546,7 +546,7 @@ def apply_dataset_vfunc(
     if signature.num_outputs > 1:
         out = tuple(
             _fast_dataset(*args)
-            for args in zip(result_vars, list_of_coords, list_of_indexes)
+            for args in zip(result_vars, list_of_coords, list_of_indexes, strict=True)
         )
     else:
         (coord_vars,) = list_of_coords
@@ -616,11 +616,13 @@ def apply_groupby_func(func, *args):
             iterator = itertools.repeat(arg)
         iterators.append(iterator)
 
-    applied: Iterator = (func(*zipped_args) for zipped_args in zip(*iterators))
+    applied: Iterator = (
+        func(*zipped_args) for zipped_args in zip(*iterators, strict=False)
+    )
     applied_example, applied = peek_at(applied)
     combine = first_groupby._combine  # type: ignore[attr-defined]
     if isinstance(applied_example, tuple):
-        combined = tuple(combine(output) for output in zip(*applied))
+        combined = tuple(combine(output) for output in zip(*applied, strict=True))
     else:
         combined = combine(applied)
     return combined
@@ -637,7 +639,7 @@ def unified_dim_sizes(
                 "broadcasting cannot handle duplicate "
                 f"dimensions on a variable: {list(var.dims)}"
             )
-        for dim, size in zip(var.dims, var.shape):
+        for dim, size in zip(var.dims, var.shape, strict=True):
             if dim not in exclude_dims:
                 if dim not in dim_sizes:
                     dim_sizes[dim] = size
@@ -741,7 +743,7 @@ def apply_variable_ufunc(
             if isinstance(arg, Variable)
             else arg
         )
-        for arg, core_dims in zip(args, signature.input_core_dims)
+        for arg, core_dims in zip(args, signature.input_core_dims, strict=True)
     ]
 
     if any(is_chunked_array(array) for array in input_data):
@@ -766,7 +768,7 @@ def apply_variable_ufunc(
             allow_rechunk = dask_gufunc_kwargs.get("allow_rechunk", None)
             if allow_rechunk is None:
                 for n, (data, core_dims) in enumerate(
-                    zip(input_data, signature.input_core_dims)
+                    zip(input_data, signature.input_core_dims, strict=True)
                 ):
                     if is_chunked_array(data):
                         # core dimensions cannot span multiple chunks
@@ -848,7 +850,7 @@ def func(*arrays):
     )
 
     output: list[Variable] = []
-    for dims, data in zip(output_dims, result_data):
+    for dims, data in zip(output_dims, result_data, strict=True):
         data = as_compatible_data(data)
         if data.ndim != len(dims):
             raise ValueError(
@@ -2179,7 +2181,7 @@ def _calc_idxminmax(
     # Handle chunked arrays (e.g. dask).
     if is_chunked_array(array.data):
         chunkmanager = get_chunked_array_type(array.data)
-        chunks = dict(zip(array.dims, array.chunks))
+        chunks = dict(zip(array.dims, array.chunks, strict=True))
         dask_coord = chunkmanager.from_array(array[dim].data, chunks=chunks[dim])
         data = dask_coord[duck_array_ops.ravel(indx.data)]
         res = indx.copy(data=duck_array_ops.reshape(data, indx.shape))
@@ -2268,7 +2270,7 @@ def unify_chunks(*objects: Dataset | DataArray) -> tuple[Dataset | DataArray, ..
     _, chunked_data = chunkmanager.unify_chunks(*unify_chunks_args)
     chunked_data_iter = iter(chunked_data)
     out: list[Dataset | DataArray] = []
-    for obj, ds in zip(objects, datasets):
+    for obj, ds in zip(objects, datasets, strict=True):
         for k, v in ds._variables.items():
             if v.chunks is not None:
                 ds._variables[k] = v.copy(data=next(chunked_data_iter))

xarray/core/concat.py

@@ -400,7 +400,9 @@ def process_subset_opt(opt, subset):
                                     equals[k] = False
                                     # computed variables are not to be re-computed
                                     # again in the future
-                                    for ds, v in zip(datasets[1:], computed):
+                                    for ds, v in zip(
+                                        datasets[1:], computed, strict=False
+                                    ):
                                         ds.variables[k].data = v.data
                                     break
                             else:
@@ -583,7 +585,7 @@ def ensure_common_dims(vars, concat_dim_lengths):
         common_dims = tuple(utils.OrderedSet(d for v in vars for d in v.dims))
         if dim_name not in common_dims:
             common_dims = (dim_name,) + common_dims
-        for var, dim_len in zip(vars, concat_dim_lengths):
+        for var, dim_len in zip(vars, concat_dim_lengths, strict=True):
             if var.dims != common_dims:
                 common_shape = tuple(dims_sizes.get(d, dim_len) for d in common_dims)
                 var = var.set_dims(common_dims, common_shape)