fractal-server 2.17.1a1__py3-none-any.whl → 2.18.0__py3-none-any.whl

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

@@ -12,21 +12,21 @@ 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 LinkUserProjectV2
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import HistoryRun
 from fractal_server.app.models.v2 import HistoryUnit
 from fractal_server.app.models.v2 import JobV2
-from fractal_server.app.models.v2 import ProjectV2
 from fractal_server.app.routes.auth import current_superuser_act
 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.routes.pagination import get_pagination_params
 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 HistoryUnitStatus
-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.app.schemas.v2 import JobRead
+from fractal_server.app.schemas.v2 import JobStatusType
+from fractal_server.app.schemas.v2 import JobUpdate
 from fractal_server.runner.filenames import WORKFLOW_LOG_FILENAME
 from fractal_server.utils import get_timestamp
 from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
@@ -34,14 +34,14 @@ from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 router = APIRouter()
 
 
-@router.get("/", response_model=PaginationResponse[JobReadV2])
+@router.get("/", response_model=PaginationResponse[JobRead])
 async def view_job(
     id: int | None = None,
     user_id: int | None = None,
     project_id: int | None = None,
     dataset_id: int | None = None,
     workflow_id: int | None = None,
-    status: JobStatusTypeV2 | None = None,
+    status: JobStatusType | None = None,
     start_timestamp_min: AwareDatetime | None = None,
     start_timestamp_max: AwareDatetime | None = None,
     end_timestamp_min: AwareDatetime | None = None,
@@ -50,12 +50,13 @@ async def view_job(
     pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[JobReadV2]:
+) -> PaginationResponse[JobRead]:
     """
-    Query `ApplyWorkflow` table.
+    Query `JobV2` table.
 
     Args:
         id: If not `None`, select a given `applyworkflow.id`.
+        user_id:
         project_id: If not `None`, select a given `applyworkflow.project_id`.
         dataset_id: If not `None`, select a given
             `applyworkflow.input_dataset_id`.
@@ -84,11 +85,21 @@ async def view_job(
         stm = stm.where(JobV2.id == id)
         stm_count = stm_count.where(JobV2.id == id)
     if user_id is not None:
-        stm = stm.join(ProjectV2).where(
-            ProjectV2.user_list.any(UserOAuth.id == user_id)
+        stm = (
+            stm.join(
+                LinkUserProjectV2,
+                LinkUserProjectV2.project_id == JobV2.project_id,
+            )
+            .where(LinkUserProjectV2.user_id == user_id)
+            .where(LinkUserProjectV2.is_owner.is_(True))
         )
-        stm_count = stm_count.join(ProjectV2).where(
-            ProjectV2.user_list.any(UserOAuth.id == user_id)
+        stm_count = (
+            stm_count.join(
+                LinkUserProjectV2,
+                LinkUserProjectV2.project_id == JobV2.project_id,
+            )
+            .where(LinkUserProjectV2.user_id == user_id)
+            .where(LinkUserProjectV2.is_owner.is_(True))
         )
     if project_id is not None:
         stm = stm.where(JobV2.project_id == project_id)
@@ -135,21 +146,21 @@ 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,
     )
 
 
-@router.get("/{job_id}/", response_model=JobReadV2)
+@router.get("/{job_id}/", response_model=JobRead)
 async def view_single_job(
     job_id: int,
     show_tmp_logs: bool = False,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> JobReadV2:
+) -> JobRead:
     job = await db.get(JobV2, job_id)
     if not job:
         raise HTTPException(
@@ -158,7 +169,7 @@ async def view_single_job(
         )
     await db.close()
 
-    if show_tmp_logs and (job.status == JobStatusTypeV2.SUBMITTED):
+    if show_tmp_logs and (job.status == JobStatusType.SUBMITTED):
         try:
             with open(f"{job.working_dir}/{WORKFLOW_LOG_FILENAME}") as f:
                 job.log = f.read()
@@ -168,13 +179,13 @@ async def view_single_job(
     return job
 
 
-@router.patch("/{job_id}/", response_model=JobReadV2)
+@router.patch("/{job_id}/", response_model=JobRead)
 async def update_job(
-    job_update: JobUpdateV2,
+    job_update: JobUpdate,
     job_id: int,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> JobReadV2 | None:
+) -> JobRead | None:
     """
     Change the status of an existing job.
 
@@ -187,13 +198,13 @@ async def update_job(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"Job {job_id} not found",
         )
-    if job.status != JobStatusTypeV2.SUBMITTED:
+    if job.status != JobStatusType.SUBMITTED:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=f"Job {job_id} has status {job.status=} != 'submitted'.",
         )
 
