fractal-server 2.14.16__py3-none-any.whl → 2.15.0__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.14.16"
+__VERSION__ = "2.15.0"

fractal_server/app/models/security.py

@@ -15,8 +15,8 @@ from typing import Optional
 from pydantic import ConfigDict
 from pydantic import EmailStr
 from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
 from sqlmodel import Field
 from sqlmodel import Relationship
 from sqlmodel import SQLModel
@@ -124,5 +124,5 @@ class UserGroup(SQLModel, table=True):
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
     viewer_paths: list[str] = Field(
-        sa_column=Column(JSON, server_default="[]", nullable=False)
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
     )

fractal_server/app/models/user_settings.py

@@ -1,5 +1,5 @@
 from sqlalchemy import Column
-from sqlalchemy.types import JSON
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlmodel import Field
 from sqlmodel import SQLModel
 
@@ -25,7 +25,7 @@ class UserSettings(SQLModel, table=True):
 
     id: int | None = Field(default=None, primary_key=True)
     slurm_accounts: list[str] = Field(
-        sa_column=Column(JSON, server_default="[]", nullable=False)
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
     )
     ssh_host: str | None = None
     ssh_username: str | None = None

fractal_server/app/models/v2/dataset.py

@@ -3,8 +3,8 @@ from typing import Any
 
 from pydantic import ConfigDict
 from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
 from sqlmodel import Field
 from sqlmodel import Relationship
 from sqlmodel import SQLModel
@@ -24,7 +24,7 @@ class DatasetV2(SQLModel, table=True):
     )
 
     history: list[dict[str, Any]] = Field(
-        sa_column=Column(JSON, server_default="[]", nullable=False)
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
     )
 
     timestamp_created: datetime = Field(
@@ -34,7 +34,7 @@ class DatasetV2(SQLModel, table=True):
 
     zarr_dir: str
     images: list[dict[str, Any]] = Field(
-        sa_column=Column(JSON, server_default="[]", nullable=False)
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
     )
 
     @property

fractal_server/app/models/v2/job.py

@@ -3,8 +3,8 @@ from typing import Any
 
 from pydantic import ConfigDict
 from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
 from sqlmodel import Field
 from sqlmodel import SQLModel
 
@@ -31,13 +31,13 @@ class JobV2(SQLModel, table=True):
     slurm_account: str | None = None
 
     dataset_dump: dict[str, Any] = Field(
-        sa_column=Column(JSON, nullable=False)
+        sa_column=Column(JSONB, nullable=False)
     )
     workflow_dump: dict[str, Any] = Field(
-        sa_column=Column(JSON, nullable=False)
+        sa_column=Column(JSONB, nullable=False)
     )
     project_dump: dict[str, Any] = Field(
-        sa_column=Column(JSON, nullable=False)
+        sa_column=Column(JSONB, nullable=False)
     )
 
     worker_init: str | None = None
@@ -57,8 +57,8 @@ class JobV2(SQLModel, table=True):
     log: str | None = None
 
     attribute_filters: AttributeFilters = Field(
-        sa_column=Column(JSON, nullable=False, server_default="{}")
+        sa_column=Column(JSONB, nullable=False, server_default="{}")
     )
     type_filters: dict[str, bool] = Field(
-        sa_column=Column(JSON, nullable=False, server_default="{}")
+        sa_column=Column(JSONB, nullable=False, server_default="{}")
     )

fractal_server/app/models/v2/task.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 from sqlalchemy import Column
-from sqlalchemy.types import JSON
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlmodel import Field
 from sqlmodel import SQLModel
 
@@ -16,25 +16,29 @@ class TaskV2(SQLModel, table=True):
     source: str | None = None
 
     meta_non_parallel: dict[str, Any] = Field(
-        sa_column=Column(JSON, server_default="{}", default={}, nullable=False)
+        sa_column=Column(
+            JSONB, server_default="{}", default={}, nullable=False
+        )
     )
     meta_parallel: dict[str, Any] = Field(
-        sa_column=Column(JSON, server_default="{}", default={}, nullable=False)
+        sa_column=Column(
+            JSONB, server_default="{}", default={}, nullable=False
+        )
     )
 
     version: str | None = None
     args_schema_non_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
     args_schema_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
     args_schema_version: str | None = None
     docs_info: str | None = None
     docs_link: str | None = None
 
-    input_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})
-    output_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})
+    input_types: dict[str, bool] = Field(sa_column=Column(JSONB), default={})
+    output_types: dict[str, bool] = Field(sa_column=Column(JSONB), default={})
 
     taskgroupv2_id: int = Field(foreign_key="taskgroupv2.id")
 
