fractal-server 2.8.1__py3-none-any.whl → 2.9.0a1__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.8.1"
+__VERSION__ = "2.9.0a1"

fractal_server/app/db/__init__.py

@@ -2,17 +2,14 @@
 `db` module, loosely adapted from
 https://testdriven.io/blog/fastapi-sqlmodel/#async-sqlmodel
 """
-import sqlite3
 from typing import AsyncGenerator
 from typing import Generator
 
 from sqlalchemy import create_engine
-from sqlalchemy import event
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.orm import Session as DBSyncSession
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
 
 from ...config import get_settings
 from ...logger import set_logger
@@ -21,14 +18,6 @@ from ...syringe import Inject
 
 logger = set_logger(__name__)
 
-SQLITE_WARNING_MESSAGE = (
-    "SQLite is supported (supported version >=3.37, "
-    f"current {sqlite3.sqlite_version=}) "
-    "but discouraged in production. "
-    "Given its partial support for ForeignKey constraints, "
-    "database consistency cannot be guaranteed."
-)
-
 
 class DB:
     """
@@ -56,14 +45,7 @@ class DB:
         settings = Inject(get_settings)
         settings.check_db()
 
-        if settings.DB_ENGINE == "sqlite":
-            logger.warning(SQLITE_WARNING_MESSAGE)
-            # Set some sqlite-specific options
-            engine_kwargs_async = dict(poolclass=StaticPool)
-        else:
-            engine_kwargs_async = {
-                "pool_pre_ping": True,
-            }
+        engine_kwargs_async = {"pool_pre_ping": True}
 
         cls._engine_async = create_async_engine(
             settings.DATABASE_ASYNC_URL,
@@ -83,15 +65,7 @@ class DB:
         settings = Inject(get_settings)
         settings.check_db()
 
-        if settings.DB_ENGINE == "sqlite":
-            logger.warning(SQLITE_WARNING_MESSAGE)
-            # Set some sqlite-specific options
-            engine_kwargs_sync = dict(
-                poolclass=StaticPool,
-                connect_args={"check_same_thread": False},
-            )
-        else:
-            engine_kwargs_sync = {}
+        engine_kwargs_sync = {}
 
         cls._engine_sync = create_engine(
             settings.DATABASE_SYNC_URL,
@@ -107,13 +81,6 @@ class DB:
             future=True,
         )
 
-        @event.listens_for(cls._engine_sync, "connect")
-        def set_sqlite_pragma(dbapi_connection, connection_record):
-            if settings.DB_ENGINE == "sqlite":
-                cursor = dbapi_connection.cursor()
-                cursor.execute("PRAGMA journal_mode=WAL")
-                cursor.close()
-
     @classmethod
     async def get_async_db(cls) -> AsyncGenerator[AsyncSession, None]:
         """

fractal_server/app/models/v2/__init__.py

@@ -2,12 +2,12 @@
 v2 `models` module
 """
 from ..linkuserproject import LinkUserProjectV2
-from .collection_state import CollectionStateV2
 from .dataset import DatasetV2
 from .job import JobV2
 from .project import ProjectV2
-from .task import TaskGroupV2
 from .task import TaskV2
+from .task_group import TaskGroupActivityV2
+from .task_group import TaskGroupV2
 from .workflow import WorkflowV2
 from .workflowtask import WorkflowTaskV2
 
@@ -16,8 +16,8 @@ __all__ = [
     "DatasetV2",
     "JobV2",
     "ProjectV2",
-    "CollectionStateV2",
     "TaskGroupV2",
+    "TaskGroupActivityV2",
     "TaskV2",
     "WorkflowTaskV2",
     "WorkflowV2",

fractal_server/app/models/v2/task.py

@@ -1,17 +1,12 @@
-from datetime import datetime
 from typing import Any
 from typing import Optional
 
 from pydantic import HttpUrl
 from sqlalchemy import Column
-from sqlalchemy.types import DateTime
 from sqlalchemy.types import JSON
 from sqlmodel import Field
-from sqlmodel import Relationship
 from sqlmodel import SQLModel
 
-from fractal_server.utils import get_timestamp
-
 
 class TaskV2(SQLModel, table=True):
     id: Optional[int] = Field(default=None, primary_key=True)
@@ -51,70 +46,3 @@ class TaskV2(SQLModel, table=True):
     tags: list[str] = Field(
         sa_column=Column(JSON, server_default="[]", nullable=False)
     )
-
-
-class TaskGroupV2(SQLModel, table=True):
-    id: Optional[int] = Field(default=None, primary_key=True)
-    task_list: list[TaskV2] = Relationship(
-        sa_relationship_kwargs=dict(
-            lazy="selectin", cascade="all, delete-orphan"
-        ),
-    )
-
-    user_id: int = Field(foreign_key="user_oauth.id")
-    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
-
-    origin: str
-    pkg_name: str
-    version: Optional[str] = None
-    python_version: Optional[str] = None
-    path: Optional[str] = None
-    venv_path: Optional[str] = None
-    wheel_path: Optional[str] = None
-    pip_extras: Optional[str] = None
-    pinned_package_versions: dict[str, str] = Field(
-        sa_column=Column(
-            JSON,
-            server_default="{}",
-            default={},
-            nullable=True,
-        ),
-    )
-
-    active: bool = True
-    timestamp_created: datetime = Field(
-        default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True), nullable=False),
-    )
-
-    @property
-    def pip_install_string(self) -> str:
-        """
-        Prepare string to be used in `python -m pip install`.
-        """
-        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}"
-        else:
-            if self.version is None:
-                raise ValueError(
-                    "Cannot run `pip_install_string` with "
-                    f"{self.pkg_name=}, {self.wheel_path=}, {self.version=}."
-                )
-            return f"{self.pkg_name}{extras}=={self.version}"
-
-    @property
-    def pinned_package_versions_string(self) -> str:
-        """
-        Prepare string to be used in `python -m pip install`.
-        """
-        if self.pinned_package_versions is None:
-            return ""
-        output = " ".join(
-            [
-                f"{key}=={value}"
-                for key, value in self.pinned_package_versions.items()
-            ]
-        )
-        return output

fractal_server/app/models/v2/task_group.py

@@ -0,0 +1,102 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import Column
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import JSON
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+from .task import TaskV2
+from fractal_server.utils import get_timestamp
+
+
+class TaskGroupV2(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    task_list: list[TaskV2] = Relationship(
+        sa_relationship_kwargs=dict(
+            lazy="selectin", cascade="all, delete-orphan"
+        ),
+    )
+
+    user_id: int = Field(foreign_key="user_oauth.id")
+    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
+
+    origin: str
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    wheel_path: Optional[str] = None
+    pip_extras: Optional[str] = None
+    pinned_package_versions: dict[str, str] = Field(
+        sa_column=Column(
+            JSON,
+            server_default="{}",
+            default={},
+            nullable=True,
+        ),
+    )
+    pip_freeze: Optional[str] = None
+    venv_path: Optional[str] = None
+    venv_size_in_kB: Optional[int] = None
+    venv_file_number: Optional[int] = None
+
+    active: bool = True
+    timestamp_created: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+
+    @property
+    def pip_install_string(self) -> str:
+        """
+        Prepare string to be used in `python -m pip install`.
+        """
+        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}"
+        else:
+            if self.version is None:
+                raise ValueError(
+                    "Cannot run `pip_install_string` with "
+                    f"{self.pkg_name=}, {self.wheel_path=}, {self.version=}."
+                )
+            return f"{self.pkg_name}{extras}=={self.version}"
+
+    @property
+    def pinned_package_versions_string(self) -> str:
+        """
+        Prepare string to be used in `python -m pip install`.
+        """
+        if self.pinned_package_versions is None:
+            return ""
+        output = " ".join(
+            [
+                f"{key}=={value}"
+                for key, value in self.pinned_package_versions.items()
+            ]
+        )
+        return output
+
+
+class TaskGroupActivityV2(SQLModel, table=True):
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    user_id: int = Field(foreign_key="user_oauth.id")
+    taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
+    timestamp_started: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+    pkg_name: str
+    version: str
+    status: str
+    action: str
+    log: Optional[str] = None
+    timestamp_ended: Optional[datetime] = Field(
+        default=None,
+        sa_column=Column(DateTime(timezone=True)),
+    )

fractal_server/app/routes/admin/v1.py

@@ -2,7 +2,6 @@
 Definition of `/admin` routes.
 """
 from datetime import datetime
-from datetime import timezone
 from pathlib import Path
 from typing import Optional
 
@@ -15,8 +14,6 @@ from fastapi.responses import StreamingResponse
 from sqlalchemy import func
 from sqlmodel import select
 
-from ....config import get_settings
-from ....syringe import Inject
 from ....utils import get_timestamp
 from ....zip_tools import _zip_folder_to_byte_stream_iterator
 from ...db import AsyncSession
@@ -36,27 +33,11 @@ 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
 
 router_admin_v1 = APIRouter()
 
 
-def _convert_to_db_timestamp(dt: datetime) -> datetime:
-    """
-    This function takes a timezone-aware datetime and converts it to UTC.
-    If using SQLite, it also removes the timezone information in order to make
-    the datetime comparable with datetimes in the database.
-    """
-    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)
-    if Inject(get_settings).DB_ENGINE == "sqlite":
-        return _dt.replace(tzinfo=None)
-    return _dt
-
-
 @router_admin_v1.get("/project/", response_model=list[ProjectReadV1])
 async def view_project(
     id: Optional[int] = None,

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

@@ -1,5 +1,4 @@
 from datetime import datetime
-from datetime import timezone
 from pathlib import Path
 from typing import Optional
 
@@ -19,35 +18,17 @@ from fractal_server.app.models.v2 import ProjectV2
 from fractal_server.app.routes.auth import current_active_superuser
 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
 from fractal_server.app.schemas.v2 import JobUpdateV2
-from fractal_server.config import get_settings
-from fractal_server.syringe import Inject
 from fractal_server.utils import get_timestamp
 from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 
 router = APIRouter()
 
 
-def _convert_to_db_timestamp(dt: datetime) -> datetime:
-    """
-    This function takes a timezone-aware datetime and converts it to UTC.
-    If using SQLite, it also removes the timezone information in order to make
-    the datetime comparable with datetimes in the database.
-    """
-    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)
-    if Inject(get_settings).DB_ENGINE == "sqlite":
-        return _dt.replace(tzinfo=None)
-    return _dt
-
-
 @router.get("/", response_model=list[JobReadV2])
 async def view_job(
     id: Optional[int] = None,

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

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Optional
 
 from fastapi import APIRouter
@@ -12,13 +13,16 @@ from sqlmodel import select
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
 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.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 TaskGroupUpdateV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
@@ -29,6 +33,42 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
+@router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
+async def get_task_group_activity_list(
+    task_group_activity_id: Optional[int] = None,
+    user_id: Optional[int] = None,
+    taskgroupv2_id: Optional[int] = None,
+    pkg_name: Optional[str] = None,
+    status: Optional[TaskGroupActivityStatusV2] = None,
+    action: Optional[TaskGroupActivityActionV2] = None,
+    timestamp_started_min: Optional[datetime] = None,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupActivityV2Read]:
+
+    stm = select(TaskGroupActivityV2)
+    if task_group_activity_id is not None:
+        stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
+    if user_id:
+        stm = stm.where(TaskGroupActivityV2.user_id == user_id)
+    if taskgroupv2_id:
+        stm = stm.where(TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id)
+    if pkg_name:
+        stm = stm.where(TaskGroupActivityV2.pkg_name.icontains(pkg_name))
+    if status:
+        stm = stm.where(TaskGroupActivityV2.status == status)
+    if action:
+        stm = stm.where(TaskGroupActivityV2.action == action)
+    if timestamp_started_min is not None:
+        stm = stm.where(
+            TaskGroupActivityV2.timestamp_started >= timestamp_started_min
+        )
+
+    res = await db.execute(stm)
+    activities = res.scalars().all()
+    return activities
+
+
 @router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
 async def query_task_group(
     task_group_id: int,
@@ -139,22 +179,22 @@ async def delete_task_group(
             detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
         )
 
-    # Cascade operations: set foreign-keys to null for CollectionStateV2 which
-    # are in relationship with the current TaskGroupV2
-    logger.debug("Start of cascade operations on CollectionStateV2.")
-    stm = select(CollectionStateV2).where(
-        CollectionStateV2.taskgroupv2_id == task_group_id
+    # Cascade operations: set foreign-keys to null for TaskGroupActivityV2
+    # which are in relationship with the current TaskGroupV2
+    logger.debug("Start of cascade operations on TaskGroupActivityV2.")
+    stm = select(TaskGroupActivityV2).where(
+        TaskGroupActivityV2.taskgroupv2_id == task_group_id
     )
     res = await db.execute(stm)
-    collection_states = res.scalars().all()
-    for collection_state in collection_states:
+    task_group_activity_list = res.scalars().all()
+    for task_group_activity in task_group_activity_list:
         logger.debug(
-            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
-            "to None."
+            f"Setting TaskGroupActivityV2[{task_group_activity.id}]"
+            ".taskgroupv2_id to None."
         )
-        collection_state.taskgroupv2_id = None
-        db.add(collection_state)
-    logger.debug("End of cascade operations on CollectionStateV2.")
+        task_group_activity.taskgroupv2_id = None
+        db.add(task_group_activity)
+    logger.debug("End of cascade operations on TaskGroupActivityV2.")
 
     await db.delete(task_group)
     await db.commit()

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

@@ -13,6 +13,7 @@ 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_group import router as task_group_router_v2
+from .task_group_lifecycle import router as task_group_lifecycle_router_v2
 from .workflow import router as workflow_router_v2
 from .workflow_import import router as workflow_import_router_v2
 from .workflowtask import router as workflowtask_router_v2
@@ -31,13 +32,21 @@ router_api_v2.include_router(submit_job_router_v2, tags=["V2 Job"])
 
 settings = Inject(get_settings)
 router_api_v2.include_router(
-    task_collection_router_v2, prefix="/task", tags=["V2 Task Collection"]
+    task_collection_router_v2,
+    prefix="/task",
+    tags=["V2 Task Lifecycle"],
 )
 router_api_v2.include_router(
     task_collection_router_v2_custom,
     prefix="/task",
-    tags=["V2 Task Collection"],
+    tags=["V2 Task Lifecycle"],
+)
+router_api_v2.include_router(
+    task_group_lifecycle_router_v2,
+    prefix="/task-group",
+    tags=["V2 Task Lifecycle"],
 )
+
 router_api_v2.include_router(task_router_v2, prefix="/task", tags=["V2 Task"])
 router_api_v2.include_router(
     task_group_router_v2, prefix="/task-group", tags=["V2 TaskGroup"]

fractal_server/app/routes/api/v2/{_aux_functions_task_collection.py → _aux_functions_task_lifecycle.py}

@@ -4,7 +4,11 @@ from fastapi import HTTPException
 from fastapi import status
 from httpx import AsyncClient
 from httpx import TimeoutException
+from sqlmodel import select
 
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models.v2 import TaskGroupActivityV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.logger import set_logger
 
 
@@ -122,3 +126,42 @@ async def get_package_version_from_pypi(
         # Case 3: `version` is unset and we use latest
         logger.info(f"No version requested, returning {latest_version=}.")
         return latest_version
+
+
+async def check_no_ongoing_activity(
+    *,
+    task_group_id: int,
+    db: AsyncSession,
+) -> None:
+    """
+    Find ongoing activities for the same task group.
+
+    Arguments:
+        task_group_id:
+        db:
+    """
+    # DB query
+    stm = (
+        select(TaskGroupActivityV2)
+        .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
+        .where(TaskGroupActivityV2.status == TaskGroupActivityStatusV2.ONGOING)
+    )
+    res = await db.execute(stm)
+    ongoing_activities = res.scalars().all()
+
+    if ongoing_activities == []:
+        # All good, exit
+        return
+
+    msg = "Found ongoing activities for the same task-group:"
+    for ind, activity in enumerate(ongoing_activities):
+        msg = (
+            f"{msg}\n{ind + 1}) "
+            f"Action={activity.action}, "
+            f"status={activity.status}, "
+            f"timestamp_started={activity.timestamp_started}."
+        )
+    raise HTTPException(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        detail=msg,
+    )

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

@@ -13,7 +13,7 @@ from fractal_server.app.db import AsyncSession
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
@@ -21,6 +21,7 @@ from fractal_server.app.routes.auth._aux_auth import _get_default_usergroup_id
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.logger import set_logger
 
 logger = set_logger(__name__)
@@ -219,27 +220,32 @@ async def _get_valid_user_group_id(
     return user_group_id
 
 
-async def _get_collection_status_message(
-    task_group: TaskGroupV2, db: AsyncSession
+async def _get_collection_task_group_activity_status_message(
+    task_group_id: int,
+    db: AsyncSession,
 ) -> str:
+
     res = await db.execute(
-        select(CollectionStateV2).where(
-            CollectionStateV2.taskgroupv2_id == task_group.id
-        )
+        select(TaskGroupActivityV2)
+        .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
+        .where(TaskGroupActivityV2.action == TaskGroupActivityActionV2.COLLECT)
     )
-    states = res.scalars().all()
-    if len(states) > 1:
+    task_group_activity_list = res.scalars().all()
+    if len(task_group_activity_list) > 1:
         msg = (
-            "Expected one CollectionStateV2 associated to TaskGroup "
-            f"{task_group.id}, found {len(states)} "
-            f"(IDs: {[state.id for state in states]}).\n"
+            "\nWarning: "
+            "Expected only one TaskGroupActivityV2 associated to TaskGroup "
+            f"{task_group_id}, found {len(task_group_activity_list)} "
+            f"(IDs: {[tga.id for tga in task_group_activity_list]})."
             "Warning: this should have not happened, please contact an admin."
         )
-    elif len(states) == 1:
+    elif len(task_group_activity_list) == 1:
         msg = (
-            f"\nThere exists a task-collection state (ID={states[0].id}) for "
-            f"such task group (ID={task_group.id}), with status "
-            f"'{states[0].data.get('status')}'."
+            "\nNote:"
+            "There exists another task-group collection "
+            f"(activity ID={task_group_activity_list[0].id}) for "
+            f"this task group (ID={task_group_id}), with status "
+            f"'{task_group_activity_list[0].status}'."
         )
     else:
         msg = ""
@@ -273,7 +279,9 @@ async def _verify_non_duplication_user_constraint(
                     "This should have not happened: please contact an admin."
                 ),
             )
-        state_msg = await _get_collection_status_message(duplicate[0], db)
+        state_msg = await _get_collection_task_group_activity_status_message(
+            duplicate[0].id, db
+        )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
@@ -313,7 +321,9 @@ async def _verify_non_duplication_group_constraint(
                     "This should have not happened: please contact an admin."
                 ),
             )
-        state_msg = await _get_collection_status_message(duplicate[0], db)
+        state_msg = await _get_collection_task_group_activity_status_message(
+            duplicate[0].id, db
+        )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(