fractal-server 2.13.1__py3-none-any.whl → 2.14.0a0__py3-none-any.whl

fractal_server/app/runner/v2/_local/__init__.py

@@ -1,132 +0,0 @@
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
-#
-# Original authors:
-# Jacopo Nespolo <jacopo.nespolo@exact-lab.it>
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-# Marco Franzon <marco.franzon@exact-lab.it>
-#
-# This file is part of Fractal and was originally developed by eXact lab S.r.l.
-# <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
-# Institute for Biomedical Research and Pelkmans Lab from the University of
-# Zurich.
-"""
-Local Bakend
-
-This backend runs Fractal workflows using `FractalThreadPoolExecutor` (a custom
-version of Python
-[ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor))
-to run tasks in several threads.
-Incidentally, it also represents the reference implementation for a backend.
-"""
-from pathlib import Path
-from typing import Optional
-
-from ....models.v2 import DatasetV2
-from ....models.v2 import WorkflowV2
-from ...set_start_and_last_task_index import set_start_and_last_task_index
-from ..runner import execute_tasks_v2
-from ._submit_setup import _local_submit_setup
-from .executor import FractalThreadPoolExecutor
-from fractal_server.images.models import AttributeFiltersType
-
-
-def process_workflow(
-    *,
-    workflow: WorkflowV2,
-    dataset: DatasetV2,
-    workflow_dir_local: Path,
-    workflow_dir_remote: Optional[Path] = None,
-    first_task_index: Optional[int] = None,
-    last_task_index: Optional[int] = None,
-    logger_name: str,
-    job_attribute_filters: AttributeFiltersType,
-    user_id: int,
-    # Slurm-specific
-    user_cache_dir: Optional[str] = None,
-    slurm_user: Optional[str] = None,
-    slurm_account: Optional[str] = None,
-    worker_init: Optional[str] = None,
-) -> None:
-    """
-    Run a workflow
-
-    This function is responsible for running a workflow on some input data,
-    saving the output and taking care of any exception raised during the run.
-
-    NOTE: This is the `local` backend's public interface, which also works as
-    a reference implementation for other backends.
-
-    Args:
-        workflow:
-            The workflow to be run
-        dataset:
-            Initial dataset.
-        workflow_dir_local:
-            Working directory for this run.
-        workflow_dir_remote:
-            Working directory for this run, on the user side. This argument is
-            present for compatibility with the standard backend interface, but
-            for the `local` backend it cannot be different from
-            `workflow_dir_local`.
-        first_task_index:
-            Positional index of the first task to execute; if `None`, start
-            from `0`.
-        last_task_index:
-            Positional index of the last task to execute; if `None`, proceed
-            until the last task.
-        logger_name: Logger name
-        user_id:
-        slurm_user:
-            Username to impersonate to run the workflow. This argument is
-            present for compatibility with the standard backend interface, but
-            is ignored in the `local` backend.
-        slurm_account:
-            SLURM account to use when running the workflow. This argument is
-            present for compatibility with the standard backend interface, but
-            is ignored in the `local` backend.
-        user_cache_dir:
-            Cache directory of the user who will run the workflow. This
-            argument is present for compatibility with the standard backend
-            interface, but is ignored in the `local` backend.
-        worker_init:
-            Any additional, usually backend specific, information to be passed
-            to the backend executor. This argument is present for compatibility
-            with the standard backend interface, but is ignored in the `local`
-            backend.
-
-    Raises:
-        TaskExecutionError: wrapper for errors raised during tasks' execution
-                            (positive exit codes).
-        JobExecutionError: wrapper for errors raised by the tasks' executors
-                           (negative exit codes).
-    """
-
-    if workflow_dir_remote and (workflow_dir_remote != workflow_dir_local):
-        raise NotImplementedError(
-            "Local backend does not support different directories "
-            f"{workflow_dir_local=} and {workflow_dir_remote=}"
-        )
-
-    # Set values of first_task_index and last_task_index
-    num_tasks = len(workflow.task_list)
-    first_task_index, last_task_index = set_start_and_last_task_index(
-        num_tasks,
-        first_task_index=first_task_index,
-        last_task_index=last_task_index,
-    )
-
-    with FractalThreadPoolExecutor() as executor:
-        execute_tasks_v2(
-            wf_task_list=workflow.task_list[
-                first_task_index : (last_task_index + 1)
-            ],
-            dataset=dataset,
-            executor=executor,
-            workflow_dir_local=workflow_dir_local,
-            workflow_dir_remote=workflow_dir_local,
-            logger_name=logger_name,
-            submit_setup_call=_local_submit_setup,
-            job_attribute_filters=job_attribute_filters,
-            user_id=user_id,
-        )

fractal_server/app/runner/v2/_local/_submit_setup.py

