fractal-server 2.11.1__py3-none-any.whl → 2.12.0__py3-none-any.whl

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

@@ -1,203 +0,0 @@
-from copy import deepcopy  # noqa
-from typing import Optional
-
-from fastapi import APIRouter
-from fastapi import Depends
-from fastapi import HTTPException
-from fastapi import Response
-from fastapi import status
-from sqlmodel import select
-
-from .....logger import set_logger
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v1 import Task
-from ....models.v1 import WorkflowTask
-from ....models.v2 import TaskV2
-from ....schemas.v1 import TaskCreateV1
-from ....schemas.v1 import TaskReadV1
-from ....schemas.v1 import TaskUpdateV1
-from ...aux.validate_user_settings import verify_user_has_settings
-from ._aux_functions import _get_task_check_owner
-from ._aux_functions import _raise_if_v1_is_read_only
-from fractal_server.app.models import UserOAuth
-from fractal_server.app.routes.auth import current_active_user
-from fractal_server.app.routes.auth import current_active_verified_user
-
-router = APIRouter()
-
-logger = set_logger(__name__)
-
-
-@router.get("/", response_model=list[TaskReadV1])
-async def get_list_task(
-    user: UserOAuth = Depends(current_active_user),
-    args_schema: bool = True,
-    db: AsyncSession = Depends(get_async_db),
-) -> list[TaskReadV1]:
-    """
-    Get list of available tasks
-    """
-    stm = select(Task)
-    res = await db.execute(stm)
-    task_list = res.scalars().all()
-    await db.close()
-    if not args_schema:
-        for task in task_list:
-            setattr(task, "args_schema", None)
-
-    return task_list
-
-
-@router.get("/{task_id}/", response_model=TaskReadV1)
-async def get_task(
-    task_id: int,
-    user: UserOAuth = Depends(current_active_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> TaskReadV1:
-    """
-    Get info on a specific task
-    """
-    task = await db.get(Task, task_id)
-    await db.close()
-    if not task:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Task not found"
-        )
-    return task
-
-
-@router.patch("/{task_id}/", response_model=TaskReadV1)
-async def patch_task(
-    task_id: int,
-    task_update: TaskUpdateV1,
-    user: UserOAuth = Depends(current_active_verified_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> Optional[TaskReadV1]:
-    """
-    Edit a specific task (restricted to superusers and task owner)
-    """
-    _raise_if_v1_is_read_only()
-    if task_update.source:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail="patch_task endpoint cannot set `source`",
-        )
-
-    # Retrieve task from database
-    db_task = await _get_task_check_owner(task_id=task_id, user=user, db=db)
-
-    update = task_update.dict(exclude_unset=True)
-    for key, value in update.items():
-        if isinstance(value, str) or (
-            key == "version" and value is None
-        ):  # special case (issue 817)
-            setattr(db_task, key, value)
-        elif isinstance(value, dict):
-            if key == "args_schema":
-                setattr(db_task, key, value)
-            else:
-                current_dict = deepcopy(getattr(db_task, key))
-                current_dict.update(value)
-                setattr(db_task, key, current_dict)
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"Invalid {type(value)=} for {key=}",
-            )
-
-    await db.commit()
-    await db.refresh(db_task)
-    await db.close()
-    return db_task
-
-
-@router.post(
-    "/", response_model=TaskReadV1, status_code=status.HTTP_201_CREATED
-)
-async def create_task(
-    task: TaskCreateV1,
-    user: UserOAuth = Depends(current_active_verified_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> Optional[TaskReadV1]:
-    """
-    Create a new task
-    """
-    _raise_if_v1_is_read_only()
-    # Set task.owner attribute
-    if user.username:
-        owner = user.username
-    else:
-        verify_user_has_settings(user)
-        if user.settings.slurm_user:
-            owner = user.settings.slurm_user
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    "Cannot add a new task because current user does not "
-                    "have `username` or `slurm_user` attributes."
-                ),
-            )
-
-    # Prepend owner to task.source
-    task.source = f"{owner}:{task.source}"
-
-    # Verify that source is not already in use (note: this check is only useful
-    # to provide a user-friendly error message, but `task.source` uniqueness is
-    # already guaranteed by a constraint in the table definition).
-    stm = select(Task).where(Task.source == task.source)
-    res = await db.execute(stm)
-    if res.scalars().all():
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Source '{task.source}' already used by some TaskV1",
-        )
-    stm = select(TaskV2).where(TaskV2.source == task.source)
-    res = await db.execute(stm)
-    if res.scalars().all():
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Source '{task.source}' already used by some TaskV2",
-        )
-
-    # Add task
-    db_task = Task(**task.dict(), owner=owner)
-    db.add(db_task)
-    await db.commit()
-    await db.refresh(db_task)
-    await db.close()
-    return db_task
-
-
-@router.delete("/{task_id}/", status_code=204)
-async def delete_task(
-    task_id: int,
-    user: UserOAuth = Depends(current_active_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> Response:
-    """
-    Delete a task
-    """
-    _raise_if_v1_is_read_only()
-    db_task = await _get_task_check_owner(task_id=task_id, user=user, db=db)
-
-    # Check that the Task is not in relationship with some WorkflowTask
-    stm = select(WorkflowTask).filter(WorkflowTask.task_id == task_id)
-    res = await db.execute(stm)
-    workflowtask_list = res.scalars().all()
-    if workflowtask_list:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Cannot remove Task {task_id} because it is currently "
-                "imported in Workflows "
-                f"{[x.workflow_id for x in workflowtask_list]}. "
-                "If you want to remove this task, then you should first remove"
-                " the workflows.",
-            ),
-        )
-
-    await db.delete(db_task)
-    await db.commit()
-    return Response(status_code=status.HTTP_204_NO_CONTENT)

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

