cf-xarray 0.9.4__tar.gz → 0.10.0__tar.gz

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/.github/workflows/ci.yaml

@@ -27,7 +27,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ["ubuntu-latest"]
-        python-version: ["3.9", "3.12"]
+        python-version: ["3.10", "3.12"]
     steps:
       - uses: actions/checkout@v4
         with:
@@ -91,7 +91,7 @@ jobs:
         shell: bash -l {0}
     strategy:
       matrix:
-        python-version: ["3.9", "3.12"]
+        python-version: ["3.10", "3.12"]
     steps:
       - uses: actions/checkout@v4
         with:

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/.github/workflows/pypi.yaml

@@ -72,7 +72,7 @@ jobs:
 
       - name: Publish package to TestPyPI
         if: github.event_name == 'push'
-        uses: pypa/gh-action-pypi-publish@v1.9.0
+        uses: pypa/gh-action-pypi-publish@v1.10.2
         with:
           password: ${{ secrets.TESTPYPI_TOKEN }}
           repository_url: https://test.pypi.org/legacy/
@@ -96,6 +96,6 @@ jobs:
           name: releases
           path: dist
       - name: Publish package to PyPI
-        uses: pypa/gh-action-pypi-publish@v1.9.0
+        uses: pypa/gh-action-pypi-publish@v1.10.2
         with:
           verbose: true

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/.pre-commit-config.yaml

@@ -3,25 +3,25 @@ ci:
 
 repos:
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.16.0
+    rev: v3.17.0
     hooks:
       - id: pyupgrade