@@ -1,52 +0,0 @@
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
-#
-# Original authors:
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-#
-# This file is part of Fractal and was originally developed by eXact lab S.r.l.
-# <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
-# Institute for Biomedical Research and Pelkmans Lab from the University of
-# Zurich.
-"""
-Submodule to define _local_submit_setup
-"""
-from pathlib import Path
-from typing import Literal
-from typing import Optional
-
-from ....models.v2 import WorkflowTaskV2
-from ._local_config import get_local_backend_config
-
-
-def _local_submit_setup(
-    *,
-    wftask: WorkflowTaskV2,
-    workflow_dir_local: Optional[Path] = None,
-    workflow_dir_remote: Optional[Path] = None,
-    which_type: Literal["non_parallel", "parallel"],
-) -> dict[str, object]:
-    """
-    Collect WorfklowTask-specific configuration parameters from different
-    sources, and inject them for execution.
-
-    Arguments:
-        wftask:
-            WorkflowTask for which the configuration is to be assembled
-        workflow_dir_local:
-            Not used in this function.
-        workflow_dir_remote:
-            Not used in this function.
-
-    Returns:
-        submit_setup_dict:
-            A dictionary that will be passed on to
-            `FractalThreadPoolExecutor.submit` and
-            `FractalThreadPoolExecutor.map`, so as to set extra options.
-    """
-
-    local_backend_config = get_local_backend_config(
-        wftask=wftask, which_type=which_type
-    )
-
-    return dict(local_backend_config=local_backend_config)

fractal_server/app/runner/v2/_local/executor.py

@@ -1,100 +0,0 @@
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
-#
-# Original authors:
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-#
-# This file is part of Fractal and was originally developed by eXact lab S.r.l.
-# <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
-# Institute for Biomedical Research and Pelkmans Lab from the University of
-# Zurich.
-"""
-Custom version of Python
-[ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor)).
-"""
-from concurrent.futures import ThreadPoolExecutor
-from typing import Callable
-from typing import Iterable
-from typing import Optional
-from typing import Sequence
-
-from ._local_config import get_default_local_backend_config
-from ._local_config import LocalBackendConfig
-
-
-class FractalThreadPoolExecutor(ThreadPoolExecutor):
-    """
-    Custom version of
-    [ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor))
-    that overrides the `submit` and `map` methods
-    """
-
-    def submit(
-        self,
-        *args,
-        local_backend_config: Optional[LocalBackendConfig] = None,
-        **kwargs,
-    ):
-        """
-        Compared to the `ThreadPoolExecutor` method, here we accept an addition
-        keyword argument (`local_backend_config`), which is then simply
-        ignored.
-        """
-        return super().submit(*args, **kwargs)
-
-    def map(
-        self,
-        fn: Callable,
-        *iterables: Sequence[Iterable],
-        local_backend_config: Optional[LocalBackendConfig] = None,
-    ):
-        """
-        Custom version of the `Executor.map` method
-
-        The main change with the respect to the original `map` method is that
-        the list of tasks to be executed is split into chunks, and then
-        `super().map` is called (sequentially) on each chunk. The goal of this
-        change is to limit parallelism, e.g. due to limited computational
-        resources.
-
-        Other changes from the `concurrent.futures` `map` method:
-
-        1. Removed `timeout` argument;
-        2. Removed `chunksize`;
-        3. All iterators (both inputs and output ones) are transformed into
-           lists.
-
-        Args:
-            fn: A callable function.
-            iterables: The argument iterables (one iterable per argument of
-                       `fn`).
-           local_backend_config: The backend configuration, needed to extract
-                                 `parallel_tasks_per_job`.
-        """
-
-        # Preliminary check
-        iterable_lengths = [len(it) for it in iterables]
-        if not len(set(iterable_lengths)) == 1:
-            raise ValueError("Iterables have different lengths.")
-
-        # Set total number of arguments
-        n_elements = len(iterables[0])
-
-        # Set parallel_tasks_per_job
-        if local_backend_config is None:
-            local_backend_config = get_default_local_backend_config()
-        parallel_tasks_per_job = local_backend_config.parallel_tasks_per_job
-        if parallel_tasks_per_job is None:
-            parallel_tasks_per_job = n_elements
-
-        # Execute tasks, in chunks of size parallel_tasks_per_job
-        results = []
-        for ind_chunk in range(0, n_elements, parallel_tasks_per_job):
-            chunk_iterables = [
-                it[ind_chunk : ind_chunk + parallel_tasks_per_job]  # noqa
-                for it in iterables
-            ]
-            map_iter = super().map(fn, *chunk_iterables)
-            results.extend(list(map_iter))
-
-        return iter(results)

fractal_server/app/runner/v2/_slurm_sudo/_submit_setup.py

