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

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

@@ -17,22 +17,24 @@ from .....logger import set_logger
 from .....syringe import Inject
 from ....db import AsyncSession
 from ....db import get_async_db
-from ....models.v2 import CollectionStateV2
 from ....models.v2 import TaskGroupV2
-from ....schemas.v2 import CollectionStateReadV2
-from ....schemas.v2 import CollectionStatusV2
 from ....schemas.v2 import TaskCollectPipV2
+from ....schemas.v2 import TaskGroupActivityStatusV2
+from ....schemas.v2 import TaskGroupActivityV2Read
 from ....schemas.v2 import TaskGroupCreateV2
 from ...aux.validate_user_settings import validate_user_settings
-from ._aux_functions_task_collection import get_package_version_from_pypi
+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_user_constraint
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.routes.auth import current_active_user
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.schemas.v2 import (
+    TaskGroupActivityActionV2,
+)
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.tasks.v2.collection_local import (
+from fractal_server.tasks.v2.local.collect import (
     collect_package_local,
 )
 from fractal_server.tasks.v2.utils_package_names import _parse_wheel_filename
@@ -48,7 +50,7 @@ logger = set_logger(__name__)
 
 @router.post(
     "/collect/pip/",
-    response_model=CollectionStateReadV2,
+    response_model=TaskGroupActivityV2Read,
 )
 async def collect_tasks_pip(
     task_collect: TaskCollectPipV2,
@@ -59,7 +61,7 @@ async def collect_tasks_pip(
     user_group_id: Optional[int] = None,
     user: UserOAuth = Depends(current_active_verified_user),
     db: AsyncSession = Depends(get_async_db),
-) -> CollectionStateReadV2:
+) -> TaskGroupActivityV2Read:
     """
     Task collection endpoint
 
@@ -227,20 +229,17 @@ async def collect_tasks_pip(
     db.expunge(task_group)
 
     # All checks are OK, proceed with task collection
-    collection_state_data = dict(
-        status=CollectionStatusV2.PENDING,
-        package=task_group.pkg_name,
+    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,
-        path=task_group.path,
-        venv_path=task_group.venv_path,
-    )
-    state = CollectionStateV2(
-        data=collection_state_data, taskgroupv2_id=task_group.id
     )
-    db.add(state)
+    db.add(task_group_activity)
     await db.commit()
-    await db.refresh(state)
-
+    await db.refresh(task_group_activity)
     logger = set_logger(logger_name="collect_tasks_pip")
 
     # END of SSH/non-SSH common part
@@ -248,7 +247,7 @@ async def collect_tasks_pip(
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
         # SSH task collection
 
-        from fractal_server.tasks.v2.collection_ssh import (
+        from fractal_server.tasks.v2.ssh.collect import (
             collect_package_ssh,
         )
 
@@ -263,8 +262,8 @@ async def collect_tasks_pip(
 
         background_tasks.add_task(
             collect_package_ssh,
-            state_id=state.id,
-            task_group=task_group,
+            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,
         )
@@ -273,37 +272,13 @@ async def collect_tasks_pip(
         # Local task collection
         background_tasks.add_task(
             collect_package_local,
-            state_id=state.id,
-            task_group=task_group,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
         )
     logger.debug(
         "Task-collection endpoint: start background collection "
-        "and return state"
+        "and return task_group_activity"
     )
     reset_logger_handlers(logger)
-    info = (
-        "Collecting tasks in the background. "
-        f"GET /task/collect/{state.id}/ to query collection status"
-    )
-    state.data["info"] = info
-    response.status_code = status.HTTP_201_CREATED
-
-    return state
-
-
-@router.get("/collect/{state_id}/", response_model=CollectionStateReadV2)
-async def check_collection_status(
-    state_id: int,
-    user: UserOAuth = Depends(current_active_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> CollectionStateReadV2:  # State[TaskCollectStatus]
-    """
-    Check status of background task collection
-    """
-    state = await db.get(CollectionStateV2, state_id)
-    if state is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"No task collection info with id={state_id}",
-        )
-    return state
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity

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

@@ -27,12 +27,12 @@ from fractal_server.config import get_settings
 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.database_operations import (
-    create_db_tasks_and_update_task_group,
-)
 from fractal_server.tasks.v2.utils_background import (
     _prepare_tasks_metadata,
 )
+from fractal_server.tasks.v2.utils_database import (
+    create_db_tasks_and_update_task_group,
+)
 
 router = APIRouter()
 

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

@@ -1,3 +1,6 @@
+from datetime import datetime
+from typing import Optional
+
 from fastapi import APIRouter
 from fastapi import Depends
 from fastapi import HTTPException
@@ -13,13 +16,16 @@ from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import LinkUserGroup
 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_user
 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.logger import set_logger
@@ -29,6 +35,70 @@ 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,
+    taskgroupv2_id: Optional[int] = None,
+    pkg_name: Optional[str] = None,
+    status: Optional[TaskGroupActivityStatusV2] = None,
+    action: Optional[TaskGroupActivityActionV2] = None,
+    timestamp_started_min: Optional[datetime] = None,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupActivityV2Read]:
+
+    stm = select(TaskGroupActivityV2).where(
+        TaskGroupActivityV2.user_id == user.id
+    )
+    if task_group_activity_id is not None:
+        stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
+    if taskgroupv2_id is not None:
+        stm = stm.where(TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id)
+    if pkg_name is not None:
+        stm = stm.where(TaskGroupActivityV2.pkg_name.icontains(pkg_name))
+    if status is not None:
+        stm = stm.where(TaskGroupActivityV2.status == status)
+    if action is not None:
+        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(
+    "/activity/{task_group_activity_id}/",
+    response_model=TaskGroupActivityV2Read,
+)
+async def get_task_group_activity(
+    task_group_activity_id: int,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupActivityV2Read:
+
+    activity = await db.get(TaskGroupActivityV2, task_group_activity_id)
+
+    if activity is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroupActivityV2 {task_group_activity_id} not found",
+        )
+    if activity.user_id != user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=(
+                "You are not the owner of TaskGroupActivityV2 "
+                f"{task_group_activity_id}",
+            ),
+        )
+
+    return activity
+
+
 @router.get("/", response_model=list[TaskGroupReadV2])
 async def get_task_group_list(
     user: UserOAuth = Depends(current_active_user),
@@ -40,7 +110,6 @@ async def get_task_group_list(
     """
     Get all accessible TaskGroups
     """
-
     if only_owner:
         condition = TaskGroupV2.user_id == user.id
     else:
@@ -112,22 +181,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/task_group_lifecycle.py

@@ -0,0 +1,221 @@
+from fastapi import APIRouter
+from fastapi import BackgroundTasks
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+from fastapi import status
+
+from ._aux_functions_task_lifecycle import check_no_ongoing_activity
+from ._aux_functions_tasks import _get_task_group_full_access
+from fractal_server.app.db import AsyncSession
+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.auth import current_active_user
+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.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,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+    # Check access
+    task_group = await _get_task_group_full_access(
+        task_group_id=task_group_id,
+        user_id=user.id,
+        db=db,
+    )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Check that task-group is active
+    if not task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot deactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = False
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.DEACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to False and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.DEACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    task_group.active = False
+    db.add(task_group)
+    db.add(task_group_activity)
+    await db.commit()
+
+    # Submit background task
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Not implemented (yet) for SSH.",
+        )
+    else:
+        background_tasks.add_task(
+            deactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+
+    logger.debug(
+        "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,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+
+    # Check access
+    task_group = await _get_task_group_full_access(
+        task_group_id=task_group_id,
+        user_id=user.id,
+        db=db,
+    )
+
+    # Check that task-group is not active
+    if task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot reactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = True
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.REACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to True and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    if task_group.pip_freeze is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "Cannot reactivate a task group with "
+                f"{task_group.pip_freeze=}."
+            ),
+        )
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.REACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    db.add(task_group_activity)
+    await db.commit()
+
+    # Submit background task
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Not implemented (yet) for SSH.",
+        )
+    else:
+        background_tasks.add_task(
+            reactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+    logger.debug(
+        "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/workflow.py

@@ -23,7 +23,7 @@ from ._aux_functions import _get_submitted_jobs_statement
 from ._aux_functions import _get_workflow_check_owner
 from ._aux_functions_tasks import _add_warnings_to_workflow_tasks
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2.task import TaskGroupV2
+from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.routes.auth import current_active_user
 
 router = APIRouter()

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

@@ -21,10 +21,10 @@ from ._aux_functions import _workflow_insert_task
 from ._aux_functions_tasks import _add_warnings_to_workflow_tasks
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2.task import TaskGroupV2
+from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.routes.auth._aux_auth import _get_default_usergroup_id
-from fractal_server.app.schemas.v2.task import TaskImportV2
+from fractal_server.app.schemas.v2 import TaskImportV2
 from fractal_server.logger import set_logger
 
 router = APIRouter()

fractal_server/app/routes/aux/_timestamp.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from datetime import timezone
+
+from fastapi import HTTPException
+from fastapi import status
+
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
+
+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

fractal_server/app/schemas/v2/__init__.py

@@ -23,10 +23,11 @@ from .task import TaskImportV2  # noqa F401
 from .task import TaskImportV2Legacy  # noqa F401
 from .task import TaskReadV2  # noqa F401
 from .task import TaskUpdateV2  # noqa F401
-from .task_collection import CollectionStateReadV2  # noqa F401
-from .task_collection import CollectionStatusV2  # noqa F401
 from .task_collection import TaskCollectCustomV2  # noqa F401
 from .task_collection import TaskCollectPipV2  # noqa F401
+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 TaskGroupReadV2  # noqa F401
 from .task_group import TaskGroupUpdateV2  # noqa F401

fractal_server/app/schemas/v2/task_collection.py

@@ -1,7 +1,4 @@
-from datetime import datetime
-from enum import Enum
 from pathlib import Path
-from typing import Any
 from typing import Literal
 from typing import Optional
 
@@ -11,19 +8,10 @@ from pydantic import root_validator
 from pydantic import validator
 
 from .._validators import valstr
-from fractal_server.app.schemas._validators import valutc
 from fractal_server.app.schemas.v2 import ManifestV2
 from fractal_server.string_tools import validate_cmd
 
 
-class CollectionStatusV2(str, Enum):
-    PENDING = "pending"
-    INSTALLING = "installing"
-    COLLECTING = "collecting"
-    FAIL = "fail"
-    OK = "OK"
-
-
 class TaskCollectPipV2(BaseModel, extra=Extra.forbid):
     """
     TaskCollectPipV2 class
@@ -191,12 +179,3 @@ class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
                 f"Python interpreter path must be absolute: (given {value})."
             )
         return value
