cf-xarray 0.10.5__tar.gz → 0.10.7__tar.gz

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/.github/workflows/ci.yaml

@@ -27,11 +27,11 @@ jobs:
       fail-fast: false
       matrix:
         os: ["ubuntu-latest"]
-        python-version: ["3.10", "3.13"]
+        python-version: ["3.11", "3.13"]
         env: [""]
         include:
           - env: "all-min-deps"
-            python-version: "3.10"
+            python-version: "3.11"
             os: ubuntu-latest
           - env: "no-optional-deps"
             python-version: "3.13"
@@ -70,7 +70,7 @@ jobs:
         run: |
           pytest -n auto --cov=./ --cov-report=xml
       - name: Upload code coverage to Codecov
-        uses: codecov/codecov-action@v5.4.0
+        uses: codecov/codecov-action@v5.4.3
         with:
           file: ./coverage.xml
           flags: unittests
@@ -86,7 +86,7 @@ jobs:
         shell: bash -l {0}
     strategy:
       matrix:
-        python-version: ["3.10", "3.13"]
+        python-version: ["3.11", "3.13"]
     steps:
       - uses: actions/checkout@v4
         with:
@@ -109,7 +109,7 @@ jobs:
         run: |
           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.4.0
+        uses: codecov/codecov-action@v5.4.3
         with:
           file: mypy_report/cobertura.xml
           flags: mypy

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/.pre-commit-config.yaml

@@ -3,28 +3,28 @@ ci:
 
 repos:
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.19.1
+    rev: v3.20.0
     hooks:
       - id: pyupgrade
         args: ["--py310-plus"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.9.3'
+    rev: 'v0.12.2'
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]
       - id: ruff-format
 
   - repo: https://github.com/rstcheck/rstcheck
-    rev: v6.2.4
+    rev: v6.2.5
     hooks:
         - id: rstcheck
           additional_dependencies: [sphinx, tomli]
           args: ['--config', 'pyproject.toml']
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.21
+    rev: 0.7.22
     hooks:
     - id: mdformat
       additional_dependencies:
@@ -55,7 +55,7 @@ repos:
     - id: validate-cff
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.23
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
 

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.10.5
+Version: 0.10.7
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -214,11 +214,10 @@ 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.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: xarray>=2023.09.0

cf_xarray-0.10.7/cf_xarray/_version.py

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

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray/accessor.py

@@ -39,8 +39,8 @@ except ImportError:
     )
 
 try:
-    from xarray.core.weighted import (
-        Weighted,  # type:ignore[import-not-found,no-redef,unused-ignore]
+    from xarray.core.weighted import (  # type:ignore[import-not-found,no-redef,unused-ignore]
+        Weighted,
     )
 except ImportError:
     from xarray.computation.weighted import (  # type:ignore[import-not-found,no-redef,unused-ignore]
@@ -1376,7 +1376,7 @@ class CFAccessor:
 
     def curvefit(
         self,
-        coords: Hashable | DataArray | Iterable[Hashable | DataArray],
+        coords: Hashable | Iterable[Hashable],
         func: Callable[..., Any],
         reduce_dims: Hashable | Iterable[Hashable] | None = None,
         skipna: bool = True,
@@ -1386,8 +1386,8 @@ class CFAccessor:
         kwargs: dict[str, Any] | None = None,
     ):
         if coords is not None:
-            if isinstance(coords, Hashable | DataArray):
-                coords_iter: Iterable[Hashable | DataArray] = [coords]
+            if isinstance(coords, Hashable):
+                coords_iter: Iterable[Hashable] = [coords]
             else:
                 coords_iter = coords
             coords = [

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray/geometry.py

@@ -298,8 +298,10 @@ def encode_geometries(ds: xr.Dataset):
     geom_var_names = [
         name
         for name, var in ds._variables.items()
-        if var.dtype == "O" and isinstance(var.data.flat[0], SHAPELY_TYPES)
+        if var.dtype == "geometry"
+        or (var.dtype == "O" and isinstance(var.data.flat[0], SHAPELY_TYPES))
     ]
+
     if not geom_var_names:
         return ds
 
@@ -410,8 +412,8 @@ def reshape_unique_geometries(
     out = out.unstack(temp_name)
 
     # geom_var was reshaped also, reconstruct it from the unique values.
-    unique_indexes = xr.DataArray(unique_indexes, dims=(new_dim,))
-    out[geom_var] = ds[geom_var].isel({old_name: unique_indexes})
+    unique_indexes_da = xr.DataArray(unique_indexes, dims=(new_dim,))
+    out[geom_var] = ds[geom_var].isel({old_name: unique_indexes_da})
     if old_name not in ds.coords:
         # If there was no coord before, drop the dummy one we made.
         out = out.drop_vars(old_name)  # type: ignore[arg-type,unused-ignore]  # Hashable/str stuff

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray/helpers.py

@@ -175,19 +175,79 @@ def bounds_to_vertices(
             f"Bounds format not understood. Got {bounds.dims} with shape {bounds.shape}."
         )
 
+    core_dim_coords = {
+        dim: bounds.coords[dim].values for dim in core_dims if dim in bounds.coords
+    }
+    core_dim_orders = _get_core_dim_orders(core_dim_coords)
+
     return xr.apply_ufunc(
         _bounds_helper,
         bounds,
         input_core_dims=[core_dims + [bounds_dim]],
         dask="parallelized",
-        kwargs={"n_core_dims": n_core_dims, "nbounds": nbounds, "order": order},
+        kwargs={
+            "n_core_dims": n_core_dims,
+            "nbounds": nbounds,
+            "order": order,
+            "core_dim_orders": core_dim_orders,
+        },
         output_core_dims=[output_core_dims],
         dask_gufunc_kwargs=dict(output_sizes=output_sizes),
         output_dtypes=[bounds.dtype],
     )
 
 
-def _bounds_helper(values, n_core_dims, nbounds, order):
+def _get_core_dim_orders(core_dim_coords: dict[str, np.ndarray]) -> dict[str, str]:
+    """
+    Determine the order (ascending, descending, or mixed) of each core dimension
+    based on its coordinates.
+
+    Repeated (equal) coordinates are ignored when determining the order. If all
+    coordinates are equal, the order is treated as "ascending".
+
+    Parameters
+    ----------
+    core_dim_coords : dict of str to np.ndarray
+        A dictionary mapping dimension names to their coordinate arrays.
+
+    Returns
+    -------
+    core_dim_orders : dict of str to str
+        A dictionary mapping each dimension name to a string indicating the order:
+        - "ascending": strictly increasing (ignoring repeated values)
+        - "descending": strictly decreasing (ignoring repeated values)
+        - "mixed": neither strictly increasing nor decreasing (ignoring repeated values)
+    """
+    core_dim_orders = {}
+
+    for dim, coords in core_dim_coords.items():
+        diffs = np.diff(coords)
+
+        # Handle datetime64 and timedelta64 safely for both numpy 1.26.4 and numpy 2
+        if np.issubdtype(coords.dtype, np.datetime64) or np.issubdtype(
+            coords.dtype, np.timedelta64
+        ):
+            # Cast to float64 for safe comparison
+            diffs_float = diffs.astype("float64")
+            nonzero_diffs = diffs_float[diffs_float != 0]
+        else:
+            zero = 0
+            nonzero_diffs = diffs[diffs != zero]
+
+        if nonzero_diffs.size == 0:
+            # All values are equal, treat as ascending
+            core_dim_orders[dim] = "ascending"
+        elif np.all(nonzero_diffs > 0):
+            core_dim_orders[dim] = "ascending"
+        elif np.all(nonzero_diffs < 0):
+            core_dim_orders[dim] = "descending"
+        else:
+            core_dim_orders[dim] = "mixed"
+
+    return core_dim_orders
+
+
+def _bounds_helper(values, n_core_dims, nbounds, order, core_dim_orders):
     if n_core_dims == 2 and nbounds == 4:
         # Vertices case (2D lat/lon)
         if order in ["counterclockwise", None]:
@@ -211,11 +271,176 @@ def _bounds_helper(values, n_core_dims, nbounds, order):
             vertex_vals = np.block([[bot_left, bot_right], [top_left, top_right]])
     elif n_core_dims == 1 and nbounds == 2:
         # Middle points case (1D lat/lon)
-        vertex_vals = np.concatenate((values[..., :, 0], values[..., -1:, 1]), axis=-1)
+        vertex_vals = _get_ordered_vertices(values, core_dim_orders)
 
     return vertex_vals
 
 
+def _get_ordered_vertices(
+    bounds: np.ndarray, core_dim_orders: dict[str, str]
+) -> np.ndarray:
+    """
+    Convert a bounds array of shape (..., N, 2) or (N, 2) into a 1D array of vertices.
+
+    This function reconstructs the vertices from a bounds array, handling both
+    monotonic and non-monotonic cases.
+
+    Monotonic bounds (all values strictly increase or decrease when flattened):
+        - Concatenate the left endpoints (bounds[..., :, 0]) with the last right
+          endpoint (bounds[..., -1, 1]) to form the vertices.
+
+    Non-monotonic bounds:
+        - Determine the order of the core dimension(s) ('ascending' or 'descending').
+        - For ascending order:
+            - Use the minimum of each interval as the vertex.
+            - Use the maximum of the last interval as the final vertex.
+        - For descending order:
+            - Use the maximum of each interval as the vertex.
+            - Use the minimum of the last interval as the final vertex.
+        - Vertices are then sorted to match the coordinate direction.
+
+    Features:
+        - Handles both ascending and descending bounds.
+        - Preserves repeated coordinates if present.
+        - Output shape is (..., N+1) or (N+1,).
+
+    Parameters
+    ----------
+    bounds : np.ndarray
+        Array of bounds, typically with shape (N, 2) or (..., N, 2).
+    core_dim_orders : dict[str, str]
+        Dictionary mapping core dimension names to their order ('ascending' or
+        'descending'). Used for sorting the vertices.
+
+    Returns
+    -------
+    np.ndarray
+        Array of vertices with shape (..., N+1) or (N+1,).
+    """
+    order = _get_order_of_core_dims(core_dim_orders)
+
+    if _is_bounds_monotonic(bounds):
+        vertices = np.concatenate((bounds[..., :, 0], bounds[..., -1:, 1]), axis=-1)
+    else:
+        if order == "ascending":
+            endpoints = np.minimum(bounds[..., :, 0], bounds[..., :, 1])
+            last_endpoint = np.maximum(bounds[..., -1, 0], bounds[..., -1, 1])
+        elif order == "descending":
+            endpoints = np.maximum(bounds[..., :, 0], bounds[..., :, 1])
+            last_endpoint = np.minimum(bounds[..., -1, 0], bounds[..., -1, 1])
+
+        vertices = np.concatenate(
+            [endpoints, np.expand_dims(last_endpoint, axis=-1)], axis=-1
+        )
+
+    vertices = _sort_vertices(vertices, order)
+
+    return vertices
+
+
+def _is_bounds_monotonic(bounds: np.ndarray) -> bool:
+    """Check if the bounds are monotonic.
+
+    Arrays are monotonic if all values are increasing or decreasing. This
+    functions ignores  an intervals where consecutive values are equal, which
+    represent repeated coordinates.
+
+    Parameters
+    ----------
+    arr : np.ndarray
+        Numpy array to check, typically with shape (..., N, 2).
+
+    Returns
+    -------
+    bool
+        True if the flattened array is increasing or decreasing, False otherwise.
+    """
+    # NOTE: Python 3.10 uses numpy 1.26.4. If the input is a datetime64 array,
+    # numpy 1.26.4 may raise: numpy.core._exceptions._UFuncInputCastingError:
+    # Cannot cast ufunc 'greater' input 0 from dtype('<m8[ns]') to dtype('<m8')
+    # with casting rule 'same_kind' To avoid this, always cast to float64 before
+    # np.diff.
+    arr_numeric = bounds.astype("float64").flatten()
+    diffs = np.diff(arr_numeric)
+    nonzero_diffs = diffs[diffs != 0]
+
+    # All values are equal, treat as monotonic
+    if nonzero_diffs.size == 0:
+        return True
+
+    return bool(np.all(nonzero_diffs > 0) or np.all(nonzero_diffs < 0))
+
+
+def _get_order_of_core_dims(core_dim_orders: dict[str, str]) -> str:
+    """
+    Determines the common order of core dimensions from a dictionary of
+    dimension orders.
+
+    Parameters
+    ----------
+    core_dim_orders : dict of str
+        A dictionary mapping dimension names to their respective order strings.
+
+    Returns
+    -------
+    order : str
+        The common order string shared by all core dimensions.
+
+    Raises
+    ------
+    ValueError
+        If the core dimension orders are not all aligned (i.e., not all values
+        are the same).
+    """
+    orders = set(core_dim_orders.values())
+
+    if len(orders) != 1:
+        raise ValueError(
+            f"All core dimension orders must be aligned. Got orders: {core_dim_orders}"
+        )
+
+    order = next(iter(orders))
+
+    return order
+
+
+def _sort_vertices(vertices: np.ndarray, order: str) -> np.ndarray:
+    """
+    Sorts the vertices array along the last axis in ascending or descending order.
+
+    Parameters
+    ----------
+    vertices : np.ndarray
+        An array of vertices to be sorted. Sorting is performed along the last
+        axis.
+    order : str
+        The order in which to sort the vertices. Must be either "ascending" or
+        any other value for descending order.
+
+    Returns
+    -------
+    np.ndarray
+        The sorted array of vertices, with the same shape as the input.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> vertices = np.array([[3, 1, 2], [6, 5, 4]])
+    >>> _sort_vertices(vertices, "ascending")
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> _sort_vertices(vertices, "descending")
+    array([[3, 2, 1],
+           [6, 5, 4]])
+    """
+    if order == "ascending":
+        new_vertices = np.sort(vertices, axis=-1)
+    else:
+        new_vertices = np.sort(vertices, axis=-1)[..., ::-1]
+
+    return new_vertices
+
+
 def vertices_to_bounds(
     vertices: DataArray, out_dims: Sequence[str] = ("bounds", "x", "y")
 ) -> DataArray:

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray/tests/test_geometry.py

@@ -507,5 +507,7 @@ def test_encode_decode(geometry_ds, polygon_geometry):
     )
     multi_ds = xr.merge([polyds, geometry_ds[1]])
     for ds in (geometry_ds[1], polygon_geometry.to_dataset(), geom_dim_ds, multi_ds):
-        roundtripped = decode_geometries(encode_geometries(ds))
+        encoded = encode_geometries(ds)
+        assert len(encoded.data_vars) > len(ds.data_vars)
+        roundtripped = decode_geometries(encoded)
         xr.testing.assert_identical(ds, roundtripped)

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray/tests/test_helpers.py

@@ -1,3 +1,4 @@
+import xarray as xr
 from numpy.testing import assert_array_equal
 from xarray.testing import assert_equal
 
@@ -12,7 +13,7 @@ except ImportError:
 
 
 def test_bounds_to_vertices() -> None:
-    # 1D case
+    # 1D case (stricly monotonic, descending bounds)
     ds = airds.cf.add_bounds(["lon", "lat", "time"])
     lat_c = cfxr.bounds_to_vertices(ds.lat_bounds, bounds_dim="bounds")
     assert_array_equal(ds.lat.values + 1.25, lat_c.values[:-1])
@@ -34,6 +35,59 @@ def test_bounds_to_vertices() -> None:
     lon_no = cfxr.bounds_to_vertices(rotds.lon_bounds, bounds_dim="bounds", order=None)
     assert_equal(lon_no, lon_ccw)
 
+    # 2D case (monotonicly increasing coords, non-monotonic bounds)
+    bounds_2d_desc = xr.DataArray(
+        [[50.5, 50.0], [51.0, 50.5], [51.0, 50.5], [52.0, 51.5], [52.5, 52.0]],
+        dims=("lat", "bounds"),
+        coords={"lat": [50.75, 50.75, 51.25, 51.75, 52.25]},
+    )
+    expected_vertices_2d_desc = xr.DataArray(
+        [50.0, 50.5, 50.5, 51.5, 52.0, 52.5],
+        dims=["lat_vertices"],
+    )
+    vertices_2d_desc = cfxr.bounds_to_vertices(bounds_2d_desc, bounds_dim="bounds")
+    assert_equal(expected_vertices_2d_desc, vertices_2d_desc)
+
+    # 3D case (non-monotonic bounds, monotonicly increasing coords)
+    bounds_3d = xr.DataArray(
+        [
+            [
+                [50.0, 50.5],
+                [50.5, 51.0],
+                [51.0, 51.5],
+                [51.5, 52.0],
+                [52.0, 52.5],
+            ],
+            [
+                [60.0, 60.5],
+                [60.5, 61.0],
+                [61.0, 61.5],
+                [61.5, 62.0],
+                [62.0, 62.5],
+            ],
+        ],
+        dims=("extra", "lat", "bounds"),
+        coords={
+            "extra": [0, 1],
+            "lat": [0, 1, 2, 3, 4],
+            "bounds": [0, 1],
+        },
+    )
+    expected_vertices_3d = xr.DataArray(
+        [
+            [50.0, 50.5, 51.0, 51.5, 52.0, 52.5],
+            [60.0, 60.5, 61.0, 61.5, 62.0, 62.5],
+        ],
+        dims=("extra", "lat_vertices"),
+        coords={
+            "extra": [0, 1],
+        },
+    )
+    vertices_3d = cfxr.bounds_to_vertices(
+        bounds_3d, bounds_dim="bounds", core_dims=["lat"]
+    )
+    assert_equal(vertices_3d, expected_vertices_3d)
+
     # Transposing the array changes the bounds direction
     ds = mollwds.transpose("x", "y", "x_vertices", "y_vertices", "bounds")
     lon_cw = cfxr.bounds_to_vertices(

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/cf_xarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.10.5
+Version: 0.10.7
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -214,11 +214,10 @@ 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.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: xarray>=2023.09.0

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/ci/doc.yml

@@ -8,7 +8,7 @@ dependencies:
   - netcdf4
   - pooch
   - xarray
-  - sphinx<8
+  - sphinx
   - sphinx-copybutton
   - numpydoc
   - sphinx-autosummary-accessors

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/doc/conf.py

@@ -265,8 +265,8 @@ napoleon_use_param = True
 napoleon_use_rtype = True
 
 numpydoc_show_class_members = False
-# Report warnings for all validation checks except the ones listed after "all"
-numpydoc_validation_checks = {"all", "ES01", "EX01", "SA01", "SA04"}
+# Disable numpydoc validation to avoid compatibility issues with Sphinx 8
+numpydoc_validation_checks = set()
 # don't report on objects that match any of these regex
 numpydoc_validation_exclude = {
     "cf_xarray.accessor.",

{cf_xarray-0.10.5 → cf_xarray-0.10.7}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "cf_xarray"
 description = "A convenience wrapper for using CF attributes on xarray objects"
 readme = "README.rst"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = {file = "LICENSE"}
 keywords = ["xarray", "metadata", "CF conventions"]
 classifiers = [
@@ -11,7 +11,6 @@ classifiers = [
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -55,7 +54,7 @@ write_to_template= '__version__ = "{version}"'
 tag_regex= "^(?P<prefix>v)?(?P<version>[^\\+]+)(?P<suffix>.*)?$"
 
 [tool.ruff]
-target-version = "py310"
+target-version = "py311"
 builtins = ["ellipsis"]
 exclude = [
     ".eggs",

cf_xarray-0.10.5/cf_xarray/_version.py

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