climate-ref-core 0.16.0__tar.gz → 0.16.2__tar.gz

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/.gitignore

@@ -164,11 +164,15 @@ packages/*/NOTICE
 # Generated SDK
 /climate_ref_client
 
+# Test cases
+# Only track the materialised data for the test cases, not the raw output of the providers.
+**/test-data/**/output/
+**/test-data/**/regression/**
+!**/test-data/**/regression/*.json
+
 # User-specific catalog paths (test data)
 *.paths.yaml
 
-# Materialised test-case output slots (local inspection only; never committed)
-**/test-data/**/output/
 
 # Debug log files
 **/main_log_debug.txt

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: climate-ref-core
-Version: 0.16.0
+Version: 0.16.2
 Summary: Core library for the CMIP Rapid Evaluation Framework
 Author-email: Jared Lewis <jared.lewis@climate-resource.com>, Mika Pflueger <mika.pflueger@climate-resource.com>, Bouwe Andela <b.andela@esciencecenter.nl>, Jiwoo Lee <lee1043@llnl.gov>, Min Xu <xum1@ornl.gov>, Nathan Collier <collierno@ornl.gov>, Dora Hegedus <dora.hegedus@stfc.ac.uk>
 License-Expression: Apache-2.0

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "climate-ref-core"
-version = "0.16.0"
+version = "0.16.2"
 description = "Core library for the CMIP Rapid Evaluation Framework"
 readme = "README.md"
 authors = [

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/dataset_registry.py

@@ -6,21 +6,67 @@ The CMIP7 Assessment Fas Track REF requires that reference datasets are openly l
 before it is included in any published data catalogs.
 """
 
+import enum
 import importlib.resources
 import os
 import pathlib
 import shutil
+from collections.abc import Iterator
 
 import pooch
 import pooch.hashes
+from attrs import frozen
 from loguru import logger
 from rich.progress import track
 
 from climate_ref_core.env import env
+from climate_ref_core.source_types import SourceDatasetType
 
 DATASET_URL = env.str("REF_DATASET_URL", default="https://obs4ref.climate-ref.org")
 
 
+class RegistryUseCase(enum.Enum):
+    """
+    Whether a registry's contents are catalog-ingestable or fetch-only.
+    """
+
+    reference = "reference"
+    """
+    Contents are catalog-ingestable reference data.
+
+    The registry declares exactly one target source type,
+    which is used to select the parsing adapter during ingest.
+    """
+
+    support = "support"
+    """
+    Contents are fetch-only support files (e.g. region masks, recipes).
+
+    These are never entered into the catalog.
+    """
+
+
+@frozen
+class RegistryEntry:
+    """
+    A dataset registry together with its ingest metadata.
+    """
+
+    registry: pooch.Pooch
+    """The underlying Pooch registry."""
+
+    source_type: SourceDatasetType | None
+    """
+    The target source type used to select the parsing adapter.
+
+    Required for ``reference`` registries.
+    ``None`` for ``support`` registries, since fetch-only content is never parsed.
+    """
+
+    use_case: RegistryUseCase
+    """Whether the registry's contents are catalog-ingestable or fetch-only."""
+
+
 def resolve_cache_dir(cache_name: str) -> pathlib.Path:
     """
     Resolve the cache directory for a registry.
@@ -216,12 +262,18 @@ class DatasetRegistryManager:
     """
 
     def __init__(self) -> None:
-        self._registries: dict[str, pooch.Pooch] = {}
+        self._registries: dict[str, RegistryEntry] = {}
 
     def __getitem__(self, item: str) -> pooch.Pooch:
         """
         Get a registry by name
         """
+        return self._registries[item].registry
+
+    def entry(self, item: str) -> RegistryEntry:
+        """
+        Get the full registry entry (registry, source type and use-case) by name
+        """
         return self._registries[item]
 
     def keys(self) -> list[str]:
@@ -275,6 +327,8 @@ class DatasetRegistryManager:
         cache_name: str | None = None,
         version: str | None = None,
         legacy_cache_dirs: list[pathlib.Path] | None = None,
+        source_type: SourceDatasetType | None = None,
+        use_case: RegistryUseCase = RegistryUseCase.support,
     ) -> None:
         """
         Register a new dataset registry
@@ -310,6 +364,19 @@ class DatasetRegistryManager:
             If provided, any files that exist in a legacy directory but not in
             the current cache will be moved to the new location. This avoids
             re-downloading data after a cache layout change.
+        source_type
+            The target source type used to select the parsing adapter.
+
+            Required for ``reference`` registries.
+            Leave as ``None`` for ``support`` registries,
+            or for registries whose contents span more than one source type
+            (which cannot be catalogued by registry-driven ingest at all).
+        use_case
+            Whether the registry's contents are catalog-ingestable (``reference``)
+            or fetch-only (``support``).
+
+            Defaults to ``support`` so that an unannotated registry is never
+            catalogued by registry-driven ingest.
         """
         if cache_name is None:
             cache_name = name
