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

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

@@ -1,6 +1,5 @@
 import os
 from datetime import datetime
-from datetime import timedelta
 from datetime import timezone
 from pathlib import Path
 from typing import Optional
@@ -32,6 +31,9 @@ from ._aux_functions import _get_dataset_check_owner
 from ._aux_functions import _get_workflow_check_owner
 from ._aux_functions import clean_app_job_list_v2
 from fractal_server.app.models import UserOAuth
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _get_task_read_access,
+)
 from fractal_server.app.routes.auth import current_active_verified_user
 
 
@@ -83,15 +85,14 @@ async def apply_workflow(
     workflow = await _get_workflow_check_owner(
         project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
     )
-
-    if not workflow.task_list:
+    num_tasks = len(workflow.task_list)
+    if num_tasks == 0:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=f"Workflow {workflow_id} has empty task list",
         )
 
     # Set values of first_task_index and last_task_index
-    num_tasks = len(workflow.task_list)
     try:
         first_task_index, last_task_index = set_start_and_last_task_index(
             num_tasks,
@@ -110,6 +111,17 @@ async def apply_workflow(
             ),
         )
 
+    # Check that tasks have read-access and are `active`
+    for wftask in workflow.task_list[
+        first_task_index : last_task_index + 1  # noqa: E203
+    ]:
+        await _get_task_read_access(
+            user_id=user.id,
+            task_id=wftask.task_id,
+            require_active=True,
+            db=db,
+        )
+
     # Validate user settings
     FRACTAL_RUNNER_BACKEND = settings.FRACTAL_RUNNER_BACKEND
     user_settings = await validate_user_settings(
@@ -168,37 +180,6 @@ async def apply_workflow(
         **job_create.dict(),
     )
 
-    # Rate Limiting:
-    # raise `429 TOO MANY REQUESTS` if this endpoint has been called with the
-    # same database keys (Project, Workflow and Datasets) during the last
-    # `settings.FRACTAL_API_SUBMIT_RATE_LIMIT` seconds.
-    stm = (
-        select(JobV2)
-        .where(JobV2.project_id == project_id)
-        .where(JobV2.workflow_id == workflow_id)
-        .where(JobV2.dataset_id == dataset_id)
-    )
-    res = await db.execute(stm)
-    db_jobs = res.scalars().all()
-    if db_jobs and any(
-        abs(
-            job.start_timestamp
-            - db_job.start_timestamp.replace(tzinfo=timezone.utc)
-        )
-        < timedelta(seconds=settings.FRACTAL_API_SUBMIT_RATE_LIMIT)
-        for db_job in db_jobs
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-            detail=(
-                f"The endpoint 'POST /api/v2/project/{project_id}/job/submit/'"
-                " was called several times within an interval of less "
-                f"than {settings.FRACTAL_API_SUBMIT_RATE_LIMIT} seconds, using"
-                " the same foreign keys. If it was intentional, please wait "
-                "and try again."
-            ),
-        )
-
     db.add(job)
     await db.commit()
     await db.refresh(job)

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

@@ -6,23 +6,28 @@ from fastapi import Depends
 from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
+from sqlmodel import func
+from sqlmodel import or_
 from sqlmodel import select
 
-from .....logger import set_logger
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v1 import Task as TaskV1
-from ....models.v2 import TaskV2
-from ....models.v2 import WorkflowTaskV2
-from ....models.v2 import WorkflowV2
-from ....schemas.v2 import TaskCreateV2
-from ....schemas.v2 import TaskReadV2
-from ....schemas.v2 import TaskUpdateV2
-from ...aux.validate_user_settings import verify_user_has_settings
-from ._aux_functions import _get_task_check_owner
+from ._aux_functions_tasks import _get_task_full_access
+from ._aux_functions_tasks import _get_task_read_access
+from ._aux_functions_tasks import _get_valid_user_group_id
+from ._aux_functions_tasks import _verify_non_duplication_group_constraint
+from ._aux_functions_tasks import _verify_non_duplication_user_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 TaskGroupV2
+from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.routes.auth import current_active_user
 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 TaskUpdateV2
+from fractal_server.logger import set_logger
 
 router = APIRouter()
 
@@ -33,13 +38,37 @@ logger = set_logger(__name__)
 async def get_list_task(
     args_schema_parallel: bool = True,
     args_schema_non_parallel: bool = True,
+    category: Optional[str] = None,
+    modality: Optional[str] = None,
+    author: Optional[str] = None,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskReadV2]:
     """
     Get list of available tasks
     """
-    stm = select(TaskV2)
+    stm = (
+        select(TaskV2)
+        .join(TaskGroupV2)
+        .where(TaskGroupV2.id == TaskV2.taskgroupv2_id)
+        .where(
+            or_(
+                TaskGroupV2.user_id == user.id,
+                TaskGroupV2.user_group_id.in_(
+                    select(LinkUserGroup.group_id).where(
+                        LinkUserGroup.user_id == user.id
+                    )
+                ),
+            )
+        )
+    )
+    if category is not None:
+        stm = stm.where(func.lower(TaskV2.category) == category.lower())
+    if modality is not None:
+        stm = stm.where(func.lower(TaskV2.modality) == modality.lower())
+    if author is not None:
+        stm = stm.where(TaskV2.authors.icontains(author))
+
     res = await db.execute(stm)
     task_list = res.scalars().all()
     await db.close()
@@ -62,12 +91,7 @@ async def get_task(
     """
     Get info on a specific task
     """
-    task = await db.get(TaskV2, task_id)
-    await db.close()
-    if not task:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="TaskV2 not found"
-        )
+    task = await _get_task_read_access(task_id=task_id, user_id=user.id, db=db)
     return task
 
 
@@ -79,11 +103,13 @@ async def patch_task(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[TaskReadV2]:
     """
-    Edit a specific task (restricted to superusers and task owner)
+    Edit a specific task (restricted to task owner)
     """
 
     # Retrieve task from database
-    db_task = await _get_task_check_owner(task_id=task_id, user=user, db=db)
+    db_task = await _get_task_full_access(
+        task_id=task_id, user_id=user.id, db=db
+    )
     update = task_update.dict(exclude_unset=True)
 
     # Forbid changes that set a previously unset command
@@ -112,6 +138,8 @@ async def patch_task(
 )
 async def create_task(
     task: TaskCreateV2,
+    user_group_id: Optional[int] = None,
+    private: bool = False,
     user: UserOAuth = Depends(current_active_verified_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[TaskReadV2]:
@@ -119,6 +147,14 @@ async def create_task(
     Create a new task
     """
 
+    # Validate query parameters related to user-group ownership
+    user_group_id = await _get_valid_user_group_id(
+        user_group_id=user_group_id,
+        private=private,
+        user_id=user.id,
+        db=db,
+    )
+
     if task.command_non_parallel is None:
         task_type = "parallel"
     elif task.command_parallel is None:
@@ -148,45 +184,28 @@ async def create_task(
             ),
         )
 
-    # Set task.owner attribute
-    if user.username:
-        owner = user.username
-    else:
-        verify_user_has_settings(user)
-        if user.settings.slurm_user:
-            owner = user.settings.slurm_user
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    "Cannot add a new task because current user does not "
-                    "have `username` or `slurm_user` attributes."
-                ),
-            )
-
-    # Prepend owner to task.source
-    task.source = f"{owner}:{task.source}"
-
-    # Verify that source is not already in use (note: this check is only useful
-    # to provide a user-friendly error message, but `task.source` uniqueness is
-    # already guaranteed by a constraint in the table definition).
-    stm = select(TaskV2).where(TaskV2.source == task.source)
-    res = await db.execute(stm)
-    if res.scalars().all():
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Source '{task.source}' already used by some TaskV2",
-        )
-    stm = select(TaskV1).where(TaskV1.source == task.source)
-    res = await db.execute(stm)
-    if res.scalars().all():
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Source '{task.source}' already used by some TaskV1",
-        )
     # Add task
-    db_task = TaskV2(**task.dict(), owner=owner, type=task_type)
-    db.add(db_task)
+    db_task = TaskV2(**task.dict(), type=task_type)
+    pkg_name = db_task.name
+    await _verify_non_duplication_user_constraint(
+        db=db, pkg_name=pkg_name, user_id=user.id, version=db_task.version
+    )
+    await _verify_non_duplication_group_constraint(
+        db=db,
+        pkg_name=pkg_name,
+        user_group_id=user_group_id,
+        version=db_task.version,
+    )
+    db_task_group = TaskGroupV2(
+        user_id=user.id,
+        user_group_id=user_group_id,
+        active=True,
+        task_list=[db_task],
+        origin=TaskGroupV2OriginEnum.OTHER,
+        version=db_task.version,
+        pkg_name=pkg_name,
+    )
+    db.add(db_task_group)
     await db.commit()
     await db.refresh(db_task)
     await db.close()
@@ -202,54 +221,10 @@ async def delete_task(
     """
     Delete a task
     """
-
-    db_task = await _get_task_check_owner(task_id=task_id, user=user, db=db)
-
-    # Check that the TaskV2 is not in relationship with some WorkflowTaskV2
-    stm = select(WorkflowTaskV2).filter(WorkflowTaskV2.task_id == task_id)
-    res = await db.execute(stm)
-    workflow_tasks = res.scalars().all()
-
-    if workflow_tasks:
-        # Find IDs of all affected workflows
-        workflow_ids = set(wftask.workflow_id for wftask in workflow_tasks)
-        # Fetch all affected workflows from DB
-        stm = select(WorkflowV2).where(WorkflowV2.id.in_(workflow_ids))
-        res = await db.execute(stm)
-        workflows = res.scalars().all()
-
-        # Find which workflows are associated to the current user
-        workflows_current_user = [
-            wf for wf in workflows if user in wf.project.user_list
-        ]
-        if workflows_current_user:
-            current_user_msg = (
-                "For the current-user workflows (listed below),"
-                " you can update the task or remove the workflows.\n"
-            )
-            current_user_msg += "\n".join(
-                [
-                    f"* '{wf.name}' (id={wf.id})"
-                    for wf in workflows_current_user
-                ]
-            )
-        else:
-            current_user_msg = ""
-
-        # Count workflows of current users or other users
-        num_workflows_current_user = len(workflows_current_user)
-        num_workflows_other_users = len(workflows) - num_workflows_current_user
-
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Cannot remove Task with id={task_id}: it is currently in "
-                f"use in {num_workflows_current_user} current-user workflows "
-                f"and in {num_workflows_other_users} other-users workflows.\n"
-                f"{current_user_msg}"
-            ),
-        )
-
-    await db.delete(db_task)
-    await db.commit()
-    return Response(status_code=status.HTTP_204_NO_CONTENT)
+    raise HTTPException(
+        status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
+        detail=(
+            "Cannot delete single tasks, "
+            "please operate directly on task groups."
+        ),
+    )