Merge branch 'main' into pixi-dust

VeckoTheGecko · web-flow · commit f779b8a2e7ca · 2025-11-11T16:46:21.000+01:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -24,7 +24,7 @@ repos:
       - id: rst-inline-touching-normal
       - id: text-unicode-replacement-char
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.1
+    rev: v0.14.3
     hooks:
       - id: ruff-check
         args: ["--fix", "--show-fixes"]
@@ -76,6 +76,6 @@ repos:
       - id: validate-pyproject
         additional_dependencies: ["validate-pyproject-schema-store[all]"]
   - repo: https://github.com/adhtruong/mirrors-typos
-    rev: v1.38.1
+    rev: v1.39.0
     hooks:
       - id: typos
diff --git a/design_notes/flexible_indexes_notes.md b/design_notes/flexible_indexes_notes.md
@@ -350,7 +350,7 @@ Indexes:
 
 To keep the `repr` compact, we could:
 
-- consolidate entries that map to the same index object, and have an short inline repr for `XarrayIndex` object
+- consolidate entries that map to the same index object, and have a short inline repr for `XarrayIndex` object
 - collapse the index section by default in the HTML `repr`
 - maybe omit all trivial indexes for 1D coordinates that match the dimension name
 
diff --git a/doc/user-guide/data-structures.rst b/doc/user-guide/data-structures.rst
@@ -360,7 +360,7 @@ in the dictionary:
 Where a pandas object is supplied as a value, the names of its indexes are used as dimension
 names, and its data is aligned to any existing dimensions.
 
-You can also create an dataset from:
+You can also create a dataset from:
 
 - A :py:class:`pandas.DataFrame` or ``pandas.Panel`` along its columns and items
   respectively, by passing it into the :py:class:`~xarray.Dataset` directly
@@ -559,7 +559,7 @@ nested dict-like containers of both :py:class:`xarray.DataArray`\s and :py:class
 A single datatree object is known as a "node", and its position relative to
 other nodes is defined by two more key properties:
 
-- ``children``: An dictionary mapping from names to other :py:class:`~xarray.DataTree`
+- ``children``: A dictionary mapping from names to other :py:class:`~xarray.DataTree`
   objects, known as its "child nodes".
 - ``parent``: The single :py:class:`~xarray.DataTree` object whose children this datatree is a
   member of, known as its "parent node".
diff --git a/doc/user-guide/hierarchical-data.rst b/doc/user-guide/hierarchical-data.rst
@@ -485,7 +485,7 @@ Operations and Methods on Trees
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To show how applying operations across a whole tree at once can be useful,
-let's first create a example scientific dataset.
+let's first create an example scientific dataset.
 
 .. jupyter-execute::
 
diff --git a/doc/user-guide/terminology.rst b/doc/user-guide/terminology.rst
@@ -64,7 +64,7 @@ complete examples, please consult the relevant documentation.*
         distinguish :term:`Dimension coordinate` vs. :term:`Non-dimension
         coordinate` and :term:`Indexed coordinate` vs. :term:`Non-indexed
         coordinate`. A coordinate named ``x`` can be retrieved from
-        ``arr.coords[x]``. A ``DataArray`` can have more coordinates than
+        ``arr.coords["x"]``. A ``DataArray`` can have more coordinates than
         dimensions because a single dimension can be labeled by multiple
         coordinate arrays. However, only one coordinate array can be assigned
         as a particular dimension's dimension coordinate array.
diff --git a/doc/whats-new.rst b/doc/whats-new.rst
@@ -19,6 +19,8 @@ New Features
   By `Stephan Hoyer <https://github.com/shoyer>`_.
 - The ``h5netcdf`` engine has support for pseudo ``NETCDF4_CLASSIC`` files, meaning variables and attributes are cast to supported types. Note that the saved files won't be recognized as genuine ``NETCDF4_CLASSIC`` files until ``h5netcdf`` adds support with version 1.7.0. (:issue:`10676`, :pull:`10686`).
   By `David Huard <https://github.com/huard>`_.
