fractal-server 2.14.12__py3-none-any.whl → 2.14.14__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.14.12"
+__VERSION__ = "2.14.14"

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

@@ -0,0 +1,163 @@
+import itertools
+
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models import LinkUserGroup
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.exceptions import UnreachableBranchError
+from fractal_server.logger import set_logger
+
+
+logger = set_logger(__name__)
+
+
+async def _disambiguate_task_groups(
+    *,
+    matching_task_groups: list[TaskGroupV2],
+    user_id: int,
+    default_group_id: int,
+    db: AsyncSession,
+) -> TaskGroupV2 | None:
+    """
+    Find ownership-based top-priority task group, if any.
+
+    Args:
+        matching_task_groups:
+        user_id:
+        default_group_id:
+        db:
+
+    Returns:
+        The task group or `None`.
+    """
+
+    # Highest priority: task groups created by user
+    list_user_ids = [tg.user_id for tg in matching_task_groups]
+    try:
+        ind_user_id = list_user_ids.index(user_id)
+        task_group = matching_task_groups[ind_user_id]
+        logger.debug(
+            "[_disambiguate_task_groups] "
+            f"Found task group {task_group.id} with {user_id=}, return."
+        )
+        return task_group
+    except ValueError:
+        logger.debug(
+            "[_disambiguate_task_groups] "
+            f"No task group with {user_id=}, continue."
+        )
+
+    # Medium priority: task groups owned by default user group
+    list_user_group_ids = [tg.user_group_id for tg in matching_task_groups]
+    try:
+        ind_user_group_id = list_user_group_ids.index(default_group_id)
+        task_group = matching_task_groups[ind_user_group_id]
+        logger.debug(
+            "[_disambiguate_task_groups] "
+            f"Found task group {task_group.id} with {user_id=}, return."
+        )
+        return task_group
+    except ValueError:
+        logger.debug(
+            "[_disambiguate_task_groups] "
+            "No task group with user_group_id="
+            f"{default_group_id}, continue."
+        )
+
+    # Lowest priority: task groups owned by other groups, sorted
+    # according to age of the user/usergroup link
+    logger.debug(
+        "[_disambiguate_task_groups] "
+        "Sort remaining task groups by oldest-user-link."
+    )
+    stm = (
+        select(LinkUserGroup.group_id)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.in_(list_user_group_ids))
+        .order_by(LinkUserGroup.timestamp_created.asc())
+    )
+    res = await db.execute(stm)
+    oldest_user_group_id = res.scalars().first()
+    logger.debug(
+        "[_disambiguate_task_groups] " f"Result: {oldest_user_group_id=}."
+    )
+    task_group = next(
+        iter(
+            task_group
+            for task_group in matching_task_groups
+            if task_group.user_group_id == oldest_user_group_id
+        ),
+        None,
+    )
+    return task_group
+
+
+async def _disambiguate_task_groups_not_none(
+    *,
+    matching_task_groups: list[TaskGroupV2],
+    user_id: int,
+    default_group_id: int,
+    db: AsyncSession,
+) -> TaskGroupV2:
+    """
+    Find ownership-based top-priority task group, and fail otherwise.
+
+    Args:
+        matching_task_groups:
+        user_id:
+        default_group_id:
+        db:
+
+    Returns:
+        The top-priority task group.
+    """
+    task_group = await _disambiguate_task_groups(
+        matching_task_groups=matching_task_groups,
+        user_id=user_id,
+        default_group_id=default_group_id,
+        db=db,
+    )
+    if task_group is None:
+        error_msg = (
+            "[_disambiguate_task_groups_not_none] Could not find a task "
+            f"group ({user_id=}, {default_group_id=})."
+        )
+        logger.error(f"UnreachableBranchError {error_msg}")
+        raise UnreachableBranchError(error_msg)
+    else:
+        return task_group
+
+
+async def remove_duplicate_task_groups(
+    *,
+    task_groups: list[TaskGroupV2],
+    user_id: int,
+    default_group_id: int,
+    db: AsyncSession,
+) -> list[TaskGroupV2]:
+    """
+    Extract an item for each `version` from a *sorted* task-group list.
+
+    Args:
+        task_groups: A list of task groups with identical `pkg_name`
+        user_id: User ID
+
+    Returns:
+        New list of task groups with no duplicate `(pkg_name,version)` entries
+    """
+
+    new_task_groups = [
+        (
+            await _disambiguate_task_groups_not_none(
+                matching_task_groups=list(groups),
+                user_id=user_id,
+                default_group_id=default_group_id,
+                db=db,
+            )
+        )
+        for version, groups in itertools.groupby(
+            task_groups, key=lambda tg: tg.version
+        )
+    ]
+    return new_task_groups

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

@@ -16,6 +16,7 @@ from fractal_server.app.models.v2 import HistoryImageCache
 from fractal_server.app.models.v2 import HistoryUnit
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.schemas.v2 import HistoryUnitStatus
+from fractal_server.app.schemas.v2 import TaskType
 from fractal_server.images.tools import aggregate_types
 from fractal_server.images.tools import filter_image_list
 from fractal_server.types import AttributeFilters
@@ -105,8 +106,8 @@ async def check_workflowtask(
         # Skip check if previous task has non-trivial `output_types`
         return JSONResponse(status_code=200, content=[])
     elif previous_wft.task.type in [
-        "converter_compound",
-        "converter_non_parallel",
+        TaskType.CONVERTER_COMPOUND,
+        TaskType.CONVERTER_NON_PARALLEL,
     ]:
         # Skip check if previous task is converter
         return JSONResponse(status_code=200, content=[])

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

@@ -25,6 +25,7 @@ from fractal_server.app.routes.auth import current_active_verified_user
 from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.app.schemas.v2 import TaskReadV2
+from fractal_server.app.schemas.v2 import TaskType
 from fractal_server.app.schemas.v2 import TaskUpdateV2
 from fractal_server.logger import set_logger
 
@@ -109,12 +110,12 @@ async def patch_task(
     update = task_update.model_dump(exclude_unset=True)
 
     # Forbid changes that set a previously unset command
-    if db_task.type == "non_parallel" and "command_parallel" in update:
+    if db_task.type == TaskType.NON_PARALLEL and "command_parallel" in update:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Cannot set an unset `command_parallel`.",
         )
-    if db_task.type == "parallel" and "command_non_parallel" in update:
+    if db_task.type == TaskType.PARALLEL and "command_non_parallel" in update:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Cannot set an unset `command_non_parallel`.",
@@ -151,7 +152,7 @@ async def create_task(
         db=db,
     )
 
-    if task.type == "parallel" and (
+    if task.type == TaskType.PARALLEL and (
         task.args_schema_non_parallel is not None
         or task.meta_non_parallel is not None
     ):
@@ -162,7 +163,7 @@ async def create_task(
                 "`TaskV2.args_schema_non_parallel` if TaskV2 is parallel"
             ),
         )
-    elif task.type == "non_parallel" and (
+    elif task.type == TaskType.NON_PARALLEL and (
         task.args_schema_parallel is not None or task.meta_parallel is not None
     ):
         raise HTTPException(

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

@@ -1,8 +1,13 @@
+import itertools
+
 from fastapi import APIRouter
 from fastapi import Depends
 from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
+from packaging.version import InvalidVersion
+from packaging.version import parse
+from packaging.version import Version
 from pydantic.types import AwareDatetime
 from sqlmodel import or_
 from sqlmodel import select
@@ -10,6 +15,7 @@ from sqlmodel import select
 from ._aux_functions_tasks import _get_task_group_full_access
 from ._aux_functions_tasks import _get_task_group_read_access
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
+from ._aux_task_group_disambiguation import remove_duplicate_task_groups
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import LinkUserGroup
@@ -18,6 +24,7 @@ from fractal_server.app.models.v2 import TaskGroupActivityV2
 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.routes.auth._aux_auth import _get_default_usergroup_id
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
@@ -33,6 +40,26 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
+def _version_sort_key(
+    task_group: TaskGroupV2,
+) -> tuple[int, Version | str | None]:
+    """
+    Returns a tuple used as (reverse) ordering key for TaskGroups in
+    `get_task_group_list`.
+    The TaskGroups with a parsable versions are the first in order,
+    sorted according to the sorting rules of packaging.version.Version.
+    Next in order we have the TaskGroups with non-null non-parsable versions,
+    sorted alphabetically.
+    Last we have the TaskGroups with null version.
+    """
+    if task_group.version is None:
+        return (0, task_group.version)
+    try:
+        return (2, parse(task_group.version))
+    except InvalidVersion:
+        return (1, task_group.version)
+
+
 @router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
 async def get_task_group_activity_list(
     task_group_activity_id: int | None = None,
@@ -97,14 +124,14 @@ async def get_task_group_activity(
     return activity
 
 
-@router.get("/", response_model=list[TaskGroupReadV2])
+@router.get("/", response_model=list[tuple[str, list[TaskGroupReadV2]]])
 async def get_task_group_list(
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
     only_active: bool = False,
     only_owner: bool = False,
     args_schema: bool = True,
-) -> list[TaskGroupReadV2]:
+) -> list[tuple[str, list[TaskGroupReadV2]]]:
     """
     Get all accessible TaskGroups
     """
@@ -119,7 +146,7 @@ async def get_task_group_list(
                 )
             ),
         )
-    stm = select(TaskGroupV2).where(condition)
+    stm = select(TaskGroupV2).where(condition).order_by(TaskGroupV2.pkg_name)
     if only_active:
         stm = stm.where(TaskGroupV2.active)
 
@@ -132,7 +159,28 @@ async def get_task_group_list(
                 setattr(task, "args_schema_non_parallel", None)
                 setattr(task, "args_schema_parallel", None)
 
-    return task_groups
+    default_group_id = await _get_default_usergroup_id(db)
+    grouped_result = [
+        (
+            pkg_name,
+            (
+                await remove_duplicate_task_groups(
+                    task_groups=sorted(
+                        list(groups),
+                        key=_version_sort_key,
+                        reverse=True,
+                    ),
+                    user_id=user.id,
+                    default_group_id=default_group_id,
+                    db=db,
+                )
+            ),
+        )
+        for pkg_name, groups in itertools.groupby(
+            task_groups, key=lambda tg: tg.pkg_name
+        )
+    ]
+    return grouped_result
 
 
 @router.get("/{task_group_id}/", response_model=TaskGroupReadV2)

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

@@ -24,21 +24,23 @@ 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.routes.auth import current_active_user
+from fractal_server.app.schemas.v2 import TaskType
 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"),
+    # Transform into converter
+    (TaskType.NON_PARALLEL, TaskType.CONVERTER_NON_PARALLEL),
+    (TaskType.COMPOUND, TaskType.CONVERTER_COMPOUND),
+    # Keep the same
+    (TaskType.CONVERTER_NON_PARALLEL, TaskType.CONVERTER_NON_PARALLEL),
+    (TaskType.CONVERTER_COMPOUND, TaskType.CONVERTER_COMPOUND),
+    (TaskType.NON_PARALLEL, TaskType.NON_PARALLEL),
+    (TaskType.COMPOUND, TaskType.COMPOUND),
+    (TaskType.PARALLEL, TaskType.PARALLEL),
 }
 
 
@@ -208,12 +210,18 @@ async def replace_workflowtask(
             ),
         )
 
-    if replace.args_non_parallel is not None and new_task.type == "parallel":
+    if (
+        replace.args_non_parallel is not None
+        and new_task.type == TaskType.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":
+    if (
+        replace.args_parallel is not None
+        and new_task.type == TaskType.NON_PARALLEL
+    ):
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Cannot set 'args_parallel' for non-parallel task.",

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

@@ -21,6 +21,9 @@ from ._aux_functions_tasks import _check_type_filters_compatibility
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.routes.api.v2._aux_task_group_disambiguation import (
+    _disambiguate_task_groups,
+)
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.routes.auth._aux_auth import _get_default_usergroup_id
 from fractal_server.app.schemas.v2 import TaskImportV2
@@ -85,76 +88,6 @@ async def _get_task_by_source(
     return task_id
 
 
-async def _disambiguate_task_groups(
-    *,
-    matching_task_groups: list[TaskGroupV2],
-    user_id: int,
-    db: AsyncSession,
-    default_group_id: int,
-) -> TaskV2 | None:
-    """
-    Disambiguate task groups based on ownership information.
-    """
-    # Highest priority: task groups created by user
-    for task_group in matching_task_groups:
-        if task_group.user_id == user_id:
-            logger.info(
-                "[_disambiguate_task_groups] "
-                f"Found task group {task_group.id} with {user_id=}, return."
-            )
-            return task_group
-    logger.info(
-        "[_disambiguate_task_groups] "
-        f"No task group found with {user_id=}, continue."
-    )
-
-    # Medium priority: task groups owned by default user group
-    for task_group in matching_task_groups:
-        if task_group.user_group_id == default_group_id:
-            logger.info(
-                "[_disambiguate_task_groups] "
-                f"Found task group {task_group.id} with user_group_id="
-                f"{default_group_id}, return."
-            )
-            return task_group
-    logger.info(
-        "[_disambiguate_task_groups] "
-        "No task group found with user_group_id="
-        f"{default_group_id}, continue."
-    )
-
-    # Lowest priority: task groups owned by other groups, sorted
-    # according to age of the user/usergroup link
-    logger.info(
-        "[_disambiguate_task_groups] "
-        "Now sorting remaining task groups by oldest-user-link."
-    )
-    user_group_ids = [
-        task_group.user_group_id for task_group in matching_task_groups
-    ]
-    stm = (
-        select(LinkUserGroup.group_id)
-        .where(LinkUserGroup.user_id == user_id)
-        .where(LinkUserGroup.group_id.in_(user_group_ids))
-        .order_by(LinkUserGroup.timestamp_created.asc())
-    )
-    res = await db.execute(stm)
-    oldest_user_group_id = res.scalars().first()
-    logger.info(
-        "[_disambiguate_task_groups] "
-        f"Result of sorting: {oldest_user_group_id=}."
-    )
-    task_group = next(
-        iter(
-            task_group
-            for task_group in matching_task_groups
-            if task_group.user_group_id == oldest_user_group_id
-        ),
-        None,
-    )
-    return task_group
-
-
 async def _get_task_by_taskimport(
     *,
     task_import: TaskImportV2,

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

@@ -15,6 +15,7 @@ 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.routes.auth import current_active_user
+from fractal_server.app.schemas.v2 import TaskType
 from fractal_server.app.schemas.v2 import WorkflowTaskCreateV2
 from fractal_server.app.schemas.v2 import WorkflowTaskReadV2
 from fractal_server.app.schemas.v2 import WorkflowTaskUpdateV2
@@ -47,7 +48,7 @@ async def create_workflowtask(
         task_id=task_id, user_id=user.id, db=db, require_active=True
     )
 
-    if task.type == "parallel":
+    if task.type == TaskType.PARALLEL:
         if (
             wftask.meta_non_parallel is not None
             or wftask.args_non_parallel is not None
@@ -60,7 +61,7 @@ async def create_workflowtask(
                     "is `parallel`."
                 ),
             )
-    elif task.type == "non_parallel":
+    elif task.type == TaskType.NON_PARALLEL:
         if (
             wftask.meta_parallel is not None
             or wftask.args_parallel is not None
@@ -143,7 +144,7 @@ async def update_workflowtask(
             wftask_type_filters=workflow_task_update.type_filters,
         )
 
-    if db_wf_task.task_type == "parallel" and (
+    if db_wf_task.task_type == TaskType.PARALLEL and (
         workflow_task_update.args_non_parallel is not None
         or workflow_task_update.meta_non_parallel is not None
     ):
@@ -156,8 +157,8 @@ async def update_workflowtask(
             ),
         )
     elif db_wf_task.task_type in [
-        "non_parallel",
-        "converter_non_parallel",
+        TaskType.NON_PARALLEL,
+        TaskType.CONVERTER_NON_PARALLEL,
     ] and (
         workflow_task_update.args_parallel is not None
         or workflow_task_update.meta_parallel is not None

fractal_server/app/runner/executors/base_runner.py

@@ -1,19 +1,34 @@
+from enum import StrEnum
 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.app.schemas.v2.task import TaskType
 from fractal_server.logger import set_logger
 
-TASK_TYPES_SUBMIT: list[TaskTypeType] = [
-    "compound",
-    "converter_compound",
-    "non_parallel",
-    "converter_non_parallel",
+
+class SubmitTaskType(StrEnum):
+    COMPOUND = TaskType.COMPOUND
+    NON_PARALLEL = TaskType.NON_PARALLEL
+    CONVERTER_NON_PARALLEL = TaskType.CONVERTER_NON_PARALLEL
+    CONVERTER_COMPOUND = TaskType.CONVERTER_COMPOUND
+
+
+class MultisubmitTaskType(StrEnum):
+    PARALLEL = TaskType.PARALLEL
+    COMPOUND = TaskType.COMPOUND
+    CONVERTER_COMPOUND = TaskType.CONVERTER_COMPOUND
+
+
+TASK_TYPES_SUBMIT: list[TaskType] = [
+    TaskType.COMPOUND,
+    TaskType.CONVERTER_COMPOUND,
+    TaskType.NON_PARALLEL,
+    TaskType.CONVERTER_NON_PARALLEL,
 ]
-TASK_TYPES_MULTISUBMIT: list[TaskTypeType] = [
-    "compound",
-    "converter_compound",
-    "parallel",
+TASK_TYPES_MULTISUBMIT: list[TaskType] = [
+    TaskType.COMPOUND,
+    TaskType.CONVERTER_COMPOUND,
+    TaskType.PARALLEL,
 ]
 
 logger = set_logger(__name__)
@@ -32,7 +47,7 @@ class BaseRunner:
         task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
-        task_type: TaskTypeType,
+        task_type: TaskType,
         task_files: TaskFiles,
         config: Any,
         user_id: int,
@@ -64,7 +79,7 @@ class BaseRunner:
         list_parameters: list[dict[str, Any]],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
-        task_type: TaskTypeType,
+        task_type: TaskType,
         config: Any,
         user_id: int,
     ) -> tuple[dict[int, Any], dict[int, BaseException]]:
@@ -90,7 +105,7 @@ class BaseRunner:
     def validate_submit_parameters(
         self,
         parameters: dict[str, Any],
-        task_type: TaskTypeType,
+        task_type: TaskType,
     ) -> None:
         """
         Validate parameters for `submit` method
@@ -104,12 +119,18 @@ class BaseRunner:
             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 task_type in [
+            TaskType.NON_PARALLEL,
+            TaskType.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"]:
+        elif task_type in [
+            TaskType.CONVERTER_NON_PARALLEL,
+            TaskType.CONVERTER_COMPOUND,
+        ]:
             if "zarr_urls" in parameters.keys():
                 raise ValueError(
                     f"Forbidden 'zarr_urls' key in {list(parameters.keys())}"
@@ -119,7 +140,7 @@ class BaseRunner:
     def validate_multisubmit_parameters(
         self,
         *,
-        task_type: TaskTypeType,
+        task_type: TaskType,
         list_parameters: list[dict[str, Any]],
         list_task_files: list[TaskFiles],
         history_unit_ids: list[int],
@@ -163,7 +184,7 @@ class BaseRunner:
                 raise ValueError(
                     f"No 'zarr_url' key in in {list(single_kwargs.keys())}"
                 )
-        if task_type == "parallel":
+        if task_type == TaskType.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")