fractal-server 2.17.2__py3-none-any.whl → 2.18.0__py3-none-any.whl

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

@@ -5,6 +5,7 @@ from fastapi import status
 from pydantic.types import AwareDatetime
 from sqlalchemy.sql.operators import is_
 from sqlalchemy.sql.operators import is_not
+from sqlmodel import func
 from sqlmodel import select
 
 from fractal_server.app.db import AsyncSession
@@ -16,12 +17,15 @@ from fractal_server.app.routes.auth import current_superuser_act
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
-from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
-from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
-from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
+from fractal_server.app.routes.pagination import PaginationRequest
+from fractal_server.app.routes.pagination import PaginationResponse
+from fractal_server.app.routes.pagination import get_pagination_params
+from fractal_server.app.schemas.v2 import TaskGroupActivityAction
+from fractal_server.app.schemas.v2 import TaskGroupActivityRead
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatus
+from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
 from fractal_server.app.schemas.v2 import TaskGroupReadSuperuser
-from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
+from fractal_server.app.schemas.v2 import TaskGroupUpdate
 from fractal_server.logger import set_logger
 
 router = APIRouter()
@@ -29,39 +33,78 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-@router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
+@router.get(
+    "/activity/", response_model=PaginationResponse[TaskGroupActivityRead]
+)
 async def get_task_group_activity_list(
     task_group_activity_id: int | None = None,
     user_id: int | None = None,
     taskgroupv2_id: int | None = None,
     pkg_name: str | None = None,
-    status: TaskGroupActivityStatusV2 | None = None,
-    action: TaskGroupActivityActionV2 | None = None,
+    status: TaskGroupActivityStatus | None = None,
+    action: TaskGroupActivityAction | None = None,
     timestamp_started_min: AwareDatetime | None = None,
+    pagination: PaginationRequest = Depends(get_pagination_params),
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskGroupActivityV2Read]:
-    stm = select(TaskGroupActivityV2)
+) -> PaginationResponse[TaskGroupActivityRead]:
+    # Assign pagination parameters
+    page = pagination.page
+    page_size = pagination.page_size
+
+    stm = select(TaskGroupActivityV2).order_by(
+        TaskGroupActivityV2.timestamp_started.desc()
+    )
+    stm_count = select(func.count(TaskGroupActivityV2.id))
     if task_group_activity_id is not None:
         stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
+        stm_count = stm_count.where(
+            TaskGroupActivityV2.id == task_group_activity_id
+        )
     if user_id:
         stm = stm.where(TaskGroupActivityV2.user_id == user_id)
+        stm_count = stm_count.where(TaskGroupActivityV2.user_id == user_id)
     if taskgroupv2_id:
         stm = stm.where(TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id)
+        stm_count = stm_count.where(
+            TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id
+        )
     if pkg_name:
         stm = stm.where(TaskGroupActivityV2.pkg_name.icontains(pkg_name))
+        stm_count = stm_count.where(
+            TaskGroupActivityV2.pkg_name.icontains(pkg_name)
+        )
     if status:
         stm = stm.where(TaskGroupActivityV2.status == status)
+        stm_count = stm_count.where(TaskGroupActivityV2.status == status)
     if action:
         stm = stm.where(TaskGroupActivityV2.action == action)
+        stm_count = stm_count.where(TaskGroupActivityV2.action == action)
     if timestamp_started_min is not None:
         stm = stm.where(
             TaskGroupActivityV2.timestamp_started >= timestamp_started_min
         )
+        stm_count = stm_count.where(
+            TaskGroupActivityV2.timestamp_started >= timestamp_started_min
+        )
+
+    # Find total number of elements
+    res_total_count = await db.execute(stm_count)
+    total_count = res_total_count.scalar()
+    if page_size is None:
+        page_size = total_count
+    else:
+        stm = stm.offset((page - 1) * page_size).limit(page_size)
 
     res = await db.execute(stm)
     activities = res.scalars().all()
-    return activities
+
+    return dict(
+        total_count=total_count,
+        page_size=page_size,
+        current_page=page,
+        items=activities,
+    )
 
 
 @router.get("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
@@ -79,21 +122,27 @@ async def query_task_group(
     return task_group
 
 
-@router.get("/", response_model=list[TaskGroupReadSuperuser])
+@router.get("/", response_model=PaginationResponse[TaskGroupReadSuperuser])
 async def query_task_group_list(
     user_id: int | None = None,
     user_group_id: int | None = None,
     private: bool | None = None,
     active: bool | None = None,
     pkg_name: str | None = None,
-    origin: TaskGroupV2OriginEnum | None = None,
+    origin: TaskGroupOriginEnum | None = None,
     timestamp_last_used_min: AwareDatetime | None = None,
     timestamp_last_used_max: AwareDatetime | None = None,
     resource_id: int | None = None,
+    pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskGroupReadSuperuser]:
+) -> PaginationResponse[TaskGroupReadSuperuser]:
+    # Assign pagination parameters
+    page = pagination.page
+    page_size = pagination.page_size
+
     stm = select(TaskGroupV2)
+    stm_count = select(func.count(TaskGroupV2.id))
 
     if user_group_id is not None and private is True:
         raise HTTPException(
@@ -105,43 +154,72 @@ async def query_task_group_list(
         )
     if user_id is not None:
         stm = stm.where(TaskGroupV2.user_id == user_id)
+        stm_count = stm_count.where(TaskGroupV2.user_id == user_id)
     if user_group_id is not None:
         stm = stm.where(TaskGroupV2.user_group_id == user_group_id)
+        stm_count = stm_count.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))
+            stm_count = stm_count.where(is_(TaskGroupV2.user_group_id, None))
         else:
             stm = stm.where(is_not(TaskGroupV2.user_group_id, None))
+            stm_count = stm_count.where(is_not(TaskGroupV2.user_group_id, None))
     if active is not None:
         if active is True:
             stm = stm.where(is_(TaskGroupV2.active, True))
+            stm_count = stm_count.where(is_(TaskGroupV2.active, True))
         else:
             stm = stm.where(is_(TaskGroupV2.active, False))
+            stm_count = stm_count.where(is_(TaskGroupV2.active, False))
     if origin is not None:
         stm = stm.where(TaskGroupV2.origin == origin)
+        stm_count = stm_count.where(TaskGroupV2.origin == origin)
     if pkg_name is not None:
         stm = stm.where(TaskGroupV2.pkg_name.icontains(pkg_name))
+        stm_count = stm_count.where(TaskGroupV2.pkg_name.icontains(pkg_name))
     if timestamp_last_used_min is not None:
         stm = stm.where(
             TaskGroupV2.timestamp_last_used >= timestamp_last_used_min
         )
+        stm_count = stm_count.where(
+            TaskGroupV2.timestamp_last_used >= timestamp_last_used_min
+        )
     if timestamp_last_used_max is not None:
         stm = stm.where(
             TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
         )
+        stm_count = stm_count.where(
+            TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
+        )
     if resource_id is not None:
         stm = stm.where(TaskGroupV2.resource_id == resource_id)
+        stm_count = stm_count.where(TaskGroupV2.resource_id == resource_id)
+
+    # Find total number of elements
+    res_total_count = await db.execute(stm_count)
+    total_count = res_total_count.scalar()
+    if page_size is None:
+        page_size = total_count
+    else:
+        stm = stm.offset((page - 1) * page_size).limit(page_size)
 
     stm = stm.order_by(TaskGroupV2.id)
     res = await db.execute(stm)
     task_groups_list = res.scalars().all()
