deep-code 0.1.3__tar.gz → 0.1.4.dev1__tar.gz

{deep_code-0.1.3 → deep_code-0.1.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deep_code
-Version: 0.1.3
+Version: 0.1.4.dev1
 Summary: deepesdl earthcode integration utility tool
 Author-email: Tejas Morbagal Harish <tejas.morbagalharish@brockmann-consult.de>
 License: MIT

deep_code-0.1.4.dev1/deep_code/tests/utils/test_custom_xrlint_rules.py

@@ -0,0 +1,73 @@
+# Copyright © 2025 Brockmann Consult GmbH.
+# This software is distributed under the terms and conditions of the
+# MIT license (https://mit-license.org/).
+
+import unittest
+
+import xarray as xr
+from xrlint.testing import RuleTest, RuleTester
+
+from deep_code.utils.custom_xrlint_rules import (
+    DatasetDescriptionRule,
+    VariableGcmdKeywordUrlRule,
+)
+
+
+class TestDeepCodePlugin(unittest.TestCase):
+    def setUp(self):
+        """Set up test datasets."""
+        # Valid dataset with all required metadata
+        self.valid_dataset = xr.Dataset(
+            data_vars={
+                "temperature": (("time", "lat", "lon"), [[[300, 301], [302, 303]]]),
+                "precipitation": (("time", "lat", "lon"), [[[10, 20], [30, 40]]]),
+            },
+            coords={"time": [1], "lat": [0, 1], "lon": [0, 1]},
+            attrs={
+                "description": "Test climate dataset",
+                "title": "Climate Dataset 2025",
+            },
+        )
+        self.valid_dataset["temperature"].attrs[
+            "gcmd_keyword_url"
+        ] = "https://gcmd.nasa.gov/KeywordViewer/temperature"
+        self.valid_dataset["temperature"].attrs["units"] = "K"
+        self.valid_dataset["precipitation"].attrs[
+            "gcmd_keyword_url"
+        ] = "https://gcmd.nasa.gov/KeywordViewer/precipitation"
+        self.valid_dataset["precipitation"].attrs["units"] = "mm"
+
+        # Invalid dataset missing required metadata
+        self.invalid_dataset = xr.Dataset(
+            data_vars={
+                "temperature": (("time", "lat", "lon"), [[[300, 301], [302, 303]]]),
+                "precipitation": (("time", "lat", "lon"), [[[10, 20], [30, 40]]]),
+            },
+            coords={"time": [1], "lat": [0, 1], "lon": [0, 1]},
+            attrs={},
+        )
+        self.invalid_dataset["temperature"].attrs[
+            "gcmd_keyword_url"
+        ] = "https://gcmd.nasa.gov/KeywordViewer/temperature"
+        self.invalid_dataset["temperature"].attrs["units"] = "K"
+        # Intentionally omit gcmd_keyword_url and units for precipitation
+
+        self.tester = RuleTester()
+
+    def test_dataset_description(self):
+        """Test DatasetDescriptionRule with valid and invalid dataset."""
+        self.tester.run(
+            "dataset-description",
+            DatasetDescriptionRule,
+            valid=[RuleTest(dataset=self.valid_dataset)],
+            invalid=[RuleTest(dataset=self.invalid_dataset, expected=1)],
+        )
+
+    def test_variable_gcmd_keyword_url(self):
+        """Test VariableGcmdKeywordUrlRule with valid dataset."""
+        self.tester.run(
+            "variable-gcmd-keyword-url",
+            VariableGcmdKeywordUrlRule,
+            valid=[RuleTest(dataset=self.valid_dataset)],
+            invalid=[RuleTest(dataset=self.invalid_dataset, expected=1)],
+        )

deep_code-0.1.4.dev1/deep_code/tests/utils/test_dataset_stac_generator.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.
+
+import unittest
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+from pystac import Catalog, Collection
+from xarray import DataArray, Dataset
+
+from deep_code.constants import (
+    DEEPESDL_COLLECTION_SELF_HREF,
+    OSC_THEME_SCHEME,
+    PRODUCT_BASE_CATALOG_SELF_HREF,
+    VARIABLE_BASE_CATALOG_SELF_HREF,
+)
+from deep_code.utils.dataset_stac_generator import OscDatasetStacGenerator, Theme
+
+
+class TestOSCProductSTACGenerator(unittest.TestCase):
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def setUp(self, mock_data_store):
+        """Set up a mock dataset and generator."""
+        self.mock_dataset = Dataset(
+            coords={
+                "lon": ("lon", np.linspace(-180, 180, 10)),
+                "lat": ("lat", np.linspace(-90, 90, 5)),
+                "time": (
+                    "time",
+                    [
+                        np.datetime64(datetime(2023, 1, 1), "ns"),
+                        np.datetime64(datetime(2023, 1, 2), "ns"),
+                    ],
+                ),
+            },
+            attrs={"description": "Mock dataset for testing.", "title": "Mock Dataset"},
+            data_vars={
+                "var1": (
+                    ("time", "lat", "lon"),
+                    np.random.rand(2, 5, 10),
+                    {
+                        "description": "dummy",
+                        "standard_name": "var1",
+                        "gcmd_keyword_url": "https://dummy",
+                    },
+                ),
+                "var2": (
+                    ("time", "lat", "lon"),
+                    np.random.rand(2, 5, 10),
+                    {
+                        "description": "dummy",
+                        "standard_name": "var2",
+                        "gcmd_keyword_url": "https://dummy",
+                    },
+                ),
+            },
+        )
+        mock_store = MagicMock()
+        mock_store.open_data.return_value = self.mock_dataset
+        mock_data_store.return_value = self.mock_dataset
+
+        self.generator = OscDatasetStacGenerator(
+            dataset_id="mock-dataset-id",
+            collection_id="mock-collection-id",
+            access_link="s3://mock-bucket/mock-dataset",
+            documentation_link="https://example.com/docs",
+            osc_status="ongoing",
+            osc_region="Global",
+            osc_themes=["climate", "environment"],
+        )
+
+    def test_open_dataset(self):
+        """Test if the dataset is opened correctly."""
+        self.assertIsInstance(self.generator.dataset, Dataset)
+        for coord in ("lon", "lat", "time"):
+            self.assertIn(coord, self.generator.dataset.coords)
+
+    def test_get_spatial_extent(self):
+        """Test spatial extent extraction."""
+        extent = self.generator._get_spatial_extent()
+        self.assertEqual(extent.bboxes[0], [-180.0, -90.0, 180.0, 90.0])
+
+    def test_get_temporal_extent(self):
+        """Test temporal extent extraction."""
+        extent = self.generator._get_temporal_extent()
+        # TemporalExtent.intervals is a list of [start, end]
+        interval = extent.intervals[0]
+        self.assertEqual(interval[0], datetime(2023, 1, 1, 0, 0))
+        self.assertEqual(interval[1], datetime(2023, 1, 2, 0, 0))
+
+    def test_get_variables(self):
+        """Test variable ID extraction."""
+        vars_ = self.generator.get_variable_ids()
+        self.assertCountEqual(vars_, ["var1", "var2"])
+
+    def test_get_general_metadata(self):
+        """Test general metadata extraction."""
+        meta = self.generator._get_general_metadata()
+        self.assertEqual(meta.get("description"), "Mock dataset for testing.")
+
+    def test_extract_metadata_for_variable(self):
+        """Test single variable metadata extraction."""
+        da: DataArray = self.mock_dataset.data_vars["var1"]
+        var_meta = self.generator.extract_metadata_for_variable(da)
+        self.assertEqual(var_meta["variable_id"], "var1")
+        self.assertEqual(var_meta["description"], "dummy")
+        self.assertEqual(var_meta["gcmd_keyword_url"], "https://dummy")
+
+    def test_get_variables_metadata(self):
+        """Test metadata dict for all variables."""
+        meta_dict = self.generator.get_variables_metadata()
+        self.assertIn("var1", meta_dict)
+        self.assertIn("var2", meta_dict)
+        self.assertIsInstance(meta_dict["var1"], dict)
+
+    def test_build_theme(self):
+        """Test Theme builder static method."""
+        themes = ["a", "b"]
+        theme_obj: Theme = OscDatasetStacGenerator.build_theme(themes)
+        self.assertEqual(theme_obj.scheme, OSC_THEME_SCHEME)
+        ids = [tc.id for tc in theme_obj.concepts]
+        self.assertListEqual(ids, ["a", "b"])
+
+    @patch.object(OscDatasetStacGenerator, "_add_gcmd_link_to_var_catalog")
+    @patch.object(OscDatasetStacGenerator, "add_themes_as_related_links_var_catalog")
+    def test_build_variable_catalog(self, mock_add_themes, mock_add_gcmd):
+        """Test building of variable-level STAC catalog."""
+        var_meta = self.generator.variables_metadata["var1"]
+        catalog = self.generator.build_variable_catalog(var_meta)
+        self.assertIsInstance(catalog, Catalog)
+        self.assertEqual(catalog.id, "var1")
+        # Title should be capitalized
+        self.assertEqual(catalog.title, "Var1")
+        # Self href ends with var1/catalog.json
+        self.assertTrue(catalog.self_href.endswith("/var1/catalog.json"))
+
+    @patch("pystac.Catalog.from_file")
+    def test_update_product_base_catalog(self, mock_from_file):
+        """Test linking product catalog."""
+        mock_cat = MagicMock(spec=Catalog)
+        mock_from_file.return_value = mock_cat
+
+        result = self.generator.update_product_base_catalog("path.json")
+        self.assertIs(result, mock_cat)
+        mock_cat.add_link.assert_called_once()
+        mock_cat.set_self_href.assert_called_once_with(PRODUCT_BASE_CATALOG_SELF_HREF)
+
+    @patch("pystac.Catalog.from_file")
+    def test_update_variable_base_catalog(self, mock_from_file):
+        """Test linking variable base catalog."""
+        mock_cat = MagicMock(spec=Catalog)
+        mock_from_file.return_value = mock_cat
+
+        vars_ = ["v1", "v2"]
+        result = self.generator.update_variable_base_catalog("vars.json", vars_)
+        self.assertIs(result, mock_cat)
+        # Expect one add_link per variable
+        self.assertEqual(mock_cat.add_link.call_count, len(vars_))
+        mock_cat.set_self_href.assert_called_once_with(VARIABLE_BASE_CATALOG_SELF_HREF)
+
+    @patch("pystac.Collection.from_file")
+    def test_update_deepesdl_collection(self, mock_from_file):
+        """Test updating DeepESDL collection."""
+        mock_coll = MagicMock(spec=Collection)
+        mock_from_file.return_value = mock_coll
+
+        result = self.generator.update_deepesdl_collection("deep.json")
+        self.assertIs(result, mock_coll)
+        # Expect child and theme related links for each theme
+        calls = mock_coll.add_link.call_count
+        self.assertGreaterEqual(calls, 1 + len(self.generator.osc_themes))
+        mock_coll.set_self_href.assert_called_once_with(DEEPESDL_COLLECTION_SELF_HREF)
+
+
+class TestFormatString(unittest.TestCase):
+    def test_single_word(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("temperature"), "Temperature"
+        )
+        self.assertEqual(OscDatasetStacGenerator.format_string("temp"), "Temp")
+        self.assertEqual(OscDatasetStacGenerator.format_string("hello"), "Hello")
+
+    def test_multiple_words_with_spaces(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface temp"), "Surface Temp"
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("this is a test"), "This Is A Test"
+        )
+
+    def test_multiple_words_with_underscores(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface_temp"), "Surface Temp"
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("this_is_a_test"), "This Is A Test"
+        )
+
+    def test_mixed_spaces_and_underscores(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface_temp and_more"),
+            "Surface Temp And More",
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string(
+                "mixed_case_with_underscores_and spaces"
+            ),
+            "Mixed Case With Underscores And Spaces",
+        )
+
+    def test_edge_cases(self):
+        # Empty string
+        self.assertEqual(OscDatasetStacGenerator.format_string(""), "")
+        # Single word with trailing underscore
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("temperature_"), "Temperature"
+        )
+        # Single word with leading underscore
+        self.assertEqual(OscDatasetStacGenerator.format_string("_temp"), "Temp")
+        # Single word with leading/trailing spaces
+        self.assertEqual(OscDatasetStacGenerator.format_string("  hello  "), "Hello")
+        # Multiple spaces or underscores
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("too___many___underscores"),
+            "Too Many Underscores",
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("too   many   spaces"),
+            "Too Many Spaces",
+        )

