fractal-server 2.9.0a3__py3-none-any.whl → 2.9.0a5__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.9.0a3"
+__VERSION__ = "2.9.0a5"

fractal_server/app/models/v2/task_group.py

@@ -49,8 +49,8 @@ class TaskGroupV2(SQLModel, table=True):
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
     timestamp_last_used: Optional[datetime] = Field(
-        default=None,
-        sa_column=Column(DateTime(timezone=True), nullable=True),
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
     )
 
     @property

fractal_server/app/routes/admin/v1.py

@@ -33,7 +33,7 @@ from ..aux._job import _write_shutdown_file
 from ..aux._runner import _check_shutdown_is_supported
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_superuser
-from fractal_server.app.routes.aux._timestamp import _convert_to_db_timestamp
+from fractal_server.app.routes.aux import _raise_if_naive_datetime
 
 router_admin_v1 = APIRouter()
 
@@ -54,6 +54,7 @@ async def view_project(
         id: If not `None`, select a given `project.id`.
         user_id: If not `None`, select a given `project.user_id`.
     """
+    _raise_if_naive_datetime(timestamp_created_min, timestamp_created_max)
 
     stm = select(Project)
 
@@ -63,10 +64,8 @@ async def view_project(
     if user_id is not None:
         stm = stm.where(Project.user_list.any(UserOAuth.id == user_id))
     if timestamp_created_min is not None:
-        timestamp_created_min = _convert_to_db_timestamp(timestamp_created_min)
         stm = stm.where(Project.timestamp_created >= timestamp_created_min)
     if timestamp_created_max is not None:
-        timestamp_created_max = _convert_to_db_timestamp(timestamp_created_max)
         stm = stm.where(Project.timestamp_created <= timestamp_created_max)
 
     res = await db.execute(stm)
@@ -96,6 +95,8 @@ async def view_workflow(
         name_contains: If not `None`, select workflows such that their
             `name` attribute contains `name_contains` (case-insensitive).
     """
+    _raise_if_naive_datetime(timestamp_created_min, timestamp_created_max)
+
     stm = select(Workflow)
 
     if user_id is not None:
@@ -112,10 +113,8 @@ async def view_workflow(
             func.lower(Workflow.name).contains(name_contains.lower())
         )
     if timestamp_created_min is not None:
-        timestamp_created_min = _convert_to_db_timestamp(timestamp_created_min)
         stm = stm.where(Workflow.timestamp_created >= timestamp_created_min)
     if timestamp_created_max is not None:
-        timestamp_created_max = _convert_to_db_timestamp(timestamp_created_max)
         stm = stm.where(Workflow.timestamp_created <= timestamp_created_max)
 
     res = await db.execute(stm)
@@ -147,6 +146,8 @@ async def view_dataset(
             `name` attribute contains `name_contains` (case-insensitive).
         type: If not `None`, select a given `dataset.type`.
     """
+    _raise_if_naive_datetime(timestamp_created_min, timestamp_created_max)
+
     stm = select(Dataset)
 
     if user_id is not None:
@@ -165,10 +166,8 @@ async def view_dataset(
     if type is not None:
         stm = stm.where(Dataset.type == type)
     if timestamp_created_min is not None:
-        timestamp_created_min = _convert_to_db_timestamp(timestamp_created_min)
         stm = stm.where(Dataset.timestamp_created >= timestamp_created_min)
     if timestamp_created_max is not None:
-        timestamp_created_max = _convert_to_db_timestamp(timestamp_created_max)
         stm = stm.where(Dataset.timestamp_created <= timestamp_created_max)
 
     res = await db.execute(stm)
@@ -218,6 +217,13 @@ async def view_job(
         log: If `True`, include `job.log`, if `False`
             `job.log` is set to `None`.
     """
+    _raise_if_naive_datetime(
+        start_timestamp_min,
+        start_timestamp_max,
+        end_timestamp_min,
+        end_timestamp_max,
+    )
+
     stm = select(ApplyWorkflow)
 
     if id is not None:
@@ -237,16 +243,12 @@ async def view_job(
     if status is not None:
         stm = stm.where(ApplyWorkflow.status == status)
     if start_timestamp_min is not None:
-        start_timestamp_min = _convert_to_db_timestamp(start_timestamp_min)
         stm = stm.where(ApplyWorkflow.start_timestamp >= start_timestamp_min)
     if start_timestamp_max is not None:
-        start_timestamp_max = _convert_to_db_timestamp(start_timestamp_max)
         stm = stm.where(ApplyWorkflow.start_timestamp <= start_timestamp_max)
     if end_timestamp_min is not None:
-        end_timestamp_min = _convert_to_db_timestamp(end_timestamp_min)
         stm = stm.where(ApplyWorkflow.end_timestamp >= end_timestamp_min)
     if end_timestamp_max is not None:
-        end_timestamp_max = _convert_to_db_timestamp(end_timestamp_max)
         stm = stm.where(ApplyWorkflow.end_timestamp <= end_timestamp_max)
 
     res = await db.execute(stm)

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/app/routes/admin/v2/job.py

@@ -16,9 +16,9 @@ from fractal_server.app.models import UserOAuth
 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.aux import _raise_if_naive_datetime
 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.aux._timestamp import _convert_to_db_timestamp
 from fractal_server.app.runner.filenames import WORKFLOW_LOG_FILENAME
 from fractal_server.app.schemas.v2 import JobReadV2
 from fractal_server.app.schemas.v2 import JobStatusTypeV2
@@ -66,6 +66,14 @@ async def view_job(
         log: If `True`, include `job.log`, if `False`
             `job.log` is set to `None`.
     """
+
+    _raise_if_naive_datetime(
+        start_timestamp_min,
+        start_timestamp_max,
+        end_timestamp_min,
+        end_timestamp_max,
+    )
+
     stm = select(JobV2)
 
     if id is not None:
@@ -83,16 +91,16 @@ async def view_job(
     if status is not None:
         stm = stm.where(JobV2.status == status)
     if start_timestamp_min is not None:
-        start_timestamp_min = _convert_to_db_timestamp(start_timestamp_min)
+        start_timestamp_min = start_timestamp_min
         stm = stm.where(JobV2.start_timestamp >= start_timestamp_min)
     if start_timestamp_max is not None:
-        start_timestamp_max = _convert_to_db_timestamp(start_timestamp_max)
+        start_timestamp_max = start_timestamp_max
         stm = stm.where(JobV2.start_timestamp <= start_timestamp_max)
     if end_timestamp_min is not None:
-        end_timestamp_min = _convert_to_db_timestamp(end_timestamp_min)
+        end_timestamp_min = end_timestamp_min
         stm = stm.where(JobV2.end_timestamp >= end_timestamp_min)
     if end_timestamp_max is not None:
-        end_timestamp_max = _convert_to_db_timestamp(end_timestamp_max)
+        end_timestamp_max = end_timestamp_max
         stm = stm.where(JobV2.end_timestamp <= end_timestamp_max)
 
     res = await db.execute(stm)

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

@@ -20,6 +20,7 @@ from fractal_server.app.routes.auth import current_active_superuser
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
+from fractal_server.app.routes.aux import _raise_if_naive_datetime
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
@@ -46,6 +47,8 @@ async def get_task_group_activity_list(
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupActivityV2Read]:
 
+    _raise_if_naive_datetime(timestamp_started_min)
+
     stm = select(TaskGroupActivityV2)
     if task_group_activity_id is not None:
         stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
@@ -93,16 +96,26 @@ async def query_task_group_list(
     active: Optional[bool] = None,
     pkg_name: Optional[str] = None,
     origin: Optional[TaskGroupV2OriginEnum] = None,
+    timestamp_last_used_min: Optional[datetime] = None,
+    timestamp_last_used_max: Optional[datetime] = None,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupReadV2]:
 
     stm = select(TaskGroupV2)
 
+    _raise_if_naive_datetime(
+        timestamp_last_used_max,
+        timestamp_last_used_min,
+    )
+
     if user_group_id is not None and private is True:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Cannot set `user_group_id` with {private=}",
+            detail=(
+                "Cannot get task groups with both "
+                f"{user_group_id=} and {private=}."
+            ),
         )
     if user_id is not None:
         stm = stm.where(TaskGroupV2.user_id == user_id)
@@ -122,6 +135,14 @@ async def query_task_group_list(
         stm = stm.where(TaskGroupV2.origin == origin)
     if pkg_name is not None:
         stm = stm.where(TaskGroupV2.pkg_name.icontains(pkg_name))
+    if timestamp_last_used_min is not None:
+        stm = stm.where(
+            TaskGroupV2.timestamp_last_used >= timestamp_last_used_min
+        )
+    if timestamp_last_used_max is not None:
+        stm = stm.where(
+            TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
+        )
 
     res = await db.execute(stm)
     task_groups_list = res.scalars().all()

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

@@ -0,0 +1,269 @@
+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_task_lifecycle import (
+    check_no_submitted_job,
+)
+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 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=}."
+            ),
+        )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(task_group_id=task_group.id, db=db)
+
+    # 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)
+
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(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/app/routes/api/v2/_aux_functions_task_lifecycle.py

@@ -4,10 +4,16 @@ from fastapi import HTTPException
 from fastapi import status
 from httpx import AsyncClient
 from httpx import TimeoutException
+from sqlmodel import func
 from sqlmodel import select
 
 from fractal_server.app.db import AsyncSession
+from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.models.v2 import TaskGroupActivityV2
+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.logger import set_logger
 
@@ -165,3 +171,37 @@ async def check_no_ongoing_activity(
         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         detail=msg,
     )
+
+
+async def check_no_submitted_job(
+    *,
+    task_group_id: int,
+    db: AsyncSession,
+) -> None:
+    """
+    Find submitted jobs which include tasks from a given task group.
+
+    Arguments:
+        task_id_list: List of TaskV2 IDs
+        db: Database session
+    """
+    stm = (
+        select(func.count(JobV2.id))
+        .join(WorkflowV2, JobV2.workflow_id == WorkflowV2.id)
+        .join(WorkflowTaskV2, WorkflowTaskV2.workflow_id == WorkflowV2.id)
+        .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(TaskV2.taskgroupv2_id == task_group_id)
+    )
+    res = await db.execute(stm)
+    num_submitted_jobs = res.scalar()
+    if num_submitted_jobs > 0:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot act on task group because {num_submitted_jobs} "
+                "submitted jobs use its tasks."
+            ),
+        )

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

@@ -15,7 +15,6 @@ from sqlmodel import select
 from .....config import get_settings
 from .....logger import set_logger
 from .....syringe import Inject
-from .....utils import get_timestamp
 from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import JobV2
@@ -62,8 +61,6 @@ async def apply_workflow(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[JobReadV2]:
 
-    now = get_timestamp()
-
     # Remove non-submitted V2 jobs from the app state when the list grows
     # beyond a threshold
     settings = Inject(get_settings)
@@ -194,12 +191,12 @@ async def apply_workflow(
     )
     used_task_groups = res.scalars().all()
     for used_task_group in used_task_groups:
-        used_task_group.timestamp_last_used = now
+        used_task_group.timestamp_last_used = job.start_timestamp
         db.add(used_task_group)
     await db.commit()
 
     # Define server-side job directory
-    timestamp_string = now.strftime("%Y%m%d_%H%M%S")
+    timestamp_string = job.start_timestamp.strftime("%Y%m%d_%H%M%S")
     WORKFLOW_DIR_LOCAL = settings.FRACTAL_RUNNER_WORKING_BASE_DIR / (
         f"proj_v2_{project_id:07d}_wf_{workflow_id:07d}_job_{job.id:07d}"
         f"_{timestamp_string}"

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

@@ -21,7 +21,7 @@ from ....models.v2 import TaskGroupV2
 from ....schemas.v2 import TaskCollectPipV2
 from ....schemas.v2 import TaskGroupActivityStatusV2
 from ....schemas.v2 import TaskGroupActivityV2Read
-from ....schemas.v2 import TaskGroupCreateV2
+from ....schemas.v2 import TaskGroupCreateV2Strict
 from ...aux.validate_user_settings import validate_user_settings
 from ._aux_functions_task_lifecycle import get_package_version_from_pypi
 from ._aux_functions_tasks import _get_valid_user_group_id
@@ -164,7 +164,7 @@ async def collect_tasks_pip(
 
     # Validate TaskGroupV2 attributes
     try:
-        TaskGroupCreateV2(**task_group_attrs)
+        TaskGroupCreateV2Strict(**task_group_attrs)
     except ValidationError as e:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,

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

@@ -23,6 +23,7 @@ from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
+from fractal_server.app.routes.aux import _raise_if_naive_datetime
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
@@ -47,6 +48,8 @@ async def get_task_group_activity_list(
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupActivityV2Read]:
 
+    _raise_if_naive_datetime(timestamp_started_min)
+
     stm = select(TaskGroupActivityV2).where(
         TaskGroupActivityV2.user_id == user.id
     )

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

@@ -8,6 +8,7 @@ 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_task_lifecycle import check_no_submitted_job
 from ._aux_functions_tasks import _get_task_group_full_access
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
@@ -59,6 +60,9 @@ async def deactivate_task_group(
     # Check no other activity is ongoing
     await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
 
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(task_group_id=task_group.id, db=db)
+
     # Check that task-group is active
     if not task_group.active:
         raise HTTPException(
@@ -181,6 +185,9 @@ async def reactivate_task_group(
     # Check no other activity is ongoing
     await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
 
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(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

fractal_server/app/routes/aux/__init__.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+from typing import Optional
+
+from fastapi import HTTPException
+from fastapi import status
+
+
+def _raise_if_naive_datetime(*timestamps: tuple[Optional[datetime]]) -> None:
+    """
+    Raise 422 if any not-null argument is a naive `datetime` object:
+    https://docs.python.org/3/library/datetime.html#determining-if-an-object-is-aware-or-naive
+    """
+    for timestamp in filter(None, timestamps):
+        if (timestamp.tzinfo is None) or (
+            timestamp.tzinfo.utcoffset(timestamp) is None
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"{timestamp=} is naive. You must provide a timezone.",
+            )

fractal_server/app/runner/executors/slurm/ssh/executor.py

@@ -26,7 +26,6 @@ from typing import Sequence
 
 import cloudpickle
 from cfut import SlurmExecutor
-from paramiko.ssh_exception import NoValidConnectionsError
 
 from ....filenames import SHUTDOWN_FILENAME
 from ....task_files import get_task_file_paths
@@ -409,15 +408,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             args=fun_args,
             kwargs=fun_kwargs,
         )
-        try:
-            self._put_subfolder_sftp(jobs=[job])
-        except NoValidConnectionsError as e:
-            logger.error("NoValidConnectionError")
-            logger.error(f"{str(e)=}")
-            logger.error(f"{e.errors=}")
-            for err in e.errors:
-                logger.error(f"{str(err)}")
-            raise e
+        self._put_subfolder_sftp(jobs=[job])
         future, job_id_str = self._submit_job(job)
         self.wait_thread.wait(job_id=job_id_str)
         return future
@@ -559,16 +550,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             current_component_index += batch_size
         logger.debug("[map] Job preparation - END")
 
-        try:
-            self._put_subfolder_sftp(jobs=jobs_to_submit)
-        except NoValidConnectionsError as e:
-            logger.error("NoValidConnectionError")
-            logger.error(f"{str(e)=}")
-            logger.error(f"{e.errors=}")
-            for err in e.errors:
-                logger.error(f"{str(err)}")
-
-            raise e
+        self._put_subfolder_sftp(jobs=jobs_to_submit)
 
         # Construct list of futures (one per SLURM job, i.e. one per batch)
         # FIXME SSH: we may create a single `_submit_many_jobs` method to
@@ -1073,16 +1055,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                     self.jobs_empty_cond.notify_all()
 
             # Fetch subfolder from remote host
-            try:
-                self._get_subfolder_sftp(jobs=jobs)
-            except NoValidConnectionsError as e:
-                logger.error("NoValidConnectionError")
-                logger.error(f"{str(e)=}")
-                logger.error(f"{e.errors=}")
-                for err in e.errors:
-                    logger.error(f"{str(err)}")
-
-                raise e
+            self._get_subfolder_sftp(jobs=jobs)
 
             # First round of checking whether all output files exist
             missing_out_paths = []

fractal_server/app/schemas/v2/__init__.py

@@ -29,6 +29,7 @@ from .task_group import TaskGroupActivityActionV2  # noqa F401
 from .task_group import TaskGroupActivityStatusV2  # noqa F401
 from .task_group import TaskGroupActivityV2Read  # noqa F401
 from .task_group import TaskGroupCreateV2  # noqa F401
+from .task_group import TaskGroupCreateV2Strict  # noqa F401
 from .task_group import TaskGroupReadV2  # noqa F401
 from .task_group import TaskGroupUpdateV2  # noqa F401
 from .task_group import TaskGroupV2OriginEnum  # noqa F401

fractal_server/app/schemas/v2/task_group.py

@@ -5,6 +5,7 @@ from typing import Optional
 from pydantic import BaseModel
 from pydantic import Extra
 from pydantic import Field
+from pydantic import root_validator
 from pydantic import validator
 
 from .._validators import val_absolute_path
@@ -66,6 +67,32 @@ class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
     )
 
 
+class TaskGroupCreateV2Strict(TaskGroupCreateV2):
+    """
+    A strict version of TaskGroupCreateV2, to be used for task collection.
+    """
+
+    path: str
+    venv_path: str
+    version: str
+    python_version: str
+
+    @root_validator
+    def check_wheel_file(cls, values):
+        origin = values.get("origin")
+        wheel_path = values.get("wheel_path")
+        bad_condition_1 = (
+            origin == TaskGroupV2OriginEnum.WHEELFILE and wheel_path is None
+        )
+        bad_condition_2 = (
+            origin != TaskGroupV2OriginEnum.WHEELFILE
+            and wheel_path is not None
+        )
+        if bad_condition_1 or bad_condition_2:
+            raise ValueError(f"Cannot have {origin=} and {wheel_path=}.")
+        return values
+
+
 class TaskGroupReadV2(BaseModel):
     id: int
     task_list: list[TaskReadV2]
@@ -89,7 +116,7 @@ class TaskGroupReadV2(BaseModel):
 
     active: bool
     timestamp_created: datetime
-    timestamp_last_used: Optional[datetime] = None
+    timestamp_last_used: datetime
 
 
 class TaskGroupUpdateV2(BaseModel, extra=Extra.forbid):

fractal_server/migrations/versions/3082479ac4ea_taskgroup_activity_and_venv_info_to_.py

@@ -71,7 +71,7 @@ def upgrade() -> None:
             sa.Column(
                 "timestamp_last_used",
                 sa.DateTime(timezone=True),
-                nullable=True,
+                nullable=False,
             )
         )
 

fractal_server/ssh/_fabric.py

@@ -11,7 +11,6 @@ from typing import Optional
 
 import paramiko.sftp_client
 from fabric import Connection
-from fabric import Result
 from invoke import UnexpectedExit
 from paramiko.ssh_exception import NoValidConnectionsError
 
@@ -116,50 +115,34 @@ class FractalSSH(object):
     def logger(self) -> logging.Logger:
         return get_logger(self.logger_name)
 
-    def _put(
-        self,
-        *,
-        local: str,
-        remote: str,
-        label: str,
-        lock_timeout: Optional[float] = None,
-    ) -> Result:
-        """
-        Transfer a local file to a remote path, via SFTP.
+    def log_and_raise(self, *, e: Exception, message: str) -> None:
         """
-        actual_lock_timeout = self.default_lock_timeout
-        if lock_timeout is not None:
-            actual_lock_timeout = lock_timeout
-        with _acquire_lock_with_timeout(
-            lock=self._lock,
-            label=label,
-            timeout=actual_lock_timeout,
-        ):
-            return self._sftp_unsafe().put(local, remote)
+        Log and re-raise an exception from a FractalSSH method.
 
-    def _get(
-        self,
-        *,
-        local: str,
-        remote: str,
-        label: str,
-        lock_timeout: Optional[float] = None,
-    ) -> Result:
-        actual_lock_timeout = self.default_lock_timeout
-        if lock_timeout is not None:
-            actual_lock_timeout = lock_timeout
-        with _acquire_lock_with_timeout(
-            lock=self._lock,
-            label=label,
-            timeout=actual_lock_timeout,
-        ):
-            return self._sftp_unsafe().get(
-                remote,
-                local,
-                prefetch=self.sftp_get_prefetch,
-                max_concurrent_prefetch_requests=self.sftp_get_max_requests,
+        Arguments:
+            message: Additional message to be logged.
+            e: Original exception
+        """
+        try:
+            self.logger.error(message)
+            self.logger.error(f"Original Error {type(e)} : \n{str(e)}")
+            # Handle the specific case of `NoValidConnectionsError`s from
+            # paramiko, which store relevant information in the `errors`
+            # attribute
+            if hasattr(e, "errors"):
+                self.logger.error(f"{type(e)=}")
+                for err in e.errors:
+                    self.logger.error(f"{err}")
+        except Exception as exception:
+            # Handle unexpected cases, e.g. (1) `e` has no `type`, or
+            # (2) `errors` is not iterable.
+            self.logger.error(
+                "Unexpected Error while handling exception above: "
+                f"{str(exception)}"
             )
 
+        raise e
+
     def _run(
         self, *args, label: str, lock_timeout: Optional[float] = None, **kwargs
     ) -> Any:
@@ -187,8 +170,17 @@ class FractalSSH(object):
             label="read_remote_json_file",
             timeout=self.default_lock_timeout,
         ):
-            with self._sftp_unsafe().open(filepath, "r") as f:
-                data = json.load(f)
+
+            try:
+                with self._sftp_unsafe().open(filepath, "r") as f:
+                    data = json.load(f)
+            except Exception as e:
+                self.log_and_raise(
+                    e=e,
+                    message=(
+                        f"Error in `read_remote_json_file`, for {filepath=}."
+                    ),
+                )
         self.logger.info(f"END reading remote JSON file {filepath}.")
         return data
 
@@ -380,21 +372,29 @@ class FractalSSH(object):
             logger_name: Name of the logger
         """
         try:
-            prefix = "[send_file]"
-            self.logger.info(f"{prefix} START transfer of '{local}' over SSH.")
-            self._put(
-                local=local,
-                remote=remote,
-                lock_timeout=lock_timeout,
+            self.logger.info(
+                f"[send_file] START transfer of '{local}' over SSH."
+            )
+            actual_lock_timeout = self.default_lock_timeout
+            if lock_timeout is not None:
+                actual_lock_timeout = lock_timeout
+            with _acquire_lock_with_timeout(
+                lock=self._lock,
                 label=f"send_file {local=} {remote=}",
+                timeout=actual_lock_timeout,
+            ):
+                self._sftp_unsafe().put(local, remote)
+            self.logger.info(
+                f"[send_file] END transfer of '{local}' over SSH."
             )
-            self.logger.info(f"{prefix} END transfer of '{local}' over SSH.")
         except Exception as e:
-            self.logger.error(
-                f"Transferring {local=} to {remote=} over SSH failed.\n"
-                f"Original Error:\n{str(e)}."
+            self.log_and_raise(
+                e=e,
+                message=(
+                    "Error in `send_file`, while "
+                    f"transferring {local=} to {remote=}."
+                ),
             )
-            raise e
 
     def fetch_file(
         self,
@@ -415,19 +415,29 @@ class FractalSSH(object):
         try:
             prefix = "[fetch_file] "
             self.logger.info(f"{prefix} START fetching '{remote}' over SSH.")
-            self._get(
-                local=local,
-                remote=remote,
-                lock_timeout=lock_timeout,
+            actual_lock_timeout = self.default_lock_timeout
+            if lock_timeout is not None:
+                actual_lock_timeout = lock_timeout
+            with _acquire_lock_with_timeout(
+                lock=self._lock,
                 label=f"fetch_file {local=} {remote=}",
-            )
+                timeout=actual_lock_timeout,
+            ):
+                self._sftp_unsafe().get(
+                    remote,
+                    local,
+                    prefetch=self.sftp_get_prefetch,
+                    max_concurrent_prefetch_requests=self.sftp_get_max_requests,  # noqa E501
+                )
             self.logger.info(f"{prefix} END fetching '{remote}' over SSH.")
         except Exception as e:
-            self.logger.error(
-                f"Transferring {remote=} to {local=} over SSH failed.\n"
-                f"Original Error:\n{str(e)}."
+            self.log_and_raise(
+                e=e,
+                message=(
+                    "Error in `fetch_file`, while "
+                    f"Transferring {remote=} to {local=}."
+                ),
             )
-            raise e
 
     def mkdir(self, *, folder: str, parents: bool = True) -> None:
         """
@@ -502,8 +512,14 @@ class FractalSSH(object):
             label=f"write_remote_file {path=}",
             timeout=actual_lock_timeout,
         ):
-            with self._sftp_unsafe().open(filename=path, mode="w") as f:
-                f.write(content)
+            try:
+                with self._sftp_unsafe().open(filename=path, mode="w") as f:
+                    f.write(content)
+            except Exception as e:
+                self.log_and_raise(
+                    e=e, message=f"Error in `write_remote_file`, for {path=}."
+                )
+
         self.logger.info(f"END writing to remote file {path}.")
 
     def remote_exists(self, path: str) -> bool:
@@ -523,6 +539,10 @@ class FractalSSH(object):
             except FileNotFoundError:
                 self.logger.info(f"END   remote_file_exists {path} / False")
                 return False
+            except Exception as e:
+                self.log_and_raise(
+                    e=e, message=f"Error in `remote_exists`, for {path=}."
+                )
 
 
 class FractalSSHList(object):

fractal_server/tasks/v2/ssh/collect.py

@@ -138,7 +138,7 @@ def collect_ssh(
                     script_dir_remote=script_dir_remote,
                     prefix=(
                         f"{int(time.time())}_"
-                        f"{TaskGroupActivityActionV2.COLLECT}_"
+                        f"{TaskGroupActivityActionV2.COLLECT}"
                     ),
                     fractal_ssh=fractal_ssh,
                     logger_name=LOGGER_NAME,

{fractal_server-2.9.0a3.dist-info → fractal_server-2.9.0a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.9.0a3
+Version: 2.9.0a5
 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.0a3.dist-info → fractal_server-2.9.0a5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fractal_server/__init__.py,sha256=8LdiYD77VYwRKrVoavHTgYHkexYzgn-F5OpNKKf-WMU,24
+fractal_server/__init__.py,sha256=g0C5KyC4Y2BjlLX8ayJEPjFY-PyIFuDQ0SsIkovQNGo,24
 fractal_server/__main__.py,sha256=dEkCfzLLQrIlxsGC-HBfoR-RBMWnJDgNrxYTyzmE9c0,6146
 fractal_server/alembic.ini,sha256=MWwi7GzjzawI9cCAK1LW7NxIBQDUqD12-ptJoq5JpP0,3153
 fractal_server/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,17 +20,18 @@ fractal_server/app/models/v2/dataset.py,sha256=-7sxHEw4IIAvF_uSan7tA3o8hvoakBkQ0
 fractal_server/app/models/v2/job.py,sha256=ypJmN-qspkKBGhBG7Mt-HypSQqcQ2EmB4Bzzb2-y550,1535
 fractal_server/app/models/v2/project.py,sha256=rAHoh5KfYwIaW7rTX0_O0jvWmxEvfo1BafvmcXuSSRk,786
 fractal_server/app/models/v2/task.py,sha256=jebD28Pz8tGcsWCItxj6uKjcD8BMMnnU8dqYhvhEB6c,1520
-fractal_server/app/models/v2/task_group.py,sha256=Lxtwxk6pfffM8IehqkFvhDuecSXnXqTWeUlf7Y78oss,3254
+fractal_server/app/models/v2/task_group.py,sha256=5ZN3LihhSYiY0Y4zIOzuT9KTpb-QLljjo1ijn_Q4rEw,3272
 fractal_server/app/models/v2/workflow.py,sha256=YBgFGCziUgU0aJ5EM3Svu9W2c46AewZO9VBlFCHiSps,1069
 fractal_server/app/models/v2/workflowtask.py,sha256=iDuJYk8kp4PNqGmbKRtGI7y-QsbjkNd_gDsbMzL4i-g,1274
 fractal_server/app/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/app/routes/admin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fractal_server/app/routes/admin/v1.py,sha256=5YxfWz2QK2spUKomnAteaMsWF9Ql-oHwMs1jhSjHznk,13319
-fractal_server/app/routes/admin/v2/__init__.py,sha256=zkdrk3mSQWfgTJugS8Sc_Q_xCAwfmHUfdRe0DTaYT80,521
-fractal_server/app/routes/admin/v2/job.py,sha256=DbkPmUk7V2iEGIlKa_xgC07cc3G8oNsONGDZ_aKq5zE,7589
+fractal_server/app/routes/admin/v1.py,sha256=ggJZMeKhRijfVe2h2VzfIcpR15FqkKImANhkTXl0mSk,12908
+fractal_server/app/routes/admin/v2/__init__.py,sha256=KYrw0COmmMuIMp7c6YcYRXah4tEYplCWeROnPK1VTeg,681
+fractal_server/app/routes/admin/v2/job.py,sha256=cbkFIRIIXaWmNsUFI7RAu8HpQ0mWn_bgoxtvWZxr-IA,7624
 fractal_server/app/routes/admin/v2/project.py,sha256=luy-yiGX1JYTdPm1hpIdDUUqPm8xHuipLy9k2X6zu74,1223
 fractal_server/app/routes/admin/v2/task.py,sha256=Y0eujBgGhVapNXfW9azDxw4EBzLmEmCdh70y1RNQcb0,3895
-fractal_server/app/routes/admin/v2/task_group.py,sha256=ldMQ8OIUKEhr1a_BXiwgh4K3d1T299ZaDNJjbn_zAxc,7411
+fractal_server/app/routes/admin/v2/task_group.py,sha256=DncrOAB4q-v3BAmxg35m4EohleriW_FLGE5gpW_Or08,8120
+fractal_server/app/routes/admin/v2/task_group_lifecycle.py,sha256=bGD5cbZI7t6t-KQuY9YQ5iIksBT68Qbz2kMkVqrGaqc,9482
 fractal_server/app/routes/api/__init__.py,sha256=2IDheFi0OFdsUg7nbUiyahqybvpgXqeHUXIL2QtWrQQ,641
 fractal_server/app/routes/api/v1/__init__.py,sha256=Y2HQdG197J0a7DyQEE2jn53IfxD0EHGhzK1I2JZuEck,958
 fractal_server/app/routes/api/v1/_aux_functions.py,sha256=P9Q48thGH95w0h5cacYoibxqgiiLW4oqZ8rNJ2LIISY,13219
@@ -43,19 +44,19 @@ fractal_server/app/routes/api/v1/workflow.py,sha256=2T93DuEnSshaDCue-JPmjuvGCtbk
 fractal_server/app/routes/api/v1/workflowtask.py,sha256=OYYConwJbmNULDw5I3T-UbSJKrbbBiAHbbBeVcpoFKQ,5785
 fractal_server/app/routes/api/v2/__init__.py,sha256=w4c9WzagaVV5d4TWBX5buu5ENk8jf3YftMQYmhavz9Q,2172
 fractal_server/app/routes/api/v2/_aux_functions.py,sha256=mb4R_qqFxeW0LAis2QJIIfVx8Sydv1jTYaRIMsMxnIk,11720
-fractal_server/app/routes/api/v2/_aux_functions_task_lifecycle.py,sha256=04-C7R8aWiXN9-rSTnZIqz7CAGcLm0y9bjIgJ2lHGZw,5332
+fractal_server/app/routes/api/v2/_aux_functions_task_lifecycle.py,sha256=fZNglsjv3Smc77olkXV4WzVS9oja5J-ejYdjs5RslAA,6739
 fractal_server/app/routes/api/v2/_aux_functions_tasks.py,sha256=PuapLtvSk9yhBAsKNEp1w2oagOMr0YZTo247-CU3hdM,11008
 fractal_server/app/routes/api/v2/dataset.py,sha256=Y6uZz--YSEGgnPYu05rZ9sr1Ug08bNl2v1h3VeApBe8,9441
 fractal_server/app/routes/api/v2/images.py,sha256=JR1rR6qEs81nacjriOXAOBQjAbCXF4Ew7M7mkWdxBU0,7920
 fractal_server/app/routes/api/v2/job.py,sha256=Bga2Kz1OjvDIdxZObWaaXVhNIhC_5JKhKRjEH2_ayEE,5157
 fractal_server/app/routes/api/v2/project.py,sha256=eWYFJ7F2ZYQcpi-_n-rhPF-Q4gJhzYBsVGYFhHZZXAE,6653
 fractal_server/app/routes/api/v2/status.py,sha256=6N9DSZ4iFqbZImorWfEAPoyoFUgEruo4Hweqo0x0xXU,6435
-fractal_server/app/routes/api/v2/submit.py,sha256=jqYix7X6dUJn8w6RWasu1lOFf7T_CcXQlpVY38njE24,8688
+fractal_server/app/routes/api/v2/submit.py,sha256=72q3HfSKeR-cgNX8CRuqZI6Xd4hFmjlTYDhZvwMZbCo,8656
 fractal_server/app/routes/api/v2/task.py,sha256=K0ik33t7vL8BAK5S7fqyJDNdRK4stGqb_73bSa8tvPE,7159
-fractal_server/app/routes/api/v2/task_collection.py,sha256=_K7c-83jpmaLz1gXM_MbndskkmV6oo_ivg0mWP6hfvs,9621
+fractal_server/app/routes/api/v2/task_collection.py,sha256=TIr1IPO15TX6CZIQ_LPc0zFtTltuleDISAdMVaVQxfw,9633
 fractal_server/app/routes/api/v2/task_collection_custom.py,sha256=cctW61-C2QYF2KXluS15lLhZJS_kt30Ca6UGLFO32z0,6207
-fractal_server/app/routes/api/v2/task_group.py,sha256=Ove7Vr3p8GKtskHANAZh8TWwOw8dfbFCN2UQFv6DhqM,8136
-fractal_server/app/routes/api/v2/task_group_lifecycle.py,sha256=SPUB-QHvADaJm3zyuPIyCg-TqbHujwiwr7RauvYGXJ0,8972
+fractal_server/app/routes/api/v2/task_group.py,sha256=4o2N0z7jK7VUVlJZMM4GveCCc4JKxYJx9-PMmsYIlJQ,8256
+fractal_server/app/routes/api/v2/task_group_lifecycle.py,sha256=3o9bCC8ubMwffQPPaxQZy-CjH9IB2RkIReIecI6L2_w,9300
 fractal_server/app/routes/api/v2/workflow.py,sha256=vjCNRzMHaAB4YWbAEWGlELHXDN4GjtE26IkIiB15RGM,8682
 fractal_server/app/routes/api/v2/workflow_import.py,sha256=WJST1AZypvOTGUrjhomYVh4R2ow8RoGpuwzNiq81Pzc,10971
 fractal_server/app/routes/api/v2/workflowtask.py,sha256=ciHTwXXFiFnMF7ZpJ3Xs0q6YfuZrFvIjqndlzAEdZpo,6969
@@ -68,10 +69,9 @@ fractal_server/app/routes/auth/oauth.py,sha256=AnFHbjqL2AgBX3eksI931xD6RTtmbciHB
 fractal_server/app/routes/auth/register.py,sha256=DlHq79iOvGd_gt2v9uwtsqIKeO6i_GKaW59VIkllPqY,587
 fractal_server/app/routes/auth/router.py,sha256=tzJrygXFZlmV_uWelVqTOJMEH-3Fr7ydwlgx1LxRjxY,527
 fractal_server/app/routes/auth/users.py,sha256=FzKNoB-wD32AkVOj1Vi29lGGyOl8NSMCRL9tEhxqpJk,8403
-fractal_server/app/routes/aux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fractal_server/app/routes/aux/__init__.py,sha256=LR4bR7RunHAK6jc9IR2bReQd-BdXADdnDccXI4uGeGY,731
 fractal_server/app/routes/aux/_job.py,sha256=q-RCiW17yXnZKAC_0La52RLvhqhxuvbgQJ2MlGXOj8A,702
 fractal_server/app/routes/aux/_runner.py,sha256=FdCVla5DxGAZ__aB7Z8dEJzD_RIeh5tftjrPyqkr8N8,895
-fractal_server/app/routes/aux/_timestamp.py,sha256=MZenRoLfVSnYnL2Vkd8AsJJ9_mV8yDB6u7OumUFjFMM,530
 fractal_server/app/routes/aux/validate_user_settings.py,sha256=Y8eubau0julkwVYB5nA83nDtxh_7RU9Iq0zAhb_dXLA,2351
 fractal_server/app/runner/.gitignore,sha256=ytzN_oyHWXrGU7iFAtoHSTUbM6Rn6kG0Zkddg0xZk6s,16
 fractal_server/app/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -87,7 +87,7 @@ fractal_server/app/runner/executors/slurm/remote.py,sha256=wLziIsGdSMiO-jIXM8x77
 fractal_server/app/runner/executors/slurm/ssh/__init__.py,sha256=Cjn1rYvljddi96tAwS-qqGkNfOcfPzjChdaEZEObCcM,65
 fractal_server/app/runner/executors/slurm/ssh/_executor_wait_thread.py,sha256=bKo5Ja0IGxJWpPWyh9dN0AG-PwzTDZzD5LyaEHB3YU4,3742
 fractal_server/app/runner/executors/slurm/ssh/_slurm_job.py,sha256=rwlqZzoGo4SAb4nSlFjsQJdaCgfM1J6YGcjb8yYxlqc,4506
-fractal_server/app/runner/executors/slurm/ssh/executor.py,sha256=si_RHAMnXwQorQ_gWeZ_hQ_cNQbbAuYPjg7nwFQoPVg,58709
+fractal_server/app/runner/executors/slurm/ssh/executor.py,sha256=Z0PL5Ch1Ute1d49_1q2wQbTpw-bVTBagtsR4Ah-gfDo,57746
 fractal_server/app/runner/executors/slurm/sudo/__init__.py,sha256=Cjn1rYvljddi96tAwS-qqGkNfOcfPzjChdaEZEObCcM,65
 fractal_server/app/runner/executors/slurm/sudo/_check_jobs_status.py,sha256=wAgwpVcr6JIslKHOuS0FhRa_6T1KCManyRJqA-fifzw,1909
 fractal_server/app/runner/executors/slurm/sudo/_executor_wait_thread.py,sha256=z5LlhaiqAb8pHsF1WwdzXN39C5anQmwjo1rSQgtRAYE,4422
@@ -148,7 +148,7 @@ fractal_server/app/schemas/v1/state.py,sha256=tBXzp_qW2TNNNPBo-AWEaffEU-1GkMBtUo
 fractal_server/app/schemas/v1/task.py,sha256=7BxOZ_qoRQ8n3YbQpDvB7VMcxB5fSYQmR5RLIWhuJ5U,3704
 fractal_server/app/schemas/v1/task_collection.py,sha256=uvq9bcMaGD_qHsh7YtcpoSAkVAbw12eY4DocIO3MKOg,3057
 fractal_server/app/schemas/v1/workflow.py,sha256=oRKamLSuAgrTcv3gMMxGcotDloLL2c3NNgPA39UEmmM,4467
-fractal_server/app/schemas/v2/__init__.py,sha256=dzDsAzLLMgyQBa3b64n71K1u83tbBn9_Oloaqqv1tjA,2444
+fractal_server/app/schemas/v2/__init__.py,sha256=jAmAxPulME4hFnQJXMTxwoMZsDjZp9jjb-m__OByiXo,2505
 fractal_server/app/schemas/v2/dataset.py,sha256=zRlcO0wDZahTW1PINdVEuARZ7GZUuEqqop7UdE3-5do,2470
 fractal_server/app/schemas/v2/dumps.py,sha256=s6dg-pHZFui6t2Ktm0SMxjKDN-v-ZqBHz9iTsBQF3eU,1712
 fractal_server/app/schemas/v2/job.py,sha256=42V-bFfMvysRplwTKGsL_WshAVsWSM6yjFqypxwrY3k,3020
@@ -157,7 +157,7 @@ fractal_server/app/schemas/v2/project.py,sha256=ABv9LSLVCq1QYthEhBvZOTn_4DFEC-7c
 fractal_server/app/schemas/v2/status.py,sha256=SQaUpQkjFq5c5k5J4rOjNhuQaDOEg8lksPhkKmPU5VU,332
 fractal_server/app/schemas/v2/task.py,sha256=FFAbYwDlqowB8gVMdjFVPVHvAM0T89PYLixUth49xfQ,6870
 fractal_server/app/schemas/v2/task_collection.py,sha256=yHpCRxoj6tKqCiQfUjaTj8SfCn1ChD_P6okfEOzyUDE,6518
-fractal_server/app/schemas/v2/task_group.py,sha256=e4NwFuOmiO0afoZLVsI_XHIpD_o_QWDpzlI7ZoNAYwo,3014
+fractal_server/app/schemas/v2/task_group.py,sha256=fSjdLbClrpmrPj5hFZMu9DoJW4Y33EnbOh0HjMBsGVc,3784
 fractal_server/app/schemas/v2/workflow.py,sha256=-KWvXnbHBFA3pj5n7mfSyLKJQSqkJmoziIEe7mpLl3M,1875
 fractal_server/app/schemas/v2/workflowtask.py,sha256=vDdMktYbHeYBgB5OuWSv6wRPRXWqvetkeqQ7IC5YtfA,5751
 fractal_server/app/security/__init__.py,sha256=8Xd4GxumZgvxEH1Vli3ULehwdesEPiaAbtffJvAEgNo,12509
@@ -178,7 +178,7 @@ fractal_server/migrations/script.py.mako,sha256=oMXw9LC3zRbinWWPPDgeZ4z9FJrV2zhR
 fractal_server/migrations/versions/034a469ec2eb_task_groups.py,sha256=vrPhC8hfFu1c4HmLHNZyCuqEfecFD8-bWc49bXMNes0,6199
 fractal_server/migrations/versions/091b01f51f88_add_usergroup_and_linkusergroup_table.py,sha256=-BSS9AFTPcu3gYC-sYbawSy4MWQQx8TfMb5BW5EBKmQ,1450
 fractal_server/migrations/versions/19eca0dd47a9_user_settings_project_dir.py,sha256=Q1Gj1cJ0UrdLBJ5AXfFK9QpxTtmcv-4Z3NEGDnxOme4,961
-fractal_server/migrations/versions/3082479ac4ea_taskgroup_activity_and_venv_info_to_.py,sha256=_wy9Yu2YfhpBffUsboAG9junlQ2jRR7qui9wbLvXp7w,3653
+fractal_server/migrations/versions/3082479ac4ea_taskgroup_activity_and_venv_info_to_.py,sha256=CPGP6ceJOab_2MzxSlxrH7hGxRoXw4d7BTcASL57pMc,3654
 fractal_server/migrations/versions/4c308bcaea2b_add_task_args_schema_and_task_args_.py,sha256=-wHe-fOffmYeAm0JXVl_lxZ7hhDkaEVqxgxpHkb_uL8,954
 fractal_server/migrations/versions/4cedeb448a53_workflowtask_foreign_keys_not_nullables.py,sha256=Mob8McGYAcmgvrseyyYOa54E6Gsgr-4SiGdC-r9O4_A,1157
 fractal_server/migrations/versions/501961cfcd85_remove_link_between_v1_and_v2_tasks_.py,sha256=5ROUgcoZOdjf8kMt6cxuvPhzHmV6xaCxvZEbhUEyZM4,3271
@@ -202,7 +202,7 @@ fractal_server/migrations/versions/efa89c30e0a4_add_project_timestamp_created.py
 fractal_server/migrations/versions/f384e1c0cf5d_drop_task_default_args_columns.py,sha256=9BwqUS9Gf7UW_KjrzHbtViC880qhD452KAytkHWWZyk,746
 fractal_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/ssh/__init__.py,sha256=sVUmzxf7_DuXG1xoLQ1_00fo5NPhi2LJipSmU5EAkPs,124
-fractal_server/ssh/_fabric.py,sha256=O1Dxl6xlg9pvqdKyKqy18mYQlslJoJHapXtDMCzZcBA,21711
+fractal_server/ssh/_fabric.py,sha256=56ud2_kkIkdThADjls5EEJ3leFwDS4bxYpyCb0qI578,22815
 fractal_server/string_tools.py,sha256=XtMNsr5R7GmgzmFi68zkKMedHs8vjGoVMMCXqWhIk9k,2568
 fractal_server/syringe.py,sha256=3qSMW3YaMKKnLdgnooAINOPxnCOxP7y2jeAQYB21Gdo,2786
 fractal_server/tasks/__init__.py,sha256=kadmVUoIghl8s190_Tt-8f-WBqMi8u8oU4Pvw39NHE8,23
@@ -221,7 +221,7 @@ fractal_server/tasks/v2/local/deactivate.py,sha256=Tjooode2oXfaSLiJz7iSu-qC1OkeI
 fractal_server/tasks/v2/local/reactivate.py,sha256=R3rArAzUpMGf6xa3dGVwwXHW9WVDi5ia28AFisZsqNc,6112
 fractal_server/tasks/v2/ssh/__init__.py,sha256=aSQbVi6Ummt9QzcSLWNmSqYjfdxrn9ROmqgH6bDpI7k,135
 fractal_server/tasks/v2/ssh/_utils.py,sha256=2E-F_862zM6FZA-im-E8t8kjptWRIhBj1IDHC6QD1H8,2818
-fractal_server/tasks/v2/ssh/collect.py,sha256=U8f6-dgtAI9Pr-gWPeDMeYdOkxYSqfsrYcSPDYEqz4I,12942
+fractal_server/tasks/v2/ssh/collect.py,sha256=ZOpz-v2t2kOAbbpdlsH_P_XjNtEh2TaC1dIZ1bBHwxw,12941
 fractal_server/tasks/v2/ssh/deactivate.py,sha256=YNJEcUPNuQ7H3I9EtWn84es2AY9Dnij388w6PQra4wc,10186
 fractal_server/tasks/v2/ssh/reactivate.py,sha256=brIa3XuoD7g9m9vIB7CSgog6KC9w8e45phLT-vSSXlI,7754
 fractal_server/tasks/v2/templates/1_create_venv.sh,sha256=PK0jdHKtQpda1zULebBaVPORt4t6V17wa4N1ohcj5ac,548
@@ -238,8 +238,8 @@ fractal_server/tasks/v2/utils_templates.py,sha256=C5WLuY3uGG2s53OEL-__H35-fmSlgu
 fractal_server/urls.py,sha256=5o_qq7PzKKbwq12NHSQZDmDitn5RAOeQ4xufu-2v9Zk,448
 fractal_server/utils.py,sha256=utvmBx8K9I8hRWFquxna2pBaOqe0JifDL_NVPmihEJI,3525
 fractal_server/zip_tools.py,sha256=GjDgo_sf6V_DDg6wWeBlZu5zypIxycn_l257p_YVKGc,4876
-fractal_server-2.9.0a3.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
-fractal_server-2.9.0a3.dist-info/METADATA,sha256=W92NgqXaqh1eO8X_o9XPN8chROYn0ZyszQCjkBo_BIg,4585
-fractal_server-2.9.0a3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fractal_server-2.9.0a3.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
-fractal_server-2.9.0a3.dist-info/RECORD,,
+fractal_server-2.9.0a5.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
+fractal_server-2.9.0a5.dist-info/METADATA,sha256=t0iiNYh719Cy3DbAgI3WK7_Sc8SV7RmCcfcCfVOIbco,4585
+fractal_server-2.9.0a5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fractal_server-2.9.0a5.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
+fractal_server-2.9.0a5.dist-info/RECORD,,

fractal_server/app/routes/aux/_timestamp.py

@@ -1,18 +0,0 @@
-from datetime import datetime
-from datetime import timezone
-
-from fastapi import HTTPException
-from fastapi import status
-
-
-def _convert_to_db_timestamp(dt: datetime) -> datetime:
-    """
-    This function takes a timezone-aware datetime and converts it to UTC.
-    """
-    if dt.tzinfo is None:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"The timestamp provided has no timezone information: {dt}",
-        )
-    _dt = dt.astimezone(timezone.utc)
-    return _dt