@@ -1,83 +0,0 @@
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
-#
-# Original authors:
-# Jacopo Nespolo <jacopo.nespolo@exact-lab.it>
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-#
-# This file is part of Fractal and was originally developed by eXact lab S.r.l.
-# <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
-# Institute for Biomedical Research and Pelkmans Lab from the University of
-# Zurich.
-"""
-Submodule to define _slurm_submit_setup, which is also the reference
-implementation of `submit_setup_call`.
-"""
-from pathlib import Path
-from typing import Literal
-
-from ...task_files import get_task_file_paths
-from fractal_server.app.models.v2 import WorkflowTaskV2
-from fractal_server.app.runner.v2._slurm_common.get_slurm_config import (
-    get_slurm_config,
-)
-
-
-def _slurm_submit_setup(
-    *,
-    wftask: WorkflowTaskV2,
-    workflow_dir_local: Path,
-    workflow_dir_remote: Path,
-    which_type: Literal["non_parallel", "parallel"],
-) -> dict[str, object]:
-    """
-    Collect WorfklowTask-specific configuration parameters from different
-    sources, and inject them for execution.
-
-    Here goes all the logic for reading attributes from the appropriate sources
-    and transforming them into an appropriate `SlurmConfig` object (encoding
-    SLURM configuration) and `TaskFiles` object (with details e.g. about file
-    paths or filename prefixes).
-
-    For now, this is the reference implementation for the argument
-    `submit_setup_call` of
-    [fractal_server.app.runner.v2.runner][].
-
-    Arguments:
-        wftask:
-            WorkflowTask for which the configuration is to be assembled
-        workflow_dir_local:
-            Server-owned directory to store all task-execution-related relevant
-            files (inputs, outputs, errors, and all meta files related to the
-            job execution). Note: users cannot write directly to this folder.
-        workflow_dir_remote:
-            User-side directory with the same scope as `workflow_dir_local`,
-            and where a user can write.
-
-    Returns:
-        submit_setup_dict:
-            A dictionary that will be passed on to
-            `FractalSlurmExecutor.submit` and `FractalSlurmExecutor.map`, so
-            as to set extra options.
-    """
-
-    # Get SlurmConfig object
-    slurm_config = get_slurm_config(
-        wftask=wftask,
-        which_type=which_type,
-    )
-
-    # Get TaskFiles object
-    task_files = get_task_file_paths(
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
-        task_order=wftask.order,
-        task_name=wftask.task.name,
-    )
-
-    # Prepare and return output dictionary
-    submit_setup_dict = dict(
-        slurm_config=slurm_config,
-        task_files=task_files,
-    )
-    return submit_setup_dict

fractal_server/app/runner/v2/handle_failed_job.py

@@ -1,59 +0,0 @@
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
-#
-# Original authors:
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-# Marco Franzon <marco.franzon@exact-lab.it>
-#
-# This file is part of Fractal and was originally developed by eXact lab S.r.l.
-# <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
-# Institute for Biomedical Research and Pelkmans Lab from the University of
-# Zurich.
-"""
-Helper functions to handle Dataset history.
-"""
-import logging
-
-from sqlalchemy.orm.attributes import flag_modified
-
-from ...models.v2 import DatasetV2
-from ...schemas.v2 import WorkflowTaskStatusTypeV2
-from fractal_server.app.db import get_sync_db
-
-
-def mark_last_wftask_as_failed(
-    dataset_id: int,
-    logger_name: str,
-) -> None:
-    """
-    Edit dataset history, by marking last item as failed.
-
-    Args:
-        dataset: The `DatasetV2` object
-        logger_name: A logger name.
-    """
-
-    logger = logging.getLogger(logger_name)
-    with next(get_sync_db()) as db:
-        db_dataset = db.get(DatasetV2, dataset_id)
-        if len(db_dataset.history) == 0:
-            logger.warning(
-                f"History for {dataset_id=} is empty. Likely reason: the job "
-                "failed before its first task was marked as SUBMITTED. "
-                "Continue."
-            )
-            return
-        workflowtask_id = db_dataset.history[-1]["workflowtask"]["id"]
-        last_item_status = db_dataset.history[-1]["status"]
-        if last_item_status != WorkflowTaskStatusTypeV2.SUBMITTED:
-            logger.warning(
-                "Unexpected branch: "
-                f"Last history item, for {workflowtask_id=}, "
-                f"has status {last_item_status}. Skip."
-            )
-            return
-        logger.info(f"Setting history item for {workflowtask_id=} to failed.")
-        db_dataset.history[-1]["status"] = WorkflowTaskStatusTypeV2.FAILED
-        flag_modified(db_dataset, "history")
-        db.merge(db_dataset)
-        db.commit()