fractal-server 2.14.5__py3-none-any.whl → 2.14.7__py3-none-any.whl

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

@@ -22,6 +22,7 @@ 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
+from fractal_server.ssh._fabric import SSHConfig
 from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.local import deactivate_local
 from fractal_server.tasks.v2.local import reactivate_local
@@ -119,19 +120,17 @@ async def deactivate_task_group(
         )
 
         # User appropriate FractalSSH object
-        ssh_credentials = dict(
+        ssh_config = SSHConfig(
             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_credentials)
 
         background_tasks.add_task(
             deactivate_ssh,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
-            fractal_ssh=fractal_ssh,
+            ssh_config=ssh_config,
             tasks_base_dir=user_settings.ssh_tasks_dir,
         )
 
@@ -241,20 +240,18 @@ async def reactivate_task_group(
             user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
         )
 
-        # Use appropriate FractalSSH object
-        ssh_credentials = dict(
+        # Use appropriate SSH credentials
+        ssh_config = SSHConfig(
             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_credentials)
 
         background_tasks.add_task(
             reactivate_ssh,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
-            fractal_ssh=fractal_ssh,
+            ssh_config=ssh_config,
             tasks_base_dir=user_settings.ssh_tasks_dir,
         )
 

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

@@ -0,0 +1,270 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import status
+from packaging.version import parse
+from packaging.version import Version
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from sqlmodel import cast
+from sqlmodel import or_
+from sqlmodel import select
+from sqlmodel import String
+
+from ....db import AsyncSession
+from ....db import get_async_db
+from ....models import LinkUserGroup
+from ....models.v2 import TaskV2
+from ._aux_functions import _get_workflow_check_owner
+from ._aux_functions import _get_workflow_task_check_owner
+from ._aux_functions_tasks import _check_type_filters_compatibility
+from ._aux_functions_tasks import _get_task_group_or_404
+from ._aux_functions_tasks import _get_task_read_access
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.routes.auth import current_active_user
+from fractal_server.app.schemas.v2 import WorkflowTaskReadV2
+from fractal_server.app.schemas.v2 import WorkflowTaskReplaceV2
+
+
+router = APIRouter()
+
+
+VALID_TYPE_UPDATES = {
+    ("non_parallel", "converter_non_parallel"),
+    ("compound", "converter_compound"),
+    ("converter_non_parallel", "converter_non_parallel"),
+    ("converter_compound", "converter_compound"),
+    ("non_parallel", "non_parallel"),
+    ("compound", "compound"),
+    ("parallel", "parallel"),
+}
+
+
+def _is_type_update_valid(*, old_type: str, new_type: str) -> bool:
+    return (old_type, new_type) in VALID_TYPE_UPDATES
+
+
+def _is_version_parsable(version: str) -> bool:
+    try:
+        parse(version)
+        return True
+    except Exception:
+        return False
+
+
+class TaskVersion(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    task_id: int
+    version: str
+    parsed_version: Version
+
+
+class TaskVersionRead(BaseModel):
+    task_id: int
+    version: str
+
+
+@router.get(
+    "/project/{project_id}/workflow/{workflow_id}/version-update-candidates/"
+)
+async def get_workflow_version_update_candidates(
+    project_id: int,
+    workflow_id: int,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[list[TaskVersionRead]]:
+
+    workflow = await _get_workflow_check_owner(
+        project_id=project_id,
+        workflow_id=workflow_id,
+        user_id=user.id,
+        db=db,
+    )
+
+    response = []
+    for wftask in workflow.task_list:
+        current_task = wftask.task
+
+        # Skip tasks with no args schemas
+        if not (
+            current_task.args_schema_parallel
+            or current_task.args_schema_non_parallel
+        ):
+            response.append([])
+            continue
+
+        current_task_group = await _get_task_group_or_404(
+            task_group_id=current_task.taskgroupv2_id, db=db
+        )
+
+        # Skip tasks with non-parsable version
+        if _is_version_parsable(current_task_group.version):
+            current_parsed_version = parse(current_task_group.version)
+        else:
+            response.append([])
+            continue
+
+        res = await db.execute(
+            select(TaskV2.id, TaskV2.type, TaskGroupV2.version)
+            .where(
+                or_(
+                    cast(TaskV2.args_schema_parallel, String) != "null",
+                    cast(TaskV2.args_schema_non_parallel, String) != "null",
+                )
+            )
+            .where(TaskV2.name == current_task.name)
+            .where(TaskV2.taskgroupv2_id == TaskGroupV2.id)
+            .where(TaskGroupV2.pkg_name == current_task_group.pkg_name)
+            .where(TaskGroupV2.active.is_(True))
+            .where(
+                or_(
+                    TaskGroupV2.user_id == user.id,
+                    TaskGroupV2.user_group_id.in_(
+                        select(LinkUserGroup.group_id).where(
+                            LinkUserGroup.user_id == user.id
+                        )
+                    ),
+                )
+            )
+        )
+        query_results: list[tuple[int, str, str]] = res.all()
+
+        # Exclude tasks with non-compatible types or non-parsable versions
+        current_task_type = current_task.type
+        update_candidates = [
+            TaskVersion(
+                task_id=task_id,
+                version=version,
+                parsed_version=parse(version),
+            )
+            for task_id, _type, version in query_results
+            if (
+                _is_type_update_valid(
+                    old_type=current_task_type,
+                    new_type=_type,
+                )
+                and _is_version_parsable(version)
+            )
+        ]
+        # Exclude tasks with old versions from update candidates
+        update_candidates = [
+            item
+            for item in update_candidates
+            if item.parsed_version > current_parsed_version
+        ]
+        # Sort update candidates by parsed version
+        update_candidates = sorted(
+            update_candidates,
+            key=lambda obj: obj.parsed_version,
+        )
+        response.append(update_candidates)
+
+    return response
+
+
+@router.post(
+    "/project/{project_id}/workflow/{workflow_id}/wftask/replace-task/",
+    response_model=WorkflowTaskReadV2,
+    status_code=status.HTTP_201_CREATED,
+)
+async def replace_workflowtask(
+    project_id: int,
+    workflow_id: int,
+    workflow_task_id: int,
+    task_id: int,
+    replace: WorkflowTaskReplaceV2,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> WorkflowTaskReadV2:
+
+    # 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,
+    )
+
+    # Preliminary checks
+    if not _is_type_update_valid(
+        old_type=old_wftask.task_type,
+        new_type=new_task.type,
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "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_wftask.type_filters,
+    )
+
+    # 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_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_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
+
+    new_workflow_task = WorkflowTaskV2(
+        task_id=new_task.id,
+        task_type=new_task.type,
+        task=new_task,
+        # old-task values
+        type_filters=old_wftask.type_filters,
+        # possibly new values
+        args_non_parallel=_args_non_parallel,
+        args_parallel=_args_parallel,
+        meta_non_parallel=_meta_non_parallel,
+        meta_parallel=_meta_parallel,
+    )
+
+    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)
+    return new_workflow_task

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

@@ -1,5 +1,4 @@
 from copy import copy
-from typing import Optional
 
 from fastapi import APIRouter
 from fastapi import Depends
@@ -40,7 +39,7 @@ async def get_workflow_list(
     project_id: int,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[list[WorkflowReadV2]]:
+) -> list[WorkflowReadV2] | None:
     """
     Get workflow list for given project
     """
@@ -67,7 +66,7 @@ async def create_workflow(
     workflow: WorkflowCreateV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2]:
+) -> WorkflowReadV2 | None:
     """
     Create a workflow, associate to a project
     """
@@ -95,7 +94,7 @@ async def read_workflow(
     workflow_id: int,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2WithWarnings]:
+) -> WorkflowReadV2WithWarnings | None:
     """
     Get info on an existing workflow
     """
@@ -129,7 +128,7 @@ async def update_workflow(
     patch: WorkflowUpdateV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2WithWarnings]:
+) -> WorkflowReadV2WithWarnings | None:
     """
     Edit a workflow
     """
