Apply ruf/flake8-simplify rule SIM118

SIM118 Use `key in dict` instead of `key in dict.keys()`
pydata · max-sixty · Jun 30, 2025 · Jun 28, 2025 · Jun 28, 2025 · Jun 28, 2025
commit c805b8a61eec162535d3a9838614889ac796cefa
diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py
@@ -298,7 +298,7 @@ def _extract_nc4_variable_encoding(
             del encoding["chunksizes"]
 
     var_has_unlim_dim = any(dim in unlimited_dims for dim in variable.dims)
-    if not raise_on_invalid and var_has_unlim_dim and "contiguous" in encoding.keys():
+    if not raise_on_invalid and var_has_unlim_dim and "contiguous" in encoding:
         del encoding["contiguous"]
 
     for k in safe_to_drop:

diff --git a/xarray/backends/pydap_.py b/xarray/backends/pydap_.py
@@ -348,14 +348,14 @@ def group_fqn(store, path=None, g_fqn=None) -> dict[str, str]:
                 if not g_fqn:
                     g_fqn = {}
                 groups = [
-                    store[key].id
-                    for key in store.keys()
-                    if isinstance(store[key], GroupType)
+                    var.id for var in store.values() if isinstance(var, GroupType)
                 ]
                 for g in groups:
                     g_fqn.update({g: path})
                     subgroups = [
-                        var for var in store[g] if isinstance(store[g][var], GroupType)
+                        key
+                        for key, var in store[g].items()
+                        if isinstance(var, GroupType)
                     ]
                     if len(subgroups) > 0:
                         npath = path + g

diff --git a/xarray/computation/rolling.py b/xarray/computation/rolling.py
@@ -1081,7 +1081,7 @@ def __init__(
         self.side = side
         self.boundary = boundary
 
-        missing_dims = tuple(dim for dim in windows.keys() if dim not in self.obj.dims)
+        missing_dims = tuple(dim for dim in windows if dim not in self.obj.dims)
         if missing_dims:
             raise ValueError(
                 f"Window dimensions {missing_dims} not found in {self.obj.__class__.__name__} "

diff --git a/xarray/core/common.py b/xarray/core/common.py
@@ -1247,9 +1247,7 @@ def _dataset_indexer(dim: Hashable) -> DataArray:
                 _dataarray_indexer if isinstance(cond, DataArray) else _dataset_indexer
             )
 
-            indexers = {}
-            for dim in cond.sizes.keys():
-                indexers[dim] = _get_indexer(dim)
+            indexers = {dim: _get_indexer(dim) for dim in cond.sizes}
 
             self = self.isel(**indexers)
             cond = cond.isel(**indexers)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
@@ -212,7 +212,7 @@ def _check_data_shape(
                 data_shape = tuple(
                     (
                         as_variable(coords[k], k, auto_convert=False).size
-                        if k in coords.keys()
+                        if k in coords
                         else 1
                     )
                     for k in dims

diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
@@ -4088,21 +4088,20 @@ def _rename(
         is raised at the right stack level.
         """
         name_dict = either_dict_or_kwargs(name_dict, names, "rename")
-        for k in name_dict.keys():
+        for k, new_k in name_dict.items():
             if k not in self and k not in self.dims:
                 raise ValueError(
                     f"cannot rename {k!r} because it is not a "
                     "variable or dimension in this dataset"
                 )
 
             create_dim_coord = False
-            new_k = name_dict[k]
 
             if k == new_k:
                 continue  # Same name, nothing to do
 
             if k in self.dims and new_k in self._coord_names:
-                coord_dims = self._variables[name_dict[k]].dims
+                coord_dims = self._variables[new_k].dims
                 if coord_dims == (k,):
                     create_dim_coord = True
             elif k in self._coord_names and new_k in self.dims:
@@ -4112,7 +4111,7 @@ def _rename(
 
             if create_dim_coord:
                 warnings.warn(
-                    f"rename {k!r} to {name_dict[k]!r} does not create an index "
+                    f"rename {k!r} to {new_k!r} does not create an index "
                     "anymore. Try using swap_dims instead or use set_index "
                     "after rename to create an indexed coordinate.",
                     UserWarning,
@@ -8980,16 +8979,18 @@ def pad(
                 variables[name] = var
             elif name in self.data_vars:
                 if utils.is_dict_like(constant_values):
-                    if name in constant_values.keys():
+                    if name in constant_values:
                         filtered_constant_values = constant_values[name]
                     elif not set(var.dims).isdisjoint(constant_values.keys()):
                         filtered_constant_values = {
-                            k: v for k, v in constant_values.items() if k in var.dims
+                            k: v  # type: ignore[misc]
+                            for k, v in constant_values.items()
+                            if k in var.dims
                         }
                     else:
                         filtered_constant_values = 0  # TODO: https://github.com/pydata/xarray/pull/9353#discussion_r1724018352
                 else:
-                    filtered_constant_values = constant_values
+                    filtered_constant_values = constant_values  # type: ignore[assignment]
                 variables[name] = var.pad(
                     pad_width=var_pad_width,
                     mode=mode,

diff --git a/xarray/core/parallel.py b/xarray/core/parallel.py
@@ -624,7 +624,7 @@ def _wrapper(
         {**hlg.layers, **new_layers},
         dependencies={
             **hlg.dependencies,
-            **{name: {gname} for name in new_layers.keys()},
+            **{name: {gname} for name in new_layers},
         },
     )
 

diff --git a/xarray/plot/utils.py b/xarray/plot/utils.py
@@ -1825,7 +1825,7 @@ def _guess_coords_to_plot(
     """
     coords_to_plot_exist = {k: v for k, v in coords_to_plot.items() if v is not None}
     available_coords = tuple(
-        k for k in darray.coords.keys() if k not in coords_to_plot_exist.values()
+        k for k in darray.coords if k not in coords_to_plot_exist.values()
     )
 
     # If dims_plot[k] isn't defined then fill with one of the available dims, unless

diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py
@@ -2671,13 +2671,13 @@ def test_hidden_zarr_keys(self) -> None:
             # check that a variable hidden attribute is present and correct
             # JSON only has a single array type, which maps to list in Python.
             # In contrast, dims in xarray is always a tuple.
-            for var in expected.variables.keys():
+            for var in expected.variables:
                 dims = zarr_group[var].attrs[self.DIMENSION_KEY]
                 assert dims == list(expected[var].dims)
 
             with xr.decode_cf(store):
                 # make sure it is hidden
-                for var in expected.variables.keys():
+                for var in expected.variables:
                     assert self.DIMENSION_KEY not in expected[var].attrs
 
             # put it back and try removing from a variable
@@ -3731,7 +3731,7 @@ def test_chunk_key_encoding_v2(self) -> None:
 
             # Verify the chunk keys in store use the slash separator
             if not has_zarr_v3:
-                chunk_keys = [k for k in store.keys() if k.startswith("var1/")]
+                chunk_keys = [k for k in store if k.startswith("var1/")]
                 assert len(chunk_keys) > 0
                 for key in chunk_keys:
                     assert "/" in key

diff --git a/xarray/tests/test_backends_datatree.py b/xarray/tests/test_backends_datatree.py
@@ -66,7 +66,7 @@ def assert_chunks_equal(
             and node1.variables[name].chunksizes == node2.variables[name].chunksizes
         )
         for path, (node1, node2) in xr.group_subtrees(actual, expected)
-        for name in node1.variables.keys()
+        for name in node1.variables
     }
 
     assert all(comparison.values()), diff_chunks(comparison, actual, expected)
@@ -312,9 +312,9 @@ def test_open_groups(self, unaligned_datatree_nc) -> None:
         unaligned_dict_of_datasets = open_groups(unaligned_datatree_nc)
 
         # Check that group names are keys in the dictionary of `xr.Datasets`
-        assert "/" in unaligned_dict_of_datasets.keys()
-        assert "/Group1" in unaligned_dict_of_datasets.keys()
-        assert "/Group1/subgroup1" in unaligned_dict_of_datasets.keys()
+        assert "/" in unaligned_dict_of_datasets
+        assert "/Group1" in unaligned_dict_of_datasets
+        assert "/Group1/subgroup1" in unaligned_dict_of_datasets
         # Check that group name returns the correct datasets
         with xr.open_dataset(unaligned_datatree_nc, group="/") as expected:
             assert_identical(unaligned_dict_of_datasets["/"], expected)
@@ -453,9 +453,9 @@ def test_open_groups(self, url=unaligned_datatree_url) -> None:
         unaligned_dict_of_datasets = open_groups(url, engine=self.engine)
 
         # Check that group names are keys in the dictionary of `xr.Datasets`
-        assert "/" in unaligned_dict_of_datasets.keys()
-        assert "/Group1" in unaligned_dict_of_datasets.keys()
-        assert "/Group1/subgroup1" in unaligned_dict_of_datasets.keys()
+        assert "/" in unaligned_dict_of_datasets
+        assert "/Group1" in unaligned_dict_of_datasets
+        assert "/Group1/subgroup1" in unaligned_dict_of_datasets
         # Check that group name returns the correct datasets
         with xr.open_dataset(url, engine=self.engine, group="/") as expected:
             assert_identical(unaligned_dict_of_datasets["/"], expected)
@@ -782,10 +782,10 @@ def test_open_groups(self, unaligned_datatree_zarr_factory, zarr_format) -> None
         storepath = unaligned_datatree_zarr_factory(zarr_format=zarr_format)
         unaligned_dict_of_datasets = open_groups(storepath, engine="zarr")
 
-        assert "/" in unaligned_dict_of_datasets.keys()
-        assert "/Group1" in unaligned_dict_of_datasets.keys()
-        assert "/Group1/subgroup1" in unaligned_dict_of_datasets.keys()
-        assert "/Group2" in unaligned_dict_of_datasets.keys()
+        assert "/" in unaligned_dict_of_datasets
+        assert "/Group1" in unaligned_dict_of_datasets
+        assert "/Group1/subgroup1" in unaligned_dict_of_datasets
+        assert "/Group2" in unaligned_dict_of_datasets
         # Check that group name returns the correct datasets
         with xr.open_dataset(storepath, group="/", engine="zarr") as expected:
             assert_identical(unaligned_dict_of_datasets["/"], expected)

diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py
@@ -29,8 +29,8 @@
 
 def assert_combined_tile_ids_equal(dict1, dict2):
     assert len(dict1) == len(dict2)
-    for k in dict1.keys():
-        assert k in dict2.keys()
+    for k in dict1:
+        assert k in dict2
         assert_equal(dict1[k], dict2[k])
 
 

diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py
@@ -3164,7 +3164,7 @@ def test_drop_encoding(self) -> None:
         vencoding = {"scale_factor": 10}
         orig.encoding = {"foo": "bar"}
 
-        for k in orig.variables.keys():
+        for k in orig.variables:
             orig[k].encoding = vencoding
 
         actual = orig.drop_encoding()

diff --git a/xarray/tests/test_strategies.py b/xarray/tests/test_strategies.py
@@ -68,7 +68,7 @@ def test_number_of_dims(self, data, ndims):
     def test_restrict_names(self, data):
         capitalized_names = st.text(st.characters(), min_size=1).map(str.upper)
         dim_sizes = data.draw(dimension_sizes(dim_names=capitalized_names))
-        for dim in dim_sizes.keys():
+        for dim in dim_sizes:
             assert dim.upper() == dim
 
 

diff --git a/xarray/tests/test_units.py b/xarray/tests/test_units.py
@@ -3052,7 +3052,7 @@ def is_compatible(a, b):
         other_units = extract_units(other)
 
         equal_arrays = all(
-            is_compatible(units[name], other_units[name]) for name in units.keys()
+            is_compatible(units[name], other_units[name]) for name in units
         ) and (
             strip_units(data_array).equals(
                 strip_units(convert_units(other, extract_units(data_array)))