fractal-server 2.13.0__py3-none-any.whl → 2.14.0__py3-none-any.whl

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

@@ -35,80 +35,81 @@ async def replace_workflowtask(
     workflow_id: int,
     workflow_task_id: int,
     task_id: int,
-    replace: Optional[WorkflowTaskReplaceV2] = None,
+    replace: WorkflowTaskReplaceV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> WorkflowTaskReadV2:
 
-    old_workflow_task, workflow = await _get_workflow_task_check_owner(
+    # Get objects from database
+    old_wftask, workflow = await _get_workflow_task_check_owner(
         project_id=project_id,
         workflow_id=workflow_id,
         workflow_task_id=workflow_task_id,
         user_id=user.id,
         db=db,
     )
-
     new_task = await _get_task_read_access(
-        task_id=task_id, user_id=user.id, db=db, require_active=True
+        task_id=task_id,
+        user_id=user.id,
+        db=db,
+        require_active=True,
     )
 
-    if new_task.type != old_workflow_task.task.type:
+    # Preliminary checks
+    EQUIVALENT_TASK_TYPES = [
+        {"non_parallel", "converter_non_parallel"},
+        {"compound", "converter_compound"},
+    ]
+    if (
+        old_wftask.task_type != new_task.type
+        and {old_wftask.task_type, new_task.type} not in EQUIVALENT_TASK_TYPES
+    ):
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
-                f"Cannot replace a Task '{old_workflow_task.task.type}' with a"
-                f"  Task '{new_task.type}'."
+                "Cannot change task type from "
+                f"{old_wftask.task_type} to {new_task.type}."
             ),
         )
 
+    if replace.args_non_parallel is not None and new_task.type == "parallel":
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Cannot set 'args_non_parallel' for parallel task.",
+        )
+    if replace.args_parallel is not None and new_task.type == "non_parallel":
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Cannot set 'args_parallel' for non-parallel task.",
+        )
     _check_type_filters_compatibility(
         task_input_types=new_task.input_types,
-        wftask_type_filters=old_workflow_task.type_filters,
+        wftask_type_filters=old_wftask.type_filters,
     )
 
-    _args_non_parallel = old_workflow_task.args_non_parallel
-    _args_parallel = old_workflow_task.args_parallel
-    if replace is not None:
-        if replace.args_non_parallel is not None:
-            if new_task.type == "parallel":
-                raise HTTPException(
-                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                    detail=(
-                        "Cannot set 'args_non_parallel' "
-                        "when Task is 'parallel'."
-                    ),
-                )
-            else:
-                _args_non_parallel = replace.args_non_parallel
-
-        if replace.args_parallel is not None:
-            if new_task.type == "non_parallel":
-                raise HTTPException(
-                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                    detail=(
-                        "Cannot set 'args_parallel' "
-                        "when Task is 'non_parallel'."
-                    ),
-                )
-            else:
-                _args_parallel = replace.args_parallel
+    # Task arguments
+    if replace.args_non_parallel is None:
+        _args_non_parallel = old_wftask.args_non_parallel
+    else:
+        _args_non_parallel = replace.args_non_parallel
+    if replace.args_parallel is None:
+        _args_parallel = old_wftask.args_parallel
+    else:
+        _args_parallel = replace.args_parallel
 
     # If user's changes to `meta_non_parallel` are compatible with new task,
     # keep them; else, get `meta_non_parallel` from new task
     if (
-        old_workflow_task.meta_non_parallel
-        != old_workflow_task.task.meta_non_parallel
-    ) and (
-        old_workflow_task.task.meta_non_parallel == new_task.meta_non_parallel
-    ):
-        _meta_non_parallel = old_workflow_task.meta_non_parallel
+        old_wftask.meta_non_parallel != old_wftask.task.meta_non_parallel
+    ) and (old_wftask.task.meta_non_parallel == new_task.meta_non_parallel):
+        _meta_non_parallel = old_wftask.meta_non_parallel
     else:
         _meta_non_parallel = new_task.meta_non_parallel
     # Same for `meta_parallel`