-
-
-class CollectionStateReadV2(BaseModel):
-
-    id: Optional[int]
-    data: dict[str, Any]
-    timestamp: datetime
-
-    _timestamp = validator("timestamp", allow_reuse=True)(valutc("timestamp"))

fractal_server/app/schemas/v2/task_group.py

@@ -20,6 +20,19 @@ class TaskGroupV2OriginEnum(str, Enum):
     OTHER = "other"
 
 
+class TaskGroupActivityStatusV2(str, Enum):
+    PENDING = "pending"
+    ONGOING = "ongoing"
+    FAILED = "failed"
+    OK = "OK"
+
+
+class TaskGroupActivityActionV2(str, Enum):
+    COLLECT = "collect"
+    DEACTIVATE = "deactivate"
+    REACTIVATE = "reactivate"
+
+
 class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
     user_id: int
     user_group_id: Optional[int] = None
@@ -32,6 +45,7 @@ class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
     venv_path: Optional[str] = None
     wheel_path: Optional[str] = None
     pip_extras: Optional[str] = None
+    pip_freeze: Optional[str] = None
     pinned_package_versions: dict[str, str] = Field(default_factory=dict)
 
     # Validators
@@ -67,19 +81,29 @@ class TaskGroupReadV2(BaseModel):
     path: Optional[str] = None
     venv_path: Optional[str] = None
     wheel_path: Optional[str] = None
+    pip_freeze: Optional[str] = None
     pip_extras: Optional[str] = None
     pinned_package_versions: dict[str, str] = Field(default_factory=dict)
 
+    venv_size_in_kB: Optional[int] = None
+    venv_file_number: Optional[int] = None
+
     active: bool
     timestamp_created: datetime
 
 
 class TaskGroupUpdateV2(BaseModel, extra=Extra.forbid):
     user_group_id: Optional[int] = None
-    active: Optional[bool] = None
 
-    @validator("active")
-    def active_cannot_be_None(cls, value):
-        if value is None:
-            raise ValueError("`active` cannot be set to None")
-        return value
+
+class TaskGroupActivityV2Read(BaseModel):
+    id: int
+    user_id: int
+    taskgroupv2_id: Optional[int] = None
+    timestamp_started: datetime
+    timestamp_ended: Optional[datetime] = None
+    pkg_name: str
+    version: str
+    status: TaskGroupActivityStatusV2
+    action: TaskGroupActivityActionV2
+    log: Optional[str] = None