fractal-server 2.4.1__tar.gz → 2.5.0a0__tar.gz

{fractal_server-2.4.1 → fractal_server-2.5.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.4.1
+Version: 2.5.0a0
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause

fractal_server-2.5.0a0/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.5.0a0"

{fractal_server-2.4.1 → fractal_server-2.5.0a0}/fractal_server/__main__.py

@@ -88,12 +88,11 @@ def set_db():
     alembic.config.main(argv=alembic_args)
     print("END: alembic.config")
     # Insert default group
-    print("START: Default group creation")
+    print()
     _create_first_group()
-    print("END: Default group creation")
+    print()
     # NOTE: It will be fixed with #1739
     settings = Inject(get_settings)
-    print("START: First user creation")
     asyncio.run(
         _create_first_user(
             email=settings.FRACTAL_DEFAULT_ADMIN_EMAIL,
@@ -103,7 +102,7 @@ def set_db():
             is_verified=True,
         )
     )
-    print("END: First user creation")
+    print()
 
 
 def update_db_data():

{fractal_server-2.4.1 → fractal_server-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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/fractal_server/app/runner/executors/slurm/sudo/_subprocess_run_as_user.py

@@ -49,7 +49,7 @@ def _run_command_as_user(
     """
     logger.debug(f'[_run_command_as_user] {user=}, cmd="{cmd}"')
     if user:
-        new_cmd = f"sudo --non-interactive -u {user} {cmd}"
+        new_cmd = f"sudo --set-home --non-interactive -u {user} {cmd}"
     else:
         new_cmd = cmd
     res = subprocess.run(  # nosec

{fractal_server-2.4.1 → fractal_server-2.5.0a0}/fractal_server/app/runner/executors/slurm/sudo/executor.py

@@ -1134,7 +1134,7 @@ class FractalSlurmExecutor(SlurmExecutor):
             f.write(sbatch_script)
 
         # Prepare submission command
-        pre_command = f"sudo --non-interactive -u {self.slurm_user}"
+        pre_command = f"sudo --set-home --non-interactive -u {self.slurm_user}"
         submit_command = f"sbatch --parsable {job.slurm_script}"
         full_command = f"{pre_command} {submit_command}"
 

{fractal_server-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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-2.4.1 → fractal_server-2.5.0a0}/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,