@@ -237,7 +236,7 @@ async def export_workflow(
     workflow_id: int,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowExportV2]:
+) -> WorkflowExportV2 | None:
     """
     Export an existing workflow, after stripping all IDs
     """

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

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from fastapi import APIRouter
 from fastapi import Depends
 from fastapi import HTTPException
@@ -64,7 +62,7 @@ async def _get_user_accessible_taskgroups(
 async def _get_task_by_source(
     source: str,
     task_groups_list: list[TaskGroupV2],
-) -> Optional[int]:
+) -> int | None:
     """
     Find task with a given source.
 
@@ -93,7 +91,7 @@ async def _disambiguate_task_groups(
     user_id: int,
     db: AsyncSession,
     default_group_id: int,
-) -> Optional[TaskV2]:
+) -> TaskV2 | None:
     """
     Disambiguate task groups based on ownership information.
     """
@@ -164,7 +162,7 @@ async def _get_task_by_taskimport(
     user_id: int,
     default_group_id: int,
     db: AsyncSession,
-) -> Optional[int]:
+) -> int | None:
     """
     Find a task based on `task_import`.
 

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

@@ -1,5 +1,4 @@
 from copy import deepcopy
-from typing import Optional
 
 from fastapi import APIRouter
 from fastapi import Depends
