fractal-server 2.7.0a5__py3-none-any.whl → 2.7.0a6__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.7.0a5"
+__VERSION__ = "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/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/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/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/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)

fractal_server/app/runner/v2/__init__.py

@@ -177,11 +177,13 @@ async def submit_workflow(
             return
 
         try:
-
             # Create WORKFLOW_DIR_LOCAL
-            original_umask = os.umask(0)
-            WORKFLOW_DIR_LOCAL.mkdir(parents=True, mode=0o755)
-            os.umask(original_umask)
+            if FRACTAL_RUNNER_BACKEND == "slurm":
+                original_umask = os.umask(0)
+                WORKFLOW_DIR_LOCAL.mkdir(parents=True, mode=0o755)
+                os.umask(original_umask)
+            else:
+                WORKFLOW_DIR_LOCAL.mkdir(parents=True)
 
             # Define and create WORKFLOW_DIR_REMOTE
             if FRACTAL_RUNNER_BACKEND == "local":
@@ -214,15 +216,19 @@ async def submit_workflow(
                     order=order,
                     task_name=task_name,
                 )
-                original_umask = os.umask(0)
-                (WORKFLOW_DIR_LOCAL / subfolder_name).mkdir(mode=0o755)
-                os.umask(original_umask)
                 if FRACTAL_RUNNER_BACKEND == "slurm":
+                    # Create local subfolder (with 755) and remote one
+                    # (via `sudo -u`)
+                    original_umask = os.umask(0)
+                    (WORKFLOW_DIR_LOCAL / subfolder_name).mkdir(mode=0o755)
+                    os.umask(original_umask)
                     _mkdir_as_user(
                         folder=str(WORKFLOW_DIR_REMOTE / subfolder_name),
                         user=slurm_user,
                     )
                 else:
+                    # Create local subfolder (with standard permission set)
+                    (WORKFLOW_DIR_LOCAL / subfolder_name).mkdir()
                     logger.info("Skip remote-subfolder creation")
         except Exception as e:
             error_type = type(e).__name__

fractal_server/app/schemas/v2/__init__.py

@@ -20,6 +20,7 @@ from .project import ProjectUpdateV2  # noqa F401
 from .task import TaskCreateV2  # noqa F401
 from .task import TaskExportV2  # noqa F401
 from .task import TaskImportV2  # noqa F401
+from .task import TaskImportV2Legacy  # noqa F401
 from .task import TaskReadV2  # noqa F401
 from .task import TaskUpdateV2  # noqa F401
 from .task_collection import CollectionStateReadV2  # noqa F401

fractal_server/app/schemas/v2/manifest.py

@@ -159,6 +159,19 @@ class ManifestV2(BaseModel):
                         )
         return values
 
+    @root_validator()
+    def _unique_task_names(cls, values):
+        task_list = values["task_list"]
+        task_list_names = [t.name for t in task_list]
+        if len(set(task_list_names)) != len(task_list_names):
+            raise ValueError(
+                (
+                    "Task names in manifest must be unique.\n",
+                    f"Given: {task_list_names}.",
+                )
+            )
+        return values
+
     @validator("manifest_version")
     def manifest_version_2(cls, value):
         if value != "2":

fractal_server/app/schemas/v2/task.py

@@ -134,7 +134,6 @@ class TaskReadV2(BaseModel):
 
 class TaskUpdateV2(BaseModel, extra=Extra.forbid):
 
-    name: Optional[str] = None
     command_parallel: Optional[str] = None
     command_non_parallel: Optional[str] = None
     input_types: Optional[dict[str, bool]] = None
@@ -152,8 +151,6 @@ class TaskUpdateV2(BaseModel, extra=Extra.forbid):
             raise ValueError
         return v
 
-    _name = validator("name", allow_reuse=True)(valstr("name"))
-
     _command_parallel = validator("command_parallel", allow_reuse=True)(
         valstr("command_parallel")
     )
