fractal-server 2.7.0a3__py3-none-any.whl → 2.7.0a4__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.7.0a3"
+__VERSION__ = "2.7.0a4"

fractal_server/__main__.py

@@ -61,12 +61,6 @@ update_db_data_parser = subparsers.add_parser(
     "update-db-data",
     description="Apply data-migration script to an existing database.",
 )
-update_db_data_parser.add_argument(
-    "--dry-run",
-    action="store_true",
-    help="If set, perform a dry run of the data migration.",
-    default=False,
-)
 
 
 def save_openapi(dest="openapi.json"):
@@ -126,7 +120,7 @@ def set_db(skip_init_data: bool = False):
     print()
 
 
-def update_db_data(dry_run: bool = False):
+def update_db_data():
     """
     Apply data migrations.
     """
@@ -191,7 +185,7 @@ def update_db_data(dry_run: bool = False):
         sys.exit()
 
     print("OK, now starting data-migration script\n")
-    current_update_db_data_module.fix_db(dry_run=dry_run)
+    current_update_db_data_module.fix_db()
 
 
 def run():
@@ -202,7 +196,7 @@ def run():
     elif args.cmd == "set-db":
         set_db(skip_init_data=args.skip_init_data)
     elif args.cmd == "update-db-data":
-        update_db_data(dry_run=args.dry_run)
+        update_db_data()
     elif args.cmd == "start":
         uvicorn.run(
             "fractal_server.main:app",

fractal_server/app/models/v2/collection_state.py

@@ -14,6 +14,7 @@ from ....utils import get_timestamp
 class CollectionStateV2(SQLModel, table=True):
 
     id: Optional[int] = Field(default=None, primary_key=True)
+    taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
     data: dict[str, Any] = Field(sa_column=Column(JSON), default={})
     timestamp: datetime = Field(
         default_factory=get_timestamp,

fractal_server/app/models/v2/task.py

@@ -14,14 +14,13 @@ from fractal_server.utils import get_timestamp
 
 
 class TaskV2(SQLModel, table=True):
-
     id: Optional[int] = Field(default=None, primary_key=True)
     name: str
 
     type: str
     command_non_parallel: Optional[str] = None
     command_parallel: Optional[str] = None
-    source: str = Field(unique=True)
+    source: Optional[str] = None
 
     meta_non_parallel: dict[str, Any] = Field(
         sa_column=Column(JSON, server_default="{}", default={}, nullable=False)
@@ -56,7 +55,6 @@ class TaskV2(SQLModel, table=True):
 
 
 class TaskGroupV2(SQLModel, table=True):
-
     id: Optional[int] = Field(default=None, primary_key=True)
     task_list: list[TaskV2] = Relationship(
         sa_relationship_kwargs=dict(
@@ -73,10 +71,36 @@ class TaskGroupV2(SQLModel, table=True):
     python_version: Optional[str] = None
     path: Optional[str] = None
     venv_path: Optional[str] = None
+    wheel_path: Optional[str] = None
     pip_extras: Optional[str] = None
+    pinned_package_versions: dict[str, str] = Field(
+        sa_column=Column(
+            JSON,
+            server_default="{}",
+            default={},
+            nullable=True,
+        ),
+    )
 
     active: bool = True
     timestamp_created: datetime = Field(
         default_factory=get_timestamp,
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
+
+    @property
+    def pip_install_string(self) -> str:
+        """
+        Prepare string to be used in `python -m pip install`.
+        """
+        extras = f"[{self.pip_extras}]" if self.pip_extras is not None else ""
+
+        if self.wheel_path is not None:
+            return f"{self.wheel_path}{extras}"
+        else:
+            if self.version is None:
+                raise ValueError(
+                    "Cannot run `pip_install_string` with "
+                    f"{self.pkg_name=}, {self.wheel_path=}, {self.version=}."
+                )
+            return f"{self.pkg_name}{extras}=={self.version}"

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

@@ -1,4 +1,3 @@
-from typing import Literal
 from typing import Optional
 
 from fastapi import APIRouter
@@ -26,11 +25,12 @@ class TaskV2Minimal(BaseModel):
     id: int
     name: str
     type: str
-    command_non_parallel: Optional[str]
+    taskgroupv2_id: int
+    command_non_parallel: Optional[str] = None
     command_parallel: Optional[str]
-    source: str
-    owner: Optional[str]
-    version: Optional[str]
+    source: Optional[str] = None
+    owner: Optional[str] = None
+    version: Optional[str] = None
 
 
 class ProjectUser(BaseModel):
@@ -61,7 +61,6 @@ async def query_tasks(
     version: Optional[str] = None,
     name: Optional[str] = None,
     owner: Optional[str] = None,
-    kind: Optional[Literal["common", "users"]] = None,
     max_number_of_results: int = 25,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
@@ -77,8 +76,6 @@ async def query_tasks(
         version: If not `None`, query for matching `task.version`.
         name: If not `None`, query for contained case insensitive `task.name`.
         owner: If not `None`, query for matching `task.owner`.
-        kind: If not `None`, query for TaskV2s that have (`users`) or don't
-            have (`common`) a `task.owner`.
         max_number_of_results: The maximum length of the response.
     """
 
@@ -95,11 +92,6 @@ async def query_tasks(
     if owner is not None:
         stm = stm.where(TaskV2.owner == owner)
 
-    if kind == "common":
-        stm = stm.where(TaskV2.owner == None)  # noqa E711
-    elif kind == "users":
-        stm = stm.where(TaskV2.owner != None)  # noqa E711
-
     res = await db.execute(stm)
     task_list = res.scalars().all()
     if len(task_list) > max_number_of_results:

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

@@ -12,6 +12,7 @@ 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 CollectionStateV2
 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
@@ -20,9 +21,12 @@ from fractal_server.app.routes.auth._aux_auth import (
 )
 from fractal_server.app.schemas.v2 import TaskGroupReadV2
 from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
+from fractal_server.logger import set_logger
 
 router = APIRouter()
 
+logger = set_logger(__name__)
+
 
 @router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
 async def query_task_group(
@@ -128,6 +132,23 @@ async def delete_task_group(
             detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
         )
 
+    # Cascade operations: set foreign-keys to null for CollectionStateV2 which
+    # are in relationship with the current TaskGroupV2
+    logger.debug("Start of cascade operations on CollectionStateV2.")
+    stm = select(CollectionStateV2).where(
+        CollectionStateV2.taskgroupv2_id == task_group_id
+    )
+    res = await db.execute(stm)
+    collection_states = res.scalars().all()
+    for collection_state in collection_states:
+        logger.debug(
+            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
+            "to None."
+        )
+        collection_state.taskgroupv2_id = None
+        db.add(collection_state)
+    logger.debug("End of cascade operations on CollectionStateV2.")
+
     await db.delete(task_group)
     await db.commit()
 

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

@@ -26,7 +26,7 @@ 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
+from fractal_server.string_tools import slugify_task_name_for_source_v1
 from fractal_server.tasks.utils import get_collection_log
 from fractal_server.tasks.v1._TaskCollectPip import _TaskCollectPip
 from fractal_server.tasks.v1.background_operations import (
@@ -160,7 +160,7 @@ async def collect_tasks_pip(
 
     # 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(new_task.name)
+        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)

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

@@ -2,6 +2,7 @@
 Auxiliary functions to get task and task-group object from the database or
 perform simple checks
 """
+from typing import Any
 from typing import Optional
 
 from fastapi import HTTPException
@@ -12,7 +13,8 @@ from ....db import AsyncSession
 from ....models import LinkUserGroup
 from ....models.v2 import TaskGroupV2
 from ....models.v2 import TaskV2
-from ...auth._aux_auth import _get_default_user_group_id
+from ....models.v2 import WorkflowTaskV2
+from ...auth._aux_auth import _get_default_usergroup_id
 from ...auth._aux_auth import _verify_user_belongs_to_group
 
 
@@ -201,9 +203,80 @@ async def _get_valid_user_group_id(
     elif private is True:
         user_group_id = None
     elif user_group_id is None:
-        user_group_id = await _get_default_user_group_id(db=db)
+        user_group_id = await _get_default_usergroup_id(db=db)
     else:
         await _verify_user_belongs_to_group(
             user_id=user_id, user_group_id=user_group_id, db=db
         )
     return user_group_id
+
+
+async def _verify_non_duplication_user_constraint(
+    db: AsyncSession,
+    user_id: int,
+    pkg_name: str,
+    version: Optional[str],
+):
+    stm = (
+        select(TaskGroupV2)
+        .where(TaskGroupV2.user_id == user_id)
+        .where(TaskGroupV2.pkg_name == pkg_name)
+        .where(TaskGroupV2.version == version)
+    )
+    res = await db.execute(stm)
+    duplicate = res.scalars().all()
+    if duplicate:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "There is already a TaskGroupV2 with "
+                f"({pkg_name=}, {version=}, {user_id=})."
+            ),
+        )
+
+
+async def _verify_non_duplication_group_constraint(
+    db: AsyncSession,
+    user_group_id: Optional[int],
+    pkg_name: str,
+    version: Optional[str],
+):
+    if user_group_id is None:
+        return
+
+    stm = (
+        select(TaskGroupV2)
+        .where(TaskGroupV2.user_group_id == user_group_id)
+        .where(TaskGroupV2.pkg_name == pkg_name)
+        .where(TaskGroupV2.version == version)
+    )
+    res = await db.execute(stm)
+    duplicate = res.scalars().all()
+    if duplicate:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "There is already a TaskGroupV2 with "
+                f"({pkg_name=}, {version=}, {user_group_id=})."
+            ),
+        )
+
+
+async def _add_warnings_to_workflow_tasks(
+    wftask_list: list[WorkflowTaskV2], user_id: int, db: AsyncSession
+) -> list[dict[str, Any]]:
+    wftask_list_with_warnings = []
+    for wftask in wftask_list:
+        wftask_data = dict(wftask.model_dump(), task=wftask.task)
+        try:
+            task_group = await _get_task_group_read_access(
+                task_group_id=wftask.task.taskgroupv2_id,
+                user_id=user_id,
+                db=db,
+            )
+            if not task_group.active:
+                wftask_data["warning"] = "Task is not active."
+        except HTTPException:
+            wftask_data["warning"] = "Current user has no access to this task."
+        wftask_list_with_warnings.append(wftask_data)
+    return wftask_list_with_warnings

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

@@ -10,15 +10,15 @@ from sqlmodel import func
 from sqlmodel import or_
 from sqlmodel import select
 
-from ...aux.validate_user_settings import verify_user_has_settings
 from ._aux_functions_tasks import _get_task_full_access
 from ._aux_functions_tasks import _get_task_read_access
 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 AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v1 import Task as TaskV1
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.routes.auth import current_active_user
@@ -102,7 +102,7 @@ async def patch_task(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[TaskReadV2]:
     """
-    Edit a specific task (restricted to superusers and task owner)
+    Edit a specific task (restricted to task owner)
     """
 
     # Retrieve task from database
@@ -183,52 +183,26 @@ async def create_task(
             ),
         )
 
-    # Set task.owner attribute - FIXME: remove this block
-    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(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",
-        )
-    stm = select(TaskV1).where(TaskV1.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",
-        )
     # Add task
-    db_task = TaskV2(**task.dict(), owner=owner, type=task_type)
-
+    db_task = TaskV2(**task.dict(), type=task_type)
+    pkg_name = db_task.name
+    await _verify_non_duplication_user_constraint(
+        db=db, pkg_name=pkg_name, user_id=user.id, version=db_task.version
+    )
+    await _verify_non_duplication_group_constraint(
+        db=db,
+        pkg_name=pkg_name,
+        user_group_id=user_group_id,
+        version=db_task.version,
+    )
     db_task_group = TaskGroupV2(
         user_id=user.id,
         user_group_id=user_group_id,
         active=True,
         task_list=[db_task],
         origin="other",
-        pkg_name=task.name,
+        version=db_task.version,
+        pkg_name=pkg_name,
     )
     db.add(db_task_group)
     await db.commit()