@@ -336,7 +403,39 @@ class DatasetRegistryManager:
         if cache_path != default_legacy:
             self._migrate_cache(registry, all_legacy_dirs)
 
-        self._registries[name] = registry
+        self._registries[name] = RegistryEntry(
+            registry=registry,
+            source_type=source_type,
+            use_case=use_case,
+        )
 
 
 dataset_registry_manager = DatasetRegistryManager()
+
+
+def iter_reference_registries(
+    manager: DatasetRegistryManager,
+) -> Iterator[tuple[pooch.Pooch, SourceDatasetType]]:
+    """
+    Yield the ``(registry, source_type)`` pairs for all catalog-ingestable registries.
+
+    Registries whose ``use_case`` is not ``reference``, or whose ``source_type`` is
+    ``None`` (e.g. registries that mix source types and so cannot be catalogued as
+    a whole), are skipped.
+    A later ingest driver can pass the yielded ``source_type`` to
+    :func:`climate_ref.datasets.get_dataset_adapter` to select the parsing adapter.
+
+    Parameters
+    ----------
+    manager
+        The registry manager to read entries from.
+
+    Returns
+    -------
+    :
+        An iterator of ``(registry, source_type)`` pairs.
+    """
+    for name in manager.keys():
+        entry = manager.entry(name)
+        if entry.use_case is RegistryUseCase.reference and entry.source_type is not None:
+            yield entry.registry, entry.source_type

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/esgf/__init__.py

@@ -5,7 +5,7 @@ This module provides classes for searching and fetching datasets from ESGF
 (Earth System Grid Federation) and other data registries.
 """
 
-from climate_ref_core.esgf.base import ESGFRequest, IntakeESGFMixin
+from climate_ref_core.esgf.base import ESGFRequest, IntakeESGFMixin, enable_ceda_solr_index
 from climate_ref_core.esgf.cmip6 import CMIP6Request
 from climate_ref_core.esgf.cmip7 import CMIP7Request
 from climate_ref_core.esgf.fetcher import ESGFFetcher
@@ -20,4 +20,5 @@ __all__ = [
     "IntakeESGFMixin",
     "Obs4MIPsRequest",
     "RegistryRequest",
+    "enable_ceda_solr_index",
 ]

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/esgf/base.py

@@ -7,8 +7,24 @@ using the intake-esgf package.
 
 from typing import Any, Protocol, runtime_checkable
 
+import intake_esgf
 import pandas as pd
 from intake_esgf import ESGFCatalog
+from intake_esgf.exceptions import NoSearchResults
+
+from climate_ref_core.exceptions import DatasetResolutionError
+
+
+def enable_ceda_solr_index() -> None:
+    """
+    Enable the CEDA Solr index as an additional ESGF search index.
+
+    The obs4MIPs record for C3S-GTO-ECV-9-0 (the ozone reference) is missing
+    from the default ESGF2-US-1.5-Catalog index but is still served by the
+    CEDA Solr index, so search that index as well.
+    Remove once the record returns to the 1.5 catalog.
+    """
+    intake_esgf.conf["solr_indices"]["esgf.ceda.ac.uk"] = True
 
 
 @runtime_checkable
@@ -107,9 +123,15 @@ class IntakeESGFMixin:
         # intake-esgf assigns Python lists into individual DataFrame cells, which only works for object dtype.
         # Pandas >= 3.0 defaults strings to the pyarrow-backed dtype, where that assignment raises,
         # so pin the legacy object-string behaviour for the intake-esgf interaction.
+        enable_ceda_solr_index()
+
         with pd.option_context("future.infer_string", False):
             cat = ESGFCatalog()  # type: ignore[no-untyped-call]
-            cat.search(**facets)
+            try:
+                cat.search(**facets)
+            except NoSearchResults:
+                msg = f"ESGF search returned no results for facets: {facets}"
+                raise DatasetResolutionError(msg) from None
 
             if self.remove_ensembles:
                 cat.remove_ensembles()

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/esgf/cmip7.py

@@ -11,7 +11,6 @@ from pathlib import Path
 from typing import Any, ClassVar
 
 import pandas as pd
-import platformdirs
 import xarray as xr
 from loguru import logger
 
@@ -25,14 +24,14 @@ from climate_ref_core.cmip6_to_cmip7 import (
     shift_time_axis_end,
     suppress_bounds_coordinates,
 )
+from climate_ref_core.dataset_registry import resolve_cache_dir
 from climate_ref_core.esgf.cmip6 import CMIP6Request
 
 
 def _get_cmip7_cache_dir() -> Path:
     """Get the cache directory for converted CMIP7 files."""
-    # Use platform-appropriate cache directory for climate-ref
-    # This avoids polluting the intake-esgf cache with converted files
-    cache_dir = Path(platformdirs.user_cache_dir("climate_ref")) / "cmip7-converted"
+    # Kept out of the intake-esgf cache so converted files don't mix with downloads.
+    cache_dir = resolve_cache_dir("cmip7-converted")
     cache_dir.mkdir(parents=True, exist_ok=True)
     return cache_dir
 

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/pycmec/cv_cmip7_aft.yaml

@@ -66,6 +66,11 @@ dimensions:
   description: "Global warming level (e.g., 1.5C, 2C, etc.)"
   allow_extra_values: true
   required: false
+- name: level
+  long_name: Level
+  description: "Vertical level at which the metric is calculated (e.g. pressure level in hPa)"
+  allow_extra_values: true
+  required: false
 - name: metric
   long_name: Metric
   description: ""

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/regression/_quantise.py

@@ -8,9 +8,9 @@ producing noisy, unreviewable diffs in the committed bundle.
 
 Rounding every float to a fixed number of significant figures at write time gives
 stable, reviewable committed bytes.
-We round to seven significant figures: one digit finer than the regression compare tolerance
-(``rtol=1e-6`` in :mod:`climate_ref_core.regression.compare`),
-so the rounding error stays an order of magnitude under tolerance and can never flip a boundary gate verdict.
+We round to seven significant figures: two digits finer than the regression compare tolerance
+(``rtol=1e-5`` in :mod:`climate_ref_core.regression.compare`),
+so the rounding error stays well under tolerance and can never flip a boundary gate verdict.
 
 This affects only the committed bundle.
 The native blobs (``.nc`` / ``.png``) and their content-addressed digests are never touched.
@@ -21,7 +21,7 @@ from typing import Any
 DEFAULT_SIG_FIGS: int = 7
 """Default significant figures for committed-bundle floats.
 
-Deliberately one digit finer than the ``rtol=1e-6`` regression compare tolerance,
+Deliberately two digits finer than the ``rtol=1e-5`` regression compare tolerance,
 so rounding never flips a boundary gate verdict.
 """
 

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/regression/capture.py

@@ -68,6 +68,12 @@ _REDACTED_PROVENANCE_PLATFORM_FIELDS: dict[str, str] = {
     "OS": "<OS>",
 }
 
+# ``conda`` sub-block fields, redacted for the same reason
+# (an ``osx-64`` mint must match a ``linux-64`` CI execute).
+_REDACTED_PROVENANCE_CONDA_FIELDS: dict[str, str] = {
+    "Platform": "<CONDA_PLATFORM>",
+}
+
 _SOURCE_DIR_PLACEHOLDER = "<SOURCE_DIR>"
 
 # Matches the machine-specific prefix before ``/packages/climate-ref-<pkg>/`` in in-repo paths.
@@ -96,7 +102,8 @@ def _redact_provenance_fields(obj: object) -> bool:
 
     Walks the parsed bundle and, for each ``PROVENANCE`` / ``provenance`` block,
     overwrites the fields in :data:`_REDACTED_PROVENANCE_FIELDS` with their placeholders,
-    and the host fields in :data:`_REDACTED_PROVENANCE_PLATFORM_FIELDS` inside its nested ``platform``.
+    the host fields in :data:`_REDACTED_PROVENANCE_PLATFORM_FIELDS` inside its nested ``platform``,
+    and the fields in :data:`_REDACTED_PROVENANCE_CONDA_FIELDS` inside its nested ``conda``.
 
     Returns
     -------
@@ -111,6 +118,9 @@ def _redact_provenance_fields(obj: object) -> bool:
                 platform = value.get("platform")
                 if isinstance(platform, dict):
                     changed |= _redact_fields(platform, _REDACTED_PROVENANCE_PLATFORM_FIELDS)
+                conda = value.get("conda")
+                if isinstance(conda, dict):
+                    changed |= _redact_fields(conda, _REDACTED_PROVENANCE_CONDA_FIELDS)
             elif _redact_provenance_fields(value):
                 changed = True
     elif isinstance(obj, list):

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/regression/compare.py

@@ -21,13 +21,13 @@ class Tolerance:
     ----------
     rtol
         Relative tolerance — the allowed proportional difference between expected
-        and actual float values (default ``1e-6``).
+        and actual float values (default ``1e-5``).
     atol
         Absolute tolerance — the floor difference always permitted,
         regardless of magnitude (default ``1e-8``).
     """
 
-    rtol: float = 1e-6
+    rtol: float = 1e-5
     atol: float = 1e-8
 
 

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/source_types.py

@@ -30,6 +30,8 @@ class SourceDatasetType(enum.Enum):
     CMIP7 = "cmip7"
     obs4MIPs = "obs4mips"
     PMPClimatology = "pmp-climatology"
+    obs4REF = "obs4ref"
+    ESMValToolReference = "esmvaltool-reference"
 
     @classmethod
     @functools.lru_cache(maxsize=1)

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/src/climate_ref_core/testing.py

@@ -3,7 +3,7 @@ Test infrastructure for diagnostic testing.
 
 This module provides:
 - TestCase and TestDataSpecification for defining test scenarios
-- YAML serialization for dataset catalogs (with paths stored separately)
+- YAML serialization for dataset catalogs (with local paths stored separately, under the cache)
 - Utilities for CMEC bundle and series regression validation
 """
 
@@ -20,6 +20,7 @@ import yaml
 from attrs import field, frozen
 from loguru import logger
 
+from climate_ref_core.dataset_registry import resolve_cache_dir
 from climate_ref_core.datasets import (
     DatasetCollection,
     ExecutionDatasetCollection,
@@ -142,17 +143,25 @@ class TestCasePaths:
 
     Provides access to all paths within a test case directory:
     - catalog.yaml: Dataset metadata (tracked in git)
-    - catalog.paths.yaml: Local file paths (gitignored)
     - regression/: Regression outputs (tracked in git)
 
+    The local-paths sidecar (``catalog.paths.yaml``) is the exception: it lives under the
+    dataset cache rather than in the package tree. The paths it records are machine-specific
+    and point into the various caches (the dataset cache, the intake-esgf cache), so the
+    sidecar belongs with those caches rather than with a checkout. It is shared by every
+    checkout on the machine, and a fresh checkout cannot lose it.
+
     Can be constructed from:
     - A diagnostic + test case name (auto-resolves provider's test-data dir)
-    - An explicit test_data_dir + diagnostic slug + test case name
+    - An explicit test_data_dir + provider slug + diagnostic slug + test case name
     """
 
     root: Path
     """The test case directory (test_data_dir / diagnostic_slug / test_case_name)."""
 
+    provider_slug: str
+    """Slug of the provider owning the diagnostic, used to namespace the paths sidecar."""
+
     @classmethod
     def from_diagnostic(cls, diagnostic: Diagnostic, test_case: str) -> TestCasePaths | None:
         """
@@ -171,7 +180,10 @@ class TestCasePaths:
         test_data_dir = _get_provider_test_data_dir(diagnostic)
         if test_data_dir is None:
             return None
-        return cls(root=test_data_dir / diagnostic.slug / test_case)
+        return cls(
+            root=test_data_dir / diagnostic.slug / test_case,
+            provider_slug=diagnostic.provider.slug,
+        )
 
     @classmethod
     def from_test_data_dir(
@@ -179,6 +191,7 @@ class TestCasePaths:
         test_data_dir: Path,
         diagnostic_slug: str,
         test_case: str,
+        provider_slug: str,
     ) -> TestCasePaths:
         """
         Create from an explicit test data directory.
@@ -194,8 +207,10 @@ class TestCasePaths:
             The diagnostic slug
         test_case
             Test case name (e.g., 'default')
+        provider_slug
+            The provider slug, used to namespace the paths sidecar
         """
-        return cls(root=test_data_dir / diagnostic_slug / test_case)
+        return cls(root=test_data_dir / diagnostic_slug / test_case, provider_slug=provider_slug)
 
     @property
     def catalog(self) -> Path:
@@ -204,8 +219,20 @@ class TestCasePaths:
 
     @property
     def catalog_paths(self) -> Path:
-        """Path to catalog.paths.yaml (gitignored, contains local file paths)."""
-        return self.root / "catalog.paths.yaml"
+        """
+        Path to catalog.paths.yaml, under the dataset cache rather than the package tree.
+
+        The sidecar maps each dataset to its local file, so it is a property of the machine,
+        not of the checkout. Namespaced by provider because diagnostic slugs are only unique
+        within a provider.
+        """
+        return (
+            resolve_cache_dir("test-case-paths")
+            / self.provider_slug
+            / self.root.parent.name
+            / self.root.name
+            / "catalog.paths.yaml"
+        )
 
     @property
     def regression(self) -> Path:
@@ -298,12 +325,7 @@ def _get_provider_test_data_dir(diag: Diagnostic) -> Path | None:
     return test_data_dir
 
 
-def _get_paths_file(catalog_path: Path) -> Path:
-    """Get the paths file path for a catalog file."""
-    return catalog_path.with_suffix(".paths.yaml")
-
-
-def load_datasets_from_yaml(path: Path) -> ExecutionDatasetCollection:
+def load_datasets_from_yaml(path: Path, paths_file: Path) -> ExecutionDatasetCollection:
     """
     Load ExecutionDatasetCollection from a YAML file.
 