-        args: ["--py39-plus"]
+        args: ["--py310-plus"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.5.0'
+    rev: 'v0.6.9'
     hooks:
       - id: ruff
         args: ["--show-fixes", "--fix"]
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 24.4.2
+    rev: 24.10.0
     hooks:
       - id: black
 
   - repo: https://github.com/rstcheck/rstcheck
-    rev: v6.2.0
+    rev: v6.2.4
     hooks:
         - id: rstcheck
           additional_dependencies: [sphinx, tomli]
@@ -36,7 +36,7 @@ repos:
         - mdformat-myst
 
   - repo: https://github.com/nbQA-dev/nbQA
-    rev: 1.8.5
+    rev: 1.8.7
     hooks:
         - id: nbqa-black
         - id: nbqa-ruff
@@ -47,7 +47,7 @@ repos:
           additional_dependencies: [mdformat==0.7.17]
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
+    rev: v5.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -67,7 +67,7 @@ repos:
     - id: validate-cff
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.18
+    rev: v0.20.2
     hooks:
       - id: validate-pyproject
 

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/.readthedocs.yml

@@ -1,15 +1,16 @@
 version: 2
 
 build:
-  os: ubuntu-22.04
+  os: ubuntu-lts-latest
   tools:
-    python: mambaforge-4.10
+    python: mambaforge-latest
   jobs:
     post_checkout:
       - (git --no-pager log --pretty="tformat:%s" -1 | grep -vqF "[skip-rtd]") || exit 183
     pre_install:
       - conda list sphinx
       - conda list cf_xarray
+      - conda list
 
 conda:
   environment: ci/doc.yml

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/CITATION.cff

@@ -83,6 +83,10 @@ authors:
   - family-names: Haëck
     given-names: Clément
     affiliation: Laboratoire d'Océanographie et du Climat (LOCEAN), Paris
+  - family-names: Boutte
+    given-names: Jason
+    orcid: 'https://orcid.org/0009-0009-3996-3772'
+    affiliation: Lawrence Livermore National Laboratory
 identifiers:
   - type: doi
     value: 10.5281/zenodo.4749735

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cf_xarray
-Version: 0.9.4
+Version: 0.10.0
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -214,14 +214,13 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: xarray
+Requires-Dist: xarray>=2022.03.0
 Provides-Extra: all
 Requires-Dist: matplotlib; extra == "all"
 Requires-Dist: pint!=0.24.0,>=0.18; extra == "all"

cf_xarray-0.10.0/cf_xarray/_version.py

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

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/cf_xarray/accessor.py

@@ -5,14 +5,19 @@ import inspect
 import itertools
 import re
 from collections import ChainMap, namedtuple
-from collections.abc import Hashable, Iterable, Mapping, MutableMapping, Sequence
+from collections.abc import (
+    Callable,
+    Hashable,
+    Iterable,
+    Mapping,
+    MutableMapping,
+    Sequence,
+)
 from datetime import datetime
 from typing import (
     Any,
-    Callable,
     Literal,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -25,7 +30,7 @@ from xarray.core.resample import Resample
 from xarray.core.rolling import Coarsen, Rolling
 from xarray.core.weighted import Weighted
 
-from . import sgrid
+from . import parametric, sgrid
 from .criteria import (
     _DSG_ROLES,
     _GEOMETRY_TYPES,
@@ -83,7 +88,7 @@ ATTRS["time"] = ATTRS["T"]
 ATTRS["vertical"] = ATTRS["Z"]
 
 # Type for Mapper functions
-Mapper = Callable[[Union[DataArray, Dataset], Hashable], list[Hashable]]
+Mapper = Callable[[DataArray | Dataset, Hashable], list[Hashable]]
 
 # Type for decorators
 F = TypeVar("F", bound=Callable[..., Any])
@@ -532,7 +537,7 @@ def _get_coords(obj: DataArray | Dataset, key: Hashable) -> list[Hashable]:
 def _variables(func: F) -> F:
     @functools.wraps(func)
     def wrapper(obj: DataArray | Dataset, key: Hashable) -> list[DataArray]:
-        return [obj[k] for k in func(obj, key)]  # type: ignore[misc]
+        return [obj[k] for k in func(obj, key)]
 
     return cast(F, wrapper)
 
@@ -1144,9 +1149,10 @@ def create_flag_dict(da) -> Mapping[Hashable, FlagParam]:
         )
 
     flag_params = tuple(
-        FlagParam(mask, value) for mask, value in zip(flag_masks, flag_values)
+        FlagParam(mask, value)
+        for mask, value in zip(flag_masks, flag_values, strict=False)
     )
-    return dict(zip(flag_meanings, flag_params))
+    return dict(zip(flag_meanings, flag_params, strict=False))
 
 
 class CFAccessor:
@@ -1362,7 +1368,7 @@ class CFAccessor:
         kwargs: dict[str, Any] | None = None,
     ):
         if coords is not None:
-            if isinstance(coords, (Hashable, DataArray)):
+            if isinstance(coords, Hashable | DataArray):
                 coords_iter: Iterable[Hashable | DataArray] = [coords]
             else:
                 coords_iter = coords
@@ -2748,13 +2754,8 @@ class CFDatasetAccessor(CFAccessor):
         """
         ds = self._obj
 
-        requirements = {
-            "ocean_s_coordinate_g1": {"depth_c", "depth", "s", "C", "eta"},
-            "ocean_s_coordinate_g2": {"depth_c", "depth", "s", "C", "eta"},
-            "ocean_sigma_coordinate": {"sigma", "eta", "depth"},
-        }
-
         allterms = self.formula_terms
+
         for dim in allterms:
             if prefix is None:
                 assert (
@@ -2776,6 +2777,7 @@ class CFDatasetAccessor(CFAccessor):
                 suffix = dim.split("_")
                 zname = f"{prefix}_" + "_".join(suffix[1:])
 
+            # never touched, if standard name is missing it's not included in allterms
             if "standard_name" not in ds[dim].attrs:
                 continue
             stdname = ds[dim].attrs["standard_name"]
@@ -2784,46 +2786,23 @@ class CFDatasetAccessor(CFAccessor):
             terms = {}
             for key, value in allterms[dim].items():
                 if value not in ds:
+                    # is this ever hit, if variable is missing it's missing in decoded allterms
                     raise KeyError(
                         f"Variable {value!r} is required to decode coordinate for {dim!r}"
                         " but it is absent in the Dataset."
                     )
-                terms[key] = ds[value]
-
-            absent_terms = requirements[stdname] - set(terms)
-            if absent_terms:
-                raise KeyError(f"Required terms {absent_terms} absent in dataset.")
-
-            if stdname == "ocean_s_coordinate_g1":
-                # S(k,j,i) = depth_c * s(k) + (depth(j,i) - depth_c) * C(k)
-                S = (
-                    terms["depth_c"] * terms["s"]
-                    + (terms["depth"] - terms["depth_c"]) * terms["C"]
-                )
+                # keys should be case insensitive
+                terms[key.lower()] = ds[value]
 
-                # z(n,k,j,i) = S(k,j,i) + eta(n,j,i) * (1 + S(k,j,i) / depth(j,i))
-                ztemp = S + terms["eta"] * (1 + S / terms["depth"])
-
-            elif stdname == "ocean_s_coordinate_g2":
-                # make sure all necessary terms are present in terms
-                # (depth_c * s(k) + depth(j,i) * C(k)) / (depth_c + depth(j,i))
-                S = (terms["depth_c"] * terms["s"] + terms["depth"] * terms["C"]) / (
-                    terms["depth_c"] + terms["depth"]
-                )
-
-                # z(n,k,j,i) = eta(n,j,i) + (eta(n,j,i) + depth(j,i)) * S(k,j,i)
-                ztemp = terms["eta"] + (terms["eta"] + terms["depth"]) * S
-
-            elif stdname == "ocean_sigma_coordinate":
-                # z(n,k,j,i) = eta(n,j,i) + sigma(k)*(depth(j,i)+eta(n,j,i))
-                ztemp = terms["eta"] + terms["sigma"] * (terms["depth"] + terms["eta"])
-
-            else:
+            try:
+                transform = parametric.TRANSFORM_FROM_STDNAME[stdname]
+            except KeyError:
+                # Should occur since stdname is check before
                 raise NotImplementedError(
-                    f"Coordinate function for {stdname!r} not implemented yet. Contributions welcome!"
-                )
+                    f"Coordinate function for {stdname!r} not implmented yet. Contributions welcome!"
+                ) from None
 
-            ds.coords[zname] = ztemp
+            ds.coords[zname] = transform.from_terms(terms)
 
 
 @xr.register_dataarray_accessor("cf")
@@ -3018,7 +2997,7 @@ class CFDataArrayAccessor(CFAccessor):
             x = self._obj.astype("i")
             bit_comp = x & bit_mask
 
-            for i, (flag, value) in enumerate(zip(flags_reduced, values)):
+            for i, (flag, value) in enumerate(zip(flags_reduced, values, strict=False)):
                 bit = bit_comp.isel(_mask=i)
                 if value is not None:
                     out[flag] = bit == value

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/cf_xarray/coding.py

@@ -46,7 +46,7 @@ def encode_multi_index_as_compress(ds, idxnames=None):
     encoded = ds.reset_index(idxnames)
     for idxname in idxnames:
         mindex = ds.indexes[idxname]
-        coords = dict(zip(mindex.names, mindex.levels))
+        coords = dict(zip(mindex.names, mindex.levels, strict=False))
         encoded.update(coords)
         for c in coords:
             encoded[c].attrs = ds[c].attrs
@@ -112,13 +112,16 @@ def decode_compress_to_multi_index(encoded, idxnames=None):
 
             variables = {
                 dim: encoded[dim].isel({dim: xr.Variable(data=index, dims=idxname)})
-                for dim, index in zip(names, indices)
+                for dim, index in zip(names, indices, strict=False)
             }
             decoded = decoded.assign_coords(variables).set_xindex(
                 names, PandasMultiIndex
             )
         except ImportError:
-            arrays = [encoded[dim].data[index] for dim, index in zip(names, indices)]
+            arrays = [
+                encoded[dim].data[index]
+                for dim, index in zip(names, indices, strict=False)
+            ]
             mindex = pd.MultiIndex.from_arrays(arrays, names=names)
             decoded.coords[idxname] = mindex
 

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/cf_xarray/formatting.py

@@ -268,14 +268,14 @@ def _format_flags(accessor, rich):
         table.add_column("Value", justify="right")
         table.add_column("Bits", justify="center")
 
-        for val, bit, key in zip(value_text, bit_text, flag_dict):
+        for val, bit, key in zip(value_text, bit_text, flag_dict, strict=False):
             table.add_row(_format_cf_name(key, rich), val, bit)
 
         return table
 
     else:
         rows = []
-        for val, bit, key in zip(value_text, bit_text, flag_dict):
+        for val, bit, key in zip(value_text, bit_text, flag_dict, strict=False):
             rows.append(
                 f"{TAB}{_format_cf_name(key, rich):>{key_width}}: {TAB} {val} {bit}"
             )

{cf_xarray-0.9.4 → cf_xarray-0.10.0}/cf_xarray/geometry.py

@@ -324,7 +324,7 @@ def encode_geometries(ds: xr.Dataset):
             # TODO: this is incomplete. It works for vector data cubes where one of the geometry vars
             # is a dimension coordinate.
             if name in var.dims:
-                var = var.copy()
+                var = var.copy(deep=False)
                 var._attrs = copy.deepcopy(var._attrs)
                 var.attrs["geometry"] = container_name
                 # The grid_mapping and coordinates attributes can be carried by the geometry container
@@ -459,11 +459,8 @@ def shapely_to_cf(
             "and set the grid mapping variable as a coordinate",
         )
 
-    # Get all types to call the appropriate translation function.
-    types = {
-        geom.item().geom_type if isinstance(geom, xr.DataArray) else geom.geom_type
-        for geom in geometries
-    }
+    as_data = geometries.data if isinstance(geometries, xr.DataArray) else geometries
+    type_ = as_data[0].geom_type
 
     grid_mapping_varname = None
     if (
@@ -482,16 +479,21 @@ def shapely_to_cf(
         suffix=suffix, grid_mapping_name=grid_mapping, grid_mapping=grid_mapping_varname
     )
 
-    if types.issubset({"Point", "MultiPoint"}):
-        ds = points_to_cf(geometries, names=names)
-    elif types.issubset({"LineString", "MultiLineString"}):
-        ds = lines_to_cf(geometries, names=names)
-    elif types.issubset({"Polygon", "MultiPolygon"}):
-        ds = polygons_to_cf(geometries, names=names)
-    else:
+    try:
+        if type_ in ["Point", "MultiPoint"]:
+            ds = points_to_cf(geometries, names=names)
+        elif type_ in ["LineString", "MultiLineString"]:
+            ds = lines_to_cf(geometries, names=names)
+        elif type_ in ["Polygon", "MultiPolygon"]:
+            ds = polygons_to_cf(geometries, names=names)
+        else:
+            raise ValueError(
+                f"This geometry type is not supported in CF-compliant datasets. Got {type_}"
+            )
+    except NotImplementedError as e:
         raise ValueError(
-            f"Mixed geometry types are not supported in CF-compliant datasets. Got {types}"
-        )
+            "Error converting geometries. Possibly you have provided mixed geometry types."
+        ) from e
 
     return ds
 
@@ -841,7 +843,7 @@ def polygons_to_cf(
         node_count = part_node_count
     elif len(offsets) >= 2:
         indices = np.take(offsets[0], offsets[1])
-        interior_ring = np.isin(offsets[0], indices, invert=True)[:-1].astype(int)
+        interior_ring = np.isin(offsets[0], indices, invert=True)[:-1]
 
         if len(offsets) == 3:
             indices = np.take(indices, offsets[2])
@@ -852,29 +854,32 @@ def polygons_to_cf(
     crdX = geom_coords[:, 0]
     crdY = geom_coords[:, 1]
 
+    data_vars = {names.node_count: (dim, node_count)}
+    geometry_attrs = names.geometry_container_attrs
+
+    # Special case when we have no MultiPolygons and no holes
+    if len(part_node_count) != len(node_count):
+        data_vars[names.part_node_count] = (names.part_dim, part_node_count)
+        geometry_attrs["part_node_count"] = names.part_node_count
+
+    # Special case when we have no holes
+    if interior_ring.any():
+        data_vars[names.interior_ring] = (names.part_dim, interior_ring)
+        geometry_attrs["interior_ring"] = names.interior_ring
+
+    data_vars[names.container_name] = (  # type: ignore[assignment]
+        (),
+        np.nan,
+        {"geometry_type": "polygon", **geometry_attrs},
+    )
     ds = xr.Dataset(
-        data_vars={
-            names.node_count: xr.DataArray(node_count, dims=(dim,)),
-            names.container_name: xr.DataArray(
-                data=np.nan,
-                attrs={"geometry_type": "polygon", **names.geometry_container_attrs},
-            ),
-        },
+        data_vars=data_vars,
         coords=names.coords(x=x, y=y, crdX=crdX, crdY=crdY, dim=dim),
     )
 
     if coord is not None:
         ds = ds.assign_coords({dim: coord})
 
-    # Special case when we have no MultiPolygons and no holes
-    if len(part_node_count) != len(node_count):
-        ds[names.part_node_count] = xr.DataArray(part_node_count, dims=names.part_dim)
-        ds[names.container_name].attrs["part_node_count"] = names.part_node_count
-
-    # Special case when we have no holes
-    if (interior_ring != 0).any():
-        ds[names.interior_ring] = xr.DataArray(interior_ring, dims=names.part_dim)
-        ds[names.container_name].attrs["interior_ring"] = names.interior_ring
     return ds