fractal-server 2.16.6__py3-none-any.whl → 2.17.0__py3-none-any.whl

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

@@ -1,7 +1,5 @@
 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
@@ -10,11 +8,16 @@ 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 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_active_superuser
+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.schemas.v2.task import TaskType
 
 router = APIRouter()
 
@@ -48,66 +51,85 @@ class TaskV2Info(BaseModel):
     relationships: list[TaskV2Relationship]
 
 
-@router.get("/", response_model=list[TaskV2Info])
+@router.get("/", response_model=PaginationResponse[TaskV2Info])
 async def query_tasks(
     id: int | None = None,
     source: str | None = None,
     version: str | None = None,
     name: str | None = None,
-    max_number_of_results: int = 25,
+    task_type: TaskType | None = None,
     category: str | None = None,
     modality: str | None = None,
     author: str | None = None,
-    user: UserOAuth = Depends(current_active_superuser),
+    resource_id: int | None = None,
+    pagination: PaginationRequest = Depends(get_pagination_params),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskV2Info]:
+) -> PaginationResponse[TaskV2Info]:
     """
-    Query `TaskV2` table and get information 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`.
-        max_number_of_results: The maximum length of the response.
-        category:
-        modality:
-        author:
+    Query `TaskV2` and get information about related workflows and projects.
     """
 
-    stm = select(TaskV2)
+    # Assign pagination parameters
+    page = pagination.page
+    page_size = pagination.page_size
 
+    # Prepare statements
+    stm = select(TaskV2).order_by(TaskV2.id)
+    stm_count = select(func.count(TaskV2.id))
     if id is not None:
         stm = stm.where(TaskV2.id == id)
+        stm_count = stm_count.where(TaskV2.id == id)
     if source is not None:
         stm = stm.where(TaskV2.source.icontains(source))
+        stm_count = stm_count.where(TaskV2.source.icontains(source))
     if version is not None:
         stm = stm.where(TaskV2.version == version)
+        stm_count = stm_count.where(TaskV2.version == version)
     if name is not None:
         stm = stm.where(TaskV2.name.icontains(name))
+        stm_count = stm_count.where(TaskV2.name.icontains(name))
+    if task_type is not None:
+        stm = stm.where(TaskV2.type == task_type)
+        stm_count = stm_count.where(TaskV2.type == task_type)
     if category is not None:
         stm = stm.where(func.lower(TaskV2.category) == category.lower())
+        stm_count = stm_count.where(
+            func.lower(TaskV2.category) == category.lower()
+        )
     if modality is not None:
         stm = stm.where(func.lower(TaskV2.modality) == modality.lower())
+        stm_count = stm_count.where(
+            func.lower(TaskV2.modality) == modality.lower()
+        )
     if author is not None:
         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)
+        )
+
+    # 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)
 
+    # Get `page_size` rows
     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_CONTENT,
-            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)
@@ -137,4 +159,9 @@ async def query_tasks(
             )
         )
 
-    return task_info_list
+    return PaginationResponse[TaskV2Info](
+        total_count=total_count,
+        page_size=page_size,
+        current_page=page,
+        items=task_info_list,
+    )

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

@@ -12,18 +12,19 @@ from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
-from fractal_server.app.routes.auth import current_active_superuser
+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.schemas.v2 import TaskGroupReadV2
+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.logger import set_logger
 
+
 router = APIRouter()
 
 logger = set_logger(__name__)
@@ -38,7 +39,7 @@ async def get_task_group_activity_list(
     status: TaskGroupActivityStatusV2 | None = None,
     action: TaskGroupActivityActionV2 | None = None,
     timestamp_started_min: AwareDatetime | None = None,
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupActivityV2Read]:
     stm = select(TaskGroupActivityV2)
