fractal-server 2.17.1a0__py3-none-any.whl → 2.17.2__py3-none-any.whl

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

@@ -8,15 +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 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()
@@ -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,30 @@ 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)
+            )
+            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,16 +163,12 @@ 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](
         total_count=total_count,
         page_size=page_size,

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

@@ -24,7 +24,6 @@ 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__)

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

@@ -199,8 +199,7 @@ async def reactivate_task_group(
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=(
-                "Cannot reactivate a task group with "
-                f"{task_group.env_info=}."
+                f"Cannot reactivate a task group with {task_group.env_info=}."
             ),
         )
 

fractal_server/app/routes/api/__init__.py

@@ -1,6 +1,7 @@
 """
 `api` module
 """
+
 from fastapi import APIRouter
 from fastapi import Depends
 

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

@@ -1,8 +1,12 @@
 """
 `api/v2` module
 """
+
 from fastapi import APIRouter
 
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
 from .dataset import router as dataset_router_v2
 from .history import router as history_router_v2
 from .images import router as images_routes_v2
@@ -21,9 +25,6 @@ from .task_version_update import router as task_version_update_router_v2
 from .workflow import router as workflow_router_v2
 from .workflow_import import router as workflow_import_router_v2
 from .workflowtask import router as workflowtask_router_v2
-from fractal_server.config import get_settings
-from fractal_server.syringe import Inject
-
 
 router_api_v2 = APIRouter()
 
@@ -34,9 +35,7 @@ router_api_v2.include_router(images_routes_v2, tags=["V2 Images"])
 router_api_v2.include_router(project_router_v2, tags=["V2 Project"])
 router_api_v2.include_router(submit_job_router_v2, tags=["V2 Job"])
 router_api_v2.include_router(history_router_v2, tags=["V2 History"])
-router_api_v2.include_router(
-    status_legacy_router_v2, tags=["V2 Status Legacy"]
-)
+router_api_v2.include_router(status_legacy_router_v2, tags=["V2 Status Legacy"])
 
 
 settings = Inject(get_settings)

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

@@ -1,6 +1,7 @@
 """
 Auxiliary functions to get object from the database or perform simple checks
 """
+
 from typing import Any
 from typing import Literal
 
@@ -11,18 +12,18 @@ from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 from sqlmodel.sql.expression import SelectOfScalar
 
-from ....models.v2 import DatasetV2
-from ....models.v2 import JobV2
-from ....models.v2 import LinkUserProjectV2
-from ....models.v2 import ProjectV2
-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.app.models.v2 import DatasetV2
+from fractal_server.app.models.v2 import JobV2
+from fractal_server.app.models.v2 import LinkUserProjectV2
+from fractal_server.app.models.v2 import ProjectV2
+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.logger import set_logger
 
 logger = set_logger(__name__)
@@ -88,29 +89,29 @@ async def _get_workflow_check_owner(
 
     Raises:
         HTTPException(status_code=404_NOT_FOUND):
-            If the workflow does not exist
-        HTTPException(status_code=422_UNPROCESSABLE_ENTITY):
-            If the workflow is not associated to the project
+            If the project or the workflow do not exist or if they are not
+            associated
+        HTTPException(status_code=403_FORBIDDEN):
+            If the user is not a member of the project
     """
 
     # Access control for project
-    project = await _get_project_check_owner(
+    await _get_project_check_owner(
         project_id=project_id, user_id=user_id, db=db
     )
 
-    # Get workflow
-    # (See issue 1087 for 'populate_existing=True')
-    workflow = await db.get(WorkflowV2, workflow_id, populate_existing=True)
+    res = await db.execute(
+        select(WorkflowV2)
+        .where(WorkflowV2.id == workflow_id)
+        .where(WorkflowV2.project_id == project_id)
+        .execution_options(populate_existing=True)  # See issue 1087
+    )
+    workflow = res.scalars().one_or_none()
 
     if not workflow:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Workflow not found"
         )
-    if workflow.project_id != project.id:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=(f"Invalid {project_id=} for {workflow_id=}."),
-        )
 
     return workflow
 
@@ -138,9 +139,10 @@ async def _get_workflow_task_check_owner(
 
     Raises:
         HTTPException(status_code=404_NOT_FOUND):
-            If the WorkflowTask does not exist
-        HTTPException(status_code=422_UNPROCESSABLE_ENTITY):
-            If the WorkflowTask is not associated to the Workflow
+            If the project, the workflow or the workflowtask do not exist or
+            if they are not associated
+        HTTPException(status_code=403_FORBIDDEN):
+            If the user is not a member of the project
     """
 
     # Access control for workflow
@@ -151,21 +153,19 @@ async def _get_workflow_task_check_owner(
         db=db,
     )
 
-    # If WorkflowTask is not in the db, exit
-    workflow_task = await db.get(WorkflowTaskV2, workflow_task_id)
-    if not workflow_task:
+    res = await db.execute(
+        select(WorkflowTaskV2)
+        .where(WorkflowTaskV2.id == workflow_task_id)
+        .where(WorkflowTaskV2.workflow_id == workflow_id)
+    )
+    workflow_task = res.scalars().one_or_none()
+
+    if workflow_task is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail="WorkflowTask not found",
         )
 
