fractal-server 1.3.14a0__tar.gz → 1.4.0a1__tar.gz

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/PKG-INFO

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

fractal_server-1.4.0a1/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "1.4.0a1"

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/api/__init__.py

@@ -7,6 +7,7 @@ from ...config import get_settings
 from ...syringe import Inject
 from .v1.dataset import router as dataset_router
 from .v1.job import router as job_router
+from .v1.monitoring import router as router_monitoring  # noqa
 from .v1.project import router as project_router
 from .v1.task import router as task_router
 from .v1.task_collection import router as taskcollection_router

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/api/v1/dataset.py

@@ -7,20 +7,19 @@ from fastapi import Depends
 from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
-from sqlmodel import or_
 from sqlmodel import select
 
 from ...db import AsyncSession
 from ...db import get_db
 from ...models import ApplyWorkflow
 from ...models import Dataset
-from ...models import JobStatusType
 from ...models import Resource
 from ...runner._common import HISTORY_FILENAME
 from ...schemas import DatasetCreate
 from ...schemas import DatasetRead
 from ...schemas import DatasetStatusRead
 from ...schemas import DatasetUpdate
+from ...schemas import JobStatusType
 from ...schemas import ResourceCreate
 from ...schemas import ResourceRead
 from ...schemas import ResourceUpdate
@@ -145,24 +144,6 @@ async def delete_dataset(
     )
     dataset = output["dataset"]
 
-    # Check that no ApplyWorkflow is in relationship with the current Dataset
-    stm = select(ApplyWorkflow).filter(
-        or_(
-            ApplyWorkflow.input_dataset_id == dataset_id,
-            ApplyWorkflow.output_dataset_id == dataset_id,
-        )
-    )
-    res = await db.execute(stm)
-    job = res.scalars().first()
-    if job:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Cannot remove dataset {dataset_id}: "
-                f"it's still linked to job {job.id}."
-            ),
-        )
-
     await db.delete(dataset)
     await db.commit()
     await db.close()

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/api/v1/job.py

@@ -7,6 +7,7 @@ from zipfile import ZipFile
 from fastapi import APIRouter
 from fastapi import Depends
 from fastapi import HTTPException
+from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
 from sqlmodel import select
@@ -22,11 +23,50 @@ from ...security import current_active_user
 from ...security import User
 from ._aux_functions import _get_job_check_owner
 from ._aux_functions import _get_project_check_owner
+from ._aux_functions import _get_workflow_check_owner
 
 
 router = APIRouter()
 
 
+@router.get("/project/job/", response_model=list[ApplyWorkflowRead])
+async def get_user_jobs(
+    user: User = Depends(current_active_user),
+) -> list[ApplyWorkflowRead]:
+    """
+    Returns all the jobs of the current user
+    """
+
+    job_list = [
+        job for project in user.project_list for job in project.job_list
+    ]
+
+    return job_list
+
+
+@router.get(
+    "/project/{project_id}/workflow/{workflow_id}/job/",
+    response_model=list[ApplyWorkflowRead],
+)
+async def get_workflow_jobs(
+    project_id: int,
+    workflow_id: int,
+    user: User = Depends(current_active_user),
+    db: AsyncSession = Depends(get_db),
+) -> Optional[list[ApplyWorkflowRead]]:
+    """
+    Returns all the jobs related to a specific workflow
+    """
+
+    workflow = await _get_workflow_check_owner(
+        project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
+    )
+    job_list = workflow.job_list
+    await db.close()
+
+    return job_list
+
+
 @router.get(
     "/project/{project_id}/job/{job_id}",
     response_model=ApplyWorkflowRead,
@@ -119,14 +159,14 @@ async def get_job_list(
 
 @router.get(
     "/project/{project_id}/job/{job_id}/stop/",
-    status_code=200,
+    status_code=204,
 )
 async def stop_job(
     project_id: int,
     job_id: int,
     user: User = Depends(current_active_user),
     db: AsyncSession = Depends(get_db),
-) -> Optional[ApplyWorkflow]:
+) -> Response:
     """
     Stop execution of a workflow job (only available for slurm backend)
     """
@@ -161,4 +201,4 @@ async def stop_job(
     with shutdown_file.open("w") as f:
         f.write(f"Trigger executor shutdown for {job.id=}, {project_id=}.")
 
-    return job
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

fractal_server-1.4.0a1/fractal_server/app/api/v1/monitoring.py

@@ -0,0 +1,150 @@
+from datetime import datetime
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlalchemy import func
+from sqlmodel import select
+
+from ...db import AsyncSession
+from ...db import get_db
+from ...models import ApplyWorkflow
+from ...models import Dataset
+from ...models import JobStatusType
+from ...models import Project
+from ...models import Workflow
+from ...schemas import ApplyWorkflowRead
+from ...schemas import DatasetRead
+from ...schemas import ProjectRead
+from ...schemas import WorkflowRead
+from ...security import current_active_superuser
+from ...security import User
+
+
+router = APIRouter()
+
+
+@router.get("/project/", response_model=list[ProjectRead])
+async def monitor_project(
+    id: Optional[int] = None,
+    user_id: Optional[int] = None,
+    user: User = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_db),
+) -> list[ProjectRead]:
+
+    stm = select(Project)
+
+    if id is not None:
+        stm = stm.where(Project.id == id)
+
+    if user_id is not None:
+        stm = stm.where(Project.user_list.any(User.id == user_id))
+
+    res = await db.execute(stm)
+    project_list = res.scalars().all()
+    await db.close()
+
+    return project_list
+
+
+@router.get("/workflow/", response_model=list[WorkflowRead])
+async def monitor_workflow(
+    id: Optional[int] = None,
+    project_id: Optional[int] = None,
+    name_contains: Optional[str] = None,
+    user: User = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_db),
+) -> list[WorkflowRead]:
+    stm = select(Workflow)
+
+    if id is not None:
+        stm = stm.where(Workflow.id == id)
+    if project_id is not None:
+        stm = stm.where(Workflow.project_id == project_id)
+    if name_contains is not None:
+        # SQLAlchemy2: use icontains
+        stm = stm.where(
+            func.lower(Workflow.name).contains(name_contains.lower())
+        )
+
+    res = await db.execute(stm)
+    workflow_list = res.scalars().all()
+    await db.close()
+
+    return workflow_list
+
+
+@router.get("/dataset/", response_model=list[DatasetRead])
+async def monitor_dataset(
+    id: Optional[int] = None,
+    project_id: Optional[int] = None,
+    name_contains: Optional[str] = None,
+    type: Optional[str] = None,
+    user: User = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_db),
+) -> list[DatasetRead]:
+    stm = select(Dataset)
+
+    if id is not None:
+        stm = stm.where(Dataset.id == id)
+    if project_id is not None:
+        stm = stm.where(Dataset.project_id == project_id)
+    if name_contains is not None:
+        # SQLAlchemy2: use icontains
+        stm = stm.where(
+            func.lower(Dataset.name).contains(name_contains.lower())
+        )
+    if type is not None:
+        stm = stm.where(Dataset.type == type)
+
+    res = await db.execute(stm)
+    dataset_list = res.scalars().all()
+    await db.close()
+
+    return dataset_list
+
+
+@router.get("/job/", response_model=list[ApplyWorkflowRead])
+async def monitor_job(
+    id: Optional[int] = None,
+    project_id: Optional[int] = None,
+    input_dataset_id: Optional[int] = None,
+    output_dataset_id: Optional[int] = None,
+    workflow_id: Optional[int] = None,
+    status: Optional[JobStatusType] = None,
+    start_timestamp_min: Optional[datetime] = None,
+    start_timestamp_max: Optional[datetime] = None,
+    end_timestamp_min: Optional[datetime] = None,
+    end_timestamp_max: Optional[datetime] = None,
+    user: User = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_db),
+) -> list[ApplyWorkflowRead]:
+
+    stm = select(ApplyWorkflow)
+
+    if id is not None:
+        stm = stm.where(ApplyWorkflow.id == id)
+    if project_id is not None:
+        stm = stm.where(ApplyWorkflow.project_id == project_id)
+    if input_dataset_id is not None:
+        stm = stm.where(ApplyWorkflow.input_dataset_id == input_dataset_id)
+    if output_dataset_id is not None:
+        stm = stm.where(ApplyWorkflow.output_dataset_id == output_dataset_id)
+    if workflow_id is not None:
+        stm = stm.where(ApplyWorkflow.workflow_id == workflow_id)
+    if status is not None:
+        stm = stm.where(ApplyWorkflow.status == status)
+    if start_timestamp_min is not None:
+        stm = stm.where(ApplyWorkflow.start_timestamp >= start_timestamp_min)
+    if start_timestamp_max is not None:
+        stm = stm.where(ApplyWorkflow.start_timestamp <= start_timestamp_max)
+    if end_timestamp_min is not None:
+        stm = stm.where(ApplyWorkflow.end_timestamp >= end_timestamp_min)
+    if end_timestamp_max is not None:
+        stm = stm.where(ApplyWorkflow.end_timestamp <= end_timestamp_max)
+
+    res = await db.execute(stm)
+    job_list = res.scalars().all()
+    await db.close()
+
+    return job_list

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/api/v1/project.py

@@ -18,7 +18,6 @@ from ...db import DBSyncSession
 from ...db import get_db
 from ...db import get_sync_db
 from ...models import ApplyWorkflow
-from ...models import JobStatusType
 from ...models import LinkUserProject
 from ...models import Project
 from ...runner import submit_workflow
@@ -26,6 +25,7 @@ from ...runner import validate_workflow_compatibility
 from ...runner.common import set_start_and_last_task_index
 from ...schemas import ApplyWorkflowCreate
 from ...schemas import ApplyWorkflowRead
+from ...schemas import JobStatusType
 from ...schemas import ProjectCreate
 from ...schemas import ProjectRead
 from ...schemas import ProjectUpdate
@@ -302,10 +302,13 @@ async def apply_workflow(
         input_dataset_id=input_dataset_id,
         output_dataset_id=output_dataset_id,
         workflow_id=workflow_id,
+        user_email=user.email,
+        input_dataset_dump=input_dataset.dict(),
+        output_dataset_dump=output_dataset.dict(),
         workflow_dump=dict(
             workflow.dict(exclude={"task_list"}),
             task_list=[
-                dict(wf_task.task.dict(exclude={"task"}), task=wf_task.dict())
+                dict(wf_task.dict(exclude={"task"}), task=wf_task.task.dict())
                 for wf_task in workflow.task_list
             ],
         ),

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/api/v1/workflow.py

@@ -23,7 +23,6 @@ from ....logger import close_logger
 from ....logger import set_logger
 from ...db import AsyncSession
 from ...db import get_db
-from ...models import ApplyWorkflow
 from ...models import Task
 from ...models import Workflow
 from ...schemas import WorkflowCreate
@@ -186,19 +185,6 @@ async def delete_workflow(
         project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
     )
 
-    # Check that no ApplyWorkflow is in relationship with the current Workflow
-    stm = select(ApplyWorkflow).where(ApplyWorkflow.workflow_id == workflow_id)
-    res = await db.execute(stm)
-    job = res.scalars().first()
-    if job:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Cannot remove workflow {workflow_id}: "
-                f"it's still linked to job {job.id}."
-            ),
-        )
-
     await db.delete(workflow)
     await db.commit()
 

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/models/dataset.py

@@ -10,6 +10,7 @@ from sqlmodel import SQLModel
 
 from ..schemas.dataset import _DatasetBase
 from ..schemas.dataset import _ResourceBase
+from .job import ApplyWorkflow
 
 
 class Resource(_ResourceBase, SQLModel, table=True):
@@ -37,6 +38,19 @@ class Dataset(_DatasetBase, SQLModel, table=True):
 
     id: Optional[int] = Field(default=None, primary_key=True)
     project_id: int = Field(foreign_key="project.id")
+
+    list_jobs_input: list[ApplyWorkflow] = Relationship(  # noqa: F821
+        sa_relationship_kwargs=dict(
+            lazy="selectin",
+            primaryjoin="ApplyWorkflow.input_dataset_id==Dataset.id",
+        )
+    )
+    list_jobs_output: list[ApplyWorkflow] = Relationship(  # noqa: F821
+        sa_relationship_kwargs=dict(
+            lazy="selectin",
+            primaryjoin="ApplyWorkflow.output_dataset_id==Dataset.id",
+        )
+    )
     resource_list: list[Resource] = Relationship(
         sa_relationship_kwargs={
             "lazy": "selectin",
@@ -45,6 +59,7 @@ class Dataset(_DatasetBase, SQLModel, table=True):
             "cascade": "all, delete-orphan",
         }
     )
+
     meta: dict[str, Any] = Field(sa_column=Column(JSON), default={})
     history: list[dict[str, Any]] = Field(
         sa_column=Column(JSON, server_default="[]", nullable=False)

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/models/job.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-from enum import Enum
 from typing import Any
 from typing import Optional
 
@@ -7,38 +6,11 @@ from sqlalchemy import Column
 from sqlalchemy.types import DateTime
 from sqlalchemy.types import JSON
 from sqlmodel import Field
-from sqlmodel import Relationship
 from sqlmodel import SQLModel
 
 from ...utils import get_timestamp
+from ..schemas import JobStatusType
 from ..schemas.applyworkflow import _ApplyWorkflowBase
-from .dataset import Dataset
-from .workflow import Workflow
-
-
-class JobStatusType(str, Enum):
-    """
-    Define the job status available
-
-    Attributes:
-        SUBMITTED:
-            The workflow has been applied but not yet scheduled with an
-            executor. In this phase, due diligence takes place, such as
-            creating working directory, assemblying arguments, etc.
-        RUNNING:
-            The workflow was scheduled with an executor. Note that it might not
-            yet be running within the executor, e.g., jobs could still be
-            pending within a SLURM executor.
-        DONE:
-            The workflow was applied successfully
-        FAILED:
-            The workflow terminated with an error.
-    """
-
-    SUBMITTED = "submitted"
-    RUNNING = "running"
-    DONE = "done"
-    FAILED = "failed"
 
 
 class ApplyWorkflow(_ApplyWorkflowBase, SQLModel, table=True):
@@ -87,37 +59,36 @@ class ApplyWorkflow(_ApplyWorkflowBase, SQLModel, table=True):
         arbitrary_types_allowed = True
 
     id: Optional[int] = Field(default=None, primary_key=True)
-    project_id: int = Field(foreign_key="project.id")
-    input_dataset_id: int = Field(foreign_key="dataset.id")
-    output_dataset_id: int = Field(foreign_key="dataset.id")
-    workflow_id: int = Field(foreign_key="workflow.id")
-    working_dir: Optional[str]
-    working_dir_user: Optional[str]
-    first_task_index: int
-    last_task_index: int
 
-    input_dataset: Dataset = Relationship(
-        sa_relationship_kwargs=dict(
-            lazy="selectin",
-            primaryjoin="ApplyWorkflow.input_dataset_id==Dataset.id",
-        )
+    project_id: Optional[int] = Field(foreign_key="project.id")
+
+    workflow_id: Optional[int] = Field(foreign_key="workflow.id")
+
+    input_dataset_id: Optional[int] = Field(foreign_key="dataset.id")
+    output_dataset_id: Optional[int] = Field(foreign_key="dataset.id")
+
+    user_email: str = Field(nullable=False)
+    input_dataset_dump: dict[str, Any] = Field(
+        sa_column=Column(JSON, nullable=False)
+    )
+    output_dataset_dump: dict[str, Any] = Field(
+        sa_column=Column(JSON, nullable=False)
     )
-    output_dataset: Dataset = Relationship(
-        sa_relationship_kwargs=dict(
-            lazy="selectin",
-            primaryjoin="ApplyWorkflow.output_dataset_id==Dataset.id",
-        )
+    workflow_dump: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON, nullable=True)
     )
-    workflow: Workflow = Relationship()
 
-    workflow_dump: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
+    working_dir: Optional[str]
+    working_dir_user: Optional[str]
+    first_task_index: int
+    last_task_index: int
 
     start_timestamp: datetime = Field(
         default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True)),
+        sa_column=Column(DateTime(timezone=True), nullable=False),
     )
     end_timestamp: Optional[datetime] = Field(
         default=None, sa_column=Column(DateTime(timezone=True))
     )
-    status: JobStatusType = JobStatusType.SUBMITTED
+    status: str = JobStatusType.SUBMITTED
     log: Optional[str] = None

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/models/project.py

@@ -37,9 +37,8 @@ class Project(_ProjectBase, SQLModel, table=True):
         },
     )
 
-    job_list: list[ApplyWorkflow] = Relationship(  # noqa
+    job_list: list[ApplyWorkflow] = Relationship(
         sa_relationship_kwargs={
             "lazy": "selectin",
-            "cascade": "all, delete-orphan",
-        },
+        }
     )

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/models/workflow.py

@@ -13,6 +13,7 @@ from sqlmodel import SQLModel
 from ..db import AsyncSession
 from ..schemas.workflow import _WorkflowBase
 from ..schemas.workflow import _WorkflowTaskBase
+from .job import ApplyWorkflow
 from .task import Task
 
 
@@ -106,7 +107,7 @@ class Workflow(_WorkflowBase, SQLModel, table=True):
     id: Optional[int] = Field(default=None, primary_key=True)
     project_id: int = Field(foreign_key="project.id")
 
-    task_list: list["WorkflowTask"] = Relationship(
+    task_list: list[WorkflowTask] = Relationship(
         sa_relationship_kwargs=dict(
             lazy="selectin",
             order_by="WorkflowTask.order",
@@ -114,6 +115,9 @@ class Workflow(_WorkflowBase, SQLModel, table=True):
             cascade="all, delete-orphan",
         ),
     )
+    job_list: list[ApplyWorkflow] = Relationship(
+        sa_relationship_kwargs={"lazy": "selectin"}
+    )
 
     async def insert_task(
         self,

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/runner/__init__.py

@@ -30,9 +30,9 @@ from ...utils import get_timestamp
 from ..db import DB
 from ..models import ApplyWorkflow
 from ..models import Dataset
-from ..models import JobStatusType
 from ..models import Workflow
 from ..models import WorkflowTask
+from ..schemas import JobStatusType
 from ._local import process_workflow as local_process_workflow
 from .common import close_job_logger
 from .common import JobExecutionError
@@ -187,6 +187,22 @@ async def submit_workflow(
         job.status = JobStatusType.RUNNING
         db_sync.merge(job)
         db_sync.commit()
+
+        # After Session.commit() is called, either explicitly or when using a
+        # context manager, all objects associated with the Session are expired.
+        # https://docs.sqlalchemy.org/en/14/orm/
+        #   session_basics.html#opening-and-closing-a-session
+        # https://docs.sqlalchemy.org/en/14/orm/
+        #   session_state_management.html#refreshing-expiring
+
+        # See issue #928:
+        # https://github.com/fractal-analytics-platform/
+        #   fractal-server/issues/928
+
+        db_sync.refresh(input_dataset)
+        db_sync.refresh(output_dataset)
+        db_sync.refresh(workflow)
+
         # Write logs
         logger_name = f"WF{workflow_id}_job{job_id}"
         log_file_path = WORKFLOW_DIR / "workflow.log"

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/schemas/__init__.py

@@ -3,6 +3,7 @@ Schemas for API request/response bodies
 """
 from .applyworkflow import ApplyWorkflowCreate  # noqa: F401
 from .applyworkflow import ApplyWorkflowRead  # noqa: F401
+from .applyworkflow import JobStatusType  # noqa: F401
 from .dataset import DatasetCreate  # noqa: F401
 from .dataset import DatasetRead  # noqa: F401
 from .dataset import DatasetStatusRead  # noqa: F401

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/schemas/applyworkflow.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from enum import Enum
 from typing import Any
 from typing import Optional
 
@@ -14,6 +15,31 @@ __all__ = (
 )
 
 
+class JobStatusType(str, Enum):
+    """
+    Define the available job statuses
+
+    Attributes:
+        SUBMITTED:
+            The workflow has been applied but not yet scheduled with an
+            executor. In this phase, due diligence takes place, such as
+            creating working directory, assemblying arguments, etc.
+        RUNNING:
+            The workflow was scheduled with an executor. Note that it might not
+            yet be running within the executor, e.g., jobs could still be
+            pending within a SLURM executor.
+        DONE:
+            The workflow was applied successfully
+        FAILED:
+            The workflow terminated with an error.
+    """
+
+    SUBMITTED = "submitted"
+    RUNNING = "running"
+    DONE = "done"
+    FAILED = "failed"
+
+
 class _ApplyWorkflowBase(BaseModel):
     """
     Base class for `ApplyWorkflow`.
@@ -99,14 +125,17 @@ class ApplyWorkflowRead(_ApplyWorkflowBase):
 
     id: int
     project_id: int
+    user_email: str
     workflow_id: int
+    workflow_dump: Optional[dict[str, Any]]
     input_dataset_id: int
+    input_dataset_dump: Optional[dict[str, Any]]
     output_dataset_id: int
+    output_dataset_dump: Optional[dict[str, Any]]
     start_timestamp: datetime
     end_timestamp: Optional[datetime]
     status: str
     log: Optional[str]
-    workflow_dump: Optional[dict[str, Any]]
     working_dir: Optional[str]
     working_dir_user: Optional[str]
     first_task_index: Optional[int]

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/app/schemas/project.py

@@ -4,7 +4,9 @@ from pydantic import BaseModel
 from pydantic import validator
 
 from ._validators import valstr
+from .applyworkflow import ApplyWorkflowRead
 from .dataset import DatasetRead
+from .workflow import WorkflowRead
 
 
 __all__ = (
@@ -47,6 +49,8 @@ class ProjectRead(_ProjectBase):
 
     id: int
     dataset_list: list[DatasetRead] = []
+    workflow_list: list[WorkflowRead] = []
+    job_list: list[ApplyWorkflowRead] = []
 
 
 class ProjectUpdate(_ProjectBase):

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/fractal_server/main.py

@@ -48,10 +48,15 @@ def collect_routers(app: FastAPI) -> None:
     """
     from .app.api import router_default
     from .app.api import router_v1
+    from .app.api import router_monitoring
+
     from .app.security import auth_router
 
     app.include_router(router_default, prefix="/api")
     app.include_router(router_v1, prefix="/api/v1")
+    app.include_router(
+        router_monitoring, prefix="/monitoring", tags=["Monitoring"]
+    )
     app.include_router(auth_router, prefix="/auth", tags=["auth"])
 
 

fractal_server-1.4.0a1/fractal_server/migrations/versions/84bf0fffde30_add_dumps_to_applyworkflow.py

@@ -0,0 +1,86 @@
+"""Add dumps to ApplyWorkflow
+
+Revision ID: 84bf0fffde30
+Revises: 99ea79d9e5d2
+Create Date: 2023-10-26 16:11:44.061971
+
+"""
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "84bf0fffde30"
+down_revision = "99ea79d9e5d2"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("applyworkflow", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "user_email",
+                sa.String(),
+                server_default="__UNDEFINED__",
+                nullable=False,
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "input_dataset_dump",
+                sa.JSON(),
+                server_default="{}",
+                nullable=False,
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "output_dataset_dump",
+                sa.JSON(),
+                server_default="{}",
+                nullable=False,
+            )
+        )
+
+        batch_op.alter_column(
+            "project_id", existing_type=sa.INTEGER(), nullable=True
+        )
+        batch_op.alter_column(
+            "workflow_id", existing_type=sa.INTEGER(), nullable=True
+        )
+        batch_op.alter_column(
+            "input_dataset_id", existing_type=sa.INTEGER(), nullable=True
+        )
+        batch_op.alter_column(
+            "output_dataset_id", existing_type=sa.INTEGER(), nullable=True
+        )
+
+    with op.batch_alter_table("applyworkflow", schema=None) as batch_op:
+        batch_op.alter_column("user_email", server_default=None)
+        batch_op.alter_column("input_dataset_dump", server_default=None)
+        batch_op.alter_column("output_dataset_dump", server_default=None)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("applyworkflow", schema=None) as batch_op:
+        batch_op.alter_column(
+            "output_dataset_id", existing_type=sa.INTEGER(), nullable=False
+        )
+        batch_op.alter_column(
+            "input_dataset_id", existing_type=sa.INTEGER(), nullable=False
+        )
+        batch_op.alter_column(
+            "workflow_id", existing_type=sa.INTEGER(), nullable=False
+        )
+        batch_op.alter_column(
+            "project_id", existing_type=sa.INTEGER(), nullable=False
+        )
+        batch_op.drop_column("output_dataset_dump")
+        batch_op.drop_column("input_dataset_dump")
+        batch_op.drop_column("user_email")
+
+    # ### end Alembic commands ###

fractal_server-1.4.0a1/fractal_server/migrations/versions/e75cac726012_make_applyworkflow_start_timestamp_not_.py

@@ -0,0 +1,35 @@
+"""Make ApplyWorkflow.start_timestamp not nullable
+
+Revision ID: e75cac726012
+Revises: 84bf0fffde30
+Create Date: 2023-10-30 15:51:18.808789
+
+"""
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "e75cac726012"
+down_revision = "84bf0fffde30"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("applyworkflow", schema=None) as batch_op:
+        batch_op.alter_column(
+            "start_timestamp", existing_type=sa.DATETIME(), nullable=False
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("applyworkflow", schema=None) as batch_op:
+        batch_op.alter_column(
+            "start_timestamp", existing_type=sa.DATETIME(), nullable=True
+        )
+
+    # ### end Alembic commands ###

{fractal_server-1.3.14a0 → fractal_server-1.4.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fractal-server"
-version = "1.3.14a0"
+version = "1.4.0a1"
 description = "Server component of the Fractal analytics platform"
 authors = [
     "Jacopo Nespolo <jacopo.nespolo@exact-lab.it>",
@@ -48,7 +48,7 @@ gunicorn = ["gunicorn"]
 asgi-lifespan = "^2"
 pytest = "^7.2"
 httpx = "^0.23"
-devtools = "^0.10"
+devtools = "^0.12"
 pytest-asyncio = "^0.20"
 bumpver = "^2022.1120"
 pre-commit = "^2.19"
@@ -82,7 +82,7 @@ filterwarnings = [
 ]
 
 [tool.bumpver]
-current_version = "1.3.14a0"
+current_version = "1.4.0a1"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true
@@ -107,5 +107,5 @@ relative_files = true
 omit = ["tests/*"]
 
 [[tool.mypy.overrides]]
-module = ["devtools", "uvicorn"]
+module = ["devtools", "uvicorn", "pytest", "asgi_lifespan", "asyncpg"]
 ignore_missing_imports = true

fractal_server-1.3.14a0/fractal_server/__init__.py

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