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

climate_ref/cli/__init__.py

@@ -88,7 +88,7 @@ def build_app() -> typer.Typer:
     :
         The CLI app
     """
-    app = typer.Typer(name="climate_ref", no_args_is_help=True)
+    app = typer.Typer(name="ref", no_args_is_help=True)
 
     app.command(name="solve")(solve.solve)
     app.add_typer(config.app, name="config")
@@ -136,10 +136,10 @@ def main(  # noqa: PLR0913
     ] = None,
 ) -> None:
     """
-    climate_ref: A CLI for the Assessment Fast Track Rapid Evaluation Framework
+    A CLI for the Assessment Fast Track Rapid Evaluation Framework
 
     This CLI provides a number of commands for managing and executing diagnostics.
-    """
+    """  # noqa: D401
     if quiet:
         log_level = LogLevel.Warning
     if verbose:

climate_ref/cli/config.py

@@ -20,9 +20,9 @@ def list_(ctx: typer.Context) -> None:
     print(config.dumps(defaults=True))
 
 
-@app.command()
-def update() -> None:
-    """
-    Update a configuration value
-    """
-    print("config")
+# @app.command()
+# def update() -> None:
+#     """
+#     Update a configuration value
+#     """
+#     print("config")

climate_ref/cli/datasets.py

@@ -1,5 +1,9 @@
 """
 View and ingest input datasets
+
+The metadata from these datasets are stored in the database so that they can be used to determine
+which executions are required for a given diagnostic without having to re-parse the datasets.
+
 """
 
 import errno
@@ -105,9 +109,12 @@ def ingest(  # noqa: PLR0913
     ] = False,
 ) -> None:
     """
-    Ingest a dataset
+    Ingest a directory of datasets into the database
+
+    Each dataset will be loaded and validated using the specified dataset adapter.
+    This will extract metadata from the datasets and store it in the database.
 
-    This will register a dataset in the database to be used for diagnostics calculations.
+    A table of the datasets will be printed to the console at the end of the operation.
     """
     config = ctx.obj.config
     db = ctx.obj.database

climate_ref/cli/executions.py

@@ -1,5 +1,5 @@
 """
-View diagnostic executions
+View execution groups and their results
 """
 
 import pathlib
@@ -29,11 +29,19 @@ console = Console()
 @app.command()
 def list_groups(
     ctx: typer.Context,
-    column: Annotated[list[str] | None, typer.Option()] = None,
+    column: Annotated[
+        list[str] | None,
+        typer.Option(help="Only include specified columns in the output"),
+    ] = None,
     limit: int = typer.Option(100, help="Limit the number of rows to display"),
 ) -> None:
     """
     List the diagnostic execution groups that have been identified
+
+    The data catalog is sorted by the date that the execution group was created (first = newest).
+    If the `--column` option is provided, only the specified columns will be displayed.
+
+    The output will be in a tabular format.
     """
     session = ctx.obj.database.session
 
@@ -178,6 +186,8 @@ def _log_panel(result_directory: pathlib.Path) -> Panel | None:
 def inspect(ctx: typer.Context, execution_id: int) -> None:
     """
     Inspect a specific execution group by its ID
+
+    This will display the execution details, datasets, results directory, and logs if available.
     """
     config: Config = ctx.obj.config
     session = ctx.obj.database.session

climate_ref/cli/providers.py

@@ -56,7 +56,10 @@ def create_env(
     ] = None,
 ) -> None:
     """
-    Create a virtual environment containing the provider software.
+    Create a conda environment containing the provider software.
+
+    If no provider is specified, all providers will be installed.
+    If the provider is up to date or does not use a virtual environment, it will be skipped.
     """
     config = ctx.obj.config
     db = ctx.obj.database

climate_ref/cli/solve.py

@@ -49,6 +49,10 @@ def solve(  # noqa: PLR0913
 
     This may trigger a number of additional calculations depending on what data has been ingested
     since the last solve.
+    This command will block until all executions have been solved or the timeout is reached.
+
+    Filters can be applied to limit the diagnostics and providers that are considered, see the options
+    `--diagnostic` and `--provider` for more information.
     """
     config = ctx.obj.config
     db = ctx.obj.database

climate_ref/config.py

@@ -15,6 +15,7 @@ which always take precedence over any other configuration values.
 # https://github.com/ESGF/esgf-download/blob/main/esgpull/config.py
 
 import importlib.resources
+import os
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -64,6 +65,7 @@ def ensure_absolute_path(path: str | Path) -> Path:
     """
     if isinstance(path, str):
         path = Path(path)
+    path = Path(*[os.path.expandvars(p) for p in path.parts])
     return path.resolve()
 
 

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,320 @@
+"""
+HPC-based Executor to use job schedulers.
+
+If you want to
+- run REF under the HPC workflows
+- run REF in multiple nodes
+
+"""
+
+try:
+    import parsl
+except ImportError:  # pragma: no cover
+    raise ImportError("The HPCExecutor requires the `parsl` package")
+
+import os
+import time
+from typing import Any
+
+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")
+        raise e
+
+
+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():
+                        # Cannot catch the execption raised by result.future.result
+                        if result.future.exception() is None:
+                            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
+                        else:
+                            err = result.future.exception()
+                            if isinstance(err, DiagnosticError):
+                                execution_result = err.result
+                            else:
+                                execution_result = None
+
+                        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, execution_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,196 @@
+import importlib.util
+import os
+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]
+        user_name = os.environ["USER"]
+
+        if user_name:
+            for acc in account_info:
+                if acc.user == user_name:
+                    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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: climate-ref
-Version: 0.6.0
+Version: 0.6.2
 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
@@ -10,7 +10,8 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -25,6 +26,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; sys_platform != 'win32'
 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.2.dist-info}/RECORD

@@ -1,20 +1,21 @@
 climate_ref/__init__.py,sha256=M45QGfl0KCPK48A8MjI08weNvZHMYH__GblraQMxsoM,808
 climate_ref/_config_helpers.py,sha256=-atI5FX7SukhLE_jz_rL-EHQ7s0YYqKu3dSFYWxSyMU,6632
 climate_ref/alembic.ini,sha256=WRvbwSIFuZ7hWNMnR2-yHPJAwYUnwhvRYBzkJhtpGdg,3535
-climate_ref/config.py,sha256=SHxqdpzq-TIfAdhwk1Yt-ob96T2a3pqYcq-Wed4Ljgg,16882
+climate_ref/config.py,sha256=T1WzwFhzJ2-RKnOzyOmyUsdXrj_KDW2eycdPXZKnbf0,16954
 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=XWXVPdXP-4BDib3bxYW9uPcAJdPpo1ixYZAI_y1cZuw,7305
 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
+climate_ref/cli/__init__.py,sha256=fvENOeL4j7CMPANVxrDlWfaB0QUvvYgrWcm5ptbL0P8,4350
 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=5fEh4VnQUcQKxSsFc8u6lWkOlpv7-ix-1eccK2TET9c,7890
-climate_ref/cli/executions.py,sha256=sZXyVFYWML5mD7dE8xlsqyunsrwOIweTBDEUKCjXEpo,6798
-climate_ref/cli/providers.py,sha256=eS9IaQxW8zGxidr8TWt7thdMU5JH53u4T3xbcIe2C_E,2455
-climate_ref/cli/solve.py,sha256=qc7yalXxqdcSZsoCh2ZSV7Mt6mxTKc4lg7zKpMA55Y8,2112
+climate_ref/cli/config.py,sha256=ak4Rn9S6fH23PkHHlI-pXuPiZYOvUB4r26eu3p525-M,532
+climate_ref/cli/datasets.py,sha256=4iYQZ0ceoF-Cd8eSpS4Q8b9aLt_vEDUw5slzGw02DsY,8277
+climate_ref/cli/executions.py,sha256=2MjwxCdRB-uVJUg7RluDIf_IsoclRn22ibJjk_nhfPo,7215
+climate_ref/cli/providers.py,sha256=-5hQkJc01jON1bc1dk--tSWTesyiHOzZuYMb9Vxge9k,2613
+climate_ref/cli/solve.py,sha256=ZTXrwDFDXNrX5GLMJTN9tFnpV3zlcZbEu2aF3JDJVxI,2367
 climate_ref/dataset_registry/obs4ref_reference.txt,sha256=2zJMbsAsQ49KaWziX3CqrlILq9yN7S2ygmfV3V5rsnw,8395
 climate_ref/dataset_registry/sample_data.txt,sha256=3JAHy14pRbLlo9-oNxUXLgZ_QOFJXUieEftBbapSY8E,20124
 climate_ref/datasets/__init__.py,sha256=PV3u5ZmhyfcHbKqySgwVA8m4-naZgxzydLXSBqdTGLM,1171
@@ -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=4o90sCyoC4jlkem3BXNo4uwFZpIvOUGfrqYucB6EtU8,12251
+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.2.dist-info/METADATA,sha256=1yFQ4n5psYiBtO6jmhhEMdWkpOhM74sD_rE92XXm3Do,4505
+climate_ref-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+climate_ref-0.6.2.dist-info/entry_points.txt,sha256=IaggEJlDIhoYWXdXJafacWbWtCcoEqUKceP1qD7_7vU,44
+climate_ref-0.6.2.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+climate_ref-0.6.2.dist-info/licenses/NOTICE,sha256=4qTlax9aX2-mswYJuVrLqJ9jK1IkN5kSBqfVvYLF3Ws,128
+climate_ref-0.6.2.dist-info/RECORD,,