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

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

@@ -6,7 +6,9 @@ from fastapi import APIRouter
 from .accounting import router as accounting_router
 from .impersonate import router as impersonate_router
 from .job import router as job_router
+from .profile import router as profile_router
 from .project import router as project_router
+from .resource import router as resource_router
 from .task import router as task_router
 from .task_group import router as task_group_router
 from .task_group_lifecycle import router as task_group_lifecycle_router
@@ -22,3 +24,5 @@ router_admin_v2.include_router(
     task_group_lifecycle_router, prefix="/task-group"
 )
 router_admin_v2.include_router(impersonate_router, prefix="/impersonate")
+router_admin_v2.include_router(resource_router, prefix="/resource")
+router_admin_v2.include_router(profile_router, prefix="/profile")

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

@@ -0,0 +1,55 @@
+from fastapi import HTTPException
+from fastapi import status
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models.v2 import Profile
+from fractal_server.app.models.v2 import Resource
+
+
+async def _get_resource_or_404(
+    *,
+    resource_id: int,
+    db: AsyncSession,
+) -> Resource:
+    resource = await db.get(Resource, resource_id)
+    if resource is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Resource {resource_id} not found",
+        )
+    return resource
+
+
+async def _get_profile_or_404(
+    *,
+    profile_id: int,
+    db: AsyncSession,
+) -> Profile:
+    profile = await db.get(Profile, profile_id)
+    if profile is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Profile {profile_id} not found",
+        )
+    return profile
+
+
+async def _check_profile_name(*, name: str, db: AsyncSession) -> None:
+    res = await db.execute(select(Profile).where(Profile.name == name))
+    namesake = res.scalars().one_or_none()
+    if namesake is not None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=f"Profile with name '{name}' already exists.",
+        )
+
+
+async def _check_resource_name(*, name: str, db: AsyncSession) -> None:
+    res = await db.execute(select(Resource).where(Resource.name == name))
+    namesake = res.scalars().one_or_none()
+    if namesake is not None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=f"Resource with name '{name}' already exists.",
+        )

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

@@ -13,7 +13,7 @@ from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import AccountingRecord
 from fractal_server.app.models.v2 import AccountingRecordSlurm
