Reduce false positives for merge warning

Author: dcherian

xarray/structure/merge.py

@@ -102,7 +102,7 @@ def unique_variable(
     variables: list[Variable],
     compat: CompatOptions | CombineKwargDefault = "broadcast_equals",
     equals: bool | None = None,
-) -> Variable:
+) -> tuple[bool, Variable]:
     """Return the unique variable from a list of variables or raise MergeError.
 
     Parameters
@@ -128,7 +128,7 @@ def unique_variable(
     out = variables[0]
 
     if len(variables) == 1 or compat == "override":
-        return out
+        return equals, out
 
     combine_method = None
 
@@ -170,7 +170,7 @@ def unique_variable(
         for var in variables[1:]:
             out = getattr(out, combine_method)(var)
 
-    return out
+    return equals, out
 
 
 def _assert_compat_valid(compat):
@@ -313,7 +313,7 @@ def merge_collected(
             else:
                 variables = [variable for variable, _ in elements_list]
                 try:
-                    merged_vars[name] = unique_variable(
+                    equals_this_var, merged_vars[name] = unique_variable(
                         name, variables, compat, equals.get(name)
                     )
                     # This is very likely to result in false positives, but there is no way
@@ -322,6 +322,7 @@ def merge_collected(
                         isinstance(compat, CombineKwargDefault)
                         and compat == "no_conflicts"
                         and len(variables) > 1
+                        and not equals_this_var
                     ):
                         emit_user_level_warning(
                             compat.warning_message(

xarray/tests/test_merge.py

@@ -47,7 +47,7 @@ def test_merge_datasets(self, use_new_combine_kwarg_defaults):
             expected = data[["var1", "var2"]]
             assert_identical(actual, expected)
 
-            actual = xr.merge([data, data], compat="no_conflicts")
+            actual = xr.merge([data, data])
             assert_identical(actual, data)
 
     def test_merge_dataarray_unnamed(self):
@@ -197,13 +197,9 @@ def test_merge_arrays_attrs_variables(
 
         if expect_exception:
             with pytest.raises(MergeError, match="combine_attrs"):
-                actual = xr.merge(
-                    [data1, data2], compat="no_conflicts", combine_attrs=combine_attrs
-                )
+                actual = xr.merge([data1, data2], combine_attrs=combine_attrs)
         else:
-            actual = xr.merge(
-                [data1, data2], compat="no_conflicts", combine_attrs=combine_attrs
-            )
+            actual = xr.merge([data1, data2], combine_attrs=combine_attrs)
             expected = xr.Dataset(
                 {"var1": ("dim1", [], expected_attrs)},
                 coords={"dim1": ("dim1", [], expected_attrs)},
@@ -282,26 +278,20 @@ def test_merge_no_conflicts_single_var(self):
         ds1 = xr.Dataset({"a": ("x", [1, 2]), "x": [0, 1]})
         ds2 = xr.Dataset({"a": ("x", [2, 3]), "x": [1, 2]})
         expected = xr.Dataset({"a": ("x", [1, 2, 3]), "x": [0, 1, 2]})
-        assert expected.identical(
-            xr.merge([ds1, ds2], compat="no_conflicts", join="outer")
-        )
-        assert expected.identical(
-            xr.merge([ds2, ds1], compat="no_conflicts", join="outer")
-        )
-        assert ds1.identical(xr.merge([ds1, ds2], compat="no_conflicts", join="left"))
-        assert ds2.identical(xr.merge([ds1, ds2], compat="no_conflicts", join="right"))
+        assert expected.identical(xr.merge([ds1, ds2], join="outer"))
+        assert expected.identical(xr.merge([ds2, ds1], join="outer"))
+        assert ds1.identical(xr.merge([ds1, ds2], join="left"))
+        assert ds2.identical(xr.merge([ds1, ds2], join="right"))
         expected = xr.Dataset({"a": ("x", [2]), "x": [1]})
-        assert expected.identical(
-            xr.merge([ds1, ds2], compat="no_conflicts", join="inner")
-        )
+        assert expected.identical(xr.merge([ds1, ds2], join="inner"))
 
         with pytest.raises(xr.MergeError):
             ds3 = xr.Dataset({"a": ("x", [99, 3]), "x": [1, 2]})
-            xr.merge([ds1, ds3], compat="no_conflicts", join="outer")
+            xr.merge([ds1, ds3], join="outer")
 
         with pytest.raises(xr.MergeError):
             ds3 = xr.Dataset({"a": ("y", [2, 3]), "y": [1, 2]})
-            xr.merge([ds1, ds3], compat="no_conflicts", join="outer")
+            xr.merge([ds1, ds3], join="outer")
 
     def test_merge_no_conflicts_multi_var(self):
         data = create_test_data(add_attrs=False)
@@ -323,19 +313,17 @@ def test_merge_no_conflicts_multi_var(self):
 
     def test_merge_no_conflicts_preserve_attrs(self):
         data = xr.Dataset({"x": ([], 0, {"foo": "bar"})})
-        actual = xr.merge(
-            [data, data], compat="no_conflicts", combine_attrs="no_conflicts"
-        )
+        actual = xr.merge([data, data], combine_attrs="no_conflicts")
         assert_identical(data, actual)
 
     def test_merge_no_conflicts_broadcast(self):
         datasets = [xr.Dataset({"x": ("y", [0])}), xr.Dataset({"x": np.nan})]
-        actual = xr.merge(datasets, compat="no_conflicts")
+        actual = xr.merge(datasets)
         expected = xr.Dataset({"x": ("y", [0])})
         assert_identical(expected, actual)
 
         datasets = [xr.Dataset({"x": ("y", [np.nan])}), xr.Dataset({"x": 0})]
-        actual = xr.merge(datasets, compat="no_conflicts")
+        actual = xr.merge(datasets)
         assert_identical(expected, actual)
 
 
@@ -350,20 +338,19 @@ def test_merge(self):
 
         actual = ds2.merge(ds1)
         assert_identical(expected, actual)
-        with pytest.warns(FutureWarning):  # this is a false alarm
-            actual = data.merge(data)
+        actual = data.merge(data)
         assert_identical(data, actual)
-        actual = data.reset_coords(drop=True).merge(data, compat="no_conflicts")
+        actual = data.reset_coords(drop=True).merge(data)
         assert_identical(data, actual)
-        actual = data.merge(data.reset_coords(drop=True), compat="no_conflicts")
+        actual = data.merge(data.reset_coords(drop=True))
         assert_identical(data, actual)
 
         with pytest.raises(ValueError, match="conflicting values for variable"):
             ds1.merge(ds2.rename({"var3": "var1"}))
         with pytest.raises(ValueError, match=r"should be coordinates or not"):
-            data.reset_coords().merge(data, compat="no_conflicts")
+            data.reset_coords().merge(data)
         with pytest.raises(ValueError, match=r"should be coordinates or not"):
-            data.merge(data.reset_coords(), compat="no_conflicts")
+            data.merge(data.reset_coords())
 
     def test_merge_drop_attrs(self):
         data = create_test_data()
@@ -417,6 +404,7 @@ def test_merge_compat(self):
         assert ds1.identical(ds1.merge(ds2, compat="override"))
 
     def test_merge_compat_minimal(self) -> None:
+        """Test that we drop the conflicting bar coordinate."""
         # https://github.com/pydata/xarray/issues/7405
         # https://github.com/pydata/xarray/issues/7588
         ds1 = xr.Dataset(coords={"foo": [1, 2, 3], "bar": 4})
@@ -426,7 +414,7 @@ def test_merge_compat_minimal(self) -> None:
         expected = xr.Dataset(coords={"foo": [1, 2, 3]})
         assert_identical(actual, expected)
 
-    def test_merge_join(self):
+    def test_merge_join_outer(self):
         ds1 = xr.Dataset({"a": ("x", [1, 2]), "x": [0, 1]})
         ds2 = xr.Dataset({"b": ("x", [3, 4]), "x": [1, 2]})
         expected = xr.Dataset(
@@ -533,11 +521,7 @@ def test_merge_datasets_false_warning(self):
         data = create_test_data(add_attrs=False, use_extension_array=True)
 
         with set_options(use_new_combine_kwarg_defaults=False):
-            with pytest.warns(
-                FutureWarning,
-                match="will change from compat='no_conflicts' to compat='override'",
-            ):
-                old = xr.merge([data, data])
+            old = xr.merge([data, data])
 
         with set_options(use_new_combine_kwarg_defaults=True):
             new = xr.merge([data, data])
@@ -571,11 +555,7 @@ def test_merge_broadcast_equals(self):
         ds2 = xr.Dataset({"x": ("y", [0, 0])})
 
         with set_options(use_new_combine_kwarg_defaults=False):
-            with pytest.warns(
-                FutureWarning,
-                match="will change from compat='no_conflicts' to compat='override'",
-            ):
-                old = ds1.merge(ds2)
+            old = ds1.merge(ds2)
 
         with set_options(use_new_combine_kwarg_defaults=True):
             new = ds1.merge(ds2)