Merge pull request #87 from euro-cordex/various_fixes

Author: sol1105

cc_plugin_cc6/base.py

@@ -903,11 +903,19 @@ def check_variable(self, ds):
         for entry in self.CTformulas["formula_entry"].keys():
             cvars.append(self.CTformulas["formula_entry"][entry]["out_name"])
         cvars = set(cvars)
-        # Add grid_mapping
+        # Add grid_mapping and quantization
         if len(self.varname) > 0:
             crs = getattr(ds.variables[self.varname[0]], "grid_mapping", False)
             if crs:
                 cvars |= {crs}
+            quant = (
+                ds.variables[self.varname[0]].getncattr("quantization")
+                if "quantization" in ds.variables[self.varname[0]].ncattrs()
+                else False
+            )
+            if quant:
+                cvars |= {quant}
+
         # Identify unknown variables / coordinates
         unknown = []
         for var in ds.variables.keys():
@@ -1023,18 +1031,25 @@ def check_grid_definition(self, ds):
                     messages.append(
                         f"Projection y coordinate variable '{y}' should be named '{self.CTgrids['axis_entry']['y_deg']['out_name']}'."
                     )
-                messages.extend(
-                    self._verify_attrs(y, self.CTgrids["axis_entry"]["y_deg"])
-                )
+                y_deg_msgs = self._verify_attrs(y, self.CTgrids["axis_entry"]["y_deg"])
+                y_msgs = self._verify_attrs(y, self.CTgrids["axis_entry"]["y"])
+                if len(y_deg_msgs) < len(y_msgs):
+                    messages.extend(y_deg_msgs)
+                else:
+                    messages.extend(y_msgs)
             if "projection_x_coordinate" in self.xrds.cf.standard_names:
                 x = self.xrds.cf.standard_names["projection_x_coordinate"][0]
                 if x != self.CTgrids["axis_entry"]["x_deg"]["out_name"]:
                     messages.append(
                         f"Projection x coordinate variable '{x}' should be named '{self.CTgrids['axis_entry']['x_deg']['out_name']}'."
                     )
-                messages.extend(
-                    self._verify_attrs(x, self.CTgrids["axis_entry"]["x_deg"])
-                )
+
+                x_deg_msgs = self._verify_attrs(x, self.CTgrids["axis_entry"]["x_deg"])
+                x_msgs = self._verify_attrs(x, self.CTgrids["axis_entry"]["x"])
+                if len(x_deg_msgs) < len(x_msgs):
+                    messages.extend(x_deg_msgs)
+                else:
+                    messages.extend(x_msgs)
 
         if len(messages) == 0:
             score += 1
@@ -1107,6 +1122,7 @@ def check_variable_definition(self, ds):
         score = 0
         out_of = 1
         messages = []
+        low_severity_messages = []
 
         # Only check if requested variable is identified
         if len(self.varname) == 0:
@@ -1356,10 +1372,17 @@ def check_variable_definition(self, ds):
             vattrCT = self._get_var_attr(vattr, False)
             if vattrCT:
                 if vattr == "comment":
+                    # Low severity
                     if vattrCT not in attrs.get("comment", ""):
-                        messages.append(
+                        low_severity_messages.append(
                             f"The variable attribute '{var}:comment' needs to include the specified comment from the CMOR table."
                         )
+                elif vattr == "long_name":
+                    # Low severity
+                    if vattrCT != attrs.get(vattr, ""):
+                        low_severity_messages.append(
+                            f"The variable attribute '{var}:{vattr} = '{attrs.get(vattr, 'unset')}' is not equivalent to the value specified in the CMOR table ('{vattrCT}')."
+                        )
                 elif vattr == "type":
                     reqdtype = self.dtypesdict.get(vattrCT, False)
                     if vattrCT == "character" and reqdtype:
@@ -1384,6 +1407,17 @@ def check_variable_definition(self, ds):
         if len(messages) == 0:
             score += 1
 
+        if len(low_severity_messages) > 0:
+            high_level_result = self.make_result(level, score, out_of, desc, messages)
+            low_level_result = self.make_result(
+                BaseCheck.LOW,
+                0,
+                1,
+                desc[:-1] + ", informational - no action required)",
+                low_severity_messages,
+            )
+            return [high_level_result, low_level_result]
+
         return self.make_result(level, score, out_of, desc, messages)
 
     def check_required_global_attributes(self, ds):

cc_plugin_cc6/cc6.py

@@ -5,14 +5,14 @@
 import cf_xarray  # noqa
 import cftime
 import numpy as np
-import xarray as xr
 from compliance_checker.base import BaseCheck
 
 from cc_plugin_cc6 import __version__
 
 from ._constants import deltdic
 from .base import MIPCVCheck
 from .tables import retrieve
+from .utils import crosses_anti_meridian, crosses_zero_meridian
 
 CORDEX_CMIP6_CMOR_TABLES_URL = "https://raw.githubusercontent.com/WCRP-CORDEX/cordex-cmip6-cmor-tables/main/Tables/"
 
@@ -820,9 +820,21 @@ def check_lon_value_range(self, ds):
         else:
             return self.make_result(level, out_of, out_of, desc, messages)
 
+        # Get domain_id from global attributes
+        domain_id = self._get_attr("domain_id", default="")
+        if not isinstance(domain_id, str):
+            domain_id = ""
+
         # Check if longitude coordinates are strictly monotonically increasing
         if lon.ndim != 2:
             messages.append("The longitude coordinate should have two dimensions.")
+        # The polar domains and generally domains crossing both, 0-meridian and anti-meridian, are exempt from monotony tests
+        elif (
+            domain_id.startswith("ARC")
+            or domain_id.startswith("ANT")
+            or (crosses_anti_meridian(lon) and crosses_zero_meridian(lon))
+        ):
+            score += 1
         else:
             increasing_0 = ((lon[1:, :].data - lon[:-1, :].data) > 0).all()
             increasing_1 = ((lon[:, 1:].data - lon[:, :-1].data) > 0).all()
@@ -859,13 +871,13 @@ def check_lon_value_range(self, ds):
             )
 
         # Check if longitude coordinates have absolute values as small as possible
-        abs = (lon > 180).any() and (xr.where(lon >= 180, lon - 360, lon) >= -180).all()
-        if not abs:
-            score += 1
-        else:
+        # If values are monotonic increasing, only the case 180 <= lon [< 360] is problematic
+        if lon.min() >= 180:
             messages.append(
-                "Longitude values are required to take the smalles absolute value in the range [-180, 360]."
+                "Longitude values are required to take the smallest absolute value in the range [-180, 360]."
             )
+        else:
+            score += 1
 
         return self.make_result(level, score, out_of, desc, messages)
 

cc_plugin_cc6/utils.py

@@ -2,6 +2,10 @@
 
 import numpy as np
 