-    if (
-        old_workflow_task.meta_parallel != old_workflow_task.task.meta_parallel
-    ) and (old_workflow_task.task.meta_parallel == new_task.meta_parallel):
-        _meta_parallel = old_workflow_task.meta_parallel
+    if (old_wftask.meta_parallel != old_wftask.task.meta_parallel) and (
+        old_wftask.task.meta_parallel == new_task.meta_parallel
+    ):
+        _meta_parallel = old_wftask.meta_parallel
     else:
         _meta_parallel = new_task.meta_parallel
 
@@ -117,7 +118,7 @@ async def replace_workflowtask(
         task_type=new_task.type,
         task=new_task,
         # old-task values
-        type_filters=old_workflow_task.type_filters,
+        type_filters=old_wftask.type_filters,
         # possibly new values
         args_non_parallel=_args_non_parallel,
         args_parallel=_args_parallel,
@@ -125,8 +126,8 @@ async def replace_workflowtask(
         meta_parallel=_meta_parallel,
     )
 
-    workflow_task_order = old_workflow_task.order
-    workflow.task_list.remove(old_workflow_task)
+    workflow_task_order = old_wftask.order
+    workflow.task_list.remove(old_wftask)
     workflow.task_list.insert(workflow_task_order, new_workflow_task)
     await db.commit()
     await db.refresh(new_workflow_task)
@@ -201,8 +202,6 @@ async def create_workflowtask(
         db=db,
     )
 
-    await db.close()
-
     return wftask_db
 
 
@@ -268,7 +267,10 @@ async def update_workflowtask(
                 "parallel."
             ),
         )
-    elif db_wf_task.task_type == "non_parallel" and (
+    elif db_wf_task.task_type in [
+        "non_parallel",
+        "converter_non_parallel",
+    ] and (
         workflow_task_update.args_parallel is not None
         or workflow_task_update.meta_parallel is not None
     ):
@@ -333,6 +335,7 @@ async def delete_workflowtask(
         db=db,
     )
 
+    # Delete WorkflowTask
     await db.delete(db_workflow_task)
     await db.commit()
 

fractal_server/app/routes/auth/group.py

@@ -19,7 +19,6 @@ from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models import UserSettings
-from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.schemas.user_group import UserGroupCreate
 from fractal_server.app.schemas.user_group import UserGroupRead
 from fractal_server.app.schemas.user_group import UserGroupUpdate
@@ -156,21 +155,6 @@ async def delete_single_group(
             ),
         )
 
-    # Cascade operations
-
-    res = await db.execute(
-        select(LinkUserGroup).where(LinkUserGroup.group_id == group_id)
-    )
-    for link in res.scalars().all():
-        await db.delete(link)
-
-    res = await db.execute(
-        select(TaskGroupV2).where(TaskGroupV2.user_group_id == group_id)
-    )
-    for task_group in res.scalars().all():
-        task_group.user_group_id = None
-        db.add(task_group)
-
     # Delete
 
     await db.delete(group)

fractal_server/app/routes/auth/oauth.py

@@ -27,20 +27,22 @@ for client_config in settings.OAUTH_CLIENTS_CONFIG:
         from httpx_oauth.clients.google import GoogleOAuth2
 
         client = GoogleOAuth2(
-            client_config.CLIENT_ID, client_config.CLIENT_SECRET
+            client_config.CLIENT_ID,
+            client_config.CLIENT_SECRET.get_secret_value(),
         )
     elif client_name == "github":
         from httpx_oauth.clients.github import GitHubOAuth2
 
         client = GitHubOAuth2(
-            client_config.CLIENT_ID, client_config.CLIENT_SECRET
+            client_config.CLIENT_ID,
+            client_config.CLIENT_SECRET.get_secret_value(),
         )
     else:
         from httpx_oauth.clients.openid import OpenID
 
         client = OpenID(
             client_config.CLIENT_ID,
-            client_config.CLIENT_SECRET,
+            client_config.CLIENT_SECRET.get_secret_value(),
             client_config.OIDC_CONFIGURATION_ENDPOINT,
         )
 