@@ -15,125 +14,14 @@ from ._aux_functions import _workflow_insert_task
 from ._aux_functions_tasks import _check_type_filters_compatibility
 from ._aux_functions_tasks import _get_task_read_access
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2 import WorkflowTaskV2
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.schemas.v2 import WorkflowTaskCreateV2
 from fractal_server.app.schemas.v2 import WorkflowTaskReadV2
-from fractal_server.app.schemas.v2 import WorkflowTaskReplaceV2
 from fractal_server.app.schemas.v2 import WorkflowTaskUpdateV2
 
 router = APIRouter()
 
 
-@router.post(
-    "/project/{project_id}/workflow/{workflow_id}/wftask/replace-task/",
-    response_model=WorkflowTaskReadV2,
-    status_code=status.HTTP_201_CREATED,
-)
-async def replace_workflowtask(
-    project_id: int,
-    workflow_id: int,
-    workflow_task_id: int,
-    task_id: int,
-    replace: WorkflowTaskReplaceV2,
-    user: UserOAuth = Depends(current_active_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> WorkflowTaskReadV2:
-
-    # 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,
-    )
-
-    # 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=(
-                "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_wftask.type_filters,
-    )
-
-    # 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_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_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
-
-    new_workflow_task = WorkflowTaskV2(
-        task_id=new_task.id,
-        task_type=new_task.type,
-        task=new_task,
-        # old-task values
-        type_filters=old_wftask.type_filters,
-        # possibly new values
-        args_non_parallel=_args_non_parallel,
-        args_parallel=_args_parallel,
-        meta_non_parallel=_meta_non_parallel,
-        meta_parallel=_meta_parallel,
-    )
-
-    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)
-    return new_workflow_task
-
-
 @router.post(
     "/project/{project_id}/workflow/{workflow_id}/wftask/",
     response_model=WorkflowTaskReadV2,
@@ -146,7 +34,7 @@ async def create_workflowtask(
     wftask: WorkflowTaskCreateV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowTaskReadV2]:
+) -> WorkflowTaskReadV2 | None:
     """
     Add a WorkflowTask to a Workflow
     """
@@ -237,7 +125,7 @@ async def update_workflowtask(
     workflow_task_update: WorkflowTaskUpdateV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowTaskReadV2]:
+) -> WorkflowTaskReadV2 | None:
     """
     Edit a WorkflowTask of a Workflow
     """

fractal_server/app/routes/auth/current_user.py

