climate-ref 0.5.0__py3-none-any.whl

climate_ref/solver.py

@@ -0,0 +1,395 @@
+"""
+Solver to determine which diagnostics need to be calculated
+
+This module provides a solver to determine which diagnostics need to be calculated.
+"""
+
+import itertools
+import pathlib
+import typing
+from collections.abc import Sequence
+
+import pandas as pd
+from attrs import define, frozen
+from loguru import logger
+
+from climate_ref.config import Config
+from climate_ref.database import Database
+from climate_ref.datasets import get_dataset_adapter
+from climate_ref.datasets.cmip6 import CMIP6DatasetAdapter
+from climate_ref.datasets.obs4mips import Obs4MIPsDatasetAdapter
+from climate_ref.datasets.pmp_climatology import PMPClimatologyDatasetAdapter
+from climate_ref.models import Diagnostic as DiagnosticModel
+from climate_ref.models import ExecutionGroup
+from climate_ref.models import Provider as ProviderModel
+from climate_ref.models.execution import Execution
+from climate_ref.provider_registry import ProviderRegistry
+from climate_ref_core.constraints import apply_constraint
+from climate_ref_core.datasets import DatasetCollection, ExecutionDatasetCollection, SourceDatasetType
+from climate_ref_core.diagnostics import DataRequirement, Diagnostic, ExecutionDefinition
+from climate_ref_core.exceptions import InvalidDiagnosticException
+from climate_ref_core.providers import DiagnosticProvider
+
+SelectorKey = tuple[tuple[str, str], ...]
+"""
+Type describing the key used to identify a group of datasets
+
+This is a tuple of tuples, where each inner tuple contains a metadata and dimension value
+that was used to group the datasets together.
+
+This SelectorKey type must be hashable, as it is used as a key in a dictionary.
+"""
+
+
+@frozen
+class DiagnosticExecution:
+    """
+    Class to hold information about the execution of a diagnostic
+
+    This is a temporary class used by the solver to hold information about an execution that might
+    be required.
+    """
+
+    provider: DiagnosticProvider
+    diagnostic: Diagnostic
+    datasets: ExecutionDatasetCollection
+
+    @property
+    def dataset_key(self) -> str:
+        """
+        Key used to uniquely identify the execution group
+
+        This key is unique to an execution group and uses unique set of metadata (selectors)
+         that defines the group.
+        This key is combines the selectors from each source dataset type into a single key
+        and should be stable if new datasets are added or removed.
+        """
+        key_values = []
+
+        for source_type in SourceDatasetType.ordered():
+            # Ensure the selector is sorted using the dimension names
+            # This will ensure a stable key even if the groupby order changes
+            if source_type not in self.datasets:
+                continue
+
+            selector = self.datasets[source_type].selector
+            selector_sorted = sorted(selector, key=lambda item: item[0])
+
+            source_key = f"{source_type.value}_" + "_".join(value for _, value in selector_sorted)
+            key_values.append(source_key)
+
+        return "__".join(key_values)
+
+    @property
+    def selectors(self) -> dict[str, SelectorKey]:
+        """
+        Collection of selectors used to identify the datasets
+
+        These are the key, value pairs that were selected during the initial group-by,
+        for each data requirement.
+        """
+        # The "value" of SourceType is used here so this can be stored in the db
+        s = {}
+        for source_type in SourceDatasetType.ordered():
+            if source_type not in self.datasets:
+                continue
+            s[source_type.value] = self.datasets[source_type].selector
+        return s
+
+    def build_execution_definition(self, output_root: pathlib.Path) -> ExecutionDefinition:
+        """
+        Build the execution definition for the current diagnostic execution
+        """
+        # Ensure that the output root is always an absolute path
+        output_root = output_root.resolve()
+
+        # This is the desired path relative to the output directory
+        fragment = pathlib.Path() / self.provider.slug / self.diagnostic.slug / self.datasets.hash
+
+        return ExecutionDefinition(
+            root_directory=output_root,
+            output_directory=output_root / fragment,
+            key=self.dataset_key,
+            datasets=self.datasets,
+        )
+
+
+def extract_covered_datasets(
+    data_catalog: pd.DataFrame, requirement: DataRequirement
+) -> dict[SelectorKey, pd.DataFrame]:
+    """
+    Determine the different diagnostic executions that should be performed with the current data catalog
+    """
+    if len(data_catalog) == 0:
+        logger.error(f"No datasets found in the data catalog: {requirement.source_type.value}")
+        return {}
+
+    subset = requirement.apply_filters(data_catalog)
+
+    if len(subset) == 0:
+        logger.debug(f"No datasets found for requirement {requirement}")
+        return {}
+
+    if requirement.group_by is None:
+        # Use a single group
+        groups = [((), subset)]
+    else:
+        groups = list(subset.groupby(list(requirement.group_by)))
+
+    results = {}
+
+    for name, group in groups:
+        if requirement.group_by is None:
+            assert len(groups) == 1  # noqa: S101
+            group_keys: SelectorKey = ()
+        else:
+            group_keys = tuple(zip(requirement.group_by, name))
+        constrained_group = _process_group_constraints(data_catalog, group, requirement)
+
+        if constrained_group is not None:
+            results[group_keys] = constrained_group
+
+    return results
+
+
+def _process_group_constraints(
+    data_catalog: pd.DataFrame, group: pd.DataFrame, requirement: DataRequirement
+) -> pd.DataFrame | None:
+    for constraint in requirement.constraints or []:
+        constrained_group = apply_constraint(group, constraint, data_catalog)
+        if constrained_group is None:
+            return None
+
+        group = constrained_group
+    return group
+
+
+def solve_executions(
+    data_catalog: dict[SourceDatasetType, pd.DataFrame], diagnostic: Diagnostic, provider: DiagnosticProvider
+) -> typing.Generator["DiagnosticExecution", None, None]:
+    """
+    Calculate the diagnostic executions that need to be performed for a given diagnostic
+
+    Parameters
+    ----------
+    data_catalog
+        Data catalogs for each source dataset type
+    diagnostic
+        Diagnostic of interest
+    provider
+        Provider of the diagnostic
+
+    Returns
+    -------
+    :
+        A generator that yields the diagnostic executions that need to be performed
+
+    """
+    if not diagnostic.data_requirements:
+        raise ValueError(f"Diagnostic {diagnostic.slug!r} has no data requirements")
+
+    first_item = next(iter(diagnostic.data_requirements))
+
+    if isinstance(first_item, DataRequirement):
+        # We have a single collection of data requirements
+        yield from _solve_from_data_requirements(
+            data_catalog,
+            diagnostic,
+            typing.cast(Sequence[DataRequirement], diagnostic.data_requirements),
+            provider,
+        )
+    elif isinstance(first_item, Sequence):
+        # We have a sequence of collections of data requirements
+        for requirement_collection in diagnostic.data_requirements:
+            if not isinstance(requirement_collection, Sequence):
+                raise TypeError(f"Expected a sequence of DataRequirement, got {type(requirement_collection)}")
+            yield from _solve_from_data_requirements(
+                data_catalog, diagnostic, requirement_collection, provider
+            )
+    else:
+        raise TypeError(f"Expected a DataRequirement, got {type(first_item)}")
+
+
+def _solve_from_data_requirements(
+    data_catalog: dict[SourceDatasetType, pd.DataFrame],
+    diagnostic: Diagnostic,
+    data_requirements: Sequence[DataRequirement],
+    provider: DiagnosticProvider,
+) -> typing.Generator["DiagnosticExecution", None, None]:
+    # Collect up the different data groups that can be used to calculate the diagnostic
+    dataset_groups = {}
+
+    for requirement in data_requirements:
+        if not isinstance(requirement, DataRequirement):
+            raise TypeError(f"Expected a DataRequirement, got {type(requirement)}")
+        if requirement.source_type not in data_catalog:
+            raise InvalidDiagnosticException(
+                diagnostic, f"No data catalog for source type {requirement.source_type}"
+            )
+
+        dataset_groups[requirement.source_type] = extract_covered_datasets(
+            data_catalog[requirement.source_type], requirement
+        )
+
+    # Calculate the product across each of the source types
+    for items in itertools.product(*dataset_groups.values()):
+        yield DiagnosticExecution(
+            provider=provider,
+            diagnostic=diagnostic,
+            datasets=ExecutionDatasetCollection(
+                {
+                    key: DatasetCollection(
+                        datasets=dataset_groups[key][dataset_group_key],
+                        slug_column=get_dataset_adapter(key.value).slug_column,
+                        selector=dataset_group_key,
+                    )
+                    for key, dataset_group_key in zip(dataset_groups.keys(), items)
+                }
+            ),
+        )
+
+
+@define
+class ExecutionSolver:
+    """
+    A solver to determine which executions need to be calculated.
+    """
+
+    provider_registry: ProviderRegistry
+    data_catalog: dict[SourceDatasetType, pd.DataFrame]
+
+    @staticmethod
+    def build_from_db(config: Config, db: Database) -> "ExecutionSolver":
+        """
+        Initialise the solver using information from the database
+
+        Parameters
+        ----------
+        db
+            Database instance
+
+        Returns
+        -------
+        :
+            A new ExecutionSolver instance
+        """
+        return ExecutionSolver(
+            provider_registry=ProviderRegistry.build_from_config(config, db),
+            data_catalog={
+                SourceDatasetType.CMIP6: CMIP6DatasetAdapter().load_catalog(db),
+                SourceDatasetType.obs4MIPs: Obs4MIPsDatasetAdapter().load_catalog(db),
+                SourceDatasetType.PMPClimatology: PMPClimatologyDatasetAdapter().load_catalog(db),
+            },
+        )
+
+    def solve(self) -> typing.Generator[DiagnosticExecution, None, None]:
+        """
+        Solve which executions need to be calculated for a dataset
+
+        The solving scheme is iterative,
+        for each iteration we find all diagnostics that can be solved and calculate them.
+        After each iteration we check if there are any more diagnostics to solve.
+
+        Yields
+        ------
+        DiagnosticExecution
+            A class containing the information related to the execution of a diagnostic
+        """
+        for provider in self.provider_registry.providers:
+            for diagnostic in provider.diagnostics():
+                yield from solve_executions(self.data_catalog, diagnostic, provider)
+
+
+def solve_required_executions(
+    db: Database,
+    dry_run: bool = False,
+    solver: ExecutionSolver | None = None,
+    config: Config | None = None,
+    timeout: int = 60,
+) -> None:
+    """
+    Solve for executions that require recalculation
+
+    This may trigger a number of additional calculations depending on what data has been ingested
+    since the last solve.
+
+    Raises
+    ------
+    TimeoutError
+        If the execution isn't completed within the specified timeout
+    """
+    if config is None:
+        config = Config.default()
+    if solver is None:
+        solver = ExecutionSolver.build_from_db(config, db)
+
+    logger.info("Solving for diagnostics that require recalculation...")
+
+    executor = config.executor.build(config, db)
+
+    for potential_execution in solver.solve():
+        # The diagnostic output is first written to the scratch directory
+        definition = potential_execution.build_execution_definition(output_root=config.paths.scratch)
+
+        logger.debug(
+            f"Identified candidate execution {definition.key} "
+            f"for {potential_execution.diagnostic.full_slug()}"
+        )
+
+        if dry_run:
+            continue
+
+        # Use a transaction to make sure that the models
+        # are created correctly before potentially executing out of process
+        with db.session.begin(nested=True):
+            diagnostic = (
+                db.session.query(DiagnosticModel)
+                .join(DiagnosticModel.provider)
+                .filter(
+                    ProviderModel.slug == potential_execution.provider.slug,
+                    ProviderModel.version == potential_execution.provider.version,
+                    DiagnosticModel.slug == potential_execution.diagnostic.slug,
+                )
+                .one()
+            )
+            execution_group, created = db.get_or_create(
+                ExecutionGroup,
+                key=definition.key,
+                diagnostic_id=diagnostic.id,
+                defaults={
+                    "selectors": potential_execution.selectors,
+                    "dirty": True,
+                },
+            )
+
+            if created:
+                logger.info(
+                    f"Created new execution group: "
+                    f"{definition.key!r}  for {potential_execution.diagnostic.full_slug()}"
+                )
+                db.session.flush()
+
+            if execution_group.should_run(definition.datasets.hash):
+                logger.info(
+                    f"Running new execution for execution group: "
+                    f"{definition.key!r} for {potential_execution.diagnostic.full_slug()}"
+                )
+                execution = Execution(
+                    execution_group=execution_group,
+                    dataset_hash=definition.datasets.hash,
+                    output_fragment=str(definition.output_fragment()),
+                )
+                db.session.add(execution)
+                db.session.flush()
+
+                # Add links to the datasets used in the execution
+                execution.register_datasets(db, definition.datasets)
+
+                executor.run(
+                    provider=potential_execution.provider,
+                    diagnostic=potential_execution.diagnostic,
+                    definition=definition,
+                    execution=execution,
+                )
+    if timeout > 0:
+        executor.join(timeout=timeout)

climate_ref/testing.py

@@ -0,0 +1,109 @@
+"""
+Testing utilities
+"""
+
+import shutil
+from pathlib import Path
+
+from loguru import logger
+
+from climate_ref.config import Config
+from climate_ref.database import Database
+from climate_ref.executor import handle_execution_result
+from climate_ref.models import Execution
+from climate_ref_core.dataset_registry import dataset_registry_manager, fetch_all_files
+from climate_ref_core.diagnostics import Diagnostic, ExecutionResult
+from climate_ref_core.pycmec.metric import CMECMetric
+from climate_ref_core.pycmec.output import CMECOutput
+
+
+def _determine_test_directory() -> Path | None:
+    expected = Path(__file__).parents[4] / "tests" / "test-data"
+
+    if not expected.exists():  # pragma: no cover
+        return None
+    return expected
+
+
+TEST_DATA_DIR = _determine_test_directory()
+SAMPLE_DATA_VERSION = "v0.5.0"
+
+
+def fetch_sample_data(force_cleanup: bool = False, symlink: bool = False) -> None:
+    """
+    Fetch the sample data for the given version.
+
+    The sample data is produced in the [Climate-REF/ref-sample-data](https://github.com/Climate-REF/ref-sample-data)
+    repository.
+    This repository contains decimated versions of key datasets used by the diagnostics packages.
+    Decimating these data greatly reduces the data volumes needed to run the test-suite.
+
+    Parameters
+    ----------
+    force_cleanup
+        If True, remove any existing files
+    symlink
+        If True, symlink in the data otherwise copy the files
+
+        The symlink approach is faster, but will fail when running with a non-local executor
+        because the symlinks can't be followed.
+    """
+
+    if TEST_DATA_DIR is None:  # pragma: no cover
+        logger.warning("Test data directory not found, skipping sample data fetch")
+        return
+
+    sample_data_registry = dataset_registry_manager["sample-data"]
+
+    output_dir = TEST_DATA_DIR / "sample-data"
+    version_file = output_dir / "version.txt"
+    existing_version = None
+
+    if output_dir.exists():  # pragma: no branch
+        if version_file.exists():  # pragma: no branch
+            with open(version_file) as fh:
+                existing_version = fh.read().strip()
+
+        if force_cleanup or existing_version != SAMPLE_DATA_VERSION:  # pragma: no branch
+            logger.warning("Removing existing sample data")
+            shutil.rmtree(output_dir)
+
+    fetch_all_files(sample_data_registry, "sample", output_dir, symlink)
+
+    # Write out the current sample data version to the copying as complete
+    with open(output_dir / "version.txt", "w") as fh:
+        fh.write(SAMPLE_DATA_VERSION)
+
+
+def validate_result(diagnostic: Diagnostic, config: Config, result: ExecutionResult) -> None:
+    """
+    Asserts the correctness of the result of a diagnostic execution
+
+    This should only be used by the test suite as it will create a fake
+    database entry for the diagnostic execution result.
+    """
+    # Add a fake item in the Database
+    database = Database.from_config(config)
+    execution = Execution(
+        execution_group_id=1,
+        dataset_hash=result.definition.datasets.hash,
+        output_fragment=str(result.definition.output_fragment()),
+    )
+    database.session.add(execution)
+    database.session.flush()
+
+    assert result.successful
+
+    # Validate bundles
+    metric_bundle = CMECMetric.load_from_json(result.to_output_path(result.metric_bundle_filename))
+    assert diagnostic.facets == tuple(metric_bundle.DIMENSIONS.root["json_structure"]), (
+        metric_bundle.DIMENSIONS.root["json_structure"]
+    )
+    CMECOutput.load_from_json(result.to_output_path(result.output_bundle_filename))
+
+    # Create a fake log file if one doesn't exist
+    if not result.to_output_path("out.log").exists():
+        result.to_output_path("out.log").touch()
+
+    # This checks if the bundles are valid
+    handle_execution_result(config, database=database, execution=execution, result=result)

climate_ref-0.5.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: climate-ref
+Version: 0.5.0
+Summary: Application which runs 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: Apache-2.0
+License-File: LICENCE
+License-File: NOTICE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: alembic>=1.13.3
+Requires-Dist: attrs>=24.2.0
+Requires-Dist: cattrs>=24.1.2
+Requires-Dist: climate-ref-core
+Requires-Dist: ecgtools>=2024.7.31
+Requires-Dist: environs>=11.0.0
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: platformdirs>=4.3.6
+Requires-Dist: setuptools>=75.8.0
+Requires-Dist: sqlalchemy>=2.0.36
+Requires-Dist: tomlkit>=0.13.2
+Requires-Dist: typer>=0.12.5
+Provides-Extra: celery
+Requires-Dist: climate-ref-celery>=0.5.0; extra == 'celery'
+Provides-Extra: metrics
+Requires-Dist: climate-ref-esmvaltool>=0.5.0; extra == 'metrics'
+Requires-Dist: climate-ref-ilamb>=0.5.0; extra == 'metrics'
+Requires-Dist: climate-ref-pmp>=0.5.0; extra == 'metrics'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.2; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# Climate REF (Rapid Evaluation Framework)
+
+[![PyPI version](https://badge.fury.io/py/climate-ref.svg)](https://badge.fury.io/py/climate-ref)
+[![Documentation Status](https://readthedocs.org/projects/climate-ref/badge/?version=latest)](https://climate-ref.readthedocs.io/en/latest/?badge=latest)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
+
+**Status**: This project is in active development. We expect to be ready for beta releases in Q2 2025.
+
+The Rapid Evaluation Framework (REF) is a set of Python packages that provide the ability to manage the execution of calculations against climate datasets.
+The aim is to be able to evaluate climate data against a set of reference data in near-real time as datasets are published,
+and to update any produced data and figures as new datasets become available.
+This is somewhat analogous to a CI/CD pipeline for climate data.
+
+## Installation
+
+```bash
+pip install climate-ref
+```
+
+If you want to use the diagnostic providers for the Assessment Fast Track, you can install them with:
+
+```bash
+pip install climate-ref[metrics]
+```
+
+## Quick Start
+
+```bash
+# Ingest some observation datasets
+ref datasets fetch-data --registry obs4ref --output-dir datasets/obs4ref
+ref datasets fetch-data --registry sample-data --output-dir datasets/sample-data
+
+# Run metrics against your climate data
+ref solve
+```
+
+## Features
+
+- Real-time evaluation of climate datasets
+- Support for multiple metrics providers (PMP, ILAMB, ESMValTool)
+- Distributed processing capabilities
+- Extensible architecture for adding new metrics providers
+- Command-line interface for easy interaction
+
+## Documentation
+
+For detailed documentation, please visit [https://climate-ref.readthedocs.io/](https://climate-ref.readthedocs.io/)
+
+## Contributing
+
+REF is a community project, and we welcome contributions from anyone. Please see our [Contributing Guide](https://climate-ref.readthedocs.io/en/latest/contributing/) for more information.
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

climate_ref-0.5.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+climate_ref/__init__.py,sha256=OJl5EnjLyEoCQpa0zQ8edV8EcU2YxBJ0xjermIlm9Bw,820
+climate_ref/_config_helpers.py,sha256=-atI5FX7SukhLE_jz_rL-EHQ7s0YYqKu3dSFYWxSyMU,6632
+climate_ref/alembic.ini,sha256=WRvbwSIFuZ7hWNMnR2-yHPJAwYUnwhvRYBzkJhtpGdg,3535
+climate_ref/config.py,sha256=QW1HOLajC2Gc5xZnrGQ8YLAver3BAlVBrfl1kVd_IyM,15072
+climate_ref/constants.py,sha256=rFk3XxNuP0lkzTvUneIhNLq16uadXsT45aUFIlSiBmg,111
+climate_ref/database.py,sha256=RCffNHbJcxxukN6PIOXBTW9TALE2rRsxU0chJHxyNK4,7257
+climate_ref/provider_registry.py,sha256=P35H4VFcsxJ8-Ly4Czwi_gelDU_nF5RiqSC-iBcx_Ws,4116
+climate_ref/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+climate_ref/solver.py,sha256=Hpb_3g-hYWopuBYyqaEtOgfuLOHfZpWbwP1rco802uE,14310
+climate_ref/testing.py,sha256=rUdtU8a4p2OV35IO87veW0mEB9C4Bqwe7BBQU6BILhs,3889
+climate_ref/cli/__init__.py,sha256=RSzaFkgwn1qWRBVbWlDKtNrIxLvQ2T7IWDBIqptpjjU,3658
+climate_ref/cli/_utils.py,sha256=6bIb8zEVvzXyKpv8MG58T-T2L2jH-G8WNrOOGpz3uCw,1918
+climate_ref/cli/config.py,sha256=8I6CLdqKgTu6yaASy-qG0T839Fc0lDZtLSZ6YCc4wOY,520
+climate_ref/cli/datasets.py,sha256=SLl88S3BxKPRbHy9OJ1ymhMnxDmkadFO_BZTIeLR0k8,7367
+climate_ref/cli/executions.py,sha256=6cnMxPK4ZydscUw_Mk9RMISNjP2Yr98BgsOsei8fQ7w,6799
+climate_ref/cli/providers.py,sha256=XVZQsZoEqiCBvgSmp6cNf0mCTxeq_Ycoc6DwVxWDYKg,2521
+climate_ref/cli/solve.py,sha256=D6rAivfm_yl1TTey_zc4KKwZ96LGGF8N1wHjcJ_0XpE,703
+climate_ref/dataset_registry/obs4ref_reference.txt,sha256=1NodZd3tOS9Z1Afpb_Oq4obp4OGAFDSAwEl3FssPwAQ,251
+climate_ref/dataset_registry/sample_data.txt,sha256=aKl9tfO4vknZ5X2mmdyxKOv-nyWhkPDXnpDoNLLTzE8,11892
+climate_ref/datasets/__init__.py,sha256=PV3u5ZmhyfcHbKqySgwVA8m4-naZgxzydLXSBqdTGLM,1171
+climate_ref/datasets/base.py,sha256=XplxCu4bfFmNHp2q8tHT26lB0RHv5swK0QqfUmuMO-c,8154
+climate_ref/datasets/cmip6.py,sha256=Dhq97ow8OmTshDCaL7vfrwn83Nfi6SY8uxJHeY4ZDHk,6083
+climate_ref/datasets/obs4mips.py,sha256=PQhI3QKlYA9L2d_MpnlcVrUn4irMG7Iu-II8l1ncjUs,7032
+climate_ref/datasets/pmp_climatology.py,sha256=goHDc_3B2Wdiy_hmpERNvWDdDYZACPOyFDt3Du6nGc0,534
+climate_ref/datasets/utils.py,sha256=iLJO7h4G3DWsRe9hIC4qkIyi5_zIW1ZMw-FDASLujtM,359
+climate_ref/executor/__init__.py,sha256=vUkE5Izfietvc57gA8LTdaD5IErKVebcE6qO7M7sCRo,9286
+climate_ref/executor/local.py,sha256=3icom02FCHiN0tIpsXR9tvn8-cQrUyoY-LlbHapbTx4,2920
+climate_ref/migrations/README,sha256=xM5osYbyEbEFA2eh5kwary_oh-5VFWtDubA-vgWwvlE,935
+climate_ref/migrations/env.py,sha256=b8om-LvFhVo_2BgaRsR8LcPQ-YcevjWikaWE6uhScAs,4213
+climate_ref/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+climate_ref/migrations/versions/2025-05-02T1418_341a4aa2551e_regenerate.py,sha256=349kbd58NdFHqqUAPDX1kR9RUOcxT2zXh9v9yg9-Je8,15533
+climate_ref/models/__init__.py,sha256=dFyqfhTffZz4m06xD4SyvRL9kIBRyVYetHwOxFGy4VM,713
+climate_ref/models/base.py,sha256=cMjNpGNU7pxRi9A5KXEmQIA9pvQDwqGCwo539yndpGY,1199
+climate_ref/models/dataset.py,sha256=Rpwrx0HqOJBHs4Sb4n6B0In__Uo0PqXSZKvZR-juGCg,7491
+climate_ref/models/diagnostic.py,sha256=YB6xzbEXdpz2j-Ddf19RV8mAiWBrkmtRmiAEUV3tl4Q,1762
+climate_ref/models/execution.py,sha256=lRCpaKLSR7rZbuoL94GW76tm9wLMsSDoIOA7bIa6xgY,9848
+climate_ref/models/metric_value.py,sha256=Sfjem65ih9g6WDpjGsiOphSjhYQ1ZAYUPZmsKyb_psU,6452
+climate_ref/models/provider.py,sha256=RAE2qAAxwObu-72CdK4kt5ACMmKYEn07WJm7DU9hF28,990
+climate_ref-0.5.0.dist-info/METADATA,sha256=pTjBsQveKvV8KGgvD9fy8LoxQ5CS-1ruBoFM4ReeLvY,4028
+climate_ref-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+climate_ref-0.5.0.dist-info/entry_points.txt,sha256=IaggEJlDIhoYWXdXJafacWbWtCcoEqUKceP1qD7_7vU,44
+climate_ref-0.5.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+climate_ref-0.5.0.dist-info/licenses/NOTICE,sha256=4qTlax9aX2-mswYJuVrLqJ9jK1IkN5kSBqfVvYLF3Ws,128
+climate_ref-0.5.0.dist-info/RECORD,,

climate_ref-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

climate_ref-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ref = climate_ref.cli:app