@@ -186,11 +183,29 @@ class TaskUpdateV2(BaseModel, extra=Extra.forbid):
 
 class TaskImportV2(BaseModel, extra=Extra.forbid):
 
+    pkg_name: str
+    version: Optional[str] = None
+    name: str
+    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
+    _version = validator("version", allow_reuse=True)(
+        valstr("version", accept_none=True)
+    )
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+
+
+class TaskImportV2Legacy(BaseModel):
     source: str
     _source = validator("source", allow_reuse=True)(valstr("source"))
 
 
 class TaskExportV2(BaseModel):
 
-    source: Optional[str] = None
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    pkg_name: str
+    version: Optional[str] = None
+    name: str
+
+    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
+    _version = validator("version", allow_reuse=True)(
+        valstr("version", accept_none=True)
+    )
+    _name = validator("name", allow_reuse=True)(valstr("name"))

fractal_server/app/schemas/v2/workflowtask.py

@@ -1,6 +1,7 @@
 from enum import Enum
 from typing import Any
 from typing import Optional
+from typing import Union
 
 from pydantic import BaseModel
 from pydantic import Extra
@@ -10,6 +11,7 @@ from pydantic import validator
 from .._validators import valdictkeys
 from .task import TaskExportV2
 from .task import TaskImportV2
+from .task import TaskImportV2Legacy
 from .task import TaskReadV2
 from fractal_server.images import Filters
 
@@ -157,7 +159,7 @@ class WorkflowTaskImportV2(BaseModel, extra=Extra.forbid):
 
     input_filters: Optional[Filters] = None
 
-    task: TaskImportV2
+    task: Union[TaskImportV2, TaskImportV2Legacy]
 
     _meta_non_parallel = validator("meta_non_parallel", allow_reuse=True)(
         valdictkeys("meta_non_parallel")

fractal_server/data_migrations/2_7_0.py

@@ -1,24 +1,68 @@
+import asyncio
 import logging
 import os
+import sys
 from pathlib import Path
 from typing import Any
+from typing import Optional
 
+from fastapi import HTTPException
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from fractal_server.app.db import get_async_db
 from fractal_server.app.db import get_sync_db
 from fractal_server.app.models import TaskGroupV2
 from fractal_server.app.models import TaskV2
 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.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_group_constraint,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_user_constraint,
+)
 from fractal_server.app.security import FRACTAL_DEFAULT_GROUP_NAME
 from fractal_server.data_migrations.tools import _check_current_version
+from fractal_server.tasks.utils import _normalize_package_name
 from fractal_server.utils import get_timestamp
 
 logger = logging.getLogger("fix_db")
 
 
