Support for bounds. (#68)

1. Unfortunately, we cannot return bounds variables with
   `ds.cf["latitude"]` for e.g. DataArrays cannot have
   coordinate variables with dimensions that are not on
   the core variable.

   Actually, if we go through the _to_temp_dataset,
   assign bounds to coords, then_from_temp_dataset
   route, this will work. But pretty sure that's not
   intended.

2. ds.cf[["air"]] will return bounds variables for dimensions
   if appropriate.

Author: dcherian

cf_xarray/accessor.py

@@ -7,6 +7,7 @@
 from typing import (
     Any,
     Callable,
+    Dict,
     Hashable,
     Iterable,
     List,
@@ -896,42 +897,72 @@ def get_standard_names(self) -> List[str]:
             ]
         )
 
-    def get_associated_variable_names(self, name: Hashable) -> List[Hashable]:
+    def get_associated_variable_names(self, name: Hashable) -> Dict[str, List[str]]:
         """
-        Returns a list of variable names referred to in the following attributes
-            1. "coordinates"
-            2. "cell_measures"
-            3. "ancillary_variables"
+        Returns a dict mapping
+            1. "ancillary_variables"
+            2. "bounds"
+            3. "cell_measures"
+            4. "coordinates"
+        to a list of variable names referred to in the appropriate attribute
+
+        Parameters
+        ----------
+
+        name: Hashable
+
+        Returns
+        ------
+
+        Dict with keys "ancillary_variables", "cell_measures", "coordinates", "bounds"
         """
-        coords = []
+        keys = ["ancillary_variables", "cell_measures", "coordinates", "bounds"]
+        coords: Dict[str, List[str]] = {k: [] for k in keys}
         attrs_or_encoding = ChainMap(self._obj[name].attrs, self._obj[name].encoding)
 
         if "coordinates" in attrs_or_encoding:
-            coords.extend(attrs_or_encoding["coordinates"].split(" "))
+            coords["coordinates"] = attrs_or_encoding["coordinates"].split(" ")
 
         if "cell_measures" in attrs_or_encoding:
-            measures = [
-                _get_measure(self._obj[name], measure)
-                for measure in _CELL_MEASURES
-                if measure in attrs_or_encoding["cell_measures"]
-            ]
-            coords.extend(*measures)
+            coords["cell_measures"] = list(
+                itertools.chain(
+                    *[
+                        _get_measure(self._obj[name], measure)
+                        for measure in _CELL_MEASURES
+                        if measure in attrs_or_encoding["cell_measures"]
+                    ]
+                )
+            )
 
         if (
             isinstance(self._obj, Dataset)
             and "ancillary_variables" in attrs_or_encoding
         ):
-            anames = attrs_or_encoding["ancillary_variables"].split(" ")
-            coords.extend(anames)
+            coords["ancillary_variables"] = attrs_or_encoding[
+                "ancillary_variables"
+            ].split(" ")
+
+        if "bounds" in attrs_or_encoding:
+            coords["bounds"] = [attrs_or_encoding["bounds"]]
 
-        missing = set(coords) - set(self._maybe_to_dataset().variables)
+        for dim in self._obj[name].dims:
+            dbounds = self._obj[dim].attrs.get("bounds", None)
+            if dbounds:
+                coords["bounds"].append(dbounds)
+
+        allvars = itertools.chain(*coords.values())
+        missing = set(allvars) - set(self._maybe_to_dataset().variables)
         if missing:
             warnings.warn(
                 f"Variables {missing!r} not found in object but are referred to in the CF attributes.",
                 UserWarning,
             )
-            for m in missing:
-                coords.remove(m)
+            for k, v in coords.items():
+                for m in missing:
+                    if m in v:
+                        v.remove(m)
+                        coords[k] = v
+
         return coords
 
     def __getitem__(self, key: Union[str, List[str]]):
@@ -981,8 +1012,12 @@ def __getitem__(self, key: Union[str, List[str]]):
         allnames = varnames + coords
 
         try:
-            for name in varnames:
-                coords.extend(self.get_associated_variable_names(name))
+            for name in allnames:
+                extravars = self.get_associated_variable_names(name)
+                # we cannot return bounds variables with scalar keys
+                if scalar_key:
+                    extravars.pop("bounds")
+                coords.extend(itertools.chain(*extravars.values()))
 
             if isinstance(self._obj, DataArray):
                 ds = self._obj._to_temp_dataset()
@@ -1036,47 +1071,6 @@ def _maybe_to_dataarray(self, obj=None):
         else:
             return obj
 