@@ -164,11 +164,11 @@ async def get_current_user_allowed_viewer_paths(
         viewer_paths_nested = res.scalars().all()
 
         # Flatten a nested object and make its elements unique
-        all_viewer_paths_set = set(
+        all_viewer_paths_set = {
             path
             for _viewer_paths in viewer_paths_nested
             for path in _viewer_paths
-        )
+        }
 
         authorized_paths.extend(all_viewer_paths_set)
 

fractal_server/app/routes/pagination.py

@@ -1,5 +1,4 @@
 from typing import Generic
-from typing import Optional
 from typing import TypeVar
 
 from fastapi import HTTPException
@@ -14,7 +13,7 @@ T = TypeVar("T")
 class PaginationRequest(BaseModel):
 
     page: int = Field(ge=1)
-    page_size: Optional[int] = Field(ge=1)
+    page_size: int | None = Field(ge=1)
 
     @model_validator(mode="after")
     def valid_pagination_parameters(self):
@@ -26,7 +25,7 @@ class PaginationRequest(BaseModel):
 
 
 def get_pagination_params(
-    page: int = 1, page_size: Optional[int] = None
+    page: int = 1, page_size: int | None = None
 ) -> PaginationRequest:
     try:
         pagination = PaginationRequest(page=page, page_size=page_size)

fractal_server/app/runner/exceptions.py

@@ -1,5 +1,4 @@
 import os
-from typing import Optional
 
 
 class TaskExecutionError(RuntimeError):
@@ -20,16 +19,16 @@ class TaskExecutionError(RuntimeError):
             Human readable name of the failing task.
     """
 
-    workflow_task_id: Optional[int] = None
-    workflow_task_order: Optional[int] = None
-    task_name: Optional[str] = None
+    workflow_task_id: int | None = None
+    workflow_task_order: int | None = None
+    task_name: str | None = None
 
     def __init__(
         self,
         *args,
-        workflow_task_id: Optional[int] = None,
-        workflow_task_order: Optional[int] = None,
-        task_name: Optional[str] = None,
+        workflow_task_id: int | None = None,
+        workflow_task_order: int | None = None,
+        task_name: str | None = None,
     ):
         super().__init__(*args)
         self.workflow_task_id = workflow_task_id
@@ -63,18 +62,18 @@ class JobExecutionError(RuntimeError):
             Path to the file with the command stderr
     """
 
-    cmd_file: Optional[str] = None
-    stdout_file: Optional[str] = None
-    stderr_file: Optional[str] = None
-    info: Optional[str] = None
+    cmd_file: str | None = None
+    stdout_file: str | None = None
+    stderr_file: str | None = None
+    info: str | None = None
 
     def __init__(
         self,
         *args,
-        cmd_file: Optional[str] = None,
-        stdout_file: Optional[str] = None,
-        stderr_file: Optional[str] = None,
-        info: Optional[str] = None,
+        cmd_file: str | None = None,
+        stdout_file: str | None = None,
+        stderr_file: str | None = None,
+        info: str | None = None,
     ):
         super().__init__(*args)
         self.cmd_file = cmd_file
@@ -88,7 +87,7 @@ class JobExecutionError(RuntimeError):
         empty or missing
         """
         if os.path.exists(filepath):
-            with open(filepath, "r") as f:
+            with open(filepath) as f:
                 content = f.read()
                 if content:
                     return f"Content of {filepath}:\n{content}"

fractal_server/app/runner/executors/base_runner.py

@@ -19,7 +19,7 @@ TASK_TYPES_MULTISUBMIT: list[TaskTypeType] = [
 logger = set_logger(__name__)
 
 
-class BaseRunner(object):
+class BaseRunner:
     """
     Base class for Fractal runners.
     """
@@ -150,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

@@ -44,7 +44,7 @@ def call_command_wrapper(*, cmd: str, log_path: str) -> None:
     if result.returncode != 0:
         stderr = ""
         if os.path.isfile(log_path):
-            with open(log_path, "r") as fp_stderr:
+            with open(log_path) as fp_stderr:
                 stderr = fp_stderr.read()
         raise TaskExecutionError(
             f"Task failed with returncode={result.returncode}.\n"