@@ -321,16 +343,21 @@ def load_datasets_from_yaml(path: Path) -> ExecutionDatasetCollection:
           # ... other metadata
     ```
 
-    Paths are loaded from a separate `.paths.yaml` file if it exists,
-    allowing the main catalog to be version-controlled while paths
-    remain user-specific. Multi-file datasets have multiple rows with
-    paths keyed by `{instance_id}::{filename}`.
+    Paths are loaded from ``paths_file`` if it exists, allowing the main catalog to be
+    version-controlled while paths remain machine-specific. Multi-file datasets have
+    multiple rows with paths keyed by `{instance_id}::{filename}`.
+
+    Parameters
+    ----------
+    path
+        Path to the catalog YAML file
+    paths_file
+        Path to the local-paths sidecar (see :attr:`TestCasePaths.catalog_paths`).
+        If it does not exist, the loaded datasets carry no ``path`` column.
     """
     with open(path) as f:
         data = yaml.safe_load(f)
 
-    # Load paths from separate file if it exists
-    paths_file = _get_paths_file(path)
     paths_map: dict[str, str] = {}
     if paths_file.exists():
         with open(paths_file) as f:
@@ -456,7 +483,8 @@ def _serialise_datasets(
     Returns a ``(data, paths_map)`` tuple: ``data`` is the catalog content (metadata plus
     per-source records with local paths stripped out), and ``paths_map`` maps
     ``{instance_id}::{filename}`` to each local file path. The two are written to
-    ``catalog.yaml`` and the gitignored ``catalog.paths.yaml`` respectively.
+    ``catalog.yaml`` (in the package tree) and ``catalog.paths.yaml`` (under the dataset
+    cache) respectively.
     """
     data: dict[str, Any] = {
         "_metadata": {"hash": datasets.hash},
@@ -496,7 +524,7 @@ def _serialise_datasets(
 
 
 def _write_paths_file(paths_file: Path, paths_map: dict[str, str]) -> None:
-    """Write the gitignored local-paths sidecar (``catalog.paths.yaml``)."""
+    """Write the local-paths sidecar (``catalog.paths.yaml``, under the dataset cache)."""
     paths_file.parent.mkdir(parents=True, exist_ok=True)
     with open(paths_file, "w") as f:
         yaml.dump(paths_map, f, default_flow_style=False, sort_keys=False)
@@ -505,14 +533,15 @@ def _write_paths_file(paths_file: Path, paths_map: dict[str, str]) -> None:
 def save_datasets_to_yaml(
     datasets: ExecutionDatasetCollection,
     path: Path,
+    paths_file: Path,
     *,
     force: bool = False,
 ) -> bool:
     """
     Save ExecutionDatasetCollection to a YAML file.
 
-    Paths are saved to a separate `.paths.yaml` file to allow the main
-    catalog to be version-controlled while paths remain user-specific.
+    Paths are saved to a separate sidecar file to allow the main catalog to be
+    version-controlled while paths remain machine-specific.
 
     Multi-file datasets (e.g., time-chunked data) are stored as multiple rows,
     one per file. Paths are keyed by `{instance_id}::{filename}` to support
@@ -521,11 +550,11 @@ def save_datasets_to_yaml(
     By default, the catalog is only written if the content has changed
     (detected via hash comparison). Use `force=True` to always write.
 
-    The gitignored `.paths.yaml` sidecar is (re)generated whenever it is **missing**, even
-    when the catalog content is unchanged: on a fresh checkout the version-controlled
-    `catalog.yaml` exists but the local paths file does not, and `run`/`mint` need it to
-    resolve inputs. In that case the catalog itself is left untouched (so a plain
-    `ref test-cases fetch` is enough — no `--force` required) and only the paths file is written.
+    The paths sidecar is (re)generated whenever it is **missing**, even when the catalog
+    content is unchanged: on a machine with a cold cache the version-controlled
+    `catalog.yaml` exists but the sidecar does not, and `run`/`mint` need it to resolve
+    inputs. In that case the catalog itself is left untouched (so a plain
+    `ref test-cases fetch` is enough, no `--force` required) and only the sidecar is written.
 
     Parameters
     ----------
@@ -533,6 +562,8 @@ def save_datasets_to_yaml(
         The datasets to save
     path
         Path to write the YAML file
+    paths_file
+        Path to write the local-paths sidecar (see :attr:`TestCasePaths.catalog_paths`)
     force
         If True, always write the catalog even if unchanged
 
@@ -543,11 +574,10 @@ def save_datasets_to_yaml(
         (the paths sidecar may still have been regenerated).
     """
     new_hash = datasets.hash
-    paths_file = _get_paths_file(path)
 
     if not force and get_catalog_hash(path) == new_hash:
-        # Catalog content is unchanged. Still regenerate the gitignored paths sidecar if it
-        # is missing (e.g. a fresh checkout) so run/mint can resolve inputs, but leave the
+        # Catalog content is unchanged. Still regenerate the paths sidecar if it is missing
+        # (e.g. a cold dataset cache) so run/mint can resolve inputs, but leave the
         # version-controlled catalog untouched to avoid spurious diffs.
         if paths_file.exists():
             logger.info(f"Catalog unchanged, skipping write: {path}")

{climate_ref_core-0.16.0 → climate_ref_core-0.16.2}/tests/unit/esgf/test_base.py

@@ -2,11 +2,14 @@
 
 from unittest.mock import MagicMock, patch
 
+import intake_esgf
 import pandas as pd
 import pytest
+from intake_esgf.exceptions import NoSearchResults
 
 from climate_ref_core.esgf import CMIP6Request, ESGFRequest
 from climate_ref_core.esgf.base import _deduplicate_datasets
+from climate_ref_core.exceptions import DatasetResolutionError
 
 
 class TestESGFRequestProtocol:
@@ -225,6 +228,31 @@ class TestIntakeESGFMixin:
 
         mock_cat.remove_ensembles.assert_called_once()
 
+    def test_fetch_datasets_enables_ceda_solr_index(self):
+        """
+        The CEDA Solr index must be enabled as a fallback while the ozone reference
+        C3S-GTO-ECV-9-0 is missing from the default ESGF2-US-1.5-Catalog index.
+        """
+        request = CMIP6Request(
+            slug="test",
+            facets={"source_id": "ACCESS-ESM1-5"},
+        )
+
+        mock_cat = MagicMock()
+        mock_cat.df = pd.DataFrame(
+            {
+                "key": ["ds1"],
+                "source_id": ["ACCESS-ESM1-5"],
+            }
+        )
+        mock_cat.to_path_dict.return_value = {"ds1": ["/path/to/file.nc"]}
+
+        intake_esgf.conf["solr_indices"]["esgf.ceda.ac.uk"] = False
+        with patch("climate_ref_core.esgf.base.ESGFCatalog", return_value=mock_cat):
+            request.fetch_datasets()
+
+        assert intake_esgf.conf["solr_indices"]["esgf.ceda.ac.uk"] is True
+
     def test_fetch_datasets_empty_result(self):
         """Test fetch_datasets raises error when no datasets found."""
         request = CMIP6Request(
@@ -255,6 +283,24 @@ class TestIntakeESGFMixin:
             with pytest.raises(ValueError, match="No datasets found"):
                 request.fetch_datasets()
 
+    def test_fetch_datasets_no_search_results(self):
+        """
+        Regression: a dataset that has been de-indexed from ESGF makes the search
+        raise NoSearchResults, which must surface as the per-test-case
+        DatasetResolutionError instead of crashing the whole prefetch.
+        """
+        request = CMIP6Request(
+            slug="test",
+            facets={"source_id": "C3S-GTO-ECV-9-0"},
+        )
+
+        mock_cat = MagicMock()
+        mock_cat.search.side_effect = NoSearchResults()
+
+        with patch("climate_ref_core.esgf.base.ESGFCatalog", return_value=mock_cat):
+            with pytest.raises(DatasetResolutionError, match="no results"):
+                request.fetch_datasets()
+
     def test_fetch_datasets_converts_tuples_to_lists(self):
         """Test that tuple facet values are converted to lists for intake-esgf compatibility."""
         request = CMIP6Request(