@@ -42,5 +46,5 @@ class TaskV2(SQLModel, table=True):
     modality: str | None = None
     authors: str | None = None
     tags: list[str] = Field(
-        sa_column=Column(JSON, server_default="[]", nullable=False)
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
     )

fractal_server/app/models/v2/task_group.py

@@ -2,8 +2,8 @@ from datetime import datetime
 from datetime import timezone
 
 from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
 from sqlmodel import Field
 from sqlmodel import Relationship
 from sqlmodel import SQLModel
@@ -29,18 +29,19 @@ class TaskGroupV2(SQLModel, table=True):
     pkg_name: str
     version: str | None = None
     python_version: str | None = None
+    pixi_version: str | None = None
     path: str | None = None
-    wheel_path: str | None = None
+    archive_path: str | None = None
     pip_extras: str | None = None
     pinned_package_versions: dict[str, str] = Field(
         sa_column=Column(
-            JSON,
+            JSONB,
             server_default="{}",
             default={},
             nullable=True,
         ),
     )
-    pip_freeze: str | None = None
+    env_info: str | None = None
     venv_path: str | None = None
     venv_size_in_kB: int | None = None
     venv_file_number: int | None = None
@@ -66,15 +67,20 @@ class TaskGroupV2(SQLModel, table=True):
         """
         Prepare string to be used in `python -m pip install`.
         """
+        if self.origin == "pixi":
+            raise ValueError(
+                f"Cannot call 'pip_install_string' if {self.origin=}."
+            )
+
         extras = f"[{self.pip_extras}]" if self.pip_extras is not None else ""
 
-        if self.wheel_path is not None:
-            return f"{self.wheel_path}{extras}"
+        if self.archive_path is not None:
+            return f"{self.archive_path}{extras}"
         else:
             if self.version is None:
                 raise ValueError(
                     "Cannot run `pip_install_string` with "
-                    f"{self.pkg_name=}, {self.wheel_path=}, {self.version=}."
+                    f"{self.pkg_name=}, {self.archive_path=}, {self.version=}."
                 )
             return f"{self.pkg_name}{extras}=={self.version}"
 
@@ -83,6 +89,12 @@ class TaskGroupV2(SQLModel, table=True):
         """
         Prepare string to be used in `python -m pip install`.
         """
+        if self.origin == "pixi":
+            raise ValueError(
+                "Cannot call 'pinned_package_versions_string' if "
+                f"{self.origin=}."
+            )
+
         if self.pinned_package_versions is None:
             return ""
         output = " ".join(

fractal_server/app/models/v2/workflowtask.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from pydantic import ConfigDict
 from sqlalchemy import Column
-from sqlalchemy.types import JSON
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlmodel import Field
 from sqlmodel import Relationship
 from sqlmodel import SQLModel
@@ -18,20 +18,20 @@ class WorkflowTaskV2(SQLModel, table=True):
     workflow_id: int = Field(foreign_key="workflowv2.id", ondelete="CASCADE")
     order: int | None = None
     meta_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
     meta_non_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
     args_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
     args_non_parallel: dict[str, Any] | None = Field(
-        sa_column=Column(JSON), default=None
+        sa_column=Column(JSONB), default=None
     )
 
     type_filters: dict[str, bool] = Field(
-        sa_column=Column(JSON, nullable=False, server_default="{}")
+        sa_column=Column(JSONB, nullable=False, server_default="{}")
     )
 
     # Task

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

@@ -2,7 +2,6 @@ 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
 
@@ -51,7 +50,6 @@ 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:
@@ -157,7 +155,6 @@ 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:
@@ -207,12 +204,12 @@ async def reactivate_task_group(
         response.status_code = status.HTTP_202_ACCEPTED
         return task_group_activity
 
-    if task_group.pip_freeze is None:
+    if task_group.env_info is None:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
                 "Cannot reactivate a task group with "
-                f"{task_group.pip_freeze=}."
+                f"{task_group.env_info=}."
             ),
         )
 

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

