cf-xarray 0.10.11__tar.gz → 0.11.1__tar.gz

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/.github/workflows/ci.yaml

@@ -58,7 +58,7 @@ jobs:
           pytest -n auto --cov=./ --cov-report=xml
 
       - name: Upload code coverage to Codecov
-        uses: codecov/codecov-action@v5.5.2
+        uses: codecov/codecov-action@v6.0.0
         with:
           file: ./coverage.xml
           flags: unittests
@@ -98,7 +98,7 @@ jobs:
           python -m mypy --install-types --non-interactive --cobertura-xml-report mypy_report cf_xarray/
 
       - name: Upload mypy coverage to Codecov
-        uses: codecov/codecov-action@v5.5.2
+        uses: codecov/codecov-action@v6.0.0
         with:
           file: mypy_report/cobertura.xml
           flags: mypy

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/.github/workflows/pypi.yaml

@@ -41,7 +41,7 @@ jobs:
           else
             echo "✅ Looks good"
           fi
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: releases
           path: dist
@@ -54,7 +54,7 @@ jobs:
         name: Install Python
         with:
           python-version: "3.11"
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           name: releases
           path: dist
@@ -72,7 +72,7 @@ jobs:
 
       - name: Publish package to TestPyPI
         if: github.event_name == 'push'
-        uses: pypa/gh-action-pypi-publish@v1.13.0
+        uses: pypa/gh-action-pypi-publish@v1.14.0
         with:
           password: ${{ secrets.TESTPYPI_TOKEN }}
           repository_url: https://test.pypi.org/legacy/
@@ -91,11 +91,11 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           name: releases
           path: dist
       - name: Publish package to PyPI
-        uses: pypa/gh-action-pypi-publish@v1.13.0
+        uses: pypa/gh-action-pypi-publish@v1.14.0
         with:
           verbose: true

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/.github/workflows/testpypi-release.yaml

@@ -53,7 +53,7 @@ jobs:
             echo "✅ Looks good"
           fi
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: releases
           path: dist
@@ -66,7 +66,7 @@ jobs:
         name: Install Python
         with:
           python-version: "3.11"
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           name: releases
           path: dist

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/.pre-commit-config.yaml

@@ -10,7 +10,7 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.14.10'
+    rev: 'v0.15.9'
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]
@@ -55,7 +55,7 @@ repos:
     - id: validate-cff
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.24.1
+    rev: v0.25
     hooks:
       - id: validate-pyproject
 

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.10.11
+Version: 0.11.1
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004

cf_xarray-0.11.1/cf_xarray/_version.py

@@ -0,0 +1 @@
+__version__ = "0.11.1"

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/cf_xarray/accessor.py

@@ -27,6 +27,7 @@ import xarray as xr
 from xarray import DataArray, Dataset
 from xarray.core.groupby import GroupBy
 from xarray.core.resample import Resample
+from xarray.core.utils import Frozen
 
 try:
     from xarray.core.rolling import (  # type:ignore[import-not-found,no-redef,unused-ignore]
@@ -48,6 +49,11 @@ except ImportError:
         Weighted,
     )
 