+async def check_non_duplication_constraints(
+    *,
+    user_id: int,
+    pkg_name: str,
+    version: Optional[str] = None,
+    user_group_id: Optional[int] = None,
+):
+    try:
+        async for db_async in get_async_db():
+            await _verify_non_duplication_user_constraint(
+                user_id=user_id,
+                pkg_name=pkg_name,
+                version=version,
+                db=db_async,
+            )
+            await _verify_non_duplication_group_constraint(
+                user_group_id=user_group_id,
+                pkg_name=pkg_name,
+                version=version,
+                db=db_async,
+            )
+    except HTTPException as e:
+        logger.error(
+            "Adding a `TaskGroupV2` with "
+            f"{user_id=}, {pkg_name=}, {version=} and {user_group_id=} "
+            "would break the non-duplication constraint."
+        )
+        logger.error(f"Original error: {str(e)}")
+
+        sys.exit("ERROR")
+
+
 def get_unique_value(list_of_objects: list[dict[str, Any]], key: str):
     """
     Loop over `list_of_objects` and extract (unique) value for `key`.
@@ -29,8 +73,7 @@ def get_unique_value(list_of_objects: list[dict[str, Any]], key: str):
         unique_values.add(this_value)
     if len(unique_values) != 1:
         raise RuntimeError(
-            f"There must be a single taskgroup `{key}`, "
-            f"but {unique_values=}"
+            f"There must be a single taskgroup `{key}`, but {unique_values=}"
         )
     return unique_values.pop()
 
@@ -85,7 +128,6 @@ def get_default_user_group_id(db):
 
 
 def get_default_user_id(db):
-
     DEFAULT_USER_EMAIL = os.getenv("FRACTAL_V27_DEFAULT_USER_EMAIL")
     if DEFAULT_USER_EMAIL is None:
         raise ValueError(
@@ -129,6 +171,7 @@ def prepare_task_groups(
                 python_version,
                 name,
             ) = source_fields
+            pkg_name = _normalize_package_name(pkg_name)
             task_group_key = ":".join(
                 [pkg_name, version, extras, python_version]
             )
@@ -235,6 +278,21 @@ def prepare_task_groups(
 
         print()
 
+        # Verify non-duplication constraints
+        asyncio.run(
+            check_non_duplication_constraints(
+                user_id=task_group_attributes["user_id"],
+                user_group_id=task_group_attributes["user_group_id"],
+                pkg_name=task_group_attributes["pkg_name"],
+                version=task_group_attributes["version"],
+            )
+        )
+        logger.warning(
+            "Non-duplication-constraint check is OK, "
+            "proceed and create TaskGroupV2."
+        )
+
+        # Create the TaskGroupV2 object and commit it
         task_group = TaskGroupV2(**task_group_attributes)
         db.add(task_group)
         db.commit()
@@ -262,3 +320,4 @@ def fix_db():
         )
 
     logger.warning("END of execution of fix_db function")
+    print()

{fractal_server-2.7.0a5.dist-info → fractal_server-2.7.0a6.dist-info}/METADATA

@@ -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.0a5.dist-info → fractal_server-2.7.0a6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fractal_server/__init__.py,sha256=LopKUzFTVHSgqDIY04paIgEGCB_DHbQtFlfZxiuBeDw,24
+fractal_server/__init__.py,sha256=wo5njXZ8nQYxNzQXX7h4A4LZLPdev2ZguHqnLTKX48Q,24
 fractal_server/__main__.py,sha256=dEkCfzLLQrIlxsGC-HBfoR-RBMWnJDgNrxYTyzmE9c0,6146
 fractal_server/alembic.ini,sha256=MWwi7GzjzawI9cCAK1LW7NxIBQDUqD12-ptJoq5JpP0,3153
 fractal_server/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -41,9 +41,9 @@ fractal_server/app/routes/api/v1/task.py,sha256=eW89nMCjpD4G6tHXDo2qGBKqWaPirjH6
 fractal_server/app/routes/api/v1/task_collection.py,sha256=5EMh3yhS1Z4x25kp5Iaxalrf7RgJh-XD1nBjrFvgwsg,9072
 fractal_server/app/routes/api/v1/workflow.py,sha256=2T93DuEnSshaDCue-JPmjuvGCtbk6lt9pFMuPt783t8,11217
 fractal_server/app/routes/api/v1/workflowtask.py,sha256=OYYConwJbmNULDw5I3T-UbSJKrbbBiAHbbBeVcpoFKQ,5785
-fractal_server/app/routes/api/v2/__init__.py,sha256=_2Yce3aFT-t2FF_Yk_KbNgmG4FJKXlY3QTqib64yhIs,1807
+fractal_server/app/routes/api/v2/__init__.py,sha256=jybEV-vrknPoQvbgKJl0QQvHDPHOJXbDUG5vatHeis4,1963
 fractal_server/app/routes/api/v2/_aux_functions.py,sha256=mb4R_qqFxeW0LAis2QJIIfVx8Sydv1jTYaRIMsMxnIk,11720
-fractal_server/app/routes/api/v2/_aux_functions_tasks.py,sha256=rgBi9KrbewTVwsd2aUAFZ4VZpAZml2q6-ekmIkK_vY0,7969
+fractal_server/app/routes/api/v2/_aux_functions_tasks.py,sha256=8CTlmPvCGpdsDAEFFCCj50vbkrqTlNrpr5O0G-FJR0A,10559
 fractal_server/app/routes/api/v2/dataset.py,sha256=Eilf_BAGjicIhqUiVwI86jlW45ineA5sVzxXW4b2GoQ,8329
 fractal_server/app/routes/api/v2/images.py,sha256=JR1rR6qEs81nacjriOXAOBQjAbCXF4Ew7M7mkWdxBU0,7920
 fractal_server/app/routes/api/v2/job.py,sha256=Bga2Kz1OjvDIdxZObWaaXVhNIhC_5JKhKRjEH2_ayEE,5157
@@ -54,12 +54,13 @@ fractal_server/app/routes/api/v2/task.py,sha256=R_1bCinQvNrkEh6uAguNNfimduz1uJzg
 fractal_server/app/routes/api/v2/task_collection.py,sha256=gCxOwigT_tfs8lCDNoE7nxl9-9iuRp1gW__3YXqsioc,11478
 fractal_server/app/routes/api/v2/task_collection_custom.py,sha256=9T0U_4gqrQbJCy6uFDCMSZ-b1sfNIzyz_qm4P41W2Gs,6133
 fractal_server/app/routes/api/v2/task_group.py,sha256=wOLoqBnoeOIefRN5juhrjm2luGK6E_sF79umKirwWu8,5313
-fractal_server/app/routes/api/v2/workflow.py,sha256=jxBgxjKjrtO8T9Y-IOZb1az9NeuhUY4Ma5wd-1uvvoE,10575
+fractal_server/app/routes/api/v2/workflow.py,sha256=PyvkrUHHzFGUGZE5X0VW5u3DPQA7wtXXNcEpG7-N66I,8687
+fractal_server/app/routes/api/v2/workflow_import.py,sha256=l39EKsyNwkkLaj-LNUh2GEG_6GtTq-8xyPbPmXwEYBM,10807
 fractal_server/app/routes/api/v2/workflowtask.py,sha256=ciHTwXXFiFnMF7ZpJ3Xs0q6YfuZrFvIjqndlzAEdZpo,6969
 fractal_server/app/routes/auth/__init__.py,sha256=fao6CS0WiAjHDTvBzgBVV_bSXFpEAeDBF6Z6q7rRkPc,1658
 fractal_server/app/routes/auth/_aux_auth.py,sha256=ifkNocTYatBSMYGwiR14qohmvR9SfMldceiEj6uJBrU,4783
 fractal_server/app/routes/auth/current_user.py,sha256=v767HGi8k076ZHoErlU4Vv0_c8HQqYmi8ncjzZZDaDE,4455
-fractal_server/app/routes/auth/group.py,sha256=riav97YGJHqAwcbjbZcSYPfx8kEnyUnYe37155dMAmU,6548
+fractal_server/app/routes/auth/group.py,sha256=dSS7r8J2cejZ6sKnOWAPSDKynxD9VyBNtqDbFpySzIU,7489
 fractal_server/app/routes/auth/login.py,sha256=tSu6OBLOieoBtMZB4JkBAdEgH2Y8KqPGSbwy7NIypIo,566
 fractal_server/app/routes/auth/oauth.py,sha256=AnFHbjqL2AgBX3eksI931xD6RTtmbciHBEuGf9YJLjU,1895
 fractal_server/app/routes/auth/register.py,sha256=DlHq79iOvGd_gt2v9uwtsqIKeO6i_GKaW59VIkllPqY,587
@@ -106,7 +107,7 @@ fractal_server/app/runner/v1/_slurm/_submit_setup.py,sha256=KO9c694d318adoPQh9UG
 fractal_server/app/runner/v1/_slurm/get_slurm_config.py,sha256=6pQNNx997bLIfLp0guF09t_O0ZYRXnbEGLktSAcKnic,5999
 fractal_server/app/runner/v1/common.py,sha256=_L-vjLnWato80VdlB_BFN4G8P4jSM07u-5cnl1T3S34,3294
 fractal_server/app/runner/v1/handle_failed_job.py,sha256=bHzScC_aIlU3q-bQxGW6rfWV4xbZ2tho_sktjsAs1no,4684
-fractal_server/app/runner/v2/__init__.py,sha256=BkmaVbhh6XMK_Y2Suzz3bXm3Ff2l0JKbHqs8zp0hi8A,16965
+fractal_server/app/runner/v2/__init__.py,sha256=4RTlY34bOqgmzqVHXER0-lpnKaG15boMgDyf1L40JWg,17362
 fractal_server/app/runner/v2/_local/__init__.py,sha256=KTj14K6jH8fXGUi5P7u5_RqEE1zF4aXtgPxCKzw46iw,5971
 fractal_server/app/runner/v2/_local/_local_config.py,sha256=9oi209Dlp35ANfxb_DISqmMKKc6DPaMsmYVWbZLseME,3630
 fractal_server/app/runner/v2/_local/_submit_setup.py,sha256=MucNOo8Er0F5ZIwH7CnTeXgnFMc6d3pKPkv563QNVi0,1630
@@ -144,22 +145,22 @@ fractal_server/app/schemas/v1/state.py,sha256=GYeOE_1PtDOgu5W4t_3gw3DBHXH2aCGzIN
 fractal_server/app/schemas/v1/task.py,sha256=7BxOZ_qoRQ8n3YbQpDvB7VMcxB5fSYQmR5RLIWhuJ5U,3704
 fractal_server/app/schemas/v1/task_collection.py,sha256=uvq9bcMaGD_qHsh7YtcpoSAkVAbw12eY4DocIO3MKOg,3057
 fractal_server/app/schemas/v1/workflow.py,sha256=tuOs5E5Q_ozA8if7YPZ07cQjzqB_QMkBS4u92qo4Ro0,4618
-fractal_server/app/schemas/v2/__init__.py,sha256=BHbRPSBLjGaCpmjd8OJSycKhBLfZY5b1lj0z9sLR17o,2273
+fractal_server/app/schemas/v2/__init__.py,sha256=G44JgD_i_zCpV7yjXcoS5ygOS3IfsIWoktLVZao6TaE,2323
 fractal_server/app/schemas/v2/dataset.py,sha256=865ia13E9mWu1DaYyppKW2csNYglaInrScrprdVYX7A,2552
 fractal_server/app/schemas/v2/dumps.py,sha256=s6dg-pHZFui6t2Ktm0SMxjKDN-v-ZqBHz9iTsBQF3eU,1712
 fractal_server/app/schemas/v2/job.py,sha256=oYSLYkQ0HL83QyjEGIaggtZ117FndzFlONMKWd9sTXM,3270
-fractal_server/app/schemas/v2/manifest.py,sha256=eHfDjth8cSDiuYeDMfBOte8sMHOI74DC0VlhebhUXvY,6545
+fractal_server/app/schemas/v2/manifest.py,sha256=Uqtd7DbyOkf9bxBOKkU7Sv7nToBIFGUcfjY7rd5iO7c,6981
 fractal_server/app/schemas/v2/project.py,sha256=UXEA0UUUe0bFFOVLLmVtvDFLBO5vmD1JVI7EeTIcwDo,756
 fractal_server/app/schemas/v2/status.py,sha256=SQaUpQkjFq5c5k5J4rOjNhuQaDOEg8lksPhkKmPU5VU,332
-fractal_server/app/schemas/v2/task.py,sha256=FRAN7bLQ5sTf3AjcthUYISHcZeHIgf5nhbyfHDuaGU4,6407
+fractal_server/app/schemas/v2/task.py,sha256=FFAbYwDlqowB8gVMdjFVPVHvAM0T89PYLixUth49xfQ,6870
 fractal_server/app/schemas/v2/task_collection.py,sha256=Ddw_7QaQ93kdEIwWQvzLQDu03gho_OHdhah3n0ioK3M,6296
 fractal_server/app/schemas/v2/task_group.py,sha256=F40u64z-wXHNPFjx9RHozzl_SySTHfKFc-sBFyn_e0I,2352
 fractal_server/app/schemas/v2/workflow.py,sha256=HSNQSrBRdoBzh8Igr76FUWCAWvVzykrqmUv1vGv-8og,2026
-fractal_server/app/schemas/v2/workflowtask.py,sha256=zBXmVFozBTIXDzyRtr2Y1ZgDc644OiDpzYgoZVOEp8Y,5662
+fractal_server/app/schemas/v2/workflowtask.py,sha256=vDdMktYbHeYBgB5OuWSv6wRPRXWqvetkeqQ7IC5YtfA,5751
 fractal_server/app/security/__init__.py,sha256=V1NOWlmaFZHMR6SrkMl62jyAuqYONyo8lyGvR6UZesM,12312
 fractal_server/app/user_settings.py,sha256=aZgQ3i0JkHfgwLGW1ee6Gzr1ae3IioFfJKKSsSS8Svk,1312
 fractal_server/config.py,sha256=gX0aYwDwbC5y7JNorifON84YMveubb7XTb4sH14N3KM,23667
-fractal_server/data_migrations/2_7_0.py,sha256=HWReCLmfz_abEzKEAbDflNjH5kQEgTpzjiKCWexNaTk,9133
+fractal_server/data_migrations/2_7_0.py,sha256=DQQJ_tLYFteH3Jw246ovIh3Dac_9SaAefoy7FLw5Cso,11145
 fractal_server/data_migrations/README.md,sha256=_3AEFvDg9YkybDqCLlFPdDmGJvr6Tw7HRI14aZ3LOIw,398
 fractal_server/data_migrations/tools.py,sha256=LeMeASwYGtEqd-3wOLle6WARdTGAimoyMmRbbJl-hAM,572
 fractal_server/gunicorn_fractal.py,sha256=u6U01TLGlXgq1v8QmEpLih3QnsInZD7CqphgJ_GrGzc,1230
@@ -222,8 +223,8 @@ fractal_server/tasks/v2/utils.py,sha256=MnY6MhcxDRo4rPuXo2tQ252eWEPZF3OlCGe-p5Mr
 fractal_server/urls.py,sha256=5o_qq7PzKKbwq12NHSQZDmDitn5RAOeQ4xufu-2v9Zk,448
 fractal_server/utils.py,sha256=jrlCBPmC7F0ptBVcDac-EbZNsdYTLbHfX9oxkXthS5Q,2193
 fractal_server/zip_tools.py,sha256=xYpzBshysD2nmxkD5WLYqMzPYUcCRM3kYy-7n9bJL-U,4426
-fractal_server-2.7.0a5.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
-fractal_server-2.7.0a5.dist-info/METADATA,sha256=lR1xBCbOuECf2yjGLD5DIriG2Lch3vpc5GDgHxv9a9g,4630
-fractal_server-2.7.0a5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fractal_server-2.7.0a5.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
-fractal_server-2.7.0a5.dist-info/RECORD,,
+fractal_server-2.7.0a6.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
+fractal_server-2.7.0a6.dist-info/METADATA,sha256=j1bQm_XclfJGp-wlzf0GSGrt5Klr2Ok37WusYcv4DQw,4630
+fractal_server-2.7.0a6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fractal_server-2.7.0a6.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
+fractal_server-2.7.0a6.dist-info/RECORD,,