fractal-server 2.7.0a0__py3-none-any.whl → 2.7.0a2__py3-none-any.whl

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

@@ -0,0 +1,134 @@
+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 sqlalchemy.sql.operators import is_
+from sqlalchemy.sql.operators import is_not
+from sqlmodel import select
+
+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 TaskGroupV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.routes.auth._aux_auth import (
+    _verify_user_belongs_to_group,
+)
+from fractal_server.app.schemas.v2 import TaskGroupReadV2
+from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
+
+router = APIRouter()
+
+
+@router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
+async def query_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroup {task_group_id} not found",
+        )
+    return task_group
+
+
+@router.get("/", response_model=list[TaskGroupReadV2])
+async def query_task_group_list(
+    user_id: Optional[int] = None,
+    user_group_id: Optional[int] = None,
+    private: Optional[bool] = None,
+    active: Optional[bool] = None,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupReadV2]:
+
+    stm = select(TaskGroupV2)
+
+    if user_group_id is not None and private is True:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Cannot set `user_group_id` with {private=}",
+        )
+    if user_id is not None:
+        stm = stm.where(TaskGroupV2.user_id == user_id)
+    if user_group_id is not None:
+        stm = stm.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))
+        else:
+            stm = stm.where(is_not(TaskGroupV2.user_group_id, None))
+    if active is not None:
+        if active is True:
+            stm = stm.where(is_(TaskGroupV2.active, True))
+        else:
+            stm = stm.where(is_(TaskGroupV2.active, False))
+
+    res = await db.execute(stm)
+    task_groups_list = res.scalars().all()
+    return task_groups_list
+
+
+@router.patch("/{task_group_id}/", response_model=TaskGroupReadV2)
+async def patch_task_group(
+    task_group_id: int,
+    task_group_update: TaskGroupUpdateV2,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupReadV2]:
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroupV2 {task_group_id} not found",
+        )
+
+    for key, value in task_group_update.dict(exclude_unset=True).items():
+        if (key == "user_group_id") and (value is not None):
+            await _verify_user_belongs_to_group(
+                user_id=user.id, user_group_id=value, db=db
+            )
+        setattr(task_group, key, value)
+
+    db.add(task_group)
+    await db.commit()
+    await db.refresh(task_group)
+    return task_group
+
+
+@router.delete("/{task_group_id}/", status_code=204)
+async def delete_task_group(
+    task_group_id: int,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+):
+    task_group = await db.get(TaskGroupV2, task_group_id)
+    if task_group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskGroupV2 {task_group_id} not found",
+        )
+
+    stm = select(WorkflowTaskV2).where(
+        WorkflowTaskV2.task_id.in_({task.id for task in task_group.task_list})
+    )
+    res = await db.execute(stm)
+    workflow_tasks = res.scalars().all()
+    if workflow_tasks != []:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
+        )
+
+    await db.delete(task_group)
+    await db.commit()
+
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

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

@@ -6,6 +6,7 @@ from fastapi import Depends
 from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
+from sqlmodel import func
 from sqlmodel import or_
 from sqlmodel import select
 
@@ -36,6 +37,9 @@ logger = set_logger(__name__)
 async def get_list_task(
     args_schema_parallel: bool = True,
     args_schema_non_parallel: bool = True,
+    category: Optional[str] = None,
+    modality: Optional[str] = None,
+    author: Optional[str] = None,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskReadV2]:
@@ -57,6 +61,13 @@ async def get_list_task(
             )
         )
     )
+    if category is not None:
+        stm = stm.where(func.lower(TaskV2.category) == category.lower())
+    if modality is not None:
+        stm = stm.where(func.lower(TaskV2.modality) == modality.lower())
+    if author is not None:
+        stm = stm.where(TaskV2.authors.icontains(author))
+
     res = await db.execute(stm)
     task_list = res.scalars().all()
     await db.close()
