fractal-server 2.15.7__py3-none-any.whl → 2.15.8__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.15.7"
+__VERSION__ = "2.15.8"

fractal_server/app/models/security.py

@@ -73,10 +73,9 @@ class UserOAuth(SQLModel, table=True):
         is_active:
         is_superuser:
         is_verified:
-        slurm_user:
-        slurm_accounts:
         username:
         oauth_accounts:
+        settings:
     """
 
     __tablename__ = "user_oauth"

fractal_server/app/routes/admin/v2/job.py

@@ -109,7 +109,7 @@ async def view_job(
 
 @router.get("/{job_id}/", response_model=JobReadV2)
 async def view_single_job(
-    job_id: int = None,
+    job_id: int,
     show_tmp_logs: bool = False,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),

fractal_server/app/routes/admin/v2/task_group_lifecycle.py

@@ -25,7 +25,6 @@ from fractal_server.app.routes.aux.validate_user_settings import (
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
-from fractal_server.app.schemas.v2 import TaskGroupReadV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.config import get_settings
 from fractal_server.logger import set_logger
@@ -52,7 +51,7 @@ async def deactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupReadV2:
+) -> TaskGroupActivityV2Read:
     """
     Deactivate task-group venv
     """
@@ -157,7 +156,7 @@ async def reactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupReadV2:
+) -> TaskGroupActivityV2Read:
     """
     Deactivate task-group venv
     """

fractal_server/app/routes/api/v2/_aux_functions_task_version_update.py

@@ -6,7 +6,7 @@ def get_new_workflow_task_meta(
     old_workflow_task_meta: dict | None,
     old_task_meta: dict | None,
     new_task_meta: dict | None,
-) -> dict[str, Any]:
+) -> dict[str, Any] | None:
     """
     Prepare new meta field based on old/new tasks and old workflow task.
     """

fractal_server/app/routes/api/v2/submit.py

@@ -156,6 +156,28 @@ async def apply_workflow(
         if len(user_settings.slurm_accounts) > 0:
             job_create.slurm_account = user_settings.slurm_accounts[0]
 
+    # User appropriate FractalSSH object
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        ssh_config = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        try:
+            fractal_ssh = fractal_ssh_list.get(**ssh_config)
+        except Exception as e:
+            logger.error(
+                "Could not get a valid SSH connection in the submit endpoint. "
+                f"Original error: '{str(e)}'."
+            )
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail="Error in setting up the SSH connection.",
+            )
+    else:
+        fractal_ssh = None
+
     # Add new Job object to DB
     job = JobV2(
         project_id=project_id,
@@ -219,18 +241,6 @@ async def apply_workflow(
     await db.merge(job)
     await db.commit()
 
-    # User appropriate FractalSSH object
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        ssh_config = dict(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
-        )
-        fractal_ssh_list = request.app.state.fractal_ssh_list
-        fractal_ssh = fractal_ssh_list.get(**ssh_config)
-    else:
-        fractal_ssh = None
-
     # Expunge user settings from db, to use in background task
     db.expunge(user_settings)
 

fractal_server/app/routes/api/v2/task.py

@@ -69,7 +69,7 @@ async def get_list_task(
         stm = stm.where(TaskV2.authors.icontains(author))
 
     res = await db.execute(stm)
-    task_list = res.scalars().all()
+    task_list = list(res.scalars().all())
     await db.close()
     if args_schema is False:
         for task in task_list:

fractal_server/app/routes/api/v2/task_group_lifecycle.py

@@ -49,7 +49,7 @@ async def deactivate_task_group(
     response: Response,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupReadV2:
+) -> TaskGroupActivityV2Read:
     """
     Deactivate task-group venv
     """

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

@@ -66,7 +66,6 @@ class _SlurmConfigSet(BaseModel):
     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
 
 
@@ -253,8 +252,6 @@ class SlurmConfig(BaseModel):
             Key-value pairs to be included as `export`-ed variables in SLURM
             submission script, after prepending values with the user's cache
             directory.
-        pre_submission_commands: List of commands to be prepended to the sbatch
-            command.
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -294,8 +291,6 @@ class SlurmConfig(BaseModel):
     target_num_jobs: int
     max_num_jobs: int
 
-    pre_submission_commands: list[str] = Field(default_factory=list)
-
     def _sorted_extra_lines(self) -> list[str]:
         """
         Return a copy of `self.extra_lines`, where lines starting with

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

@@ -137,7 +137,9 @@ class BaseSlurmRunner(BaseRunner):
     def run_squeue(self, *, job_ids: list[str], **kwargs) -> str:
         raise NotImplementedError("Implement in child class.")
 
-    def _is_squeue_error_recoverable(self, exception: BaseException) -> True:
+    def _is_squeue_error_recoverable(
+        self, exception: BaseException
+    ) -> Literal[True]:
         """
         Determine whether a `squeue` error is considered recoverable.
 
@@ -262,14 +264,25 @@ class BaseSlurmRunner(BaseRunner):
 
         return new_slurm_config
 
-    def _submit_single_sbatch(
+    def _prepare_single_slurm_job(
         self,
         *,
         base_command: str,
         slurm_job: SlurmJob,
         slurm_config: SlurmConfig,
     ) -> str:
-        logger.debug("[_submit_single_sbatch] START")
+        """
+        Prepare submission script locally.
+
+        Args:
+            base_command: Base of task executable command.
+            slurm_job: `SlurmJob` object
+            slurm_config: Configuration for SLURM job
+
+        Returns:
+            Command to submit the SLURM job.
+        """
+        logger.debug("[_prepare_single_slurm_job] START")
 
         for task in slurm_job.tasks:
             # Write input file
@@ -299,24 +312,10 @@ class BaseSlurmRunner(BaseRunner):
                 json.dump(task.parameters, f, indent=2)
 
             logger.debug(
-                "[_submit_single_sbatch] Written " f"{task.input_file_local=}"
+                "[_prepare_single_slurm_job] Written "
+                f"{task.input_file_local=}"
             )
 
-            if self.slurm_runner_type == "ssh":
-                # Send input file (only relevant for SSH)
-                self.fractal_ssh.send_file(
-                    local=task.input_file_local,
-                    remote=task.input_file_remote,
-                )
-                self.fractal_ssh.send_file(
-                    local=task.task_files.args_file_local,
-                    remote=task.task_files.args_file_remote,
-                )
-                logger.debug(
-                    "[_submit_single_sbatch] Transferred "
-                    f"{task.input_file_local=}"
-                )
-
         # Prepare commands to be included in SLURM submission script
         cmdlines = []
         for task in slurm_job.tasks:
@@ -353,7 +352,7 @@ class BaseSlurmRunner(BaseRunner):
             ]
         )
         script_lines = slurm_config.sort_script_lines(script_lines)
-        logger.debug(script_lines)
+        logger.debug(f"[_prepare_single_slurm_job] {script_lines=}")
 
         # Always print output of `uname -n` and `pwd`
         script_lines.append('\necho "Hostname: $(uname -n)"')
@@ -373,61 +372,64 @@ class BaseSlurmRunner(BaseRunner):
                 f"--mem={mem_per_task_MB}MB "
                 f"{cmd} &"
             )
-        script_lines.append("wait\n")
-        script = "\n".join(script_lines)
+        script_lines.append("wait\n\n")
         script_lines.append(
             'echo "End time:   $(date +"%Y-%m-%dT%H:%M:%S%z")"'
         )
+        script = "\n".join(script_lines)
 
         # Write submission script
         with open(slurm_job.slurm_submission_script_local, "w") as f:
             f.write(script)
         logger.debug(
-            "[_submit_single_sbatch] Written "
+            "[_prepare_single_slurm_job] Written "
             f"{slurm_job.slurm_submission_script_local=}"
         )
 
         if self.slurm_runner_type == "ssh":
-            self.fractal_ssh.send_file(
-                local=slurm_job.slurm_submission_script_local,
-                remote=slurm_job.slurm_submission_script_remote,
-            )
             submit_command = (
-                "sbatch --parsable "
-                f"{slurm_job.slurm_submission_script_remote}"
+                f"sbatch --parsable {slurm_job.slurm_submission_script_remote}"
             )
         else:
             submit_command = (
-                "sbatch --parsable "
-                f"{slurm_job.slurm_submission_script_local}"
+                f"sbatch --parsable {slurm_job.slurm_submission_script_local}"
             )
-        # Run sbatch
-        pre_submission_cmds = slurm_config.pre_submission_commands
-        if len(pre_submission_cmds) == 0:
-            logger.debug(f"Now run {submit_command=}")
-            sbatch_stdout = self._run_remote_cmd(submit_command)
-        else:
-            logger.debug(f"Now using {pre_submission_cmds=}")
-            script_lines = pre_submission_cmds + [submit_command]
-            wrapper_script_contents = "\n".join(script_lines)
-            wrapper_script_contents = f"{wrapper_script_contents}\n"
-            if self.slurm_runner_type == "ssh":
-                wrapper_script = (
-                    f"{slurm_job.slurm_submission_script_remote}_wrapper.sh"
-                )
-                self.fractal_ssh.write_remote_file(
-                    path=wrapper_script, content=wrapper_script_contents
-                )
-            else:
-                wrapper_script = (
-                    f"{slurm_job.slurm_submission_script_local}_wrapper.sh"
-                )
-                with open(wrapper_script, "w") as f:
-                    f.write(wrapper_script_contents)
-            logger.debug(f"Now run {wrapper_script=}")
-            sbatch_stdout = self._run_remote_cmd(f"bash {wrapper_script}")
+        logger.debug("[_prepare_single_slurm_job] END")
+        return submit_command
+
+    def _send_many_job_inputs(
+        self, *, workdir_local: Path, workdir_remote: Path
+    ) -> None:
+        """
+        Placeholder method.
+
+        This method is intentionally left unimplemented in the base class.
+        Subclasses must override it to provide the logic for transferring
+        input data.
+        """
+        pass
+
+    def _submit_single_sbatch(
+        self,
+        *,
+        submit_command: str,
+        slurm_job: SlurmJob,
+    ) -> None:
+        """
+        Run `sbatch` and add the `slurm_job` to `self.jobs`.
+
+        Args:
+            submit_command:
+                The SLURM submission command prepared in
+                `self._prepare_single_slurm_job`.
+            slurm_job: The `SlurmJob` object.
+        """
+
+        logger.debug("[_submit_single_sbatch] START")
 
         # Submit SLURM job and retrieve job ID
+        logger.debug(f"[_submit_single_sbatch] Now run {submit_command=}")
+        sbatch_stdout = self._run_remote_cmd(submit_command)
         logger.info(f"[_submit_single_sbatch] {sbatch_stdout=}")
         stdout = sbatch_stdout.strip("\n")
         submitted_job_id = int(stdout)
@@ -623,11 +625,19 @@ class BaseSlurmRunner(BaseRunner):
             )
 
             config.parallel_tasks_per_job = 1
-            self._submit_single_sbatch(
+            submit_command = self._prepare_single_slurm_job(
                 base_command=base_command,
                 slurm_job=slurm_job,
                 slurm_config=config,
             )
+            self._send_many_job_inputs(
+                workdir_local=workdir_local,
+                workdir_remote=workdir_remote,
+            )
+            self._submit_single_sbatch(
+                submit_command=submit_command,
+                slurm_job=slurm_job,
+            )
             logger.debug(f"[submit] END submission phase, {self.job_ids=}")
 
             create_accounting_record_slurm(
@@ -726,8 +736,8 @@ class BaseSlurmRunner(BaseRunner):
                             status=HistoryUnitStatus.FAILED,
                             db_sync=db,
                         )
-                results = {}
-                exceptions = {
+                results: dict[int, Any] = {}
+                exceptions: dict[int, BaseException] = {
                     ind: SHUTDOWN_EXCEPTION
                     for ind in range(len(list_parameters))
                 }
@@ -801,13 +811,25 @@ class BaseSlurmRunner(BaseRunner):
                     )
                 )
 
-            # NOTE: see issue 2431
-            logger.debug("[multisubmit] Transfer files and submit jobs.")
+            submit_commands = []
             for slurm_job in jobs_to_submit:
+                submit_commands.append(
+                    self._prepare_single_slurm_job(
+                        base_command=base_command,
+                        slurm_job=slurm_job,
+                        slurm_config=config,
+                    )
+                )
+            self._send_many_job_inputs(
+                workdir_local=workdir_local,
+                workdir_remote=workdir_remote,
+            )
+            for slurm_job, submit_command in zip(
+                jobs_to_submit, submit_commands
+            ):
                 self._submit_single_sbatch(
-                    base_command=base_command,
+                    submit_command=submit_command,
                     slurm_job=slurm_job,
-                    slurm_config=config,
                 )
 
             logger.info(f"[multisubmit] END submission phase, {self.job_ids=}")
@@ -830,8 +852,10 @@ class BaseSlurmRunner(BaseRunner):
                         status=HistoryUnitStatus.FAILED,
                         db_sync=db,
                     )
-            results = {}
-            exceptions = {ind: e for ind in range(len(list_parameters))}
+            results: dict[int, Any] = {}
+            exceptions: dict[int, BaseException] = {
+                ind: e for ind in range(len(list_parameters))
+            }
             return results, exceptions
 
         # Retrieval phase

fractal_server/app/runner/executors/slurm_ssh/runner.py

@@ -166,12 +166,69 @@ class SlurmSSHRunner(BaseSlurmRunner):
         stdout = self.fractal_ssh.run_command(cmd=cmd)
         return stdout
 
+    def _send_many_job_inputs(
+        self, *, workdir_local: Path, workdir_remote: Path
+    ) -> None:
+        """
+        Compress, transfer, and extract a local working directory onto a remote
+        host.
+
+        This method creates a temporary `.tar.gz` archive of the given
+        `workdir_local`, transfers it to the remote machine via the configured
+        SSH connection, extracts it into `workdir_remote`, and removes the
+        temporary archive from both local and remote filesystems.
+        """
+
+        logger.debug("[_send_many_job_inputs] START")
+
+        tar_path_local = workdir_local.with_suffix(".tar.gz")
+        tar_name = Path(tar_path_local).name
+        tar_path_remote = workdir_remote.parent / tar_name
+
+        tar_compression_cmd = get_tar_compression_cmd(
+            subfolder_path=workdir_local, filelist_path=None
+        )
+        _, tar_extraction_cmd = get_tar_extraction_cmd(
+            archive_path=tar_path_remote
+        )
+        rm_tar_cmd = f"rm {tar_path_remote.as_posix()}"
+
+        try:
+            run_subprocess(tar_compression_cmd, logger_name=logger.name)
+            logger.debug(
+                "[_send_many_job_inputs] "
+                f"{workdir_local=} compressed to {tar_path_local=}."
+            )
+            self.fractal_ssh.send_file(
+                local=tar_path_local.as_posix(),
+                remote=tar_path_remote.as_posix(),
+            )
+            logger.debug(
+                "[_send_many_job_inputs] "
+                f"{tar_path_local=} sent via SSH to {tar_path_remote=}."
+            )
+            self.fractal_ssh.run_command(cmd=tar_extraction_cmd)
+            logger.debug(
+                "[_send_many_job_inputs] "
+                f"{tar_path_remote=} extracted to {workdir_remote=}."
+            )
+            self.fractal_ssh.run_command(cmd=rm_tar_cmd)
+            logger.debug(
+                "[_send_many_job_inputs] "
+                f"{tar_path_remote=} removed from remote server."
+            )
+        except Exception as e:
+            raise e
+        finally:
+            Path(tar_path_local).unlink(missing_ok=True)
+            logger.debug(f"[_send_many_job_inputs] {tar_path_local=} removed.")
+
+        logger.debug("[_send_many_job_inputs] END.")
+
     def run_squeue(
         self,
         *,
         job_ids: list[str],
-        base_interval: float = 2.0,
-        max_attempts: int = 7,
     ) -> str:
         """
         Run `squeue` for a set of SLURM job IDs.
@@ -205,8 +262,6 @@ class SlurmSSHRunner(BaseSlurmRunner):
         try:
             stdout = self.fractal_ssh.run_command(
                 cmd=cmd,
-                base_interval=base_interval,
-                max_attempts=max_attempts,
             )
             return stdout
         except FractalSSHCommandError as e:

fractal_server/app/runner/executors/slurm_sudo/runner.py

@@ -167,7 +167,7 @@ class SudoSlurmRunner(BaseSlurmRunner):
         )
         return res.stdout
 
-    def run_squeue(self, job_ids: list[str]) -> str:
+    def run_squeue(self, *, job_ids: list[str]) -> str:
         """
         Run `squeue` for a set of SLURM job IDs.
         """

fractal_server/app/runner/v2/runner.py

@@ -47,7 +47,7 @@ def _remove_status_from_attributes(
     Drop attribute `IMAGE_STATUS_KEY` from all images.
     """
     images_copy = deepcopy(images)
-    [img["attributes"].pop(IMAGE_STATUS_KEY) for img in images_copy]
+    [img["attributes"].pop(IMAGE_STATUS_KEY, None) for img in images_copy]
     return images_copy
 
 

fractal_server/config.py

@@ -66,37 +66,74 @@ class MailSettings(BaseModel):
 
 class PixiSettings(BaseModel):
     """
-    Configuration for Pixi task collection
-
-    See https://pixi.sh/latest/reference/cli/pixi/install/#config-options for
-    `pixi install` concurrency options.
-    See https://docs.rs/tokio/latest/tokio/#cpu-bound-tasks-and-blocking-code
-    for `tokio` configuration.
-
-    versions:
-        Available `pixi` versions and their `PIXI_HOME` folders.
-    default_version:
-        Default `pixi` version to use for task collection - must be one
-        of `versions` keys.
-    PIXI_CONCURRENT_SOLVES:
-        Value of `--concurrent-solves` for `pixi install`.
-    PIXI_CONCURRENT_DOWNLOADS:
-        Value of `--concurrent-downloads for `pixi install`.
-    TOKIO_WORKER_THREADS:
-        From tokio docs, "The core threads are where all asynchronous code
-        runs, and Tokio will by default spawn one for each CPU core. You can
-        use the environment variable TOKIO_WORKER_THREADS to override the
-        default value."
+    Configuration for Pixi Task collection.
+
+    In order to use Pixi for Task collection, you must have one or more Pixi
+    binaries in your machine
+    (see
+    [example/get_pixi.sh](https://github.com/fractal-analytics-platform/fractal-server/blob/main/example/get_pixi.sh)
+    for installation example).
+
+    To let Fractal Server use these binaries for Task collection, a JSON file
+    must be prepared with the data to populate `PixiSettings` (arguments with
+    default values may be omitted).
+
+    The path to this JSON file must then be provided to Fractal via the
+    environment variable `FRACTAL_PIXI_CONFIG_FILE`.
     """
 
     versions: DictStrStr
+    """
+    A dictionary with Pixi versions as keys and paths to the corresponding
+    folder as values.
+
+    E.g. let's assume that you have Pixi v0.47.0 at
+    `/pixi-path/0.47.0/bin/pixi` and Pixi v0.48.2 at
+    `/pixi-path/0.48.2/bin/pixi`, then
+    ```json
+    "versions": {
+        "0.47.0": "/pixi-path/0.47.0",
+        "0.48.2": "/pixi-path/0.48.2"
+    }
+    ```
+    """
     default_version: str
+    """
+    Default Pixi version to be used for Task collection.
 
+    Must be a key of the `versions` dictionary.
+    """
     PIXI_CONCURRENT_SOLVES: int = 4
+    """
+    Value of
+    [`--concurrent-solves`](https://pixi.sh/latest/reference/cli/pixi/install/#arg---concurrent-solves)
+    for `pixi install`.
+    """
     PIXI_CONCURRENT_DOWNLOADS: int = 4
+    """
+    Value of
+    [`--concurrent-downloads`](https://pixi.sh/latest/reference/cli/pixi/install/#arg---concurrent-downloads)
+    for `pixi install`.
+    """
     TOKIO_WORKER_THREADS: int = 2
+    """
+    From
+    [Tokio documentation](
+    https://docs.rs/tokio/latest/tokio/#cpu-bound-tasks-and-blocking-code
+    )
+    :
+
+        The core threads are where all asynchronous code runs,
+        and Tokio will by default spawn one for each CPU core.
+        You can use the environment variable `TOKIO_WORKER_THREADS` to override
+        the default value.
+    """
     DEFAULT_ENVIRONMENT: str = "default"
+    """
+    """
     DEFAULT_PLATFORM: str = "linux-64"
+    """
+    """
 
     @model_validator(mode="after")
     def check_pixi_settings(self):
@@ -542,7 +579,7 @@ class Settings(BaseSettings):
         else:
             return "--no-cache-dir"
 
-    FRACTAL_MAX_PIP_VERSION: str = "24.0"
+    FRACTAL_MAX_PIP_VERSION: str = "25.2"
     """
     Maximum value at which to update `pip` before performing task collection.
     """
@@ -578,6 +615,9 @@ class Settings(BaseSettings):
     """
 
     FRACTAL_PIXI_CONFIG_FILE: Path | None = None
+    """
+    Path to the Pixi configuration JSON file that will populate `PixiSettings`.
+    """
 
     pixi: PixiSettings | None = None
 

fractal_server/ssh/_fabric.py

@@ -3,6 +3,7 @@ import logging
 import time
 from collections.abc import Generator
 from contextlib import contextmanager
+from functools import wraps
 from pathlib import Path
 from threading import Lock
 from typing import Any
@@ -44,6 +45,32 @@ class SSHConfig(BaseModel):
 logger = set_logger(__name__)
 
 
+def retry_if_socket_error(func):
+    @wraps(func)
+    def func_with_retry(*args, **kwargs):
+        self = args[0]
+        try:
+            return func(*args, **kwargs)
+        except NoValidConnectionsError as e:
+            self.logger.warning(
+                f"Socket error type: {e.__class__.__name__}, {e}"
+            )
+            self.logger.warning("Now refresh connection")
+            self.refresh_connection()
+            self.logger.warning(f"Now retry {func.__name__}")
+            return func(*args, **kwargs)
+        except OSError as e:
+            self.logger.warning(f"Something goes wrong,{e}")
+            if "Socket is closed" in str(e):
+                self.logger.warning("Now refresh connection")
+                self.refresh_connection()
+                self.logger.warning(f"Now retry {func.__name__}")
+                return func(*args, **kwargs)
+            raise e
+
+    return func_with_retry
+
+
 @contextmanager
 def _acquire_lock_with_timeout(
     lock: Lock,
@@ -92,8 +119,6 @@ class FractalSSH:
         _lock:
         _connection:
         default_lock_timeout:
-        default_max_attempts:
-        default_base_interval:
         sftp_get_prefetch:
         sftp_get_max_requests:
         logger_name:
@@ -102,8 +127,6 @@ class FractalSSH:
     _lock: Lock
     _connection: Connection
     default_lock_timeout: float
-    default_max_attempts: int
-    default_base_interval: float
     sftp_get_prefetch: bool
     sftp_get_max_requests: int
     logger_name: str
@@ -112,8 +135,6 @@ class FractalSSH:
         self,
         connection: Connection,
         default_timeout: float = 250,
-        default_max_attempts: int = 5,
-        default_base_interval: float = 3.0,
         sftp_get_prefetch: bool = False,
         sftp_get_max_requests: int = 64,
         logger_name: str = __name__,
@@ -121,8 +142,6 @@ class FractalSSH:
         self._lock = Lock()
         self._connection = connection
         self.default_lock_timeout = default_timeout
-        self.default_base_interval = default_base_interval
-        self.default_max_attempts = default_max_attempts
         self.sftp_get_prefetch = sftp_get_prefetch
         self.sftp_get_max_requests = sftp_get_max_requests
         self.logger_name = logger_name
@@ -188,6 +207,7 @@ class FractalSSH:
         """
         return self._connection.sftp()
 
+    @retry_if_socket_error
     def read_remote_json_file(self, filepath: str) -> dict[str, Any]:
         self.logger.info(f"START reading remote JSON file {filepath}.")
         with _acquire_lock_with_timeout(
@@ -208,6 +228,7 @@ class FractalSSH:
         self.logger.info(f"END reading remote JSON file {filepath}.")
         return data
 
+    @retry_if_socket_error
     def read_remote_text_file(self, filepath: str) -> dict[str, Any]:
         """
         Read a remote text file into a string.
@@ -270,6 +291,9 @@ class FractalSSH:
                 )
         # Try opening the connection (if it was closed) or to re-open it (if
         # an error happened).
+        self.refresh_connection()
+
+    def refresh_connection(self) -> None:
         try:
             self.close()
             with _acquire_lock_with_timeout(
@@ -307,13 +331,12 @@ class FractalSSH:
             if self._connection.client is not None:
                 self._connection.client.close()
 
+    @retry_if_socket_error
     def run_command(
         self,
         *,
         cmd: str,
         allow_char: str | None = None,
-        max_attempts: int | None = None,
-        base_interval: float | None = None,
         lock_timeout: int | None = None,
     ) -> str:
         """
@@ -332,81 +355,50 @@ class FractalSSH:
 
         validate_cmd(cmd, allow_char=allow_char)
 
-        actual_max_attempts = self.default_max_attempts
-        if max_attempts is not None:
-            actual_max_attempts = max_attempts
-
-        actual_base_interval = self.default_base_interval
-        if base_interval is not None:
-            actual_base_interval = base_interval
-
         actual_lock_timeout = self.default_lock_timeout
         if lock_timeout is not None:
             actual_lock_timeout = lock_timeout
 
         t_0 = time.perf_counter()
-        ind_attempt = 0
-        while ind_attempt <= actual_max_attempts:
-            ind_attempt += 1
-            prefix = f"[attempt {ind_attempt}/{actual_max_attempts}]"
-            self.logger.info(f"{prefix} START running '{cmd}' over SSH.")
-            try:
-                # Case 1: Command runs successfully
-                res = self._run(
-                    cmd,
-                    label=f"run {cmd}",
-                    lock_timeout=actual_lock_timeout,
-                    hide=True,
-                    in_stream=False,
-                )
-                t_1 = time.perf_counter()
-                self.logger.info(
-                    f"{prefix} END   running '{cmd}' over SSH, "
-                    f"elapsed={t_1 - t_0:.3f}"
-                )
-                self.logger.debug("STDOUT:")
-                self.logger.debug(res.stdout)
-                self.logger.debug("STDERR:")
-                self.logger.debug(res.stderr)
-                return res.stdout
-            except NoValidConnectionsError as e:
-                # Case 2: Command fails with a connection error
-                self.logger.warning(
-                    f"{prefix} Running command `{cmd}` over SSH failed.\n"
-                    f"Original NoValidConnectionError:\n{str(e)}.\n"
-                    f"{e.errors=}\n"
-                )
-                if ind_attempt < actual_max_attempts:
-                    sleeptime = actual_base_interval**ind_attempt
-                    self.logger.warning(
-                        f"{prefix} Now sleep {sleeptime:.3f} "
-                        "seconds and retry."
-                    )
-                    time.sleep(sleeptime)
-                else:
-                    self.logger.error(f"{prefix} Reached last attempt")
-                    raise FractalSSHConnectionError(
-                        f"Reached last attempt "
-                        f"({max_attempts=}) for running "
-                        f"'{cmd}' over SSH"
-                    )
-            except UnexpectedExit as e:
-                # Case 3: Command fails with an actual error
-                error_msg = (
-                    f"{prefix} Running command `{cmd}` over SSH failed.\n"
-                    f"Original error:\n{str(e)}."
-                )
-                self.logger.error(error_msg)
-                raise FractalSSHCommandError(error_msg)
-            except FractalSSHTimeoutError as e:
-                raise e
-            except Exception as e:
-                self.logger.error(
-                    f"Running command `{cmd}` over SSH failed.\n"
-                    f"Original Error:\n{str(e)}."
-                )
-                raise FractalSSHUnknownError(f"{type(e)}: {str(e)}")
+        try:
+            # Case 1: Command runs successfully
+            res = self._run(
+                cmd,
+                label=f"run {cmd}",
+                lock_timeout=actual_lock_timeout,
+                hide=True,
+                in_stream=False,
+            )
+            t_1 = time.perf_counter()
+            self.logger.info(
+                f"END   running '{cmd}' over SSH, " f"elapsed={t_1 - t_0:.3f}"
+            )
+            self.logger.debug("STDOUT:")
+            self.logger.debug(res.stdout)
+            self.logger.debug("STDERR:")
+            self.logger.debug(res.stderr)
+            return res.stdout
+        # Case 2: Command fails with a connection error
+        except NoValidConnectionsError as e:
+            raise NoValidConnectionsError(errors=e.errors)
+        except UnexpectedExit as e:
+            # Case 3: Command fails with an actual error
+            error_msg = (
+                f"Running command `{cmd}` over SSH failed.\n"
+                f"Original error:\n{str(e)}."
+            )
+            self.logger.error(error_msg)
+            raise FractalSSHCommandError(error_msg)
+        except FractalSSHTimeoutError as e:
+            raise e
+        except Exception as e:
+            self.logger.error(
+                f"Running command `{cmd}` over SSH failed.\n"
+                f"Original Error:\n{str(e)}."
+            )
+            raise FractalSSHUnknownError(f"{type(e)}: {str(e)}")
 
+    @retry_if_socket_error
     def send_file(
         self,
         *,
@@ -447,6 +439,7 @@ class FractalSSH:
                 ),
             )
 
+    @retry_if_socket_error
     def fetch_file(
         self,
         *,
@@ -538,6 +531,7 @@ class FractalSSH:
             cmd = f"rm -r {folder}"
             self.run_command(cmd=cmd)
 
+    @retry_if_socket_error
     def write_remote_file(
         self,
         *,
@@ -574,6 +568,7 @@ class FractalSSH:
         elapsed = time.perf_counter() - t_start
         self.logger.info(f"[write_remote_file] END, {elapsed=} s ({path}).")
 
+    @retry_if_socket_error
     def remote_exists(self, path: str) -> bool:
         """
         Return whether a remote file/folder exists

{fractal_server-2.15.7.dist-info → fractal_server-2.15.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fractal-server
-Version: 2.15.7
+Version: 2.15.8
 Summary: Backend component of the Fractal analytics platform
 License: BSD-3-Clause
 Author: Tommaso Comparin

{fractal_server-2.15.7.dist-info → fractal_server-2.15.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fractal_server/__init__.py,sha256=SIpD8yvbZydQsQo0H2fClLPf0pyYpjeHjRBmNRTNLKk,23
+fractal_server/__init__.py,sha256=eybsCSXKOGknxAUjcGaSuqucfMoHoV6kgH5_eHJcYyQ,23
 fractal_server/__main__.py,sha256=rkM8xjY1KeS3l63irB8yCrlVobR-73uDapC4wvrIlxI,6957
 fractal_server/alembic.ini,sha256=MWwi7GzjzawI9cCAK1LW7NxIBQDUqD12-ptJoq5JpP0,3153
 fractal_server/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -6,7 +6,7 @@ fractal_server/app/db/__init__.py,sha256=U2gwpNyy79iMsK1lg43LRl9z-MW8wiOaICJ7GGd
 fractal_server/app/models/__init__.py,sha256=xJWiGAwpXmCpnFMC4c_HTqoUCzMOXrakoGLUH_uMvdA,415
 fractal_server/app/models/linkusergroup.py,sha256=3KkkE4QIUAlTrBAZs_tVy0pGvAxUAq6yOEjflct_z2M,678
 fractal_server/app/models/linkuserproject.py,sha256=hvaxh3Lkiy2uUCwB8gvn8RorCpvxSSdzWdCS_U1GL7g,315
-fractal_server/app/models/security.py,sha256=NfR0I4dRbOEmCWOKeEHyFO-uqhSJ11dS0B6yWtZRqs4,3852
+fractal_server/app/models/security.py,sha256=bwye5cLPUq4R2ArC2KKvUhi_XQtgliM7a-t5Ofnk_rw,3826
 fractal_server/app/models/user_settings.py,sha256=WdnrLOP2w8Nqh_3K-4-b-8a7XEC9ILrE6SfbYoTk-7Y,1279
 fractal_server/app/models/v2/__init__.py,sha256=vjHwek7-IXmaZZL9VF0nD30YL9ca4wNc8P4RXJK_kDc,832
 fractal_server/app/models/v2/accounting.py,sha256=i-2TsjqyuclxFQ21C-TeDoss7ZBTRuXdzIJfVr2UxwE,1081
@@ -23,17 +23,17 @@ fractal_server/app/routes/admin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 fractal_server/app/routes/admin/v2/__init__.py,sha256=_5lqb6-M8-fZqE1HRMep6pAFYRUKMxrvbZOKs-RXWkw,933
 fractal_server/app/routes/admin/v2/accounting.py,sha256=-eLzBirENvdhjhrCf6bs1pTriIui19DAr_k-zuJB7Y8,3593
 fractal_server/app/routes/admin/v2/impersonate.py,sha256=gc4lshfEPFR6W2asH7aKu6hqE6chzusdhAUVV9p51eU,1131
-fractal_server/app/routes/admin/v2/job.py,sha256=ysfrmsaLUwdo3_YbXOhh6j2zZqKrj5dF2s4gJf1ngtQ,8604
+fractal_server/app/routes/admin/v2/job.py,sha256=NJwAecyiQDRwLEqg1fKQsllxW1FdtbwnLJQHocBQinU,8597
 fractal_server/app/routes/admin/v2/project.py,sha256=MA_LdoEuSuisSGRO43TapMuJ080y5iaUGSAUgKuuKOg,1188
 fractal_server/app/routes/admin/v2/task.py,sha256=8njjq_zcvNW-Ewxn7WfsRQbs_aV5h-7pgcRIAegzTnc,4308
 fractal_server/app/routes/admin/v2/task_group.py,sha256=JUCxKnwSNmOKyh6lpqfG5jT5BuRE_U2X6HqD5VVhWPg,7096
-fractal_server/app/routes/admin/v2/task_group_lifecycle.py,sha256=2J3M9VXWD_0j9jRTZ5APuUXl9E-aVv0qF8K02vvcO3s,9150
+fractal_server/app/routes/admin/v2/task_group_lifecycle.py,sha256=qHQbSD7EKSOLvt4KigbXIb2iJmI9sAEGROSrMS8Vwfg,9108
 fractal_server/app/routes/api/__init__.py,sha256=B8l6PSAhR10iZqHEiyTat-_0tkeKdrCigIE6DJGP5b8,638
 fractal_server/app/routes/api/v2/__init__.py,sha256=D3sRRsqkmZO6kBxUjg40q0aRDsnuXI4sOOfn0xF9JsM,2820
 fractal_server/app/routes/api/v2/_aux_functions.py,sha256=tfnxqbufKqd5dbFUzOFlRPc9EgURhpNa5V2V4agzndg,14259
 fractal_server/app/routes/api/v2/_aux_functions_history.py,sha256=ykTyiY3H-nGSgGfcVkb2xQqJd65YOY2aWVK9sfqTdIY,4439
 fractal_server/app/routes/api/v2/_aux_functions_task_lifecycle.py,sha256=GpKfw9yj01LmOAuNMTOreU1PFkCKpjK5oCt7_wp35-A,6741
-fractal_server/app/routes/api/v2/_aux_functions_task_version_update.py,sha256=WLDOYCnb6fnS5avKflyx6yN24Vo1n5kJk5ZyiKbzb8Y,1175
+fractal_server/app/routes/api/v2/_aux_functions_task_version_update.py,sha256=PKjV7r8YsPRXoNiVSnOK4KBYVV3l_Yb_ZPrqAkMkXrQ,1182
 fractal_server/app/routes/api/v2/_aux_functions_tasks.py,sha256=sjlhv6LliDvhttVTjC2xhIFO-Vj3roE3bEv7_TZ1h0A,12494
 fractal_server/app/routes/api/v2/_aux_task_group_disambiguation.py,sha256=8x1_q9FyCzItnPmdSdLQuwUTy4B9xCsXscp97_lJcpM,4635
 fractal_server/app/routes/api/v2/dataset.py,sha256=6u4MFqJ3YZ0Zq6Xx8CRMrTPKW55ZaR63Uno21DqFr4Q,8889
@@ -43,13 +43,13 @@ fractal_server/app/routes/api/v2/job.py,sha256=8xRTwh_OCHmK9IfI_zUASa2ozewR0qu0z
 fractal_server/app/routes/api/v2/pre_submission_checks.py,sha256=AEN6w2X5kCkSpZydudvuTPhl_VZUQ4zUav6D3NiF6r8,4935
 fractal_server/app/routes/api/v2/project.py,sha256=ldMEyjtwGpX2teu85sCNWaubDFlw-En8U1SA7G1VaIw,4567
 fractal_server/app/routes/api/v2/status_legacy.py,sha256=ZckHeBy8y21cyQ_OLY-VmkapzMhd3g9ae-qg-r4-uVo,6317
-fractal_server/app/routes/api/v2/submit.py,sha256=3RPfpuMWEp-orB6iUQCQYmxXu9nRC0m1V5-dznsDrks,8780
-fractal_server/app/routes/api/v2/task.py,sha256=ptS47XtxnHzk9bPNZV24Wfroo5sP19RE0-LsfX0ZvOc,7018
+fractal_server/app/routes/api/v2/submit.py,sha256=C9cLecHoVl_VXQFAHs2Y2LVE6S_v2PHpa-w5XQIaT-M,9174
+fractal_server/app/routes/api/v2/task.py,sha256=WxkWRw-0fJkgmMt9fSDc6oikBFd6nSS-JdPwR0z24tg,7024
 fractal_server/app/routes/api/v2/task_collection.py,sha256=UcS7tb9RjiDimeI-iWwD0wqnXYQEdEZT56PnPa0zC9Q,12233
 fractal_server/app/routes/api/v2/task_collection_custom.py,sha256=j-vI1_FjoxU59VwkwUTYW5HhMVB5NObMkWLCjAKbers,6726
 fractal_server/app/routes/api/v2/task_collection_pixi.py,sha256=1rCBfKANT9zcKcOVMQTByVpP8GjdrzeaMzyQT05k0nY,7517
 fractal_server/app/routes/api/v2/task_group.py,sha256=DrXMc0D7IYqUsrlrpF5JO1zVKvx7RPdKPPOhz3FqqJE,9203
-fractal_server/app/routes/api/v2/task_group_lifecycle.py,sha256=itsldN_aYT_-wuCmwAoVKbH8D6eZpL_z89gCBZDM5cg,9996
+fractal_server/app/routes/api/v2/task_group_lifecycle.py,sha256=9EF5o8ASGa-hMpL_PLekDNp1uOnJ13SM7x9YmSSLAbM,10004
 fractal_server/app/routes/api/v2/task_version_update.py,sha256=RoeN21kYvBwc8xLcJZ8t0hZtl32P3FhMqiofntHyrjQ,8233
 fractal_server/app/routes/api/v2/workflow.py,sha256=n0sRsDHGrjDAoo_0klqoYW4AuZ1LajWtlzEd6gKmvps,10697
 fractal_server/app/routes/api/v2/workflow_import.py,sha256=kOGDaCj0jCGK1WSYGbnUjtUg2U1YxUY9UMH-2ilqJg4,9027
@@ -80,18 +80,18 @@ fractal_server/app/runner/executors/local/runner.py,sha256=syJcUYkdKeGYbD33VzuX9
 fractal_server/app/runner/executors/slurm_common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/app/runner/executors/slurm_common/_batching.py,sha256=gbHZIxt90GjUwhB9_UInwVqpX-KdxRQMDeXzUagdL3U,8816
 fractal_server/app/runner/executors/slurm_common/_job_states.py,sha256=nuV-Zba38kDrRESOVB3gaGbrSPZc4q7YGichQaeqTW0,238
-fractal_server/app/runner/executors/slurm_common/_slurm_config.py,sha256=7L80pH2lOe6qAH-8VzmcUOMgA9KJoQLTPDpkonKwhH8,15945
-fractal_server/app/runner/executors/slurm_common/base_slurm_runner.py,sha256=1Sh56lb7NERVtsBMvVs4K7nVHhMy_KDbwquPl1ub8vE,37937
+fractal_server/app/runner/executors/slurm_common/_slurm_config.py,sha256=FI2p4yQ16571C_YM3Vs_tJnb71urVykwxfIXDXa79I8,15721
+fractal_server/app/runner/executors/slurm_common/base_slurm_runner.py,sha256=yWl71_rTp34t9KvB6jjCBQIJPEg-btsWm3oZC7ytRgI,38141
 fractal_server/app/runner/executors/slurm_common/get_slurm_config.py,sha256=KhQQJrGQZLX5u8fsMcIx7FN8jUKSGEeG68yO7Ay_LXg,7454
 fractal_server/app/runner/executors/slurm_common/remote.py,sha256=LHK2Ram8X8q6jNSCxnnwKUwmSJMsyQyRem_VjH53qdw,3811
 fractal_server/app/runner/executors/slurm_common/slurm_job_task_models.py,sha256=K4SdJOKsUWzDlnkb8Ug_UmTx6nBMsTqn9_oKqwE4XDI,3520
 fractal_server/app/runner/executors/slurm_ssh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/app/runner/executors/slurm_ssh/run_subprocess.py,sha256=SyW6t4egvbiARph2YkFjc88Hj94fCamZVi50L7ph8VM,996
-fractal_server/app/runner/executors/slurm_ssh/runner.py,sha256=Hzq01rLgOEzS6UPMzW59d4Ox-wwHlxyPF1KiKcGQvIM,7993
+fractal_server/app/runner/executors/slurm_ssh/runner.py,sha256=3YEE3_CKQWqrgINA7LLn5Xnq510clskTP2KDSTc2orw,10098
 fractal_server/app/runner/executors/slurm_ssh/tar_commands.py,sha256=yqBjWTLmh_FzhCllt_KfbuCUGvRhsHLVWlPOZlRWLzY,1762
 fractal_server/app/runner/executors/slurm_sudo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/app/runner/executors/slurm_sudo/_subprocess_run_as_user.py,sha256=W-FxnVcHxMGpv4zGgJVttVQoweyGgR4uBxO22QIZkp0,2576
-fractal_server/app/runner/executors/slurm_sudo/runner.py,sha256=TGH6B1eRHgHjYjqN86F1V-WNAB_kp-nPo5TJ0FHwigY,5859
+fractal_server/app/runner/executors/slurm_sudo/runner.py,sha256=pb2otlEQIHT9qaN-q0qlUq_BJG4-ozk-P2-C9drHbDU,5862
 fractal_server/app/runner/filenames.py,sha256=lPnxKHtdRizr6FqG3zOdjDPyWA7GoaJGTtiuJV0gA8E,70
 fractal_server/app/runner/set_start_and_last_task_index.py,sha256=NsioSzfEpGyo9ZKrV5KsbxeI7d5V3tE678Y3IAo5rHM,1218
 fractal_server/app/runner/shutdown.py,sha256=ViSNJyXWU_iWPSDOOMGNh_iQdUFrdPh_jvf8vVKLpAo,1950
@@ -103,7 +103,7 @@ fractal_server/app/runner/v2/_slurm_sudo.py,sha256=Gvsh4tUlc1_3KdF3B7zEqs-YIntC_
 fractal_server/app/runner/v2/db_tools.py,sha256=ozp4RFLB3LNI0rM0q0udi6ja8-5vooH_dVqrbmTPNDg,3323
 fractal_server/app/runner/v2/deduplicate_list.py,sha256=IVTE4abBU1bUprFTkxrTfYKnvkNTanWQ-KWh_etiT08,645
 fractal_server/app/runner/v2/merge_outputs.py,sha256=YOTKbGOM9s-uqY4KN2onoIxuHNm-v3hr5zv6Aa1KEtA,905
-fractal_server/app/runner/v2/runner.py,sha256=IsQhSxASVI-yPBO2G2uuVvZkRIoAlSY6Ev7gcSYmDOw,18989
+fractal_server/app/runner/v2/runner.py,sha256=IE7Ups3LqMy4ijV427xugYtEz003xM7UzJD3G8Jw_T4,18995
 fractal_server/app/runner/v2/runner_functions.py,sha256=xteoDSXKxStl3ABEXyjrggPiXdXAPy9sJPfT3B8CQ3Y,19050
 fractal_server/app/runner/v2/submit_workflow.py,sha256=L6WqQC3Vm-tLe_CJXHIMbYLAeulAN2no_4HZD4cbhR0,12554
 fractal_server/app/runner/v2/task_interface.py,sha256=BRSKpitGproY48JQdCbfrghbDonA-EqPP1yIopohpPo,2525
@@ -129,7 +129,7 @@ fractal_server/app/schemas/v2/workflowtask.py,sha256=6eweAMyziwaoMT-7R1fVJYunIeZ
 fractal_server/app/security/__init__.py,sha256=oJ8RVglpOvWPQY4RokiE2YA72Nqo42dZEjywWTt8xr8,14032
 fractal_server/app/security/signup_email.py,sha256=Xd6QYxcdmg0PHpDwmUE8XQmPcOj3Xjy5oROcIMhmltM,1472
 fractal_server/app/user_settings.py,sha256=OP1yiYKtPadxwM51_Q0hdPk3z90TCN4z1BLpQsXyWiU,1316
-fractal_server/config.py,sha256=NQ4wHfxzbd3nlCLbuATimq-5L7OQ2-4Y9MnyX1DEup0,28484
+fractal_server/config.py,sha256=vNaDkzjqOzQMQyNVCWJ9qNMvfXKDuk2L0mMTPGzX79U,29505
 fractal_server/data_migrations/2_14_10.py,sha256=jzMg2c1zNO8C_Nho_9_EZJD6kR1-gkFNpNrMR5Hr8hM,1598
 fractal_server/data_migrations/README.md,sha256=_3AEFvDg9YkybDqCLlFPdDmGJvr6Tw7HRI14aZ3LOIw,398
 fractal_server/data_migrations/tools.py,sha256=LeMeASwYGtEqd-3wOLle6WARdTGAimoyMmRbbJl-hAM,572
@@ -185,7 +185,7 @@ fractal_server/migrations/versions/f384e1c0cf5d_drop_task_default_args_columns.p
 fractal_server/migrations/versions/fbce16ff4e47_new_history_items.py,sha256=TDWCaIoM0Q4SpRWmR9zr_rdp3lJXhCfBPTMhtrP5xYE,3950
 fractal_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/ssh/__init__.py,sha256=sVUmzxf7_DuXG1xoLQ1_00fo5NPhi2LJipSmU5EAkPs,124
-fractal_server/ssh/_fabric.py,sha256=7fCxTYqkAOaTTm67trfYdYQenOsI4EfrRQoG6x3M5kk,25188
+fractal_server/ssh/_fabric.py,sha256=I_94ha3xxVESoa8opuvidcO32E4cJZF1Tow4eXPPc8o,24450
 fractal_server/string_tools.py,sha256=UJFi8rhlI6QXxX5twycLjsvOQ6x4uG7L3JdxEVDhC5A,2592
 fractal_server/syringe.py,sha256=3YJeIALH-wibuJ9R5VMNYUWh7x1-MkWT0SqGcWG5MY8,2795
 fractal_server/tasks/__init__.py,sha256=kadmVUoIghl8s190_Tt-8f-WBqMi8u8oU4Pvw39NHE8,23
@@ -230,8 +230,8 @@ fractal_server/types/validators/_workflow_task_arguments_validators.py,sha256=HL
 fractal_server/urls.py,sha256=QjIKAC1a46bCdiPMu3AlpgFbcv6a4l3ABcd5xz190Og,471
 fractal_server/utils.py,sha256=Vn35lApt1T1J8nc09sAVqd10Cy0sa3dLipcljI-hkuk,2185
 fractal_server/zip_tools.py,sha256=H0w7wS5yE4ebj7hw1_77YQ959dl2c-L0WX6J_ro1TY4,4884
-fractal_server-2.15.7.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
-fractal_server-2.15.7.dist-info/METADATA,sha256=8pzRt84EdeTR6rbYAlgbDw6cC-YErI_N_eBIeGUtvLs,4334
-fractal_server-2.15.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-fractal_server-2.15.7.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
-fractal_server-2.15.7.dist-info/RECORD,,
+fractal_server-2.15.8.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
+fractal_server-2.15.8.dist-info/METADATA,sha256=rCOwXnSjjBclcc6-qtpSeGkHxWtfyaE3Iglq7grOi1Y,4334
+fractal_server-2.15.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+fractal_server-2.15.8.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
+fractal_server-2.15.8.dist-info/RECORD,,