fractal-server 2.9.0a2__tar.gz → 2.9.0a4__tar.gz

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.9.0a2
+Version: 2.9.0a4
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause

fractal_server-2.9.0a4/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.9.0a4"

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/routes/admin/v2/__init__.py

@@ -7,6 +7,7 @@ from .job import router as job_router
 from .project import router as project_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
 
 router_admin_v2 = APIRouter()
 
@@ -14,3 +15,6 @@ router_admin_v2.include_router(job_router, prefix="/job")
 router_admin_v2.include_router(project_router, prefix="/project")
 router_admin_v2.include_router(task_router, prefix="/task")
 router_admin_v2.include_router(task_group_router, prefix="/task-group")
+router_admin_v2.include_router(
+    task_group_lifecycle_router, prefix="/task-group"
+)

fractal_server-2.9.0a4/fractal_server/app/routes/admin/v2/task_group_lifecycle.py

@@ -0,0 +1,260 @@
+from fastapi import APIRouter
+from fastapi import BackgroundTasks
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Request
+from fastapi import Response
+from fastapi import status
+
+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 TaskGroupActivityV2
+from fractal_server.app.routes.api.v2._aux_functions_task_lifecycle import (
+    check_no_ongoing_activity,
+)
+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.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 TaskGroupV2OriginEnum
+from fractal_server.config import get_settings
+from fractal_server.logger import set_logger
+from fractal_server.syringe import Inject
+from fractal_server.tasks.v2.local import deactivate_local
+from fractal_server.tasks.v2.local import reactivate_local
+from fractal_server.tasks.v2.ssh import deactivate_ssh
+from fractal_server.tasks.v2.ssh import reactivate_ssh
+from fractal_server.utils import get_timestamp
+
+router = APIRouter()
+
+logger = set_logger(__name__)
+
+
+@router.post(
+    "/{task_group_id}/deactivate/",
+    response_model=TaskGroupActivityV2Read,
+)
+async def deactivate_task_group(
+    task_group_id: int,
+    background_tasks: BackgroundTasks,
+    response: Response,
+    request: Request,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+    task_group = await _get_task_group_or_404(
+        task_group_id=task_group_id, db=db
+    )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Check that task-group is active
+    if not task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot deactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = False
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.DEACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to False and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.DEACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    task_group.active = False
+    db.add(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_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            deactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+        )
+    else:
+        background_tasks.add_task(
+            deactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+
+    logger.debug(
+        "Admin task group deactivation endpoint: start deactivate "
+        "and return task_group_activity"
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity
+
+
+@router.post(
+    "/{task_group_id}/reactivate/",
+    response_model=TaskGroupActivityV2Read,
+)
+async def reactivate_task_group(
+    task_group_id: int,
+    background_tasks: BackgroundTasks,
+    response: Response,
+    request: Request,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+
+    task_group = await _get_task_group_or_404(
+        task_group_id=task_group_id, db=db
+    )
+
+    # Check that task-group is not active
+    if task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot reactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = True
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.REACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to True and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    if task_group.pip_freeze is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "Cannot reactivate a task group with "
+                f"{task_group.pip_freeze=}."
+            ),
+        )
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.REACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    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_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            reactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+        )
+    else:
+        background_tasks.add_task(
+            reactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+    logger.debug(
+        "Admin task group reactivation endpoint: start reactivate "
+        "and return task_group_activity"
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/routes/api/v2/task_collection.py

@@ -37,6 +37,7 @@ from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.tasks.v2.local.collect import (
     collect_local,
 )
+from fractal_server.tasks.v2.ssh import collect_ssh
 from fractal_server.tasks.v2.utils_package_names import _parse_wheel_filename
 from fractal_server.tasks.v2.utils_package_names import normalize_package_name
 from fractal_server.tasks.v2.utils_python_interpreter import (
@@ -63,10 +64,7 @@ async def collect_tasks_pip(
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupActivityV2Read:
     """
-    Task collection endpoint
-
-    Trigger the creation of a dedicated virtual environment, the installation
-    of a package and the collection of tasks as advertised in the manifest.
+    Task-collection endpoint
     """
 
     # Get settings
@@ -246,12 +244,7 @@ async def collect_tasks_pip(
 
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
         # SSH task collection
-
-        from fractal_server.tasks.v2.ssh.collect import (
-            collect_ssh,
-        )
-
-        # User appropriate FractalSSH object
+        # Use appropriate FractalSSH object
         ssh_credentials = dict(
             user=user_settings.ssh_username,
             host=user_settings.ssh_host,

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/routes/api/v2/task_group_lifecycle.py

@@ -2,9 +2,11 @@ from fastapi import APIRouter
 from fastapi import BackgroundTasks
 from fastapi import Depends
 from fastapi import HTTPException
+from fastapi import Request
 from fastapi import Response
 from fastapi import status
 
+from ...aux.validate_user_settings import validate_user_settings
 from ._aux_functions_task_lifecycle import check_no_ongoing_activity
 from ._aux_functions_tasks import _get_task_group_full_access
 from fractal_server.app.db import AsyncSession
@@ -22,6 +24,8 @@ from fractal_server.logger import set_logger
 from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.local import deactivate_local
 from fractal_server.tasks.v2.local import reactivate_local
+from fractal_server.tasks.v2.ssh import deactivate_ssh
+from fractal_server.tasks.v2.ssh import reactivate_ssh
 from fractal_server.utils import get_timestamp
 
 router = APIRouter()
@@ -38,6 +42,7 @@ async def deactivate_task_group(
     task_group_id: int,
     background_tasks: BackgroundTasks,
     response: Response,
+    request: Request,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupReadV2:
@@ -103,10 +108,29 @@ async def deactivate_task_group(
     # Submit background task
     settings = Inject(get_settings)
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail="Not implemented (yet) for SSH.",
+
+        # Validate user settings (backend-specific)
+        user_settings = await validate_user_settings(
+            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+        )
+
+        # User appropriate FractalSSH object
+        ssh_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            deactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
         )
+
     else:
         background_tasks.add_task(
             deactivate_local,
@@ -130,6 +154,7 @@ async def reactivate_task_group(
     task_group_id: int,
     background_tasks: BackgroundTasks,
     response: Response,
+    request: Request,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupReadV2:
@@ -203,10 +228,29 @@ async def reactivate_task_group(
     # Submit background task
     settings = Inject(get_settings)
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail="Not implemented (yet) for SSH.",
+
+        # Validate user settings (backend-specific)
+        user_settings = await validate_user_settings(
+            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+        )
+
+        # Use appropriate FractalSSH object
+        ssh_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            reactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
         )
+
     else:
         background_tasks.add_task(
             reactivate_local,

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/_validators.py

@@ -1,6 +1,4 @@
 import os
-from datetime import datetime
-from datetime import timezone
 from typing import Any
 from typing import Optional
 
@@ -103,15 +101,3 @@ def val_unique_list(attribute: str):
         return must_be_unique
 
     return val
-
-
-def valutc(attribute: str):
-    def val(timestamp: Optional[datetime]) -> Optional[datetime]:
-        """
-        Replace `tzinfo` with `timezone.utc`.
-        """
-        if timestamp is not None:
-            return timestamp.replace(tzinfo=timezone.utc)
-        return None
-
-    return val

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v1/applyworkflow.py

@@ -7,7 +7,6 @@ from pydantic import validator
 from pydantic.types import StrictStr
 
 from .._validators import valstr
-from .._validators import valutc
 from .dumps import DatasetDumpV1
 from .dumps import ProjectDumpV1
 from .dumps import WorkflowDumpV1
@@ -150,13 +149,6 @@ class ApplyWorkflowReadV1(_ApplyWorkflowBaseV1):
     first_task_index: Optional[int]
     last_task_index: Optional[int]
 
-    _start_timestamp = validator("start_timestamp", allow_reuse=True)(
-        valutc("start_timestamp")
-    )
-    _end_timestamp = validator("end_timestamp", allow_reuse=True)(
-        valutc("end_timestamp")
-    )
-
 
 class ApplyWorkflowUpdateV1(BaseModel):
     """

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v1/dataset.py

@@ -8,7 +8,6 @@ from pydantic import validator
 
 from .._validators import val_absolute_path
 from .._validators import valstr
-from .._validators import valutc
 from .dumps import WorkflowTaskDumpV1
 from .project import ProjectReadV1
 from .workflow import WorkflowTaskStatusTypeV1
@@ -151,10 +150,6 @@ class DatasetReadV1(_DatasetBaseV1):
     project: ProjectReadV1
     timestamp_created: datetime
 
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
-
 
 class DatasetStatusReadV1(BaseModel):
     """

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v1/project.py

@@ -5,7 +5,6 @@ from pydantic import BaseModel
 from pydantic import validator
 
 from .._validators import valstr
-from .._validators import valutc
 
 
 __all__ = (
@@ -50,10 +49,6 @@ class ProjectReadV1(_ProjectBaseV1):
     id: int
     timestamp_created: datetime
 
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
-
 
 class ProjectUpdateV1(_ProjectBaseV1):
     """

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v1/state.py

@@ -3,9 +3,6 @@ from typing import Any
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import validator
-
-from fractal_server.app.schemas._validators import valutc
 
 
 class StateRead(BaseModel):
@@ -19,5 +16,3 @@ class StateRead(BaseModel):
     id: Optional[int]
     data: dict[str, Any]
     timestamp: datetime
-
-    _timestamp = validator("timestamp", allow_reuse=True)(valutc("timestamp"))

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v1/workflow.py

@@ -8,7 +8,6 @@ from pydantic import validator
 
 from .._validators import valint
 from .._validators import valstr
-from .._validators import valutc
 from .project import ProjectReadV1
 from .task import TaskExportV1
 from .task import TaskImportV1
@@ -135,10 +134,6 @@ class WorkflowReadV1(_WorkflowBaseV1):
     project: ProjectReadV1
     timestamp_created: datetime
 
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
-
 
 class WorkflowCreateV1(_WorkflowBaseV1):
     """

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v2/dataset.py

@@ -7,7 +7,6 @@ from pydantic import Field
 from pydantic import validator
 
 from .._validators import valstr
-from .._validators import valutc
 from .dumps import WorkflowTaskDumpV2
 from .project import ProjectReadV2
 from .workflowtask import WorkflowTaskStatusTypeV2
@@ -62,11 +61,6 @@ class DatasetReadV2(BaseModel):
     zarr_dir: str
     filters: Filters = Field(default_factory=Filters)
 
-    # Validators
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
-
 
 class DatasetUpdateV2(BaseModel, extra=Extra.forbid):
 

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v2/job.py

@@ -8,7 +8,6 @@ from pydantic import validator
 from pydantic.types import StrictStr
 
 from .._validators import valstr
-from .._validators import valutc
 from .dumps import DatasetDumpV2
 from .dumps import ProjectDumpV2
 from .dumps import WorkflowDumpV2
@@ -101,13 +100,6 @@ class JobReadV2(BaseModel):
     last_task_index: Optional[int]
     worker_init: Optional[str]
 
-    _start_timestamp = validator("start_timestamp", allow_reuse=True)(
-        valutc("start_timestamp")
-    )
-    _end_timestamp = validator("end_timestamp", allow_reuse=True)(
-        valutc("end_timestamp")
-    )
-
 
 class JobUpdateV2(BaseModel, extra=Extra.forbid):
 

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v2/project.py

@@ -6,7 +6,6 @@ from pydantic import Extra
 from pydantic import validator
 
 from .._validators import valstr
-from .._validators import valutc
 
 
 class ProjectCreateV2(BaseModel, extra=Extra.forbid):
@@ -21,10 +20,6 @@ class ProjectReadV2(BaseModel):
     id: int
     name: str
     timestamp_created: datetime
-    # Validators
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
 
 
 class ProjectUpdateV2(BaseModel, extra=Extra.forbid):

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/app/schemas/v2/workflow.py

@@ -6,7 +6,6 @@ from pydantic import Extra
 from pydantic import validator
 
 from .._validators import valstr
-from .._validators import valutc
 from .project import ProjectReadV2
 from .workflowtask import WorkflowTaskExportV2
 from .workflowtask import WorkflowTaskImportV2
@@ -31,10 +30,6 @@ class WorkflowReadV2(BaseModel):
     project: ProjectReadV2
     timestamp_created: datetime
 
-    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
-        valutc("timestamp_created")
-    )
-
 
 class WorkflowReadV2WithWarnings(WorkflowReadV2):
     task_list: list[WorkflowTaskReadV2WithWarning]

{fractal_server-2.9.0a2 → fractal_server-2.9.0a4}/fractal_server/ssh/_fabric.py

@@ -321,8 +321,10 @@ class FractalSSH(object):
                     f"{prefix} END   running '{cmd}' over SSH, "
                     f"elapsed {t_1-t_0:.3f}"
                 )
-                self.logger.debug(f"STDOUT: {res.stdout}")
-                self.logger.debug(f"STDERR: {res.stderr}")
+                self.logger.debug("STDOUT:")
+                self.logger.debug(res.stdout)
+                self.logger.debug("STDERR:")
+                self.logger.debug(res.stderr)
                 return res.stdout
             except NoValidConnectionsError as e:
                 # Case 2: Command fails with a connection error

fractal_server-2.9.0a2/fractal_server/tasks/v2/local/utils_local.py → fractal_server-2.9.0a4/fractal_server/tasks/v2/local/_utils.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 
+from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.logger import get_logger
 from fractal_server.tasks.v2.utils_templates import customize_template
 from fractal_server.utils import execute_command_sync
@@ -43,3 +44,27 @@ def _customize_and_run_template(
     stdout = execute_command_sync(command=cmd, logger_name=logger_name)
     logger.debug(f"_customize_and_run_template {template_filename} - END")
     return stdout
+
+
+def check_task_files_exist(task_list: list[TaskCreateV2]) -> None:
+    """
+    Check that the modules listed in task commands point to existing files.
+
+    Args:
+        task_list:
+    """
+    for _task in task_list:
+        if _task.command_non_parallel is not None:
+            _task_path = _task.command_non_parallel.split()[1]
+            if not Path(_task_path).exists():
+                raise FileNotFoundError(
+                    f"Task `{_task.name}` has `command_non_parallel` "
+                    f"pointing to missing file `{_task_path}`."
+                )
+        if _task.command_parallel is not None:
+            _task_path = _task.command_parallel.split()[1]
+            if not Path(_task_path).exists():
+                raise FileNotFoundError(
+                    f"Task `{_task.name}` has `command_parallel` "
+                    f"pointing to missing file `{_task_path}`."
+                )