new rule lat-lon-naming

Author: forman

tests/plugins/xcube/rules/test_lat_lon_naming.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from xrlint.plugins.xcube.rules.lat_lon_naming import LatLonNaming
+
+import xarray as xr
+
+from xrlint.testing import RuleTester, RuleTest
+
+
+def make_dataset(lat_dim: str, lon_dim: str):
+    dims = ["time", lat_dim, lon_dim]
+    n = 3
+    return xr.Dataset(
+        attrs=dict(title="v-data"),
+        coords={
+            lon_dim: xr.DataArray(
+                np.linspace(0, 1, n), dims=lon_dim, attrs={"units": "m"}
+            ),
+            lat_dim: xr.DataArray(
+                np.linspace(0, 1, n), dims=lat_dim, attrs={"units": "m"}
+            ),
+            "time": xr.DataArray(
+                list(range(2010, 2010 + n)), dims="time", attrs={"units": "years"}
+            ),
+        },
+        data_vars={
+            "chl": xr.DataArray(
+                np.random.random((n, n, n)), dims=dims, attrs={"units": "mg/m^-3"}
+            ),
+            "tsm": xr.DataArray(
+                np.random.random((n, n, n)), dims=dims, attrs={"units": "mg/m^-3"}
+            ),
+            "avg_temp": xr.DataArray(
+                np.random.random(n), dims=dims[0], attrs={"units": "kelvin"}
+            ),
+            "mask": xr.DataArray(np.random.random((n, n)), dims=dims[-2:]),
+        },
+    )
+
+
+valid_dataset_1 = make_dataset("lat", "lon")
+
+invalid_dataset_1 = make_dataset("lat", "long")
+invalid_dataset_2 = make_dataset("lat", "longitude")
+invalid_dataset_3 = make_dataset("lat", "Lon")
+
+invalid_dataset_4 = make_dataset("ltd", "lon")
+invalid_dataset_5 = make_dataset("latitude", "lon")
+invalid_dataset_6 = make_dataset("Lat", "lon")
+
+LatLonNamingTest = RuleTester.define_test(
+    "lat-lon-naming",
+    LatLonNaming,
+    valid=[
+        RuleTest(dataset=valid_dataset_1),
+    ],
+    invalid=[
+        RuleTest(dataset=invalid_dataset_1),
+        RuleTest(dataset=invalid_dataset_2),
+        RuleTest(dataset=invalid_dataset_3),
+        RuleTest(dataset=invalid_dataset_4),
+        RuleTest(dataset=invalid_dataset_5),
+        RuleTest(dataset=invalid_dataset_6),
+    ],
+)

tests/plugins/xcube/test_plugin.py

@@ -19,6 +19,7 @@ def test_rules_complete(self):
         self.assertEqual(
             {
                 "cube-dims-order",
+                "lat-lon-naming",
             },
             set(_plugin.rules.keys()),
         )

xrlint/plugins/xcube/rules/lat_lon_naming.py

@@ -0,0 +1,48 @@
+from xrlint.node import DatasetNode
+from xrlint.plugins.xcube.rules import plugin
+from xrlint.rule import RuleOp, RuleContext
+
+VALID_LON = "lon"
+VALID_LAT = "lat"
+INVALID_LONS = {"lng", "long", "longitude"}
+INVALID_LATS = {"ltd", "latitude"}
+
+
+@plugin.define_rule(
+    "lat-lon-naming",
+    version="1.0.0",
+    description=(
+        f"Latitude and longitude coordinates and dimensions"
+        f" should be called {VALID_LAT!r} and {VALID_LON!r}."
+    ),
+)
+class LatLonNaming(RuleOp):
+    def dataset(self, ctx: RuleContext, node: DatasetNode):
+        lon_ok = _check(
+            ctx, "variable", node.dataset.variables.keys(), INVALID_LONS, VALID_LON
+        )
+        lat_ok = _check(
+            ctx, "variable", node.dataset.variables.keys(), INVALID_LATS, VALID_LAT
+        )
+        if lon_ok and lat_ok:
+            # If variables have been reported,
+            # we should not need to report (their) coordinates
+            _check(ctx, "dimension", node.dataset.sizes.keys(), INVALID_LONS, VALID_LON)
+            _check(ctx, "dimension", node.dataset.sizes.keys(), INVALID_LATS, VALID_LAT)
+
+
+def _check(ctx, names_name, names, invalid_names, valid_name):
+    names = [str(n) for n in names]  # xarray keys are Hashable, not str
+    found_names = [
+        n
+        for n in names
+        if (n.lower() in invalid_names) or (n.lower() == valid_name and n != valid_name)
+    ]
+    if found_names:
+        ctx.report(
+            f"The {names_name} {found_names[0]!r} should be named {valid_name!r}.",
+            suggestions=[f"Rename {names_name} to {valid_name!r}."],
+        )
+        return False
+    else:
+        return True