spatial-dims-order -> cube-dims-order

Author: forman

…s/xcube/rules/test_spatial_dims_order.py …gins/xcube/rules/test_cube_dims_order.pytests/plugins/xcube/rules/test_spatial_dims_order.py renamed to tests/plugins/xcube/rules/test_cube_dims_order.py tests/plugins/xcube/rules/test_spatial_dims_order.py renamed to tests/plugins/xcube/rules/test_cube_dims_order.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from xrlint.plugins.xcube.rules.spatial_dims_order import SpatialDimsOrder
+from xrlint.plugins.xcube.rules.cube_dims_order import CubeDimsOrder
 
 import xarray as xr
 
@@ -34,24 +34,28 @@ def make_dataset(dims: tuple[str, str, str]):
 
 valid_dataset_1 = make_dataset(("time", "y", "x"))
 valid_dataset_2 = make_dataset(("time", "lat", "lon"))
+valid_dataset_3 = make_dataset(("level", "y", "x"))
 
 invalid_dataset_1 = make_dataset(("time", "x", "y"))
 invalid_dataset_2 = make_dataset(("x", "y", "time"))
 invalid_dataset_3 = make_dataset(("time", "lon", "lat"))
-invalid_dataset_4 = make_dataset(("lon", "lat", "time"))
+invalid_dataset_4 = make_dataset(("lon", "lat", "level"))
+invalid_dataset_5 = make_dataset(("x", "y", "level"))
 
 
-SpatialDimsOrderTest = RuleTester.define_test(
-    "spatial-dims-order",
-    SpatialDimsOrder,
+CubeDimsOrderTest = RuleTester.define_test(
+    "cube-dims-order",
+    CubeDimsOrder,
     valid=[
         RuleTest(dataset=valid_dataset_1),
         RuleTest(dataset=valid_dataset_2),
+        RuleTest(dataset=valid_dataset_3),
     ],
     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),
     ],
 )

tests/plugins/xcube/test_plugin.py

@@ -18,7 +18,7 @@ def test_rules_complete(self):
         _plugin = export_plugin()
         self.assertEqual(
             {
-                "spatial-dims-order",
+                "cube-dims-order",
             },
             set(_plugin.rules.keys()),
         )

tests/test_linter.py

@@ -33,7 +33,7 @@ def test_new_linter(self):
         self.assertEqual({CORE_PLUGIN_NAME, "xcube"}, set(linter.config.plugins.keys()))
         self.assertIsInstance(linter.config.rules, dict)
         self.assertIn("dataset-title-attr", linter.config.rules)
-        self.assertIn("xcube/spatial-dims-order", linter.config.rules)
+        self.assertIn("xcube/cube-dims-order", linter.config.rules)
 
         linter = new_linter(recommended=False)
         self.assertIsInstance(linter, xrl.Linter)

tests/test_result.py

@@ -2,7 +2,7 @@
 
 from xrlint.config import Config
 from xrlint.plugin import Plugin, PluginMeta
-from xrlint.result import get_rules_meta_for_results, Result, Message
+from xrlint.result import get_rules_meta_for_results, Result, Message, Suggestion
 from xrlint.rule import RuleOp, RuleMeta
 
 
@@ -76,3 +76,16 @@ def test_repr_html(self):
         self.assertIsInstance(html, str)
         self.assertIn("<table>", html)
         self.assertIn("</table>", html)
+
+
+class SuggestionTest(TestCase):
+
+    # noinspection PyUnusedLocal
+    def test_from_value(self):
+        self.assertEqual(
+            Suggestion("Use xr.transpose()"),
+            Suggestion.from_value("Use xr.transpose()"),
+        )
+
+        suggestion = Suggestion("Use xr.transpose()")
+        self.assertIs(suggestion, Suggestion.from_value(suggestion))

xrlint/_linter/rule_ctx_impl.py

@@ -57,8 +57,11 @@ def report(
         message: str,
         *,
         fatal: bool | None = None,
-        suggestions: list[Suggestion] | None = None,
+        suggestions: list[Suggestion | str] | None = None,
     ):
