fractal-server 2.18.0a0__tar.gz → 2.18.0a1__tar.gz

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fractal-server
-Version: 2.18.0a0
+Version: 2.18.0a1
 Summary: Backend component of the Fractal analytics platform
 License-Expression: BSD-3-Clause
 License-File: LICENSE

fractal_server-2.18.0a1/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.18.0a1"

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/fractal_server/app/routes/admin/v2/accounting.py

@@ -67,11 +67,11 @@ async def query_accounting(
     res = await db.execute(stm)
     records = res.scalars().all()
 
-    return PaginationResponse[AccountingRecordRead](
+    return dict(
         total_count=total_count,
         page_size=page_size,
         current_page=page,
-        items=[record.model_dump() for record in records],
+        items=records,
     )
 
 

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/fractal_server/app/routes/admin/v2/job.py

@@ -146,11 +146,11 @@ async def view_job(
         for job in job_list:
             setattr(job, "log", None)
 
-    return PaginationResponse[JobReadV2](
+    return dict(
         total_count=total_count,
         page_size=page_size,
         current_page=page,
-        items=[job.model_dump() for job in job_list],
+        items=job_list,
     )
 
 

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/fractal_server/app/routes/admin/v2/task.py

@@ -170,7 +170,7 @@ async def query_tasks(
                 ],
             )
         )
-    return PaginationResponse[TaskV2Info](
+    return dict(
         total_count=total_count,
         page_size=page_size,
         current_page=page,

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/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,6 +17,9 @@ 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.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 TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
@@ -29,7 +33,9 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-@router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
+@router.get(
+    "/activity/", response_model=PaginationResponse[TaskGroupActivityV2Read]
+)
 async def get_task_group_activity_list(
     task_group_activity_id: int | None = None,
     user_id: int | None = None,
@@ -38,30 +44,65 @@ async def get_task_group_activity_list(
     status: TaskGroupActivityStatusV2 | None = None,
     action: TaskGroupActivityActionV2 | 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]:
+) -> PaginationResponse[TaskGroupActivityV2Read]:
+    # Assign pagination parameters
+    page = pagination.page
+    page_size = pagination.page_size
+
     stm = select(TaskGroupActivityV2)
+    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,7 +120,7 @@ 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,
@@ -90,10 +131,16 @@ async def query_task_group_list(
     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,37 +152,66 @@ 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)

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/fractal_server/app/routes/api/v2/sharing.py

@@ -243,9 +243,8 @@ async def get_access_info(
                     UserOAuth.id == LinkUserProjectV2.user_id,
                 )
                 .where(LinkUserProjectV2.is_owner.is_(True))
-                .where(LinkUserProjectV2.project_id == ProjectV2.id)
+                .where(LinkUserProjectV2.project_id == project_id)
                 .scalar_subquery()
-                .correlate(LinkUserProjectV2)
             ),
         )
         .where(LinkUserProjectV2.project_id == project_id)

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/fractal_server/app/routes/api/v2/workflowtask.py

@@ -69,13 +69,14 @@ async def create_workflowtask(
                 require_active=True,
             )
         except HTTPException as e:
-            if e.status_code == 403:
-                raise HTTPException(
+            raise (
+                HTTPException(
                     status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                     detail="The task must be accessible to the project owner.",
                 )
-            else:
-                raise e
+                if e.status_code == 403
+                else e
+            )
 
     task = await _get_task_read_access(
         task_id=task_id, user_id=user.id, db=db, require_active=True

{fractal_server-2.18.0a0 → fractal_server-2.18.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fractal-server"
-version = "2.18.0a0"
+version = "2.18.0a1"
 description = "Backend component of the Fractal analytics platform"
 authors = [
     { name="Tommaso Comparin", email="tommaso.comparin@exact-lab.it" },
@@ -95,7 +95,7 @@ filterwarnings = [
 markers = ["container", "ssh", "fails_on_macos", "oauth"]
 
 [tool.bumpver]
-current_version = "2.18.0a0"
+current_version = "2.18.0a1"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

fractal_server-2.18.0a0/fractal_server/__init__.py

@@ -1 +0,0 @@
-__VERSION__ = "2.18.0a0"