Fix equivalent() for NumPy scalar NaN comparison (#10838)

Author: max-sixty

xarray/core/utils.py

@@ -256,6 +256,11 @@ def equivalent(first: T, second: T) -> bool:
     if isinstance(first, list) or isinstance(second, list):
         return list_equiv(first, second)  # type: ignore[arg-type]
 
+    # Check for NaN equivalence early (before equality comparison)
+    # This handles both Python float NaN and NumPy scalar NaN (issue #10833)
+    if pd.isnull(first) and pd.isnull(second):  # type: ignore[call-overload]
+        return True
+
     # For non-array/list types, use == but require boolean result
     result = first == second
     if not isinstance(result, bool):
@@ -265,8 +270,7 @@ def equivalent(first: T, second: T) -> bool:
         # Reject any other non-boolean type (Dataset, Series, custom objects, etc.)
         return False
 
-    # Check for NaN equivalence
-    return result or (pd.isnull(first) and pd.isnull(second))  # type: ignore[call-overload]
+    return result
 
 
 def list_equiv(first: Sequence[T], second: Sequence[T]) -> bool:

xarray/tests/test_concat.py

@@ -9,7 +9,15 @@
 import pandas as pd
 import pytest
 
-from xarray import AlignmentError, DataArray, Dataset, Variable, concat, set_options
+from xarray import (
+    AlignmentError,
+    DataArray,
+    Dataset,
+    Variable,
+    concat,
+    open_dataset,
+    set_options,
+)
 from xarray.core import dtypes, types
 from xarray.core.coordinates import Coordinates
 from xarray.core.indexes import PandasIndex
@@ -23,6 +31,7 @@
     assert_identical,
     requires_dask,
     requires_pyarrow,
+    requires_scipy_or_netCDF4,
 )
 from xarray.tests.indexes import XYIndex
 from xarray.tests.test_dataset import create_test_data
@@ -1119,6 +1128,47 @@ def test_concat_promote_shape_without_creating_new_index(self) -> None:
         assert_identical(actual, expected, check_default_indexes=False)
         assert actual.indexes == {}
 
+    @requires_scipy_or_netCDF4
+    def test_concat_combine_attrs_nan_after_netcdf_roundtrip(self, tmp_path) -> None:
+        # Test for issue #10833: NaN attributes should be preserved
+        # with combine_attrs="drop_conflicts" after NetCDF roundtrip
+        import numpy as np
+
+        # Create arrays with matching NaN fill_value attribute
+        ds1 = Dataset(
+            {"a": ("x", [0, 1])},
+            attrs={"fill_value": np.nan, "sensor": "G18", "field": "CTH"},
+        )
+        ds2 = Dataset(
+            {"a": ("x", [2, 3])},
+            attrs={"fill_value": np.nan, "sensor": "G16", "field": "CTH"},
+        )
+
+        # Save to NetCDF and reload (converts Python float NaN to NumPy scalar NaN)
+        path1 = tmp_path / "ds1.nc"
+        path2 = tmp_path / "ds2.nc"
+        ds1.to_netcdf(path1)
+        ds2.to_netcdf(path2)
+
+        ds1_loaded = open_dataset(path1)
+        ds2_loaded = open_dataset(path2)
+
+        # Verify that NaN attributes are preserved after concat
+        actual = concat(
+            [ds1_loaded, ds2_loaded], dim="y", combine_attrs="drop_conflicts"
+        )
+
+        # fill_value should be preserved (not dropped) since both have NaN
+        assert "fill_value" in actual.attrs
+        assert np.isnan(actual.attrs["fill_value"])
+        # field should be preserved (identical in both)
+        assert actual.attrs["field"] == "CTH"
+        # sensor should be dropped (conflicts)
+        assert "sensor" not in actual.attrs
+
+        ds1_loaded.close()
+        ds2_loaded.close()
+
 
 class TestConcatDataArray:
     def test_concat(self) -> None:

xarray/tests/test_utils.py

@@ -80,6 +80,15 @@ def test_equivalent(self):
         assert utils.equivalent(np.array([0]), [0])
         assert utils.equivalent(np.arange(3), 1.0 * np.arange(3))
         assert not utils.equivalent(0, np.zeros(3))
+        # Test NaN comparisons (issue #10833)
+        # Python float NaN
+        assert utils.equivalent(float("nan"), float("nan"))
+        # NumPy scalar NaN (various dtypes)
+        assert utils.equivalent(np.float64(np.nan), np.float64(np.nan))
+        assert utils.equivalent(np.float32(np.nan), np.float32(np.nan))
+        # Mixed: Python float NaN vs NumPy scalar NaN
+        assert utils.equivalent(float("nan"), np.float64(np.nan))
+        assert utils.equivalent(np.float64(np.nan), float("nan"))
 
     def test_safe(self):
         # should not raise exception: