cf-xarray 0.8.7__tar.gz → 0.8.8__tar.gz

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/.github/workflows/pypi.yaml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         name: Install Python
         with:
           python-version: "3.10"
@@ -41,7 +41,7 @@ jobs:
           else
             echo "✅ Looks good"
           fi
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: releases
           path: dist
@@ -50,11 +50,11 @@ jobs:
     needs: build-artifacts
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         name: Install Python
         with:
           python-version: "3.10"
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: releases
           path: dist
@@ -91,7 +91,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: releases
           path: dist

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/.github/workflows/testpypi-release.yaml

@@ -21,7 +21,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         name: Install Python
         with:
           python-version: "3.10"
@@ -53,7 +53,7 @@ jobs:
             echo "✅ Looks good"
           fi
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: releases
           path: dist
@@ -62,11 +62,11 @@ jobs:
     needs: build-artifacts
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         name: Install Python
         with:
           python-version: "3.10"
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: releases
           path: dist

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/.pre-commit-config.yaml

@@ -10,13 +10,13 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.1.1'
+    rev: 'v0.1.9'
     hooks:
       - id: ruff
         args: ["--show-fixes", "--fix"]
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 23.10.1
+    rev: 23.12.1
     hooks:
       - id: black
 
@@ -36,7 +36,7 @@ repos:
         - mdformat-myst
 
   - repo: https://github.com/nbQA-dev/nbQA
-    rev: 1.7.0
+    rev: 1.7.1
     hooks:
         - id: nbqa-black
         - id: nbqa-ruff
@@ -56,7 +56,7 @@ repos:
       - id: debug-statements
 
   - repo: https://github.com/keewis/blackdoc
-    rev: v0.3.8
+    rev: v0.3.9
     hooks:
       - id: blackdoc
         files: .+\.py$

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/PKG-INFO

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

cf_xarray-0.8.8/cf_xarray/_version.py

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

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray/datasets.py

@@ -503,6 +503,16 @@ flag_indep = xr.DataArray(
     name="flag_var",
 )
 
+flag_indep_uint16 = xr.DataArray(
+    np.array([1, 10, 100, 1000, 10000, 65535], dtype=np.uint16),
+    dims=("time",),
+    attrs={
+        "flag_masks": [2**i for i in range(16)],
+        "flag_meanings": " ".join([f"flag_{2**i}" for i in range(16)]),
+        "standard_name": "flag_independent",
+    },
+    name="flag_var",
+)
 
 flag_mix = xr.DataArray(
     np.array([4, 8, 13, 5, 10, 14, 7, 3], np.uint8),

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray/formatting.py

@@ -151,8 +151,47 @@ def _maybe_panel(textgen, title: str, rich: bool):
         return title + ":\n" + text
 
 
-def find_set_bits(mask, value, repeated_masks):
-    bitpos = np.arange(8)[::-1]
+def _get_bit_length(dtype):
+    # Check if dtype is a numpy dtype, if not, convert it
+    if not isinstance(dtype, np.dtype):
+        dtype = np.dtype(dtype)
+
+    # Calculate the bit length
+    bit_length = 8 * dtype.itemsize
+
+    return bit_length
+
+
+def _unpackbits(mask, bit_length):
+    # Ensure the array is a numpy array
+    arr = np.asarray(mask)
+
+    # Create an output array of the appropriate shape
+    output_shape = arr.shape + (bit_length,)
+    output = np.zeros(output_shape, dtype=np.uint8)
+
+    # Unpack bits
+    for i in range(bit_length):
+        output[..., i] = (arr >> i) & 1
+
+    return output[..., ::-1]
+
+
+def _max_chars_for_bit_length(bit_length):
+    """
+    Find the maximum characters needed for a fixed-width display
+    for integer values of a certain bit_length. Use calculation
+    for signed integers, since it conservatively will always have
+    enough characters for signed or unsigned.
+    """
+    # Maximum value for signed integers of this bit length
+    max_val = 2 ** (bit_length - 1) - 1
+    # Add 1 for the negative sign
+    return len(str(max_val)) + 1
+
+
+def find_set_bits(mask, value, repeated_masks, bit_length):
+    bitpos = np.arange(bit_length)[::-1]
     if mask not in repeated_masks:
         if value == 0:
             return [-1]
@@ -161,8 +200,8 @@ def find_set_bits(mask, value, repeated_masks):
         else:
             return [int(np.log2(mask))]
     else:
-        allset = bitpos[np.unpackbits(np.uint8(mask)) == 1]
-        setbits = bitpos[np.unpackbits(np.uint8(mask & value)) == 1]
+        allset = bitpos[_unpackbits(mask, bit_length) == 1]
+        setbits = bitpos[_unpackbits(mask & value, bit_length) == 1]
         return [b if abs(b) in setbits else -b for b in allset]
 
 
@@ -184,6 +223,11 @@ def _format_flags(accessor, rich):
     #     for f, (m, _) in flag_dict.items()
     #     if m is not None and m not in repeated_masks
     # ]
+
+    bit_length = _get_bit_length(accessor._obj.dtype)
+    mask_width = _max_chars_for_bit_length(bit_length)
+    key_width = max(len(key) for key in flag_dict)
+
     bit_text = []
     value_text = []
     for key, (mask, value) in flag_dict.items():
@@ -191,8 +235,8 @@ def _format_flags(accessor, rich):
             bit_text.append("✗" if rich else "")
             value_text.append(str(value))
             continue
-        bits = find_set_bits(mask, value, repeated_masks)
-        bitstring = ["."] * 8
+        bits = find_set_bits(mask, value, repeated_masks, bit_length)
+        bitstring = ["."] * bit_length
         if bits == [-1]:
             continue
         else:
@@ -200,9 +244,9 @@ def _format_flags(accessor, rich):
                 bitstring[abs(b)] = _format_cf_name("1" if b >= 0 else "0", rich)
         text = "".join(bitstring[::-1])
         value_text.append(
-            f"{mask} & {value}"
+            f"{mask:{mask_width}} & {value}"
             if key in excl_flags and value is not None
-            else str(mask)
+            else f"{mask:{mask_width}}"
         )
         bit_text.append(text if rich else f" / Bit: {text}")
 
@@ -230,7 +274,9 @@ def _format_flags(accessor, rich):
     else:
         rows = []
         for val, bit, key in zip(value_text, bit_text, flag_dict):
-            rows.append(f"{TAB}{_format_cf_name(key, rich)}: {TAB} {val} {bit}")
+            rows.append(
+                f"{TAB}{_format_cf_name(key, rich):>{key_width}}: {TAB} {val} {bit}"
+            )
         return _print_rows("Flag Meanings", rows, rich)
 
 

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray/geometry.py

@@ -75,9 +75,6 @@ def shapely_to_cf(geometries: xr.DataArray | Sequence, grid_mapping: str | None
     """
     Convert a DataArray with shapely geometry objects into a CF-compliant dataset.
 
-    .. warning::
-        Only point geometries are currently implemented.
-
     Parameters
     ----------
     geometries : sequence of shapely geometries or xarray.DataArray
@@ -115,7 +112,7 @@ def shapely_to_cf(geometries: xr.DataArray | Sequence, grid_mapping: str | None
     elif types.issubset({"LineString", "MultiLineString"}):
         ds = lines_to_cf(geometries)
     elif types.issubset({"Polygon", "MultiPolygon"}):
-        raise NotImplementedError("Polygon geometry conversion is not implemented.")
+        ds = polygons_to_cf(geometries)
     else:
         raise ValueError(
             f"Mixed geometry types are not supported in CF-compliant datasets. Got {types}"
@@ -142,9 +139,6 @@ def cf_to_shapely(ds: xr.Dataset):
     """
     Convert geometries stored in a CF-compliant way to shapely objects stored in a single variable.
 
-    .. warning::
-        Only point geometries are currently implemented.
-
     Parameters
     ----------
     ds : xr.Dataset
@@ -168,7 +162,7 @@ def cf_to_shapely(ds: xr.Dataset):
     elif geom_type == "line":
         geometries = cf_to_lines(ds)
     elif geom_type == "polygon":
-        raise NotImplementedError("Polygon geometry conversion is not implemented.")
+        geometries = cf_to_polygons(ds)
     else:
         raise ValueError(
             f"Valid CF geometry types are 'point', 'line' and 'polygon'. Got {geom_type}"
@@ -328,13 +322,13 @@ def lines_to_cf(lines: xr.DataArray | Sequence):
     x = arr[:, 0]
     y = arr[:, 1]
 
-    node_count = np.diff(offsets[0])
+    part_node_count = np.diff(offsets[0])
     if len(offsets) == 1:
         indices = offsets[0]
-        part_node_count = node_count
+        node_count = part_node_count
     else:
         indices = np.take(offsets[0], offsets[1])
-        part_node_count = np.diff(indices)
+        node_count = np.diff(indices)
 
     geom_coords = arr.take(indices[:-1], 0)
     crdX = geom_coords[:, 0]
@@ -342,8 +336,8 @@ def lines_to_cf(lines: xr.DataArray | Sequence):
 
     ds = xr.Dataset(
         data_vars={
-            "node_count": xr.DataArray(node_count, dims=("segment",)),
-            "part_node_count": xr.DataArray(part_node_count, dims=(dim,)),
+            "node_count": xr.DataArray(node_count, dims=(dim,)),
+            "part_node_count": xr.DataArray(part_node_count, dims=("part",)),
             "geometry_container": xr.DataArray(
                 attrs={
                     "geometry_type": "line",
@@ -394,7 +388,7 @@ def cf_to_lines(ds: xr.Dataset):
     # Shorthand for convenience
     geo = ds.geometry_container.attrs
 
-    # The features dimension name, defaults to the one of 'part_node_count'
+    # The features dimension name, defaults to the one of 'node_count'
     # or the dimension of the coordinates, if present.
     feat_dim = None
     if "coordinates" in geo:
@@ -405,36 +399,188 @@ def cf_to_lines(ds: xr.Dataset):
     xy = np.stack([ds[x_name].values, ds[y_name].values], axis=-1)
 
     node_count_name = geo.get("node_count")
-    part_node_count_name = geo.get("part_node_count")
+    part_node_count_name = geo.get("part_node_count", node_count_name)
     if node_count_name is None:
         raise ValueError("'node_count' must be provided for line geometries")
     else:
         node_count = ds[node_count_name]
+        feat_dim = feat_dim or "index"
+        if feat_dim in ds.coords:
+            node_count = node_count.assign_coords({feat_dim: ds[feat_dim]})
 
-    offset1 = np.insert(np.cumsum(node_count.values), 0, 0)
+    # first get geometries for all the parts
+    part_node_count = ds[part_node_count_name]
+    offset1 = np.insert(np.cumsum(part_node_count.values), 0, 0)
     lines = from_ragged_array(GeometryType.LINESTRING, xy, offsets=(offset1,))
 
-    if part_node_count_name is None:
-        # No part_node_count means there are no multilines
-        # And if we had no coordinates, then the dimension defaults to "index"
+    # get index of offset2 values that are edges for part_node_count
+    offset2 = np.nonzero(np.isin(offset1, np.insert(np.cumsum(node_count), 0, 0)))[0]
+
+    multilines = from_ragged_array(
+        GeometryType.MULTILINESTRING, xy, offsets=(offset1, offset2)
+    )
+
+    # get items from lines or multilines depending on number of parts
+    geoms = np.where(np.diff(offset2) == 1, lines[offset2[:-1]], multilines)
+
+    return xr.DataArray(geoms, dims=node_count.dims, coords=node_count.coords)
+
+
+def polygons_to_cf(polygons: xr.DataArray | Sequence):
+    """Convert an iterable of polygons (shapely.geometry.[Multi]Polygon) into a CF-compliant geometry dataset.
+
+    Parameters
+    ----------
+    polygons : sequence of shapely.geometry.Polygon or MultiPolygon
+        The sequence of [multi]polygons to translate to a CF dataset.
+
+    Returns
+    -------
+    xr.Dataset
+        A Dataset with variables 'x', 'y', 'crd_x', 'crd_y', 'node_count' and 'geometry_container'
+        and optionally 'part_node_count'.
+    """
+    from shapely import to_ragged_array
+
+    if isinstance(polygons, xr.DataArray):
+        dim = polygons.dims[0]
+        coord = polygons[dim] if dim in polygons.coords else None
+        polygons_ = polygons.values
+    else:
+        dim = "index"
+        coord = None
+        polygons_ = np.array(polygons)
+
+    _, arr, offsets = to_ragged_array(polygons_)
+    x = arr[:, 0]
+    y = arr[:, 1]
+
+    part_node_count = np.diff(offsets[0])
+    if len(offsets) == 1:
+        indices = offsets[0]
+        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)
+
+        if len(offsets) == 3:
+            indices = np.take(indices, offsets[2])
+
+        node_count = np.diff(indices)
+
+    geom_coords = arr.take(indices[:-1], 0)
+    crdX = geom_coords[:, 0]
+    crdY = geom_coords[:, 1]
+
+    ds = xr.Dataset(
+        data_vars={
+            "node_count": xr.DataArray(node_count, dims=(dim,)),
+            "interior_ring": xr.DataArray(interior_ring, dims=("part",)),
+            "part_node_count": xr.DataArray(part_node_count, dims=("part",)),
+            "geometry_container": xr.DataArray(
+                attrs={
+                    "geometry_type": "polygon",
+                    "node_count": "node_count",
+                    "part_node_count": "part_node_count",
+                    "interior_ring": "interior_ring",
+                    "node_coordinates": "x y",
+                    "coordinates": "crd_x crd_y",
+                }
+            ),
+        },
+        coords={
+            "x": xr.DataArray(x, dims=("node",), attrs={"axis": "X"}),
+            "y": xr.DataArray(y, dims=("node",), attrs={"axis": "Y"}),
+            "crd_x": xr.DataArray(crdX, dims=(dim,), attrs={"nodes": "x"}),
+            "crd_y": xr.DataArray(crdY, dims=(dim,), attrs={"nodes": "y"}),
+        },
+    )
+
+    if coord is not None:
+        ds = ds.assign_coords({dim: coord})
+
+    # Special case when we have no MultiPolygons and no holes
+    if len(ds.part_node_count) == len(ds.node_count):
+        ds = ds.drop_vars("part_node_count")
+        del ds.geometry_container.attrs["part_node_count"]
+
+    # Special case when we have no holes
+    if (ds.interior_ring == 0).all():
+        ds = ds.drop_vars("interior_ring")
+        del ds.geometry_container.attrs["interior_ring"]
+    return ds
+
+
+def cf_to_polygons(ds: xr.Dataset):
+    """Convert polygon geometries stored in a CF-compliant way to shapely polygons stored in a single variable.
+
+    Parameters
+    ----------
+    ds : xr.Dataset
+        A dataset with CF-compliant polygon geometries.
+        Must have a "geometry_container" variable with at least a 'node_coordinates' attribute.
+        Must also have the two 1D variables listed by this attribute.
+
+    Returns
+    -------
+    geometry : xr.DataArray
+        A 1D array of shapely.geometry.[Multi]Polygon objects.
+        It has the same dimension as the ``part_node_count`` or the coordinates variables, or
+        ``'features'`` if those were not present in ``ds``.
+    """
+    from shapely import GeometryType, from_ragged_array
+
+    # Shorthand for convenience
+    geo = ds.geometry_container.attrs
+
+    # The features dimension name, defaults to the one of 'part_node_count'
+    # or the dimension of the coordinates, if present.
+    feat_dim = None
+    if "coordinates" in geo:
+        xcoord_name, _ = geo["coordinates"].split(" ")
+        (feat_dim,) = ds[xcoord_name].dims
+
+    x_name, y_name = geo["node_coordinates"].split(" ")
+    xy = np.stack([ds[x_name].values, ds[y_name].values], axis=-1)
+
+    node_count_name = geo.get("node_count")
+    part_node_count_name = geo.get("part_node_count", node_count_name)
+    interior_ring_name = geo.get("interior_ring")
+
+    if node_count_name is None:
+        raise ValueError("'node_count' must be provided for polygon geometries")
+    else:
+        node_count = ds[node_count_name]
         feat_dim = feat_dim or "index"
-        part_node_count = xr.DataArray(node_count.values, dims=(feat_dim,))
         if feat_dim in ds.coords:
-            part_node_count = part_node_count.assign_coords({feat_dim: ds[feat_dim]})
+            node_count = node_count.assign_coords({feat_dim: ds[feat_dim]})
 
-        geoms = lines
+    # first get geometries for all the rings
+    part_node_count = ds[part_node_count_name]
+    offset1 = np.insert(np.cumsum(part_node_count.values), 0, 0)
+
+    if interior_ring_name is None:
+        offset2 = np.array(list(range(len(offset1))))
     else:
-        part_node_count = ds[part_node_count_name]
-
-        # get index of offset1 values that are edges for part_node_count
-        offset2 = np.nonzero(
-            np.isin(offset1, np.insert(np.cumsum(part_node_count), 0, 0))
-        )[0]
-        multilines = from_ragged_array(
-            GeometryType.MULTILINESTRING, xy, offsets=(offset1, offset2)
+        interior_ring = ds[interior_ring_name]
+        if not interior_ring[0] == 0:
+            raise ValueError("coordinate array must start with an exterior ring")
+        offset2 = np.append(np.where(interior_ring == 0)[0], [len(part_node_count)])
+
+    polygons = from_ragged_array(GeometryType.POLYGON, xy, offsets=(offset1, offset2))
+
+    # get index of offset2 values that are edges for node_count
+    offset3 = np.nonzero(
+        np.isin(
+            offset2,
+            np.nonzero(np.isin(offset1, np.insert(np.cumsum(node_count), 0, 0)))[0],
         )
+    )[0]
+    multipolygons = from_ragged_array(
+        GeometryType.MULTIPOLYGON, xy, offsets=(offset1, offset2, offset3)
+    )
 
-        # get items from lines or multilines depending on number of segments
-        geoms = np.where(np.diff(offset2) == 1, lines[offset2[:-1]], multilines)
+    # get items from polygons or multipolygons depending on number of parts
+    geoms = np.where(np.diff(offset3) == 1, polygons[offset3[:-1]], multipolygons)
 
-    return xr.DataArray(geoms, dims=part_node_count.dims, coords=part_node_count.coords)
+    return xr.DataArray(geoms, dims=node_count.dims, coords=node_count.coords)

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray/tests/test_accessor.py

@@ -26,6 +26,7 @@ from ..datasets import (
     dsg,
     flag_excl,
     flag_indep,
+    flag_indep_uint16,
     flag_mix,
     forecast,
     mollwds,
@@ -164,6 +165,7 @@ def test_repr() -> None:
     # Flag DataArray
     assert "Flag Variable" in repr(flag_excl.cf)
     assert "Flag Variable" in repr(flag_indep.cf)
+    assert "Flag Variable" in repr(flag_indep_uint16.cf)
     assert "Flag Variable" in repr(flag_mix.cf)
     assert "Flag Variable" in repr(basin.cf)
 
@@ -1837,6 +1839,30 @@ class TestFlags:
             res = flag_indep.cf.flags[name]
             np.testing.assert_equal(res.to_numpy(), expected[i])
 
+    def test_flag_indep_uint16(self) -> None:
+        expected = [
+            [True, False, False, False, False, True],  # bit     1
+            [False, True, False, False, False, True],  # bit     2
+            [False, False, True, False, False, True],  # bit     4
+            [False, True, False, True, False, True],  # bit     8
+            [False, False, False, False, True, True],  # bit    16
+            [False, False, True, True, False, True],  # bit    32
+            [False, False, True, True, False, True],  # bit    64
+            [False, False, False, True, False, True],  # bit   128
+            [False, False, False, True, True, True],  # bit   256
+            [False, False, False, True, True, True],  # bit   512
+            [False, False, False, False, True, True],  # bit  1024
+            [False, False, False, False, False, True],  # bit  2048
+            [False, False, False, False, False, True],  # bit  4096
+            [False, False, False, False, True, True],  # bit  8192
+            [False, False, False, False, False, True],  # bit 16384
+            [False, False, False, False, False, True],  # bit 32768
+        ]
+        for i in range(16):
+            name = f"flag_{2**i}"
+            res = flag_indep_uint16.cf.flags[name]
+            np.testing.assert_equal(res.to_numpy(), expected[i])
+
     def test_flag_mix(self) -> None:
         expected = [
             [False, False, True, True, False, False, True, True],  # flag 1
@@ -1983,6 +2009,7 @@ def test_curvefit() -> None:
         [basin, "Flag Variable"],
         [flag_mix, "Flag Variable"],
         [flag_indep, "Flag Variable"],
+        [flag_indep_uint16, "Flag Variable"],
         [flag_excl, "Flag Variable"],
         [dsg, "Discrete Sampling Geometry"],
     ),

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray/tests/test_geometry.py

@@ -71,8 +71,8 @@ def geometry_line_ds():
         y=xr.DataArray(
             [0, 2, 4, 6, 0, 0, 1, 1.0, 2.0, 9.5], dims=("node",), attrs={"axis": "Y"}
         ),
-        part_node_count=xr.DataArray([4, 3, 3], dims=("index",)),
-        node_count=xr.DataArray([2, 2, 3, 3], dims=("segment",)),
+        node_count=xr.DataArray([4, 3, 3], dims=("index",)),
+        part_node_count=xr.DataArray([2, 2, 3, 3], dims=("part",)),
         crd_x=xr.DataArray([0.0, 0.0, 1.0], dims=("index",), attrs={"nodes": "x"}),
         crd_y=xr.DataArray([0.0, 0.0, 1.0], dims=("index",), attrs={"nodes": "y"}),
         geometry_container=xr.DataArray(
@@ -108,7 +108,7 @@ def geometry_line_without_multilines_ds():
     cf_ds = ds.assign(
         x=xr.DataArray([0, 1, 1, 1.0, 2.0, 1.7], dims=("node",), attrs={"axis": "X"}),
         y=xr.DataArray([0, 0, 1, 1.0, 2.0, 9.5], dims=("node",), attrs={"axis": "Y"}),
-        node_count=xr.DataArray([3, 3], dims=("segment",)),
+        node_count=xr.DataArray([3, 3], dims=("index",)),
         crd_x=xr.DataArray([0.0, 1.0], dims=("index",), attrs={"nodes": "x"}),
         crd_y=xr.DataArray([0.0, 1.0], dims=("index",), attrs={"nodes": "y"}),
         geometry_container=xr.DataArray(
@@ -126,6 +126,154 @@ def geometry_line_without_multilines_ds():
     return cf_ds, shp_da
 
 
+@pytest.fixture
+def geometry_polygon_without_holes_ds():
+    from shapely.geometry import Polygon
+
+    # empty/fill workaround to avoid numpy deprecation(warning) due to the array interface of shapely geometries.
+    geoms = np.empty(2, dtype=object)
+    geoms[:] = [
+        Polygon(([50, 0], [40, 15], [30, 0])),
+        Polygon(([70, 50], [60, 65], [50, 50])),
+    ]
+
+    ds = xr.Dataset()
+    shp_da = xr.DataArray(geoms, dims=("index",), name="geometry")
+
+    cf_ds = ds.assign(
+        x=xr.DataArray(
+            [50, 40, 30, 50, 70, 60, 50, 70], dims=("node",), attrs={"axis": "X"}
+        ),
+        y=xr.DataArray(
+            [0, 15, 0, 0, 50, 65, 50, 50], dims=("node",), attrs={"axis": "Y"}
+        ),
+        node_count=xr.DataArray([4, 4], dims=("index",)),
+        crd_x=xr.DataArray([50, 70], dims=("index",), attrs={"nodes": "x"}),
+        crd_y=xr.DataArray([0, 50], dims=("index",), attrs={"nodes": "y"}),
+        geometry_container=xr.DataArray(
+            attrs={
+                "geometry_type": "polygon",
+                "node_count": "node_count",
+                "node_coordinates": "x y",
+                "coordinates": "crd_x crd_y",
+            }
+        ),
+    )
+
+    cf_ds = cf_ds.set_coords(["x", "y", "crd_x", "crd_y"])
+
+    return cf_ds, shp_da
+
+
+@pytest.fixture
+def geometry_polygon_without_multipolygons_ds():
+    from shapely.geometry import Polygon
+
+    # empty/fill workaround to avoid numpy deprecation(warning) due to the array interface of shapely geometries.
+    geoms = np.empty(2, dtype=object)
+    geoms[:] = [
+        Polygon(([50, 0], [40, 15], [30, 0])),
+        Polygon(
+            ([70, 50], [60, 65], [50, 50]),
+            [
+                ([55, 55], [60, 60], [65, 55]),
+            ],
+        ),
+    ]
+
+    ds = xr.Dataset()
+    shp_da = xr.DataArray(geoms, dims=("index",), name="geometry")
+
+    cf_ds = ds.assign(
+        x=xr.DataArray(
+            [50, 40, 30, 50, 70, 60, 50, 70, 55, 60, 65, 55],
+            dims=("node",),
+            attrs={"axis": "X"},
+        ),
+        y=xr.DataArray(
+            [0, 15, 0, 0, 50, 65, 50, 50, 55, 60, 55, 55],
+            dims=("node",),
+            attrs={"axis": "Y"},
+        ),
+        node_count=xr.DataArray([4, 8], dims=("index",)),
+        part_node_count=xr.DataArray([4, 4, 4], dims=("part",)),
+        interior_ring=xr.DataArray([0, 0, 1], dims=("part",)),
+        crd_x=xr.DataArray([50, 70], dims=("index",), attrs={"nodes": "x"}),
+        crd_y=xr.DataArray([0, 50], dims=("index",), attrs={"nodes": "y"}),
+        geometry_container=xr.DataArray(
+            attrs={
+                "geometry_type": "polygon",
+                "node_count": "node_count",
+                "part_node_count": "part_node_count",
+                "interior_ring": "interior_ring",
+                "node_coordinates": "x y",
+                "coordinates": "crd_x crd_y",
+            }
+        ),
+    )
+
+    cf_ds = cf_ds.set_coords(["x", "y", "crd_x", "crd_y"])
+
+    return cf_ds, shp_da
+
+
+@pytest.fixture
+def geometry_polygon_ds():
+    from shapely.geometry import MultiPolygon, Polygon
+
+    # empty/fill workaround to avoid numpy deprecation(warning) due to the array interface of shapely geometries.
+    geoms = np.empty(2, dtype=object)
+    geoms[:] = [
+        MultiPolygon(
+            [
+                (
+                    ([20, 0], [10, 15], [0, 0]),
+                    [
+                        ([5, 5], [10, 10], [15, 5]),
+                    ],
+                ),
+                (([20, 20], [10, 35], [0, 20]),),
+            ]
+        ),
+        Polygon(([50, 0], [40, 15], [30, 0])),
+    ]
+
+    ds = xr.Dataset()
+    shp_da = xr.DataArray(geoms, dims=("index",), name="geometry")
+
+    cf_ds = ds.assign(
+        x=xr.DataArray(
+            [20, 10, 0, 20, 5, 10, 15, 5, 20, 10, 0, 20, 50, 40, 30, 50],
+            dims=("node",),
+            attrs={"axis": "X"},
+        ),
+        y=xr.DataArray(
+            [0, 15, 0, 0, 5, 10, 5, 5, 20, 35, 20, 20, 0, 15, 0, 0],
+            dims=("node",),
+            attrs={"axis": "Y"},
+        ),
+        node_count=xr.DataArray([12, 4], dims=("index",)),
+        part_node_count=xr.DataArray([4, 4, 4, 4], dims=("part",)),
+        interior_ring=xr.DataArray([0, 1, 0, 0], dims=("part",)),
+        crd_x=xr.DataArray([20, 50], dims=("index",), attrs={"nodes": "x"}),
+        crd_y=xr.DataArray([0, 0], dims=("index",), attrs={"nodes": "y"}),
+        geometry_container=xr.DataArray(
+            attrs={
+                "geometry_type": "polygon",
+                "node_count": "node_count",
+                "part_node_count": "part_node_count",
+                "interior_ring": "interior_ring",
+                "node_coordinates": "x y",
+                "coordinates": "crd_x crd_y",
+            }
+        ),
+    )
+
+    cf_ds = cf_ds.set_coords(["x", "y", "crd_x", "crd_y"])
+
+    return cf_ds, shp_da
+
+
 @requires_shapely
 def test_shapely_to_cf(geometry_ds):
     from shapely.geometry import Point
@@ -192,6 +340,43 @@ def test_shapely_to_cf_for_lines_without_multilines(
     xr.testing.assert_identical(actual, expected)
 
 
+@requires_shapely
+def test_shapely_to_cf_for_polygons_as_da(geometry_polygon_ds):
+    expected, in_da = geometry_polygon_ds
+
+    actual = cfxr.shapely_to_cf(in_da)
+    xr.testing.assert_identical(actual, expected)
+
+    in_da = in_da.assign_coords(index=["a", "b"])
+    actual = cfxr.shapely_to_cf(in_da)
+    xr.testing.assert_identical(actual, expected.assign_coords(index=["a", "b"]))
+
+
+@requires_shapely
+def test_shapely_to_cf_for_polygons_as_sequence(geometry_polygon_ds):
+    expected, in_da = geometry_polygon_ds
+    actual = cfxr.shapely_to_cf(in_da.values)
+    xr.testing.assert_identical(actual, expected)
+
+
+@requires_shapely
+def test_shapely_to_cf_for_polygons_without_multipolygons(
+    geometry_polygon_without_multipolygons_ds,
+):
+    expected, in_da = geometry_polygon_without_multipolygons_ds
+    actual = cfxr.shapely_to_cf(in_da)
+    xr.testing.assert_identical(actual, expected)
+
+
+@requires_shapely
+def test_shapely_to_cf_for_polygons_without_holes(
+    geometry_polygon_without_holes_ds,
+):
+    expected, in_da = geometry_polygon_without_holes_ds
+    actual = cfxr.shapely_to_cf(in_da)
+    xr.testing.assert_identical(actual, expected)
+
+
 @requires_shapely
 def test_shapely_to_cf_errors():
     from shapely.geometry import Point, Polygon
@@ -199,13 +384,8 @@ def test_shapely_to_cf_errors():
     geoms = [
         Polygon([[1, 1], [1, 3], [3, 3], [1, 1]]),
         Polygon([[1, 1, 4], [1, 3, 4], [3, 3, 3], [1, 1, 4]]),
+        Point(1, 2),
     ]
-    with pytest.raises(
-        NotImplementedError, match="Polygon geometry conversion is not implemented"
-    ):
-        cfxr.shapely_to_cf(geoms)
-
-    geoms.append(Point(1, 2))
     with pytest.raises(ValueError, match="Mixed geometry types are not supported"):
         cfxr.shapely_to_cf(geoms)
 
@@ -247,7 +427,7 @@ def test_cf_to_shapely_for_lines_without_multilines(
     in_ds, expected = geometry_line_without_multilines_ds
     actual = cfxr.cf_to_shapely(in_ds)
     assert actual.dims == ("index",)
-    xr.testing.assert_identical(actual, expected)
+    xr.testing.assert_identical(actual.drop_vars(["crd_x", "crd_y"]), expected)
 
     in_ds = in_ds.assign_coords(index=["b", "c"])
     actual = cfxr.cf_to_shapely(in_ds)
@@ -258,12 +438,51 @@ def test_cf_to_shapely_for_lines_without_multilines(
 
 
 @requires_shapely
-def test_cf_to_shapely_errors(geometry_ds, geometry_line_ds):
-    in_ds, _ = geometry_ds
-    in_ds.geometry_container.attrs["geometry_type"] = "polygon"
-    with pytest.raises(NotImplementedError, match="Polygon geometry"):
-        cfxr.cf_to_shapely(in_ds)
+def test_cf_to_shapely_for_polygons(geometry_polygon_ds):
+    in_ds, expected = geometry_polygon_ds
+
+    actual = cfxr.cf_to_shapely(in_ds)
+    assert actual.dims == ("index",)
+    xr.testing.assert_identical(actual.drop_vars(["crd_x", "crd_y"]), expected)
+
+
+@requires_shapely
+def test_cf_to_shapely_for_polygons_without_multipolygons(
+    geometry_polygon_without_multipolygons_ds,
+):
+    in_ds, expected = geometry_polygon_without_multipolygons_ds
+    actual = cfxr.cf_to_shapely(in_ds)
+    assert actual.dims == ("index",)
+    xr.testing.assert_identical(actual.drop_vars(["crd_x", "crd_y"]), expected)
+
+    in_ds = in_ds.assign_coords(index=["b", "c"])
+    actual = cfxr.cf_to_shapely(in_ds)
+    assert actual.dims == ("index",)
+    xr.testing.assert_identical(
+        actual.drop_vars(["crd_x", "crd_y"]), expected.assign_coords(index=["b", "c"])
+    )
+
 
+@requires_shapely
+def test_cf_to_shapely_for_polygons_without_holes(
+    geometry_polygon_without_holes_ds,
+):
+    in_ds, expected = geometry_polygon_without_holes_ds
+    actual = cfxr.cf_to_shapely(in_ds)
+    assert actual.dims == ("index",)
+    xr.testing.assert_identical(actual.drop_vars(["crd_x", "crd_y"]), expected)
+
+    in_ds = in_ds.assign_coords(index=["b", "c"])
+    actual = cfxr.cf_to_shapely(in_ds)
+    assert actual.dims == ("index",)
+    xr.testing.assert_identical(
+        actual.drop_vars(["crd_x", "crd_y"]), expected.assign_coords(index=["b", "c"])
+    )
+
+
+@requires_shapely
+def test_cf_to_shapely_errors(geometry_ds, geometry_line_ds, geometry_polygon_ds):
+    in_ds, _ = geometry_ds
     in_ds.geometry_container.attrs["geometry_type"] = "punkt"
     with pytest.raises(ValueError, match="Valid CF geometry types are "):
         cfxr.cf_to_shapely(in_ds)
@@ -273,6 +492,11 @@ def test_cf_to_shapely_errors(geometry_ds, geometry_line_ds):
     with pytest.raises(ValueError, match="'node_count' must be provided"):
         cfxr.cf_to_shapely(in_ds)
 
+    in_ds, _ = geometry_polygon_ds
+    del in_ds.geometry_container.attrs["node_count"]
+    with pytest.raises(ValueError, match="'node_count' must be provided"):
+        cfxr.cf_to_shapely(in_ds)
+
 
 @requires_shapely
 def test_reshape_unique_geometries(geometry_ds):

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/cf_xarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: cf-xarray
-Version: 0.8.7
+Name: cf_xarray
+Version: 0.8.8
 Summary: A convenience wrapper for using CF attributes on xarray objects
 License:                                  Apache License
                                    Version 2.0, January 2004

cf_xarray-0.8.8/codecov.yml

@@ -0,0 +1,3 @@
+ignore:
+  - "*/tests/*"
+  - "cf_xarray/datasets.py"

{cf_xarray-0.8.7 → cf_xarray-0.8.8}/doc/whats-new.rst

@@ -3,6 +3,11 @@
 What's New
 ----------
 
+v0.8.8 (Jan 19, 2023)
+=====================
+- Add conversion between CF geometries and Shapely objects for polygons. By `Julia Signell`_.
+- Support 32bit wide bit masks. By `Michael St Laurent`_.
+
 v0.8.7 (Dec 19, 2023)
 =====================
 - Add conversion between CF geometries and Shapely objects for lines. By `Julia Signell`_.
@@ -253,4 +258,5 @@ v0.1.3
 .. _`Aidan Heerdegen`: https://github.com/aidanheerdegen
 .. _`Clément Haëck`: https://github.com/Descanonge
 .. _`Julia Signell`: https://github.com/jsignell
+.. _`Michael St Laurent`: https://github.com/mps010160
 .. _`flag variables`: http://cfconventions.org/Data/cf-conventions/cf-conventions-1.8/cf-conventions.html#flags

cf_xarray-0.8.7/cf_xarray/_version.py

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

cf_xarray-0.8.7/codecov.yml

@@ -1,2 +0,0 @@
-ignore:
-  - "*/tests/*"