Remove xarray.tests.test_combine from mypy exclusions (#10753)

- Add type annotations to satisfy mypy's check_untyped_defs requirement
- Fix combine_nested type signature to accept None for concat_dim parameter
- Add minimal type hints where mypy cannot infer types
- No behavioral changes, all tests pass

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude <[email protected]>

Author: max-sixty

pyproject.toml

@@ -190,7 +190,6 @@ check_untyped_defs = false
 module = [
   "xarray.tests.test_coarsen",
   "xarray.tests.test_coding_times",
-  "xarray.tests.test_combine",
   "xarray.tests.test_computation",
   "xarray.tests.test_concat",
   "xarray.tests.test_coordinates",

xarray/structure/combine.py

@@ -405,7 +405,7 @@ def _nested_combine(
 
 def combine_nested(
     datasets: DATASET_HYPERCUBE,
-    concat_dim: str | DataArray | Sequence[str | DataArray | pd.Index | None],
+    concat_dim: str | DataArray | Sequence[str | DataArray | pd.Index | None] | None,
     compat: str | CombineKwargDefault = _COMPAT_DEFAULT,
     data_vars: str | CombineKwargDefault = _DATA_VARS_DEFAULT,
     coords: str | CombineKwargDefault = _COORDS_DEFAULT,

xarray/tests/test_combine.py

@@ -28,7 +28,7 @@
 from xarray.tests.test_dataset import create_test_data
 
 
-def assert_combined_tile_ids_equal(dict1, dict2):
+def assert_combined_tile_ids_equal(dict1: dict, dict2: dict) -> None:
     assert len(dict1) == len(dict2)
     for k in dict1.keys():
         assert k in dict2.keys()
@@ -41,7 +41,9 @@ def test_1d(self):
         input = [ds(0), ds(1)]
 
         expected = {(0,): ds(0), (1,): ds(1)}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_2d(self):
@@ -56,7 +58,9 @@ def test_2d(self):
             (2, 0): ds(4),
             (2, 1): ds(5),
         }
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_3d(self):
@@ -80,40 +84,50 @@ def test_3d(self):
             (1, 2, 0): ds(10),
             (1, 2, 1): ds(11),
         }
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_single_dataset(self):
         ds = create_test_data(0)
         input = [ds]
 
         expected = {(0,): ds}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_redundant_nesting(self):
         ds = create_test_data
         input = [[ds(0)], [ds(1)]]
 
         expected = {(0, 0): ds(0), (1, 0): ds(1)}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_ignore_empty_list(self):
         ds = create_test_data(0)
-        input = [ds, []]
+        input: list = [ds, []]
         expected = {(0,): ds}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_uneven_depth_input(self):
         # Auto_combine won't work on ragged input
         # but this is just to increase test coverage
         ds = create_test_data
-        input = [ds(0), [ds(1), ds(2)]]
+        input: list = [ds(0), [ds(1), ds(2)]]
 
         expected = {(0,): ds(0), (1, 0): ds(1), (1, 1): ds(2)}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_uneven_length_input(self):
@@ -123,15 +137,19 @@ def test_uneven_length_input(self):
         input = [[ds(0)], [ds(1), ds(2)]]
 
         expected = {(0, 0): ds(0), (1, 0): ds(1), (1, 1): ds(2)}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
     def test_infer_from_datasets(self):
         ds = create_test_data
         input = [ds(0), ds(1)]
 
         expected = {(0,): ds(0), (1,): ds(1)}
-        actual = _infer_concat_order_from_positions(input)
+        actual: dict[tuple[int, ...], Dataset] = _infer_concat_order_from_positions(
+            input
+        )
         assert_combined_tile_ids_equal(expected, actual)
 
 
@@ -581,8 +599,8 @@ def test_auto_combine_2d_combine_attrs_kwarg(self):
         expected_dict["override"] = expected.copy(deep=True)
         expected_dict["override"].attrs = {"a": 1}
         f = lambda attrs, context: attrs[0]
-        expected_dict[f] = expected.copy(deep=True)
-        expected_dict[f].attrs = f([{"a": 1}], None)
+        expected_dict[f] = expected.copy(deep=True)  # type: ignore[index]
+        expected_dict[f].attrs = f([{"a": 1}], None)  # type: ignore[index]
 
         datasets = [[ds(0), ds(1), ds(2)], [ds(3), ds(4), ds(5)]]
 
@@ -606,7 +624,7 @@ def test_auto_combine_2d_combine_attrs_kwarg(self):
                 datasets,
                 concat_dim=["dim1", "dim2"],
                 data_vars="all",
-                combine_attrs=combine_attrs,
+                combine_attrs=combine_attrs,  # type: ignore[arg-type]
             )
             assert_identical(result, expected)
 
@@ -632,11 +650,11 @@ def test_invalid_hypercube_input(self):
         ):
             combine_nested(datasets, concat_dim=["dim1", "dim2"])
 
-        datasets = [[ds(0), ds(1)], [[ds(3), ds(4)]]]
+        datasets2: list = [[ds(0), ds(1)], [[ds(3), ds(4)]]]
         with pytest.raises(
             ValueError, match=r"sub-lists do not have consistent depths"
         ):
-            combine_nested(datasets, concat_dim=["dim1", "dim2"])
+            combine_nested(datasets2, concat_dim=["dim1", "dim2"])
 
         datasets = [[ds(0), ds(1)], [ds(3), ds(4)]]
         with pytest.raises(ValueError, match=r"concat_dims has length"):
@@ -1019,7 +1037,7 @@ def test_infer_order_from_coords(self):
         objs = [data.isel(dim2=slice(4, 9)), data.isel(dim2=slice(4))]
         actual = combine_by_coords(objs, data_vars="all")
         expected = data
-        assert expected.broadcast_equals(actual)
+        assert expected.broadcast_equals(actual)  # type: ignore[arg-type]
 
         with set_options(use_new_combine_kwarg_defaults=True):
             actual = combine_by_coords(objs)
@@ -1067,7 +1085,7 @@ def test_combine_by_coords_still_fails(self):
         # https://github.com/pydata/xarray/issues/508
         datasets = [Dataset({"x": 0}, {"y": 0}), Dataset({"x": 1}, {"y": 1, "z": 1})]
         with pytest.raises(ValueError):
-            combine_by_coords(datasets, "y")
+            combine_by_coords(datasets, "y")  # type: ignore[arg-type]
 
     def test_combine_by_coords_no_concat(self):
         objs = [Dataset({"x": 0}), Dataset({"y": 1})]