+        suggestions = (
+            [Suggestion.from_value(s) for s in suggestions] if suggestions else None
+        )
         m = Message(
             message=message,
             fatal=fatal,

xrlint/plugins/xcube/__init__.py

@@ -12,7 +12,7 @@ def export_plugin() -> Plugin:
         {
             "name": "recommended",
             "rules": {
-                f"xcube/{rule_id}": "error" for rule_id, rule in plugin.rules.items()
+                "xcube/cube-dims-order": "error",
             },
         }
     )

xrlint/plugins/xcube/rules/cube_dims_order.py

@@ -0,0 +1,58 @@
+from xrlint.node import DataArrayNode
+from xrlint.plugins.xcube.rules import plugin
+from xrlint.result import Suggestion
+from xrlint.rule import RuleOp, RuleContext
+
+
+@plugin.define_rule(
+    "cube-dims-order",
+    version="1.0.0",
+    description=(
+        "Order of dimensions in spatio-temporal datacube variables"
+        " should be [time, ..., y, x]."
+    ),
+)
+class CubeDimsOrder(RuleOp):
+    def data_array(self, ctx: RuleContext, node: DataArrayNode):
+        if node.in_data_vars():
+            dims = list(node.data_array.dims)
+            indexes = {d: i for i, d in enumerate(node.data_array.dims)}
+
+            yx_names = None
+            if "x" in indexes and "y" in indexes:
+                yx_names = ["y", "x"]
+            elif "lon" in indexes and "lat" in indexes:
+                yx_names = ["lat", "lon"]
+            else:
+                # TODO: get yx_names/yx_indexes from grid-mapping
+                pass
+            if yx_names is None:
+                # This rule only applies to spatial dimensions
+                return
+
+            t_name = None
+            if "time" in indexes:
+                t_name = "time"
+
+            n = len(dims)
+            t_index = indexes[t_name] if t_name else None
+            y_index = indexes[yx_names[0]]
+            x_index = indexes[yx_names[1]]
+
+            yx_ok = y_index == n - 2 and x_index == n - 1
+            t_ok = t_index is None or t_index == 0
+            if not yx_ok or not t_ok:
+                if t_index is None:
+                    expected_dims = [d for d in dims if d not in yx_names] + yx_names
+                else:
+                    expected_dims = (
+                        [t_name]
+                        + [d for d in dims if d != t_name and d not in yx_names]
+                        + yx_names
+                    )
+                # noinspection PyTypeChecker
+                ctx.report(
+                    f"order of dimensions should be"
+                    f" {','.join(expected_dims)}, but was {','.join(dims)}",
+                    suggestions=["Use xarray.transpose(...) to reorder dimensions."],
+                )

xrlint/plugins/xcube/rules/spatial_dims_order.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Literal, TYPE_CHECKING
+from typing import Literal, TYPE_CHECKING, Any
 import html
 
 from tabulate import tabulate
@@ -8,6 +8,7 @@
 from xrlint.constants import SEVERITY_ERROR
 from xrlint.constants import SEVERITY_WARN
 from xrlint.util.formatting import format_problems
+from xrlint.util.formatting import format_message_type_of
 from xrlint.util.todict import ToDictMixin
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -31,6 +32,14 @@ class Suggestion(ToDictMixin):
     fix: EditInfo | None = None
     """Not used yet."""
 
+    @classmethod
+    def from_value(cls, value: Any):
+        if isinstance(value, Suggestion):
+            return value
+        if isinstance(value, str):
+            return Suggestion(value)
+        raise TypeError(format_message_type_of("value", value, "Suggestion|str"))
+
 
 @dataclass(kw_only=True)
 class Message(ToDictMixin):

xrlint/result.py

@@ -40,15 +40,16 @@ def report(
         message: str,
         *,
         fatal: bool | None = None,
-        suggestions: list[Suggestion] | None = None,
+        suggestions: list[Suggestion | str] | None = None,
     ):
         """Report an issue.
 
         Args:
             message: mandatory message text
             fatal: True, if a fatal error is reported.
             suggestions: A list of suggestions for the user
-                on how to fix the reported issue.
+                on how to fix the reported issue. Items may
+                be of type `Suggestion` or `str`.
         """