Repo checker (#9450)

* Remove default mypy option

* Implement mypy ignore-without-code option

* Enable mypy redundant-expr

* Fix erroneous tuple types

* Remove ruff target-version, redundant with project

* Use extend selections for ruff

* Fix B009 and B010 with ruff

* Fix test parametrization

* Fix FutureWarning

* Make zips strict unless it is causing errors

In which case set them to explicit False

* Add a commit message for pre-commit autoupdate

.pre-commit-config.yaml

@@ -1,6 +1,7 @@
 # https://pre-commit.com/
 ci:
  autoupdate_schedule: monthly
+ autoupdate_commit_msg: 'Update pre-commit hooks'
 exclude: 'xarray/datatree_.*'
 repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks

asv_bench/benchmarks/dataset_io.py

@@ -724,7 +724,7 @@ class PerformanceBackend(xr.backends.BackendEntrypoint):
  def open_dataset(
  self,
  filename_or_obj: str | os.PathLike | None,
- drop_variables: tuple[str] = None,
+ drop_variables: tuple[str, ...] = None,
  *,
  mask_and_scale=True,
  decode_times=True,

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(

asv_bench/benchmarks/rolling.py

@@ -64,7 +64,7 @@ def time_rolling_long(self, func, pandas, use_bottleneck):
  def time_rolling_np(self, window_, min_periods, use_bottleneck):
  with xr.set_options(use_bottleneck=use_bottleneck):
  self.ds.rolling(x=window_, center=False, min_periods=min_periods).reduce(
- getattr(np, "nansum")
+ np.nansum
  ).load()
 
  @parameterized(

doc/user-guide/testing.rst

@@ -193,7 +193,7 @@ different type:
 
 .. ipython:: python
 
- def sparse_random_arrays(shape: tuple[int]) -> sparse._coo.core.COO:
+ def sparse_random_arrays(shape: tuple[int, ...]) -> sparse._coo.core.COO:
  """Strategy which generates random sparse.COO arrays"""
  if shape is None:
  shape = npst.array_shapes()

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)

pyproject.toml

@@ -84,14 +84,13 @@ source = ["xarray"]
 exclude_lines = ["pragma: no cover", "if TYPE_CHECKING"]
 
 [tool.mypy]
-enable_error_code = "redundant-self"
+enable_error_code = ["ignore-without-code", "redundant-self", "redundant-expr"]
 exclude = [
  'build',
  'xarray/util/generate_.*\.py',
  'xarray/datatree_/doc/.*\.py',
 ]
 files = "xarray"
-show_error_codes = true
 show_error_context = true
 warn_redundant_casts = true
 warn_unused_configs = true
@@ -240,7 +239,6 @@ extend-exclude = [
  "doc",
  "_typed_ops.pyi",
 ]
-target-version = "py310"
 
 [tool.ruff.lint]
 # E402: module level import not at top of file
@@ -249,13 +247,13 @@ target-version = "py310"
 extend-safe-fixes = [
  "TID252", # absolute imports
 ]
-ignore = [
+extend-ignore = [
  "E402",
  "E501",
  "E731",
  "UP007",
 ]
-select = [
+extend-select = [
  "F", # Pyflakes
  "E", # Pycodestyle
  "W",

xarray/backends/api.py

@@ -51,7 +51,7 @@
  try:
  from dask.delayed import Delayed
  except ImportError:
- Delayed = None # type: ignore
+ Delayed = None # type: ignore[assignment, misc]
  from io import BufferedIOBase
 
  from xarray.backends.common import BackendEntrypoint
@@ -1113,7 +1113,7 @@ def open_mfdataset(
  list(combined_ids_paths.keys()),
  list(combined_ids_paths.values()),
  )
- elif combine == "by_coords" and concat_dim is not None:
+ elif concat_dim is not None:
  raise ValueError(
  "When combine='by_coords', passing a value for `concat_dim` has no "
  "effect. To manually combine along a specific dimension you should "
@@ -1432,7 +1432,7 @@ def to_netcdf(
  store.sync()
  return target.getvalue()
  finally:
- if not multifile and compute:
+ if not multifile and compute: # type: ignore[redundant-expr]
  store.close()
 
  if not compute:
@@ -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/file_manager.py

@@ -276,7 +276,7 @@ def __getstate__(self):
  def __setstate__(self, state) -> None:
  """Restore from a pickle."""
  opener, args, mode, kwargs, lock, manager_id = state
- self.__init__( # type: ignore
+ self.__init__( # type: ignore[misc]
  opener, *args, mode=mode, kwargs=kwargs, lock=lock, manager_id=manager_id
  )
 

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,9 @@ 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=False
+ )
  )
  has_original_shape = "original_shape" in encoding
  changed_shape = (
@@ -446,7 +448,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/plugins.py

@@ -199,7 +199,7 @@ def get_backend(engine: str | type[BackendEntrypoint]) -> BackendEntrypoint:
  "https://docs.xarray.dev/en/stable/getting-started-guide/installing.html"
  )
  backend = engines[engine]
- elif isinstance(engine, type) and issubclass(engine, BackendEntrypoint):
+ elif issubclass(engine, BackendEntrypoint):
  backend = engine()
  else:
  raise TypeError(

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,13 +548,13 @@ 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,
  }
  # _FillValue needs to be in attributes, not encoding, so it will get
  # picked up by decode_cf
- if getattr(zarr_array, "fill_value") is not None:
+ if zarr_array.fill_value is not None:
  attributes["_FillValue"] = zarr_array.fill_value
 
  return Variable(dimensions, data, attributes, encoding)
@@ -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

@@ -198,7 +198,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/coding/times.py

@@ -204,7 +204,7 @@ def _unpack_time_units_and_ref_date(units: str) -> tuple[str, pd.Timestamp]:
 
 
 def _decode_cf_datetime_dtype(
- data, units: str, calendar: str, use_cftime: bool | None
+ data, units: str, calendar: str | None, use_cftime: bool | None
 ) -> np.dtype:
  # Verify that at least the first and last date can be decoded
  # successfully. Otherwise, tracebacks end up swallowed by
@@ -704,7 +704,7 @@ def _cast_to_dtype_if_safe(num: np.ndarray, dtype: np.dtype) -> np.ndarray:
 
 
 def encode_cf_datetime(
- dates: T_DuckArray, # type: ignore
+ dates: T_DuckArray, # type: ignore[misc]
  units: str | None = None,
  calendar: str | None = None,
  dtype: np.dtype | None = None,
@@ -726,7 +726,7 @@ def encode_cf_datetime(
 
 
 def _eagerly_encode_cf_datetime(
- dates: T_DuckArray, # type: ignore
+ dates: T_DuckArray, # type: ignore[misc]
  units: str | None = None,
  calendar: str | None = None,
  dtype: np.dtype | None = None,
@@ -809,7 +809,7 @@ def _eagerly_encode_cf_datetime(
 
 
 def _encode_cf_datetime_within_map_blocks(
- dates: T_DuckArray, # type: ignore
+ dates: T_DuckArray, # type: ignore[misc]
  units: str,
  calendar: str,
  dtype: np.dtype,
@@ -859,7 +859,7 @@ def _lazily_encode_cf_datetime(
 
 
 def encode_cf_timedelta(
- timedeltas: T_DuckArray, # type: ignore
+ timedeltas: T_DuckArray, # type: ignore[misc]
  units: str | None = None,
  dtype: np.dtype | None = None,
 ) -> tuple[T_DuckArray, str]:
@@ -871,7 +871,7 @@ def encode_cf_timedelta(
 
 
 def _eagerly_encode_cf_timedelta(
- timedeltas: T_DuckArray, # type: ignore
+ timedeltas: T_DuckArray, # type: ignore[misc]
  units: str | None = None,
  dtype: np.dtype | None = None,
  allow_units_modification: bool = True,
@@ -923,7 +923,7 @@ def _eagerly_encode_cf_timedelta(
 
 
 def _encode_cf_timedelta_within_map_blocks(
- timedeltas: T_DuckArray, # type:ignore
+ timedeltas: T_DuckArray, # type: ignore[misc]
  units: str,
  dtype: np.dtype,
 ) -> T_DuckArray:

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: