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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.11.1
+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.1 → cf_xarray-0.11.2}/cf_xarray/accessor.py

@@ -556,6 +556,37 @@ def _parse_grid_mapping_attribute(
     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,
@@ -669,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, [])
@@ -2076,17 +2107,14 @@ 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: dict[str, str] = {}
@@ -2269,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

{cf_xarray-0.11.1 → 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.1 → 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.1 → 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.1
+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.1 → 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.1/cf_xarray/_version.py

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