fractal-server 2.17.1a1__py3-none-any.whl → 2.18.0__py3-none-any.whl

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

@@ -9,12 +9,8 @@ from fastapi import HTTPException
 from fastapi import Request
 from fastapi import status
 from sqlmodel import select
+from sqlmodel import update
 
-from ...aux.validate_user_profile import validate_user_profile
-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_tasks import _check_type_filters_compatibility
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import Profile
@@ -25,10 +21,14 @@ from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_read_access,
 )
 from fractal_server.app.routes.auth import current_user_act_ver_prof
-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.routes.aux.validate_user_profile import (
+    validate_user_profile,
+)
+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 (
@@ -37,6 +37,11 @@ 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_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"
 router = APIRouter()
 logger = set_logger(__name__)
@@ -45,37 +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,36 +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(
@@ -193,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,
@@ -206,7 +219,7 @@ async def apply_workflow(
             workflow.model_dump_json(exclude={"task_list"})
         ),
         project_dump=json.loads(
-            project.model_dump_json(exclude={"user_list", "resource_id"})
+            project.model_dump_json(exclude={"resource_id"})
         ),
         **job_create.model_dump(),
     )
@@ -216,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()
 
@@ -263,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

@@ -9,7 +9,9 @@ from sqlmodel import func
 from sqlmodel import or_
 from sqlmodel import select
 
-from ...aux.validate_user_profile import validate_user_profile
+from fractal_server.app.routes.aux.validate_user_profile import (
+    validate_user_profile,
+)
 from ._aux_functions import _get_user_resource_id
 from ._aux_functions_tasks import _get_task_full_access
 from ._aux_functions_tasks import _get_task_read_access
@@ -23,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()
@@ -35,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,
@@ -43,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
     """
@@ -52,8 +54,7 @@ async def get_list_task(
 
     stm = (
         select(TaskV2)
-        .join(TaskGroupV2)
-        .where(TaskGroupV2.id == TaskV2.taskgroupv2_id)
+        .join(TaskGroupV2, TaskGroupV2.id == TaskV2.taskgroupv2_id)
         .where(TaskGroupV2.resource_id == user_resource_id)
         .where(
             or_(
@@ -85,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
     """
@@ -98,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)
     """
@@ -136,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
     """
@@ -210,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

@@ -8,39 +8,32 @@ from fastapi import File
 from fastapi import Form
 from fastapi import HTTPException
 from fastapi import Response
-from fastapi import status
 from fastapi import UploadFile
+from fastapi import status
 from pydantic import BaseModel
-from pydantic import model_validator
 from pydantic import ValidationError
+from pydantic import model_validator
 
-from .....logger import reset_logger_handlers
-from .....logger import set_logger
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v2 import TaskGroupV2
-from ....schemas.v2 import FractalUploadedFile
-from ....schemas.v2 import TaskCollectPipV2
-from ....schemas.v2 import TaskGroupActivityStatusV2
-from ....schemas.v2 import TaskGroupActivityV2Read
-from ....schemas.v2 import TaskGroupCreateV2Strict
-from ...aux.validate_user_profile import validate_user_profile
-from ._aux_functions_task_lifecycle import get_package_version_from_pypi
-from ._aux_functions_tasks import _get_valid_user_group_id
-from ._aux_functions_tasks import _verify_non_duplication_group_constraint
-from ._aux_functions_tasks import _verify_non_duplication_group_path
-from ._aux_functions_tasks import _verify_non_duplication_user_constraint
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupActivityV2
+from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.routes.auth import current_user_act_ver_prof
-from fractal_server.app.schemas.v2 import ResourceType
-from fractal_server.app.schemas.v2 import (
-    TaskGroupActivityActionV2,
-)
-from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.tasks.v2.local.collect import (
-    collect_local,
+from fractal_server.app.routes.aux.validate_user_profile import (
+    validate_user_profile,
 )
+from fractal_server.app.schemas.v2 import FractalUploadedFile
+from fractal_server.app.schemas.v2 import ResourceType
+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
 from fractal_server.tasks.v2.ssh import collect_ssh
 from fractal_server.tasks.v2.utils_package_names import _parse_wheel_filename
 from fractal_server.tasks.v2.utils_package_names import normalize_package_name
@@ -48,6 +41,11 @@ from fractal_server.tasks.v2.utils_python_interpreter import (
     get_python_interpreter,
 )
 
+from ._aux_functions_task_lifecycle import get_package_version_from_pypi
+from ._aux_functions_tasks import _get_valid_user_group_id
+from ._aux_functions_tasks import _verify_non_duplication_group_constraint
+from ._aux_functions_tasks import _verify_non_duplication_group_path
+from ._aux_functions_tasks import _verify_non_duplication_user_constraint
 
 router = APIRouter()
 
@@ -61,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
@@ -77,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(
@@ -89,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:
@@ -127,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,
@@ -152,7 +150,7 @@ def parse_request_data(
 
 @router.post(
     "/collect/pip/",
-    response_model=TaskGroupActivityV2Read,
+    response_model=TaskGroupActivityRead,
 )
 async def collect_tasks_pip(
     response: Response,
@@ -162,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
     """
@@ -211,19 +209,19 @@ async def collect_tasks_pip(
 
     # Set pinned_package_versions
     if task_collect.pinned_package_versions_pre is not None:
-        task_group_attrs[
-            "pinned_package_versions_pre"
-        ] = task_collect.pinned_package_versions_pre
+        task_group_attrs["pinned_package_versions_pre"] = (
+            task_collect.pinned_package_versions_pre
+        )
     if task_collect.pinned_package_versions_post is not None:
-        task_group_attrs[
-            "pinned_package_versions_post"
-        ] = task_collect.pinned_package_versions_post
+        task_group_attrs["pinned_package_versions_post"] = (
+            task_collect.pinned_package_versions_post
+        )
 
     # Initialize wheel_file_content as None
     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)
@@ -244,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(
@@ -280,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,
@@ -330,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

@@ -9,44 +9,43 @@ from fastapi import HTTPException
 from fastapi import status
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from ...aux.validate_user_profile import validate_user_profile
-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.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
 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 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,
-)
+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_async,
 )
 
+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
+
 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
@@ -138,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,
@@ -147,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(