fractal-server 2.7.0a5__tar.gz → 2.7.0a6__tar.gz

{fractal_server-2.7.0a5 → fractal_server-2.7.0a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.7.0a5
+Version: 2.7.0a6
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause

fractal_server-2.7.0a6/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.7.0a6"

{fractal_server-2.7.0a5 → fractal_server-2.7.0a6}/fractal_server/app/routes/api/v2/__init__.py

@@ -14,6 +14,7 @@ from .task_collection import router as task_collection_router_v2
 from .task_collection_custom import router as task_collection_router_v2_custom
 from .task_group import router as task_group_router_v2
 from .workflow import router as workflow_router_v2
+from .workflow_import import router as workflow_import_router_v2
 from .workflowtask import router as workflowtask_router_v2
 from fractal_server.config import get_settings
 from fractal_server.syringe import Inject
@@ -42,5 +43,8 @@ router_api_v2.include_router(
     task_group_router_v2, prefix="/task-group", tags=["V2 TaskGroup"]
 )
 router_api_v2.include_router(workflow_router_v2, tags=["V2 Workflow"])
+router_api_v2.include_router(
+    workflow_import_router_v2, tags=["V2 Workflow Import"]
+)
 router_api_v2.include_router(workflowtask_router_v2, tags=["V2 WorkflowTask"])
 router_api_v2.include_router(status_router_v2, tags=["V2 Status"])

{fractal_server-2.7.0a5 → fractal_server-2.7.0a6}/fractal_server/app/routes/api/v2/_aux_functions_tasks.py

@@ -9,13 +9,21 @@ from fastapi import HTTPException
 from fastapi import status
 from sqlmodel import select
 
-from ....db import AsyncSession
-from ....models import LinkUserGroup
-from ....models.v2 import TaskGroupV2
-from ....models.v2 import TaskV2
-from ....models.v2 import WorkflowTaskV2
-from ...auth._aux_auth import _get_default_usergroup_id
-from ...auth._aux_auth import _verify_user_belongs_to_group
+from fractal_server.app.db import AsyncSession
+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.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.models.v2 import TaskV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+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,
+)
+from fractal_server.logger import set_logger
+
+logger = set_logger(__name__)
 
 
 async def _get_task_group_or_404(
@@ -211,6 +219,33 @@ async def _get_valid_user_group_id(
     return user_group_id
 
 
+async def _get_collection_status_message(
+    task_group: TaskGroupV2, db: AsyncSession
+) -> str:
+    res = await db.execute(
+        select(CollectionStateV2).where(
+            CollectionStateV2.taskgroupv2_id == task_group.id
+        )
+    )
+    states = res.scalars().all()
+    if len(states) > 1:
+        msg = (
+            "Expected one CollectionStateV2 associated to TaskGroup "
+            f"{task_group.id}, found {len(states)} "
+            f"(IDs: {[state.id for state in states]}).\n"
+            "Warning: this should have not happened, please contact an admin."
+        )
+    elif len(states) == 1:
+        msg = (
+            f"\nThere exists a task collection state (ID={states[0].id}) for "
+            f"this task group (ID={task_group.id}), with status "
+            f"{states[0].data.get('status')}."
+        )
+    else:
+        msg = ""
+    return msg
+
+
 async def _verify_non_duplication_user_constraint(
     db: AsyncSession,
     user_id: int,
@@ -226,11 +261,24 @@ async def _verify_non_duplication_user_constraint(
     res = await db.execute(stm)
     duplicate = res.scalars().all()
     if duplicate:
+        user = await db.get(UserOAuth, user_id)
+        if len(duplicate) > 1:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=(
+                    "Invalid state:\n"
+                    f"User '{user.email}' already owns {len(duplicate)} task "
+                    f"groups with name='{pkg_name}' and {version=} "
+                    f"(IDs: {[group.id for group in duplicate]}).\n"
+                    "This should have not happened: please contact an admin."
+                ),
+            )
+        state_msg = await _get_collection_status_message(duplicate[0], db)
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
-                "There is already a TaskGroupV2 with "
-                f"({pkg_name=}, {version=}, {user_id=})."
+                f"User '{user.email}' already owns a task group "
+                f"with name='{pkg_name}' and {version=}.{state_msg}"
             ),
         )
 
@@ -253,11 +301,24 @@ async def _verify_non_duplication_group_constraint(
     res = await db.execute(stm)
     duplicate = res.scalars().all()
     if duplicate:
+        user_group = await db.get(UserGroup, user_group_id)
+        if len(duplicate) > 1:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=(
+                    "Invalid state:\n"
+                    f"UserGroup '{user_group.name}' already owns "
+                    f"{len(duplicate)} task groups with name='{pkg_name}' and "
+                    f"{version=} (IDs: {[group.id for group in duplicate]}).\n"
+                    "This should have not happened: please contact an admin."
+                ),
+            )
+        state_msg = await _get_collection_status_message(duplicate[0], db)
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
-                "There is already a TaskGroupV2 with "
-                f"({pkg_name=}, {version=}, {user_group_id=})."
+                f"UserGroup {user_group.name} already owns a task group "
+                f"with {pkg_name=} and {version=}.{state_msg}"
             ),
         )
 

{fractal_server-2.7.0a5 → fractal_server-2.7.0a6}/fractal_server/app/routes/api/v2/workflow.py

@@ -11,25 +11,21 @@ from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import JobV2
 from ....models.v2 import ProjectV2
-from ....models.v2 import TaskV2
 from ....models.v2 import WorkflowV2
 from ....schemas.v2 import WorkflowCreateV2
 from ....schemas.v2 import WorkflowExportV2
-from ....schemas.v2 import WorkflowImportV2
 from ....schemas.v2 import WorkflowReadV2
 from ....schemas.v2 import WorkflowReadV2WithWarnings
-from ....schemas.v2 import WorkflowTaskCreateV2
 from ....schemas.v2 import WorkflowUpdateV2
 from ._aux_functions import _check_workflow_exists
 from ._aux_functions import _get_project_check_owner
 from ._aux_functions import _get_submitted_jobs_statement
 from ._aux_functions import _get_workflow_check_owner
-from ._aux_functions import _workflow_insert_task
 from ._aux_functions_tasks import _add_warnings_to_workflow_tasks
 from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2.task import TaskGroupV2
 from fractal_server.app.routes.auth import current_active_user
 
-
 router = APIRouter()
 
 
@@ -256,85 +252,21 @@ async def export_worfklow(
         user_id=user.id,
         db=db,
     )
-    return workflow
-
-
-@router.post(
-    "/project/{project_id}/workflow/import/",
-    response_model=WorkflowReadV2,
-    status_code=status.HTTP_201_CREATED,
-)
-async def import_workflow(
-    project_id: int,
-    workflow: WorkflowImportV2,
-    user: UserOAuth = Depends(current_active_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2]:
-    """
-    Import an existing workflow into a project
-
-    Also create all required objects (i.e. Workflow and WorkflowTask's) along
-    the way.
-    """
-
-    # Preliminary checks
-    await _get_project_check_owner(
-        project_id=project_id,
-        user_id=user.id,
-        db=db,
-    )
-
-    await _check_workflow_exists(
-        name=workflow.name, project_id=project_id, db=db
-    )
-
-    # Check that all required tasks are available
-    source_to_id = {}
-
-    for wf_task in workflow.task_list:
-
-        source = wf_task.task.source
-        if source not in source_to_id.keys():
-            stm = select(TaskV2).where(TaskV2.source == source)
-            tasks_by_source = (await db.execute(stm)).scalars().all()
-            if len(tasks_by_source) != 1:
-                raise HTTPException(
-                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                    detail=(
-                        f"Found {len(tasks_by_source)} tasks "
-                        f"with {source=}."
-                    ),
-                )
-            source_to_id[source] = tasks_by_source[0].id
-
-    # Create new Workflow (with empty task_list)
-    db_workflow = WorkflowV2(
-        project_id=project_id,
-        **workflow.dict(exclude_none=True, exclude={"task_list"}),
-    )
-    db.add(db_workflow)
-    await db.commit()
-    await db.refresh(db_workflow)
-
-    # Insert tasks
-
-    for wf_task in workflow.task_list:
-        source = wf_task.task.source
-        task_id = source_to_id[source]
-
-        new_wf_task = WorkflowTaskCreateV2(
-            **wf_task.dict(exclude_none=True, exclude={"task"})
-        )
-        # Insert task
-        await _workflow_insert_task(
-            **new_wf_task.dict(),
-            workflow_id=db_workflow.id,
-            task_id=task_id,
-            db=db,
+    wf_task_list = []
+    for wftask in workflow.task_list:
+        task_group = await db.get(TaskGroupV2, wftask.task.taskgroupv2_id)
+        wf_task_list.append(wftask.dict())
+        wf_task_list[-1]["task"] = dict(
+            pkg_name=task_group.pkg_name,
+            version=task_group.version,
+            name=wftask.task.name,
         )
 
-    await db.close()
-    return db_workflow
+    wf = WorkflowExportV2(
+        **workflow.model_dump(),
+        task_list=wf_task_list,
+    )
+    return wf
 
 
 @router.get("/workflow/", response_model=list[WorkflowReadV2])

fractal_server-2.7.0a6/fractal_server/app/routes/api/v2/workflow_import.py

@@ -0,0 +1,355 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import status
+from sqlmodel import or_
+from sqlmodel import select
+
+from ....db import AsyncSession
+from ....db import get_async_db
+from ....models.v2 import TaskV2
+from ....models.v2 import WorkflowV2
+from ....schemas.v2 import TaskImportV2Legacy
+from ....schemas.v2 import WorkflowImportV2
+from ....schemas.v2 import WorkflowReadV2WithWarnings
+from ....schemas.v2 import WorkflowTaskCreateV2
+from ._aux_functions import _check_workflow_exists
+from ._aux_functions import _get_project_check_owner
+from ._aux_functions import _workflow_insert_task
+from ._aux_functions_tasks import _add_warnings_to_workflow_tasks
+from fractal_server.app.models import LinkUserGroup
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2.task import TaskGroupV2
+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.task import TaskImportV2
+from fractal_server.logger import set_logger
+
+router = APIRouter()
+
+
+logger = set_logger(__name__)
+
+
+async def _get_user_accessible_taskgroups(
+    *,
+    user_id: int,
+    db: AsyncSession,
+) -> list[TaskGroupV2]:
+    """
+    Retrieve list of task groups that the user has access to.
+    """
+    stm = select(TaskGroupV2).where(
+        or_(
+            TaskGroupV2.user_id == user_id,
+            TaskGroupV2.user_group_id.in_(
+                select(LinkUserGroup.group_id).where(
+                    LinkUserGroup.user_id == user_id
+                )
+            ),
+        )
+    )
+    res = await db.execute(stm)
+    accessible_task_groups = res.scalars().all()
+    logger.info(
+        f"Found {len(accessible_task_groups)} accessible "
+        f"task groups for {user_id=}."
+    )
+    return accessible_task_groups
+
+
+async def _get_task_by_source(
+    source: str,
+    task_groups_list: list[TaskGroupV2],
+) -> Optional[int]:
+    """
+    Find task with a given source.
+
+    Args:
+        task_import: Info on task to be imported.
+        user_id: ID of current user.
+        default_group_id: ID of default user group.
+        task_group_list: Current list of valid task groups.
+        db: Asynchronous db session
+
+    Return:
+        `id` of the matching task, or `None`.
+    """
+    task_id = next(
+        iter(
+            task.id
+            for task_group in task_groups_list
+            for task in task_group.task_list
+            if task.source == source
+        ),
+        None,
+    )
+    return task_id
+
+
+async def _disambiguate_task_groups(
+    *,
+    matching_task_groups: list[TaskGroupV2],
+    user_id: int,
+    db: AsyncSession,
+    default_group_id: int,
+) -> Optional[TaskV2]:
+    """
+    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,
+    task_groups_list: list[TaskGroupV2],
+    user_id: int,
+    default_group_id: int,
+    db: AsyncSession,
+) -> Optional[int]:
+    """
+    Find a task based on `task_import`.
+
+    Args:
+        task_import: Info on task to be imported.
+        user_id: ID of current user.
+        default_group_id: ID of default user group.
+        task_group_list: Current list of valid task groups.
+        db: Asynchronous db session
+
+    Return:
+        `id` of the matching task, or `None`.
+    """
+
+    logger.info(f"[_get_task_by_taskimport] START, {task_import=}")
+
+    # Filter by `pkg_name` and by presence of a task with given `name`.
+    matching_task_groups = [
+        task_group
+        for task_group in task_groups_list
+        if (
+            task_group.pkg_name == task_import.pkg_name
+            and task_import.name
+            in [task.name for task in task_group.task_list]
+        )
+    ]
+    if len(matching_task_groups) < 1:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            f"No task group with {task_import.pkg_name=} "
+            f"and a task with {task_import.name=}."
+        )
+        return None
+
+    # Determine target `version`
+    # Note that task_import.version cannot be "", due to a validator
+    if task_import.version is None:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "No version requested, looking for latest."
+        )
+        latest_task = max(
+            matching_task_groups, key=lambda tg: tg.version or ""
+        )
+        version = latest_task.version
+        logger.info(
+            f"[_get_task_by_taskimport] Latest version set to {version}."
+        )
+    else:
+        version = task_import.version
+
+    # Filter task groups by version
+    final_matching_task_groups = list(
+        filter(lambda tg: tg.version == version, task_groups_list)
+    )
+
+    if len(final_matching_task_groups) < 1:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "No task group left after filtering by version."
+        )
+        return None
+    elif len(final_matching_task_groups) == 1:
+        final_task_group = final_matching_task_groups[0]
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "Found a single task group, after filtering by version."
+        )
+    else:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "Found many task groups, after filtering by version."
+        )
+        final_task_group = await _disambiguate_task_groups(
+            matching_task_groups, user_id, db, default_group_id
+        )
+        if final_task_group is None:
+            logger.info(
+                "[_get_task_by_taskimport] Disambiguation returned None."
+            )
+            return None
+
+    # Find task with given name
+    task_id = next(
+        iter(
+            task.id
+            for task in final_task_group.task_list
+            if task.name == task_import.name
+        ),
+        None,
+    )
+
+    logger.info(f"[_get_task_by_taskimport] END, {task_import=}, {task_id=}.")
+
+    return task_id
+
+
+@router.post(
+    "/project/{project_id}/workflow/import/",
+    response_model=WorkflowReadV2WithWarnings,
+    status_code=status.HTTP_201_CREATED,
+)
+async def import_workflow(
+    project_id: int,
+    workflow_import: WorkflowImportV2,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> WorkflowReadV2WithWarnings:
+    """
+    Import an existing workflow into a project and create required objects.
+    """
+
+    # Preliminary checks
+    await _get_project_check_owner(
+        project_id=project_id,
+        user_id=user.id,
+        db=db,
+    )
+    await _check_workflow_exists(
+        name=workflow_import.name,
+        project_id=project_id,
+        db=db,
+    )
+
+    task_group_list = await _get_user_accessible_taskgroups(
+        user_id=user.id,
+        db=db,
+    )
+    default_group_id = await _get_default_usergroup_id(db)
+
+    list_wf_tasks = []
+    for wf_task in workflow_import.task_list:
+        task_import = wf_task.task
+        if isinstance(task_import, TaskImportV2Legacy):
+            task_id = await _get_task_by_source(
+                source=task_import.source,
+                task_groups_list=task_group_list,
+            )
+        else:
+            task_id = await _get_task_by_taskimport(
+                task_import=task_import,
+                user_id=user.id,
+                default_group_id=default_group_id,
+                task_groups_list=task_group_list,
+                db=db,
+            )
+        if task_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Could not find a task matching with {wf_task.task}.",
+            )
+        new_wf_task = WorkflowTaskCreateV2(
+            **wf_task.dict(exclude_none=True, exclude={"task"})
+        )
+        list_wf_tasks.append(new_wf_task)
+
+    # Create new Workflow
+    db_workflow = WorkflowV2(
+        project_id=project_id,
+        **workflow_import.dict(exclude_none=True, exclude={"task_list"}),
+    )
+    db.add(db_workflow)
+    await db.commit()
+    await db.refresh(db_workflow)
+
+    # Insert task into the workflow
+    for new_wf_task in list_wf_tasks:
+        await _workflow_insert_task(
+            **new_wf_task.dict(),
+            workflow_id=db_workflow.id,
+            task_id=task_id,
+            db=db,
+        )
+
+    # Add warnings for non-active tasks (or non-accessible tasks,
+    # although that should never happen)
+    wftask_list_with_warnings = await _add_warnings_to_workflow_tasks(
+        wftask_list=db_workflow.task_list, user_id=user.id, db=db
+    )
+    workflow_data = dict(
+        **db_workflow.model_dump(),
+        project=db_workflow.project,
+        task_list=wftask_list_with_warnings,
+    )
+
+    return workflow_data

{fractal_server-2.7.0a5 → fractal_server-2.7.0a6}/fractal_server/app/routes/auth/group.py

@@ -19,10 +19,12 @@ from fractal_server.app.db import get_async_db
 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
+from fractal_server.app.schemas.user_settings import UserSettingsUpdate
 from fractal_server.app.security import FRACTAL_DEFAULT_GROUP_NAME
 from fractal_server.logger import set_logger
 
@@ -212,3 +214,28 @@ async def delete_single_group(
     await db.commit()
 
     return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router_group.patch("/group/{group_id}/user-settings/", status_code=200)
+async def patch_user_settings_bulk(
+    group_id: int,
+    settings_update: UserSettingsUpdate,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+):
+    await _usergroup_or_404(group_id, db)
+    res = await db.execute(
+        select(UserSettings)
+        .join(UserOAuth)
+        .where(LinkUserGroup.user_id == UserOAuth.id)
+        .where(LinkUserGroup.group_id == group_id)
+    )
+    settings_list = res.scalars().all()
+    update = settings_update.dict(exclude_unset=True)
+    for settings in settings_list:
+        for k, v in update.items():
+            setattr(settings, k, v)
+        db.add(settings)
+    await db.commit()
+
+    return Response(status_code=status.HTTP_200_OK)