Removed Result.new(), added test for linting data trees

Author: forman

CHANGES.md

@@ -4,6 +4,11 @@
 
 ### Adjustments and Enhancements
 
+- Added support for validating Zarr and HDF-5 groups and their items. 
+  Rules can now validate `xarray.DataTree` objects originating 
+  from `xarray.open_datatree()` by implementing
+  rule operation method `RuleOp.validate_datatree(ctx, node)`. (#54)
+
 - Added a new core rule `access-latency` that can be used to check the
   time it takes to open a dataset.
 

pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 ]
 description = "A linter for xarray datasets."
 keywords = [
-  "xarray"
+  "xarray", "data-science", "cf", "metadata"
 ]
 license = {text = "MIT"}
 requires-python = ">=3.10"

tests/formatters/helpers.py

@@ -45,9 +45,9 @@ class Rule2(RuleOp):
     config_obj = ConfigObject(plugins={"test": plugin})
 
     return [
-        Result.new(
-            config_object=config_obj,
+        Result(
             file_path="test.nc",
+            config_object=config_obj,
             messages=[
                 Message(
                     message="message-1",
@@ -64,9 +64,9 @@ class Rule2(RuleOp):
                 Message(message="message-3", fatal=True),
             ],
         ),
-        Result.new(
+        Result(
+            file_path="test.nc",
             config_object=config_obj,
-            file_path="test-2.nc",
             messages=[
                 Message(message="message-1", rule_id="test/rule-1", severity=1),
                 Message(message="message-2", rule_id="test/rule-2", severity=2),

tests/formatters/test_simple.py

@@ -12,9 +12,9 @@
 
 class SimpleTest(TestCase):
     errors_and_warnings = [
-        Result.new(
-            config_object=ConfigObject(),
+        Result(
             file_path="test1.nc",
+            config_object=ConfigObject(),
             messages=[
                 Message(message="what", rule_id="rule-1", severity=2),
                 Message(message="is", fatal=True),
@@ -24,9 +24,9 @@ class SimpleTest(TestCase):
     ]
 
     warnings_only = [
-        Result.new(
-            ConfigObject(),
+        Result(
             file_path="test2.nc",
+            config_object=ConfigObject(),
             messages=[
                 Message(message="what", rule_id="rule-1", severity=1),
                 Message(message="happened?", rule_id="rule-2", severity=1),

tests/test_linter.py

@@ -10,7 +10,7 @@
 from xrlint.config import Config, ConfigObject
 from xrlint.constants import CORE_PLUGIN_NAME, DATASET_ROOT_NAME
 from xrlint.linter import Linter, new_linter
-from xrlint.node import AttrNode, AttrsNode, DatasetNode, VariableNode
+from xrlint.node import AttrNode, AttrsNode, DatasetNode, VariableNode, DataTreeNode
 from xrlint.plugin import new_plugin
 from xrlint.processor import ProcessorOp
 from xrlint.result import Message, Result
@@ -97,6 +97,7 @@ def assert_result_ok(self, result: Result, expected_message: str):
 
 
 class LinterValidateTest(TestCase):
+    # noinspection PyUnusedLocal
     def setUp(self):
         plugin = new_plugin(name="test")
 
@@ -113,7 +114,7 @@ def validate_attrs(self, ctx: RuleContext, node: AttrsNode):
                     ctx.report("Empty attributes")
 
         @plugin.define_rule("data-var-dim-must-have-coord")
-        class DataArrayVer(RuleOp):
+        class VariableVer(RuleOp):
             def validate_variable(self, ctx: RuleContext, node: VariableNode):
                 if node.in_data_vars():
                     for dim_name in node.array.dims:
@@ -131,6 +132,12 @@ def validate_dataset(self, ctx: RuleContext, node: DatasetNode):
                     ctx.report("Dataset does not have data variables")
                     raise RuleExit  # no need to traverse further
 
+        @plugin.define_rule("datatree-without-data-vars")
+        class DataTreeVer(RuleOp):
+            def validate_datatree(self, ctx: RuleContext, node: DataTreeNode):
+                if len(node.datatree.data_vars) == 0:
+                    ctx.report("DataTree does not have data variables")
+
         @plugin.define_processor("multi-level-dataset")
         class MultiLevelDataset(ProcessorOp):
             def preprocess(
@@ -159,6 +166,7 @@ def test_rules_are_ok(self):
                 "no-empty-attrs",
                 "data-var-dim-must-have-coord",
                 "dataset-without-data-vars",
+                "datatree-without-data-vars",
             ],
             list(self.linter.config.objects[0].plugins["test"].rules.keys()),
         )
@@ -171,11 +179,6 @@ def test_linter_respects_rule_severity_error(self):
             Result(
                 config_object=result.config_object,
                 file_path="<dataset>",
-                warning_count=0,
-                error_count=1,
-                fatal_error_count=0,
-                fixable_warning_count=0,
-                fixable_error_count=0,
                 messages=[
                     Message(
                         message="Dataset does not have data variables",
@@ -187,6 +190,9 @@ def test_linter_respects_rule_severity_error(self):
             ),
             result,
         )
+        self.assertEqual(0, result.warning_count)
+        self.assertEqual(1, result.error_count)
+        self.assertEqual(0, result.fatal_error_count)
 
     def test_linter_respects_rule_severity_warn(self):
         result = self.linter.validate(
@@ -196,11 +202,6 @@ def test_linter_respects_rule_severity_warn(self):
             Result(
                 config_object=result.config_object,
                 file_path="<dataset>",
-                warning_count=1,
-                error_count=0,
-                fatal_error_count=0,
-                fixable_warning_count=0,
-                fixable_error_count=0,
                 messages=[
                     Message(
                         message="Dataset does not have data variables",
@@ -212,6 +213,9 @@ def test_linter_respects_rule_severity_warn(self):
             ),
             result,
         )
+        self.assertEqual(1, result.warning_count)
+        self.assertEqual(0, result.error_count)
+        self.assertEqual(0, result.fatal_error_count)
 
     def test_linter_respects_rule_severity_off(self):
         result = self.linter.validate(
@@ -221,15 +225,13 @@ def test_linter_respects_rule_severity_off(self):
             Result(
                 config_object=result.config_object,
                 file_path="<dataset>",
-                warning_count=0,
-                error_count=0,
-                fatal_error_count=0,
-                fixable_warning_count=0,
-                fixable_error_count=0,
                 messages=[],
             ),
             result,
         )
+        self.assertEqual(0, result.warning_count)
+        self.assertEqual(0, result.error_count)
+        self.assertEqual(0, result.fatal_error_count)
 
     def test_linter_recognized_unknown_rule(self):
         result = self.linter.validate(xr.Dataset(), rules={"test/dataset-is-fast": 2})
@@ -246,6 +248,66 @@ def test_linter_recognized_unknown_rule(self):
             result.messages,
         )
 
+    def test_linter_recognized_datatree_rule(self):
+        result = self.linter.validate(
+            xr.DataTree(
+                children={
+                    "measurement": xr.DataTree(
+                        children={
+                            "r10m": xr.DataTree(),
+                            "r20m": xr.DataTree(),
+                            "r60m": xr.DataTree(),
+                        }
+                    )
+                }
+            ),
+            rules={"test/datatree-without-data-vars": 2},
+        )
+        self.assertEqual(
+            [
+                Message(
+                    message="DataTree does not have data variables",
+                    node_path="dt",
+                    rule_id="test/datatree-without-data-vars",
+                    severity=2,
+                    fatal=None,
+                    fix=None,
+                    suggestions=None,
+                ),
+                Message(
+                    message="DataTree does not have data variables",
+                    node_path="dt/measurement",
+                    rule_id="test/datatree-without-data-vars",
+                    severity=2,
+                    fatal=None,
+                    fix=None,
+                    suggestions=None,
+                ),
+                Message(
+                    message="DataTree does not have data variables",
+                    node_path="dt/measurement/r10m",
+                    rule_id="test/datatree-without-data-vars",
+                    severity=2,
+                ),
+                Message(
+                    message="DataTree does not have data variables",
+                    node_path="dt/measurement/r20m",
+                    rule_id="test/datatree-without-data-vars",
+                    severity=2,
+                ),
+                Message(
+                    message="DataTree does not have data variables",
+                    node_path="dt/measurement/r60m",
+                    rule_id="test/datatree-without-data-vars",
+                    severity=2,
+                ),
+            ],
+            result.messages,
+        )
+        self.assertEqual(0, result.warning_count)
+        self.assertEqual(5, result.error_count)
+        self.assertEqual(0, result.fatal_error_count)
+
     def test_linter_real_life_scenario(self):
         dataset = xr.Dataset(
             attrs={
@@ -286,11 +348,6 @@ def test_linter_real_life_scenario(self):
             Result(
                 config_object=result.config_object,
                 file_path="chl-tsm.zarr",
-                warning_count=1,
-                error_count=3,
-                fatal_error_count=0,
-                fixable_warning_count=0,
-                fixable_error_count=0,
                 messages=[
                     Message(
                         message="Attribute name with space: 'created at'",
@@ -328,6 +385,9 @@ def test_linter_real_life_scenario(self):
             ),
             result,
         )
+        self.assertEqual(1, result.warning_count)
+        self.assertEqual(3, result.error_count)
+        self.assertEqual(0, result.fatal_error_count)
 
     def test_processor_ok(self):
         result = self.linter.validate(

tests/test_result.py

@@ -32,24 +32,24 @@ class MyRule2(RuleOp):
         config_obj = ConfigObject(plugins={"test": plugin})
         rules_meta = get_rules_meta_for_results(
             results=[
-                Result.new(
-                    config_object=config_obj,
+                Result(
                     file_path="test.zarr",
+                    config_object=config_obj,
                     messages=[Message(message="m 1", rule_id="test/my-rule-1")],
                 ),
-                Result.new(
-                    config_object=config_obj,
+                Result(
                     file_path="test.zarr",
+                    config_object=config_obj,
                     messages=[Message(message="m 2", rule_id="test/my-rule-2")],
                 ),
-                Result.new(
-                    config_object=config_obj,
+                Result(
                     file_path="test.zarr",
+                    config_object=config_obj,
                     messages=[Message(message="m 3", rule_id="test/my-rule-1")],
                 ),
-                Result.new(
-                    config_object=config_obj,
+                Result(
                     file_path="test.zarr",
+                    config_object=config_obj,
                     messages=[Message(message="m 4", rule_id="test/my-rule-2")],
                 ),
             ]
@@ -66,19 +66,19 @@ class MyRule2(RuleOp):
         )
 
     def test_repr_html(self):
-        result = Result.new(
-            config_object=ConfigObject(),
+        result = Result(
             file_path="test.zarr",
+            config_object=ConfigObject(),
             messages=[],
         )
         html = result._repr_html_()
         self.assertIsInstance(html, str)
         self.assertIn("ok", html)
         self.assertIn("<div", html)
 
-        result = Result.new(
-            config_object=ConfigObject(),
+        result = Result(
             file_path="test.zarr",
+            config_object=ConfigObject(),
             messages=[Message(message="m 1", rule_id="test/my-rule-1")],
         )
         html = result._repr_html_()
@@ -108,23 +108,26 @@ def test_collect(self):
         self.assertEqual(0, stats.result_count)
 
         results = [
-            Result.new(
+            Result(
+                file_path="test.zarr",
                 messages=[
                     Message("R1 M1", severity=1),
                     Message("R1 M2", severity=2),
-                ]
+                ],
             ),
-            Result.new(
+            Result(
+                file_path="test.zarr",
                 messages=[
                     Message("R2 M1", severity=2),
-                ]
+                ],
             ),
-            Result.new(
+            Result(
+                file_path="test.zarr",
                 messages=[
                     Message("R3 M1", severity=1),
                     Message("R3 M2", severity=2),
                     Message("R3 M3", severity=2),
-                ]
+                ],
             ),
         ]
 

xrlint/_linter/validate.py

@@ -19,11 +19,11 @@ def validate_dataset(config_obj: ConfigObject, dataset: Any, file_path: str):
     assert isinstance(config_obj, ConfigObject)
     assert dataset is not None
     assert isinstance(file_path, str)
-    if isinstance(dataset, xr.Dataset):
+    if isinstance(dataset, (xr.Dataset, xr.DataTree)):
         messages = _validate_dataset(config_obj, dataset, file_path, None, None)
     else:
         messages = _open_and_validate_dataset(config_obj, dataset, file_path)
-    return Result.new(config_object=config_obj, messages=messages, file_path=file_path)
+    return Result(file_path=file_path, config_object=config_obj, messages=messages)
 
 
 def _validate_dataset(