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

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

@@ -1,20 +1,19 @@
 from fastapi import APIRouter
 from fastapi import Depends
-from fastapi import HTTPException
-from fastapi import status
 
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.routes.auth import current_user_act_ver_prof
-from fractal_server.app.schemas.v2.status_legacy import LegacyStatusReadV2
-from fractal_server.app.schemas.v2.status_legacy import WorkflowTaskStatusTypeV2
+from fractal_server.app.schemas.v2.sharing import ProjectPermissions
+from fractal_server.app.schemas.v2.status_legacy import LegacyStatusRead
+from fractal_server.app.schemas.v2.status_legacy import WorkflowTaskStatusType
 from fractal_server.logger import set_logger
 
-from ._aux_functions import _get_dataset_check_owner
+from ._aux_functions import _get_dataset_check_access
 from ._aux_functions import _get_submitted_jobs_statement
-from ._aux_functions import _get_workflow_check_owner
+from ._aux_functions import _get_workflow_check_access
 
 router = APIRouter()
 
@@ -23,7 +22,7 @@ logger = set_logger(__name__)
 
 @router.get(
     "/project/{project_id}/status-legacy/",
-    response_model=LegacyStatusReadV2,
+    response_model=LegacyStatusRead,
 )
 async def get_workflowtask_status(
     project_id: int,
@@ -31,7 +30,7 @@ async def get_workflowtask_status(
     workflow_id: int,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> LegacyStatusReadV2 | None:
+) -> LegacyStatusRead | None:
     """
     Extract the status of all `WorkflowTaskV2` of a given `WorkflowV2` that ran
     on a given `DatasetV2`.
@@ -42,43 +41,33 @@ async def get_workflowtask_status(
     order). See fractal-server GitHub issues: 793, 1083.
     """
     # Get the dataset DB entry
-    output = await _get_dataset_check_owner(
+    output = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.READ,
         db=db,
     )
     dataset = output["dataset"]
 
     # Get the workflow DB entry
-    workflow = await _get_workflow_check_owner(
+    workflow = await _get_workflow_check_access(
         project_id=project_id,
         workflow_id=workflow_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.READ,
         db=db,
     )
 
     # Check whether there exists a submitted job associated to this
     # workflow/dataset pair. If it does exist, it will be used later.
     # If there are multiple jobs, raise an error.
-    stm = _get_submitted_jobs_statement()
-    stm = stm.where(JobV2.dataset_id == dataset_id)
-    stm = stm.where(JobV2.workflow_id == workflow_id)
-    res = await db.execute(stm)
-    running_jobs = res.scalars().all()
-    if len(running_jobs) == 0:
-        running_job = None
-    elif len(running_jobs) == 1:
-        running_job = running_jobs[0]
-    else:
-        string_ids = str([job.id for job in running_jobs])[1:-1]
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=(
-                f"Cannot get WorkflowTaskV2 statuses as DatasetV2 {dataset.id}"
-                f" is linked to multiple active jobs: {string_ids}."
-            ),
-        )
+    res = await db.execute(
+        _get_submitted_jobs_statement()
+        .where(JobV2.dataset_id == dataset_id)
+        .where(JobV2.workflow_id == workflow_id)
+    )
+    running_job = res.scalars().one_or_none()
 
     # Initialize empty dictionary for WorkflowTaskV2 status
     workflow_tasks_status_dict: dict = {}
@@ -113,18 +102,18 @@ async def get_workflowtask_status(
         ]
         try:
             first_submitted_index = running_job_statuses.index(
-                WorkflowTaskStatusTypeV2.SUBMITTED
+                WorkflowTaskStatusType.SUBMITTED
             )
         except ValueError:
             logger.warning(
                 f"Job {running_job.id} is submitted but its task list does not"
-                f" contain a {WorkflowTaskStatusTypeV2.SUBMITTED} task."
+                f" contain a {WorkflowTaskStatusType.SUBMITTED} task."
             )
             first_submitted_index = 0
 
         for wftask in running_job_wftasks[first_submitted_index:]:
             workflow_tasks_status_dict[wftask.id] = (
-                WorkflowTaskStatusTypeV2.SUBMITTED
+                WorkflowTaskStatusType.SUBMITTED
             )
 
         # The last workflow task that is included in the submitted job is also
@@ -154,7 +143,7 @@ async def get_workflowtask_status(
             # If a wftask ID was not found, ignore it and continue
             continue
         clean_workflow_tasks_status_dict[str(wf_task.id)] = wf_task_status
-        if wf_task_status == WorkflowTaskStatusTypeV2.FAILED:
+        if wf_task_status == WorkflowTaskStatusType.FAILED:
             # Starting from the beginning of `workflow.task_list`, stop the
             # first time that you hit a failed job
             break
@@ -163,5 +152,5 @@ async def get_workflowtask_status(
             # first time that you hit `last_valid_wftask_id``
             break
 
-    response_body = LegacyStatusReadV2(status=clean_workflow_tasks_status_dict)
+    response_body = LegacyStatusRead(status=clean_workflow_tasks_status_dict)
     return response_body

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

@@ -9,6 +9,7 @@ from fastapi import HTTPException
 from fastapi import Request
 from fastapi import status
 from sqlmodel import select
+from sqlmodel import update
 
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
@@ -23,10 +24,11 @@ from fractal_server.app.routes.auth import current_user_act_ver_prof
 from fractal_server.app.routes.aux.validate_user_profile import (
     validate_user_profile,
 )
-from fractal_server.app.schemas.v2 import JobCreateV2
-from fractal_server.app.schemas.v2 import JobReadV2
-from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.app.schemas.v2 import JobCreate
+from fractal_server.app.schemas.v2 import JobRead
+from fractal_server.app.schemas.v2 import JobStatusType
 from fractal_server.app.schemas.v2 import ResourceType
+from fractal_server.app.schemas.v2.sharing import ProjectPermissions
 from fractal_server.config import get_settings
 from fractal_server.logger import set_logger
 from fractal_server.runner.set_start_and_last_task_index import (
@@ -35,9 +37,9 @@ from fractal_server.runner.set_start_and_last_task_index import (
 from fractal_server.runner.v2.submit_workflow import submit_workflow
 from fractal_server.syringe import Inject
 
-from ._aux_functions import _get_dataset_check_owner
-from ._aux_functions import _get_workflow_check_owner
-from ._aux_functions import clean_app_job_list_v2
+from ._aux_functions import _get_dataset_check_access
+from ._aux_functions import _get_workflow_check_access
+from ._aux_functions import clean_app_job_list
 from ._aux_functions_tasks import _check_type_filters_compatibility
 
 FRACTAL_CACHE_DIR = ".fractal_cache"
@@ -48,34 +50,33 @@ logger = set_logger(__name__)
 @router.post(
     "/project/{project_id}/job/submit/",
     status_code=status.HTTP_202_ACCEPTED,
-    response_model=JobReadV2,
+    response_model=JobRead,
 )
-async def apply_workflow(
+async def submit_job(
     project_id: int,
     workflow_id: int,
     dataset_id: int,
-    job_create: JobCreateV2,
+    job_create: JobCreate,
     background_tasks: BackgroundTasks,
     request: Request,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> JobReadV2 | None:
-    # Remove non-submitted V2 jobs from the app state when the list grows
+) -> JobRead | None:
+    # Remove non-submitted Jobs from the app state when the list grows
     # beyond a threshold
-    # NOTE: this may lead to a race condition on `app.state.jobsV2` if two
-    # requests take place at the same time and `clean_app_job_list_v2` is
+    # NOTE: this may lead to a race condition on `app.state.jobs` if two
+    # requests take place at the same time and `clean_app_job_list` is
     # somewhat slow.
     settings = Inject(get_settings)
-    if len(request.app.state.jobsV2) > settings.FRACTAL_API_MAX_JOB_LIST_LENGTH:
-        new_jobs_list = await clean_app_job_list_v2(
-            db, request.app.state.jobsV2
-        )
-        request.app.state.jobsV2 = new_jobs_list
+    if len(request.app.state.jobs) > settings.FRACTAL_API_MAX_JOB_LIST_LENGTH:
+        new_jobs_list = await clean_app_job_list(db, request.app.state.jobs)
+        request.app.state.jobs = new_jobs_list
 
-    output = await _get_dataset_check_owner(
+    output = await _get_dataset_check_access(
         project_id=project_id,
         dataset_id=dataset_id,
         user_id=user.id,
+        required_permissions=ProjectPermissions.EXECUTE,
         db=db,
     )
     project = output["project"]
@@ -92,8 +93,12 @@ async def apply_workflow(
             detail="Project resource does not match with user's resource",
         )
 
-    workflow = await _get_workflow_check_owner(
-        project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
+    workflow = await _get_workflow_check_access(
+        project_id=project_id,
+        workflow_id=workflow_id,
+        user_id=user.id,
+        required_permissions=ProjectPermissions.EXECUTE,
+        db=db,
     )
     num_tasks = len(workflow.task_list)
     if num_tasks == 0:
@@ -141,35 +146,15 @@ async def apply_workflow(
         user=user,
         db=db,
     )
-
-    # Check that no other job with the same dataset_id is SUBMITTED
-    stm = (
-        select(JobV2)
-        .where(JobV2.dataset_id == dataset_id)
-        .where(JobV2.status == JobStatusTypeV2.SUBMITTED)
-    )
-    res = await db.execute(stm)
-    if res.scalars().all():
+    if resource.prevent_new_submissions:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=(
-                f"Dataset {dataset_id} is already in use in submitted job(s)."
+                f"The '{resource.name}' resource does not currently accept "
+                "new job submissions."
             ),
         )
 
-    if job_create.slurm_account is not None:
-        if job_create.slurm_account not in user.slurm_accounts:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-                detail=(
-                    f"SLURM account '{job_create.slurm_account}' is not "
-                    "among those available to the current user"
-                ),
-            )
-    else:
-        if len(user.slurm_accounts) > 0:
-            job_create.slurm_account = user.slurm_accounts[0]
-
     # User appropriate FractalSSH object
     if resource.type == ResourceType.SLURM_SSH:
         ssh_config = dict(
@@ -192,6 +177,35 @@ async def apply_workflow(
     else:
         fractal_ssh = None
 
+    # Assign `job_create.slurm_account`
+    if job_create.slurm_account is not None:
+        if job_create.slurm_account not in user.slurm_accounts:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                detail=(
+                    f"SLURM account '{job_create.slurm_account}' is not "
+                    "among those available to the current user"
+                ),
+            )
+    else:
+        if len(user.slurm_accounts) > 0:
+            job_create.slurm_account = user.slurm_accounts[0]
+
+    # Check that no other job with the same dataset_id is SUBMITTED
+    stm = (
+        select(JobV2)
+        .where(JobV2.dataset_id == dataset_id)
+        .where(JobV2.status == JobStatusType.SUBMITTED)
+    )
+    res = await db.execute(stm)
+    if res.scalars().all():
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"Dataset {dataset_id} is already in use in submitted job(s)."
+            ),
+        )
+
     # Add new Job object to DB
     job = JobV2(
         project_id=project_id,
@@ -215,38 +229,31 @@ async def apply_workflow(
     await db.refresh(job)
 
     # Update TaskGroupV2.timestamp_last_used
-    res = await db.execute(
-        select(TaskGroupV2).where(TaskGroupV2.id.in_(used_task_group_ids))
+    await db.execute(
+        update(TaskGroupV2)
+        .where(TaskGroupV2.id.in_(used_task_group_ids))
+        .values(timestamp_last_used=job.start_timestamp)
     )
-    used_task_groups = res.scalars().all()
-    for used_task_group in used_task_groups:
-        used_task_group.timestamp_last_used = job.start_timestamp
-        db.add(used_task_group)
     await db.commit()
 
-    # Define server-side job directory
-    timestamp_string = job.start_timestamp.strftime("%Y%m%d_%H%M%S")
-    WORKFLOW_DIR_LOCAL = Path(resource.jobs_local_dir) / (
+    # Define `cache_dir`
+    cache_dir = Path(user.project_dirs[0], FRACTAL_CACHE_DIR)
+
+    # Define server-side and user-side job directories
+    timestamp_string = job.start_timestamp.strftime(r"%Y%m%d_%H%M%S")
+    working_dir = Path(resource.jobs_local_dir) / (
         f"proj_v2_{project_id:07d}_wf_{workflow_id:07d}_job_{job.id:07d}"
         f"_{timestamp_string}"
     )
-
-    # Define user-side job directory
-    cache_dir = Path(user.project_dir, FRACTAL_CACHE_DIR)
     match resource.type:
         case ResourceType.LOCAL:
-            WORKFLOW_DIR_REMOTE = WORKFLOW_DIR_LOCAL
+            working_dir_user = working_dir
         case ResourceType.SLURM_SUDO:
-            WORKFLOW_DIR_REMOTE = cache_dir / WORKFLOW_DIR_LOCAL.name
+            working_dir_user = cache_dir / working_dir.name
         case ResourceType.SLURM_SSH:
-            WORKFLOW_DIR_REMOTE = Path(
-                profile.jobs_remote_dir,
-                WORKFLOW_DIR_LOCAL.name,
-            )
-
-    # Update job folders in the db
-    job.working_dir = WORKFLOW_DIR_LOCAL.as_posix()
-    job.working_dir_user = WORKFLOW_DIR_REMOTE.as_posix()
+            working_dir_user = Path(profile.jobs_remote_dir, working_dir.name)
+    job.working_dir = working_dir.as_posix()
+    job.working_dir_user = working_dir_user.as_posix()
     await db.merge(job)
     await db.commit()
 
@@ -262,11 +269,9 @@ async def apply_workflow(
         resource=resource,
         profile=profile,
     )
-    request.app.state.jobsV2.append(job.id)
+    request.app.state.jobs.append(job.id)
     logger.info(
-        f"Current worker's pid is {os.getpid()}. "
-        f"Current status of worker job's list "
-        f"{request.app.state.jobsV2}"
+        f"Job {job.id}, worker with pid {os.getpid()}. "
+        f"Worker jobs list: {request.app.state.jobs}."
     )
-    await db.close()
     return job

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

@@ -25,11 +25,11 @@ from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.routes.auth import current_user_act_ver_prof
-from fractal_server.app.schemas.v2 import TaskCreateV2
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.app.schemas.v2 import TaskReadV2
+from fractal_server.app.schemas.v2 import TaskCreate
+from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
+from fractal_server.app.schemas.v2 import TaskRead
 from fractal_server.app.schemas.v2 import TaskType
-from fractal_server.app.schemas.v2 import TaskUpdateV2
+from fractal_server.app.schemas.v2 import TaskUpdate
 from fractal_server.logger import set_logger
 
 router = APIRouter()
@@ -37,7 +37,7 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-@router.get("/", response_model=list[TaskReadV2])
+@router.get("/", response_model=list[TaskRead])
 async def get_list_task(
     args_schema: bool = True,
     category: str | None = None,
@@ -45,7 +45,7 @@ async def get_list_task(
     author: str | None = None,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskReadV2]:
+) -> list[TaskRead]:
     """
     Get list of available tasks
     """
@@ -86,12 +86,12 @@ async def get_list_task(
     return task_list
 
 
-@router.get("/{task_id}/", response_model=TaskReadV2)
+@router.get("/{task_id}/", response_model=TaskRead)
 async def get_task(
     task_id: int,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskReadV2:
+) -> TaskRead:
     """
     Get info on a specific task
     """
@@ -99,13 +99,13 @@ async def get_task(
     return task
 
 
-@router.patch("/{task_id}/", response_model=TaskReadV2)
+@router.patch("/{task_id}/", response_model=TaskRead)
 async def patch_task(
     task_id: int,
-    task_update: TaskUpdateV2,
+    task_update: TaskUpdate,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskReadV2 | None:
+) -> TaskRead | None:
     """
     Edit a specific task (restricted to task owner)
     """
@@ -137,16 +137,14 @@ async def patch_task(
     return db_task
 
 
-@router.post(
-    "/", response_model=TaskReadV2, status_code=status.HTTP_201_CREATED
-)
+@router.post("/", response_model=TaskRead, status_code=status.HTTP_201_CREATED)
 async def create_task(
-    task: TaskCreateV2,
+    task: TaskCreate,
     user_group_id: int | None = None,
     private: bool = False,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskReadV2 | None:
+) -> TaskRead | None:
     """
     Create a new task
     """
@@ -211,7 +209,7 @@ async def create_task(
         resource_id=resource_id,
         active=True,
         task_list=[db_task],
-        origin=TaskGroupV2OriginEnum.OTHER,
+        origin=TaskGroupOriginEnum.OTHER,
         version=db_task.version,
         pkg_name=pkg_name,
     )

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

@@ -25,12 +25,12 @@ from fractal_server.app.routes.aux.validate_user_profile import (
 )
 from fractal_server.app.schemas.v2 import FractalUploadedFile
 from fractal_server.app.schemas.v2 import ResourceType
-from fractal_server.app.schemas.v2 import TaskCollectPipV2
-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 TaskGroupCreateV2Strict
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
+from fractal_server.app.schemas.v2 import TaskCollectPip
+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 TaskGroupCreateStrict
+from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
 from fractal_server.logger import reset_logger_handlers
 from fractal_server.logger import set_logger
 from fractal_server.tasks.v2.local.collect import collect_local
@@ -59,9 +59,9 @@ class CollectionRequestData(BaseModel):
     Validate form data _and_ wheel file.
     """
 
-    task_collect: TaskCollectPipV2
+    task_collect: TaskCollectPip
     file: UploadFile | None = None
-    origin: TaskGroupV2OriginEnum
+    origin: TaskGroupOriginEnum
 
     @model_validator(mode="before")
     @classmethod
@@ -75,7 +75,7 @@ class CollectionRequestData(BaseModel):
                 raise ValueError(
                     "When no `file` is provided, `package` is required."
                 )
-            values["origin"] = TaskGroupV2OriginEnum.PYPI
+            values["origin"] = TaskGroupOriginEnum.PYPI
         else:
             if package is not None:
                 raise ValueError(
@@ -87,7 +87,7 @@ class CollectionRequestData(BaseModel):
                     "Cannot set `package_version` when `file` is "
                     f"provided (given package_version='{package_version}')."
                 )
-            values["origin"] = TaskGroupV2OriginEnum.WHEELFILE
+            values["origin"] = TaskGroupOriginEnum.WHEELFILE
 
             for forbidden_char in FORBIDDEN_CHAR_WHEEL:
                 if forbidden_char in file.filename:
@@ -125,7 +125,7 @@ def parse_request_data(
             else None
         )
         # Validate and coerce form data
-        task_collect_pip = TaskCollectPipV2(
+        task_collect_pip = TaskCollectPip(
             package=package,
             package_version=package_version,
             package_extras=package_extras,
@@ -150,7 +150,7 @@ def parse_request_data(
 
 @router.post(
     "/collect/pip/",
-    response_model=TaskGroupActivityV2Read,
+    response_model=TaskGroupActivityRead,
 )
 async def collect_tasks_pip(
     response: Response,
@@ -160,7 +160,7 @@ async def collect_tasks_pip(
     user_group_id: int | None = None,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> TaskGroupActivityV2Read:
+) -> TaskGroupActivityRead:
     """
     Task-collection endpoint
     """
@@ -221,7 +221,7 @@ async def collect_tasks_pip(
     wheel_file = None
 
     # Set pkg_name, version, origin and archive_path
-    if request_data.origin == TaskGroupV2OriginEnum.WHEELFILE:
+    if request_data.origin == TaskGroupOriginEnum.WHEELFILE:
         try:
             wheel_filename = request_data.file.filename
             wheel_info = _parse_wheel_filename(wheel_filename)
@@ -242,7 +242,7 @@ async def collect_tasks_pip(
             wheel_info["distribution"]
         )
         task_group_attrs["version"] = wheel_info["version"]
-    elif request_data.origin == TaskGroupV2OriginEnum.PYPI:
+    elif request_data.origin == TaskGroupOriginEnum.PYPI:
         pkg_name = task_collect.package
         task_group_attrs["pkg_name"] = normalize_package_name(pkg_name)
         latest_version = await get_package_version_from_pypi(
@@ -278,7 +278,7 @@ async def collect_tasks_pip(
 
     # Validate TaskGroupV2 attributes
     try:
-        TaskGroupCreateV2Strict(**task_group_attrs)
+        TaskGroupCreateStrict(**task_group_attrs)
     except ValidationError as e:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
@@ -328,8 +328,8 @@ async def collect_tasks_pip(
     task_group_activity = TaskGroupActivityV2(
         user_id=task_group.user_id,
         taskgroupv2_id=task_group.id,
-        status=TaskGroupActivityStatusV2.PENDING,
-        action=TaskGroupActivityActionV2.COLLECT,
+        status=TaskGroupActivityStatus.PENDING,
+        action=TaskGroupActivityAction.COLLECT,
         pkg_name=task_group.pkg_name,
         version=task_group.version,
     )

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

@@ -17,11 +17,11 @@ 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 TaskCollectCustomV2
-from fractal_server.app.schemas.v2 import TaskCreateV2
-from fractal_server.app.schemas.v2 import TaskGroupCreateV2
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.app.schemas.v2 import TaskReadV2
+from fractal_server.app.schemas.v2 import TaskCollectCustom
+from fractal_server.app.schemas.v2 import TaskCreate
+from fractal_server.app.schemas.v2 import TaskGroupCreate
+from fractal_server.app.schemas.v2 import TaskGroupOriginEnum
+from fractal_server.app.schemas.v2 import TaskRead
 from fractal_server.logger import set_logger
 from fractal_server.string_tools import validate_cmd
 from fractal_server.tasks.v2.utils_background import prepare_tasks_metadata
@@ -38,16 +38,14 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-@router.post(
-    "/collect/custom/", status_code=201, response_model=list[TaskReadV2]
-)
+@router.post("/collect/custom/", status_code=201, response_model=list[TaskRead])
 async def collect_task_custom(
-    task_collect: TaskCollectCustomV2,
+    task_collect: TaskCollectCustom,
     private: bool = False,
     user_group_id: int | None = None,
     user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
-) -> list[TaskReadV2]:
+) -> list[TaskRead]:
     # Get validated resource and profile
     resource, profile = await validate_user_profile(user=user, db=db)
     resource_id = resource.id
@@ -139,7 +137,7 @@ async def collect_task_custom(
     else:
         package_root = Path(task_collect.package_root)
 
-    task_list: list[TaskCreateV2] = prepare_tasks_metadata(
+    task_list: list[TaskCreate] = prepare_tasks_metadata(
         package_manifest=task_collect.manifest,
         python_bin=Path(task_collect.python_interpreter),
         package_root=package_root,
@@ -148,14 +146,14 @@ async def collect_task_custom(
 
     # Prepare task-group attributes
     task_group_attrs = dict(
-        origin=TaskGroupV2OriginEnum.OTHER,
+        origin=TaskGroupOriginEnum.OTHER,
         pkg_name=task_collect.label,
         user_id=user.id,
         user_group_id=user_group_id,
         version=task_collect.version,
         resource_id=resource_id,
     )
-    TaskGroupCreateV2(**task_group_attrs)
+    TaskGroupCreate(**task_group_attrs)
 
     # Verify non-duplication constraints
     await _verify_non_duplication_user_constraint(