deep_code-0.1.4.dev1/deep_code/tests/utils/test_helper.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.
+
+import os
+import unittest
+from unittest.mock import MagicMock, call, patch
+
+import xarray
+import xarray as xr
+
+from deep_code.utils.helper import open_dataset
+
+
+def make_dummy_dataset():
+    """Create a simple xarray.Dataset for testing."""
+    return xr.Dataset(
+        coords={"time": [0, 1, 2]}, data_vars={"x": (("time",), [10, 20, 30])}
+    )
+
+
+class TestOpenDataset(unittest.TestCase):
+    @patch("deep_code.utils.helper.logging.getLogger")
+    @patch("deep_code.utils.helper.new_data_store")
+    def test_success_public_store(self, mock_new_store, mock_get_logger):
+        """Should open dataset with the public store on first try."""
+        dummy = make_dummy_dataset()
+        mock_store = MagicMock()
+        mock_store.open_data.return_value = dummy
+        mock_new_store.return_value = mock_store
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        result = open_dataset("test-id")
+
+        self.assertIs(result, dummy)
+        mock_new_store.assert_called_once_with(
+            "s3", root="deep-esdl-public", storage_options={"anon": True}
+        )
+        mock_logger.info.assert_any_call(
+            "Attempting to open dataset 'test-id' with configuration: Public store"
+        )
+        mock_logger.info.assert_any_call(
+            "Successfully opened dataset 'test-id' with configuration: Public store"
+        )
+
+    @patch("deep_code.utils.helper.new_data_store")
+    @patch("deep_code.utils.helper.logging.getLogger")
+    def test_open_dataset_success_authenticated_store(
+        self, mock_get_logger, mock_new_store
+    ):
+        """Test fallback to authenticated store when public store fails."""
+        mock_store = MagicMock()
+        mock_new_store.side_effect = [Exception("Public store failure"), mock_store]
+        mock_store.open_data.return_value = make_dummy_dataset()
+
+        os.environ["S3_USER_STORAGE_BUCKET"] = "mock-bucket"
+        os.environ["S3_USER_STORAGE_KEY"] = "mock-key"
+        os.environ["S3_USER_STORAGE_SECRET"] = "mock-secret"
+
+        ds = open_dataset("my-id", logger=mock_get_logger())
+
+        self.assertIsInstance(ds, xarray.Dataset)
+
+        # And new_data_store should have been called twice with exactly these params
+        expected_calls = [
+            call("s3", root="deep-esdl-public", storage_options={"anon": True}),
+            call(
+                "s3",
+                root="mock-bucket",
+                storage_options={
+                    "anon": False,
+                    "key": "mock-key",
+                    "secret": "mock-secret",
+                },
+            ),
+        ]
+        mock_new_store.assert_has_calls(expected_calls, any_order=False)
+
+        # And the logger should have info about both attempts
+        logger = mock_get_logger()
+        logger.info.assert_any_call(
+            "Attempting to open dataset 'my-id' with configuration: Public store"
+        )
+        logger.info.assert_any_call(
+            "Attempting to open dataset 'my-id' with configuration: Authenticated store"
+        )
+        logger.info.assert_any_call(
+            "Successfully opened dataset 'my-id' with configuration: Authenticated store"
+        )
+
+    @patch("deep_code.utils.helper.logging.getLogger")
+    @patch("deep_code.utils.helper.new_data_store")
+    def test_all_stores_fail_raises(self, mock_new_store, mock_get_logger):
+        """Should raise ValueError if all stores fail."""
+        mock_new_store.side_effect = Exception("fail")
+        os.environ["S3_USER_STORAGE_BUCKET"] = "user-bucket"
+        os.environ["S3_USER_STORAGE_KEY"] = "key"
+        os.environ["S3_USER_STORAGE_SECRET"] = "secret"
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        with self.assertRaises(ValueError) as ctx:
+            open_dataset("test-id")
+        msg = str(ctx.exception)
+        self.assertIn("Tried configurations: Public store, Authenticated store", msg)
+        self.assertIn("Last error: fail", msg)
+
+    @patch("deep_code.utils.helper.logging.getLogger")
+    @patch("deep_code.utils.helper.new_data_store")
+    def test_with_custom_configs(self, mock_new_store, mock_get_logger):
+        """Should use provided storage_configs instead of defaults."""
+        dummy = make_dummy_dataset()
+        mock_store = MagicMock()
+        mock_store.open_data.return_value = dummy
+        mock_new_store.return_value = mock_store
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        custom_cfgs = [
+            {
+                "description": "Local store",
+                "params": {"storage_type": "file", "root": ".", "storage_options": {}},
+            }
+        ]
+
+        result = open_dataset("test-id", storage_configs=custom_cfgs)
+
+        self.assertIs(result, dummy)
+        mock_new_store.assert_called_once_with("file", root=".", storage_options={})
+        mock_logger.info.assert_any_call(
+            "Attempting to open dataset 'test-id' with configuration: Local store"
+        )
+        mock_logger.info.assert_any_call(
+            "Successfully opened dataset 'test-id' with configuration: Local store"
+        )
+
+    @patch("deep_code.utils.helper.logging.getLogger")
+    @patch("deep_code.utils.helper.new_data_store")
+    def test_uses_provided_logger(self, mock_new_store, mock_get_logger):
+        """Should use the logger provided by the caller."""
+        dummy = make_dummy_dataset()
+        mock_store = MagicMock()
+        mock_store.open_data.return_value = dummy
+        mock_new_store.return_value = mock_store
+        custom_logger = MagicMock()
+        mock_get_logger.side_effect = AssertionError("getLogger should not be used")
+
+        result = open_dataset("test-id", logger=custom_logger)
+
+        self.assertIs(result, dummy)
+        custom_logger.info.assert_any_call(
+            "Attempting to open dataset 'test-id' with configuration: Public store"
+        )
+        custom_logger.info.assert_any_call(
+            "Successfully opened dataset 'test-id' with configuration: Public store"
+        )