@@ -14,6 +14,7 @@ from .submit import router as submit_job_router_v2
 from .task import router as task_router_v2
 from .task_collection import router as task_collection_router_v2
 from .task_collection_custom import router as task_collection_router_v2_custom
+from .task_collection_pixi import router as task_collection_pixi_router_v2
 from .task_group import router as task_group_router_v2
 from .task_group_lifecycle import router as task_group_lifecycle_router_v2
 from .task_version_update import router as task_version_update_router_v2
@@ -49,6 +50,11 @@ router_api_v2.include_router(
     prefix="/task",
     tags=["V2 Task Lifecycle"],
 )
+router_api_v2.include_router(
+    task_collection_pixi_router_v2,
+    prefix="/task",
+    tags=["V2 Task Lifecycle"],
+)
 router_api_v2.include_router(
     task_group_lifecycle_router_v2,
     prefix="/task-group",

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

@@ -333,6 +333,28 @@ async def _verify_non_duplication_group_constraint(
         )
 
 
+async def _verify_non_duplication_group_path(
+    path: str | None,
+    db: AsyncSession,
+) -> None:
+    """
+    Verify uniqueness of non-`None` `TaskGroupV2.path`
+    """
+    if path is None:
+        return
+    stm = select(TaskGroupV2.id).where(TaskGroupV2.path == path)
+    res = await db.execute(stm)
+    duplicate_ids = res.scalars().all()
+    if duplicate_ids:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Other TaskGroups already have {path=}: "
+                f"{sorted(duplicate_ids)}."
+            ),
+        )
+
+
 async def _add_warnings_to_workflow_tasks(
     wftask_list: list[WorkflowTaskV2], user_id: int, db: AsyncSession
 ) -> list[dict[str, Any]]:

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

@@ -7,14 +7,12 @@ from fastapi import Depends
 from fastapi import File
 from fastapi import Form
 from fastapi import HTTPException
-from fastapi import Request
 from fastapi import Response
 from fastapi import status
 from fastapi import UploadFile
 from pydantic import BaseModel
 from pydantic import model_validator
 from pydantic import ValidationError
-from sqlmodel import select
 
 from .....config import get_settings
 from .....logger import reset_logger_handlers
@@ -23,15 +21,16 @@ from .....syringe import Inject
 from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import TaskGroupV2
+from ....schemas.v2 import FractalUploadedFile
 from ....schemas.v2 import TaskCollectPipV2
 from ....schemas.v2 import TaskGroupActivityStatusV2
 from ....schemas.v2 import TaskGroupActivityV2Read
 from ....schemas.v2 import TaskGroupCreateV2Strict
-from ....schemas.v2 import WheelFile
 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
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
+from ._aux_functions_tasks import _verify_non_duplication_group_path
 from ._aux_functions_tasks import _verify_non_duplication_user_constraint
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupActivityV2
@@ -151,7 +150,6 @@ def parse_request_data(
     response_model=TaskGroupActivityV2Read,
 )
 async def collect_tasks_pip(
-    request: Request,
     response: Response,
     background_tasks: BackgroundTasks,
     request_data: CollectionRequestData = Depends(parse_request_data),
@@ -208,13 +206,13 @@ async def collect_tasks_pip(
     # Initialize wheel_file_content as None
     wheel_file = None
 
-    # Set pkg_name, version, origin and wheel_path
+    # Set pkg_name, version, origin and archive_path
     if request_data.origin == TaskGroupV2OriginEnum.WHEELFILE:
         try:
             wheel_filename = request_data.file.filename
             wheel_info = _parse_wheel_filename(wheel_filename)
             wheel_file_content = await request_data.file.read()
-            wheel_file = WheelFile(
+            wheel_file = FractalUploadedFile(
                 filename=wheel_filename,
                 contents=wheel_file_content,
             )
@@ -293,18 +291,10 @@ async def collect_tasks_pip(
         version=task_group_attrs["version"],
         db=db,
     )
-
-    # Verify that task-group path is unique
-    stm = select(TaskGroupV2).where(TaskGroupV2.path == task_group_path)
-    res = await db.execute(stm)
-    for conflicting_task_group in res.scalars().all():
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Another task-group already has path={task_group_path}.\n"
-                f"{conflicting_task_group=}"
-            ),
-        )
+    await _verify_non_duplication_group_path(
+        path=task_group_attrs["path"],
+        db=db,
+    )
 
     # On-disk checks
 

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

@@ -26,7 +26,7 @@ from fractal_server.logger import set_logger
 from fractal_server.string_tools import validate_cmd
 from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.utils_background import (
-    _prepare_tasks_metadata,
+    prepare_tasks_metadata,
 )
 from fractal_server.tasks.v2.utils_database import (
     create_db_tasks_and_update_task_group_async,
@@ -138,7 +138,7 @@ async def collect_task_custom(
     else:
         package_root = Path(task_collect.package_root)
 
-    task_list: list[TaskCreateV2] = _prepare_tasks_metadata(
+    task_list: list[TaskCreateV2] = prepare_tasks_metadata(
         package_manifest=task_collect.manifest,
         python_bin=Path(task_collect.python_interpreter),
         package_root=package_root,

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

@@ -0,0 +1,219 @@
+import os
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi import BackgroundTasks
+from fastapi import Depends
+from fastapi import Form
+from fastapi import HTTPException
+from fastapi import Response
+from fastapi import status
+from fastapi import UploadFile
+
+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.models.v2 import TaskGroupV2
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _get_valid_user_group_id,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_group_constraint,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_group_path,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_user_constraint,
+)
+from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.aux.validate_user_settings import (
+    validate_user_settings,
+)
+from fractal_server.app.schemas.v2 import FractalUploadedFile
+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.task_group import TaskGroupV2OriginEnum
+from fractal_server.config import get_settings
+from fractal_server.logger import set_logger
+from fractal_server.ssh._fabric import SSHConfig
+from fractal_server.syringe import Inject
+from fractal_server.tasks.v2.local import collect_local_pixi
+from fractal_server.tasks.v2.ssh import collect_ssh_pixi
+from fractal_server.tasks.v2.utils_package_names import normalize_package_name
+from fractal_server.types import NonEmptyStr
+
+
+router = APIRouter()
+
+logger = set_logger(__name__)
+
+
+def validate_pkgname_and_version(filename: str) -> tuple[str, str]:
+    if not filename.endswith(".tar.gz"):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"{filename=} does not end with '.tar.gz'.",
+        )
+    filename_splitted = filename.split("-")
+    if len(filename_splitted) != 2:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Invalid filename: '{filename}' must contain a single `-` "
+                "character, separating the package name from the version "
+                "(expected format: 'pkg_name-version')."
+            ),
+        )
+
+    pkg_name = filename_splitted[0]
+    version = filename.removeprefix(f"{pkg_name}-").removesuffix(".tar.gz")
+
+    return normalize_package_name(pkg_name), version
+
+
+@router.post(
+    "/collect/pixi/",
+    status_code=202,
+    response_model=TaskGroupActivityV2Read,
+)
+async def collect_task_pixi(
+    response: Response,
+    background_tasks: BackgroundTasks,
+    file: UploadFile,
+    pixi_version: NonEmptyStr | None = Form(None),
+    private: bool = False,
+    user_group_id: int | None = None,
+    user: UserOAuth = Depends(current_active_verified_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupActivityV2Read:
+
+    settings = Inject(get_settings)
+    # Check if Pixi is available
+    if settings.pixi is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Pixi task collection is not available.",
+        )
+    # Check if provided Pixi version is available. Use default if not provided
+    if pixi_version is None:
+        pixi_version = settings.pixi.default_version
+    else:
+        if pixi_version not in settings.pixi.versions:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=(
+                    f"Pixi version {pixi_version} is not available. Available "
+                    f"versions: {list(settings.pixi.versions.keys())}"
+                ),
+            )
+
+    pkg_name, version = validate_pkgname_and_version(file.filename)
+    tar_gz_content = await file.read()
+    tar_gz_file = FractalUploadedFile(
+        filename=file.filename,
+        contents=tar_gz_content,
+    )
+
+    user_group_id = await _get_valid_user_group_id(
+        user_group_id=user_group_id,
+        private=private,
+        user_id=user.id,
+        db=db,
+    )
+
+    user_settings = await validate_user_settings(
+        user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+    )
+
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        base_tasks_path = user_settings.ssh_tasks_dir
+    else:
+        base_tasks_path = settings.FRACTAL_TASKS_DIR.as_posix()
+    task_group_path = (
+        Path(base_tasks_path) / str(user.id) / pkg_name / version
+    ).as_posix()
+
+    task_group_attrs = dict(
+        user_id=user.id,
+        user_group_id=user_group_id,
+        origin=TaskGroupV2OriginEnum.PIXI,
+        pixi_version=pixi_version,
+        pkg_name=pkg_name,
+        version=version,
+        path=task_group_path,
+    )
+
+    await _verify_non_duplication_user_constraint(
+        user_id=user.id,
+        pkg_name=task_group_attrs["pkg_name"],
+        version=task_group_attrs["version"],
+        db=db,
+    )
+    await _verify_non_duplication_group_constraint(
+        user_group_id=task_group_attrs["user_group_id"],
+        pkg_name=task_group_attrs["pkg_name"],
+        version=task_group_attrs["version"],
+        db=db,
+    )
+    await _verify_non_duplication_group_path(
+        path=task_group_attrs["path"],
+        db=db,
+    )
+
+    if settings.FRACTAL_RUNNER_BACKEND != "slurm_ssh":
+        if Path(task_group_path).exists():
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"{task_group_path} already exists.",
+            )
+
+    task_group = TaskGroupV2(**task_group_attrs)
+    db.add(task_group)
+    await db.commit()
+    await db.refresh(task_group)
+    db.expunge(task_group)
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.COLLECT,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+    )
+    db.add(task_group_activity)
+    await db.commit()
+    await db.refresh(task_group_activity)
+
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        ssh_config = SSHConfig(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+
+        background_tasks.add_task(
+            collect_ssh_pixi,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            ssh_config=ssh_config,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+            tar_gz_file=tar_gz_file,
+        )
+    else:
+        background_tasks.add_task(
+            collect_local_pixi,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            tar_gz_file=tar_gz_file,
+        )
+    logger.info(
+        "Task-collection endpoint: start background collection "
+        "and return task_group_activity. "
+        f"Current pid is {os.getpid()}. "
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity

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

@@ -12,6 +12,7 @@ from pydantic.types import AwareDatetime
 from sqlmodel import or_
 from sqlmodel import select
 
+from ._aux_functions_task_lifecycle import check_no_ongoing_activity
 from ._aux_functions_tasks import _get_task_group_full_access
 from ._aux_functions_tasks import _get_task_group_read_access
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
@@ -216,6 +217,8 @@ async def delete_task_group(
         db=db,
     )
 
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
     stm = select(WorkflowTaskV2).where(
         WorkflowTaskV2.task_id.in_({task.id for task in task_group.task_list})
     )