-    def add_bounds(self, dims: Union[Hashable, Iterable[Hashable]]):
-        """
-        Returns a new object with bounds variables. The bounds values are guessed assuming
-        equal spacing on either side of a coordinate label.
-
-        Parameters
-        ----------
-        dims: Hashable or Iterable[Hashable]
-            Either a single dimension name or a list of dimension names.
-
-        Returns
-        -------
-        DataArray or Dataset with bounds variables added and appropriate "bounds" attribute set.
-
-        Notes
-        -----
-
-        The bounds variables are automatically named f"{dim}_bounds" where ``dim``
-        is a dimension name.
-        """
-        if isinstance(dims, Hashable):
-            dimensions = (dims,)
-        else:
-            dimensions = dims
-
-        bad_dims: Set[Hashable] = set(dimensions) - set(self._obj.dims)
-        if bad_dims:
-            raise ValueError(
-                f"{bad_dims!r} are not dimensions in the underlying object."
-            )
-
-        obj = self._maybe_to_dataset(self._obj.copy(deep=True))
-        for dim in dimensions:
-            bname = f"{dim}_bounds"
-            if bname in obj.variables:
-                raise ValueError(f"Bounds variable name {bname!r} will conflict!")
-            obj.coords[bname] = _guess_bounds_dim(obj[dim].reset_coords(drop=True))
-            obj[dim].attrs["bounds"] = bname
-
-        return self._maybe_to_dataarray(obj)
-
     def rename_like(
         self, other: Union[DataArray, Dataset]
     ) -> Union[DataArray, Dataset]:
@@ -1169,7 +1163,66 @@ def guess_coord_axis(self, verbose: bool = False) -> Union[DataArray, Dataset]:
 
 @xr.register_dataset_accessor("cf")
 class CFDatasetAccessor(CFAccessor):
-    pass
+    def get_bounds(self, key: str) -> DataArray:
+        """
+        Get bounds variable corresponding to key.
+
+        Parameters
+        ----------
+        key: str
+            Name of variable whose bounds are desired
+
+        Returns
+        -------
+        DataArray
+        """
+        name = apply_mapper(
+            _get_axis_coord_single, self._obj, key, error=False, default=[key]
+        )[0]
+        bounds = self._obj[name].attrs["bounds"]
+        obj = self._maybe_to_dataset()
+        return obj[bounds]
+
+    def add_bounds(self, dims: Union[Hashable, Iterable[Hashable]]):
+        """
+        Returns a new object with bounds variables. The bounds values are guessed assuming
+        equal spacing on either side of a coordinate label.
+
+        Parameters
+        ----------
+        dims: Hashable or Iterable[Hashable]
+            Either a single dimension name or a list of dimension names.
+
+        Returns
+        -------
+        DataArray or Dataset with bounds variables added and appropriate "bounds" attribute set.
+
+        Notes
+        -----
+
+        The bounds variables are automatically named f"{dim}_bounds" where ``dim``
+        is a dimension name.
+        """
+        if isinstance(dims, Hashable):
+            dimensions = (dims,)
+        else:
+            dimensions = dims
+
+        bad_dims: Set[Hashable] = set(dimensions) - set(self._obj.dims)
+        if bad_dims:
+            raise ValueError(
+                f"{bad_dims!r} are not dimensions in the underlying object."
+            )
+
+        obj = self._maybe_to_dataset(self._obj.copy(deep=True))
+        for dim in dimensions:
+            bname = f"{dim}_bounds"
+            if bname in obj.variables:
+                raise ValueError(f"Bounds variable name {bname!r} will conflict!")
+            obj.coords[bname] = _guess_bounds_dim(obj[dim].reset_coords(drop=True))
+            obj[dim].attrs["bounds"] = bname
+
+        return self._maybe_to_dataarray(obj)
 
 
 @xr.register_dataarray_accessor("cf")

cf_xarray/tests/test_accessor.py

@@ -356,7 +356,7 @@ def test_plot_xincrease_yincrease():
 
 
 @pytest.mark.parametrize("dims", ["lat", "time", ["lat", "lon"]])
-@pytest.mark.parametrize("obj", [airds, airds.air])
+@pytest.mark.parametrize("obj", [airds])
 def test_add_bounds(obj, dims):
     expected = dict()
     expected["lat"] = xr.concat(
@@ -399,6 +399,26 @@ def test_add_bounds(obj, dims):
         assert_allclose(added[name].reset_coords(drop=True), expected[dim])
 
 
+def test_bounds():
+    ds = airds.copy(deep=True).cf.add_bounds("lat")
+    actual = ds.cf[["lat"]]
+    expected = ds[["lat", "lat_bounds"]]
+    assert_identical(actual, expected)
+
+    actual = ds.cf[["air"]]
+    assert "lat_bounds" in actual.coords
+
+    # can't associate bounds variable when providing scalar keys
+    # i.e. when DataArrays are returned
+    actual = ds.cf["lat"]
+    expected = ds["lat"]
+    assert_identical(actual, expected)
+
+    actual = ds.cf.get_bounds("lat")
+    expected = ds["lat_bounds"]
+    assert_identical(actual, expected)
+
+
 def test_docstring():
     assert "One of ('X'" in airds.cf.groupby.__doc__
     assert "One or more of ('X'" in airds.cf.mean.__doc__

doc/api.rst

@@ -16,7 +16,6 @@ DataArray
    :toctree: generated/
    :template: autosummary/accessor_method.rst
 
-    DataArray.cf.add_bounds
     DataArray.cf.describe
     DataArray.cf.get_standard_names
     DataArray.cf.get_valid_keys
@@ -36,6 +35,7 @@ Dataset
 
     Dataset.cf.add_bounds
     Dataset.cf.describe
+    Dataset.cf.get_bounds
     Dataset.cf.get_standard_names
     Dataset.cf.get_valid_keys
     Dataset.cf.guess_coord_axis