deep_code-0.1.4.dev1/deep_code/tools/lint.py

@@ -0,0 +1,37 @@
+import xarray as xr
+from xrlint.linter import new_linter
+from xrlint.result import Result
+
+from deep_code.utils.custom_xrlint_rules import export_config
+from deep_code.utils.helper import open_dataset
+
+
+class LintDataset:
+    """Lints xarray dataset using xrlint library.
+
+    Args:
+        dataset_id (str | None): ID of a Zarr dataset in the DeepESDL public or team bucket.
+        dataset (xr.Dataset | None): In-memory xarray.Dataset instance.
+
+    Note:
+        One of `dataset_id` or `dataset` must be provided.
+    """
+
+    def __init__(
+        self, dataset_id: str | None = None, dataset: xr.Dataset | None = None
+    ):
+        if not dataset_id and not dataset:
+            raise ValueError("You must provide either `dataset_id` or `dataset`.")
+        self.dataset_id = dataset_id
+        self.dataset = dataset
+
+    def lint_dataset(self) -> Result:
+        if self.dataset is not None:
+            ds = self.dataset
+        elif self.dataset_id is not None:
+            ds = open_dataset(self.dataset_id)
+        else:
+            raise RuntimeError("No dataset to lint.")
+
+        linter = new_linter(*export_config())
+        return linter.validate(ds)