fractal_server/app/routes/aux/__init__.py

@@ -1,20 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from fastapi import HTTPException
-from fastapi import status
-
-
-def _raise_if_naive_datetime(*timestamps: tuple[Optional[datetime]]) -> None:
-    """
-    Raise 422 if any not-null argument is a naive `datetime` object:
-    https://docs.python.org/3/library/datetime.html#determining-if-an-object-is-aware-or-naive
-    """
-    for timestamp in filter(None, timestamps):
-        if (timestamp.tzinfo is None) or (
-            timestamp.tzinfo.utcoffset(timestamp) is None
-        ):
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"{timestamp=} is naive. You must provide a timezone.",
-            )

fractal_server/app/routes/pagination.py

@@ -0,0 +1,47 @@
+from typing import Generic
+from typing import Optional
+from typing import TypeVar
+
+from fastapi import HTTPException
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import model_validator
+from pydantic import ValidationError
+
+T = TypeVar("T")
+
+
+class PaginationRequest(BaseModel):
+
+    page: int = Field(ge=1)
+    page_size: Optional[int] = Field(ge=1)
+
+    @model_validator(mode="after")
+    def valid_pagination_parameters(self):
+        if self.page_size is None and self.page > 1:
+            raise ValueError(
+                f"page_size is None but page={self.page} is greater than 1."
+            )
+        return self
+
+
+def get_pagination_params(
+    page: int = 1, page_size: Optional[int] = None
+) -> PaginationRequest:
+    try:
+        pagination = PaginationRequest(page=page, page_size=page_size)
+    except ValidationError as e:
+        raise HTTPException(
+            status_code=422,
+            detail=f"Invalid pagination parameters. Original error: '{e}'.",
+        )
+    return pagination
+
+
+class PaginationResponse(BaseModel, Generic[T]):
+
+    current_page: int = Field(ge=1)
+    page_size: int = Field(ge=0)
+    total_count: int = Field(ge=0)
+
+    items: list[T]

fractal_server/app/runner/components.py

@@ -1,5 +1,2 @@
 def _index_to_component(ind: int) -> str:
     return f"{ind:07d}"
-
-
-_COMPONENT_KEY_ = "__FRACTAL_PARALLEL_COMPONENT__"

fractal_server/app/runner/compress_folder.py