-    if job_update.status != JobStatusTypeV2.FAILED:
+    if job_update.status != JobStatusType.FAILED:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=f"Cannot set job status to {job_update.status}",
@@ -206,7 +217,7 @@ async def update_job(
         job,
         "log",
         f"{job.log or ''}\nThis job was manually marked as "
-        f"'{JobStatusTypeV2.FAILED}' by an admin ({timestamp.isoformat()}).",
+        f"'{JobStatusType.FAILED}' by an admin ({timestamp.isoformat()}).",
     )
 
     res = await db.execute(

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

@@ -6,8 +6,6 @@ from fastapi import status
 from sqlmodel import func
 from sqlmodel import select
 
-from ._aux_functions import _check_profile_name
-from ._aux_functions import _get_profile_or_404
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import Profile
@@ -16,6 +14,9 @@ from fractal_server.app.routes.auth import current_superuser_act
 from fractal_server.app.schemas.v2 import ProfileCreate
 from fractal_server.app.schemas.v2 import ProfileRead
 
+from ._aux_functions import _check_profile_name
+from ._aux_functions import _get_profile_or_404
+
 router = APIRouter()
 
 

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

@@ -6,9 +6,6 @@ from fastapi import status
 from sqlalchemy.exc import IntegrityError
 from sqlmodel import select
 
-from ._aux_functions import _check_resource_name
-from ._aux_functions import _get_resource_or_404
-from .profile import _check_profile_name
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
@@ -22,6 +19,10 @@ from fractal_server.app.schemas.v2 import ResourceRead
 from fractal_server.config import get_settings
 from fractal_server.syringe import Inject
 
+from ._aux_functions import _check_resource_name
+from ._aux_functions import _get_resource_or_404
+from .profile import _check_profile_name
+
 router = APIRouter()
 
 
@@ -47,8 +48,7 @@ def _check_type_match_or_422(new_resource: ResourceCreate) -> None:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=(
-                f"{settings.FRACTAL_RUNNER_BACKEND=} != "
-                f"{new_resource.type=}"
+                f"{settings.FRACTAL_RUNNER_BACKEND=} != {new_resource.type=}"
             ),
         )
 

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

@@ -0,0 +1,103 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlalchemy import func
+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 LinkUserProjectV2
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import ProjectV2
+from fractal_server.app.routes.auth import current_superuser_act
+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 LinkUserProjectRead
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginationResponse[LinkUserProjectRead])
+async def view_link_user_project(
+    # User info
+    user_id: int | None = None,
+    # Project info
+    project_id: int | None = None,
+    project_name: str | None = None,
+    # Permissions
+    is_owner: bool | None = None,
+    is_verified: bool | None = None,
+    # -----
+    pagination: PaginationRequest = Depends(get_pagination_params),
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> PaginationResponse[LinkUserProjectRead]:
+    page = pagination.page
+    page_size = pagination.page_size
+
+    stm = (
+        select(
+            LinkUserProjectV2,
+            UserOAuth.email,
+            ProjectV2.name,
+        )
+        .join(UserOAuth, UserOAuth.id == LinkUserProjectV2.user_id)
+        .join(ProjectV2, ProjectV2.id == LinkUserProjectV2.project_id)
+        .order_by(UserOAuth.email, ProjectV2.name)
+    )
+    stm_count = (
+        select(func.count())
+        .select_from(LinkUserProjectV2)
+        .join(UserOAuth, UserOAuth.id == LinkUserProjectV2.user_id)
+        .join(ProjectV2, ProjectV2.id == LinkUserProjectV2.project_id)
+    )
+
+    if project_id is not None:
+        stm = stm.where(LinkUserProjectV2.project_id == project_id)
+        stm_count = stm_count.where(LinkUserProjectV2.project_id == project_id)
+    if project_name is not None:
+        stm = stm.where(ProjectV2.name.icontains(project_name))
+        stm_count = stm_count.where(ProjectV2.name.icontains(project_name))
+    if user_id is not None:
+        stm = stm.where(LinkUserProjectV2.user_id == user_id)
+        stm_count = stm_count.where(LinkUserProjectV2.user_id == user_id)
+    if is_owner is not None:
+        stm = stm.where(LinkUserProjectV2.is_owner == is_owner)
+        stm_count = stm_count.where(LinkUserProjectV2.is_owner == is_owner)
+    if is_verified is not None:
+        stm = stm.where(LinkUserProjectV2.is_verified == is_verified)
+        stm_count = stm_count.where(
+            LinkUserProjectV2.is_verified == is_verified
+        )
+
+    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)
+    items = res.all()
+
+    return PaginationResponse[LinkUserProjectRead](
+        total_count=total_count,
+        page_size=page_size,
+        current_page=page,
+        items=[
+            dict(
+                # User info
+                user_id=linkuserproject.user_id,
+                user_email=user_email,
+                # Project info
+                project_id=linkuserproject.project_id,
+                project_name=project_name,
+                # Permissions
+                is_verified=linkuserproject.is_verified,
+                is_owner=linkuserproject.is_owner,
+                permissions=linkuserproject.permissions,
+            )
+            for linkuserproject, user_email, project_name in items
+        ],
+    )

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

