fractal-server 2.14.4a0__py3-none-any.whl → 2.14.6__py3-none-any.whl

fractal_server/app/runner/executors/base_runner.py

@@ -19,14 +19,17 @@ TASK_TYPES_MULTISUBMIT: list[TaskTypeType] = [
 logger = set_logger(__name__)
 
 
-class BaseRunner(object):
+class BaseRunner:
     """
     Base class for Fractal runners.
     """
 
     def submit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
         task_type: TaskTypeType,
@@ -38,7 +41,10 @@ class BaseRunner(object):
         Run a single fractal task.
 
         Args:
-            func: Function to be executed.
+            base_command:
+            workflow_task_order:
+            workflow_task_id:
+            task_name:
             parameters: Dictionary of parameters.
             history_unit_id:
                 Database ID of the corresponding `HistoryUnit` entry.
@@ -51,7 +57,10 @@ class BaseRunner(object):
 
     def multisubmit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         list_parameters: list[dict[str, Any]],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
@@ -63,7 +72,10 @@ class BaseRunner(object):
         Run a parallel fractal task.
 
         Args:
-            func: Function to be executed.
+            base_command:
+            workflow_task_order:
+            workflow_task_id:
+            task_name:
             parameters:
                 Dictionary of parameters. Must include `zarr_urls` key.
             history_unit_ids:
@@ -138,9 +150,9 @@ class BaseRunner(object):
                 f"{len(list_parameters)=}."
             )
 
-        subfolders = set(
+        subfolders = {
             task_file.wftask_subfolder_local for task_file in list_task_files
-        )
+        }
         if len(subfolders) != 1:
             raise ValueError(f"More than one subfolders: {subfolders}.")
 

fractal_server/app/runner/executors/call_command_wrapper.py

@@ -0,0 +1,52 @@
+import os
+import shlex
+import shutil
+import subprocess  # nosec
+
+from fractal_server.app.runner.exceptions import TaskExecutionError
+from fractal_server.string_tools import validate_cmd
+
+
+def call_command_wrapper(*, cmd: str, log_path: str) -> None:
+    """
+    Call a command and write its stdout and stderr to files
+
+    Args:
+        cmd:
+        log_path:
+    """
+    try:
+        validate_cmd(cmd)
+    except ValueError as e:
+        raise TaskExecutionError(f"Invalid command. Original error: {str(e)}")
+
+    split_cmd = shlex.split(cmd)
+
+    # Verify that task command is executable
+    if shutil.which(split_cmd[0]) is None:
+        msg = (
+            f'Command "{split_cmd[0]}" is not valid. '
+            "Hint: make sure that it is executable."
+        )
+        raise TaskExecutionError(msg)
+
+    with open(log_path, "w") as fp_log:
+        try:
+            result = subprocess.run(  # nosec
+                split_cmd,
+                stderr=fp_log,
+                stdout=fp_log,
+            )
+        except Exception as e:
+            # This is likely unreachable
+            raise e
+
+    if result.returncode != 0:
+        stderr = ""
+        if os.path.isfile(log_path):
+            with open(log_path) as fp_stderr:
+                stderr = fp_stderr.read()
+        raise TaskExecutionError(
+            f"Task failed with returncode={result.returncode}.\n"
+            f"STDERR: {stderr}"
+        )

fractal_server/app/runner/executors/local/get_local_config.py

@@ -14,7 +14,6 @@ Submodule to handle the local-backend configuration for a WorkflowTask
 import json
 from pathlib import Path
 from typing import Literal
-from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import ConfigDict
@@ -45,7 +44,7 @@ class LocalBackendConfig(BaseModel):
     """
 
     model_config = ConfigDict(extra="forbid")
-    parallel_tasks_per_job: Optional[int] = None
+    parallel_tasks_per_job: int | None = None
 
     @property
     def batch_size(self) -> int:
@@ -55,7 +54,7 @@ class LocalBackendConfig(BaseModel):
 def get_local_backend_config(
     wftask: WorkflowTaskV2,
     which_type: Literal["non_parallel", "parallel"],
-    config_path: Optional[Path] = None,
+    config_path: Path | None = None,
     tot_tasks: int = 1,
 ) -> LocalBackendConfig:
     """

fractal_server/app/runner/executors/local/runner.py

@@ -1,9 +1,11 @@
+import json
 from concurrent.futures import Future
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 from typing import Literal
 
+from ..call_command_wrapper import call_command_wrapper
 from .get_local_config import LocalBackendConfig
 from fractal_server.app.db import get_sync_db
 from fractal_server.app.runner.exceptions import TaskExecutionError
@@ -16,10 +18,40 @@ from fractal_server.app.runner.v2.db_tools import update_status_of_history_unit
 from fractal_server.app.schemas.v2 import HistoryUnitStatus
 from fractal_server.logger import set_logger
 
-
 logger = set_logger(__name__)
 
 
+def run_single_task(
+    base_command: str,
+    parameters: dict[str, Any],
+    task_files: TaskFiles,
+):
+
+    # Write args.json file
+    with open(task_files.args_file_local, "w") as f:
+        json.dump(parameters, f)
+
+    # Run command
+    full_command = (
+        f"{base_command} "
+        f"--args-json {task_files.args_file_local} "
+        f"--out-json {task_files.metadiff_file_local}"
+    )
+
+    call_command_wrapper(
+        cmd=full_command,
+        log_path=task_files.log_file_local,
+    )
+
+    try:
+        with open(task_files.metadiff_file_local) as f:
+            out_meta = json.load(f)
+        return out_meta
+    except FileNotFoundError:
+        # Command completed, but it produced no metadiff file
+        return None
+
+
 class LocalRunner(BaseRunner):
     executor: ThreadPoolExecutor
     root_dir_local: Path
@@ -47,17 +79,20 @@ class LocalRunner(BaseRunner):
 
     def submit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
         task_files: TaskFiles,
+        config: LocalBackendConfig,
         task_type: Literal[
             "non_parallel",
             "converter_non_parallel",
             "compound",
             "converter_compound",
         ],
-        config: LocalBackendConfig,
         user_id: int,
     ) -> tuple[Any, Exception]:
         logger.debug("[submit] START")
@@ -69,9 +104,10 @@ class LocalRunner(BaseRunner):
 
             # SUBMISSION PHASE
             future = self.executor.submit(
-                func,
+                run_single_task,
+                base_command=base_command,
                 parameters=parameters,
-                remote_files=task_files.remote_files_dict,
+                task_files=task_files,
             )
         except Exception as e:
             logger.error(
@@ -111,7 +147,10 @@ class LocalRunner(BaseRunner):
 
     def multisubmit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         list_parameters: list[dict],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
@@ -139,8 +178,9 @@ class LocalRunner(BaseRunner):
             )
 
             workdir_local = list_task_files[0].wftask_subfolder_local
-            if task_type == "parallel":
-                workdir_local.mkdir()
+            # Note: the `mkdir` is not needed for compound tasks, but it is
+            # needed for parallel tasks
+            workdir_local.mkdir(exist_ok=True)
 
             # Set `n_elements` and `parallel_tasks_per_job`
             n_elements = len(list_parameters)
@@ -178,11 +218,10 @@ class LocalRunner(BaseRunner):
                 positional_index = ind_chunk + ind_within_chunk
                 try:
                     future = self.executor.submit(
-                        func,
-                        parameters=kwargs,
-                        remote_files=list_task_files[
-                            positional_index
-                        ].remote_files_dict,
+                        run_single_task,
+                        base_command=base_command,
+                        parameters=list_parameters[positional_index],
+                        task_files=list_task_files[positional_index],
                     )
                     active_futures[positional_index] = future
                 except Exception as e:

fractal_server/app/runner/executors/slurm_common/_batching.py

@@ -12,7 +12,6 @@
 Submodule to determine the number of total/parallel tasks per SLURM job.
 """
 import math
-from typing import Optional
 
 from fractal_server.logger import set_logger
 
@@ -58,8 +57,8 @@ def heuristics(
     # Number of parallel components (always known)
     tot_tasks: int,
     # Optional WorkflowTask attributes:
-    tasks_per_job: Optional[int] = None,
-    parallel_tasks_per_job: Optional[int] = None,
+    tasks_per_job: int | None = None,
+    parallel_tasks_per_job: int | None = None,
     # Task requirements (multiple possible sources):
     cpus_per_task: int,
     mem_per_task: int,

fractal_server/app/runner/executors/slurm_common/_slurm_config.py

@@ -14,8 +14,6 @@ Submodule to handle the SLURM configuration for a WorkflowTask
 """
 import json
 from pathlib import Path
-from typing import Optional
-from typing import Union
 
 from pydantic import BaseModel
 from pydantic import ConfigDict
@@ -56,16 +54,16 @@ class _SlurmConfigSet(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    partition: Optional[str] = None
-    cpus_per_task: Optional[int] = None
-    mem: Optional[Union[int, str]] = None
-    constraint: Optional[str] = None
-    gres: Optional[str] = None
-    time: Optional[str] = None
-    account: Optional[str] = None
-    extra_lines: Optional[list[str]] = None
-    pre_submission_commands: Optional[list[str]] = None
-    gpus: Optional[str] = None
+    partition: str | None = None
+    cpus_per_task: int | None = None
+    mem: int | str | None = None
+    constraint: str | None = None
+    gres: str | None = None
+    time: str | None = None
+    account: str | None = None
+    extra_lines: list[str] | None = None
+    pre_submission_commands: list[str] | None = None
+    gpus: str | None = None
 
 
 class _BatchingConfigSet(BaseModel):
@@ -89,8 +87,8 @@ class _BatchingConfigSet(BaseModel):
 
     target_cpus_per_job: int
     max_cpus_per_job: int
-    target_mem_per_job: Union[int, str]
-    max_mem_per_job: Union[int, str]
+    target_mem_per_job: int | str
+    max_mem_per_job: int | str
     target_num_jobs: int
     max_num_jobs: int
 
@@ -143,13 +141,13 @@ class SlurmConfigFile(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     default_slurm_config: _SlurmConfigSet
-    gpu_slurm_config: Optional[_SlurmConfigSet] = None
+    gpu_slurm_config: _SlurmConfigSet | None = None
     batching_config: _BatchingConfigSet
-    user_local_exports: Optional[dict[str, str]] = None
+    user_local_exports: dict[str, str] | None = None
 
 
 def load_slurm_config_file(
-    config_path: Optional[Path] = None,
+    config_path: Path | None = None,
 ) -> SlurmConfigFile:
     """
     Load a SLURM configuration file and validate its content with
@@ -264,23 +262,23 @@ class SlurmConfig(BaseModel):
     shebang_line: str = "#!/bin/sh"
 
     # Optional SLURM parameters
-    job_name: Optional[str] = None
-    constraint: Optional[str] = None
-    gres: Optional[str] = None
-    gpus: Optional[str] = None
-    time: Optional[str] = None
-    account: Optional[str] = None
+    job_name: str | None = None
+    constraint: str | None = None
+    gres: str | None = None
+    gpus: str | None = None
+    time: str | None = None
+    account: str | None = None
 
     # Free-field attribute for extra lines to be added to the SLURM job
     # preamble
-    extra_lines: Optional[list[str]] = Field(default_factory=list)
+    extra_lines: list[str] | None = Field(default_factory=list)
 
     # Variables that will be `export`ed in the SLURM submission script
-    user_local_exports: Optional[dict[str, str]] = None
+    user_local_exports: dict[str, str] | None = None
 
     # Metaparameters needed to combine multiple tasks in each SLURM job
-    tasks_per_job: Optional[int] = None
-    parallel_tasks_per_job: Optional[int] = None
+    tasks_per_job: int | None = None
+    parallel_tasks_per_job: int | None = None
     target_cpus_per_job: int
     max_cpus_per_job: int
     target_mem_per_job: int
@@ -328,7 +326,7 @@ class SlurmConfig(BaseModel):
 
     def to_sbatch_preamble(
         self,
-        remote_export_dir: Optional[str] = None,
+        remote_export_dir: str | None = None,
     ) -> list[str]:
         """
         Compile `SlurmConfig` object into the preamble of a SLURM submission
@@ -410,7 +408,7 @@ class SlurmConfig(BaseModel):
         return self.tasks_per_job
 
 
-def _parse_mem_value(raw_mem: Union[str, int]) -> int:
+def _parse_mem_value(raw_mem: str | int) -> int:
     """
     Convert a memory-specification string into an integer (in MB units), or
     simply return the input if it is already an integer.