@@ -216,6 +227,8 @@ async def create_task(
         user_group_id=user_group_id,
         active=True,
         task_list=[db_task],
+        origin="other",
+        pkg_name=task.name,
     )
     db.add(db_task_group)
     await db.commit()

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

@@ -186,9 +186,15 @@ async def collect_task_custom(
             detail="\n".join(overlapping_tasks_v1_source_and_id),
         )
 
+    # Prepare task-group attributes
+    task_group_attrs = dict(
+        origin="other",
+        pkg_name=task_collect.source,  # FIXME
+    )
+
     task_group = create_db_task_group_and_tasks(
         task_list=task_list,
-        task_group_obj=TaskGroupCreateV2(),
+        task_group_obj=TaskGroupCreateV2(**task_group_attrs),
         user_id=user.id,
         user_group_id=user_group_id,
         db=db_sync,

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

@@ -31,12 +31,17 @@ logger = set_logger(__name__)
 async def get_task_group_list(
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
+    only_active: bool = False,
+    only_owner: bool = False,
 ) -> list[TaskGroupReadV2]:
     """
     Get all accessible TaskGroups
     """
-    stm = select(TaskGroupV2).where(
-        or_(
+
+    if only_owner:
+        condition = TaskGroupV2.user_id == user.id
+    else:
+        condition = or_(
             TaskGroupV2.user_id == user.id,
             TaskGroupV2.user_group_id.in_(
                 select(LinkUserGroup.group_id).where(
@@ -44,7 +49,10 @@ async def get_task_group_list(
                 )
             ),
         )
-    )
+    stm = select(TaskGroupV2).where(condition)
+    if only_active:
+        stm = stm.where(TaskGroupV2.active)
+
     res = await db.execute(stm)
     task_groups = res.scalars().all()
 

fractal_server/app/routes/auth/_aux_auth.py

@@ -1,6 +1,7 @@
 from fastapi import HTTPException
 from fastapi import status
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import asc
 from sqlmodel import select
 
 from fractal_server.app.models.linkusergroup import LinkUserGroup
@@ -9,58 +10,58 @@ from fractal_server.app.models.security import UserOAuth
 from fractal_server.app.schemas.user import UserRead
 from fractal_server.app.schemas.user_group import UserGroupRead
 from fractal_server.app.security import FRACTAL_DEFAULT_GROUP_NAME
+from fractal_server.logger import set_logger
 
+logger = set_logger(__name__)
 
-async def _get_single_user_with_group_names(
+
+async def _get_single_user_with_groups(
     user: UserOAuth,
     db: AsyncSession,
 ) -> UserRead:
     """
-    Enrich a user object by filling its `group_names` attribute.
+    Enrich a user object by filling its `group_ids_names` attribute.
 
     Arguments:
         user: The current `UserOAuth` object
         db: Async db session
 
     Returns:
-        A `UserRead` object with `group_names` set
+        A `UserRead` object with `group_ids_names` dict
     """
     stm_groups = (
         select(UserGroup)
         .join(LinkUserGroup)
-        .where(LinkUserGroup.user_id == UserOAuth.id)
+        .where(LinkUserGroup.user_id == user.id)
+        .order_by(asc(LinkUserGroup.timestamp_created))
     )
     res = await db.execute(stm_groups)
     groups = res.scalars().unique().all()
-    group_names = [group.name for group in groups]
-    return UserRead(
-        **user.model_dump(),
-        group_names=group_names,
-        oauth_accounts=user.oauth_accounts,
+    group_ids_names = [(group.id, group.name) for group in groups]
+
+    # Check that Fractal Default Group is the first of the list. If not, fix.
+    index = next(
+        (
+            i
+            for i, group_tuple in enumerate(group_ids_names)
+            if group_tuple[1] == FRACTAL_DEFAULT_GROUP_NAME
+        ),
+        None,
     )
+    if index is None:
+        logger.warning(
+            f"User {user.id} not in "
+            f"default UserGroup '{FRACTAL_DEFAULT_GROUP_NAME}'"
+        )
+    elif index != 0:
+        default_group = group_ids_names.pop(index)
+        group_ids_names.insert(0, default_group)
+    else:
+        pass
 
-
-async def _get_single_user_with_group_ids(
-    user: UserOAuth,
-    db: AsyncSession,
-) -> UserRead:
-    """
-    Enrich a user object by filling its `group_ids` attribute.
-
-    Arguments:
-        user: The current `UserOAuth` object
-        db: Async db session
-
-    Returns:
-        A `UserRead` object with `group_ids` set
-    """
-    stm_links = select(LinkUserGroup).where(LinkUserGroup.user_id == user.id)
-    res = await db.execute(stm_links)
-    links = res.scalars().unique().all()
-    group_ids = [link.group_id for link in links]
     return UserRead(
         **user.model_dump(),
-        group_ids=group_ids,
+        group_ids_names=group_ids_names,
         oauth_accounts=user.oauth_accounts,
     )
 

fractal_server/app/routes/auth/current_user.py

@@ -13,7 +13,7 @@ from ...schemas.user import UserRead
 from ...schemas.user import UserUpdate
 from ...schemas.user import UserUpdateStrict
 from ..aux.validate_user_settings import verify_user_has_settings
-from ._aux_auth import _get_single_user_with_group_names
+from ._aux_auth import _get_single_user_with_groups
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
@@ -28,15 +28,15 @@ router_current_user = APIRouter()
 
 @router_current_user.get("/current-user/", response_model=UserRead)
 async def get_current_user(
-    group_names: bool = False,
+    group_ids_names: bool = False,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ):
     """
     Return current user
     """
-    if group_names is True:
-        user_with_groups = await _get_single_user_with_group_names(user, db)
+    if group_ids_names is True:
+        user_with_groups = await _get_single_user_with_groups(user, db)
         return user_with_groups
     else:
         return user
@@ -65,7 +65,7 @@ async def patch_current_user(
     patched_user = await db.get(
         UserOAuth, validated_user.id, populate_existing=True
     )
-    patched_user_with_groups = await _get_single_user_with_group_names(
+    patched_user_with_groups = await _get_single_user_with_groups(
         patched_user, db
     )
     return patched_user_with_groups

fractal_server/app/routes/auth/router.py

@@ -2,7 +2,6 @@ from fastapi import APIRouter
 
 from .current_user import router_current_user
 from .group import router_group
-from .group_names import router_group_names
 from .login import router_login
 from .oauth import router_oauth
 from .register import router_register
@@ -13,7 +12,6 @@ router_auth = APIRouter()
 router_auth.include_router(router_register)
 router_auth.include_router(router_current_user)
 router_auth.include_router(router_login)
-router_auth.include_router(router_group_names)
 router_auth.include_router(router_users)
 router_auth.include_router(router_group)
 router_auth.include_router(router_oauth)

fractal_server/app/routes/auth/users.py

@@ -20,7 +20,7 @@ from ...schemas.user import UserRead
 from ...schemas.user import UserUpdate
 from ...schemas.user import UserUpdateWithNewGroupIds
 from ..aux.validate_user_settings import verify_user_has_settings
-from ._aux_auth import _get_single_user_with_group_ids
+from ._aux_auth import _get_single_user_with_groups
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
@@ -41,13 +41,14 @@ logger = set_logger(__name__)
 @router_users.get("/users/{user_id}/", response_model=UserRead)
 async def get_user(
     user_id: int,
-    group_ids: bool = True,
+    group_ids_names: bool = True,
     superuser: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> UserRead:
     user = await _user_or_404(user_id, db)
-    if group_ids:
-        user = await _get_single_user_with_group_ids(user, db)
+    if group_ids_names:
+        user_with_groups = await _get_single_user_with_groups(user, db)
+        return user_with_groups
     return user
 
 
@@ -163,12 +164,12 @@ async def patch_user(
         # Nothing to do, just continue
         patched_user = user_to_patch
 
-    # Enrich user object with `group_ids` attribute
-    patched_user_with_group_ids = await _get_single_user_with_group_ids(
+    # Enrich user object with `group_ids_names` attribute
+    patched_user_with_groups = await _get_single_user_with_groups(
         patched_user, db
     )
 
-    return patched_user_with_group_ids
+    return patched_user_with_groups
 
 
 @router_users.get("/users/", response_model=list[UserRead])

fractal_server/app/schemas/user.py

@@ -41,8 +41,7 @@ class UserRead(schemas.BaseUser[int]):
     """
 
     username: Optional[str]
-    group_names: Optional[list[str]] = None
-    group_ids: Optional[list[int]] = None
+    group_ids_names: Optional[list[tuple[int, str]]] = None
     oauth_accounts: list[OAuthAccountRead]
 
 

fractal_server/app/schemas/v2/manifest.py

@@ -7,6 +7,8 @@ from pydantic import HttpUrl
 from pydantic import root_validator
 from pydantic import validator
 
+from .._validators import valstr
+
 
 class TaskManifestV2(BaseModel):
     """
@@ -50,6 +52,10 @@ class TaskManifestV2(BaseModel):
     docs_info: Optional[str] = None
     docs_link: Optional[HttpUrl] = None
 
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    tags: list[str] = Field(default_factory=list)
+
     @root_validator
     def validate_executable_args_meta(cls, values):
 
@@ -128,7 +134,8 @@ class ManifestV2(BaseModel):
     manifest_version: str
     task_list: list[TaskManifestV2]
     has_args_schemas: bool = False
-    args_schema_version: Optional[str]
+    args_schema_version: Optional[str] = None
+    authors: Optional[str] = None
 
     @root_validator()
     def _check_args_schemas_are_present(cls, values):
@@ -157,3 +164,7 @@ class ManifestV2(BaseModel):
         if value != "2":
             raise ValueError(f"Wrong manifest version (given {value})")
         return value
+
+    _authors = validator("authors", allow_reuse=True)(
+        valstr("authors", accept_none=True)
+    )

fractal_server/app/schemas/v2/task.py

@@ -9,8 +9,9 @@ from pydantic import HttpUrl
 from pydantic import root_validator
 from pydantic import validator
 
-from .._validators import valdictkeys
-from .._validators import valstr
+from fractal_server.app.schemas._validators import val_unique_list
+from fractal_server.app.schemas._validators import valdictkeys
+from fractal_server.app.schemas._validators import valstr
 from fractal_server.string_tools import validate_cmd
 
 
@@ -18,22 +19,27 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
 
     name: str
 
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
     source: str
 
-    meta_non_parallel: Optional[dict[str, Any]]
-    meta_parallel: Optional[dict[str, Any]]
-    version: Optional[str]
-    args_schema_non_parallel: Optional[dict[str, Any]]
-    args_schema_parallel: Optional[dict[str, Any]]
-    args_schema_version: Optional[str]
-    docs_info: Optional[str]
-    docs_link: Optional[HttpUrl]
+    meta_non_parallel: Optional[dict[str, Any]] = None
+    meta_parallel: Optional[dict[str, Any]] = None
+    version: Optional[str] = None
+    args_schema_non_parallel: Optional[dict[str, Any]] = None
+    args_schema_parallel: Optional[dict[str, Any]] = None
+    args_schema_version: Optional[str] = None
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
 
     input_types: dict[str, bool] = Field(default={})
     output_types: dict[str, bool] = Field(default={})
 
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    tags: list[str] = Field(default_factory=list)
+    authors: Optional[str] = None
+
     # Validators
     @root_validator
     def validate_commands(cls, values):
@@ -83,6 +89,22 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
         valdictkeys("output_types")
     )
 
+    _category = validator("category", allow_reuse=True)(
+        valstr("category", accept_none=True)
+    )
+    _modality = validator("modality", allow_reuse=True)(
+        valstr("modality", accept_none=True)
+    )
+    _authors = validator("authors", allow_reuse=True)(
+        valstr("authors", accept_none=True)
+    )
+
+    @validator("tags")
+    def validate_list_of_strings(cls, value):
+        for i, tag in enumerate(value):
+            value[i] = valstr(f"tags[{i}]")(tag)
+        return val_unique_list("tags")(value)
+
 
 class TaskReadV2(BaseModel):
 
@@ -90,31 +112,41 @@ class TaskReadV2(BaseModel):
     name: str
     type: Literal["parallel", "non_parallel", "compound"]
     source: str
-    version: Optional[str]
+    version: Optional[str] = None
 
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
     meta_parallel: dict[str, Any]
     meta_non_parallel: dict[str, Any]
     args_schema_non_parallel: Optional[dict[str, Any]] = None
     args_schema_parallel: Optional[dict[str, Any]] = None
-    args_schema_version: Optional[str]
-    docs_info: Optional[str]
-    docs_link: Optional[HttpUrl]
+    args_schema_version: Optional[str] = None
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
     input_types: dict[str, bool]
     output_types: dict[str, bool]
 
-    taskgroupv2_id: Optional[int]
+    taskgroupv2_id: Optional[int] = None
+
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: list[str]
 
 
 class TaskUpdateV2(BaseModel):
 
-    name: Optional[str]
-    version: Optional[str]
-    command_parallel: Optional[str]
-    command_non_parallel: Optional[str]
-    input_types: Optional[dict[str, bool]]
-    output_types: Optional[dict[str, bool]]
+    name: Optional[str] = None
+    version: Optional[str] = None
+    command_parallel: Optional[str] = None
+    command_non_parallel: Optional[str] = None
+    input_types: Optional[dict[str, bool]] = None
+    output_types: Optional[dict[str, bool]] = None
+
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: Optional[list[str]] = None
 
     # Validators
     @validator("input_types", "output_types")
@@ -140,6 +172,22 @@ class TaskUpdateV2(BaseModel):
         valdictkeys("output_types")
     )
 
+    _category = validator("category", allow_reuse=True)(
+        valstr("category", accept_none=True)
+    )
+    _modality = validator("modality", allow_reuse=True)(
+        valstr("modality", accept_none=True)
+    )
+    _authors = validator("authors", allow_reuse=True)(
+        valstr("authors", accept_none=True)
+    )
+
+    @validator("tags")
+    def validate_tags(cls, value):
+        for i, tag in enumerate(value):
+            value[i] = valstr(f"tags[{i}]")(tag)
+        return val_unique_list("tags")(value)
+
 
 class TaskImportV2(BaseModel):
 

fractal_server/app/schemas/v2/task_group.py

@@ -1,23 +1,50 @@
+from datetime import datetime
+from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
+from pydantic import validator
 
 from .task import TaskReadV2
 
 
 class TaskGroupCreateV2(BaseModel):
     active: bool = True
+    origin: Literal["pypi", "wheel-file", "other"]
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    venv_path: Optional[str] = None
+    pip_extras: Optional[str] = None
 
 
 class TaskGroupReadV2(BaseModel):
 
     id: int
+    task_list: list[TaskReadV2]
+
     user_id: int
     user_group_id: Optional[int] = None
+
+    origin: Literal["pypi", "wheel-file", "other"]
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    venv_path: Optional[str] = None
+    pip_extras: Optional[str] = None
+
     active: bool
-    task_list: list[TaskReadV2]
+    timestamp_created: datetime
 
 
 class TaskGroupUpdateV2(BaseModel):
     user_group_id: Optional[int] = None
     active: Optional[bool] = None
+
+    @validator("active")
+    def active_cannot_be_None(cls, value):
+        if value is None:
+            raise ValueError("`active` cannot be set to None")
+        return value