@@ -64,12 +65,12 @@ async def get_task_group_activity_list(
     return activities
 
 
-@router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
+@router.get("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
 async def query_task_group(
     task_group_id: int,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupReadV2:
+) -> TaskGroupReadSuperuser:
     task_group = await db.get(TaskGroupV2, task_group_id)
     if task_group is None:
         raise HTTPException(
@@ -79,7 +80,7 @@ async def query_task_group(
     return task_group
 
 
-@router.get("/", response_model=list[TaskGroupReadV2])
+@router.get("/", response_model=list[TaskGroupReadSuperuser])
 async def query_task_group_list(
     user_id: int | None = None,
     user_group_id: int | None = None,
@@ -89,9 +90,10 @@ async def query_task_group_list(
     origin: TaskGroupV2OriginEnum | None = None,
     timestamp_last_used_min: AwareDatetime | None = None,
     timestamp_last_used_max: AwareDatetime | None = None,
-    user: UserOAuth = Depends(current_active_superuser),
+    resource_id: int | None = None,
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskGroupReadV2]:
+) -> list[TaskGroupReadSuperuser]:
     stm = select(TaskGroupV2)
 
     if user_group_id is not None and private is True:
@@ -128,19 +130,22 @@ async def query_task_group_list(
         stm = stm.where(
             TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
         )
+    if resource_id is not None:
+        stm = stm.where(TaskGroupV2.resource_id == resource_id)
 
+    stm = stm.order_by(TaskGroupV2.id)
     res = await db.execute(stm)
     task_groups_list = res.scalars().all()
     return task_groups_list
 
 
-@router.patch("/{task_group_id}/", response_model=TaskGroupReadV2)
+@router.patch("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
 async def patch_task_group(
     task_group_id: int,
     task_group_update: TaskGroupUpdateV2,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskGroupReadV2]:
+) -> list[TaskGroupReadSuperuser]:
     task_group = await db.get(TaskGroupV2, task_group_id)
     if task_group is None:
         raise HTTPException(

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

@@ -21,18 +21,16 @@ from fractal_server.app.routes.api.v2._aux_functions_task_lifecycle import (
 from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_group_or_404,
 )
-from fractal_server.app.routes.auth import current_active_superuser
-from fractal_server.app.routes.aux.validate_user_settings import (
-    validate_user_settings,
+from fractal_server.app.routes.auth import current_superuser_act
+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.config import get_settings
 from fractal_server.logger import set_logger
-from fractal_server.ssh._fabric import SSHConfig
-from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.local import deactivate_local
 from fractal_server.tasks.v2.local import delete_local
 from fractal_server.tasks.v2.local import reactivate_local
@@ -54,7 +52,7 @@ async def deactivate_task_group(
     task_group_id: int,
     background_tasks: BackgroundTasks,
     response: Response,
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupActivityV2Read:
     """
@@ -114,34 +112,23 @@ async def deactivate_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    # Submit background task
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        user = await db.get(UserOAuth, task_group.user_id)
-        user_settings = await validate_user_settings(
-            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # User appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
-        )
+    user = await db.get(UserOAuth, task_group.user_id)
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(user=user, db=db)
 
-        background_tasks.add_task(
-            deactivate_ssh,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            ssh_config=ssh_config,
-            tasks_base_dir=user_settings.ssh_tasks_dir,
-        )
+    # Submit background task
+    if resource.type == ResourceType.SLURM_SSH:
+        deactivate_function = deactivate_ssh
     else:
-        background_tasks.add_task(
-            deactivate_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        deactivate_function = deactivate_local
+
+    background_tasks.add_task(
+        deactivate_function,
+        task_group_id=task_group.id,
+        task_group_activity_id=task_group_activity.id,
+        resource=resource,
+        profile=profile,
+    )
 
     logger.debug(
         "Admin task group deactivation endpoint: start deactivate "
@@ -159,7 +146,7 @@ async def reactivate_task_group(
     task_group_id: int,
     background_tasks: BackgroundTasks,
     response: Response,
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupActivityV2Read:
     """
@@ -229,34 +216,24 @@ async def reactivate_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    # Submit background task
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        user = await db.get(UserOAuth, task_group.user_id)
-        user_settings = await validate_user_settings(
-            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # Use appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
-        )
+    # Get validated resource and profile
+    user = await db.get(UserOAuth, task_group.user_id)
+    resource, profile = await validate_user_profile(user=user, db=db)
 
-        background_tasks.add_task(
-            reactivate_ssh,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            ssh_config=ssh_config,
-            tasks_base_dir=user_settings.ssh_tasks_dir,
-        )
+    # Submit background task
+    if resource.type == ResourceType.SLURM_SSH:
+        reactivate_function = reactivate_ssh
     else:
-        background_tasks.add_task(
-            reactivate_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        reactivate_function = reactivate_local
+
+    background_tasks.add_task(
+        reactivate_function,
+        task_group_id=task_group.id,
+        task_group_activity_id=task_group_activity.id,
+        resource=resource,
+        profile=profile,
+    )
+
     logger.debug(
         "Admin task group reactivation endpoint: start reactivate "
         "and return task_group_activity"
@@ -270,7 +247,7 @@ async def delete_task_group(
     task_group_id: int,
     background_tasks: BackgroundTasks,
     response: Response,
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ):
     task_group = await _get_task_group_or_404(
@@ -292,33 +269,22 @@ async def delete_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        task_owner = await db.get(UserOAuth, task_group.user_id)
-        task_owner_settings = await validate_user_settings(
-            user=task_owner, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # Use appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=task_owner_settings.ssh_username,
-            host=task_owner_settings.ssh_host,
-            key_path=task_owner_settings.ssh_private_key_path,
-        )
+    # Get validated resource and profile
+    task_owner = await db.get(UserOAuth, task_group.user_id)
+    resource, profile = await validate_user_profile(user=task_owner, db=db)
 
-        background_tasks.add_task(
-            delete_ssh,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            ssh_config=ssh_config,
-            tasks_base_dir=task_owner_settings.ssh_tasks_dir,
-        )
+    if resource.type == ResourceType.SLURM_SSH:
+        delete_function = delete_ssh
     else:
-        background_tasks.add_task(
-            delete_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        delete_function = delete_local
+
+    background_tasks.add_task(
+        delete_function,
+        task_group_activity_id=task_group_activity.id,
+        task_group_id=task_group.id,
+        resource=resource,
+        profile=profile,
+    )
     logger.debug(
         "Admin task group deletion endpoint: start deletion "
         "and return task_group_activity"

fractal_server/app/routes/api/__init__.py

@@ -4,25 +4,62 @@
 from fastapi import APIRouter
 from fastapi import Depends
 
-from ....config import get_settings
-from ....syringe import Inject
+import fractal_server
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.routes.auth import current_active_superuser
-
+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
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
 
 router_api = APIRouter()
 
 
 @router_api.get("/alive/")
 async def alive():
-    settings = Inject(get_settings)
     return dict(
         alive=True,
-        version=settings.PROJECT_VERSION,
+        version=fractal_server.__VERSION__,
     )
 
 
-@router_api.get("/settings/")
-async def view_settings(user: UserOAuth = Depends(current_active_superuser)):
+@router_api.get("/settings/app/")
+async def view_settings(
+    user: UserOAuth = Depends(current_superuser_act),
+):
     settings = Inject(get_settings)
     return settings.model_dump()
+
+
+@router_api.get("/settings/database/")
+async def view_db_settings(
+    user: UserOAuth = Depends(current_superuser_act),
+):
+    settings = Inject(get_db_settings)
+    return settings.model_dump()
+
+
+@router_api.get("/settings/email/")
+async def view_email_settings(
+    user: UserOAuth = Depends(current_superuser_act),
+):
+    settings = Inject(get_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),
+):
+    settings = Inject(get_oauth_settings)
+    return settings.model_dump()

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

@@ -11,7 +11,6 @@ from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 from sqlmodel.sql.expression import SelectOfScalar
 
-from ....db import AsyncSession
 from ....models.v2 import DatasetV2
 from ....models.v2 import JobV2
 from ....models.v2 import LinkUserProjectV2
@@ -20,6 +19,10 @@ from ....models.v2 import TaskV2
 from ....models.v2 import WorkflowTaskV2
 from ....models.v2 import WorkflowV2
 from ....schemas.v2 import JobStatusTypeV2
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models import Profile
+from fractal_server.app.models import Resource
+from fractal_server.app.models import UserOAuth
 from fractal_server.logger import set_logger
 
 logger = set_logger(__name__)
@@ -538,3 +541,16 @@ async def _get_submitted_job_or_none(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=error_msg,
         )
+
+
+async def _get_user_resource_id(user_id: int, db: AsyncSession) -> int | None:
+    res = await db.execute(
+        select(Resource.id)
+        .join(Profile)
+        .join(UserOAuth)
+        .where(Resource.id == Profile.resource_id)
+        .where(Profile.id == UserOAuth.profile_id)
+        .where(UserOAuth.id == user_id)
+    )
+    resource_id = res.scalar_one_or_none()
+    return resource_id

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

@@ -32,7 +32,7 @@ async def get_history_unit_or_404(
     """
     Get an existing HistoryUnit  or raise a 404.
 
-    Arguments:
+    Args:
         history_unit_id: The `HistoryUnit` id
         db: An asynchronous db session
     """
@@ -51,7 +51,7 @@ async def get_history_run_or_404(
     """
     Get an existing HistoryRun  or raise a 404.
 
-    Arguments:
+    Args:
         history_run_id:
         db:
     """

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

@@ -59,7 +59,7 @@ async def get_package_version_from_pypi(
 
     Ref https://warehouse.pypa.io/api-reference/json.html.
 
-    Arguments:
+    Args:
         name: Package name.
         version:
             Could be a correct version (`1.3.0`), an incomplete one
@@ -165,7 +165,7 @@ async def check_no_ongoing_activity(
     """
     Find ongoing activities for the same task group.
 
-    Arguments:
+    Args:
         task_group_id:
         db:
     """
@@ -204,7 +204,7 @@ async def check_no_submitted_job(
     """
     Find submitted jobs which include tasks from a given task group.
 
-    Arguments:
+    Args:
         task_group_id: ID of the `TaskGroupV2` object.
         db: Asynchronous database session.
     """