-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
@@ -34,7 +34,7 @@ async def query_accounting(
     query: AccountingQuery,
     # Dependencies
     pagination: PaginationRequest = Depends(get_pagination_params),
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> PaginationResponse[AccountingRecordRead]:
     page = pagination.page
@@ -79,7 +79,7 @@ async def query_accounting(
 async def query_accounting_slurm(
     query: AccountingQuery,
     # dependencies
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> JSONResponse:
     stm = select(AccountingRecordSlurm.slurm_job_ids)

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

@@ -6,7 +6,7 @@ from fastapi_users.authentication import JWTStrategy
 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.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 _user_or_404
 from fractal_server.config import get_settings
 from fractal_server.syringe import Inject
@@ -17,7 +17,7 @@ router = APIRouter()
 @router.get("/{user_id}/")
 async def impersonate_user(
     user_id: int,
-    superuser: UserOAuth = Depends(current_active_superuser),
+    superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> JSONResponse:
     user = await _user_or_404(user_id, db)

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

@@ -7,6 +7,7 @@ from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
 from pydantic.types import AwareDatetime
+from sqlalchemy import func
 from sqlmodel import select
 
 from fractal_server.app.db import AsyncSession
@@ -16,9 +17,12 @@ 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_active_superuser
+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.schemas.v2 import HistoryUnitStatus
 from fractal_server.app.schemas.v2 import JobReadV2
 from fractal_server.app.schemas.v2 import JobStatusTypeV2
@@ -30,7 +34,7 @@ from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 router = APIRouter()
 
 
-@router.get("/", response_model=list[JobReadV2])
+@router.get("/", response_model=PaginationResponse[JobReadV2])
 async def view_job(
     id: int | None = None,
     user_id: int | None = None,
@@ -43,9 +47,10 @@ async def view_job(
     end_timestamp_min: AwareDatetime | None = None,
     end_timestamp_max: AwareDatetime | None = None,
     log: bool = True,
-    user: UserOAuth = Depends(current_active_superuser),
+    pagination: PaginationRequest = Depends(get_pagination_params),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> list[JobReadV2]:
+) -> PaginationResponse[JobReadV2]:
     """
     Query `ApplyWorkflow` table.
 
@@ -68,50 +73,81 @@ async def view_job(
             `job.log` is set to `None`.
     """
 
-    stm = select(JobV2)
+    # Assign pagination parameters
+    page = pagination.page
+    page_size = pagination.page_size
 
+    # Prepare statements
+    stm = select(JobV2).order_by(JobV2.start_timestamp.desc())
+    stm_count = select(func.count(JobV2.id))
     if id is not None:
         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_count = stm_count.join(ProjectV2).where(
+            ProjectV2.user_list.any(UserOAuth.id == user_id)
+        )
     if project_id is not None:
         stm = stm.where(JobV2.project_id == project_id)
+        stm_count = stm_count.where(JobV2.project_id == project_id)
     if dataset_id is not None:
         stm = stm.where(JobV2.dataset_id == dataset_id)
+        stm_count = stm_count.where(JobV2.dataset_id == dataset_id)
     if workflow_id is not None:
         stm = stm.where(JobV2.workflow_id == workflow_id)
+        stm_count = stm_count.where(JobV2.workflow_id == workflow_id)
     if status is not None:
         stm = stm.where(JobV2.status == status)
+        stm_count = stm_count.where(JobV2.status == status)
     if start_timestamp_min is not None:
-        start_timestamp_min = start_timestamp_min
         stm = stm.where(JobV2.start_timestamp >= start_timestamp_min)
+        stm_count = stm_count.where(
+            JobV2.start_timestamp >= start_timestamp_min
+        )
     if start_timestamp_max is not None:
-        start_timestamp_max = start_timestamp_max
         stm = stm.where(JobV2.start_timestamp <= start_timestamp_max)
+        stm_count = stm_count.where(
+            JobV2.start_timestamp <= start_timestamp_max
+        )
     if end_timestamp_min is not None:
-        end_timestamp_min = end_timestamp_min
         stm = stm.where(JobV2.end_timestamp >= end_timestamp_min)
+        stm_count = stm_count.where(JobV2.end_timestamp >= end_timestamp_min)
     if end_timestamp_max is not None:
-        end_timestamp_max = end_timestamp_max
         stm = stm.where(JobV2.end_timestamp <= end_timestamp_max)
+        stm_count = stm_count.where(JobV2.end_timestamp <= end_timestamp_max)
 
+    # 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)
     job_list = res.scalars().all()
-    await db.close()
+
     if not log:
         for job in job_list:
             setattr(job, "log", None)
 
-    return job_list
+    return PaginationResponse[JobReadV2](
+        total_count=total_count,
+        page_size=page_size,
+        current_page=page,
+        items=[job.model_dump() for job in job_list],
+    )
 
 
 @router.get("/{job_id}/", response_model=JobReadV2)
 async def view_single_job(
     job_id: int,
     show_tmp_logs: bool = False,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> JobReadV2:
     job = await db.get(JobV2, job_id)
@@ -136,7 +172,7 @@ async def view_single_job(
 async def update_job(
     job_update: JobUpdateV2,
     job_id: int,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> JobReadV2 | None:
     """
@@ -200,7 +236,7 @@ async def update_job(
 @router.get("/{job_id}/stop/", status_code=202)
 async def stop_job(
     job_id: int,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> Response:
     """
@@ -224,7 +260,7 @@ async def stop_job(
 @router.get("/{job_id}/download/", response_class=StreamingResponse)
 async def download_job_logs(
     job_id: int,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> StreamingResponse:
     """

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

@@ -0,0 +1,100 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+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
+from fractal_server.app.models import UserOAuth
+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
+
+router = APIRouter()
+
+
+@router.get("/{profile_id}/", response_model=ProfileRead, status_code=200)
+async def get_single_profile(
+    profile_id: int,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ProfileRead:
+    """
+    Query single `Profile`.
+    """
+    profile = await _get_profile_or_404(profile_id=profile_id, db=db)
+    return profile
+
+
+@router.get("/", response_model=list[ProfileRead], status_code=200)
+async def get_profile_list(
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ProfileRead:
+    """
+    Query single `Profile`.
+    """
+    res = await db.execute(select(Profile).order_by(Profile.id))
+    profiles = res.scalars().all()
+    return profiles
+
+
+@router.put("/{profile_id}/", response_model=ProfileRead, status_code=200)
+async def put_profile(
+    profile_id: int,
+    profile_update: ProfileCreate,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ProfileRead:
+    """
+    Override single `Profile`.
+    """
+    profile = await _get_profile_or_404(profile_id=profile_id, db=db)
+
+    if profile_update.name and profile_update.name != profile.name:
+        await _check_profile_name(name=profile_update.name, db=db)
+
+    for key, value in profile_update.model_dump().items():
+        setattr(profile, key, value)
+    await db.commit()
+    await db.refresh(profile)
+    return profile
+
+
+@router.delete("/{profile_id}/", status_code=204)
+async def delete_profile(
+    profile_id: int,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """
+    Delete single `Profile`.
+    """
+    profile = await _get_profile_or_404(profile_id=profile_id, db=db)
+
+    # Fail if at least one UserOAuth is associated with the Profile.
+    res = await db.execute(
+        select(func.count(UserOAuth.id)).where(
+            UserOAuth.profile_id == profile.id
+        )
+    )
+    associated_users_count = res.scalar()
+    if associated_users_count > 0:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"Cannot delete Profile {profile_id} because it's associated"
+                f" with {associated_users_count} UserOAuths."
+            ),
+        )
+
+    # Delete
+    await db.delete(profile)
+    await db.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

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

@@ -6,7 +6,7 @@ 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.routes.auth import current_superuser_act
 from fractal_server.app.schemas.v2 import ProjectReadV2
 
 router = APIRouter()
@@ -16,7 +16,7 @@ router = APIRouter()
 async def view_project(
     id: int | None = None,
     user_id: int | None = None,
-    user: UserOAuth = Depends(current_active_superuser),
+    user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[ProjectReadV2]:
     """

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

@@ -0,0 +1,222 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+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
+from fractal_server.app.models.v2 import Profile
+from fractal_server.app.models.v2 import Resource
+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 fractal_server.app.schemas.v2 import ResourceCreate
+from fractal_server.app.schemas.v2 import ResourceRead
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
+router = APIRouter()
+
+
+def _check_resource_type_match_or_422(
+    resource: Resource,
+    new_profile: ProfileCreate,
+) -> None:
+    if resource.type != new_profile.resource_type:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"{resource.type=} differs from {new_profile.resource_type=}."
+            ),
+        )
+
+
+def _check_type_match_or_422(new_resource: ResourceCreate) -> None:
+    """
+    Handle case where `resource.type != FRACTAL_RUNNER_BACKEND`
+    """
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND != new_resource.type:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"{settings.FRACTAL_RUNNER_BACKEND=} != "
+                f"{new_resource.type=}"
+            ),
+        )
+
+
+@router.get("/", response_model=list[ResourceRead], status_code=200)
+async def get_resource_list(
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ResourceRead]:
+    """
+    Query `Resource` table.
+    """
+
+    stm = select(Resource).order_by(Resource.id)
+    res = await db.execute(stm)
+    resource_list = res.scalars().all()
+
+    return resource_list
+
+
+@router.get("/{resource_id}/", response_model=ResourceRead, status_code=200)
+async def get_resource(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Query single `Resource`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    return resource
+
+
+@router.post("/", response_model=ResourceRead, status_code=201)
+async def post_resource(
+    resource_create: ResourceCreate,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Create new `Resource`.
+    """
+
+    # Handle case where type!=FRACTAL_RUNNER_BACKEND
+    _check_type_match_or_422(resource_create)
+
+    await _check_resource_name(name=resource_create.name, db=db)
+
+    resource = Resource(**resource_create.model_dump())
+    db.add(resource)
+    await db.commit()
+    await db.refresh(resource)
+
+    return resource
+
+
+@router.put(
+    "/{resource_id}/",
+    response_model=ResourceRead,
+    status_code=200,
+)
+async def put_resource(
+    resource_id: int,
+    resource_update: ResourceCreate,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Overwrite a single `Resource`.
+    """
+
+    # Handle case where type!=FRACTAL_RUNNER_BACKEND
+    _check_type_match_or_422(resource_update)
+
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    # Handle non-unique resource names
+    if resource_update.name and resource_update.name != resource.name:
+        await _check_resource_name(name=resource_update.name, db=db)
+
+    # Prepare new db object
+    for key, value in resource_update.model_dump().items():
+        setattr(resource, key, value)
+
+    await db.commit()
+    await db.refresh(resource)
+    return resource
+
+
+@router.delete("/{resource_id}/", status_code=204)
+async def delete_resource(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """
+    Delete single `Resource`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+    try:
+        await db.delete(resource)
+        await db.commit()
+        return Response(status_code=status.HTTP_204_NO_CONTENT)
+    except IntegrityError as e:
+        await db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                "IntegrityError for resource deletion. "
+                f"Original error:\n{str(e)}"
+            ),
+        )
+
+
+@router.get(
+    "/{resource_id}/profile/",
+    response_model=list[ProfileRead],
+    status_code=200,
+)
+async def get_resource_profiles(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ProfileRead]:
+    """
+    Query `Profile`s for single `Resource`.
+    """
+    await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    res = await db.execute(
+        select(Profile)
+        .where(Profile.resource_id == resource_id)
+        .order_by(Profile.id)
+    )
+    profiles = res.scalars().all()
+
+    return profiles
+
+
+@router.post(
+    "/{resource_id}/profile/",
+    response_model=ProfileRead,
+    status_code=201,
+)
+async def post_profile(
+    resource_id: int,
+    profile_create: ProfileCreate,
+    superuser: UserOAuth = Depends(current_superuser_act),
+    db: AsyncSession = Depends(get_async_db),
+) -> ProfileRead:
+    """
+    Create new `Profile`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    _check_resource_type_match_or_422(
+        resource=resource,
+        new_profile=profile_create,
+    )
+    await _check_profile_name(name=profile_create.name, db=db)
+
+    profile = Profile(
+        resource_id=resource_id,
+        **profile_create.model_dump(),
+    )
+
+    db.add(profile)
+    await db.commit()
+    await db.refresh(profile)
+    return profile