-    return task_groups_list
+
+    return dict(
+        total_count=total_count,
+        page_size=page_size,
+        current_page=page,
+        items=task_groups_list,
+    )
 
 
 @router.patch("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
 async def patch_task_group(
     task_group_id: int,
-    task_group_update: TaskGroupUpdateV2,
+    task_group_update: TaskGroupUpdate,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupReadSuperuser]:

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

@@ -26,10 +26,10 @@ from fractal_server.app.routes.aux.validate_user_profile import (
     validate_user_profile,
 )
 from fractal_server.app.schemas.v2 import ResourceType
-from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
-from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
-from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
+from fractal_server.app.schemas.v2 import TaskGroupActivityAction
+from fractal_server.app.schemas.v2 import TaskGroupActivityRead
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatus
+from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
 from fractal_server.logger import set_logger
 from fractal_server.tasks.v2.local import deactivate_local
 from fractal_server.tasks.v2.local import delete_local
@@ -46,7 +46,7 @@ logger = set_logger(__name__)
 
 @router.post(
     "/{task_group_id}/deactivate/",
-    response_model=TaskGroupActivityV2Read,
+    response_model=TaskGroupActivityRead,
 )
 async def deactivate_task_group(
     task_group_id: int,
@@ -54,7 +54,7 @@ async def deactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupActivityV2Read:
+) -> TaskGroupActivityRead:
     """
     Deactivate task-group venv
     """
@@ -78,13 +78,13 @@ async def deactivate_task_group(
     await check_no_submitted_job(task_group_id=task_group.id, db=db)
 
     # Shortcut for task-group with origin="other"
-    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+    if task_group.origin == TaskGroupOriginEnum.OTHER:
         task_group.active = False
         task_group_activity = TaskGroupActivityV2(
             user_id=task_group.user_id,
             taskgroupv2_id=task_group.id,
-            status=TaskGroupActivityStatusV2.OK,
-            action=TaskGroupActivityActionV2.DEACTIVATE,
+            status=TaskGroupActivityStatus.OK,
+            action=TaskGroupActivityAction.DEACTIVATE,
             pkg_name=task_group.pkg_name,
             version=(task_group.version or "N/A"),
             log=(
@@ -103,8 +103,8 @@ async def deactivate_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatusV2.PENDING,
-        action=TaskGroupActivityActionV2.DEACTIVATE,
+        status=TaskGroupActivityStatus.PENDING,
+        action=TaskGroupActivityAction.DEACTIVATE,
         pkg_name=task_group.pkg_name,
         version=task_group.version,
         timestamp_started=get_timestamp(),
@@ -140,7 +140,7 @@ async def deactivate_task_group(
 
 @router.post(
     "/{task_group_id}/reactivate/",
-    response_model=TaskGroupActivityV2Read,
+    response_model=TaskGroupActivityRead,
 )
 async def reactivate_task_group(
     task_group_id: int,
@@ -148,7 +148,7 @@ async def reactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupActivityV2Read:
+) -> TaskGroupActivityRead:
     """
     Deactivate task-group venv
     """
@@ -173,13 +173,13 @@ async def reactivate_task_group(
     await check_no_submitted_job(task_group_id=task_group.id, db=db)
 
     # Shortcut for task-group with origin="other"
-    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+    if task_group.origin == TaskGroupOriginEnum.OTHER:
         task_group.active = True
         task_group_activity = TaskGroupActivityV2(
             user_id=task_group.user_id,
             taskgroupv2_id=task_group.id,
-            status=TaskGroupActivityStatusV2.OK,
-            action=TaskGroupActivityActionV2.REACTIVATE,
+            status=TaskGroupActivityStatus.OK,
+            action=TaskGroupActivityAction.REACTIVATE,
             pkg_name=task_group.pkg_name,
             version=(task_group.version or "N/A"),
             log=(
@@ -206,8 +206,8 @@ async def reactivate_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatusV2.PENDING,
-        action=TaskGroupActivityActionV2.REACTIVATE,
+        status=TaskGroupActivityStatus.PENDING,
+        action=TaskGroupActivityAction.REACTIVATE,
         pkg_name=task_group.pkg_name,
         version=task_group.version,
         timestamp_started=get_timestamp(),
@@ -259,8 +259,8 @@ async def delete_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatusV2.PENDING,
-        action=TaskGroupActivityActionV2.DELETE,
+        status=TaskGroupActivityStatus.PENDING,
+        action=TaskGroupActivityAction.DELETE,
         pkg_name=task_group.pkg_name,
         version=(task_group.version or "N/A"),
         timestamp_started=get_timestamp(),

fractal_server/app/routes/api/__init__.py

@@ -8,7 +8,6 @@ from fastapi import Depends
 import fractal_server
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_superuser_act
-from fractal_server.config import get_data_settings
 from fractal_server.config import get_db_settings
 from fractal_server.config import get_email_settings
 from fractal_server.config import get_oauth_settings
@@ -50,14 +49,6 @@ async def view_email_settings(
     return settings.model_dump()
 
 
-@router_api.get("/settings/data/")
-async def view_data_settings(
-    user: UserOAuth = Depends(current_superuser_act),
-):
-    settings = Inject(get_data_settings)
-    return settings.model_dump()
-
-
 @router_api.get("/settings/oauth/")
 async def view_oauth_settings(
     user: UserOAuth = Depends(current_superuser_act),

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

@@ -7,66 +7,66 @@ from fastapi import APIRouter
 from fractal_server.config import get_settings
 from fractal_server.syringe import Inject
 
-from .dataset import router as dataset_router_v2
-from .history import router as history_router_v2
-from .images import router as images_routes_v2
-from .job import router as job_router_v2
+from .dataset import router as dataset_router
+from .history import router as history_router
+from .images import router as images_routes
+from .job import router as job_router
 from .pre_submission_checks import router as pre_submission_checks_router
-from .project import router as project_router_v2
-from .status_legacy import router as status_legacy_router_v2
-from .submit import router as submit_job_router_v2
-from .task import router as task_router_v2
-from .task_collection import router as task_collection_router_v2
-from .task_collection_custom import router as task_collection_router_v2_custom
-from .task_collection_pixi import router as task_collection_pixi_router_v2
-from .task_group import router as task_group_router_v2
-from .task_group_lifecycle import router as task_group_lifecycle_router_v2
-from .task_version_update import router as task_version_update_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 .project import router as project_router
+from .sharing import router as sharing_router
+from .status_legacy import router as status_legacy_router
+from .submit import router as submit_job_router
+from .task import router as task_router
+from .task_collection import router as task_collection_router
+from .task_collection_custom import router as task_collection_router_custom
+from .task_collection_pixi import router as task_collection_pixi_router
+from .task_group import router as task_group_router
+from .task_group_lifecycle import router as task_group_lifecycle_router
+from .task_version_update import router as task_version_update_router
+from .workflow import router as workflow_router
+from .workflow_import import router as workflow_import_router
+from .workflowtask import router as workflowtask_router
 
-router_api_v2 = APIRouter()
+router_api = APIRouter()
 
-router_api_v2.include_router(dataset_router_v2, tags=["V2 Dataset"])
-router_api_v2.include_router(pre_submission_checks_router, tags=["V2 Job"])
-router_api_v2.include_router(job_router_v2, tags=["V2 Job"])
-router_api_v2.include_router(images_routes_v2, tags=["V2 Images"])
-router_api_v2.include_router(project_router_v2, tags=["V2 Project"])
-router_api_v2.include_router(submit_job_router_v2, tags=["V2 Job"])
-router_api_v2.include_router(history_router_v2, tags=["V2 History"])
-router_api_v2.include_router(status_legacy_router_v2, tags=["V2 Status Legacy"])
+router_api.include_router(dataset_router, tags=["Dataset"])
+router_api.include_router(pre_submission_checks_router, tags=["Job"])
+router_api.include_router(job_router, tags=["Job"])
+router_api.include_router(images_routes, tags=["Images"])
+router_api.include_router(sharing_router, tags=["Project Sharing"])
+router_api.include_router(project_router, tags=["Project"])
+router_api.include_router(submit_job_router, tags=["Job"])
+router_api.include_router(history_router, tags=["History"])
+router_api.include_router(status_legacy_router, tags=["Status Legacy"])
 
 
 settings = Inject(get_settings)
-router_api_v2.include_router(
-    task_collection_router_v2,
+router_api.include_router(
+    task_collection_router,
     prefix="/task",
-    tags=["V2 Task Lifecycle"],
+    tags=["Task Lifecycle"],
 )
-router_api_v2.include_router(
-    task_collection_router_v2_custom,
+router_api.include_router(
+    task_collection_router_custom,
     prefix="/task",
-    tags=["V2 Task Lifecycle"],
+    tags=["Task Lifecycle"],
 )
-router_api_v2.include_router(
-    task_collection_pixi_router_v2,
+router_api.include_router(
+    task_collection_pixi_router,
     prefix="/task",
-    tags=["V2 Task Lifecycle"],
+    tags=["Task Lifecycle"],
 )
-router_api_v2.include_router(
-    task_group_lifecycle_router_v2,
+router_api.include_router(
+    task_group_lifecycle_router,
     prefix="/task-group",
-    tags=["V2 Task Lifecycle"],
+    tags=["Task Lifecycle"],
 )
 
-router_api_v2.include_router(task_router_v2, prefix="/task", tags=["V2 Task"])
-router_api_v2.include_router(task_version_update_router_v2, tags=["V2 Task"])
-router_api_v2.include_router(
-    task_group_router_v2, prefix="/task-group", tags=["V2 TaskGroup"]
+router_api.include_router(task_router, prefix="/task", tags=["Task"])
+router_api.include_router(task_version_update_router, tags=["Task"])
+router_api.include_router(
+    task_group_router, prefix="/task-group", tags=["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.include_router(workflow_router, tags=["Workflow"])
+router_api.include_router(workflow_import_router, tags=["Workflow Import"])
+router_api.include_router(workflowtask_router, tags=["WorkflowTask"])