+- Support comparing :py:class:`DataTree` objects with :py:func:`testing.assert_allclose` (:pull:`10887`).
+  By `Justus Magin <https://github.com/keewis>`_.
 
 Breaking Changes
 ~~~~~~~~~~~~~~~~
@@ -39,6 +41,9 @@ Bug Fixes
   ``engine=`` argument. (:pull:`10804`). By `Ian Hunt-Isaak <https://github.com/ianhi>`_.
 - Fix indexing with empty arrays for scipy & h5netcdf backends which now resolves to empty slices (:issue:`10867`, :pull:`10870`).
   By `Kai Mühlbauer <https://github.com/kmuehlbauer>`_
+- Fix error handling issue in ``decode_cf_variables`` when decoding fails - the exception is now re-raised
+  correctly, with a note added about the variable name that caused the error (:issue:`10873`, :pull:`10886`).
+  By `Jonas L. Bertelsen <https://github.com/jonaslb>`_
 
 Performance
 ~~~~~~~~~~~
diff --git a/properties/test_pandas_roundtrip.py b/properties/test_pandas_roundtrip.py
@@ -163,7 +163,9 @@ def test_roundtrip_1d_pandas_extension_array(extension_array, is_index) -> None:
     df_arr_to_test = df.index if is_index else df["arr"]
     assert (df_arr_to_test == roundtripped).all()
     # `NumpyExtensionArray` types are not roundtripped, including `StringArray` which subtypes.
-    if isinstance(extension_array, pd.arrays.NumpyExtensionArray):  # type: ignore[attr-defined]
+    if isinstance(
+        extension_array, pd.arrays.NumpyExtensionArray | pd.arrays.ArrowStringArray
+    ):  # type: ignore[attr-defined]
         assert isinstance(arr.data, np.ndarray)
     else:
         assert (
diff --git a/xarray/backends/api.py b/xarray/backends/api.py
@@ -650,7 +650,7 @@ def open_dataarray(
     backend_kwargs: dict[str, Any] | None = None,
     **kwargs,
 ) -> DataArray:
-    """Open an DataArray from a file or file-like object containing a single
+    """Open a DataArray from a file or file-like object containing a single
     data variable.
 
     This is designed to read netCDF files with only one data variable. If
diff --git a/xarray/conventions.py b/xarray/conventions.py
@@ -422,7 +422,8 @@ def stackable(dim: Hashable) -> bool:
                 decode_timedelta=_item_or_default(decode_timedelta, k, None),
             )
         except Exception as e:
-            raise type(e)(f"Failed to decode variable {k!r}: {e}") from e
+            e.add_note(f"Raised while decoding variable {k!r} with value {v!r}")
+            raise
         if decode_coords in [True, "coordinates", "all"]:
             var_attrs = new_vars[k].attrs
             if "coordinates" in var_attrs:
diff --git a/xarray/convert.py b/xarray/convert.py
@@ -155,7 +155,7 @@ def _name(iris_obj, default="unknown"):
 
 
 def from_iris(cube):
-    """Convert a Iris cube into an DataArray"""
+    """Convert a Iris cube into a DataArray"""
     import iris.exceptions
 
     name = _name(cube)
diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
@@ -1506,13 +1506,18 @@ def __delitem__(self, key: Hashable) -> None:
     # https://github.com/python/mypy/issues/4266
     __hash__ = None  # type: ignore[assignment]
 
-    def _all_compat(self, other: Self, compat_str: str) -> bool:
+    def _all_compat(
+        self, other: Self, compat: str | Callable[[Variable, Variable], bool]
+    ) -> bool:
         """Helper function for equals and identical"""
 
