cf-xarray 0.11.0__tar.gz → 0.11.2__tar.gz

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/PKG-INFO

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

cf_xarray-0.11.2/cf_xarray/_version.py

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

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/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]
@@ -495,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.
 
@@ -507,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)
@@ -519,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]] = {}
 
@@ -548,13 +553,44 @@ def _parse_grid_mapping_attribute(grid_mapping_attr: str) -> dict[str, list[Hash
         else:
             result[gm] = []
 
-    return result
+    return Frozen(result)
+
+
+def _hashable_attrs(attrs: Mapping[Any, Any]) -> tuple:
+    """Return a hashable, order-independent representation of an attrs mapping.
+
+    List- and array-valued attributes (e.g. ``standard_parallel``) are coerced
+    to tuples so the result can be used as an ``lru_cache`` key.
+    """
+    frozen = []
+    for key, value in attrs.items():
+        if hasattr(value, "tolist"):  # numpy scalars/arrays
+            value = value.tolist()
+        if isinstance(value, list | tuple):
+            value = tuple(value)
+        frozen.append((key, value))
+    frozen.sort(key=lambda kv: repr(kv[0]))
+    return tuple(frozen)
+
+
+@functools.lru_cache(maxsize=256)
+def _crs_from_cf_attrs(attrs_items: tuple) -> Any:
+    """Build a ``pyproj.CRS`` from frozen CF grid-mapping attrs (memoized).
+
+    ``pyproj.CRS.from_cf`` re-parses the datum/ellipsoid on every call, which is
+    expensive for grid mappings carrying explicit ellipsoid parameters (e.g.
+    geostationary). A dataset routinely references the same grid mapping from
+    many variables, so cache on the attribute items.
+    """
+    import pyproj
+
+    return pyproj.CRS.from_cf(dict(attrs_items))
 
 
 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.
@@ -664,7 +700,7 @@ def _create_grid_mapping(
             }
         )
     else:
-        crs = pyproj.CRS.from_cf(var.attrs)
+        crs = _crs_from_cf_attrs(_hashable_attrs(var.attrs))
 
     # Get associated coordinate variables, fallback to dimension names
     coordinates: list[Hashable] = grid_mapping_dict.get(var_name, [])
@@ -1007,7 +1043,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,
         }
@@ -1048,7 +1088,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: ...
 
 
@@ -1056,14 +1097,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.
@@ -1077,9 +1120,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
@@ -1127,60 +1175,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
@@ -2029,20 +2107,17 @@ class CFAccessor:
         """
 
         obj = self._obj
+        if isinstance(obj, DataArray):
+            variables = [*obj.coords.variables.values(), obj.variable]
+        else:
+            variables = list(obj.variables.values())
         all_attrs = [
-            ChainMap(da.attrs, da.encoding).get("cell_measures", "")
-            for da in obj.coords.values()
+            ChainMap(var.attrs, var.encoding).get("cell_measures", "")
+            for var in variables
         ]
-        if isinstance(obj, DataArray):
-            all_attrs += [ChainMap(obj.attrs, obj.encoding).get("cell_measures", "")]
-        elif isinstance(obj, Dataset):
-            all_attrs += [
-                ChainMap(da.attrs, da.encoding).get("cell_measures", "")
-                for da in obj.data_vars.values()
-            ]
         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))
@@ -2222,6 +2297,8 @@ class CFAccessor:
 
         if grid := attrs_or_encoding.get("grid", None):
             coords["grid"] = [grid]
+            if isinstance(self._obj, Dataset):
+                coords["coordinates"].extend(sgrid.get_topology_coords(self._obj, grid))
 
         if grid_mapping_attr := attrs_or_encoding.get("grid_mapping", None):
             # Parse grid mapping variables and their coordinates
@@ -2835,14 +2912,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.11.0 → cf_xarray-0.11.2}/cf_xarray/sgrid.py

@@ -11,6 +11,31 @@ SGRID_DIM_ATTRS = [
     # "edge3_dimensions",
 ]
 
+SGRID_COORD_ATTRS = [
+    "node_coordinates",
+    "face_coordinates",
+    "edge1_coordinates",
+    "edge2_coordinates",
+    "volume_coordinates",
+]
+
+
+def get_topology_coords(ds, grid_var_name):
+    """Return coordinate variable names referenced by an SGRID topology variable.
+
+    Reads ``node_coordinates``, ``face_coordinates``, ``edge{1,2}_coordinates``,
+    and ``volume_coordinates`` from the topology variable's attrs and filters
+    to names that are actually present in ``ds``.
+    """
+    if grid_var_name not in ds.variables:
+        return []
+    grid_attrs = ds[grid_var_name].attrs
+    names: list[str] = []
+    for attr_name in SGRID_COORD_ATTRS:
+        if coord_str := grid_attrs.get(attr_name):
+            names.extend(n for n in coord_str.split() if n in ds.variables)
+    return names
+
 
 def parse_axes(ds):
     import re

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/cf_xarray/tests/test_accessor.py

@@ -1254,6 +1254,44 @@ def test_grid_mappings_property():
             assert gm.coordinates == ("x", "y")
 
 
+@requires_pyproj
+def test_grid_mappings_crs_construction_is_cached(monkeypatch):
+    """``pyproj.CRS.from_cf`` is memoized per grid-mapping attrs.
+
+    Building the CRS re-parses the datum/ellipsoid on every call. A dataset
+    references the same grid mapping from many variables and the property may
+    be accessed repeatedly, so each distinct grid mapping should be built once.
+    """
+    import pyproj
+
+    from ..accessor import _crs_from_cf_attrs
+
+    _crs_from_cf_attrs.cache_clear()
+
+    from ..datasets import hrrrds
+
+    ds = hrrrds
+
+    calls = {"n": 0}
+    orig = pyproj.CRS.from_cf
+
+    def counting_from_cf(*args, **kwargs):
+        calls["n"] += 1
+        return orig(*args, **kwargs)
+
+    monkeypatch.setattr(pyproj.CRS, "from_cf", staticmethod(counting_from_cf))
+
+    # Repeated property accesses, including via a DataArray, must not rebuild
+    # the same CRS: hrrrds has 3 distinct grid mappings, each built once.
+    ds.cf.grid_mappings
+    ds.cf.grid_mappings
+    ds.foo.cf.grid_mappings
+
+    assert calls["n"] == 3
+
+    _crs_from_cf_attrs.cache_clear()
+
+
 @requires_pyproj
 def test_grid_mappings_coordinates_attribute():
     """Test that coordinates attribute is always populated correctly for DataArray grid mappings."""
@@ -2484,6 +2522,43 @@ def test_sgrid():
     }
 
 
+def test_sgrid_includes_topology_coordinates():
+    """Variables referenced in node/face/edge/volume_coordinates of the
+    grid_topology variable should be pulled in by ds.cf[[var]]."""
+    roms = sgrid_roms.copy()
+    for pos in ("psi", "rho", "u", "v"):
+        roms[f"lon_{pos}"] = ((f"xi_{pos}", f"eta_{pos}"), np.zeros((2, 2)))
+        roms[f"lat_{pos}"] = ((f"xi_{pos}", f"eta_{pos}"), np.zeros((2, 2)))
+
+    expected_coord_vars = {
+        "lon_psi",
+        "lat_psi",
+        "lon_rho",
+        "lat_rho",
+        "lon_u",
+        "lat_u",
+        "lon_v",
+        "lat_v",
+    }
+    assoc = roms.cf.get_associated_variable_names("u")
+    assert expected_coord_vars.issubset(set(assoc["coordinates"]))
+
+    subset = roms.cf[["u"]]
+    assert "grid" in subset.variables
+    assert expected_coord_vars.issubset(set(subset.variables))
+
+    # only dim-compatible coords attach to the DataArray form
+    u_da = roms.cf["u"]
+    assert {"lon_u", "lat_u"}.issubset(set(u_da.coords))
+
+    delft = sgrid_delft.copy()
+    delft["node_lon"] = (("inode", "jnode"), np.zeros((2, 2)))
+    delft["node_lat"] = (("inode", "jnode"), np.zeros((2, 2)))
+    delft["foo"] = (("icell", "jcell"), np.ones((2, 2)), {"grid": "grid"})
+    delft_subset = delft.cf[["foo"]]
+    assert {"grid", "node_lon", "node_lat"}.issubset(set(delft_subset.variables))
+
+
 def test_ancillary_variables_extra_dim():
     ds = xr.Dataset(
         {

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/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.11.0 → cf_xarray-0.11.2}/cf_xarray.egg-info/PKG-INFO

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

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/doc/sgrid_ugrid.md

@@ -61,6 +61,23 @@ only `xi_u`, `eta_u` are listed in the repr even though the attributes on the `g
 variable `grid` list many more dimension names.
 ```
 
+### Coordinate variables
+
+`cf_xarray` also follows the `node_coordinates`, `face_coordinates`,
+`edge1_coordinates`, `edge2_coordinates`, and `volume_coordinates` attributes
+on the `grid_topology` variable. When you select a data variable that
+references a `grid_topology` via its `grid` attribute, the referenced
+coordinate variables are pulled in alongside it:
+
+```python
+ds.cf[["u"]]  # includes `grid`, lon_psi/lat_psi, lon_rho/lat_rho, ...
+```
+
+Only names actually present in the dataset are propagated. For the
+`DataArray` form (`ds.cf["u"]`) xarray only attaches coordinates whose
+dimensions are compatible with the variable, so e.g. only `lon_u`/`lat_u`
+appear as coords on `u`.
+
 ## UGRID
 
 ### Topology variable

{cf_xarray-0.11.0 → cf_xarray-0.11.2}/uv.lock

@@ -2983,11 +2983,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]

cf_xarray-0.11.0/cf_xarray/_version.py

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