climate-ref-core 0.19.2__tar.gz → 0.20.0__tar.gz

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: climate-ref-core
-Version: 0.19.2
+Version: 0.20.0
 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
@@ -22,7 +22,7 @@ Requires-Dist: cattrs>=24.1
 Requires-Dist: dask[array]>=2024.10.0
 Requires-Dist: environs>=11
 Requires-Dist: fastprogress==1.0.5
-Requires-Dist: intake-esgf>=2025.7.16
+Requires-Dist: intake-esgf>=2026.9.28
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: pandas>=2.1.0

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "climate-ref-core"
-version = "0.19.2"
+version = "0.20.0"
 description = "Core library for the CMIP Rapid Evaluation Framework"
 readme = "README.md"
 authors = [
@@ -42,7 +42,7 @@ dependencies = [
     "setuptools<85",
 
     # ESGF data fetching
-    "intake-esgf>=2025.7.16",
+    "intake-esgf>=2026.9.28",
     "pyarrow>=17.0.0",
     "dask[array]>=2024.10.0",
 

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/constraints.py

@@ -691,3 +691,104 @@ class SelectFirstMember:
             first = min(members, key=_member_sort_key)
             keep.loc[subgroup.index[subgroup[self.member_facet] == first]] = True
         return group[keep]
+
+
+_RESOLUTION_KM_RE = re.compile(r"\s*([0-9.]+)\s*km\s*")
+
+
+@runtime_checkable
+class GridPreference(Protocol):
+    """
+    A rule for choosing one grid when a variable is published on several.
+
+    CMIP7 grids are described by the
+    [Essential Model Documentation](https://github.com/WCRP-CMIP/Essential-Model-Documentation),
+    which has a [grid viewer](https://emd.wcrp-cmip.org/docs/grid_viewer/horizontal/).
+    A native grid is likely the one that is not regular lat/lon.
+    """
+
+    def choose(self, grids: pd.DataFrame, data_catalog: pd.DataFrame) -> str:
+        """
+        Choose the grid to keep.
+
+        Parameters
+        ----------
+        grids
+            The candidate grids, one row per ``grid_label``.
+            Each row holds the facets of the first dataset on that grid.
+        data_catalog
+            The data catalog of datasets
+
+        Returns
+        -------
+        :
+            The ``grid_label`` of the chosen grid
+        """
+        ...
+
+
+@frozen
+class PreferNativeGrid:
+    """
+    Prefer the native grid, then the finest resolution.
+
+    The CMIP6 native grid ``gn`` comes first, then the finest ``nominal_resolution``.
+
+    CMIP7 grid labels carry no meaning, so for CMIP7 this picks the finest ``nominal_resolution``.
+    Resolutions that are missing or not given in km sort last,
+    and the grid label breaks any remaining tie.
+    """
+
+    def choose(self, grids: pd.DataFrame, data_catalog: pd.DataFrame) -> str:
+        """
+        Choose the native or finest grid.
+        """
+        resolutions = (
+            grids["nominal_resolution"]
+            if "nominal_resolution" in grids.columns
+            else pd.Series(None, index=grids.index)
+        )
+
+        def sort_key(row: int) -> tuple[bool, float, str]:
+            label = str(grids["grid_label"].iloc[row])
+            match = _RESOLUTION_KM_RE.fullmatch(str(resolutions.iloc[row]))
+            resolution = float(match.group(1)) if match else float("inf")
+            return (label != "gn", resolution, label)
+
+        return str(grids["grid_label"].iloc[min(range(len(grids)), key=sort_key)])
+
+
+@frozen
+class SelectSingleGrid:
+    """
+    Keep a single grid per variable within each group.
+
+    A model may publish one variable on several grids, such as its native grid and a regridded copy.
+    A group that spans realms cannot be split by ``grid_label``,
+    because CMIP7 labels each realm's grid separately, so this constraint drops the extra copies instead.
+
+    The ``preference`` decides which grid is kept (:class:`PreferNativeGrid` by default).
+    """
+
+    group_by: tuple[str, ...] = field(converter=_to_tuple)
+    """The facets defining each variable of a model, within which a single grid is kept."""
+
+    preference: GridPreference = field(factory=PreferNativeGrid)
+    """The rule that chooses which grid to keep."""
+
+    def apply(self, group: pd.DataFrame, data_catalog: pd.DataFrame) -> pd.DataFrame:
+        """
+        Keep only the preferred grid within each group.
+        """
+        if group.empty or "grid_label" not in group.columns:
+            return group
+
+        keep = pd.Series(False, index=group.index)
+        for _, subgroup in group.groupby(list(self.group_by), dropna=False):
+            grids = subgroup.dropna(subset=["grid_label"]).drop_duplicates("grid_label")
+            if len(grids) <= 1:
+                keep.loc[subgroup.index] = True
+                continue
+            preferred = self.preference.choose(grids, data_catalog)
+            keep.loc[subgroup.index[subgroup["grid_label"] == preferred]] = True
+        return group[keep]

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/esgf/__init__.py

@@ -8,10 +8,10 @@ This module provides classes for searching and fetching datasets from ESGF
 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.cmip7_converted import ConvertedCMIP7Request
 from climate_ref_core.esgf.fetcher import ESGFFetcher
 from climate_ref_core.esgf.obs4mips import Obs4MIPsRequest
 from climate_ref_core.esgf.registry import RegistryRequest
@@ -19,10 +19,10 @@ from climate_ref_core.esgf.registry import RegistryRequest
 __all__ = [
     "CMIP6Request",
     "CMIP7Request",
+    "ConvertedCMIP7Request",
     "ESGFFetcher",
     "ESGFRequest",
     "IntakeESGFMixin",
     "Obs4MIPsRequest",
     "RegistryRequest",
-    "enable_ceda_solr_index",
 ]

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/esgf/base.py

@@ -7,9 +7,8 @@ using the intake-esgf package.
 
 import copy
 from collections.abc import Mapping, Sequence
-from typing import Any, Protocol, Self, cast, runtime_checkable
+from typing import Any, ClassVar, Protocol, Self, cast, runtime_checkable
 
-import intake_esgf
 import pandas as pd
 from intake_esgf import ESGFCatalog
 from intake_esgf.exceptions import NoSearchResults
@@ -18,18 +17,6 @@ from loguru import logger
 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
 class ESGFRequest(Protocol):
     """
@@ -164,11 +151,7 @@ class IntakeESGFMixin:
     """
     Mixin that fetches datasets from ESGF using intake-esgf.
 
-    Subclasses must define:
-    - project: str
-    - facets: dict[str, str | tuple[str, ...]]
-    - remove_ensembles: bool
-    - time_span: tuple[str, str] | None
+    Subclasses must define ``source_type`` and ``project``.
 
     A request can also be pinned to the datasets an existing test case catalog records,
     see :meth:`pin_to_datasets`.
@@ -184,6 +167,35 @@ class IntakeESGFMixin:
     pinned_instance_ids: tuple[str, ...] | None = None
     """Ids of the datasets this request is pinned to."""
 
+    facet_renames: ClassVar[Mapping[str, str]] = {}
+    """REF facet names that the ESGF index spells differently."""
+
+    def __init__(
+        self,
+        slug: str,
+        facets: dict[str, Any],
+        remove_ensembles: bool = False,
+        time_span: tuple[str, str] | None = None,
+    ):
+        """
+        Initialize an ESGF request.
+
+        Parameters
+        ----------
+        slug
+            Unique identifier for this request
+        facets
+            ESGF search facets (e.g., source_id, variable_id, experiment_id)
+        remove_ensembles
+            If True, keep only one ensemble member per model
+        time_span
+            Optional time range filter (start, end) in YYYY-MM format
+        """
+        self.slug = slug
+        self.facets = facets
+        self.remove_ensembles = remove_ensembles
+        self.time_span = time_span
+
     def pin_to_datasets(self, datasets: Sequence[Mapping[str, Any]]) -> Self:
         """
         Return a copy of this request that only resolves the given datasets.
@@ -216,9 +228,20 @@ class IntakeESGFMixin:
         pinned.pinned_instance_ids = tuple(dict.fromkeys(cast(list[str], instance_ids)))
         return pinned
 
+    def _pinned_facets(self, instance_ids: tuple[str, ...]) -> dict[str, Any]:
+        """Search facets that find the pinned datasets."""
+        return {"instance_id": list(instance_ids)}
+
+    def _select_pinned(self, results: pd.DataFrame) -> pd.DataFrame:
+        """Narrow the search results for a pinned request down to the pinned datasets."""
+        return results
+
     def fetch_datasets(self) -> pd.DataFrame:
         """Fetch dataset metadata from ESGF."""
-        facets: dict[str, Any] = {"project": self.project, **self.facets}
+        facets: dict[str, Any] = {
+            "project": self.project,
+            **{self.facet_renames.get(key, key): value for key, value in self.facets.items()},
+        }
 
         if self.pinned_instance_ids:
             # Ask for the pinned datasets by id as the declared facets may now
@@ -227,7 +250,7 @@ class IntakeESGFMixin:
             logger.info(f"Resolving {len(self.pinned_instance_ids)} pinned datasets for {self.slug}")
             facets = {
                 "project": facets["project"],
-                "instance_id": list(self.pinned_instance_ids),
+                **self._pinned_facets(self.pinned_instance_ids),
                 # A pin holds even once a newer version of the dataset has been published
                 "latest": [True, False],
             }
@@ -244,8 +267,6 @@ 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]
             try:
@@ -258,10 +279,16 @@ class IntakeESGFMixin:
                 # Pinned ids already name one ensemble member each
                 cat.remove_ensembles()
 
-            path_dict = cat.to_path_dict(prefer_streaming=False, minimal_keys=False, quiet=True)
             if cat.df is None or cat.df.empty:
-                raise ValueError("No datasets found for the given ESGF request")
+                raise DatasetResolutionError(f"No datasets found for the ESGF request {self.slug}")
+            if self.pinned_instance_ids:
+                cat.df = self._select_pinned(cat.df)
+
+            path_dict = cat.to_path_dict(prefer_streaming=False, minimal_keys=False, quiet=True)
             merged_df = cat.df.merge(pd.Series(path_dict, name="files"), left_on="key", right_index=True)
+            if self.pinned_instance_ids and len(merged_df) < len(cat.df):
+                missing = sorted(set(cat.df["key"]) - set(path_dict))
+                raise DatasetResolutionError(f"Could not retrieve pinned datasets for {self.slug}: {missing}")
 
             if self.time_span:
                 merged_df["time_start"] = self.time_span[0]

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/esgf/cmip6.py

@@ -4,7 +4,7 @@ CMIP6 dataset request implementation.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from climate_ref_core.esgf.base import IntakeESGFMixin
 
@@ -83,38 +83,5 @@ class CMIP6Request(IntakeESGFMixin):
         "data_node",
     )
 
-    def __init__(
-        self,
-        slug: str,
-        facets: dict[str, Any],
-        remove_ensembles: bool = False,
-        time_span: tuple[str, str] | None = None,
-    ):
-        """
-        Initialize a CMIP6 request.
-
-        Parameters
-        ----------
-        slug
-            Unique identifier for this request
-        facets
-            ESGF search facets (e.g., source_id, variable_id, experiment_id)
-        remove_ensembles
-            If True, keep only one ensemble member per model
-        time_span
-            Optional time range filter (start, end) in YYYY-MM format
-        """
-        self.slug = slug
-        self.facets = facets
-        self.remove_ensembles = remove_ensembles
-        self.time_span = time_span
-
-        for key in self.cmip6_path_items:
-            if key not in self.available_facets:
-                raise ValueError(f"Path item {key!r} not in available facets")
-        for key in self.cmip6_filename_paths:
-            if key not in self.available_facets:
-                raise ValueError(f"Filename path {key!r} not in available facets")
-
     def __repr__(self) -> str:
         return f"CMIP6Request(slug={self.slug!r}, facets={self.facets!r})"

climate_ref_core-0.20.0/src/climate_ref_core/esgf/cmip7.py

@@ -0,0 +1,62 @@
+"""
+CMIP7 dataset request implementation.
+"""
+
+from collections.abc import Mapping
+from typing import Any, ClassVar
+
+import intake_esgf
+import pandas as pd
+from loguru import logger
+
+from climate_ref_core.esgf.base import IntakeESGFMixin
+from climate_ref_core.exceptions import DatasetResolutionError
+
+STAC_INDICES = ("discovery.east.esgf.io", "discovery.west.esgf.io")
+"""The ESGF indices that publish CMIP7 data."""
+
+
+def _esgf_id(instance_id: str) -> str:
+    """Spell a REF CMIP7 ``instance_id`` the way ESGF identifies the dataset."""
+    return f"MIP-DRS7.{instance_id}"
+
+
+class CMIP7Request(IntakeESGFMixin):
+    """
+    Represents a request for CMIP7 datasets published on ESGF.
+    """
+
+    source_type = "CMIP7"
+    project = "CMIP7"
+    facet_renames: ClassVar[Mapping[str, str]] = {"branding_suffix": "variable_branding_suffix"}
+
+    def _pinned_facets(self, instance_ids: tuple[str, ...]) -> dict[str, Any]:
+        # The STAC indices cannot be searched by id, only by the id without its version
+        base_ids, versions = zip(*(_esgf_id(instance_id).rsplit(".", 1) for instance_id in instance_ids))
+        return {"base_id": sorted(set(base_ids)), "version": sorted({v.removeprefix("v") for v in versions})}
+
+    def _select_pinned(self, results: pd.DataFrame) -> pd.DataFrame:
+        wanted = {_esgf_id(instance_id) for instance_id in self.pinned_instance_ids or ()}
+        found = results["id"].map(lambda ids: {str(i).split("|")[0] for i in ids} & wanted)
+
+        # intake-esgf keeps only the newest version it finds of each dataset
+        # TODO: fix this upstream in intake-esgf as ESGF has the information
+        missing = wanted - set().union(*found)
+        if missing:
+            raise DatasetResolutionError(
+                f"ESGF no longer resolves {len(missing)} pinned datasets for {self.slug}: {sorted(missing)}"
+            )
+        return results[found.map(bool)]
+
+    def fetch_datasets(self) -> pd.DataFrame:
+        """Fetch dataset metadata from ESGF, warning if no index that publishes CMIP7 is enabled."""
+        enabled = intake_esgf.conf["stac_indices"]
+
+        if not any(enabled.get(index) for index in STAC_INDICES):
+            logger.warning(
+                f"No CMIP7 index enabled in {intake_esgf.conf.filename}: enable {', '.join(STAC_INDICES)}"
+            )
+        return super().fetch_datasets()
+
+    def __repr__(self) -> str:
+        return f"CMIP7Request(slug={self.slug!r}, facets={self.facets!r})"

climate_ref_core-0.19.2/src/climate_ref_core/esgf/cmip7.py → climate_ref_core-0.20.0/src/climate_ref_core/esgf/cmip7_converted.py

@@ -1,8 +1,8 @@
 """
-CMIP7 dataset request implementation.
+CMIP7 test data fabricated from CMIP6 data.
 
-Since CMIP7 data is not yet available on ESGF, this module provides
-a request class that fetches CMIP6 data and converts it to CMIP7 format.
+:class:`ConvertedCMIP7Request` serves test cases whose models have not published CMIP7 data yet.
+It will be removed once every test case can use :class:`~climate_ref_core.esgf.CMIP7Request`.
 """
 
 from __future__ import annotations
@@ -293,12 +293,12 @@ def _convert_file_to_cmip7(
     return output_file
 
 
-class CMIP7Request:
+class ConvertedCMIP7Request:
     """
-    Represents a CMIP7 dataset request.
+    Represents a CMIP7 dataset request fabricated from CMIP6 data.
 
-    Since CMIP7 data is not yet available on ESGF, this class fetches
-    CMIP6 data and converts it to CMIP7 format using convert_cmip6_dataset().
+    This class fetches CMIP6 data and converts it to CMIP7 format using convert_cmip6_dataset().
+    Use :class:`CMIP7Request` for data that is published on ESGF as CMIP7.
 
     The facets use CMIP7 naming conventions (e.g., variant_label instead of member_id).
     """
@@ -368,11 +368,9 @@ class CMIP7Request:
         # Create corresponding CMIP6 facets
         self._cmip6_facets = self._convert_to_cmip6_facets(facets)
 
-    def pin_to_datasets(self, datasets: Sequence[Mapping[str, Any]]) -> CMIP7Request:
+    def pin_to_datasets(self, datasets: Sequence[Mapping[str, Any]]) -> ConvertedCMIP7Request:
         """
-        Return this request unchanged: CMIP7 requests are not pinned yet.
-
-        CMIP7 data cannot be fetched from ESGF at the moment.
+        Return this request unchanged: converted CMIP7 data has no ESGF ids to pin to.
 
         Parameters
         ----------
@@ -519,4 +517,4 @@ class CMIP7Request:
         return pd.DataFrame(converted_rows)
 
     def __repr__(self) -> str:
-        return f"CMIP7Request(slug={self.slug!r}, facets={self.facets!r})"
+        return f"ConvertedCMIP7Request(slug={self.slug!r}, facets={self.facets!r})"

climate_ref_core-0.20.0/src/climate_ref_core/esgf/obs4mips.py

@@ -0,0 +1,56 @@
+"""
+Obs4MIPs dataset request implementation.
+"""
+
+from __future__ import annotations
+
+import intake_esgf
+import pandas as pd
+
+from climate_ref_core.esgf.base import IntakeESGFMixin
+
+
+class Obs4MIPsRequest(IntakeESGFMixin):
+    """
+    Represents an Obs4MIPs dataset request.
+
+    These data are fetched from ESGF based on the provided facets.
+    """
+
+    source_type = "obs4MIPs"
+    project = "obs4MIPs"
+
+    obs4mips_path_items = (
+        "activity_id",
+        "institution_id",
+        "source_id",
+        "variable_id",
+        "grid_label",
+    )
+
+    obs4mips_filename_paths = (
+        "variable_id",
+        "source_id",
+        "grid_label",
+    )
+
+    avail_facets = (
+        "activity_id",
+        "institution_id",
+        "source_id",
+        "frequency",
+        "variable_id",
+        "grid_label",
+        "version",
+        "data_node",
+        "project",
+    )
+
+    def fetch_datasets(self) -> pd.DataFrame:
+        """Fetch dataset metadata from ESGF, also searching the CEDA Solr index."""
+        # C3S-GTO-ECV-9-0 (the ozone reference) is missing from the default index but CEDA still serves it
+        with intake_esgf.conf.set(indices={"esgf.ceda.ac.uk": True}):
+            return super().fetch_datasets()
+
+    def __repr__(self) -> str:
+        return f"Obs4MIPsRequest(slug={self.slug!r}, facets={self.facets!r})"

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/providers.py

@@ -25,7 +25,7 @@ from typing import Any
 
 import requests
 import yaml
-from attrs import evolve
+from attrs import evolve, frozen
 from loguru import logger
 
 from climate_ref_core.constraints import IgnoreFacets
@@ -57,6 +57,19 @@ def _slugify(value: str) -> str:
     return value.lower().replace(" ", "-")
 
 
+@frozen
+class DataIngestRequest:
+    """
+    A directory of fetched provider data that the application should ingest into its database.
+    """
+
+    source_type: SourceDatasetType
+    """Source type whose dataset adapter parses the files"""
+
+    path: Path
+    """Directory containing the files to ingest"""
+
+
 class DiagnosticProvider:
     """
     The interface for registering and running diagnostics.
@@ -203,15 +216,16 @@ class DiagnosticProvider:
         self,
         config: Any,
         *,
-        db: Any = None,
         skip_env: bool = False,
         skip_data: bool = False,
     ) -> None:
         """
         Perform all setup required before offline execution.
 
-        This calls setup_environment, fetch_data, and ingest_data in the correct order.
+        This calls setup_environment and fetch_data in the correct order.
         Override individual hooks for fine-grained control.
+        Ingesting the fetched data is left to the application,
+        which reads what to ingest from `data_to_ingest`.
 
         This method MUST be idempotent - safe to call multiple times.
 
@@ -219,11 +233,6 @@ class DiagnosticProvider:
         ----------
         config
             The application configuration
-        db
-            Optional database instance for data ingestion.
-
-            If None, ingestion is skipped. This allows providers to be set up without the full
-            climate-ref package (e.g., for environment setup or data fetching only).
         skip_env
             If True, skip environment setup (e.g., conda)
         skip_data
@@ -233,8 +242,6 @@ class DiagnosticProvider:
             self.setup_environment(config)
         if not skip_data:
             self.fetch_data(config)
-            if db is not None:
-                self.ingest_data(config, db)
 
     def setup_environment(self, config: Any) -> None:
         """
@@ -276,34 +283,28 @@ class DiagnosticProvider:
         """
         pass
 
-    def ingest_data(self, config: Any, db: Any) -> None:
+    def data_to_ingest(self, config: Any) -> list[DataIngestRequest]:
         """
-        Ingest fetched data into the database.
+        Describe the fetched data that needs ingesting into the database.
 
-        This is called after fetch_data to register any provider-specific
-        datasets in the database. For example, PMP climatology data needs
-        to be ingested so it can be used by diagnostics.
+        `ref providers setup` ingests each request after fetch_data,
+        using `climate_ref.datasets.ingest_provider_data`,
+        so the solver can find provider-specific datasets such as the PMP climatologies.
 
-        Default implementation does nothing. Override in subclasses
-        that have data to ingest.
-
-        This method MUST be idempotent.
-
-        Note: This method is only called when a database instance is provided
-        to setup(). The database and ingestion utilities are part of the
-        climate-ref package, not climate-ref-core. Provider implementations
-        should handle ImportError gracefully if they need to import from
-        climate-ref, allowing the provider to work standalone without
-        the full climate-ref package installed.
+        Default implementation returns no requests.
+        Override in subclasses that have data to ingest.
 
         Parameters
         ----------
         config
             The application configuration
-        db
-            The database instance (from climate-ref package)
+
+        Returns
+        -------
+        :
+            The directories to ingest
         """
-        pass
+        return []
 
     def validate_setup(self, config: Any) -> bool:
         """

{climate_ref_core-0.19.2 → climate_ref_core-0.20.0}/src/climate_ref_core/source_types.py

@@ -33,6 +33,11 @@ class SourceDatasetType(enum.Enum):
     obs4REF = "obs4ref"
     ESMValToolReference = "esmvaltool-reference"
 
+    @property
+    def is_model_output(self) -> bool:
+        """Whether the dataset holds model simulation output rather than observations."""
+        return self in (SourceDatasetType.CMIP6, SourceDatasetType.CMIP7)
+
     @classmethod
     @functools.lru_cache(maxsize=1)
     def ordered(