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

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

@@ -14,8 +14,8 @@ from fractal_server.app.models.v2 import TaskGroupV2
 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.schemas.v2 import JobStatusTypeV2
-from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.app.schemas.v2 import JobStatusType
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatus
 from fractal_server.logger import set_logger
 from fractal_server.tasks.v2.utils_package_names import normalize_package_name
 
@@ -99,8 +99,7 @@ async def get_package_version_from_pypi(
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=(
-                f"Could not get {url} (status_code {res.status_code})."
-                f"\n{hint}"
+                f"Could not get {url} (status_code {res.status_code}).\n{hint}"
             ),
         )
     try:
@@ -144,8 +143,7 @@ async def get_package_version_from_pypi(
                 raise HTTPException(
                     status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                     detail=(
-                        f"No version starting with {version} found.\n"
-                        f"{hint}"
+                        f"No version starting with {version} found.\n{hint}"
                     ),
                 )
             else:
@@ -173,7 +171,7 @@ async def check_no_ongoing_activity(
     stm = (
         select(TaskGroupActivityV2)
         .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
-        .where(TaskGroupActivityV2.status == TaskGroupActivityStatusV2.ONGOING)
+        .where(TaskGroupActivityV2.status == TaskGroupActivityStatus.ONGOING)
     )
     res = await db.execute(stm)
     ongoing_activities = res.scalars().all()
@@ -215,7 +213,7 @@ async def check_no_submitted_job(
         .join(TaskV2, WorkflowTaskV2.task_id == TaskV2.id)
         .where(WorkflowTaskV2.order >= JobV2.first_task_index)
         .where(WorkflowTaskV2.order <= JobV2.last_task_index)
-        .where(JobV2.status == JobStatusTypeV2.SUBMITTED)
+        .where(JobV2.status == JobStatusType.SUBMITTED)
         .where(TaskV2.taskgroupv2_id == task_group_id)
     )
     res = await db.execute(stm)

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

@@ -2,6 +2,7 @@
 Auxiliary functions to get task and task-group object from the database or
 perform simple checks
 """
+
 from typing import Any
 
 from fastapi import HTTPException
@@ -26,7 +27,7 @@ from fractal_server.app.routes.auth._aux_auth import (
 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 TaskGroupActivityAction
 from fractal_server.images.tools import merge_type_filters
 from fractal_server.logger import set_logger
 
@@ -74,8 +75,7 @@ async def _get_task_group_read_access(
     forbidden_exception = HTTPException(
         status_code=status.HTTP_403_FORBIDDEN,
         detail=(
-            "Current user has no read access to TaskGroupV2 "
-            f"{task_group_id}."
+            f"Current user has no read access to TaskGroupV2 {task_group_id}."
         ),
     )
 
@@ -86,13 +86,11 @@ async def _get_task_group_read_access(
     else:
         stm = (
             select(LinkUserGroup)
-            .join(UserOAuth)
-            .join(Profile)
+            .join(UserOAuth, UserOAuth.id == LinkUserGroup.user_id)
+            .join(Profile, Profile.id == UserOAuth.profile_id)
             .where(LinkUserGroup.group_id == task_group.user_group_id)
-            .where(LinkUserGroup.user_id == user_id)
             .where(UserOAuth.id == user_id)
-            .where(Profile.id == UserOAuth.profile_id)
-            .where(task_group.resource_id == Profile.resource_id)
+            .where(Profile.resource_id == task_group.resource_id)
         )
         res = await db.execute(stm)
         link = res.unique().scalars().one_or_none()
@@ -254,7 +252,7 @@ async def _get_collection_task_group_activity_status_message(
     res = await db.execute(
         select(TaskGroupActivityV2)
         .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
-        .where(TaskGroupActivityV2.action == TaskGroupActivityActionV2.COLLECT)
+        .where(TaskGroupActivityV2.action == TaskGroupActivityAction.COLLECT)
     )
     task_group_activity_list = res.scalars().all()
     if len(task_group_activity_list) > 1:

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

@@ -10,7 +10,6 @@ from fractal_server.exceptions import UnreachableBranchError
 from fractal_server.logger import set_logger
 from fractal_server.syringe import Inject
 
-
 logger = set_logger(__name__)
 
 
@@ -84,7 +83,7 @@ async def _disambiguate_task_groups(
     res = await db.execute(stm)
     oldest_user_group_id = res.scalars().first()
     logger.debug(
-        "[_disambiguate_task_groups] " f"Result: {oldest_user_group_id=}."
+        f"[_disambiguate_task_groups] Result: {oldest_user_group_id=}."
     )
     task_group = next(
         iter(

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

@@ -1,3 +1,6 @@
+import os
+from pathlib import Path
+
 from fastapi import APIRouter
 from fastapi import Depends
 from fastapi import HTTPException
@@ -5,89 +8,106 @@ from fastapi import Response
 from fastapi import status
 from sqlmodel import select
 
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v2 import DatasetV2
-from ....models.v2 import JobV2
-from ....models.v2 import ProjectV2
-from ....schemas.v2 import DatasetCreateV2
-from ....schemas.v2 import DatasetReadV2
-from ....schemas.v2 import DatasetUpdateV2
-from ....schemas.v2.dataset import DatasetExportV2
-from ....schemas.v2.dataset import DatasetImportV2
-from ._aux_functions import _get_dataset_check_owner
-from ._aux_functions import _get_project_check_owner
-from ._aux_functions import _get_submitted_jobs_statement
+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 DatasetV2
+from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.routes.auth import current_user_act_ver_prof
+from fractal_server.app.schemas.v2 import DatasetCreate
+from fractal_server.app.schemas.v2 import DatasetRead
+from fractal_server.app.schemas.v2 import DatasetUpdate
+from fractal_server.app.schemas.v2.dataset import DatasetExport
+from fractal_server.app.schemas.v2.dataset import DatasetImport
+from fractal_server.app.schemas.v2.sharing import ProjectPermissions
 from fractal_server.string_tools import sanitize_string
 from fractal_server.urls import normalize_url
 
+from ._aux_functions import _get_dataset_check_access
+from ._aux_functions import _get_project_check_access
+from ._aux_functions import _get_submitted_jobs_statement
+
 router = APIRouter()
 
 
 @router.post(
     "/project/{project_id}/dataset/",
-    response_model=DatasetReadV2,
+    response_model=DatasetRead,
     status_code=status.HTTP_201_CREATED,
 )
 async def create_dataset(
     project_id: int,
-    dataset: DatasetCreateV2,
+    dataset: DatasetCreate,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> DatasetReadV2 | None:
+) -> DatasetRead | None:
     """
     Add new dataset to current project
     """
-    project = await _get_project_check_owner(
-        project_id=project_id, user_id=user.id, db=db
+    project = await _get_project_check_access(
+        project_id=project_id,
+        user_id=user.id,
+        required_permissions=ProjectPermissions.WRITE,
+        db=db,
     )
 
-    if dataset.zarr_dir is None:
-        db_dataset = DatasetV2(
-            project_id=project_id,
-            zarr_dir="__PLACEHOLDER__",
-            **dataset.model_dump(exclude={"zarr_dir"}),
-        )
-        db.add(db_dataset)
-        await db.commit()
-        await db.refresh(db_dataset)
-        path = (
-            f"{user.project_dir}/fractal/"
-            f"{project_id}_{sanitize_string(project.name)}/"
+    db_dataset = DatasetV2(
+        project_id=project_id,
+        zarr_dir="__PLACEHOLDER__",
+        **dataset.model_dump(exclude={"project_dir", "zarr_subfolder"}),
+    )
+    db.add(db_dataset)
+    await db.commit()
+    await db.refresh(db_dataset)
+
+    if dataset.project_dir is None:
+        project_dir = user.project_dirs[0]
+    else:
+        if dataset.project_dir not in user.project_dirs:
+            await db.delete(db_dataset)
+            await db.commit()
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"You are not allowed to use {dataset.project_dir=}.",
+            )
+        project_dir = dataset.project_dir
+
+    if dataset.zarr_subfolder is None:
+        zarr_subfolder = (
+            f"fractal/{project_id}_{sanitize_string(project.name)}/"
             f"{db_dataset.id}_{sanitize_string(db_dataset.name)}"
         )
-        normalized_path = normalize_url(path)
-        db_dataset.zarr_dir = normalized_path
-
-        db.add(db_dataset)
-        await db.commit()
-        await db.refresh(db_dataset)
     else:
-        db_dataset = DatasetV2(project_id=project_id, **dataset.model_dump())
-        db.add(db_dataset)
-        await db.commit()
-        await db.refresh(db_dataset)
+        zarr_subfolder = dataset.zarr_subfolder
+
+    zarr_dir = os.path.join(project_dir, zarr_subfolder)
+    db_dataset.zarr_dir = normalize_url(zarr_dir)
+
+    db.add(db_dataset)
+    await db.commit()
+    await db.refresh(db_dataset)
 
     return db_dataset
 
 
 @router.get(
     "/project/{project_id}/dataset/",
-    response_model=list[DatasetReadV2],
+    response_model=list[DatasetRead],
 )
 async def read_dataset_list(
     project_id: int,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> list[DatasetReadV2] | None:
+) -> list[DatasetRead] | None:
     """
     Get dataset list for given project
     """
     # Access control
-    project = await _get_project_check_owner(
-        project_id=project_id, user_id=user.id, db=db
+    project = await _get_project_check_access(
+        project_id=project_id,
+        user_id=user.id,
+        required_permissions=ProjectPermissions.READ,
+        db=db,
     )
     # Find datasets of the current project. Note: this select/where approach
     # has much better scaling than refreshing all elements of
@@ -96,72 +116,62 @@ async def read_dataset_list(
     stm = select(DatasetV2).where(DatasetV2.project_id == project.id)
     res = await db.execute(stm)
     dataset_list = res.scalars().all()
-    await db.close()
     return dataset_list
 
 
 @router.get(
     "/project/{project_id}/dataset/{dataset_id}/",
-    response_model=DatasetReadV2,
+    response_model=DatasetRead,
 )
 async def read_dataset(
     project_id: int,
     dataset_id: int,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> DatasetReadV2 | None:
+) -> DatasetRead | None:
     """
     Get info on a dataset associated to the current project
     """
-    output = await _get_dataset_check_owner(
+    output = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.READ,
         db=db,
     )
     dataset = output["dataset"]
-    await db.close()
     return dataset
 
 
 @router.patch(
     "/project/{project_id}/dataset/{dataset_id}/",
-    response_model=DatasetReadV2,
+    response_model=DatasetRead,
 )
 async def update_dataset(
     project_id: int,
     dataset_id: int,
-    dataset_update: DatasetUpdateV2,
+    dataset_update: DatasetUpdate,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> DatasetReadV2 | None:
+) -> DatasetRead | None:
     """
     Edit a dataset associated to the current project
     """
 
-    output = await _get_dataset_check_owner(
+    output = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.WRITE,
         db=db,
     )
     db_dataset = output["dataset"]
 
-    if (dataset_update.zarr_dir is not None) and (len(db_dataset.images) != 0):
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=(
-                "Cannot modify `zarr_dir` because the dataset has a non-empty "
-                "image list."
-            ),
-        )
-
     for key, value in dataset_update.model_dump(exclude_unset=True).items():
         setattr(db_dataset, key, value)
 
     await db.commit()
     await db.refresh(db_dataset)
-    await db.close()
     return db_dataset
 
 
@@ -178,10 +188,11 @@ async def delete_dataset(
     """
     Delete a dataset associated to the current project
     """
-    output = await _get_dataset_check_owner(
+    output = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.WRITE,
         db=db,
     )
     dataset = output["dataset"]
@@ -208,46 +219,26 @@ async def delete_dataset(
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
-@router.get("/dataset/", response_model=list[DatasetReadV2])
-async def get_user_datasets(
-    user: UserOAuth = Depends(current_user_act_ver_prof),
-    db: AsyncSession = Depends(get_async_db),
-) -> list[DatasetReadV2]:
-    """
-    Returns all the datasets of the current user
-    """
-    stm = select(DatasetV2)
-    stm = stm.join(ProjectV2).where(
-        ProjectV2.user_list.any(UserOAuth.id == user.id)
-    )
-
-    res = await db.execute(stm)
-    dataset_list = res.scalars().all()
-    await db.close()
-    return dataset_list
-
-
 @router.get(
     "/project/{project_id}/dataset/{dataset_id}/export/",
-    response_model=DatasetExportV2,
+    response_model=DatasetExport,
 )
 async def export_dataset(
     project_id: int,
     dataset_id: int,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> DatasetExportV2 | None:
+) -> DatasetExport | None:
     """
     Export an existing dataset
     """
-    dict_dataset_project = await _get_dataset_check_owner(
+    dict_dataset_project = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.READ,
         db=db,
     )
-    await db.close()
-
     dataset = dict_dataset_project["dataset"]
 
     return dataset
@@ -255,35 +246,38 @@ async def export_dataset(
 
 @router.post(
     "/project/{project_id}/dataset/import/",
-    response_model=DatasetReadV2,
+    response_model=DatasetRead,
     status_code=status.HTTP_201_CREATED,
 )
 async def import_dataset(
     project_id: int,
-    dataset: DatasetImportV2,
+    dataset: DatasetImport,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> DatasetReadV2 | None:
+) -> DatasetRead | None:
     """
     Import an existing dataset into a project
     """
 
     # Preliminary checks
-    await _get_project_check_owner(
+    await _get_project_check_access(
         project_id=project_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.WRITE,
         db=db,
     )
 
-    for image in dataset.images:
-        if not image.zarr_url.startswith(dataset.zarr_dir):
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-                detail=(
-                    f"Cannot import dataset: zarr_url {image.zarr_url} is not "
-                    f"relative to zarr_dir={dataset.zarr_dir}."
-                ),
-            )
+    if not any(
+        Path(dataset.zarr_dir).is_relative_to(project_dir)
+        for project_dir in user.project_dirs
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"{dataset.zarr_dir=} is not relative to any of user's project "
+                "dirs."
+            ),
+        )
 
     # Create new Dataset
     db_dataset = DatasetV2(
@@ -293,6 +287,5 @@ async def import_dataset(
     db.add(db_dataset)
     await db.commit()
     await db.refresh(db_dataset)
-    await db.close()
 
     return db_dataset