+###################################
+# General Utility Functions
+###################################
+
 
 def convert_posix_to_python(posix_regex):
     """
@@ -19,6 +23,13 @@ def convert_posix_to_python(posix_regex):
     if not isinstance(posix_regex, str):
         raise ValueError("Input must be a string")
 
+    # [a,b] -> [a b]
+    posix_regex = re.sub(
+        r"(?<!\\)\[(.*?)(?<!\\)\]",
+        lambda m: "[" + m.group(1).replace(",", " ") + "]",
+        posix_regex,
+    )
+
     # Dictionary of POSIX to Python character class conversions
     posix_to_python_classes = {
         r"[[:alnum:]]": r"[a-zA-Z0-9]",
@@ -40,6 +51,20 @@ def convert_posix_to_python(posix_regex):
     # Replace POSIX quantifiers with Python equivalents
     posix_regex = posix_regex.replace(r"\{", "{").replace(r"\}", "}")
 
+    # Deal with groups
+    # Temporarily mark existing escaped parentheses that should become groups, e.g., \(
+    posix_regex = re.sub(r"\\\(", "__GROUP_LEFTPARENTHESIS__", posix_regex)
+    posix_regex = re.sub(r"\\\)", "__GROUP_RIGHTPARENTHESIS__", posix_regex)
+    # Escape all remaining unescaped parentheses (-> literal parentheses)
+    posix_regex = re.sub(r"(?<!\\)\(", r"\(", posix_regex)
+    posix_regex = re.sub(r"(?<!\\)\)", r"\)", posix_regex)
+    # Restore the placeholders as unescaped parentheses (grouping)
+    posix_regex = posix_regex.replace("__GROUP_LEFTPARENTHESIS__", "(")
+    posix_regex = posix_regex.replace("__GROUP_RIGHTPARENTHESIS__", ")")
+
+    # Replace "{1,}" with "+" to matchone or more repetitions
+    posix_regex = re.sub(r"\{1,\}", "+", posix_regex)
+
     return posix_regex
 
 
@@ -54,13 +79,21 @@ def match_pattern_or_string(pattern, target):
     Returns:
         bool: True if the target matches the regex pattern or is equal to the string.
     """
-    return bool(
-        re.fullmatch(convert_posix_to_python(pattern), target, flags=re.ASCII)
-    ) or (
-        pattern == target
-        and convert_posix_to_python(target) == target
-        and ".*" not in target
-    )
+    try:
+        return bool(
+            re.fullmatch(convert_posix_to_python(pattern), target, flags=re.ASCII)
+        ) or (
+            pattern == target
+            and convert_posix_to_python(target) == target
+            and ".*" not in target
+        )
+    except re.error:
+        # Invalid regex treat pattern as literal string
+        return (
+            pattern == target
+            and convert_posix_to_python(target) == target
+            and ".*" not in target
+        )
 
 
 def to_str(val):
@@ -90,3 +123,58 @@ def sanitize(obj):
     if isinstance(obj, (np.ndarray,)):
         return obj.tolist()
     return obj
+
+
+###################################
+# Coordinate Utility Functions
+###################################
+
+
+def convert_lon_360(lon):
+    """Convert longitude to [0, 360)."""
+    lon = np.asarray(lon)
+    return lon % 360.0
+
+
+def convert_lon_180(lon):
+    """Convert longitude to [-180, 180)."""
+    lon = np.asarray(lon)
+    return ((lon + 180.0) % 360.0) - 180.0
+
+
+def crosses_zero_meridian(lon, intv=5.0):
+    """
+    Check if longitude crosses 0-meridian.
+
+    Args:
+        lon (numpy.ndarray): Array of longitudes.
+        intv (float, optional): Requiring longitude in interval [-intv, 0] and [0,intv]
+                                to be classified as crossing 0-meridian. Default is 5.
+
+    Returns:
+        bool: True if longitude crosses 0-meridian.
+    """
+    lon180 = convert_lon_180(lon)
+    return bool(
+        np.any((lon180 > -intv) & (lon180 < 0))
+        and np.any((lon180 > 0) & (lon180 < intv))
+    )
+
+
+def crosses_anti_meridian(lon, intv=5.0):
+    """
+    Check if longitude crosses anti-meridian.
+
+    Args:
+        lon (numpy.ndarray): Array of longitudes.
+        intv (float, optional): Requiring longitude in interval [-intv, 0] and [0,intv]
+                                to be classified as crossing 0-meridian. Default is 5.
+
+    Returns:
+        bool: True if longitude crosses anti-meridian.
+    """
+    lon360 = convert_lon_360(lon)
+    return bool(
+        np.any((lon360 > 180 - intv) & (lon360 < 180))
+        and np.any((lon360 > 180) & (lon360 < 180 + intv))
+    )