@@ -8,21 +8,22 @@ 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 LinkUserProjectV2
 from fractal_server.app.models import TaskGroupV2
 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_superuser_act
-from fractal_server.app.routes.pagination import get_pagination_params
 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.task import TaskType
 
 router = APIRouter()
 
 
-class TaskV2Minimal(BaseModel):
+class TaskMinimal(BaseModel):
     id: int
     name: str
     type: str
@@ -38,7 +39,7 @@ class ProjectUser(BaseModel):
     email: EmailStr
 
 
-class TaskV2Relationship(BaseModel):
+class TaskRelationship(BaseModel):
     workflow_id: int
     workflow_name: str
     project_id: int
@@ -46,12 +47,12 @@ class TaskV2Relationship(BaseModel):
     project_users: list[ProjectUser] = Field(default_factory=list)
 
 
-class TaskV2Info(BaseModel):
-    task: TaskV2Minimal
-    relationships: list[TaskV2Relationship]
+class TaskInfo(BaseModel):
+    task: TaskMinimal
+    relationships: list[TaskRelationship]
 
 
-@router.get("/", response_model=PaginationResponse[TaskV2Info])
+@router.get("/", response_model=PaginationResponse[TaskInfo])
 async def query_tasks(
     id: int | None = None,
     source: str | None = None,
@@ -65,7 +66,7 @@ async def query_tasks(
     pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[TaskV2Info]:
+) -> PaginationResponse[TaskInfo]:
     """
     Query `TaskV2` and get information about related workflows and projects.
     """
@@ -106,16 +107,12 @@ async def query_tasks(
         stm = stm.where(TaskV2.authors.icontains(author))
         stm_count = stm_count.where(TaskV2.authors.icontains(author))
     if resource_id is not None:
-        stm = (
-            stm.join(TaskGroupV2)
-            .where(TaskGroupV2.id == TaskV2.taskgroupv2_id)
-            .where(TaskGroupV2.resource_id == resource_id)
-        )
-        stm_count = (
-            stm_count.join(TaskGroupV2)
-            .where(TaskGroupV2.id == TaskV2.taskgroupv2_id)
-            .where(TaskGroupV2.resource_id == resource_id)
-        )
+        stm = stm.join(
+            TaskGroupV2, TaskGroupV2.id == TaskV2.taskgroupv2_id
+        ).where(TaskGroupV2.resource_id == resource_id)
+        stm_count = stm_count.join(
+            TaskGroupV2, TaskGroupV2.id == TaskV2.taskgroupv2_id
+        ).where(TaskGroupV2.resource_id == resource_id)
 
     # Find total number of elements
     res_total_count = await db.execute(stm_count)
@@ -133,13 +130,31 @@ async def query_tasks(
     for task in task_list:
         stm = (
             select(WorkflowV2)
-            .join(WorkflowTaskV2)
-            .where(WorkflowTaskV2.workflow_id == WorkflowV2.id)
+            .join(
+                WorkflowTaskV2,
+                WorkflowTaskV2.workflow_id == WorkflowV2.id,
+            )
             .where(WorkflowTaskV2.task_id == task.id)
         )
         res = await db.execute(stm)
         wf_list = res.scalars().all()
 
+        project_users = {}
+        for project_id in set([workflow.project_id for workflow in wf_list]):
+            res = await db.execute(
+                select(UserOAuth.id, UserOAuth.email)
+                .join(
+                    LinkUserProjectV2,
+                    LinkUserProjectV2.user_id == UserOAuth.id,
+                )
+                .where(LinkUserProjectV2.project_id == project_id)
+                .where(LinkUserProjectV2.is_owner.is_(True))
+            )
+            project_users[project_id] = [
+                ProjectUser(id=p_user[0], email=p_user[1])
+                for p_user in res.all()
+            ]
+
         task_info_list.append(
             dict(
                 task=task.model_dump(),
@@ -149,17 +164,13 @@ async def query_tasks(
                         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
-                        ],
+                        project_users=project_users[workflow.project_id],
                     )
                     for workflow in wf_list
                 ],
             )
         )
-
-    return PaginationResponse[TaskV2Info](
+    return dict(
         total_count=total_count,
         page_size=page_size,
         current_page=page,

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,53 +17,94 @@ 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()
 
 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)
@@ -80,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(
@@ -106,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]: