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

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

@@ -34,17 +34,17 @@ jobs:
             python-version: "3.13"
             os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0 # Fetch all history for all branches and tags.
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
@@ -58,7 +58,7 @@ jobs:
           pytest -n auto --cov=./ --cov-report=xml
 
       - name: Upload code coverage to Codecov
-        uses: codecov/codecov-action@v5.5.0
+        uses: codecov/codecov-action@v5.5.2
         with:
           file: ./coverage.xml
           flags: unittests
@@ -73,17 +73,17 @@ jobs:
       matrix:
         python-version: ["3.11", "3.13"]
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0 # Fetch all history for all branches and tags.
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
@@ -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.0
+        uses: codecov/codecov-action@v5.5.2
         with:
           file: mypy_report/cobertura.xml
           flags: mypy

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

@@ -12,10 +12,10 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository == 'xarray-contrib/cf-xarray'
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         name: Install Python
         with:
           python-version: "3.11"
@@ -41,7 +41,7 @@ jobs:
           else
             echo "✅ Looks good"
           fi
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v6
         with:
           name: releases
           path: dist
@@ -50,11 +50,11 @@ jobs:
     needs: build-artifacts
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         name: Install Python
         with:
           python-version: "3.11"
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v7
         with:
           name: releases
           path: dist
@@ -91,7 +91,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v7
         with:
           name: releases
           path: dist

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

