fractal-server 2.7.0a1__py3-none-any.whl → 2.7.0a3__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.7.0a1"
+__VERSION__ = "2.7.0a3"

fractal_server/__main__.py

@@ -57,10 +57,16 @@ set_db_parser.add_argument(
 )
 
 # fractalctl update-db-data
-subparsers.add_parser(
+update_db_data_parser = subparsers.add_parser(
     "update-db-data",
     description="Apply data-migration script to an existing database.",
 )
+update_db_data_parser.add_argument(
+    "--dry-run",
+    action="store_true",
+    help="If set, perform a dry run of the data migration.",
+    default=False,
+)
 
 
 def save_openapi(dest="openapi.json"):
@@ -120,7 +126,7 @@ def set_db(skip_init_data: bool = False):
     print()
 
 
-def update_db_data():
+def update_db_data(dry_run: bool = False):
     """
     Apply data migrations.
     """
@@ -185,7 +191,7 @@ def update_db_data():
         sys.exit()
 
     print("OK, now starting data-migration script\n")
-    current_update_db_data_module.fix_db()
+    current_update_db_data_module.fix_db(dry_run=dry_run)
 
 
 def run():
@@ -196,7 +202,7 @@ def run():
     elif args.cmd == "set-db":
         set_db(skip_init_data=args.skip_init_data)
     elif args.cmd == "update-db-data":
-        update_db_data()
+        update_db_data(dry_run=args.dry_run)
     elif args.cmd == "start":
         uvicorn.run(
             "fractal_server.main:app",

fractal_server/app/models/v2/task.py

@@ -47,21 +47,35 @@ class TaskV2(SQLModel, table=True):
 
     taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
 
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: list[str] = Field(
+        sa_column=Column(JSON, server_default="[]", nullable=False)
+    )
+
 
 class TaskGroupV2(SQLModel, table=True):
 
     id: Optional[int] = Field(default=None, primary_key=True)
-
-    user_id: int = Field(foreign_key="user_oauth.id")
-    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
-
-    active: bool = True
     task_list: list[TaskV2] = Relationship(
         sa_relationship_kwargs=dict(
             lazy="selectin", cascade="all, delete-orphan"
         ),
     )
 
+    user_id: int = Field(foreign_key="user_oauth.id")
+    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
+
+    origin: str
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    venv_path: Optional[str] = None
+    pip_extras: Optional[str] = None
+
+    active: bool = True
     timestamp_created: datetime = Field(
         default_factory=get_timestamp,
         sa_column=Column(DateTime(timezone=True), nullable=False),

fractal_server/app/routes/admin/v2/__init__.py

@@ -0,0 +1,16 @@
+"""
+`admin/v2` module
+"""
+from fastapi import APIRouter
+
+from .job import router as job_router
+from .project import router as project_router
+from .task import router as task_router
+from .task_group import router as task_group_router
+
+router_admin_v2 = APIRouter()
+
+router_admin_v2.include_router(job_router, prefix="/job")
+router_admin_v2.include_router(project_router, prefix="/project")
+router_admin_v2.include_router(task_router, prefix="/task")
+router_admin_v2.include_router(task_group_router, prefix="/task-group")

fractal_server/app/routes/admin/{v2.py → v2/job.py}

@@ -1,10 +1,6 @@
-"""
-Definition of `/admin` routes.
-"""
 from datetime import datetime
 from datetime import timezone
 from pathlib import Path
-from typing import Literal
 from typing import Optional
 
 from fastapi import APIRouter
@@ -13,33 +9,26 @@ from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-from pydantic import EmailStr
-from pydantic import Field
 from sqlmodel import select
 
-from ....config import get_settings
-from ....syringe import Inject
-from ....utils import get_timestamp
-from ....zip_tools import _zip_folder_to_byte_stream_iterator
-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 WorkflowTaskV2
-from ...models.v2 import WorkflowV2
-from ...runner.filenames import WORKFLOW_LOG_FILENAME
-from ...schemas.v2 import JobReadV2
-from ...schemas.v2 import JobStatusTypeV2
-from ...schemas.v2 import JobUpdateV2
-from ...schemas.v2 import ProjectReadV2
-from ..aux._job import _write_shutdown_file
-from ..aux._runner import _check_shutdown_is_supported
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import JobV2
+from fractal_server.app.models.v2 import ProjectV2
 from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.routes.aux._job import _write_shutdown_file
+from fractal_server.app.routes.aux._runner import _check_shutdown_is_supported
+from fractal_server.app.runner.filenames import WORKFLOW_LOG_FILENAME
+from fractal_server.app.schemas.v2 import JobReadV2
+from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.app.schemas.v2 import JobUpdateV2
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+from fractal_server.utils import get_timestamp
+from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 
-router_admin_v2 = APIRouter()
+router = APIRouter()
 
 
 def _convert_to_db_timestamp(dt: datetime) -> datetime:
@@ -59,36 +48,7 @@ def _convert_to_db_timestamp(dt: datetime) -> datetime:
     return _dt
 
 
-@router_admin_v2.get("/project/", response_model=list[ProjectReadV2])
-async def view_project(
-    id: Optional[int] = None,
-    user_id: Optional[int] = None,
-    user: UserOAuth = Depends(current_active_superuser),
-    db: AsyncSession = Depends(get_async_db),
-) -> list[ProjectReadV2]:
-    """
-    Query `ProjectV2` table.
-
-    Args:
-        id: If not `None`, select a given `project.id`.
-        user_id: If not `None`, select a given `project.user_id`.
-    """
-
-    stm = select(ProjectV2)
-
-    if id is not None:
-        stm = stm.where(ProjectV2.id == id)
-    if user_id is not None:
-        stm = stm.where(ProjectV2.user_list.any(UserOAuth.id == user_id))
-
-    res = await db.execute(stm)
-    project_list = res.scalars().all()
-    await db.close()
-
-    return project_list
-
-
-@router_admin_v2.get("/job/", response_model=list[JobReadV2])
+@router.get("/", response_model=list[JobReadV2])
 async def view_job(
     id: Optional[int] = None,
     user_id: Optional[int] = None,
@@ -164,7 +124,7 @@ async def view_job(
     return job_list
 
 
-@router_admin_v2.get("/job/{job_id}/", response_model=JobReadV2)
+@router.get("/{job_id}/", response_model=JobReadV2)
 async def view_single_job(
     job_id: int = None,
     show_tmp_logs: bool = False,
@@ -190,10 +150,7 @@ async def view_single_job(
     return job
 
 
-@router_admin_v2.patch(
-    "/job/{job_id}/",
-    response_model=JobReadV2,
-)
+@router.patch("/{job_id}/", response_model=JobReadV2)
 async def update_job(
     job_update: JobUpdateV2,
     job_id: int,
@@ -227,7 +184,7 @@ async def update_job(
     return job
 
 
-@router_admin_v2.get("/job/{job_id}/stop/", status_code=202)
+@router.get("/{job_id}/stop/", status_code=202)
 async def stop_job(
     job_id: int,
     user: UserOAuth = Depends(current_active_superuser),
@@ -251,10 +208,7 @@ async def stop_job(
     return Response(status_code=status.HTTP_202_ACCEPTED)
 
 
-@router_admin_v2.get(
-    "/job/{job_id}/download/",
-    response_class=StreamingResponse,
-)
+@router.get("/{job_id}/download/", response_class=StreamingResponse)
 async def download_job_logs(
     job_id: int,
     user: UserOAuth = Depends(current_active_superuser),
@@ -278,128 +232,3 @@ async def download_job_logs(
         media_type="application/x-zip-compressed",
         headers={"Content-Disposition": f"attachment;filename={zip_filename}"},
     )
-
-
-class TaskV2Minimal(BaseModel):
-
-    id: int
-    name: str
-    type: str
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
-    source: str
-    owner: Optional[str]
-    version: Optional[str]
-
-
-class ProjectUser(BaseModel):
-
-    id: int
-    email: EmailStr
-
-
-class TaskV2Relationship(BaseModel):
-
-    workflow_id: int
-    workflow_name: str
-    project_id: int
-    project_name: str
-    project_users: list[ProjectUser] = Field(default_factory=list)
-
-
-class TaskV2Info(BaseModel):
-
-    task: TaskV2Minimal
-    relationships: list[TaskV2Relationship]
-
-
-@router_admin_v2.get("/task/", response_model=list[TaskV2Info])
-async def query_tasks(
-    id: Optional[int] = None,
-    source: Optional[str] = None,
-    version: Optional[str] = None,
-    name: Optional[str] = None,
-    owner: Optional[str] = None,
-    kind: Optional[Literal["common", "users"]] = None,
-    max_number_of_results: int = 25,
-    user: UserOAuth = Depends(current_active_superuser),
-    db: AsyncSession = Depends(get_async_db),
-) -> list[TaskV2Info]:
-    """
-    Query `TaskV2` table and get informations about related items
-    (WorkflowV2s and ProjectV2s)
-
-    Args:
-        id: If not `None`, query for matching `task.id`.
-        source: If not `None`, query for contained case insensitive
-            `task.source`.
-        version: If not `None`, query for matching `task.version`.
-        name: If not `None`, query for contained case insensitive `task.name`.
-        owner: If not `None`, query for matching `task.owner`.
-        kind: If not `None`, query for TaskV2s that have (`users`) or don't
-            have (`common`) a `task.owner`.
-        max_number_of_results: The maximum length of the response.
-    """
-
-    stm = select(TaskV2)
-
-    if id is not None:
-        stm = stm.where(TaskV2.id == id)
-    if source is not None:
-        stm = stm.where(TaskV2.source.icontains(source))
-    if version is not None:
-        stm = stm.where(TaskV2.version == version)
-    if name is not None:
-        stm = stm.where(TaskV2.name.icontains(name))
-    if owner is not None:
-        stm = stm.where(TaskV2.owner == owner)
-
-    if kind == "common":
-        stm = stm.where(TaskV2.owner == None)  # noqa E711
-    elif kind == "users":
-        stm = stm.where(TaskV2.owner != None)  # noqa E711
-
-    res = await db.execute(stm)
-    task_list = res.scalars().all()
-    if len(task_list) > max_number_of_results:
-        await db.close()
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Too many Tasks ({len(task_list)} > {max_number_of_results})."
-                " Please add more query filters."
-            ),
-        )
-
-    task_info_list = []
-
-    for task in task_list:
-        stm = (
-            select(WorkflowV2)
-            .join(WorkflowTaskV2)
-            .where(WorkflowTaskV2.workflow_id == WorkflowV2.id)
-            .where(WorkflowTaskV2.task_id == task.id)
-        )
-        res = await db.execute(stm)
-        wf_list = res.scalars().all()
-
-        task_info_list.append(
-            dict(
-                task=task.model_dump(),
-                relationships=[
-                    dict(
-                        workflow_id=workflow.id,
-                        workflow_name=workflow.name,
-                        project_id=workflow.project.id,
-                        project_name=workflow.project.name,
-                        project_users=[
-                            dict(id=user.id, email=user.email)
-                            for user in workflow.project.user_list
-                        ],
-                    )
-                    for workflow in wf_list
-                ],
-            )
-        )
-
-    return task_info_list

fractal_server/app/routes/admin/v2/project.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import ProjectV2
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.schemas.v2 import ProjectReadV2
+
+router = APIRouter()
+
+
+@router.get("/", response_model=list[ProjectReadV2])
+async def view_project(
+    id: Optional[int] = None,
+    user_id: Optional[int] = None,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ProjectReadV2]:
+    """
+    Query `ProjectV2` table.
+
+    Args:
+        id: If not `None`, select a given `project.id`.
+        user_id: If not `None`, select a given `project.user_id`.
+    """
+
+    stm = select(ProjectV2)
+
+    if id is not None:
+        stm = stm.where(ProjectV2.id == id)
+    if user_id is not None:
+        stm = stm.where(ProjectV2.user_list.any(UserOAuth.id == user_id))
+
+    res = await db.execute(stm)
+    project_list = res.scalars().all()
+    await db.close()
+
+    return project_list

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

@@ -0,0 +1,146 @@
+from typing import Literal
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import status
+from pydantic import BaseModel
+from pydantic import EmailStr
+from pydantic import Field
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import TaskV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.models.v2 import WorkflowV2
+from fractal_server.app.routes.auth import current_active_superuser
+
+router = APIRouter()
+
+
+class TaskV2Minimal(BaseModel):
+
+    id: int
+    name: str
+    type: str
+    command_non_parallel: Optional[str]
+    command_parallel: Optional[str]
+    source: str
+    owner: Optional[str]
+    version: Optional[str]
+
+
+class ProjectUser(BaseModel):
+
+    id: int
+    email: EmailStr
+
+
+class TaskV2Relationship(BaseModel):
+
+    workflow_id: int
+    workflow_name: str
+    project_id: int
+    project_name: str
+    project_users: list[ProjectUser] = Field(default_factory=list)
+
+
+class TaskV2Info(BaseModel):
+
+    task: TaskV2Minimal
+    relationships: list[TaskV2Relationship]
+
+
+@router.get("/", response_model=list[TaskV2Info])
+async def query_tasks(
+    id: Optional[int] = None,
+    source: Optional[str] = None,
+    version: Optional[str] = None,
+    name: Optional[str] = None,
+    owner: Optional[str] = None,
+    kind: Optional[Literal["common", "users"]] = None,
+    max_number_of_results: int = 25,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskV2Info]:
+    """
+    Query `TaskV2` table and get informations about related items
+    (WorkflowV2s and ProjectV2s)
+
+    Args:
+        id: If not `None`, query for matching `task.id`.
+        source: If not `None`, query for contained case insensitive
+            `task.source`.
+        version: If not `None`, query for matching `task.version`.
+        name: If not `None`, query for contained case insensitive `task.name`.
+        owner: If not `None`, query for matching `task.owner`.
+        kind: If not `None`, query for TaskV2s that have (`users`) or don't
+            have (`common`) a `task.owner`.
+        max_number_of_results: The maximum length of the response.
+    """
+
+    stm = select(TaskV2)
+
+    if id is not None:
+        stm = stm.where(TaskV2.id == id)
+    if source is not None:
+        stm = stm.where(TaskV2.source.icontains(source))
+    if version is not None:
+        stm = stm.where(TaskV2.version == version)
+    if name is not None:
+        stm = stm.where(TaskV2.name.icontains(name))
+    if owner is not None:
+        stm = stm.where(TaskV2.owner == owner)
+
+    if kind == "common":
+        stm = stm.where(TaskV2.owner == None)  # noqa E711
+    elif kind == "users":
+        stm = stm.where(TaskV2.owner != None)  # noqa E711
+
+    res = await db.execute(stm)
+    task_list = res.scalars().all()
+    if len(task_list) > max_number_of_results:
+        await db.close()
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Too many Tasks ({len(task_list)} > {max_number_of_results})."
+                " Please add more query filters."
+            ),
+        )
+
+    task_info_list = []
+
+    for task in task_list:
+        stm = (
+            select(WorkflowV2)
+            .join(WorkflowTaskV2)
+            .where(WorkflowTaskV2.workflow_id == WorkflowV2.id)
+            .where(WorkflowTaskV2.task_id == task.id)
+        )
+        res = await db.execute(stm)
+        wf_list = res.scalars().all()
+
+        task_info_list.append(
+            dict(
+                task=task.model_dump(),
+                relationships=[
+                    dict(
+                        workflow_id=workflow.id,
+                        workflow_name=workflow.name,
+                        project_id=workflow.project.id,
+                        project_name=workflow.project.name,
+                        project_users=[
+                            dict(id=user.id, email=user.email)
+                            for user in workflow.project.user_list
+                        ],
+                    )
+                    for workflow in wf_list
+                ],
+            )
+        )
+
+    return task_info_list

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

@@ -0,0 +1,134 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+from fastapi import status
+from sqlalchemy.sql.operators import is_
+from sqlalchemy.sql.operators import is_not
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+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_superuser
+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
+
+router = APIRouter()
+
+
+@router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
+async def query_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroup {task_group_id} not found",
+        )
+    return task_group
+
+
+@router.get("/", response_model=list[TaskGroupReadV2])
+async def query_task_group_list(
+    user_id: Optional[int] = None,
+    user_group_id: Optional[int] = None,
+    private: Optional[bool] = None,
+    active: Optional[bool] = None,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupReadV2]:
+
+    stm = select(TaskGroupV2)
+
+    if user_group_id is not None and private is True:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Cannot set `user_group_id` with {private=}",
+        )
+    if user_id is not None:
+        stm = stm.where(TaskGroupV2.user_id == user_id)
+    if user_group_id is not None:
+        stm = stm.where(TaskGroupV2.user_group_id == user_group_id)
+    if private is not None:
+        if private is True:
+            stm = stm.where(is_(TaskGroupV2.user_group_id, None))
+        else:
+            stm = stm.where(is_not(TaskGroupV2.user_group_id, None))
+    if active is not None:
+        if active is True:
+            stm = stm.where(is_(TaskGroupV2.active, True))
+        else:
+            stm = stm.where(is_(TaskGroupV2.active, False))
+
+    res = await db.execute(stm)
+    task_groups_list = res.scalars().all()
+    return task_groups_list
+
+
+@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_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupReadV2]:
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroupV2 {task_group_id} not found",
+        )
+
+    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
+
+
+@router.delete("/{task_group_id}/", status_code=204)
+async def delete_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+):
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroupV2 {task_group_id} not found",
+        )
+
+    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",
+        )
+
+    await db.delete(task_group)
+    await db.commit()
+
+    return Response(status_code=status.HTTP_204_NO_CONTENT)