{deep_code-0.1.3 → deep_code-0.1.4.dev1}/deep_code/tools/new.py

@@ -15,24 +15,24 @@ class TemplateGenerator:
         """Generate a complete template with all possible keys and placeholder values"""
 
         template = {
-            "workflow_id": "[WORKFLOW_ID]",
+            "workflow_id": "[A unique identifier for your workflow]",
             "properties": {
-                "title": "[TITLE]",
-                "description": "[DESCRIPTION]",
+                "title": "[Human-readable title of the workflow]",
+                "description": "[A concise summary of what the workflow does]",
                 "keywords": ["[KEYWORD1]", "[KEYWORD2]"],
-                "themes": ["[THEME1]", "[THEME2]"],
-                "license": "[LICENSE_TYPE]",
+                "themes": ["[Thematic area(s) of focus (e.g. land, ocean, atmosphere)]","[THEME1]", "[THEME2]"],
+                "license": "[License type (e.g. MIT, Apache-2.0, CC-BY-4.0, proprietary)]",
                 "jupyter_kernel_info": {
-                    "name": "[DEEPESDL_KERNEL_NAME]",
+                    "name": "[Name of the execution environment or notebook kernel]",
                     "python_version": "[PYTHON_VERSION]",
-                    "env_file": "[ENV_FILE_URL_IN_GIT]",
+                    "env_file": "[Link to the environment file (YAML) used to create the notebook environment]",
                 },
             },
-            "jupyter_notebook_url": "[NOTEBOOK_URL]",
+            "jupyter_notebook_url": "[Link to the source notebook (e.g. on GitHub)]",
             "contact": [
                 {
-                    "name": "[CONTACT_NAME]",
-                    "organization": "[ORGANIZATION]",
+                    "name": "[Contact person's full name]",
+                    "organization": "[Affiliated institution or company]",
                     "links": [
                         {
                             "rel": "about",
@@ -59,12 +59,13 @@ class TemplateGenerator:
         """Generate a complete dataset template with all possible keys and placeholder values"""
 
         template = {
-            "dataset_id": "[DATASET_ID].zarr",
-            "collection_id": "[COLLECTION_ID]",
-            "osc_themes": ["[THEME1]", "[THEME2]"],
-            "osc_region": "[REGION]",
-            "dataset_status": "[STATUS]",
-            "documentation_link": "[DOCS_URL]",
+            "dataset_id": "[The name of the dataset object within your S3 bucket].zarr",
+            "collection_id": "[A unique identifier for the dataset collection]",
+            "osc_themes": ["[Oceans]",  "[Open Science theme (choose from "
+                                           "https://opensciencedata.esa.int/themes/catalog)"],
+            "osc_region": "[Geographical coverage, e.g. 'global']",
+            "dataset_status": "[Status of the dataset: 'ongoing', 'completed', or 'planned']",
+            "documentation_link": "[Link to relevant documentation, publication, or handbook]",
         }
 
         yaml_str = yaml.dump(

deep_code-0.1.4.dev1/deep_code/utils/custom_xrlint_rules.py

@@ -0,0 +1,78 @@
+# Copyright © 2025 Brockmann Consult GmbH.
+# This software is distributed under the terms and conditions of the
+# MIT license (https://mit-license.org/).
+
+"""
+This module defines the deepcode plugin for XRLint, which validates
+metadata required for dataset publication to a catalog. It checks for:
+- A 'description' attribute in dataset.attrs
+- A 'gcmd_keyword_url' attribute in each variable's attrs
+"""
+
+from xrlint.node import DatasetNode, VariableNode
+from xrlint.plugin import new_plugin
+from xrlint.rule import RuleContext, RuleOp
+
+plugin = new_plugin(name="deepcode", version="1.0.0")
+
+
+@plugin.define_rule("dataset-description")
+class DatasetDescriptionRule(RuleOp):
+    """Ensures the dataset has a 'description' attribute."""
+
+    def validate_dataset(self, ctx: RuleContext, node: DatasetNode):
+        if "description" not in node.dataset.attrs:
+            ctx.report(
+                "Dataset missing required 'description' attribute.",
+                suggestions=["Add a 'description' attribute to dataset.attrs."],
+            )
+
+
+@plugin.define_rule("variable-gcmd-keyword-url")
+class VariableGcmdKeywordUrlRule(RuleOp):
+    """Ensures all variables have a 'gcmd_keyword_url' attribute."""
+
+    def validate_variable(self, ctx: RuleContext, node: VariableNode):
+        if node.name not in ctx.dataset.data_vars:
+            return
+
+        if "gcmd_keyword_url" not in node.array.attrs:
+            ctx.report(f"Variable '{node.name}' missing 'gcmd_keyword_url' attribute.")
+
+
+# Define the recommended ruleset for this plugin
+plugin.define_config(
+    "recommended",
+    [
+        {
+            "rules": {
+                "deepcode/variable-gcmd-keyword-url": "error",
+                "deepcode/dataset-description": "error",
+            }
+        }
+    ],
+)
+
+
+def export_config() -> list:
+    """
+    Export the plugin configuration to be consumed by the XRLint Linter.
+
+    Returns
+    -------
+    list
+        A list of plugin config dictionaries and rule presets.
+    """
+    return [
+        {"plugins": {"deepcode": plugin}},
+        "recommended",
+        {
+            "rules": {
+                "content-desc": "off",
+                "no-empty-attrs": "off",
+                "conventions": "off",
+                "time-coordinate": "off"
+            }
+        },
+        "deepcode/recommended",
+    ]