@@ -11,8 +11,8 @@ built-in `tarfile` library has to do with performance issues we observed
 when handling files which were just created within a SLURM job, and in the
 context of a CephFS filesystem.
 """
-import shutil
 import sys
+import time
 from pathlib import Path
 
 from fractal_server.app.runner.run_subprocess import run_subprocess
@@ -20,48 +20,66 @@ from fractal_server.logger import get_logger
 from fractal_server.logger import set_logger
 
 
-def copy_subfolder(src: Path, dest: Path, logger_name: str):
+def _copy_subfolder(src: Path, dest: Path, logger_name: str):
+    t_start = time.perf_counter()
     cmd_cp = f"cp -r {src.as_posix()} {dest.as_posix()}"
     logger = get_logger(logger_name=logger_name)
     logger.debug(f"{cmd_cp=}")
     res = run_subprocess(cmd=cmd_cp, logger_name=logger_name)
+    elapsed = time.perf_counter() - t_start
+    logger.debug(f"[_copy_subfolder] END {elapsed=} s ({dest.as_posix()})")
     return res
 
 
-def create_tar_archive(
-    tarfile_path: Path,
+def _create_tar_archive(
+    tarfile_path: str,
     subfolder_path_tmp_copy: Path,
     logger_name: str,
-    remote_to_local: bool,
+    filelist_path: str | None,
 ):
     logger = get_logger(logger_name)
-
-    if remote_to_local:
-        exclude_options = "--exclude *sbatch --exclude *_in_*.pickle "
+    logger.debug(f"[_create_tar_archive] START ({tarfile_path})")
+    t_start = time.perf_counter()
+
+    if filelist_path is None:
+        cmd_tar = (
+            f"tar -c -z -f {tarfile_path} "
+            f"--directory={subfolder_path_tmp_copy.as_posix()} "
+            "."
+        )
     else:
-        exclude_options = ""
+        cmd_tar = (
+            f"tar -c -z -f {tarfile_path} "
+            f"--directory={subfolder_path_tmp_copy.as_posix()} "
+            f"--files-from={filelist_path} --ignore-failed-read"
+        )
 
-    cmd_tar = (
-        f"tar czf {tarfile_path} "
-        f"{exclude_options} "
-        f"--directory={subfolder_path_tmp_copy.as_posix()} "
-        "."
-    )
     logger.debug(f"cmd tar:\n{cmd_tar}")
+
     run_subprocess(cmd=cmd_tar, logger_name=logger_name, allow_char="*")
+    elapsed = time.perf_counter() - t_start
+    logger.debug(f"[_create_tar_archive] END {elapsed=} s ({tarfile_path})")
 
 
-def remove_temp_subfolder(subfolder_path_tmp_copy: Path, logger_name: str):
+def _remove_temp_subfolder(subfolder_path_tmp_copy: Path, logger_name: str):
     logger = get_logger(logger_name)
+    t_start = time.perf_counter()
     try:
-        logger.debug(f"Now remove {subfolder_path_tmp_copy}")
-        shutil.rmtree(subfolder_path_tmp_copy)
+        cmd_rm = f"rm -rf {subfolder_path_tmp_copy}"
+        logger.debug(f"cmd rm:\n{cmd_rm}")
+        run_subprocess(cmd=cmd_rm, logger_name=logger_name, allow_char="*")
     except Exception as e:
-        logger.debug(f"ERROR during shutil.rmtree: {e}")
+        logger.debug(f"ERROR during {cmd_rm}: {e}")
+    elapsed = time.perf_counter() - t_start
+    logger.debug(
+        f"[_remove_temp_subfolder] END {elapsed=} s "
+        f"({subfolder_path_tmp_copy=})"
+    )
 
 
 def compress_folder(
-    subfolder_path: Path, remote_to_local: bool = False
+    subfolder_path: Path,
+    filelist_path: str | None,
 ) -> str:
     """
     Compress e.g. `/path/archive` into `/path/archive.tar.gz`
@@ -91,14 +109,16 @@ def compress_folder(
         subfolder_path.parent / f"{subfolder_path.name}_copy"
     )
     try:
