fractal-server 2.6.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

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

@@ -0,0 +1,173 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+from fastapi import status
+from sqlmodel import or_
+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 fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import LinkUserGroup
+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 WorkflowTaskV2
+from fractal_server.app.routes.auth import current_active_user
+from fractal_server.app.routes.auth._aux_auth import (
+    _verify_user_belongs_to_group,
+)
+from fractal_server.app.schemas.v2 import TaskGroupReadV2
+from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
+from fractal_server.logger import set_logger
+
+router = APIRouter()
+
+logger = set_logger(__name__)
+
+
+@router.get("/", response_model=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]:
+    """
+    Get all accessible TaskGroups
+    """
+
+    if only_owner:
+        condition = TaskGroupV2.user_id == user.id
+    else:
+        condition = or_(
+            TaskGroupV2.user_id == user.id,
+            TaskGroupV2.user_group_id.in_(
+                select(LinkUserGroup.group_id).where(
+                    LinkUserGroup.user_id == user.id
+                )
+            ),
+        )
+    stm = select(TaskGroupV2).where(condition)
+    if only_active:
+        stm = stm.where(TaskGroupV2.active)
+
+    res = await db.execute(stm)
+    task_groups = res.scalars().all()
+
+    if args_schema is False:
+        for taskgroup in task_groups:
+            for task in taskgroup.task_list:
+                setattr(task, "args_schema_non_parallel", None)
+                setattr(task, "args_schema_parallel", None)
+
+    return task_groups
+
+
+@router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
+async def get_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Get single TaskGroup
+    """
+    task_group = await _get_task_group_read_access(
+        task_group_id=task_group_id,
+        user_id=user.id,
+        db=db,
+    )
+    return task_group
+
+
+@router.delete("/{task_group_id}/", status_code=204)
+async def delete_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """
+    Delete single TaskGroup
+    """
+
+    task_group = await _get_task_group_full_access(
+        task_group_id=task_group_id,
+        user_id=user.id,
+        db=db,
+    )
+
+    stm = select(WorkflowTaskV2).where(
+        WorkflowTaskV2.task_id.in_({task.id for task in task_group.task_list})
+    )
+    res = await db.execute(stm)
+    workflow_tasks = res.scalars().all()
+    if workflow_tasks != []:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
+        )
+
+    # Cascade operations: set foreign-keys to null for CollectionStateV2 which
+    # are in relationship with the current TaskGroupV2
+    logger.debug("Start of cascade operations on CollectionStateV2.")
+    stm = select(CollectionStateV2).where(
+        CollectionStateV2.taskgroupv2_id == task_group_id
+    )
+    res = await db.execute(stm)
+    collection_states = res.scalars().all()
+    for collection_state in collection_states:
+        logger.debug(
+            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
+            "to None."
+        )
+        collection_state.taskgroupv2_id = None
+        db.add(collection_state)
+    logger.debug("End of cascade operations on CollectionStateV2.")
+
+    await db.delete(task_group)
+    await db.commit()
+
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.patch("/{task_group_id}/", response_model=TaskGroupReadV2)
+async def patch_task_group(
+    task_group_id: int,
+    task_group_update: TaskGroupUpdateV2,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Patch single TaskGroup
+    """
+    task_group = await _get_task_group_full_access(
+        task_group_id=task_group_id,
+        user_id=user.id,
+        db=db,
+    )
+    if (
+        "user_group_id" in task_group_update.dict(exclude_unset=True)
+        and task_group_update.user_group_id != task_group.user_group_id
+    ):
+        await _verify_non_duplication_group_constraint(
+            db=db,
+            pkg_name=task_group.pkg_name,
+            version=task_group.version,
+            user_group_id=task_group_update.user_group_id,
+        )
+    for key, value in task_group_update.dict(exclude_unset=True).items():
+        if (key == "user_group_id") and (value is not None):
+            await _verify_user_belongs_to_group(
+                user_id=user.id, user_group_id=value, db=db
+            )
+        setattr(task_group, key, value)
+
+    db.add(task_group)
+    await db.commit()
+    await db.refresh(task_group)
+    return task_group

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

@@ -7,29 +7,25 @@ from fastapi import Response
 from fastapi import status
 from sqlmodel import select
 
-from .....logger import reset_logger_handlers
-from .....logger import set_logger
 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 WorkflowTaskCreateV2
+from ....schemas.v2 import WorkflowReadV2WithWarnings
 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()
 
 
@@ -89,14 +85,14 @@ async def create_workflow(
 
 @router.get(
     "/project/{project_id}/workflow/{workflow_id}/",
-    response_model=WorkflowReadV2,
+    response_model=WorkflowReadV2WithWarnings,
 )
 async def read_workflow(
     project_id: int,
     workflow_id: int,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2]:
+) -> Optional[WorkflowReadV2WithWarnings]:
     """
     Get info on an existing workflow
     """
@@ -108,12 +104,21 @@ async def read_workflow(
         db=db,
     )
 
-    return workflow
+    wftask_list_with_warnings = await _add_warnings_to_workflow_tasks(
+        wftask_list=workflow.task_list, user_id=user.id, db=db
+    )
+    workflow_data = dict(
+        **workflow.model_dump(),
+        project=workflow.project,
+        task_list=wftask_list_with_warnings,
+    )
+
+    return workflow_data
 
 
 @router.patch(
     "/project/{project_id}/workflow/{workflow_id}/",
-    response_model=WorkflowReadV2,
+    response_model=WorkflowReadV2WithWarnings,
 )
 async def update_workflow(
     project_id: int,
@@ -121,7 +126,7 @@ async def update_workflow(
     patch: WorkflowUpdateV2,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2]:
+) -> Optional[WorkflowReadV2WithWarnings]:
     """
     Edit a workflow
     """
@@ -163,7 +168,16 @@ async def update_workflow(
     await db.refresh(workflow)
     await db.close()
 
-    return workflow
+    wftask_list_with_warnings = await _add_warnings_to_workflow_tasks(
+        wftask_list=workflow.task_list, user_id=user.id, db=db
+    )
+    workflow_data = dict(
+        **workflow.model_dump(),
+        project=workflow.project,
+        task_list=wftask_list_with_warnings,
+    )
+
+    return workflow_data
 
 
 @router.delete(
@@ -238,98 +252,21 @@ async def export_worfklow(
         user_id=user.id,
         db=db,
     )
-    # Emit a warning when exporting a workflow with custom tasks
-    logger = set_logger(None)
+    wf_task_list = []
     for wftask in workflow.task_list:
-        if wftask.task.owner is not None:
-            logger.warning(
-                f"Custom tasks (like the one with id={wftask.task_id} and "
-                f'source="{wftask.task.source}") are not meant to be '
-                "portable; re-importing this workflow may not work as "
-                "expected."
-            )
-    reset_logger_handlers(logger)
-
-    await db.close()
-    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,
+        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])