climate-ref 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

climate_ref/executor/__init__.py

@@ -9,8 +9,9 @@ The simplest executor is the `LocalExecutor`, which runs the diagnostic in the s
 This is useful for local testing and debugging.
 """
 
+from .hpc import HPCExecutor
 from .local import LocalExecutor
 from .result_handling import handle_execution_result
 from .synchronous import SynchronousExecutor
 
-__all__ = ["LocalExecutor", "SynchronousExecutor", "handle_execution_result"]
+__all__ = ["HPCExecutor", "LocalExecutor", "SynchronousExecutor", "handle_execution_result"]

climate_ref/executor/hpc.py

@@ -0,0 +1,308 @@
+"""
+HPC-based Executor to use job schedulers.
+
+If you want to
+- run REF under the HPC workflows
+- run REF in multiple nodes
+
+"""
+
+import os
+import time
+from typing import Any, cast
+
+import parsl
+from loguru import logger
+from parsl import python_app
+from parsl.config import Config as ParslConfig
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SrunLauncher
+from parsl.providers import SlurmProvider
+from tqdm import tqdm
+
+from climate_ref.config import Config
+from climate_ref.database import Database
+from climate_ref.models import Execution
+from climate_ref.slurm import HAS_REAL_SLURM, SlurmChecker
+from climate_ref_core.diagnostics import ExecutionDefinition, ExecutionResult
+from climate_ref_core.exceptions import DiagnosticError, ExecutionError
+from climate_ref_core.executor import execute_locally
+
+from .local import ExecutionFuture, process_result
+
+
+@python_app
+def _process_run(definition: ExecutionDefinition, log_level: str) -> ExecutionResult:
+    """Run the function on computer nodes"""
+    # This is a catch-all for any exceptions that occur in the process and need to raise for
+    # parsl retries to work
+    try:
+        return execute_locally(definition=definition, log_level=log_level, raise_error=True)
+    except DiagnosticError as e:  # pragma: no cover
+        # any diagnostic error will be caught here
+        logger.exception("Error running diagnostic")
+        return cast(ExecutionResult, e.result)
+
+
+def _to_float(x: Any) -> float | None:
+    if x is None:
+        return None
+    if isinstance(x, int | float):
+        return float(x)
+    try:
+        return float(x)
+    except (ValueError, TypeError):
+        return None
+
+
+def _to_int(x: Any) -> int | None:
+    if x is None:
+        return None
+    if isinstance(x, int):
+        return x
+    try:
+        return int(float(x))  # Handles both "123" and "123.0"
+    except (ValueError, TypeError):
+        return None
+
+
+class HPCExecutor:
+    """
+    Run diagnostics by submitting a job script
+
+    """
+
+    name = "hpc"
+
+    def __init__(
+        self,
+        *,
+        database: Database | None = None,
+        config: Config | None = None,
+        **executor_config: str | float | int,
+    ) -> None:
+        config = config or Config.default()
+        database = database or Database.from_config(config, run_migrations=False)
+
+        self.config = config
+        self.database = database
+
+        self.scheduler = executor_config.get("scheduler", "slurm")
+        self.account = str(executor_config.get("account", os.environ.get("USER")))
+        self.username = executor_config.get("username", os.environ.get("USER"))
+        self.partition = str(executor_config.get("partition")) if executor_config.get("partition") else None
+        self.qos = str(executor_config.get("qos")) if executor_config.get("qos") else None
+        self.req_nodes = int(executor_config.get("req_nodes", 1))
+        self.walltime = str(executor_config.get("walltime", "00:10:00"))
+        self.log_dir = str(executor_config.get("log_dir", "runinfo"))
+
+        self.cores_per_worker = _to_int(executor_config.get("cores_per_worker"))
+        self.mem_per_worker = _to_float(executor_config.get("mem_per_worker"))
+
+        hours, minutes, seconds = map(int, self.walltime.split(":"))
+        total_minutes = hours * 60 + minutes + seconds / 60
+        self.total_minutes = total_minutes
+
+        if executor_config.get("validation") and HAS_REAL_SLURM:
+            self._validate_slurm_params()
+
+        self._initialize_parsl()
+
+        self.parsl_results: list[ExecutionFuture] = []
+
+    def _validate_slurm_params(self) -> None:
+        """Validate the Slurm configuration using SlurmChecker.
+
+        Raises
+        ------
+            ValueError: If account, partition or QOS are invalid or inaccessible.
+        """
+        slurm_checker = SlurmChecker()
+        if self.account and not slurm_checker.get_account_info(self.account):
+            raise ValueError(f"Account: {self.account} not valid")
+
+        partition_limits = None
+        node_info = None
+
+        if self.partition:
+            if not slurm_checker.get_partition_info(self.partition):
+                raise ValueError(f"Partition: {self.partition} not valid")
+
+            if not slurm_checker.can_account_use_partition(self.account, self.partition):
+                raise ValueError(f"Account: {self.account} cannot access partiton: {self.partition}")
+
+            partition_limits = slurm_checker.get_partition_limits(self.partition)
+            node_info = slurm_checker.get_node_from_partition(self.partition)
+
+        qos_limits = None
+        if self.qos:
+            if not slurm_checker.get_qos_info(self.qos):
+                raise ValueError(f"QOS: {self.qos} not valid")
+
+            if not slurm_checker.can_account_use_qos(self.account, self.qos):
+                raise ValueError(f"Account: {self.account} cannot access qos: {self.qos}")
+
+            qos_limits = slurm_checker.get_qos_limits(self.qos)
+
+        max_cores_per_node = int(node_info["cpus"]) if node_info else None
+        if max_cores_per_node and self.cores_per_worker:
+            if self.cores_per_worker > max_cores_per_node:
+                raise ValueError(
+                    f"cores_per_work:{self.cores_per_worker}"
+                    f"larger than the maximum in a node {max_cores_per_node}"
+                )
+
+        max_mem_per_node = float(node_info["real_memory"]) if node_info else None
+        if max_mem_per_node and self.mem_per_worker:
+            if self.mem_per_worker > max_mem_per_node:
+                raise ValueError(
+                    f"mem_per_work:{self.mem_per_worker}"
+                    f"larger than the maximum mem in a node {max_mem_per_node}"
+                )
+
+        max_walltime_partition = (
+            partition_limits["max_time_minutes"] if partition_limits else self.total_minutes
+        )
+        max_walltime_qos = qos_limits["max_time_minutes"] if qos_limits else self.total_minutes
+
+        max_walltime_minutes = min(float(max_walltime_partition), float(max_walltime_qos))
+
+        if self.total_minutes > float(max_walltime_minutes):
+            raise ValueError(
+                f"Walltime: {self.walltime} exceed the maximum time "
+                f"{max_walltime_minutes} allowed by {self.partition} and {self.qos}"
+            )
+
+    def _initialize_parsl(self) -> None:
+        executor_config = self.config.executor.config
+
+        provider = SlurmProvider(
+            account=self.account,
+            partition=self.partition,
+            qos=self.qos,
+            nodes_per_block=self.req_nodes,
+            max_blocks=int(executor_config.get("max_blocks", 1)),
+            scheduler_options=executor_config.get("scheduler_options", "#SBATCH -C cpu"),
+            worker_init=executor_config.get("worker_init", "source .venv/bin/activate"),
+            launcher=SrunLauncher(
+                debug=True,
+                overrides=executor_config.get("overrides", ""),
+            ),
+            walltime=self.walltime,
+            cmd_timeout=int(executor_config.get("cmd_timeout", 120)),
+        )
+        executor = HighThroughputExecutor(
+            label="ref_hpc_executor",
+            cores_per_worker=self.cores_per_worker if self.cores_per_worker else 1,
+            mem_per_worker=self.mem_per_worker,
+            max_workers_per_node=_to_int(executor_config.get("max_workers_per_node", 16)),
+            cpu_affinity=str(executor_config.get("cpu_affinity")),
+            provider=provider,
+        )
+
+        hpc_config = ParslConfig(
+            run_dir=self.log_dir, executors=[executor], retries=int(executor_config.get("retries", 2))
+        )
+        parsl.load(hpc_config)
+
+    def run(
+        self,
+        definition: ExecutionDefinition,
+        execution: Execution | None = None,
+    ) -> None:
+        """
+        Run a diagnostic in process
+
+        Parameters
+        ----------
+        definition
+            A description of the information needed for this execution of the diagnostic
+        execution
+            A database model representing the execution of the diagnostic.
+            If provided, the result will be updated in the database when completed.
+        """
+        # Submit the execution to the process pool
+        # and track the future so we can wait for it to complete
+        future = _process_run(
+            definition=definition,
+            log_level=self.config.log_level,
+        )
+
+        self.parsl_results.append(
+            ExecutionFuture(
+                future=future,
+                definition=definition,
+                execution_id=execution.id if execution else None,
+            )
+        )
+
+    def join(self, timeout: float) -> None:
+        """
+        Wait for all diagnostics to finish
+
+        This will block until all diagnostics have completed or the timeout is reached.
+        If the timeout is reached, the method will return and raise an exception.
+
+        Parameters
+        ----------
+        timeout
+            Timeout in seconds (won't used in HPCExecutor)
+
+        Raises
+        ------
+        TimeoutError
+            If the timeout is reached
+        """
+        start_time = time.time()
+        refresh_time = 0.5
+
+        results = self.parsl_results
+        t = tqdm(total=len(results), desc="Waiting for executions to complete", unit="execution")
+
+        try:
+            while results:
+                # Iterate over a copy of the list and remove finished tasks
+                for result in results[:]:
+                    if result.future.done():
+                        try:
+                            execution_result = result.future.result(timeout=0)
+                        except Exception as e:
+                            # Something went wrong when attempting to run the execution
+                            # This is likely a failure in the execution itself not the diagnostic
+                            raise ExecutionError(
+                                f"Failed to execute {result.definition.execution_slug()!r}"
+                            ) from e
+
+                        assert execution_result is not None, "Execution result should not be None"
+                        assert isinstance(execution_result, ExecutionResult), (
+                            "Execution result should be of type ExecutionResult"
+                        )
+
+                        # Process the result in the main process
+                        # The results should be committed after each execution
+                        with self.database.session.begin():
+                            execution = (
+                                self.database.session.get(Execution, result.execution_id)
+                                if result.execution_id
+                                else None
+                            )
+                            process_result(self.config, self.database, result.future.result(), execution)
+                        logger.debug(f"Execution completed: {result}")
+                        t.update(n=1)
+                        results.remove(result)
+
+                # Break early to avoid waiting for one more sleep cycle
+                if len(results) == 0:
+                    break
+
+                elapsed_time = time.time() - start_time
+
+                if elapsed_time > self.total_minutes * 60:
+                    logger.debug(f"Time elasped {elapsed_time} for joining the results")
+
+                # Wait for a short time before checking for completed executions
+                time.sleep(refresh_time)
+        finally:
+            t.close()
+            if parsl.dfk():
+                parsl.dfk().cleanup()

climate_ref/executor/local.py

@@ -1,4 +1,5 @@
 import concurrent.futures
+import multiprocessing
 import time
 from concurrent.futures import Future, ProcessPoolExecutor
 from typing import Any
@@ -124,7 +125,12 @@ class LocalExecutor:
         if pool is not None:
             self.pool = pool
         else:
-            self.pool = ProcessPoolExecutor(max_workers=n, initializer=_process_initialiser)
+            self.pool = ProcessPoolExecutor(
+                max_workers=n,
+                initializer=_process_initialiser,
+                # Explicitly set the context to "spawn" to avoid issues with hanging on MacOS
+                mp_context=multiprocessing.get_context("spawn"),
+            )
         self._results: list[ExecutionFuture] = []
 
     def run(

climate_ref/slurm.py

@@ -0,0 +1,192 @@
+import importlib.util
+from typing import Any
+
+HAS_REAL_SLURM = importlib.util.find_spec("pyslurm") is not None
+
+
+class SlurmChecker:
+    """Check and get slurm settings."""
+
+    def __init__(self, intest: bool = False) -> None:
+        if HAS_REAL_SLURM:
+            import pyslurm  # type: ignore
+
+            self.slurm_association: dict[int, Any] | None = pyslurm.db.Associations.load()
+            self.slurm_partition: dict[str, Any] | None = pyslurm.Partitions.load()
+            self.slurm_qos: dict[str, Any] | None = pyslurm.qos().get()
+            self.slurm_node: dict[str, Any] | None = pyslurm.Nodes.load()
+        elif intest:
+            import pyslurm
+
+            self.slurm_association = pyslurm.db.Associations.load()  # dict [num -> Association]
+            self.slurm_partition = pyslurm.Partitions.load()  # collection
+            self.slurm_qos = pyslurm.qos().get()  # dict
+            self.slurm_node = pyslurm.Nodes.load()  # dict
+        else:
+            print("Warning: pyslurm not found. Skipping HPCExecutor config validations")
+            self.slurm_association = None
+            self.slurm_partition = None
+            self.slurm_qos = None
+            self.slurm_node = None
+
+    def get_partition_info(self, partition_name: str) -> Any:
+        """Check if a partition exists in the Slurm configuration."""
+        return self.slurm_partition.get(partition_name) if self.slurm_partition else None
+
+    def get_qos_info(self, qos_name: str) -> Any:
+        """Check if a qos exists in the Slurm configuration."""
+        return self.slurm_qos.get(qos_name) if self.slurm_qos else None
+
+    def get_account_info(self, account_name: str) -> list[Any]:
+        """Get all associations for an account"""
+        if self.slurm_association:
+            return [a for a in self.slurm_association.values() if a.account == account_name]
+        else:
+            return [None]
+
+    def can_account_use_partition(self, account_name: str, partition_name: str) -> bool:
+        """
+        Check if an account has access to a specific partition.
+
+        Returns
+        -------
+            bool: True if accessible, False if not accessible or error occurred
+        """
+        account_info = self.get_account_info(account_name)
+        if not account_info:
+            return False
+
+        partition_info = self.get_partition_info(partition_name)
+
+        if not partition_info:
+            return False
+
+        allowed_partitions = account_info[0].partition
+        if allowed_partitions is None:
+            return True
+        else:
+            return partition_name in allowed_partitions
+
+    def can_account_use_qos(self, account_name: str, qos_name: str) -> bool:
+        """
+        Check if an account has access to a specific qos.
+
+        Returns
+        -------
+            bool: True if accessible, False if not accessible or error occurred
+        """
+        account_info = self.get_account_info(account_name)
+
+        if not account_info:
+            return False
+
+        qos_info = self.get_qos_info(qos_name)
+        if not qos_info:
+            return False
+
+        sample_acc = account_info[0]
+        for acc in account_info:
+            if acc.user == "minxu":
+                sample_acc = acc
+                break
+
+        allowed_qoss = sample_acc.qos
+        if allowed_qoss is None:
+            return True
+        else:
+            return qos_name in allowed_qoss
+
+    def get_partition_limits(self, partition_name: str) -> dict[str, str | int] | None:
+        """
+        Get time limits for a specific partition.
+
+        Returns
+        -------
+            Dict with 'max_time' and 'default_time' (strings or UNLIMITED)
+            or None if partition doesn't exist or error occurred
+        """
+        partition_info = self.get_partition_info(partition_name)
+        if not partition_info:
+            return None
+
+        return {
+            "max_time_minutes": partition_info.to_dict().get("max_time", 0),  # in minutes
+            "default_time_minutes": partition_info.to_dict().get("default_time", 30),  # in minutes
+            "max_nodes": partition_info.to_dict().get("max_node", 1),
+            "total_nodes": partition_info.to_dict().get("total_nodes", 0),
+            "total_cpus": partition_info.to_dict().get("total_cpus", 0),
+        }
+
+    def get_node_from_partition(self, partition_name: str) -> dict[str, str | int] | None:
+        """
+        Get the node information for a specific partition.
+
+        Returns
+        -------
+            Dicts
+        """
+        partition_info = self.get_partition_info(partition_name)
+        if not partition_info:
+            return None
+
+        sample_node = None
+
+        if self.slurm_node:
+            for node in self.slurm_node.values():
+                if partition_name in node.partitions and "cpu" in node.available_features:
+                    sample_node = node
+                    break
+
+        return {
+            "cpus": int(sample_node.total_cpus) if sample_node is not None else 1,
+            "cores_per_socket": int(sample_node.cores_per_socket) if sample_node is not None else 1,
+            "sockets": int(sample_node.sockets) if sample_node is not None else 1,
+            "threads_per_core": int(sample_node.threads_per_core) if sample_node is not None else 1,
+            "real_memory": int(sample_node.real_memory) if sample_node is not None else 215,
+            "node_names": sample_node.name if sample_node is not None else "unknown",
+        }
+
+    def get_qos_limits(self, qos_name: str) -> dict[str, str | int]:
+        """
+        Get time limits for a specific qos.
+
+        Returns
+        -------
+            Dict with 'max_time' and 'default_time' (strings or UNLIMITED)
+            or None if partition doesn't exist or error occurred
+        """
+        qos_info = self.get_qos_info(qos_name)
+
+        return {
+            "max_time_minutes": qos_info.get("max_wall_pj", 1.0e6),
+            "max_jobs_pu": qos_info.get("max_jobs_pu", 1.0e6),
+            "max_submit_jobs_pu": qos_info.get("max_submit_jobs_pu", 1.0e6),
+            "max_tres_pj": qos_info.get("max_tres_pj").split("=")[0],
+            "default_time_minutes": 120,
+        }
+
+    def check_account_partition_access_with_limits(
+        self, account_name: str, partition_name: str
+    ) -> dict[str, Any]:
+        """
+        Comprehensive check of account access and partition limits.
+
+        Returns dictionary with all relevant information.
+        """
+        result = {
+            "account_exists": True if self.get_account_info(account_name) else False,
+            "partition_exists": True if self.get_partition_info(partition_name) else False,
+            "has_access": False,
+            "time_limits": None,
+            "error": "none",
+        }
+
+        try:
+            if result["account_exists"] and result["partition_exists"]:
+                result["has_access"] = self.can_account_use_partition(account_name, partition_name)
+                if result["has_access"]:
+                    result["time_limits"] = self.get_partition_info(partition_name).to_dict().get("max_time")
+        except Exception as e:
+            result["error"] = str(e)
+
+        return result

{climate_ref-0.6.0.dist-info → climate_ref-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: climate-ref
-Version: 0.6.0
+Version: 0.6.1
 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-Expression: Apache-2.0
@@ -25,6 +25,7 @@ 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: parsl>=2025.5.19
 Requires-Dist: platformdirs>=4.3.6
 Requires-Dist: sqlalchemy>=2.0.36
 Requires-Dist: tomlkit>=0.13.2

{climate_ref-0.6.0.dist-info → climate_ref-0.6.1.dist-info}/RECORD

@@ -6,6 +6,7 @@ climate_ref/constants.py,sha256=9RaNLgUSuQva7ki4eRW3TjOKeVP6T81QNiu0veB1zVk,111
 climate_ref/database.py,sha256=b_6XHdr78Mo7KeLqQJ5DjLsySHPdQE83P8dRpdMfzfM,8661
 climate_ref/provider_registry.py,sha256=dyfj4vU6unKHNXtT03HafQtAi3LilL37uvu3paCnmNY,4159
 climate_ref/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+climate_ref/slurm.py,sha256=20of7zMEeCg8BVQmy_IjSgZ8AJlYJbb8MK2Rjuzig-U,7215
 climate_ref/solver.py,sha256=T5sQjweSvpUMG4q8MfbGjljxa5kBgKxNotT78PwyxqU,16804
 climate_ref/testing.py,sha256=1b9lVCJlKxjJ7JGq6zDD2gK3BEM9ZVv1dbA-j6yb4Yk,4256
 climate_ref/cli/__init__.py,sha256=q-JAiRmwTXqapJGwtfuZ2P-L1a4XAmWj3CoZKLWlP3A,4357
@@ -23,8 +24,9 @@ climate_ref/datasets/cmip6.py,sha256=3MVJ1kPdw6f6V3G4gdHIiqDGUyMqPs-_wttkw2YKAH0
 climate_ref/datasets/obs4mips.py,sha256=CmMm4kopfb0yFsMSgUlHUm8clGJImBaodSkh6lAv_Ug,5926
 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=DooN4jQudmLHyw24IfqNfWynfa1vEolLs-mZ7uY8O0k,604
-climate_ref/executor/local.py,sha256=P_nGD4blrLavk-ISj73cakAQCeELM_hNIhs8yVWWSAQ,8353
+climate_ref/executor/__init__.py,sha256=PYtJs3oBS_GiUHbt8BF-6wJibpF6_vREm1Cg9TxVbLI,648
+climate_ref/executor/hpc.py,sha256=2uZkSXww-oMqmzrYmh21hwJ7Mjjpojg-AhxX8eX_8Qo,11677
+climate_ref/executor/local.py,sha256=65LUl41YtURFb87YTWZQHjDpIRlIKJ5Ny51c9DZjy0s,8582
 climate_ref/executor/result_handling.py,sha256=i7ZMX5vvyPY5gW-WWd-JHLi1BLviB9FXhn4FE8C9d4w,7787
 climate_ref/executor/synchronous.py,sha256=o4TndsoKMu9AzJYLkusU9lRkgHCy6HcCP46tEs6o86U,1895
 climate_ref/migrations/README,sha256=xM5osYbyEbEFA2eh5kwary_oh-5VFWtDubA-vgWwvlE,935
@@ -39,9 +41,9 @@ climate_ref/models/diagnostic.py,sha256=YB6xzbEXdpz2j-Ddf19RV8mAiWBrkmtRmiAEUV3t
 climate_ref/models/execution.py,sha256=lRCpaKLSR7rZbuoL94GW76tm9wLMsSDoIOA7bIa6xgY,9848
 climate_ref/models/metric_value.py,sha256=44OLcZz-qLx-p_9w7YWDKpD5S7Y9HyTKKsvSb77RBro,10190
 climate_ref/models/provider.py,sha256=RAE2qAAxwObu-72CdK4kt5ACMmKYEn07WJm7DU9hF28,990
-climate_ref-0.6.0.dist-info/METADATA,sha256=Ov6ZLG2A0D78je48OtG4TOhaCczrwoknsHSSt0rwutE,4399
-climate_ref-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-climate_ref-0.6.0.dist-info/entry_points.txt,sha256=IaggEJlDIhoYWXdXJafacWbWtCcoEqUKceP1qD7_7vU,44
-climate_ref-0.6.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-climate_ref-0.6.0.dist-info/licenses/NOTICE,sha256=4qTlax9aX2-mswYJuVrLqJ9jK1IkN5kSBqfVvYLF3Ws,128
-climate_ref-0.6.0.dist-info/RECORD,,
+climate_ref-0.6.1.dist-info/METADATA,sha256=X-O5GFGtgPisrdsh0VZp4v5JgqOXF9e5Kqx1jYkxbkI,4431
+climate_ref-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+climate_ref-0.6.1.dist-info/entry_points.txt,sha256=IaggEJlDIhoYWXdXJafacWbWtCcoEqUKceP1qD7_7vU,44
+climate_ref-0.6.1.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+climate_ref-0.6.1.dist-info/licenses/NOTICE,sha256=4qTlax9aX2-mswYJuVrLqJ9jK1IkN5kSBqfVvYLF3Ws,128
+climate_ref-0.6.1.dist-info/RECORD,,