fractal-server 2.18.0__py3-none-any.whl → 2.18.0a0__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.18.0"
+__VERSION__ = "2.18.0a0"

fractal_server/__main__.py

@@ -167,8 +167,7 @@ def init_db_data(
             "`--admin-pwd` and `--admin-project-dir`. Exit."
         )
         sys.exit(1)
-
-    if admin_email:
+    if admin_password and admin_email:
         asyncio.run(
             _create_first_user(
                 email=admin_email,

fractal_server/app/models/security.py

@@ -6,6 +6,7 @@ from pydantic import EmailStr
 from sqlalchemy import Column
 from sqlalchemy import String
 from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
 from sqlmodel import Field
 from sqlmodel import Relationship
@@ -112,13 +113,7 @@ class UserOAuth(SQLModel, table=True):
         ondelete="RESTRICT",
     )
 
-    # TODO-2.18.1: drop `project_dir`
-    project_dir: str | None = Field(default=None, nullable=True)
-    # TODO-2.18.1: `project_dirs: list[str] = Field(min_length=1)`
-    project_dirs: list[str] = Field(
-        sa_column=Column(ARRAY(String), nullable=False, server_default="{}"),
-    )
-
+    project_dir: str
     slurm_accounts: list[str] = Field(
         sa_column=Column(ARRAY(String), server_default="{}"),
     )
@@ -140,3 +135,6 @@ class UserGroup(SQLModel, table=True):
         default_factory=get_timestamp,
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
+    viewer_paths: list[str] = Field(
+        sa_column=Column(JSONB, server_default="[]", nullable=False)
+    )

fractal_server/app/models/v2/job.py

@@ -6,11 +6,9 @@ from sqlalchemy import Column
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
 from sqlmodel import Field
-from sqlmodel import Index
 from sqlmodel import SQLModel
-from sqlmodel import text
 
-from fractal_server.app.schemas.v2 import JobStatusType
+from fractal_server.app.schemas.v2 import JobStatusTypeV2
 from fractal_server.utils import get_timestamp
 
 
@@ -58,7 +56,7 @@ class JobV2(SQLModel, table=True):
     end_timestamp: datetime | None = Field(
         default=None, sa_column=Column(DateTime(timezone=True))
     )
-    status: str = JobStatusType.SUBMITTED
+    status: str = JobStatusTypeV2.SUBMITTED
     log: str | None = None
     executor_error_log: str | None = None
 
@@ -68,12 +66,3 @@ class JobV2(SQLModel, table=True):
     type_filters: dict[str, bool] = Field(
         sa_column=Column(JSONB, nullable=False, server_default="{}")
     )
-
-    __table_args__ = (
-        Index(
-            "ix_jobv2_one_submitted_job_per_dataset",
-            "dataset_id",
-            unique=True,
-            postgresql_where=text(f"status = '{JobStatusType.SUBMITTED}'"),
-        ),
-    )

fractal_server/app/models/v2/resource.py

@@ -5,7 +5,6 @@ from typing import Self
 from sqlalchemy import Column
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.types import DateTime
-from sqlmodel import BOOLEAN
 from sqlmodel import CheckConstraint
 from sqlmodel import Field
 from sqlmodel import SQLModel
@@ -44,18 +43,6 @@ class Resource(SQLModel, table=True):
     Address for ssh connections, when `type="slurm_ssh"`.
     """
 
-    prevent_new_submissions: bool = Field(
-        sa_column=Column(
-            BOOLEAN,
-            server_default="false",
-            nullable=False,
-        ),
-    )
-    """
-    When set to true: Prevent new job submissions and stop execution of
-    ongoing jobs as soon as the current task is complete.
-    """
-
     jobs_local_dir: str
     """
     Base local folder for job subfolders (containing artifacts and logs).

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

@@ -14,14 +14,16 @@ 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 = APIRouter()
+router_admin_v2 = APIRouter()
 
-router_admin.include_router(accounting_router, prefix="/accounting")
-router_admin.include_router(job_router, prefix="/job")
-router_admin.include_router(task_router, prefix="/task")
-router_admin.include_router(task_group_router, prefix="/task-group")
-router_admin.include_router(task_group_lifecycle_router, prefix="/task-group")
-router_admin.include_router(impersonate_router, prefix="/impersonate")
-router_admin.include_router(resource_router, prefix="/resource")
-router_admin.include_router(profile_router, prefix="/profile")
-router_admin.include_router(sharing_router, prefix="/linkuserproject")
+router_admin_v2.include_router(accounting_router, prefix="/accounting")
+router_admin_v2.include_router(job_router, prefix="/job")
+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"
+)
+router_admin_v2.include_router(impersonate_router, prefix="/impersonate")
+router_admin_v2.include_router(resource_router, prefix="/resource")
+router_admin_v2.include_router(profile_router, prefix="/profile")
+router_admin_v2.include_router(sharing_router, prefix="/linkuserproject")

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

