refactor

compliance_checker/cf/cf_1_6.py

@@ -17,6 +17,7 @@
     grid_mapping_dict16,
 )
 from compliance_checker.cf.cf_base import CFNCCheck, appendix_a_base
+from compliance_checker.cfunits import _units
 
 logger = logging.getLogger(__name__)
 
@@ -811,7 +812,7 @@ def _check_valid_cf_units(self, ds, variable_name):
         )
 
         try:
-            units_conv = cfutil._units(units)
+            units_conv = _units(units)
         except ValueError:
             valid_units.messages.append(
                 f'Unit string "{units}" is not recognized by UDUnits',
@@ -827,7 +828,7 @@ def _check_valid_cf_units(self, ds, variable_name):
         # being expressed as "s"/seconds
         if standard_name not in {"time", "forecast_reference_time"}:
             valid_units.assert_true(
-                units_conv.is_convertible_to(cfutil._units(reference)),
+                units_conv.is_convertible(_units(reference)),
                 f'Units "{units}" for variable '
                 f"{variable_name} must be convertible to "
                 f'canonical units "{reference}"',
@@ -1493,8 +1494,7 @@ def check_latitude(self, ds):
                 # check that the units aren't in east and north degrees units,
                 # but are convertible to angular units
                 allowed_units.assert_true(
-                    units not in e_n_units
-                    and cfutil._units(units) == cfutil._units("degree"),
+                    units not in e_n_units and _units(units) == _units("degree"),
                     f"Grid latitude variable '{latitude}' should use degree equivalent units without east or north components. "
                     f"Current units are {units}",
                 )
@@ -1603,8 +1603,7 @@ def check_longitude(self, ds):
                 # check that the units aren't in east and north degrees units,
                 # but are convertible to angular units
                 allowed_units.assert_true(
-                    units not in e_n_units
-                    and cfutil._units(units) == cfutil._units("degree"),
+                    units not in e_n_units and _units(units) == _units("degree"),
                     f"Grid longitude variable '{longitude}' should use degree equivalent units without east or north components. "
                     f"Current units are {units}",
                 )
@@ -2844,13 +2843,13 @@ def _cell_measures_core(self, ds, var, external_set, variable_template):
                         f'cell_methods attribute with a measure type of "{cell_measure_type}".'
                     )
                     try:
-                        cell_measure_units = cfutil._units(cell_measure_var.units)
+                        cell_measure_units = _units(cell_measure_var.units)
                     except ValueError:
                         valid = False
                         reasoning.append(conversion_failure_msg)
                     else:
-                        if not cell_measure_units.is_convertible_to(
-                            cfutil._units(f"m{exponent}"),
+                        if not cell_measure_units.is_convertible(
+                            _units(f"m{exponent}"),
                         ):
                             valid = False
                             reasoning.append(conversion_failure_msg)
@@ -3044,7 +3043,7 @@ def _check_cell_methods_paren_info(self, paren_contents, var):
 
                     # then the units
                     try:
-                        cfutil._units(interval_matches.group("interval_units"))
+                        _units(interval_matches.group("interval_units"))
                     except ValueError:
                         valid_info.messages.append(
                             '§7.3.3 {}:cell_methods interval units "{}" is not parsable by UDUNITS.'.format(

compliance_checker/cf/util.py

@@ -8,7 +8,8 @@
 from lxml import etree
 from netCDF4 import Dataset
 
-from compliance_checker.cfutil import _units, units_convertible
+from compliance_checker.cfunits import _units
+from compliance_checker.cfutil import units_convertible
 
 # copied from paegan
 # paegan may depend on these later
@@ -337,7 +338,7 @@ def units_temporal(units):
     # IMPLEMENTATION CONFORMANCE REQUIRED 4.4 3/3
     # check that reference time seconds is not greater than or
     # equal to 60
-    return u.is_time_reference
+    return u.is_time_reference()
 
 
 def find_coord_vars(ncds):

compliance_checker/cfunits.py

@@ -0,0 +1,107 @@
+from pyudunits2 import UnitSystem, UnresolvableUnitException
+
+try:
+    from cf_units import Unit
+
+    cf_units = True
+except ImportError:
+    Unit = object
+    cf_units = False
+
+
+class CFUnitMixin:
+    """Standardize the methods from cf-untis and pyudunits2 used in compliance-checker."""
+
+    def has_shift_from(self):
+        return self.is_time_reference()
+
+
+class PyUdunits2:
+    """Workaround for the differences in pyudunits2 and cf-units.
+
+    NB: Some of these may change and/or get implemented upstream. Pyudunits2 is new and in-flux.
+
+    1/4 Raise the same ValueError to match cf-unit errors.
+    2/4 Creates an empty unit from None to mimic cf-unit's Unit('unknown')
+    3/4 Add a definition object that is ust units.expanded()
+    """
+
+    def __init__(self, units):
+        """Keep unit system so we can convert from string later."""
+        self.ut_system = UnitSystem.from_udunits2_xml()
+
+        if units is None:
+            units = ""
+
+        try:
+            self.units = self.ut_system.unit(units)
+        except (SyntaxError, UnresolvableUnitException) as err:
+            raise ValueError from err
+        self.definition = self.units.expanded()
+
+    def __eq__(self, other):
+        return self.units == other
+
+    def is_dimensionless(self):
+        return self.units.is_dimensionless()
+
+    def is_convertible(self, other):
+        if isinstance(other, str):
+            other = self.ut_system.unit(other)
+        elif isinstance(other, (PyUdunits2)):
+            other = other.units
+        else:
+            msg = f"Expected valid unit string or pyudunits2 unit object. Got {other}."
+            raise ValueError(msg)
+
+        # FIXME: cf-units Workaround 1/4 -> cf_units.Unit(None) -> Unit('unknown').
+        if "" in (self.units.expanded(), other.expanded()):
+            return False
+
+        convertible = self.units.is_convertible_to(other)
+        # FIXME: cf-units Workaround 2/4 -> time is not convertible to time reference.
+
+        # Both are time reference confirm.
+        if _is_time_reference(self.units) and _is_time_reference(other):
+            convertible = True
+        # One is time, the other is not, change it to False.
+        if sum((_is_time_reference(self.units), _is_time_reference(other))) == 1:
+            convertible = False
+
+        return convertible
+
+    def is_time_reference(self):
+        return _is_time_reference(self.units)
+
+
+def _is_time_reference(self):
+    # FIXME: cf-units Workaround 4/4 -> cf_units can differentiante between time reference and time units.
+    is_time_reference = False
+    try:
+        if hasattr(self._definition, "shift_from"):
+            is_time_reference = True
+    except KeyError:
+        # FIXME: hasattr should return None in that case.
+        # pyudunits2/_expr_graph.py:27, in Node.__getattr__(self, name)
+        #      25 def __getattr__(self, name):
+        #      26     # Allow the dictionary to raise KeyError if the key doesn't exist.
+        # ---> 27     return self._attrs[name]
+        # KeyError: 'shift_from'
+        pass
+    return is_time_reference
+
+
+class Udunits2(CFUnitMixin, PyUdunits2):
+    def __init__(self, units):
+        super().__init__(units)
+
+
+class CFUnits(CFUnitMixin, Unit):
+    def __init__(self, units):
+        super().__init__(units)
+
+
+def _units(units):
+    if cf_units:
+        return CFUnits(units)
+    return Udunits2(units)

compliance_checker/cfutil.py

@@ -10,6 +10,8 @@
 
 from importlib_resources import files
 
+from compliance_checker.cfunits import _units
+
 _UNITLESS_DB = None
 _SEA_NAMES = None
 
@@ -2029,89 +2031,17 @@ def guess_feature_type(nc, variable):
         return "reduced-grid"
 
 
-class _CCUnit:
-    def __init__(self, units):
-        import cf_units
-
-        self.u = cf_units.Unit(units)
-        self.is_time_reference = self.u.is_time_reference()
-
-    def __eq__(self, other):
-        return self.u == other.u
-
-    def is_convertible_to(self, other):
-        if isinstance(other, str):
-            ret = self.u.is_convertible(other)
-        else:
-            ret = self.u.is_convertible(other.u)
-        return ret
-
-    def is_dimensionless(self):
-        return self.u.is_dimensionless()
-
-    def expanded(self):
-        return self.u.definition
-
-
-def _units(units: str):
-    """PLACEHOLDER."""
-    # FIXME: Make cf_units optional in a more elegant way when pyudunits2 is release.
-    try:
-        return _CCUnit(units)
-    except ImportError:
-        from pyudunits2 import UnitSystem, UnresolvableUnitException
-
-        ut_system = UnitSystem.from_udunits2_xml()
-
-    # FIXME: cf_units.Unit(None) -> Unit('unknown')
-    if units is None:
-        units = ""
-
-    # FIXME: cf_units raised only ValueError
-    try:
-        u = ut_system.unit(units)
-    except (SyntaxError, UnresolvableUnitException) as err:
-        raise ValueError from err
-    # FIXME: cf_units defined .is_time_reference for time reference units.
-    u.is_time_reference = False
-    try:
-        if hasattr(u._definition, "shift_from"):
-            u.is_time_reference = True
-    except KeyError:
-        # FIXME: hasattr should return None in that case.
-        # pyudunits2/_expr_graph.py:27, in Node.__getattr__(self, name)
-        #      25 def __getattr__(self, name):
-        #      26     # Allow the dictionary to raise KeyError if the key doesn't exist.
-        # ---> 27     return self._attrs[name]
-        # KeyError: 'shift_from'
-        pass
-    return u
-
-
-def units_convertible(units1, units2, reftimeistime=True):
+def units_convertible(units1, units2):
     """
     Return True if a Unit representing the string units1 can be converted
     to a Unit representing the string units2, else False.
 
     :param str units1: A string representing the units
     :param str units2: A string representing the units
     """
-    convertible = False
     try:
         u1 = _units(units1)
         u2 = _units(units2)
     except ValueError:
         return False
-    # FIXME: Workaround for unknown units in cf_units.
-    if "" in (u1.expanded(), u2.expanded()):
-        return False
-
-    convertible = u1.is_convertible_to(u2)
-    # FIXME: Workaround for is_time_reference vs time in cf_units.
-    # Both are time reference confirm.
-    if u1.is_time_reference and u2.is_time_reference:
-        convertible = True
-    # One is time, the other is not, change it to False.
-    if sum((u1.is_time_reference, u2.is_time_reference)) == 1:
-        convertible = False
-    return convertible
+    return u1.is_convertible(u2)

compliance_checker/ioos.py

@@ -22,8 +22,8 @@
 )
 from compliance_checker.cf import util as cf_util  # not to be confused with cfutil.py
 from compliance_checker.cf.cf import CF1_6Check, CF1_7Check
+from compliance_checker.cfunits import _units
 from compliance_checker.cfutil import (
-    _units,
     get_geophysical_variables,
     get_instrument_variables,
     get_z_variables,
@@ -1378,12 +1378,12 @@ def check_vertical_coordinates(self, ds):
                 "fathom",
             )
             unit_def_set = {
-                _units(unit_str).expanded() for unit_str in expected_unit_strs
+                _units(unit_str).definition for unit_str in expected_unit_strs
             }
 
             try:
                 units = _units(units_str)
-                pass_stat = units.expanded() in unit_def_set
+                pass_stat = units.definition in unit_def_set
             # unknown unit not convertible to UDUNITS
             except ValueError:
                 pass_stat = False