@@ -1,239 +0,0 @@
-from pathlib import Path
-from shutil import copy as shell_copy
-from tempfile import TemporaryDirectory
-
-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 pydantic.error_wrappers import ValidationError
-from sqlmodel import select
-
-from .....config import get_settings
-from .....logger import close_logger
-from .....logger import set_logger
-from .....syringe import Inject
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v1 import State
-from ....models.v1 import Task
-from ....schemas.v1 import StateRead
-from ....schemas.v1 import TaskCollectPipV1
-from ....schemas.v1 import TaskCollectStatusV1
-from ._aux_functions import _raise_if_v1_is_read_only
-from fractal_server.app.models import UserOAuth
-from fractal_server.app.routes.auth import current_active_user
-from fractal_server.app.routes.auth import current_active_verified_user
-from fractal_server.string_tools import slugify_task_name_for_source_v1
-from fractal_server.tasks.utils import get_collection_log_v1
-from fractal_server.tasks.v1._TaskCollectPip import _TaskCollectPip
-from fractal_server.tasks.v1.background_operations import (
-    background_collect_pip,
-)
-from fractal_server.tasks.v1.endpoint_operations import create_package_dir_pip
-from fractal_server.tasks.v1.endpoint_operations import download_package
-from fractal_server.tasks.v1.endpoint_operations import inspect_package
-from fractal_server.tasks.v1.get_collection_data import get_collection_data
-
-router = APIRouter()
-
-logger = set_logger(__name__)
-
-
-@router.post(
-    "/collect/pip/",
-    response_model=StateRead,
-    responses={
-        201: dict(
-            description=(
-                "Task collection successfully started in the background"
-            )
-        ),
-        200: dict(
-            description=(
-                "Package already collected. Returning info on already "
-                "available tasks"
-            )
-        ),
-    },
-)
-async def collect_tasks_pip(
-    task_collect: TaskCollectPipV1,
-    background_tasks: BackgroundTasks,
-    response: Response,
-    user: UserOAuth = Depends(current_active_verified_user),
-    db: AsyncSession = Depends(get_async_db),
-) -> StateRead:  # State[TaskCollectStatus]
-    """
-    Task collection endpoint
-
-    Trigger the creation of a dedicated virtual environment, the installation
-    of a package and the collection of tasks as advertised in the manifest.
-    """
-    _raise_if_v1_is_read_only()
-    logger = set_logger(logger_name="collect_tasks_pip")
-
-    # Validate payload as _TaskCollectPip, which has more strict checks than
-    # TaskCollectPip
-    try:
-        task_pkg = _TaskCollectPip(**task_collect.dict(exclude_unset=True))
-    except ValidationError as e:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Invalid task-collection object. Original error: {e}",
-        )
-
-    with TemporaryDirectory() as tmpdir:
-        try:
-            # Copy or download the package wheel file to tmpdir
-            if task_pkg.is_local_package:
-                shell_copy(task_pkg.package_path.as_posix(), tmpdir)
-                pkg_path = Path(tmpdir) / task_pkg.package_path.name
-            else:
-                pkg_path = await download_package(
-                    task_pkg=task_pkg, dest=tmpdir
-                )
-            # Read package info from wheel file, and override the ones coming
-            # from the request body
-            pkg_info = inspect_package(pkg_path)
-            task_pkg.package_name = pkg_info["pkg_name"]
-            task_pkg.package_version = pkg_info["pkg_version"]
-            task_pkg.package_manifest = pkg_info["pkg_manifest"]
-            task_pkg.check()
-        except Exception as e:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"Invalid package or manifest. Original error: {e}",
-            )
-
-    try:
-        venv_path = create_package_dir_pip(task_pkg=task_pkg)
-    except FileExistsError:
-        venv_path = create_package_dir_pip(task_pkg=task_pkg, create=False)
-        try:
-            task_collect_status = get_collection_data(venv_path)
-            for task in task_collect_status.task_list:
-                db_task = await db.get(Task, task.id)
-                if (
-                    (not db_task)
-                    or db_task.source != task.source
-                    or db_task.name != task.name
-                ):
-                    await db.close()
-                    raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            "Cannot collect package. Folder already exists, "
-                            f"but task {task.id} does not exists or it does "
-                            f"not have the expected source ({task.source}) or "
-                            f"name ({task.name})."
-                        ),
-                    )
-        except FileNotFoundError as e:
-            await db.close()
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    "Cannot collect package. Possible reason: another "
-                    "collection of the same package is in progress. "
-                    f"Original error: {e}"
-                ),
-            )
-        except ValidationError as e:
-            await db.close()
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    "Cannot collect package. Possible reason: an old version "
-                    "of the same package has already been collected. "
-                    f"Original error: {e}"
-                ),
-            )
-        task_collect_status.info = "Already installed"
-        state = State(data=task_collect_status.sanitised_dict())
-        response.status_code == status.HTTP_200_OK
-        await db.close()
-        return state
-    settings = Inject(get_settings)
-
-    # Check that tasks are not already in the DB
-    for new_task in task_pkg.package_manifest.task_list:
-        new_task_name_slug = slugify_task_name_for_source_v1(new_task.name)
-        new_task_source = f"{task_pkg.package_source}:{new_task_name_slug}"
-        stm = select(Task).where(Task.source == new_task_source)
-        res = await db.execute(stm)
-        if res.scalars().all():
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    "Cannot collect package. Task with source "
-                    f'"{new_task_source}" already exists in the database.'
-                ),
-            )
-
-    # All checks are OK, proceed with task collection
-    full_venv_path = venv_path.relative_to(settings.FRACTAL_TASKS_DIR)
-    collection_status = TaskCollectStatusV1(
-        status="pending", venv_path=full_venv_path, package=task_pkg.package
-    )
-
-    # Create State object (after casting venv_path to string)
-    collection_status_dict = collection_status.dict()
-    collection_status_dict["venv_path"] = str(collection_status.venv_path)
-    state = State(data=collection_status_dict)
-    db.add(state)
-    await db.commit()
-    await db.refresh(state)
-
-    background_tasks.add_task(
-        background_collect_pip,
-        state_id=state.id,
-        venv_path=venv_path,
-        task_pkg=task_pkg,
-    )
-    logger.debug(
-        "Task-collection endpoint: start background collection "
-        "and return state"
-    )
-    close_logger(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
-    await db.close()
-    return state
-
-
-@router.get("/collect/{state_id}/", response_model=StateRead)
-async def check_collection_status(
-    state_id: int,
-    user: UserOAuth = Depends(current_active_user),
-    verbose: bool = False,
-    db: AsyncSession = Depends(get_async_db),
-) -> StateRead:  # State[TaskCollectStatus]
-    """
-    Check status of background task collection
-    """
-    logger = set_logger(logger_name="check_collection_status")
-    logger.debug(f"Querying state for state.id={state_id}")
-    state = await db.get(State, state_id)
-    if not state:
-        await db.close()
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"No task collection info with id={state_id}",
-        )
-    data = TaskCollectStatusV1(**state.data)
-
-    # In some cases (i.e. a successful or ongoing task collection), data.log is
-    # not set; if so, we collect the current logs
-    if verbose and not data.log:
-        data.log = get_collection_log_v1(data.venv_path)
-        state.data = data.sanitised_dict()
-    close_logger(logger)
-    await db.close()
-    return state