@@ -67,11 +67,11 @@ async def query_accounting(
     res = await db.execute(stm)
     records = res.scalars().all()
 
-    return dict(
+    return PaginationResponse[AccountingRecordRead](
         total_count=total_count,
         page_size=page_size,
         current_page=page,
-        items=records,
+        items=[record.model_dump() for record in records],
     )
 
 

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

@@ -24,9 +24,9 @@ from fractal_server.app.routes.pagination import PaginationRequest
 from fractal_server.app.routes.pagination import PaginationResponse
 from fractal_server.app.routes.pagination import get_pagination_params
 from fractal_server.app.schemas.v2 import HistoryUnitStatus
-from fractal_server.app.schemas.v2 import JobRead
-from fractal_server.app.schemas.v2 import JobStatusType
-from fractal_server.app.schemas.v2 import JobUpdate
+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.runner.filenames import WORKFLOW_LOG_FILENAME
 from fractal_server.utils import get_timestamp
 from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
@@ -34,14 +34,14 @@ from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 router = APIRouter()
 
 
-@router.get("/", response_model=PaginationResponse[JobRead])
+@router.get("/", response_model=PaginationResponse[JobReadV2])
 async def view_job(
     id: int | None = None,
     user_id: int | None = None,
     project_id: int | None = None,
     dataset_id: int | None = None,
     workflow_id: int | None = None,
-    status: JobStatusType | None = None,
+    status: JobStatusTypeV2 | None = None,
     start_timestamp_min: AwareDatetime | None = None,
     start_timestamp_max: AwareDatetime | None = None,
     end_timestamp_min: AwareDatetime | None = None,
@@ -50,7 +50,7 @@ async def view_job(
     pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[JobRead]:
+) -> PaginationResponse[JobReadV2]:
     """
     Query `JobV2` table.
 
@@ -146,21 +146,21 @@ async def view_job(
         for job in job_list:
             setattr(job, "log", None)
 
-    return dict(
+    return PaginationResponse[JobReadV2](
         total_count=total_count,
         page_size=page_size,
         current_page=page,
-        items=job_list,
+        items=[job.model_dump() for job in job_list],
     )
 
 
-@router.get("/{job_id}/", response_model=JobRead)
+@router.get("/{job_id}/", response_model=JobReadV2)
 async def view_single_job(
     job_id: int,
     show_tmp_logs: bool = False,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> JobRead:
+) -> JobReadV2:
     job = await db.get(JobV2, job_id)
     if not job:
         raise HTTPException(
@@ -169,7 +169,7 @@ async def view_single_job(
         )
     await db.close()
 
-    if show_tmp_logs and (job.status == JobStatusType.SUBMITTED):
+    if show_tmp_logs and (job.status == JobStatusTypeV2.SUBMITTED):
         try:
             with open(f"{job.working_dir}/{WORKFLOW_LOG_FILENAME}") as f:
                 job.log = f.read()
@@ -179,13 +179,13 @@ async def view_single_job(
     return job
 
 
-@router.patch("/{job_id}/", response_model=JobRead)
+@router.patch("/{job_id}/", response_model=JobReadV2)
 async def update_job(
-    job_update: JobUpdate,
+    job_update: JobUpdateV2,
     job_id: int,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> JobRead | None:
+) -> JobReadV2 | None:
     """
     Change the status of an existing job.
 
@@ -198,13 +198,13 @@ async def update_job(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"Job {job_id} not found",
         )
-    if job.status != JobStatusType.SUBMITTED:
+    if job.status != JobStatusTypeV2.SUBMITTED:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=f"Job {job_id} has status {job.status=} != 'submitted'.",
         )
 
-    if job_update.status != JobStatusType.FAILED:
+    if job_update.status != JobStatusTypeV2.FAILED:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=f"Cannot set job status to {job_update.status}",
@@ -217,7 +217,7 @@ async def update_job(
         job,
         "log",
         f"{job.log or ''}\nThis job was manually marked as "
-        f"'{JobStatusType.FAILED}' by an admin ({timestamp.isoformat()}).",
+        f"'{JobStatusTypeV2.FAILED}' by an admin ({timestamp.isoformat()}).",
     )
 
     res = await db.execute(

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

@@ -23,7 +23,7 @@ from fractal_server.app.schemas.v2.task import TaskType
 router = APIRouter()
 
 
-class TaskMinimal(BaseModel):
+class TaskV2Minimal(BaseModel):
     id: int
     name: str
     type: str
@@ -39,7 +39,7 @@ class ProjectUser(BaseModel):
     email: EmailStr
 
 
-class TaskRelationship(BaseModel):
+class TaskV2Relationship(BaseModel):
     workflow_id: int
     workflow_name: str
     project_id: int
@@ -47,12 +47,12 @@ class TaskRelationship(BaseModel):
     project_users: list[ProjectUser] = Field(default_factory=list)
 
 
-class TaskInfo(BaseModel):
-    task: TaskMinimal
-    relationships: list[TaskRelationship]
+class TaskV2Info(BaseModel):
+    task: TaskV2Minimal
+    relationships: list[TaskV2Relationship]
 
 
-@router.get("/", response_model=PaginationResponse[TaskInfo])
+@router.get("/", response_model=PaginationResponse[TaskV2Info])
 async def query_tasks(
     id: int | None = None,
     source: str | None = None,
@@ -66,7 +66,7 @@ async def query_tasks(
     pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[TaskInfo]:
+) -> PaginationResponse[TaskV2Info]:
     """
     Query `TaskV2` and get information about related workflows and projects.
     """
@@ -170,7 +170,7 @@ async def query_tasks(
                 ],
             )
         )
-    return dict(
+    return PaginationResponse[TaskV2Info](
         total_count=total_count,
         page_size=page_size,
         current_page=page,

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

@@ -5,7 +5,6 @@ from fastapi import status
 from pydantic.types import AwareDatetime
 from sqlalchemy.sql.operators import is_
 from sqlalchemy.sql.operators import is_not
-from sqlmodel import func
 from sqlmodel import select
 
 from fractal_server.app.db import AsyncSession
@@ -17,15 +16,12 @@ from fractal_server.app.routes.auth import current_superuser_act
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
-from fractal_server.app.routes.pagination import PaginationRequest
-from fractal_server.app.routes.pagination import PaginationResponse
-from fractal_server.app.routes.pagination import get_pagination_params
-from fractal_server.app.schemas.v2 import TaskGroupActivityAction
-from fractal_server.app.schemas.v2 import TaskGroupActivityRead
-from fractal_server.app.schemas.v2 import TaskGroupActivityStatus
-from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
+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 TaskGroupReadSuperuser
-from fractal_server.app.schemas.v2 import TaskGroupUpdate
+from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
+from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.logger import set_logger
 
 router = APIRouter()
@@ -33,78 +29,39 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-@router.get(
-    "/activity/", response_model=PaginationResponse[TaskGroupActivityRead]
-)
+@router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
 async def get_task_group_activity_list(
     task_group_activity_id: int | None = None,
     user_id: int | None = None,
     taskgroupv2_id: int | None = None,
     pkg_name: str | None = None,
-    status: TaskGroupActivityStatus | None = None,
-    action: TaskGroupActivityAction | None = None,
+    status: TaskGroupActivityStatusV2 | None = None,
+    action: TaskGroupActivityActionV2 | None = None,
     timestamp_started_min: AwareDatetime | None = None,
-    pagination: PaginationRequest = Depends(get_pagination_params),
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[TaskGroupActivityRead]:
-    # Assign pagination parameters
-    page = pagination.page
-    page_size = pagination.page_size
-
-    stm = select(TaskGroupActivityV2).order_by(
-        TaskGroupActivityV2.timestamp_started.desc()
-    )
-    stm_count = select(func.count(TaskGroupActivityV2.id))
+) -> list[TaskGroupActivityV2Read]:
+    stm = select(TaskGroupActivityV2)
     if task_group_activity_id is not None:
         stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
-        stm_count = stm_count.where(
-            TaskGroupActivityV2.id == task_group_activity_id
-        )
     if user_id:
         stm = stm.where(TaskGroupActivityV2.user_id == user_id)
-        stm_count = stm_count.where(TaskGroupActivityV2.user_id == user_id)
     if taskgroupv2_id:
         stm = stm.where(TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id)
-        stm_count = stm_count.where(
-            TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id
-        )
     if pkg_name:
         stm = stm.where(TaskGroupActivityV2.pkg_name.icontains(pkg_name))
-        stm_count = stm_count.where(
-            TaskGroupActivityV2.pkg_name.icontains(pkg_name)
-        )
     if status:
         stm = stm.where(TaskGroupActivityV2.status == status)
-        stm_count = stm_count.where(TaskGroupActivityV2.status == status)
     if action:
         stm = stm.where(TaskGroupActivityV2.action == action)
-        stm_count = stm_count.where(TaskGroupActivityV2.action == action)
     if timestamp_started_min is not None:
         stm = stm.where(
             TaskGroupActivityV2.timestamp_started >= timestamp_started_min
         )
-        stm_count = stm_count.where(
-            TaskGroupActivityV2.timestamp_started >= timestamp_started_min
-        )
-
-    # Find total number of elements
-    res_total_count = await db.execute(stm_count)
-    total_count = res_total_count.scalar()
-    if page_size is None:
-        page_size = total_count
-    else:
-        stm = stm.offset((page - 1) * page_size).limit(page_size)
 
     res = await db.execute(stm)
     activities = res.scalars().all()
-
-    return dict(
-        total_count=total_count,
-        page_size=page_size,
-        current_page=page,
-        items=activities,
-    )
+    return activities
 
 
 @router.get("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
@@ -122,27 +79,21 @@ async def query_task_group(
     return task_group
 
 
-@router.get("/", response_model=PaginationResponse[TaskGroupReadSuperuser])
+@router.get("/", response_model=list[TaskGroupReadSuperuser])
 async def query_task_group_list(
     user_id: int | None = None,
     user_group_id: int | None = None,
     private: bool | None = None,
     active: bool | None = None,
     pkg_name: str | None = None,
-    origin: TaskGroupOriginEnum | None = None,
+    origin: TaskGroupV2OriginEnum | None = None,
     timestamp_last_used_min: AwareDatetime | None = None,
     timestamp_last_used_max: AwareDatetime | None = None,
     resource_id: int | None = None,
-    pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> PaginationResponse[TaskGroupReadSuperuser]:
-    # Assign pagination parameters
-    page = pagination.page
-    page_size = pagination.page_size
-
+) -> list[TaskGroupReadSuperuser]:
     stm = select(TaskGroupV2)
-    stm_count = select(func.count(TaskGroupV2.id))
 
     if user_group_id is not None and private is True:
         raise HTTPException(
@@ -154,72 +105,43 @@ async def query_task_group_list(
         )
     if user_id is not None:
         stm = stm.where(TaskGroupV2.user_id == user_id)
-        stm_count = stm_count.where(TaskGroupV2.user_id == user_id)
     if user_group_id is not None:
         stm = stm.where(TaskGroupV2.user_group_id == user_group_id)
-        stm_count = stm_count.where(TaskGroupV2.user_group_id == user_group_id)
     if private is not None:
         if private is True:
             stm = stm.where(is_(TaskGroupV2.user_group_id, None))
-            stm_count = stm_count.where(is_(TaskGroupV2.user_group_id, None))
         else:
             stm = stm.where(is_not(TaskGroupV2.user_group_id, None))
-            stm_count = stm_count.where(is_not(TaskGroupV2.user_group_id, None))
     if active is not None:
         if active is True:
             stm = stm.where(is_(TaskGroupV2.active, True))
-            stm_count = stm_count.where(is_(TaskGroupV2.active, True))
         else:
             stm = stm.where(is_(TaskGroupV2.active, False))
-            stm_count = stm_count.where(is_(TaskGroupV2.active, False))
     if origin is not None:
         stm = stm.where(TaskGroupV2.origin == origin)
-        stm_count = stm_count.where(TaskGroupV2.origin == origin)
     if pkg_name is not None:
         stm = stm.where(TaskGroupV2.pkg_name.icontains(pkg_name))
-        stm_count = stm_count.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
         )
-        stm_count = stm_count.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
         )
-        stm_count = stm_count.where(
-            TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
-        )
     if resource_id is not None:
         stm = stm.where(TaskGroupV2.resource_id == resource_id)
-        stm_count = stm_count.where(TaskGroupV2.resource_id == resource_id)
-
-    # Find total number of elements
-    res_total_count = await db.execute(stm_count)
-    total_count = res_total_count.scalar()
-    if page_size is None:
-        page_size = total_count
-    else:
-        stm = stm.offset((page - 1) * page_size).limit(page_size)
 
     stm = stm.order_by(TaskGroupV2.id)
     res = await db.execute(stm)
     task_groups_list = res.scalars().all()
-
-    return dict(
-        total_count=total_count,
-        page_size=page_size,
-        current_page=page,
-        items=task_groups_list,
-    )
+    return task_groups_list
 
 
 @router.patch("/{task_group_id}/", response_model=TaskGroupReadSuperuser)
 async def patch_task_group(
     task_group_id: int,
-    task_group_update: TaskGroupUpdate,
+    task_group_update: TaskGroupUpdateV2,
     user: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupReadSuperuser]:

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

@@ -26,10 +26,10 @@ from fractal_server.app.routes.aux.validate_user_profile import (
     validate_user_profile,
 )
 from fractal_server.app.schemas.v2 import ResourceType
-from fractal_server.app.schemas.v2 import TaskGroupActivityAction
-from fractal_server.app.schemas.v2 import TaskGroupActivityRead
-from fractal_server.app.schemas.v2 import TaskGroupActivityStatus
-from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
+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 TaskGroupV2OriginEnum
 from fractal_server.logger import set_logger
 from fractal_server.tasks.v2.local import deactivate_local
 from fractal_server.tasks.v2.local import delete_local
@@ -46,7 +46,7 @@ logger = set_logger(__name__)
 
 @router.post(
     "/{task_group_id}/deactivate/",
-    response_model=TaskGroupActivityRead,
+    response_model=TaskGroupActivityV2Read,
 )
 async def deactivate_task_group(
     task_group_id: int,
@@ -54,7 +54,7 @@ async def deactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupActivityRead:
+) -> TaskGroupActivityV2Read:
     """
     Deactivate task-group venv
     """
@@ -78,13 +78,13 @@ async def deactivate_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 == TaskGroupOriginEnum.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=TaskGroupActivityStatus.OK,
-            action=TaskGroupActivityAction.DEACTIVATE,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.DEACTIVATE,
             pkg_name=task_group.pkg_name,
             version=(task_group.version or "N/A"),
             log=(
@@ -103,8 +103,8 @@ async def deactivate_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatus.PENDING,
-        action=TaskGroupActivityAction.DEACTIVATE,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.DEACTIVATE,
         pkg_name=task_group.pkg_name,
         version=task_group.version,
         timestamp_started=get_timestamp(),
@@ -140,7 +140,7 @@ async def deactivate_task_group(
 
 @router.post(
     "/{task_group_id}/reactivate/",
-    response_model=TaskGroupActivityRead,
+    response_model=TaskGroupActivityV2Read,
 )
 async def reactivate_task_group(
     task_group_id: int,
@@ -148,7 +148,7 @@ async def reactivate_task_group(
     response: Response,
     superuser: UserOAuth = Depends(current_superuser_act),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupActivityRead:
+) -> TaskGroupActivityV2Read:
     """
     Deactivate task-group venv
     """
@@ -173,13 +173,13 @@ async def reactivate_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 == TaskGroupOriginEnum.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=TaskGroupActivityStatus.OK,
-            action=TaskGroupActivityAction.REACTIVATE,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.REACTIVATE,
             pkg_name=task_group.pkg_name,
             version=(task_group.version or "N/A"),
             log=(
@@ -206,8 +206,8 @@ async def reactivate_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatus.PENDING,
-        action=TaskGroupActivityAction.REACTIVATE,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.REACTIVATE,
         pkg_name=task_group.pkg_name,
         version=task_group.version,
         timestamp_started=get_timestamp(),
@@ -259,8 +259,8 @@ async def delete_task_group(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatus.PENDING,
-        action=TaskGroupActivityAction.DELETE,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.DELETE,
         pkg_name=task_group.pkg_name,
         version=(task_group.version or "N/A"),
         timestamp_started=get_timestamp(),

fractal_server/app/routes/api/__init__.py

@@ -8,6 +8,7 @@ from fastapi import Depends
 import fractal_server
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_superuser_act
+from fractal_server.config import get_data_settings
 from fractal_server.config import get_db_settings
 from fractal_server.config import get_email_settings
 from fractal_server.config import get_oauth_settings
@@ -49,6 +50,14 @@ async def view_email_settings(
     return settings.model_dump()
 
 
+@router_api.get("/settings/data/")
+async def view_data_settings(
+    user: UserOAuth = Depends(current_superuser_act),
+):
+    settings = Inject(get_data_settings)
+    return settings.model_dump()
+
+
 @router_api.get("/settings/oauth/")
 async def view_oauth_settings(
     user: UserOAuth = Depends(current_superuser_act),