+try:
+    from regex import match as regex_match
+except ImportError:
+    from re import match as regex_match  # type: ignore[no-redef]
+
 
 from . import parametric, sgrid
 from .criteria import (
@@ -305,12 +311,6 @@ def _get_custom_criteria(
     List[str]
         Variable name(s) in parent xarray object that matches axis, coordinate, or custom ``key``
     """
-
-    try:
-        from regex import match as regex_match
-    except ImportError:
-        from re import match as regex_match  # type: ignore[no-redef]
-
     if criteria is None:
         if not OPTIONS["custom_criteria"]:
             return []
@@ -496,7 +496,10 @@ def _get_bounds(obj: DataArray | Dataset, key: Hashable) -> list[Hashable]:
     return list(results)
 
 
-def _parse_grid_mapping_attribute(grid_mapping_attr: str) -> dict[str, list[Hashable]]:
+@functools.lru_cache(maxsize=256)
+def _parse_grid_mapping_attribute(
+    grid_mapping_attr: str,
+) -> Mapping[str, list[Hashable]]:
     """
     Parse a grid_mapping attribute that may contain multiple grid mappings.
 
@@ -508,11 +511,12 @@ def _parse_grid_mapping_attribute(grid_mapping_attr: str) -> dict[str, list[Hash
     - Multiple: "spatial_ref: crs_4326: latitude longitude crs_27700: x27700 y27700"
       -> {"spatial_ref": [], "crs_4326": ["latitude", "longitude"], "crs_27700": ["x27700", "y27700"]}
 
-    Returns a dictionary mapping grid mapping variable names to their associated coordinate variables.
+    Returns a read-only mapping from grid mapping variable name to its associated
+    coordinate variables. The result is memoized, so callers must not mutate it.
     """
     # Check if there are colons indicating multiple mappings
     if ":" not in grid_mapping_attr:
-        return {grid_mapping_attr.strip(): []}
+        return Frozen({grid_mapping_attr.strip(): []})
 
     # Use regex to parse the format
     # First, find all grid mapping variables (words before colons)
@@ -520,7 +524,7 @@ def _parse_grid_mapping_attribute(grid_mapping_attr: str) -> dict[str, list[Hash
     grid_mappings = re.findall(grid_pattern, grid_mapping_attr)
 
     if not grid_mappings:
-        return {grid_mapping_attr.strip(): []}
+        return Frozen({grid_mapping_attr.strip(): []})
 
     result: dict[str, list[Hashable]] = {}
 
@@ -549,13 +553,13 @@ def _parse_grid_mapping_attribute(grid_mapping_attr: str) -> dict[str, list[Hash
         else:
             result[gm] = []
 
-    return result
+    return Frozen(result)
 
 
 def _create_grid_mapping(
     var_name: str,
     ds: Dataset,
-    grid_mapping_dict: dict[str, list[Hashable]],
+    grid_mapping_dict: Mapping[str, list[Hashable]],
 ) -> GridMapping:
     """
     Create a GridMapping dataclass instance from a grid mapping variable.
@@ -1008,7 +1012,11 @@ def _getattr(
             newmap.update(dict.fromkeys(inverted[key], value))
         newmap.update({key: attribute[key] for key in unused_keys})
 
-        skip: dict[str, list[Literal["coords", "measures"]] | None] = {
+        skip: dict[
+            str,
+            list[Literal["coords", "measures", "grid_mapping_names", "geometries"]]
+            | None,
+        ] = {
             "data_vars": ["coords"],
             "coords": None,
         }
@@ -1049,7 +1057,8 @@ def _getattr(
 def _getitem(
     accessor: CFAccessor,
     key: Hashable,
-    skip: list[Literal["coords", "measures"]] | None = None,
+    skip: list[Literal["coords", "measures", "grid_mapping_names", "geometries"]]
+    | None = None,
 ) -> DataArray: ...
 
 
@@ -1057,14 +1066,16 @@ def _getitem(
 def _getitem(
     accessor: CFAccessor,
     key: Iterable[Hashable],
-    skip: list[Literal["coords", "measures"]] | None = None,
+    skip: list[Literal["coords", "measures", "grid_mapping_names", "geometries"]]
+    | None = None,
 ) -> Dataset: ...
 
 
 def _getitem(
     accessor: CFAccessor,
     key: Hashable | Iterable[Hashable],
-    skip: list[Literal["coords", "measures"]] | None = None,
+    skip: list[Literal["coords", "measures", "grid_mapping_names", "geometries"]]
+    | None = None,
 ):
     """
     Index into obj using key. Attaches CF associated variables.
@@ -1078,9 +1089,14 @@ def _getitem(
     """
 
     obj = accessor._obj
-    all_bounds = obj.cf.bounds if isinstance(obj, Dataset) else {}
     kind = str(type(obj).__name__)
     scalar_key = isinstance(key, Hashable)
+    # obj.cf.bounds is expensive; only compute it when scalar lookup on a
+    # Dataset actually needs to drop bounds variables.
+    if not isinstance(obj, DataArray) and scalar_key:
+        all_bounds = obj.cf.bounds
+    else:
+        all_bounds = {}
 
     key_iter: Iterable[Hashable]
     if isinstance(key, Hashable):  # using scalar_key breaks mypy type narrowing
@@ -1128,60 +1144,90 @@ def _getitem(
 
     custom_criteria = ChainMap(*OPTIONS["custom_criteria"])
 
-    varnames: list[Hashable] = []
-    coords: list[Hashable] = []
-    successful = dict.fromkeys(key_iter, False)
-    for k in key_iter:
-        if "coords" not in skip and k in _AXIS_NAMES + _COORD_NAMES:
-            names = _get_all(obj, k)
-            names = drop_bounds(names)
-            check_results(names, k)
-            successful[k] = bool(names)
-            coords.extend(names)
-        elif "measures" not in skip and k in measures:
-            measure = _get_all(obj, k)
-            check_results(measure, k)
-            successful[k] = bool(measure)
-            if measure:
-                varnames.extend(measure)
-        elif "grid_mapping_names" not in skip and k in grid_mapping_names:
-            grid_mapping = _get_all(obj, k)
-            check_results(grid_mapping, k)
-            successful[k] = bool(grid_mapping)
-            if grid_mapping:
-                varnames.extend(grid_mapping)
-        elif "geometries" not in skip and (k == "geometry" or k in _GEOMETRY_TYPES):
-            geometries = _get_all(obj, k)
-            if geometries and k in _GEOMETRY_TYPES:
-                new = itertools.chain(
-                    _parse_related_geometry_vars(
-                        ChainMap(obj[g].attrs, obj[g].encoding)
+    # Fast path: when every key is just a plain variable in the Dataset (no CF
+    # special meaning), skip the per-key classification loop below. Test the
+    # cheap predicates first and only build the reserved-name set / consult
+    # accessor.standard_names (a full attrs scan) if those could pass — the
+    # common ds.cf["X"] / ds.cf["longitude"] paths must not pay that cost.
+    fast_path = (
+        isinstance(obj, Dataset)
+        and not skip
+        and all(k in obj._variables for k in key_iter)
+    )
+    if fast_path:
+        reserved: set[Hashable] = set(_AXIS_NAMES).union(
+            _COORD_NAMES,
+            _GEOMETRY_TYPES,
+            ("geometry",),
+            measures,
+            grid_mapping_names,
+            custom_criteria,
+            cf_role_criteria,
+        )
+        standard_names = accessor.standard_names
+        fast_path = all(k not in reserved and k not in standard_names for k in key_iter)
+
+    varnames: list[Hashable]
+    coords: list[Hashable]
+    if fast_path:
+        varnames = list(key_iter)
+        coords = []
+        successful = dict.fromkeys(key_iter, True)
+    else:
+        varnames = []
+        coords = []
+        successful = dict.fromkeys(key_iter, False)
+        for k in key_iter:
+            if "coords" not in skip and k in _AXIS_NAMES + _COORD_NAMES:
+                names = _get_all(obj, k)
+                names = drop_bounds(names)
+                check_results(names, k)
+                successful[k] = bool(names)
+                coords.extend(names)
+            elif "measures" not in skip and k in measures:
+                measure = _get_all(obj, k)
+                check_results(measure, k)
+                successful[k] = bool(measure)
+                if measure:
+                    varnames.extend(measure)
+            elif "grid_mapping_names" not in skip and k in grid_mapping_names:
+                grid_mapping = _get_all(obj, k)
+                check_results(grid_mapping, k)
+                successful[k] = bool(grid_mapping)
+                if grid_mapping:
+                    varnames.extend(grid_mapping)
+            elif "geometries" not in skip and (k == "geometry" or k in _GEOMETRY_TYPES):
+                geometries = _get_all(obj, k)
+                if geometries and k in _GEOMETRY_TYPES:
+                    new = itertools.chain(
+                        _parse_related_geometry_vars(
+                            ChainMap(obj[g].attrs, obj[g].encoding)
+                        )
+                        for g in geometries
                     )
-                    for g in geometries
-                )
-                geometries.extend(*new)
-            if len(geometries) > 1 and scalar_key:
-                raise ValueError(
-                    f"CF geometries must be represented by an Xarray Dataset. To request a Dataset in return please pass `[{k!r}]` instead."
-                )
-            successful[k] = bool(geometries)
-            if geometries:
-                varnames.extend(geometries)
-        elif k in custom_criteria or k in cf_role_criteria:
-            names = _get_all(obj, k)
-            check_results(names, k)
-            successful[k] = bool(names)
-            varnames.extend(names)
-        else:
-            stdnames = set(_get_with_standard_name(obj, k))
-            objcoords = set(obj.coords)
-            stdnames = drop_bounds(stdnames)
-            if "coords" in skip:
-                stdnames -= objcoords
-            check_results(stdnames, k)
-            successful[k] = bool(stdnames)
-            varnames.extend(stdnames - objcoords)
-            coords.extend(stdnames & objcoords)
+                    geometries.extend(*new)
+                if len(geometries) > 1 and scalar_key:
+                    raise ValueError(
+                        f"CF geometries must be represented by an Xarray Dataset. To request a Dataset in return please pass `[{k!r}]` instead."
+                    )
+                successful[k] = bool(geometries)
+                if geometries:
+                    varnames.extend(geometries)
+            elif k in custom_criteria or k in cf_role_criteria:
+                names = _get_all(obj, k)
+                check_results(names, k)
+                successful[k] = bool(names)
+                varnames.extend(names)
+            else:
+                stdnames = set(_get_with_standard_name(obj, k))
+                objcoords = set(obj.coords)
+                stdnames = drop_bounds(stdnames)
+                if "coords" in skip:
+                    stdnames -= objcoords
+                check_results(stdnames, k)
+                successful[k] = bool(stdnames)
+                varnames.extend(stdnames - objcoords)
+                coords.extend(stdnames & objcoords)
 
     # these are not special names but could be variable names in underlying object
     # we allow this so that we can return variables with appropriate CF auxiliary variables
@@ -1814,10 +1860,6 @@ class CFAccessor:
                         for k, v in value.items()
                     )
                 )
-
-            elif value is Ellipsis:
-                pass
-
             else:
                 # things like sum which have dim
                 newvalue = [
@@ -2047,7 +2089,7 @@ class CFAccessor:
             ]
         as_dataset = self._maybe_to_dataset().reset_coords()
 
-        keys = {}
+        keys: dict[str, str] = {}
         for attr in set(all_attrs):
             try:
                 keys.update(parse_cell_methods_attr(attr))
@@ -2840,14 +2882,38 @@ class CFDatasetAccessor(CFAccessor):
         """
 
         obj = self._obj
-        keys = self.keys() | set(obj.variables)
+        variables = obj._variables
+
+        # Single linear scan to discover which variables in the dataset have
+        # a ``bounds`` attribute pointing at another existing variable. The
+        # naive implementation called ``apply_mapper(_get_bounds, ...)`` for
+        # every key in ``self.keys() | set(variables)``, which itself fans
+        # out through ``_get_all`` and runs the regex criteria against every
+        # variable's attrs. That is O(num_keys × num_vars × num_criteria)
+        # for an answer that is structurally a single attribute lookup.
+        var_to_bounds: dict[Hashable, Hashable] = {}
+        for name, var in variables.items():
+            attrs_or_encoding = ChainMap(var.attrs, var.encoding)
+            bounds_name = attrs_or_encoding.get("bounds")
+            if bounds_name is not None and bounds_name in variables:
+                var_to_bounds[name] = bounds_name
+
+        if not var_to_bounds:
+            return {}
 
-        vardict = {
-            key: self._drop_missing_variables(
-                apply_mapper(_get_bounds, obj, key, error=False)
-            )
-            for key in keys
-        }
+        vardict: dict[Hashable, set[Hashable]] = {}
+        # Direct variable-name keys: O(1) lookup, no mapper machinery.
+        for name, bounds_name in var_to_bounds.items():
+            vardict[name] = {bounds_name}
+
+        # CF keys (axes, coordinate names, custom criteria, ...): resolve to
+        # their target variable names once, then read the precomputed
+        # ``var_to_bounds`` map. ``_get_bounds`` is no longer invoked.
+        for key in self.keys() - set(variables):
+            target_vars = apply_mapper(_get_all, obj, key, error=False, default=[])
+            bounds_vars = {var_to_bounds[v] for v in target_vars if v in var_to_bounds}
+            if bounds_vars:
+                vardict[key] = bounds_vars
 
         return {k: sort_maybe_hashable(v) for k, v in vardict.items() if v}
 

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/cf_xarray/helpers.py

@@ -17,24 +17,23 @@ def _guess_bounds_1d(da, dim):
     """
     if dim not in da.dims:
         (dim,) = da.cf.axes[dim]
-    ADDED_INDEX = False
-    if dim not in da.coords:
-        # For proper alignment in the lines below, we need an index on dim.
-        da = da.assign_coords({dim: da[dim]})
-        ADDED_INDEX = True
-
-    diff = da.diff(dim)
-    lower = da - diff / 2
-    upper = da + diff / 2
-    bounds = xr.concat([lower, upper], dim="bounds")
-
-    first = (bounds.isel({dim: 0}) - diff.isel({dim: 0})).assign_coords(
-        {dim: da[dim][0]}
+
+    bound_position = 0.5
+
+    diff = da.diff(dim).pad({dim: (1, 1)}, mode="edge")
+    lower = da.copy(
+        deep=False,
+        data=da.data - bound_position * diff.isel({dim: slice(0, -1)}).data,
+    )
+    upper = da.copy(
+        deep=False,
+        data=da.data + bound_position * diff.isel({dim: slice(1, None)}).data,
+    )
+    return (
+        xr.concat([lower, upper], dim="bounds")
+        .transpose(..., "bounds")
+        .drop_attrs(deep=False)
     )
-    result = xr.concat([first, bounds], dim=dim).transpose(..., "bounds")
-    if ADDED_INDEX:
-        result = result.drop_vars(dim)
-    return result.drop_attrs(deep=False)
 
 
 def _guess_bounds_2d(da, dims):

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/cf_xarray/tests/test_accessor.py

@@ -3,6 +3,7 @@ import pickle
 import warnings
 from textwrap import dedent
 
+import dask.array
 import matplotlib as mpl
 import numpy as np
 import pandas as pd
@@ -839,6 +840,51 @@ def test_add_bounds(dims):
     _check_unchanged(original, ds)
 
 
+def test_add_bounds_preserves_array_type() -> None:
+    # Test that the array type of the bounds variable is the same as the original variable.
+    ds = airds
+    original = ds.copy(deep=True)
+    ds = ds.drop_indexes("lat").rename_dims(lat="x")
+    ds["lat"] = ds.lat.copy(data=dask.array.asarray(ds.lat.data))
+    added = ds.cf.add_bounds("lat")
+
+    assert isinstance(added.lat.data, dask.array.Array)
+    assert isinstance(added.lat_bounds.data, dask.array.Array)
+
+    assert isinstance(ds.lat.data, dask.array.Array)
+    _check_unchanged(original, ds)
+
+
+def test_add_irregularly_spaced_bounds_do_not_overlap() -> None:
+    # Test that added bounds with irregular spacing do not overlap.
+    ds = airds
+    original = ds.copy(deep=True)
+    ds["time"] = ds["time"].copy(data=pd.date_range("2013-01", "2013-04", freq="MS"))
+    expected = xr.DataArray(
+        data=[
+            pd.to_datetime(t)
+            for t in [
+                ["2012-12-16T12", "2013-01-16T12"],
+                ["2013-01-16T12", "2013-02-15T00"],
+                ["2013-02-15T00", "2013-03-16T12"],
+                ["2013-03-16T12", "2013-04-16T12"],
+            ]
+        ],
+        dims=["time", "bounds"],
+        name="time_bounds",
+        coords={"time": ds.time.data},
+    )
+    added = ds.copy(deep=False)
+    added = added.cf.add_bounds("time")
+
+    name = "time_bounds"
+    assert name in added.coords
+    assert added["time"].attrs["bounds"] == name
+    assert_allclose(added[name].reset_coords(drop=True), expected)
+
+    _check_unchanged(original, ds)
+
+
 def test_add_bounds_multiple() -> None:
     # Test multiple dimensions
     assert not {"x1_bounds", "x2_bounds"} <= set(multiple.variables)
@@ -853,7 +899,7 @@ def test_add_bounds_nd_variable() -> None:
 
     # 2D
     expected = (
-        vertices_to_bounds(  # type: ignore[misc]
+        vertices_to_bounds(
             xr.DataArray(
                 np.arange(0, 13, 3).reshape(5, 1) + np.arange(-2, 2).reshape(1, 4),
                 dims=("x", "y"),
@@ -861,7 +907,7 @@ def test_add_bounds_nd_variable() -> None:
             out_dims=("bounds", "x", "y"),
         )
         .rename("z_bounds")
-        .assign_coords(**ds.coords)
+        .assign_coords(**ds.coords)  # type: ignore[arg-type]
     )
     actual = ds.cf.add_bounds("z").z_bounds.reset_coords(drop=True)
     xr.testing.assert_identical(actual, expected)
@@ -882,11 +928,11 @@ def test_add_bounds_nd_variable() -> None:
     expected = (
         xr.concat([ds.z - 1.5, ds.z + 1.5], dim="bounds")
         .rename("z_bounds")
-        .transpose("bounds", "y", "x")
+        .transpose(..., "bounds")
     )
 
     actual = ds.cf.add_bounds("z", dim="x").z_bounds.reset_coords(drop=True)
-    xr.testing.assert_identical(expected.transpose(..., "bounds"), actual)
+    xr.testing.assert_identical(expected, actual)
 
     # Requesting bounds on a non-variable dimension
     with pytest.raises(ValueError, match="are dimensions with no index."):

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/cf_xarray/utils.py

@@ -1,13 +1,15 @@
+import functools
 import inspect
 import os
 import warnings
 from collections import defaultdict
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from typing import Any
 from xml.etree import ElementTree
 
 import numpy as np
 from xarray import DataArray
+from xarray.core.utils import Frozen
 
 try:
     import cftime
@@ -64,7 +66,8 @@ def _is_datetime_like(da: DataArray) -> bool:
     return False
 
 
-def parse_cell_methods_attr(attr: str) -> dict[str, str]:
+@functools.lru_cache(maxsize=256)
+def parse_cell_methods_attr(attr: str) -> Mapping[str, str]:
     """
     Parse cell_methods attributes (format is 'measure: name').
 
@@ -75,14 +78,14 @@ def parse_cell_methods_attr(attr: str) -> dict[str, str]:
 
     Returns
     -------
-    Dictionary mapping measure to name
+    Read-only mapping from measure to name.
     """
     strings = [s for scolons in attr.split(":") for s in scolons.split()]
     if len(strings) % 2 != 0:
         raise ValueError(f"attrs['cell_measures'] = {attr!r} is malformed.")
 
-    return dict(
-        zip(strings[slice(0, None, 2)], strings[slice(1, None, 2)], strict=False)
+    return Frozen(
+        dict(zip(strings[slice(0, None, 2)], strings[slice(1, None, 2)], strict=False))
     )
 
 

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/cf_xarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.10.11
+Version: 0.11.1
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004

{cf_xarray-0.10.11 → cf_xarray-0.11.1}/doc/index.rst

@@ -35,7 +35,7 @@ or using ``conda``
    examples/introduction
    EarthCube 2021 demo <https://earthcube2021.github.io/ec21_book/notebooks/ec21_cherian_etal/DC_01_cf-xarray.html>
    CESM ocean model demo <https://pop-tools.readthedocs.io/en/latest/examples/cesm-cmip-cf-xarray.html>
-   COSIMA ocean-sea ice model demo <https://cosima-recipes.readthedocs.io/en/latest/Tutorials/Model_Agnostic_Analysis.html>
+   COSIMA ocean-sea ice model demo <https://cosima-recipes.readthedocs.io/en/latest/01-Cooking-Lessons-101/02-Advanced/Model_Agnostic_Analysis.html>
 
 .. toctree::
    :maxdepth: 2