-        # some stores (e.g., scipy) do not seem to preserve order, so don't
-        # require matching order for equality
-        def compat(x: Variable, y: Variable) -> bool:
-            return getattr(x, compat_str)(y)
+        if not callable(compat):
+            compat_str = compat
+
+            # some stores (e.g., scipy) do not seem to preserve order, so don't
+            # require matching order for equality
+            def compat(x: Variable, y: Variable) -> bool:
+                return getattr(x, compat_str)(y)
 
         return self._coord_names == other._coord_names and utils.dict_equiv(
             self._variables, other._variables, compat=compat
@@ -5428,7 +5433,7 @@ def _unstack_once(
             if name not in index_vars:
                 if dim in var.dims:
                     if isinstance(fill_value, Mapping):
-                        fill_value_ = fill_value[name]
+                        fill_value_ = fill_value.get(name, xrdtypes.NA)
                     else:
                         fill_value_ = fill_value
 
diff --git a/xarray/core/indexing.py b/xarray/core/indexing.py
@@ -977,7 +977,7 @@ def __setitem__(self, indexer: ExplicitIndexer, value: Any) -> None:
 
 def as_indexable(array):
     """
-    This function always returns a ExplicitlyIndexed subclass,
+    This function always returns an ExplicitlyIndexed subclass,
     so that the vectorized indexing is always possible with the returned
     object.
     """
@@ -1315,7 +1315,7 @@ def _decompose_outer_indexer(
     arrays that only support basic or outer indexing.
 
     As an example, let us consider to index a few elements from a backend array
-    with a orthogonal indexer ([0, 3, 1], [2, 3, 2]).
+    with an orthogonal indexer ([0, 3, 1], [2, 3, 2]).
     Even if the backend array only supports basic indexing, it is more
     efficient to load a subslice of the array than loading the entire array,
 
diff --git a/xarray/core/treenode.py b/xarray/core/treenode.py
@@ -49,7 +49,7 @@ class TreeNode:
 
     This class stores no data, it has only parents and children attributes, and various methods.
 
-    Stores child nodes in an dict, ensuring that equality checks between trees
+    Stores child nodes in a dict, ensuring that equality checks between trees
     and order of child nodes is preserved (since python 3.7).
 
     Nodes themselves are intrinsically unnamed (do not possess a ._name attribute), but if the node has a parent you can
diff --git a/xarray/core/utils.py b/xarray/core/utils.py
@@ -900,7 +900,7 @@ def __len__(self) -> int:
 
 
 def get_temp_dimname(dims: Container[Hashable], new_dim: Hashable) -> Hashable:
-    """Get an new dimension name based on new_dim, that is not used in dims.
+    """Get a new dimension name based on new_dim, that is not used in dims.
     If the same name exists, we add an underscore(s) in the head.
 
     Example1:
diff --git a/xarray/plot/utils.py b/xarray/plot/utils.py
@@ -100,27 +100,22 @@ def _build_discrete_cmap(cmap, levels, extend, filled):
 
     # copy colors to use for bad, under, and over values in case they have been
     # set to non-default values
-    try:
-        # matplotlib<3.2 only uses bad color for masked values
-        bad = cmap(np.ma.masked_invalid([np.nan]))[0]
-    except TypeError:
-        # cmap was a str or list rather than a color-map object, so there are
-        # no bad, under or over values to check or copy
-        pass
-    else:
-        under = cmap(-np.inf)
-        over = cmap(np.inf)
-
-        new_cmap.set_bad(bad)
+    if isinstance(cmap, mpl.colors.Colormap):
+        bad = cmap(np.nan)
 
         # Only update under and over if they were explicitly changed by the user
         # (i.e. are different from the lowest or highest values in cmap). Otherwise
         # leave unchanged so new_cmap uses its default values (its own lowest and
         # highest values).
-        if under != cmap(0):
-            new_cmap.set_under(under)
-        if over != cmap(cmap.N - 1):
-            new_cmap.set_over(over)
+        under = cmap(-np.inf)
+        if under == cmap(0):
+            under = None
+
+        over = cmap(np.inf)
+        if over == cmap(cmap.N - 1):
+            over = None
+
+        new_cmap = new_cmap.with_extremes(bad=bad, under=under, over=over)
 
     return new_cmap, cnorm
 
diff --git a/xarray/testing/assertions.py b/xarray/testing/assertions.py
@@ -239,6 +239,11 @@ def compat_variable(a, b):
         b = getattr(b, "variable", b)
         return a.dims == b.dims and (a._data is b._data or equiv(a.data, b.data))
 
+    def compat_node(a, b):
+        return a.ds._coord_names == b.ds._coord_names and utils.dict_equiv(
+            a.variables, b.variables, compat=compat_variable
+        )
+
     if isinstance(a, Variable):
         allclose = compat_variable(a, b)
         assert allclose, formatting.diff_array_repr(a, b, compat=equiv)
@@ -255,6 +260,11 @@ def compat_variable(a, b):
     elif isinstance(a, Coordinates):
         allclose = utils.dict_equiv(a.variables, b.variables, compat=compat_variable)
         assert allclose, formatting.diff_coords_repr(a, b, compat=equiv)
+    elif isinstance(a, DataTree):
+        allclose = utils.dict_equiv(
+            dict(a.subtree_with_keys), dict(b.subtree_with_keys), compat=compat_node
+        )
+        assert allclose, formatting.diff_datatree_repr(a, b, compat=equiv)
     else:
         raise TypeError(f"{type(a)} not supported by assertion comparison")
 
diff --git a/xarray/tests/test_assertions.py b/xarray/tests/test_assertions.py
@@ -62,6 +62,19 @@ def test_allclose_regression() -> None:
             xr.Coordinates({"x": [0, 3]}),
             id="Coordinates",
         ),
+        pytest.param(
+            xr.DataTree.from_dict(
+                {
+                    "/b": xr.Dataset({"a": ("x", [1e-17, 2]), "b": ("y", [-2e-18, 2])}),
+                }
+            ),
+            xr.DataTree.from_dict(
+                {
+                    "/b": xr.Dataset({"a": ("x", [0, 2]), "b": ("y", [0, 1])}),
+                }
+            ),
+            id="DataTree",
+        ),
     ),
 )
 def test_assert_allclose(obj1, obj2) -> None:
diff --git a/xarray/tests/test_conventions.py b/xarray/tests/test_conventions.py
@@ -658,8 +658,11 @@ def test_scalar_units() -> None:
 
 
 def test_decode_cf_error_includes_variable_name():
-    ds = Dataset({"invalid": ([], 1e36, {"units": "days since 2000-01-01"})})
-    with pytest.raises(ValueError, match="Failed to decode variable 'invalid'"):
+    ds = Dataset({"my_invalid_var": ([], 1e36, {"units": "days since 2000-01-01"})})
+    with pytest.raises(
+        ValueError,
+        match=r"unable to decode(?s:.*)my_invalid_var",
+    ):
         decode_cf(ds)
 
 
diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py
@@ -4150,6 +4150,10 @@ def test_unstack_fill_value(self) -> None:
         expected3 = ds.unstack("index").fillna({"var": -1, "other_var": 1}).astype(int)
         assert_equal(actual3, expected3)
 
+        actual4 = ds.unstack("index", fill_value={"var": -1})
+        expected4 = ds.unstack("index").fillna({"var": -1, "other_var": np.nan})
+        assert_equal(actual4, expected4)
+
     @requires_sparse
     def test_unstack_sparse(self) -> None:
         ds = xr.Dataset(
diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py
@@ -482,21 +482,20 @@ def test_contourf_cmap_set(self) -> None:
     def test_contourf_cmap_set_with_bad_under_over(self) -> None:
         a = DataArray(easy_array((4, 4)), dims=["z", "time"])
 
-        # make a copy here because we want a local cmap that we will modify.
-        cmap_expected = copy(mpl.colormaps["viridis"])
+        # make a copy using with_extremes because we want a local cmap:
+        cmap_expected = mpl.colormaps["viridis"].with_extremes(
+            bad="w", under="r", over="g"
+        )
 
-        cmap_expected.set_bad("w")
         # check we actually changed the set_bad color
         assert np.all(
             cmap_expected(np.ma.masked_invalid([np.nan]))[0]
             != mpl.colormaps["viridis"](np.ma.masked_invalid([np.nan]))[0]
         )
 
-        cmap_expected.set_under("r")
         # check we actually changed the set_under color
         assert cmap_expected(-np.inf) != mpl.colormaps["viridis"](-np.inf)
 
-        cmap_expected.set_over("g")
         # check we actually changed the set_over color
         assert cmap_expected(np.inf) != mpl.colormaps["viridis"](-np.inf)
 