@@ -17,11 +17,11 @@ jobs:
     if: ${{ contains( github.event.pull_request.labels.*.name, 'test-build') && github.event_name == 'pull_request' || github.event_name == 'workflow_dispatch' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         name: Install Python
         with:
           python-version: "3.11"
@@ -53,7 +53,7 @@ jobs:
             echo "✅ Looks good"
           fi
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v6
         with:
           name: releases
           path: dist
@@ -62,11 +62,11 @@ jobs:
     needs: build-artifacts
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         name: Install Python
         with:
           python-version: "3.11"
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v7
         with:
           name: releases
           path: dist

{cf_xarray-0.10.9 → cf_xarray-0.10.11}/.github/workflows/upstream-dev-ci.yaml

@@ -28,17 +28,17 @@ jobs:
       matrix:
         python-version: ["3.13"]
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0 # Fetch all history for all branches and tags.
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
 
       - name: Install dependencies
         run: |

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

@@ -3,14 +3,14 @@ ci:
 
 repos:
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.20.0
+    rev: v3.21.2
     hooks:
       - id: pyupgrade
         args: ["--py310-plus"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.12.2'
+    rev: 'v0.14.10'
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]
@@ -24,7 +24,7 @@ repos:
           args: ['--config', 'pyproject.toml']
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.22
+    rev: 1.0.0
     hooks:
     - id: mdformat
       additional_dependencies:
@@ -41,7 +41,7 @@ repos:
           additional_dependencies: [mdformat==0.7.17]
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cf_xarray
-Version: 0.10.9
+Version: 0.10.11
 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/_version.py

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

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

@@ -589,7 +589,83 @@ def _create_grid_mapping(
     cf_name = var.attrs.get("grid_mapping_name", var_name)
 
     # Create CRS from the grid mapping variable
-    crs = pyproj.CRS.from_cf(var.attrs)
+    if cf_name == "reduced_gaussian":
+        # pyproj does not recognize "reduced_gaussian" as a grid mapping name,
+        # but the grid uses geographic (lat/lon) coordinates on a sphere or
+        # spheroid. Build a geographic CRS from the earth shape parameters.
+        crs = pyproj.CRS.from_json_dict(
+            {
+                "$schema": "https://proj.org/schemas/v0.6/projjson.schema.json",
+                "type": "GeographicCRS",
+                "name": "Reduced Gaussian Grid",
+                "datum": {
+                    "type": "GeodeticReferenceFrame",
+                    "name": "Unknown",
+                    "ellipsoid": {
+                        "name": "Custom",
+                        "semi_major_axis": var.attrs.get("semi_major_axis", 6371229.0),
+                        "semi_minor_axis": var.attrs.get("semi_minor_axis", 6371229.0),
+                    },
+                },
+                "coordinate_system": {
+                    "subtype": "ellipsoidal",
+                    "axis": [
+                        {
+                            "name": "Latitude",
+                            "abbreviation": "lat",
+                            "direction": "north",
+                            "unit": "degree",
+                        },
+                        {
+                            "name": "Longitude",
+                            "abbreviation": "lon",
+                            "direction": "east",
+                            "unit": "degree",
+                        },
+                    ],
+                },
+            }
+        )
+    elif cf_name == "healpix":
+        # pyproj does not recognize "healpix" as a grid mapping name,
+        # but the grid uses geographic (lat/lon) coordinates on a sphere.
+        # Build a geographic CRS from the earth_radius parameter.
+        earth_radius = var.attrs.get("earth_radius", 6371229.0)
+        crs = pyproj.CRS.from_json_dict(
+            {
+                "$schema": "https://proj.org/schemas/v0.6/projjson.schema.json",
+                "type": "GeographicCRS",
+                "name": "HEALPix Grid",
+                "datum": {
+                    "type": "GeodeticReferenceFrame",
+                    "name": "Unknown",
+                    "ellipsoid": {
+                        "name": "Custom",
+                        "semi_major_axis": earth_radius,
+                        "semi_minor_axis": earth_radius,
+                    },
+                },
+                "coordinate_system": {
+                    "subtype": "ellipsoidal",
+                    "axis": [
+                        {
+                            "name": "Latitude",
+                            "abbreviation": "lat",
+                            "direction": "north",
+                            "unit": "degree",
+                        },
+                        {
+                            "name": "Longitude",
+                            "abbreviation": "lon",
+                            "direction": "east",
+                            "unit": "degree",
+                        },
+                    ],
+                },
+            }
+        )
+    else:
+        crs = pyproj.CRS.from_cf(var.attrs)
 
     # Get associated coordinate variables, fallback to dimension names
     coordinates: list[Hashable] = grid_mapping_dict.get(var_name, [])
@@ -600,16 +676,47 @@ def _create_grid_mapping(
     #     The appropriate values of the standard_name depend on the grid mapping and are given in Appendix F, Grid Mappings.
     # """
     if not coordinates and len(grid_mapping_dict) == 1:
-        if crs.to_cf().get("grid_mapping_name") == "rotated_latitude_longitude":
-            xname, yname = "grid_longitude", "grid_latitude"
-        elif crs.is_geographic:
-            xname, yname = "longitude", "latitude"
-        elif crs.is_projected:
-            xname, yname = "projection_x_coordinate", "projection_y_coordinate"
-
-        x = apply_mapper(_get_with_standard_name, ds, xname, error=False, default=[[]])
-        y = apply_mapper(_get_with_standard_name, ds, yname, error=False, default=[[]])
-        coordinates = list(itertools.chain(x, y))
+        if cf_name == "healpix":
+            # For HEALPix grids, the primary coordinate is the pixel index.
+            coords_found = apply_mapper(
+                _get_with_standard_name, ds, "healpix_index", error=False, default=[[]]
+            )
+            coordinates = list(itertools.chain(coords_found))
+        elif cf_name == "reduced_gaussian":
+            # For reduced gaussian grids, the primary coordinate is the grid
+            # point index. For compressed subsets, also look for the gather
+            # variable (with compress attribute).
+            idx_coords = apply_mapper(
+                _get_with_standard_name,
+                ds,
+                "reduced_gaussian_index",
+                error=False,
+                default=[[]],
+            )
+            coordinates = list(itertools.chain(idx_coords))
+            # Also find any compress/gather variable that references
+            # the detected index coordinate(s)
+            for vname in ds.coords:
+                if "compress" in ds[vname].attrs:
+                    compress_target = ds[vname].attrs["compress"]
+                    if any(c in compress_target for c in coordinates):
+                        if vname not in coordinates:
+                            coordinates.append(vname)
+        else:
+            if crs.to_cf().get("grid_mapping_name") == "rotated_latitude_longitude":
+                xname, yname = "grid_longitude", "grid_latitude"
+            elif crs.is_geographic:
+                xname, yname = "longitude", "latitude"
+            elif crs.is_projected:
+                xname, yname = "projection_x_coordinate", "projection_y_coordinate"
+
+            x = apply_mapper(
+                _get_with_standard_name, ds, xname, error=False, default=[[]]
+            )
+            y = apply_mapper(
+                _get_with_standard_name, ds, yname, error=False, default=[[]]
+            )
+            coordinates = list(itertools.chain(x, y))
 
     return GridMapping(name=cf_name, crs=crs, array=da, coordinates=tuple(coordinates))
 
@@ -796,7 +903,6 @@ def _guess_bounds(da, dim=None, out_dim="bounds"):
                 f"If dim is None, variable {da.name} must be 1D or 2D. Received {da.ndim}D variable instead."
             )
         dim = da.dims
-
     if not isinstance(dim, str):
         if len(dim) > 2:
             raise NotImplementedError(

{cf_xarray-0.10.9 → cf_xarray-0.10.11}/cf_xarray/datasets.py

@@ -784,6 +784,52 @@ try:
         np.zeros((10, 20)),
         {"standard_name": "projected_y_coordinate"},
     )
+    # HEALPix dataset: refinement_level=1, nside=2, 12*nside^2 = 48 pixels, nested ordering
+    healpix_ds = xr.Dataset(
+        {
+            "tas": xr.DataArray(
+                np.random.default_rng(42).standard_normal((2, 48)).astype(np.float32),
+                dims=["time", "healpix_index"],
+                attrs={
+                    "standard_name": "air_temperature",
+                    "units": "K",
+                    "coordinates": "height",
+                    "grid_mapping": "healpix",
+                    "cell_methods": "time: mean area: mean",
+                },
+            ),
+            "healpix": xr.DataArray(
+                np.int32(0),
+                attrs={
+                    "grid_mapping_name": "healpix",
+                    "earth_radius": 6371000,
+                    "indexing_scheme": "nested",
+                    "refinement_level": 1,
+                },
+            ),
+        },
+        coords={
+            "time": xr.DataArray(
+                [0.0, 1.0],
+                dims=["time"],
+                attrs={
+                    "standard_name": "time",
+                    "calendar": "proleptic_gregorian",
+                    "units": "days since 2025-06-01",
+                },
+            ),
+            "healpix_index": xr.DataArray(
+                np.arange(48),
+                dims=["healpix_index"],
+                attrs={"standard_name": "healpix_index"},
+            ),
+            "height": xr.DataArray(
+                np.float32(2.0),
+                attrs={"standard_name": "height", "units": "m"},
+            ),
+        },
+    )
+
 except ImportError:
     pass
 
@@ -815,3 +861,145 @@ def encoded_point_dataset():
         {"geometry": "geometry_container"},
     )
     return ds
+
+
+# --- Reduced Gaussian Grid test fixtures ---
+# A tiny O2 octahedral reduced gaussian grid with 4 latitudes and 40 total points.
+
+
+def _create_reduced_gaussian_global():
+    """Create a small O2 reduced gaussian grid dataset (full global)."""
+    lat = np.array([59.44, 19.47, -19.47, -59.44])
+    pl = np.array([8, 12, 12, 8], dtype=np.int32)
+    total = int(np.sum(pl))  # 40
+
+    rng = np.random.default_rng(42)
+    temp_data = rng.standard_normal((1, 1, total)).astype(np.float32)
+
+    ds = xr.Dataset(
+        {
+            "air_temperature": xr.DataArray(
+                temp_data,
+                dims=["time", "height", "reduced_gaussian_index"],
+                attrs={
+                    "grid_mapping": "reduced_gaussian",
+                    "coordinates": "reduced_gaussian_index",
+                    "standard_name": "air_temperature",
+                    "units": "K",
+                },
+            ),
+            "reduced_gaussian": xr.DataArray(
+                np.int32(0),
+                attrs={
+                    "grid_mapping_name": "reduced_gaussian",
+                    "grid_subtype": "octahedral",
+                    "points_per_latitude": "pl",
+                    "latitude_dimension": "lat",
+                    "semi_major_axis": 6371229.0,
+                    "semi_minor_axis": 6371229.0,
+                },
+            ),
+        },
+        coords={
+            "lat": xr.DataArray(
+                lat,
+                dims=["lat"],
+                attrs={"standard_name": "latitude", "units": "degrees_north"},
+            ),
+            "pl": xr.DataArray(
+                pl,
+                dims=["lat"],
+                attrs={"long_name": "number of points per latitude"},
+            ),
+            "reduced_gaussian_index": xr.DataArray(
+                np.arange(total, dtype=np.int32),
+                dims=["reduced_gaussian_index"],
+                attrs={"standard_name": "reduced_gaussian_index"},
+            ),
+            "time": xr.DataArray(
+                [0.0], dims=["time"], attrs={"units": "hours since 2024-01-01"}
+            ),
+            "height": xr.DataArray([2.0], dims=["height"], attrs={"units": "m"}),
+        },
+    )
+    return ds
+
+
+def _create_reduced_gaussian_land():
+    """Create a small O2 reduced gaussian grid with compression by gathering (land subset)."""
+    global_ds = _create_reduced_gaussian_global()
+    land_indices = np.array([2, 5, 10, 15, 20, 25, 30, 35], dtype=np.int32)
+
+    rng = np.random.default_rng(43)
+    temp_data = rng.standard_normal((1, 1, len(land_indices))).astype(np.float32)
+
+    ds = xr.Dataset(
+        {
+            "air_temperature": xr.DataArray(
+                temp_data,
+                dims=["time", "height", "grid_points"],
+                attrs={
+                    "grid_mapping": "reduced_gaussian",
+                    "coordinates": "time height reduced_gaussian_index",
+                },
+            ),
+            "reduced_gaussian": global_ds["reduced_gaussian"],
+        },
+        coords={
+            "lat": global_ds["lat"],
+            "pl": global_ds["pl"],
+            "reduced_gaussian_index": global_ds["reduced_gaussian_index"],
+            "grid_points": xr.DataArray(
+                land_indices,
+                dims=["grid_points"],
+                attrs={"compress": "reduced_gaussian_index"},
+            ),
+            "time": global_ds["time"],
+            "height": global_ds["height"],
+        },
+    )
+    return ds
+
+
+def _create_reduced_gaussian_region():
+    """Create a small O2 reduced gaussian grid with compression (regional subset)."""
+    global_ds = _create_reduced_gaussian_global()
+    region_indices = np.array([8, 9, 10, 11, 12, 13, 14], dtype=np.int32)
+
+    rng = np.random.default_rng(44)
+    temp_data = rng.standard_normal((1, 1, len(region_indices))).astype(np.float32)
+
+    ds = xr.Dataset(
+        {
+            "air_temperature": xr.DataArray(
+                temp_data,
+                dims=["time", "height", "grid_points"],
+                attrs={
+                    "grid_mapping": "reduced_gaussian",
+                    "coordinates": "time height reduced_gaussian_index",
+                },
+            ),
+            "reduced_gaussian": global_ds["reduced_gaussian"],
+        },
+        coords={
+            "lat": global_ds["lat"],
+            "pl": global_ds["pl"],
+            "reduced_gaussian_index": global_ds["reduced_gaussian_index"],
+            "grid_points": xr.DataArray(
+                region_indices,
+                dims=["grid_points"],
+                attrs={
+                    "standard_name": "reduced_gaussian_index",
+                    "compress": "reduced_gaussian_index",
+                },
+            ),
+            "time": global_ds["time"],
+            "height": global_ds["height"],
+        },
+    )
+    return ds
+
+
+reduced_gaussian_global_ds = _create_reduced_gaussian_global()
+reduced_gaussian_land_ds = _create_reduced_gaussian_land()
+reduced_gaussian_region_ds = _create_reduced_gaussian_region()

{cf_xarray-0.10.9 → cf_xarray-0.10.11}/cf_xarray/geometry.py

@@ -586,7 +586,11 @@ def points_to_cf(
         coord = None
         pts_ = pts
 
-    x, y, node_count, crdX, crdY = [], [], [], [], []
+    x: list[np.ndarray] = []
+    y: list[np.ndarray] = []
+    node_count: list[int] = []
+    crdX: list[float] = []
+    crdY: list[float] = []
     for pt in pts_:
         if isinstance(pt, MultiPoint):
             xy = np.concatenate([p.coords for p in pt.geoms])

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

@@ -34,7 +34,7 @@ def _guess_bounds_1d(da, dim):
     result = xr.concat([first, bounds], dim=dim).transpose(..., "bounds")
     if ADDED_INDEX:
         result = result.drop_vars(dim)
-    return result
+    return result.drop_attrs(deep=False)
 
 
 def _guess_bounds_2d(da, dims):
@@ -338,6 +338,12 @@ def _get_ordered_vertices(
         elif order == "descending":
             endpoints = np.maximum(bounds[..., :, 0], bounds[..., :, 1])
             last_endpoint = np.minimum(bounds[..., -1, 0], bounds[..., -1, 1])
+        else:
+            raise NotImplementedError(
+                f"Cannot determine vertices for non-monotonic bounds with {order} core "
+                "dimension orders. Try normalizing the coordinates to a monotonic "
+                "convention and try again."
+            )
 
         vertices = np.concatenate(
             [endpoints, np.expand_dims(last_endpoint, axis=-1)], axis=-1

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

@@ -832,6 +832,9 @@ def test_add_bounds(dims):
         assert_allclose(
             added[name].reset_coords(drop=True), expected[dim].transpose(..., "bounds")
         )
+        if dim == "lat":
+            # The CF axes shouldn't have changed
+            assert added.cf.axes["Y"] == ["lat"]
 
     _check_unchanged(original, ds)
 
@@ -1261,6 +1264,132 @@ def test_grid_mappings_coordinates_attribute():
             )
 
 
+@requires_pyproj
+def test_reduced_gaussian_grid_mapping_global():
+    """Test GridMapping integration for a full reduced gaussian grid."""
+    from ..datasets import reduced_gaussian_global_ds as ds
+
+    # Grid mapping discovery
+    assert ds.cf.grid_mapping_names == {"reduced_gaussian": ["reduced_gaussian"]}
+
+    # CF indexing returns the grid mapping variable
+    gm_var = ds.cf["reduced_gaussian"]
+    assert gm_var.attrs["grid_mapping_name"] == "reduced_gaussian"
+    assert gm_var.attrs["grid_subtype"] == "octahedral"
+
+    # Grid mapping propagation to data variables
+    da = ds.cf["air_temperature"]
+    assert "reduced_gaussian" in da.coords
+
+    # grid_mapping_name property
+    assert da.cf.grid_mapping_name == "reduced_gaussian"
+
+    # .cf.grid_mappings property returns valid GridMapping
+    gms = ds.cf.grid_mappings
+    assert len(gms) == 1
+    gm = gms[0]
+    assert gm.name == "reduced_gaussian"
+    assert gm.crs is not None
+    assert gm.crs.is_geographic
+    assert gm.array.name == "reduced_gaussian"
+    assert gm.array.shape == ()  # scalar variable
+    assert isinstance(gm.coordinates, tuple)
+    # Should detect reduced_gaussian_index via standard_name
+    assert "reduced_gaussian_index" in gm.coordinates
+
+    # DataArray grid_mappings should also work
+    da_gms = da.cf.grid_mappings
+    assert len(da_gms) == 1
+    assert da_gms[0].name == "reduced_gaussian"
+    assert da_gms[0].crs.is_geographic
+
+    # Repr should include reduced_gaussian
+    assert "reduced_gaussian" in ds.cf.__repr__()
+
+
+@requires_pyproj
+def test_reduced_gaussian_grid_mapping_land():
+    """Test GridMapping for a land-only subset using CF compress/gather."""
+    from ..datasets import reduced_gaussian_land_ds as ds
+
+    # Grid mapping discovery
+    assert ds.cf.grid_mapping_names == {"reduced_gaussian": ["reduced_gaussian"]}
+
+    # Grid mapping propagation
+    da = ds.cf["air_temperature"]
+    assert "reduced_gaussian" in da.coords
+
+    # .cf.grid_mappings property
+    gms = ds.cf.grid_mappings
+    assert len(gms) == 1
+    gm = gms[0]
+    assert gm.name == "reduced_gaussian"
+    assert gm.crs.is_geographic
+    assert gm.array.attrs["grid_subtype"] == "octahedral"
+
+    # Coordinates should include the compress/gather variable
+    assert "grid_points" in gm.coordinates
+
+    # Verify the dataset structure: data on grid_points, with compress attribute
+    assert "grid_points" in ds.dims
+    assert "compress" in ds.grid_points.attrs
+    assert ds.grid_points.attrs["compress"] == "reduced_gaussian_index"
+
+
+@requires_pyproj
+def test_reduced_gaussian_grid_mapping_region():
+    """Test GridMapping for a regional subset using CF compress/gather."""
+    from ..datasets import reduced_gaussian_region_ds as ds
+
+    # Grid mapping discovery
+    assert ds.cf.grid_mapping_names == {"reduced_gaussian": ["reduced_gaussian"]}
+
+    # Grid mapping propagation
+    da = ds.cf["air_temperature"]
+    assert "reduced_gaussian" in da.coords
+
+    # .cf.grid_mappings property
+    gms = ds.cf.grid_mappings
+    assert len(gms) == 1
+    gm = gms[0]
+    assert gm.name == "reduced_gaussian"
+    assert gm.crs.is_geographic
+
+    # Coordinates should include both reduced_gaussian_index and grid_points
+    assert "reduced_gaussian_index" in gm.coordinates
+    assert "grid_points" in gm.coordinates
+
+    # Verify compress structure
+    assert "grid_points" in ds.dims
+    assert ds.grid_points.attrs["compress"] == "reduced_gaussian_index"
+
+    # CRS earth parameters should match the grid mapping variable
+    gm_attrs = ds.reduced_gaussian.attrs
+    # The CRS should be built from semi_major/minor_axis
+    assert gm.crs.ellipsoid is not None
+    assert gm.crs.ellipsoid.semi_major_metre == gm_attrs["semi_major_axis"]
+
+
+@requires_pyproj
+def test_reduced_gaussian_crs_properties():
+    """Test that the CRS built for reduced_gaussian has correct properties."""
+    from ..datasets import reduced_gaussian_global_ds as ds
+
+    gm = ds.cf.grid_mappings[0]
+    crs = gm.crs
+
+    # Must be geographic (lat/lon on a sphere)
+    assert crs.is_geographic
+    assert not crs.is_projected
+
+    # Earth shape parameters from the grid mapping variable
+    assert crs.ellipsoid.semi_major_metre == 6371229.0
+    assert crs.ellipsoid.semi_minor_metre == 6371229.0
+
+    # Should not have an EPSG code (custom sphere)
+    assert crs.to_epsg() is None
+
+
 @requires_pyproj
 def test_bad_grid_mapping_attribute():
     ds = rotds.copy(deep=False)
@@ -1282,6 +1411,71 @@ def test_bad_grid_mapping_attribute():
     assert grid_mappings == ()  # No valid grid mappings since 'foo' doesn't exist
 
 
+@requires_pyproj
+def test_healpix_grid_mapping():
+    """Test GridMapping integration for HEALPix grids."""
+    from ..datasets import healpix_ds as ds
+
+    # Grid mapping discovery
+    assert ds.cf.grid_mapping_names == {"healpix": ["healpix"]}
+
+    # Grid mapping propagation to data variables
+    da = ds.cf["air_temperature"]
+    assert "healpix" in da.coords
+
+    # grid_mapping_name property
+    assert da.cf.grid_mapping_name == "healpix"
+
+    # .cf.grid_mappings property on Dataset
+    gms = ds.cf.grid_mappings
+    assert len(gms) == 1
+    gm = gms[0]
+    assert gm.name == "healpix"
+    assert gm.crs is not None
+    assert gm.crs.is_geographic
+    assert gm.array.name == "healpix"
+    assert gm.array.shape == ()  # scalar variable
+    assert isinstance(gm.coordinates, tuple)
+    # Should detect healpix_index via standard_name
+    assert "healpix_index" in gm.coordinates
+
+    # DataArray grid_mappings should also work
+    da_gms = da.cf.grid_mappings
+    assert len(da_gms) == 1
+    assert da_gms[0].name == "healpix"
+    assert da_gms[0].crs.is_geographic
+
+    # Repr should include healpix
+    assert "healpix" in ds.cf.__repr__()
+
+
+@requires_pyproj
+def test_healpix_crs_properties():
+    """Test that the CRS built for HEALPix has correct properties."""
+    from ..datasets import healpix_ds as ds
+
+    gm = ds.cf.grid_mappings[0]
+    crs = gm.crs
+
+    # Must be geographic (lat/lon on a sphere)
+    assert crs.is_geographic
+    assert not crs.is_projected
+
+    # Earth shape parameters from the grid mapping variable
+    assert crs.ellipsoid.semi_major_metre == 6371000
+    assert crs.ellipsoid.semi_minor_metre == 6371000
+
+    # Should not have an EPSG code (custom sphere)
+    assert crs.to_epsg() is None
+
+    # Verify HEALPix-specific attributes are preserved in the grid mapping array
+    gm_attrs = gm.array.attrs
+    assert gm_attrs["grid_mapping_name"] == "healpix"
+    assert gm_attrs["refinement_level"] == 1
+    assert gm_attrs["indexing_scheme"] == "nested"
+    assert gm_attrs["earth_radius"] == 6371000
+
+
 def test_docstring() -> None:
     assert "One of ('X'" in airds.cf.groupby.__doc__
     assert "Time variable accessor e.g. 'T.month'" in airds.cf.groupby.__doc__

{cf_xarray-0.10.9 → cf_xarray-0.10.11}/cf_xarray/units.py

@@ -60,7 +60,7 @@ def short_formatter(unit, registry, **options):
 # Reused with modification from MetPy under the terms of the BSD 3-Clause License.
 # Copyright (c) 2015,2017,2019 MetPy Developers.
 # Create registry, with preprocessors for UDUNITS-style powers (m2 s-2) and percent signs
-units = pint.UnitRegistry(
+units: pint.UnitRegistry = pint.UnitRegistry(
     autoconvert_offset_to_baseunit=True,
     preprocessors=[
         functools.partial(

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

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

{cf_xarray-0.10.9 → cf_xarray-0.10.11}/pyproject.toml

@@ -107,7 +107,6 @@ docstring-code-format = true
 
 
 [tool.pytest]
-python_files = "test_*.py"
 testpaths = ["cf_xarray/tests"]
 
 [tool.rstcheck]

cf_xarray-0.10.9/cf_xarray/_version.py

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