-    # If WorkflowTask is not part of the expected Workflow, exit
-    if workflow_id != workflow_task.workflow_id:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=f"Invalid {workflow_id=} for {workflow_task_id=}",
-        )
-
     return workflow_task, workflow
 
 
@@ -220,7 +220,7 @@ async def _check_project_exists(
     """
     stm = (
         select(ProjectV2)
-        .join(LinkUserProjectV2)
+        .join(LinkUserProjectV2, LinkUserProjectV2.project_id == ProjectV2.id)
         .where(ProjectV2.name == project_name)
         .where(LinkUserProjectV2.user_id == user_id)
     )
@@ -253,27 +253,29 @@ async def _get_dataset_check_owner(
             `project`).
 
     Raises:
-        HTTPException(status_code=422_UNPROCESSABLE_ENTITY):
-            If the dataset is not associated to the project
+        HTTPException(status_code=404_UNPROCESSABLE_ENTITY):
+            If the project or the dataset do not exist or if they are not
+            associated
+        HTTPException(status_code=403_FORBIDDEN):
+            If the user is not a member of the project
     """
     # Access control for project
     project = await _get_project_check_owner(
         project_id=project_id, user_id=user_id, db=db
     )
 
-    # Get dataset
-    # (See issue 1087 for 'populate_existing=True')
-    dataset = await db.get(DatasetV2, dataset_id, populate_existing=True)
+    res = await db.execute(
+        select(DatasetV2)
+        .where(DatasetV2.id == dataset_id)
+        .where(DatasetV2.project_id == project_id)
+        .execution_options(populate_existing=True)  # See issue 1087
+    )
+    dataset = res.scalars().one_or_none()
 
-    if not dataset:
+    if dataset is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Dataset not found"
         )
-    if dataset.project_id != project_id:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=f"Invalid {project_id=} for {dataset_id=}",
-        )
 
     return dict(dataset=dataset, project=project)
 
@@ -299,8 +301,11 @@ async def _get_job_check_owner(
             `project`).
 
     Raises:
-        HTTPException(status_code=422_UNPROCESSABLE_ENTITY):
-            If the job is not associated to the project
+        HTTPException(status_code=404_UNPROCESSABLE_ENTITY):
+            If the project or the job do not exist or if they are not
+            associated
+        HTTPException(status_code=403_FORBIDDEN):
+            If the user is not a member of the project
     """
     # Access control for project
     project = await _get_project_check_owner(
@@ -308,17 +313,19 @@ async def _get_job_check_owner(
         user_id=user_id,
         db=db,
     )
-    # Get dataset
-    job = await db.get(JobV2, job_id)
-    if not job:
+
+    res = await db.execute(
+        select(JobV2)
+        .where(JobV2.id == job_id)
+        .where(JobV2.project_id == project_id)
+    )
+    job = res.scalars().one_or_none()
+
+    if job is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Job not found"
         )
-    if job.project_id != project_id:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=f"Invalid {project_id=} for {job_id=}",
-        )
+
     return dict(job=job, project=project)
 
 
@@ -411,8 +418,11 @@ async def _workflow_insert_task(
     flag_modified(db_workflow, "task_list")
     await db.commit()
 
-    # See issue 1087 for 'populate_existing=True'
-    wf_task = await db.get(WorkflowTaskV2, wf_task.id, populate_existing=True)
+    wf_task = await db.get(
+        WorkflowTaskV2,
+        wf_task.id,
+        populate_existing=True,  # See issue 1087
+    )
 
     return wf_task
 
@@ -533,8 +543,7 @@ async def _get_submitted_job_or_none(
         return res.scalars().one_or_none()
     except MultipleResultsFound as e:
         error_msg = (
-            "Multiple running jobs found for "
-            f"{dataset_id=} and {workflow_id=}."
+            f"Multiple running jobs found for {dataset_id=} and {workflow_id=}."
         )
         logger.error(f"{error_msg} Original error: {str(e)}.")
         raise HTTPException(
@@ -546,10 +555,8 @@ async def _get_submitted_job_or_none(
 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)
+        .join(Profile, Resource.id == Profile.resource_id)
+        .join(UserOAuth, Profile.id == UserOAuth.profile_id)
         .where(UserOAuth.id == user_id)
     )
     resource_id = res.scalar_one_or_none()

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

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import Literal
 
@@ -14,14 +15,12 @@ from fractal_server.app.routes.api.v2._aux_functions import _get_dataset_or_404
 from fractal_server.app.routes.api.v2._aux_functions import (
     _get_project_check_owner,
 )
-from fractal_server.app.routes.api.v2._aux_functions import (
-    _get_workflow_or_404,
-)
+from fractal_server.app.routes.api.v2._aux_functions import _get_workflow_or_404
 from fractal_server.app.routes.api.v2._aux_functions import (
     _get_workflowtask_or_404,
 )
 from fractal_server.logger import set_logger
-
+from fractal_server.zip_tools import _read_single_file_from_zip
 
 logger = set_logger(__name__)
 
@@ -66,27 +65,51 @@ async def get_history_run_or_404(
 
 def read_log_file(
     *,
-    logfile: str | None,
-    wftask: WorkflowTaskV2,
+    task_name: str,
     dataset_id: int,
-):
-    if logfile is None or not Path(logfile).exists():
-        logger.debug(
-            f"Logs for task '{wftask.task.name}' in dataset "
-            f"{dataset_id} are not available ({logfile=})."
-        )
-        return (
-            f"Logs for task '{wftask.task.name}' in dataset "
-            f"{dataset_id} are not available."
-        )
+    logfile: str,
+    job_working_dir: str,
+) -> str:
+    """
+    Returns the contents of a Job's log file, either directly from the working
+    directory or from the corresponding ZIP archive.
+
+    The function first checks if `logfile` exists on disk.
 
+    If not, it checks if the Job working directory has been zipped and tries to
+    read `logfile` from within the archive.
+    (Note: it is assumed that `logfile` is relative to `job_working_dir`)
+    """
+    archive_path = os.path.normpath(job_working_dir) + ".zip"
     try:
-        with open(logfile) as f:
-            return f.read()
+        if Path(logfile).exists():
+            with open(logfile) as f:
+                return f.read()
+        elif Path(archive_path).exists():
+            relative_logfile = (
+                Path(logfile).relative_to(job_working_dir).as_posix()
+            )
+            return _read_single_file_from_zip(
+                file_path=relative_logfile, archive_path=archive_path
+            )
+
+        else:
+            logger.error(
+                f"Error while retrieving logs for {logfile=} and "
+                f"{archive_path=}: both files do not exist."
+            )
+            return (
+                f"Logs for task '{task_name}' in dataset "
+                f"{dataset_id} are not available."
+            )
     except Exception as e:
+        logger.error(
+            f"Error while retrieving logs for {logfile=} and {archive_path=}. "
+            f"Original error: {str(e)}"
+        )
         return (
-            f"Error while retrieving logs for task '{wftask.task.name}' "
-            f"in dataset {dataset_id}. Original error: {str(e)}."
+            f"Error while retrieving logs for task '{task_name}' "
+            f"in dataset {dataset_id}."
         )
 
 

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

@@ -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:

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
@@ -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()

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

@@ -5,24 +5,24 @@ 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 DatasetCreateV2
+from fractal_server.app.schemas.v2 import DatasetReadV2
+from fractal_server.app.schemas.v2 import DatasetUpdateV2
+from fractal_server.app.schemas.v2.dataset import DatasetExportV2
+from fractal_server.app.schemas.v2.dataset import DatasetImportV2
 from fractal_server.string_tools import sanitize_string
 from fractal_server.urls import normalize_url
 
+from ._aux_functions import _get_dataset_check_owner
+from ._aux_functions import _get_project_check_owner
+from ._aux_functions import _get_submitted_jobs_statement
+
 router = APIRouter()
 
 
@@ -208,25 +208,6 @@ 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,