-        copy_subfolder(
-            subfolder_path, subfolder_path_tmp_copy, logger_name=logger_name
+        _copy_subfolder(
+            subfolder_path,
+            subfolder_path_tmp_copy,
+            logger_name=logger_name,
         )
-        create_tar_archive(
+        _create_tar_archive(
             tarfile_path,
             subfolder_path_tmp_copy,
             logger_name=logger_name,
-            remote_to_local=remote_to_local,
+            filelist_path=filelist_path,
         )
         return tarfile_path
 
@@ -107,7 +127,9 @@ def compress_folder(
         sys.exit(1)
 
     finally:
-        remove_temp_subfolder(subfolder_path_tmp_copy, logger_name=logger_name)
+        _remove_temp_subfolder(
+            subfolder_path_tmp_copy, logger_name=logger_name
+        )
 
 
 def main(sys_argv: list[str]):
@@ -115,15 +137,21 @@ def main(sys_argv: list[str]):
     help_msg = (
         "Expected use:\n"
         "python -m fractal_server.app.runner.compress_folder "
-        "path/to/folder [--remote-to-local]\n"
+        "path/to/folder [--filelist /path/to/filelist]\n"
     )
     num_args = len(sys_argv[1:])
     if num_args == 0:
         sys.exit(f"Invalid argument.\n{help_msg}\nProvided: {sys_argv[1:]=}")
     elif num_args == 1:
-        compress_folder(subfolder_path=Path(sys_argv[1]))
-    elif num_args == 2 and sys_argv[2] == "--remote-to-local":
-        compress_folder(subfolder_path=Path(sys_argv[1]), remote_to_local=True)
+        compress_folder(
+            subfolder_path=Path(sys_argv[1]),
+            filelist_path=None,
+        )
+    elif num_args == 3 and sys_argv[2] == "--filelist":
+        compress_folder(
+            subfolder_path=Path(sys_argv[1]),
+            filelist_path=sys_argv[3],
+        )
     else:
         sys.exit(f"Invalid argument.\n{help_msg}\nProvided: {sys_argv[1:]=}")
 

fractal_server/app/runner/exceptions.py

@@ -37,6 +37,10 @@ class TaskExecutionError(RuntimeError):
         self.task_name = task_name
 
 
+class TaskOutputValidationError(ValueError):
+    pass
+
+
 class JobExecutionError(RuntimeError):
     """
     Forwards errors in the execution of a task that are due to external factors

fractal_server/app/runner/executors/base_runner.py

@@ -0,0 +1,157 @@
+from typing import Any
+
+from fractal_server.app.runner.task_files import TaskFiles
+from fractal_server.app.schemas.v2.task import TaskTypeType
+from fractal_server.logger import set_logger
+
+TASK_TYPES_SUBMIT: list[TaskTypeType] = [
+    "compound",
+    "converter_compound",
+    "non_parallel",
+    "converter_non_parallel",
+]
+TASK_TYPES_MULTISUBMIT: list[TaskTypeType] = [
+    "compound",
+    "converter_compound",
+    "parallel",
+]
+
+logger = set_logger(__name__)
+
+
+class BaseRunner(object):
+    """
+    Base class for Fractal runners.
+    """
+
+    def submit(
+        self,
+        func: callable,
+        parameters: dict[str, Any],
+        history_unit_id: int,
+        task_type: TaskTypeType,
+        task_files: TaskFiles,
+        config: Any,
+        user_id: int,
+    ) -> tuple[Any, BaseException]:
+        """
+        Run a single fractal task.
+
+        Args:
+            func: Function to be executed.
+            parameters: Dictionary of parameters.
+            history_unit_id:
+                Database ID of the corresponding `HistoryUnit` entry.
+            task_type: Task type.
+            task_files: `TaskFiles` object.
+            config: Runner-specific parameters.
+            user_id:
+        """
+        raise NotImplementedError()
+
+    def multisubmit(
+        self,
+        func: callable,
+        list_parameters: list[dict[str, Any]],
+        history_unit_ids: list[int],
+        list_task_files: list[TaskFiles],
+        task_type: TaskTypeType,
+        config: Any,
+        user_id: int,
+    ) -> tuple[dict[int, Any], dict[int, BaseException]]:
+        """
+        Run a parallel fractal task.
+
+        Args:
+            func: Function to be executed.
+            parameters:
+                Dictionary of parameters. Must include `zarr_urls` key.
+            history_unit_ids:
+                Database IDs of the corresponding `HistoryUnit` entries.
+            task_type: Task type.
+            task_files: `TaskFiles` object.
+            config: Runner-specific parameters.
+            user_id
+        """
+        raise NotImplementedError()
+
+    def validate_submit_parameters(
+        self,
+        parameters: dict[str, Any],
+        task_type: TaskTypeType,
+    ) -> None:
+        """
+        Validate parameters for `submit` method
+
+        Args:
+            parameters: Parameters dictionary.
+            task_type: Task type.s
+        """
+        logger.info("[validate_submit_parameters] START")
+        if task_type not in TASK_TYPES_SUBMIT:
+            raise ValueError(f"Invalid {task_type=} for `submit`.")
+        if not isinstance(parameters, dict):
+            raise ValueError("`parameters` must be a dictionary.")
+        if task_type in ["non_parallel", "compound"]:
+            if "zarr_urls" not in parameters.keys():
+                raise ValueError(
+                    f"No 'zarr_urls' key in in {list(parameters.keys())}"
+                )
+        elif task_type in ["converter_non_parallel", "converter_compound"]:
+            if "zarr_urls" in parameters.keys():
+                raise ValueError(
+                    f"Forbidden 'zarr_urls' key in {list(parameters.keys())}"
+                )
+        logger.info("[validate_submit_parameters] END")
+
+    def validate_multisubmit_parameters(
+        self,
+        *,
+        task_type: TaskTypeType,
+        list_parameters: list[dict[str, Any]],
+        list_task_files: list[TaskFiles],
+        history_unit_ids: list[int],
+    ) -> None:
+        """
+        Validate parameters for `multisubmit` method
+
+        Args:
+            task_type: Task type.
+            list_parameters: List of parameters dictionaries.
+            list_task_files:
+            history_unit_ids:
+        """
+        if task_type not in TASK_TYPES_MULTISUBMIT:
+            raise ValueError(f"Invalid {task_type=} for `multisubmit`.")
+
+        if not isinstance(list_parameters, list):
+            raise ValueError("`parameters` must be a list.")
+
+        if len(list_parameters) != len(list_task_files):
+            raise ValueError(
+                f"{len(list_task_files)=} differs from "
+                f"{len(list_parameters)=}."
+            )
+        if len(history_unit_ids) != len(list_parameters):
+            raise ValueError(
+                f"{len(history_unit_ids)=} differs from "
+                f"{len(list_parameters)=}."
+            )
+
+        subfolders = set(
+            task_file.wftask_subfolder_local for task_file in list_task_files
+        )
+        if len(subfolders) != 1:
+            raise ValueError(f"More than one subfolders: {subfolders}.")
+
+        for single_kwargs in list_parameters:
+            if not isinstance(single_kwargs, dict):
+                raise ValueError("kwargs itemt must be a dictionary.")
+            if "zarr_url" not in single_kwargs.keys():
+                raise ValueError(
+                    f"No 'zarr_url' key in in {list(single_kwargs.keys())}"
+                )
+        if task_type == "parallel":
+            zarr_urls = [kwargs["zarr_url"] for kwargs in list_parameters]
+            if len(zarr_urls) != len(set(zarr_urls)):
+                raise ValueError("Non-unique zarr_urls")

fractal_server/app/runner/{v2/_local/_local_config.py → executors/local/get_local_config.py}

@@ -20,9 +20,9 @@ from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import ValidationError
 
-from .....config import get_settings
-from .....syringe import Inject
-from ....models.v2 import WorkflowTaskV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
 
 
 class LocalBackendConfigError(ValueError):
@@ -47,18 +47,16 @@ class LocalBackendConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
     parallel_tasks_per_job: Optional[int] = None
 
-
-def get_default_local_backend_config():
-    """
-    Return a default `LocalBackendConfig` configuration object
-    """
-    return LocalBackendConfig(parallel_tasks_per_job=None)
+    @property
+    def batch_size(self) -> int:
+        return self.parallel_tasks_per_job or 1
 
 
 def get_local_backend_config(
     wftask: WorkflowTaskV2,
     which_type: Literal["non_parallel", "parallel"],
     config_path: Optional[Path] = None,
+    tot_tasks: int = 1,
 ) -> LocalBackendConfig:
     """
     Prepare a `LocalBackendConfig` configuration object