fractal-server 2.9.0a3__tar.gz → 2.9.0a5__tar.gz

{fractal_server-2.9.0a3 → fractal_server-2.9.0a5}/PKG-INFO

@@ -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.0a5/fractal_server/__init__.py

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

{fractal_server-2.9.0a3 → fractal_server-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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a5/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a3 → fractal_server-2.9.0a5}/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-2.9.0a5/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.",
+            )