fractal-server 2.4.2__py3-none-any.whl → 2.5.0a0__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.4.2"
+__VERSION__ = "2.5.0a0"

fractal_server/app/db/__init__.py

@@ -2,6 +2,7 @@
 `db` module, loosely adapted from
 https://testdriven.io/blog/fastapi-sqlmodel/#async-sqlmodel
 """
+import sqlite3
 from typing import AsyncGenerator
 from typing import Generator
 
@@ -21,7 +22,9 @@ from ...syringe import Inject
 logger = set_logger(__name__)
 
 SQLITE_WARNING_MESSAGE = (
-    "SQLite is supported (for version >=3.37) but discouraged in production. "
+    "SQLite is supported (supported version >=3.37, "
+    f"current {sqlite3.sqlite_version=}) "
+    "but discouraged in production. "
     "Given its partial support for ForeignKey constraints, "
     "database consistency cannot be guaranteed."
 )

fractal_server/app/models/v1/task.py

@@ -5,7 +5,6 @@ from typing import Optional
 
 from pydantic import HttpUrl
 from sqlalchemy import Column
-from sqlalchemy import sql
 from sqlalchemy.types import JSON
 from sqlmodel import Field
 from sqlmodel import SQLModel
@@ -49,10 +48,6 @@ class Task(_TaskBaseV1, SQLModel, table=True):
     docs_info: Optional[str] = None
     docs_link: Optional[HttpUrl] = None
 
-    is_v2_compatible: bool = Field(
-        default=False, sa_column_kwargs={"server_default": sql.false()}
-    )
-
     @property
     def parallelization_level(self) -> Optional[str]:
         try:

fractal_server/app/models/v2/workflowtask.py

@@ -8,7 +8,6 @@ from sqlmodel import Field
 from sqlmodel import Relationship
 from sqlmodel import SQLModel
 
-from ..v1.task import Task
 from .task import TaskV2
 
 
@@ -37,13 +36,6 @@ class WorkflowTaskV2(SQLModel, table=True):
     )
 
     # Task
-    is_legacy_task: bool
     task_type: str
-    task_id: Optional[int] = Field(foreign_key="taskv2.id")
-    task: Optional[TaskV2] = Relationship(
-        sa_relationship_kwargs=dict(lazy="selectin")
-    )
-    task_legacy_id: Optional[int] = Field(foreign_key="task.id")
-    task_legacy: Optional[Task] = Relationship(
-        sa_relationship_kwargs=dict(lazy="selectin")
-    )
+    task_id: int = Field(foreign_key="taskv2.id")
+    task: TaskV2 = Relationship(sa_relationship_kwargs=dict(lazy="selectin"))

fractal_server/app/routes/admin/v2.py

@@ -24,7 +24,6 @@ from ....utils import get_timestamp
 from ....zip_tools import _zip_folder_to_byte_stream_iterator
 from ...db import AsyncSession
 from ...db import get_async_db
-from ...models.v1 import Task
 from ...models.v2 import JobV2
 from ...models.v2 import ProjectV2
 from ...models.v2 import TaskV2
@@ -281,35 +280,6 @@ async def download_job_logs(
     )
 
 
-class TaskCompatibility(BaseModel):
-    is_v2_compatible: bool
-
-
-@router_admin_v2.patch(
-    "/task-v1/{task_id}/",
-    status_code=status.HTTP_200_OK,
-)
-async def flag_task_v1_as_v2_compatible(
-    task_id: int,
-    compatibility: TaskCompatibility,
-    user: UserOAuth = Depends(current_active_superuser),
-    db: AsyncSession = Depends(get_async_db),
-) -> Response:
-
-    task = await db.get(Task, task_id)
-    if task is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Task {task_id} not found",
-        )
-
-    task.is_v2_compatible = compatibility.is_v2_compatible
-    await db.commit()
-    await db.close()
-
-    return Response(status_code=status.HTTP_200_OK)
-
-
 class TaskV2Minimal(BaseModel):
 
     id: int

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

@@ -12,7 +12,6 @@ from .submit import router as submit_job_router_v2
 from .task import router as task_router_v2
 from .task_collection import router as task_collection_router_v2
 from .task_collection_custom import router as task_collection_router_v2_custom
-from .task_legacy import router as task_legacy_router_v2
 from .workflow import router as workflow_router_v2
 from .workflowtask import router as workflowtask_router_v2
 from fractal_server.config import get_settings
@@ -38,9 +37,6 @@ router_api_v2.include_router(
     tags=["V2 Task Collection"],
 )
 router_api_v2.include_router(task_router_v2, prefix="/task", tags=["V2 Task"])
-router_api_v2.include_router(
-    task_legacy_router_v2, prefix="/task-legacy", tags=["V2 Task Legacy"]
-)
 router_api_v2.include_router(workflow_router_v2, tags=["V2 Workflow"])
 router_api_v2.include_router(workflowtask_router_v2, tags=["V2 WorkflowTask"])
 router_api_v2.include_router(status_router_v2, tags=["V2 Status"])

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

@@ -13,7 +13,6 @@ from sqlmodel import select
 from sqlmodel.sql.expression import SelectOfScalar
 
 from ....db import AsyncSession
-from ....models.v1 import Task
 from ....models.v2 import DatasetV2
 from ....models.v2 import JobV2
 from ....models.v2 import LinkUserProjectV2
@@ -389,7 +388,6 @@ async def _workflow_insert_task(
     *,
     workflow_id: int,
     task_id: int,
-    is_legacy_task: bool = False,
     order: Optional[int] = None,
     meta_parallel: Optional[dict[str, Any]] = None,
     meta_non_parallel: Optional[dict[str, Any]] = None,
@@ -404,7 +402,7 @@ async def _workflow_insert_task(
     Args:
         workflow_id:
         task_id:
-        is_legacy_task:
+
         order:
         meta_parallel:
         meta_non_parallel:
@@ -420,52 +418,21 @@ async def _workflow_insert_task(
     if order is None:
         order = len(db_workflow.task_list)
 
-    # Get task from db, and extract default arguments via a Task property
-    # method
-    # NOTE: this logic remains there for V1 tasks only. When we deprecate V1
-    # tasks, we can simplify this block
-    if is_legacy_task is True:
-        db_task = await db.get(Task, task_id)
-        if db_task is None:
-            raise ValueError(f"Task {task_id} not found.")
-        task_type = "parallel"
-
-        final_args_parallel = db_task.default_args_from_args_schema.copy()
-        final_args_non_parallel = {}
-        final_meta_parallel = (db_task.meta or {}).copy()
-        final_meta_non_parallel = {}
-
-    else:
-        db_task = await db.get(TaskV2, task_id)
-        if db_task is None:
-            raise ValueError(f"TaskV2 {task_id} not found.")
-        task_type = db_task.type
-
-        final_args_non_parallel = {}
-        final_args_parallel = {}
-        final_meta_parallel = (db_task.meta_parallel or {}).copy()
-        final_meta_non_parallel = (db_task.meta_non_parallel or {}).copy()
-
-    # Combine arg_parallel
-    if args_parallel is not None:
-        for k, v in args_parallel.items():
-            final_args_parallel[k] = v
-    if final_args_parallel == {}:
-        final_args_parallel = None
-    # Combine arg_non_parallel
-    if args_non_parallel is not None:
-        for k, v in args_non_parallel.items():
-            final_args_non_parallel[k] = v
-    if final_args_non_parallel == {}:
-        final_args_non_parallel = None
+    # Get task from db
+    db_task = await db.get(TaskV2, task_id)
+    if db_task is None:
+        raise ValueError(f"TaskV2 {task_id} not found.")
+    task_type = db_task.type
 
     # Combine meta_parallel (higher priority)
     # and db_task.meta_parallel (lower priority)
+    final_meta_parallel = (db_task.meta_parallel or {}).copy()
     final_meta_parallel.update(meta_parallel or {})
     if final_meta_parallel == {}:
         final_meta_parallel = None
     # Combine meta_non_parallel (higher priority)
     # and db_task.meta_non_parallel (lower priority)
+    final_meta_non_parallel = (db_task.meta_non_parallel or {}).copy()
     final_meta_non_parallel.update(meta_non_parallel or {})
     if final_meta_non_parallel == {}:
         final_meta_non_parallel = None
@@ -479,11 +446,9 @@ async def _workflow_insert_task(
     # Create DB entry
     wf_task = WorkflowTaskV2(
         task_type=task_type,
-        is_legacy_task=is_legacy_task,
-        task_id=(task_id if not is_legacy_task else None),
-        task_legacy_id=(task_id if is_legacy_task else None),
-        args_non_parallel=final_args_non_parallel,
-        args_parallel=final_args_parallel,
+        task_id=task_id,
+        args_non_parallel=args_non_parallel,
+        args_parallel=args_parallel,
         meta_parallel=final_meta_parallel,
         meta_non_parallel=final_meta_non_parallel,
         **input_filters_kwarg,

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

@@ -11,7 +11,6 @@ from .....logger import reset_logger_handlers
 from .....logger import set_logger
 from ....db import AsyncSession
 from ....db import get_async_db
-from ....models.v1 import Task as TaskV1
 from ....models.v2 import JobV2
 from ....models.v2 import ProjectV2
 from ....models.v2 import TaskV2
@@ -242,23 +241,13 @@ async def export_worfklow(
     # Emit a warning when exporting a workflow with custom tasks
     logger = set_logger(None)
     for wftask in workflow.task_list:
-        if wftask.is_legacy_task:
-            if wftask.task_legacy.owner is not None:
-                logger.warning(
-                    f"Custom tasks (like the one with "
-                    f"id={wftask.task_legacy_id} and "
-                    f"source='{wftask.task_legacy.source}') are not meant to "
-                    "be portable; re-importing this workflow may not work as "
-                    "expected."
-                )
-        else:
-            if wftask.task.owner is not None:
-                logger.warning(
-                    f"Custom tasks (like the one with id={wftask.task_id} and "
-                    f'source="{wftask.task.source}") are not meant to be '
-                    "portable; re-importing this workflow may not work as "
-                    "expected."
-                )
+        if wftask.task.owner is not None:
+            logger.warning(
+                f"Custom tasks (like the one with id={wftask.task_id} and "
+                f'source="{wftask.task.source}") are not meant to be '
+                "portable; re-importing this workflow may not work as "
+                "expected."
+            )
     reset_logger_handlers(logger)
 
     await db.close()
@@ -296,38 +285,22 @@ async def import_workflow(
 
     # Check that all required tasks are available
     source_to_id = {}
-    source_to_id_legacy = {}
 
     for wf_task in workflow.task_list:
 
-        if wf_task.is_legacy_task is True:
-            source = wf_task.task_legacy.source
-            if source not in source_to_id_legacy.keys():
-                stm = select(TaskV1).where(TaskV1.source == source)
-                tasks_by_source = (await db.execute(stm)).scalars().all()
-                if len(tasks_by_source) != 1:
-                    raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            f"Found {len(tasks_by_source)} tasks legacy "
-                            f"with {source=}."
-                        ),
-                    )
-                source_to_id_legacy[source] = tasks_by_source[0].id
-        else:
-            source = wf_task.task.source
-            if source not in source_to_id.keys():
-                stm = select(TaskV2).where(TaskV2.source == source)
-                tasks_by_source = (await db.execute(stm)).scalars().all()
-                if len(tasks_by_source) != 1:
-                    raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            f"Found {len(tasks_by_source)} tasks "
-                            f"with {source=}."
-                        ),
-                    )
-                source_to_id[source] = tasks_by_source[0].id
+        source = wf_task.task.source
+        if source not in source_to_id.keys():
+            stm = select(TaskV2).where(TaskV2.source == source)
+            tasks_by_source = (await db.execute(stm)).scalars().all()
+            if len(tasks_by_source) != 1:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=(
+                        f"Found {len(tasks_by_source)} tasks "
+                        f"with {source=}."
+                    ),
+                )
+            source_to_id[source] = tasks_by_source[0].id
 
     # Create new Workflow (with empty task_list)
     db_workflow = WorkflowV2(
@@ -341,15 +314,11 @@ async def import_workflow(
     # Insert tasks
 
     for wf_task in workflow.task_list:
-        if wf_task.is_legacy_task is True:
-            source = wf_task.task_legacy.source
-            task_id = source_to_id_legacy[source]
-        else:
-            source = wf_task.task.source
-            task_id = source_to_id[source]
+        source = wf_task.task.source
+        task_id = source_to_id[source]
 
         new_wf_task = WorkflowTaskCreateV2(
-            **wf_task.dict(exclude_none=True, exclude={"task", "task_legacy"})
+            **wf_task.dict(exclude_none=True, exclude={"task"})
         )
         # Insert task
         await _workflow_insert_task(

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

@@ -9,7 +9,6 @@ from fastapi import status
 
 from ....db import AsyncSession
 from ....db import get_async_db
-from ....models.v1 import Task
 from ....models.v2 import TaskV2
 from ....schemas.v2 import WorkflowTaskCreateV2
 from ....schemas.v2 import WorkflowTaskReadV2
@@ -44,27 +43,14 @@ async def create_workflowtask(
         project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
     )
 
-    if new_task.is_legacy_task is True:
-        task = await db.get(Task, task_id)
-        if not task:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Task {task_id} not found.",
-            )
-        if not task.is_v2_compatible:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"Task {task_id} is not V2-compatible.",
-            )
-    else:
-        task = await db.get(TaskV2, task_id)
-        if not task:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"TaskV2 {task_id} not found.",
-            )
+    task = await db.get(TaskV2, task_id)
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TaskV2 {task_id} not found.",
+        )
 
-    if new_task.is_legacy_task is True or task.type == "parallel":
+    if task.type == "parallel":
         if (
             new_task.meta_non_parallel is not None
             or new_task.args_non_parallel is not None
@@ -74,7 +60,7 @@ async def create_workflowtask(
                 detail=(
                     "Cannot set `WorkflowTaskV2.meta_non_parallel` or "
                     "`WorkflowTask.args_non_parallel` if the associated Task "
-                    "is `parallel` (or legacy)."
+                    "is `parallel`."
                 ),
             )
     elif task.type == "non_parallel":
@@ -93,7 +79,6 @@ async def create_workflowtask(
 
     workflow_task = await _workflow_insert_task(
         workflow_id=workflow.id,
-        is_legacy_task=new_task.is_legacy_task,
         task_id=task_id,
         order=new_task.order,
         meta_non_parallel=new_task.meta_non_parallel,
@@ -182,16 +167,7 @@ async def update_workflowtask(
     for key, value in workflow_task_update.dict(exclude_unset=True).items():
         if key == "args_parallel":
             # Get default arguments via a Task property method
-            if db_wf_task.is_legacy_task:
-                default_args = (
-                    db_wf_task.task_legacy.default_args_from_args_schema
-                )
-                actual_args = deepcopy(default_args)
-                if value is not None:
-                    for k, v in value.items():
-                        actual_args[k] = v
-            else:
-                actual_args = deepcopy(value)
+            actual_args = deepcopy(value)
             if not actual_args:
                 actual_args = None
             setattr(db_wf_task, key, actual_args)

fractal_server/app/runner/v2/__init__.py

@@ -208,10 +208,7 @@ async def submit_workflow(
             # Create all tasks subfolders
             for order in range(job.first_task_index, job.last_task_index + 1):
                 this_wftask = workflow.task_list[order]
-                if this_wftask.is_legacy_task:
-                    task_name = this_wftask.task_legacy.name
-                else:
-                    task_name = this_wftask.task.name
+                task_name = this_wftask.task.name
                 subfolder_name = task_subfolder_name(
                     order=order,
                     task_name=task_name,

fractal_server/app/runner/v2/_slurm_common/get_slurm_config.py

@@ -116,10 +116,7 @@ def get_slurm_config(
         slurm_dict["mem_per_task_MB"] = mem_per_task_MB
 
     # Job name
-    if wftask.is_legacy_task:
-        job_name = wftask.task_legacy.name.replace(" ", "_")
-    else:
-        job_name = wftask.task.name.replace(" ", "_")
+    job_name = wftask.task.name.replace(" ", "_")
     slurm_dict["job_name"] = job_name
 
     # Optional SLURM arguments and extra lines

fractal_server/app/runner/v2/handle_failed_job.py

@@ -96,15 +96,8 @@ def assemble_history_failed_job(
 
     # Part 3/B: Append failed task to history
     if failed_wftask is not None:
-        failed_wftask_dump = failed_wftask.model_dump(
-            exclude={"task", "task_legacy"}
-        )
-        if failed_wftask.is_legacy_task:
-            failed_wftask_dump[
-                "task_legacy"
-            ] = failed_wftask.task_legacy.model_dump()
-        else:
-            failed_wftask_dump["task"] = failed_wftask.task.model_dump()
+        failed_wftask_dump = failed_wftask.model_dump(exclude={"task"})
+        failed_wftask_dump["task"] = failed_wftask.task.model_dump()
         new_history_item = dict(
             workflowtask=failed_wftask_dump,
             status=WorkflowTaskStatusTypeV2.FAILED,

fractal_server/app/runner/v2/runner.py

@@ -17,7 +17,6 @@ from ..filenames import FILTERS_FILENAME
 from ..filenames import HISTORY_FILENAME
 from ..filenames import IMAGES_FILENAME
 from .runner_functions import no_op_submit_setup_call
-from .runner_functions import run_v1_task_parallel
 from .runner_functions import run_v2_task_compound
 from .runner_functions import run_v2_task_non_parallel
 from .runner_functions import run_v2_task_parallel
@@ -53,16 +52,8 @@ def execute_tasks_v2(
 
     for wftask in wf_task_list:
         task = wftask.task
-        task_legacy = wftask.task_legacy
-        if wftask.is_legacy_task:
-            task_name = task_legacy.name
-            logger.debug(
-                f"SUBMIT {wftask.order}-th task "
-                f'(legacy, name="{task_name}")'
-            )
-        else:
-            task_name = task.name
-            logger.debug(f'SUBMIT {wftask.order}-th task (name="{task_name}")')
+        task_name = task.name
+        logger.debug(f'SUBMIT {wftask.order}-th task (name="{task_name}")')
 
         # PRE TASK EXECUTION
 
@@ -78,67 +69,53 @@ def execute_tasks_v2(
             filters=Filters(**pre_filters),
         )
         # Verify that filtered images comply with task input_types
-        if not wftask.is_legacy_task:
-            for image in filtered_images:
-                if not match_filter(image, Filters(types=task.input_types)):
-                    raise JobExecutionError(
-                        "Invalid filtered image list\n"
-                        f"Task input types: {task.input_types=}\n"
-                        f'Image zarr_url: {image["zarr_url"]}\n'
-                        f'Image types: {image["types"]}\n'
-                    )
+        for image in filtered_images:
+            if not match_filter(image, Filters(types=task.input_types)):
+                raise JobExecutionError(
+                    "Invalid filtered image list\n"
+                    f"Task input types: {task.input_types=}\n"
+                    f'Image zarr_url: {image["zarr_url"]}\n'
+                    f'Image types: {image["types"]}\n'
+                )
 
         # TASK EXECUTION (V2)
-        if not wftask.is_legacy_task:
-            if task.type == "non_parallel":
-                current_task_output = run_v2_task_non_parallel(
-                    images=filtered_images,
-                    zarr_dir=zarr_dir,
-                    wftask=wftask,
-                    task=task,
-                    workflow_dir_local=workflow_dir_local,
-                    workflow_dir_remote=workflow_dir_remote,
-                    executor=executor,
-                    logger_name=logger_name,
-                    submit_setup_call=submit_setup_call,
-                )
-            elif task.type == "parallel":
-                current_task_output = run_v2_task_parallel(
-                    images=filtered_images,
-                    wftask=wftask,
-                    task=task,
-                    workflow_dir_local=workflow_dir_local,
-                    workflow_dir_remote=workflow_dir_remote,
-                    executor=executor,
-                    logger_name=logger_name,
-                    submit_setup_call=submit_setup_call,
-                )
-            elif task.type == "compound":
-                current_task_output = run_v2_task_compound(
-                    images=filtered_images,
-                    zarr_dir=zarr_dir,
-                    wftask=wftask,
-                    task=task,
-                    workflow_dir_local=workflow_dir_local,
-                    workflow_dir_remote=workflow_dir_remote,
-                    executor=executor,
-                    logger_name=logger_name,
-                    submit_setup_call=submit_setup_call,
-                )
-            else:
-                raise ValueError(f"Unexpected error: Invalid {task.type=}.")
-        # TASK EXECUTION (V1)
-        else:
-            current_task_output = run_v1_task_parallel(
+        if task.type == "non_parallel":
+            current_task_output = run_v2_task_non_parallel(
                 images=filtered_images,
+                zarr_dir=zarr_dir,
                 wftask=wftask,
-                task_legacy=task_legacy,
+                task=task,
+                workflow_dir_local=workflow_dir_local,
+                workflow_dir_remote=workflow_dir_remote,
                 executor=executor,
                 logger_name=logger_name,
+                submit_setup_call=submit_setup_call,
+            )
+        elif task.type == "parallel":
+            current_task_output = run_v2_task_parallel(
+                images=filtered_images,
+                wftask=wftask,
+                task=task,
+                workflow_dir_local=workflow_dir_local,
+                workflow_dir_remote=workflow_dir_remote,
+                executor=executor,
+                logger_name=logger_name,
+                submit_setup_call=submit_setup_call,
+            )
+        elif task.type == "compound":
+            current_task_output = run_v2_task_compound(
+                images=filtered_images,
+                zarr_dir=zarr_dir,
+                wftask=wftask,
+                task=task,
                 workflow_dir_local=workflow_dir_local,
                 workflow_dir_remote=workflow_dir_remote,
+                executor=executor,
+                logger_name=logger_name,
                 submit_setup_call=submit_setup_call,
             )
+        else:
+            raise ValueError(f"Unexpected error: Invalid {task.type=}.")
 
         # POST TASK EXECUTION
 
@@ -191,8 +168,7 @@ def execute_tasks_v2(
                 # Update image attributes/types with task output and manifest
                 updated_attributes.update(image["attributes"])
                 updated_types.update(image["types"])
-                if not wftask.is_legacy_task:
-                    updated_types.update(task.output_types)
+                updated_types.update(task.output_types)
 
                 # Unset attributes with None value
                 updated_attributes = {
@@ -249,8 +225,7 @@ def execute_tasks_v2(
                     if value is not None
                 }
                 updated_types.update(image["types"])
-                if not wftask.is_legacy_task:
-                    updated_types.update(task.output_types)
+                updated_types.update(task.output_types)
                 new_image = dict(
                     zarr_url=image["zarr_url"],
                     origin=image["origin"],
@@ -282,10 +257,7 @@ def execute_tasks_v2(
             )
 
         # Find manifest ouptut types
-        if wftask.is_legacy_task:
-            types_from_manifest = {}
-        else:
-            types_from_manifest = task.output_types
+        types_from_manifest = task.output_types
 
         # Find task-output types
         if current_task_output.filters is not None: