fractal-server 1.3.14a0__py3-none-any.whl → 1.4.0a1__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.3.14a0"
+__VERSION__ = "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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info → fractal_server-1.4.0a1.dist-info}/METADATA

@@ -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.3.14a0.dist-info → fractal_server-1.4.0a1.dist-info}/RECORD

@@ -1,29 +1,30 @@
-fractal_server/__init__.py,sha256=iPNo2MDnIP2-b3B7XSPtF_n3wyAA3KmQilmX-gUiWo8,25
+fractal_server/__init__.py,sha256=FghpTUvsrKafSXB-cqMEGar7ZwCBi90wwLD4GOQ4kfs,24
 fractal_server/__main__.py,sha256=znijcImbcEC4P26ICOhEJ9VY3_5vWdMwQcl-WP25sYA,2202
 fractal_server/alembic.ini,sha256=MWwi7GzjzawI9cCAK1LW7NxIBQDUqD12-ptJoq5JpP0,3153
 fractal_server/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fractal_server/app/api/__init__.py,sha256=_g30kAzDmakaxQQYwSZwVbid1O-3zMzQqnSuQZOWI3U,1192
+fractal_server/app/api/__init__.py,sha256=zYFP-qSzNrgPYwqBza-NYGjSm-PyAnHXftmJsd1SOlo,1255
 fractal_server/app/api/v1/__init__.py,sha256=2HMymr1YkUk39V8iof7KENyLnre4ghouOSvNZ_kF1ec,24
 fractal_server/app/api/v1/_aux_functions.py,sha256=_-D-iTKvOfH1yufa4lIHvP88Sgic8cvKXq3GmDHC-lk,9659
-fractal_server/app/api/v1/dataset.py,sha256=wWMtz48i_XzK8Ja-1u1t1XZLY9gXWqlJR8V8tJo4z_Q,14564
-fractal_server/app/api/v1/job.py,sha256=k1TxhmU_VMiHb6RxJUsiVaLWcH5GvtwsB44DsnmxNmc,4550
-fractal_server/app/api/v1/project.py,sha256=LlNkkKpJ7WtEcMOQ1KzGwxYqxScUex-wTlu1x1KL4rs,10236
+fractal_server/app/api/v1/dataset.py,sha256=sCtOPfKWiuhCzM2w2gPx2UsKQKDQizTZojw1biqi7qw,13952
+fractal_server/app/api/v1/job.py,sha256=APac5RLanwCf_3oY1PbWpKASQP4i1CJWq-bFtnEKpxg,5613
+fractal_server/app/api/v1/monitoring.py,sha256=LN9RI0iST_NshPfmnOa7vFW_wKyZbcA3gBDjFY-9ffw,4736
+fractal_server/app/api/v1/project.py,sha256=ZJCZi1CYqkdBXI83jzqZ8W3qPutYGxrh538TLfNfZA8,10368
 fractal_server/app/api/v1/task.py,sha256=0MJNhn5f8KZy4XBMUoJNhrk3E6GBQWcVfKoQzP5XXWw,5582
 fractal_server/app/api/v1/task_collection.py,sha256=mY1cSGepWvVz6IJCnFYA8iy4hU-8qsA1HbiQXZjg1OM,11697
-fractal_server/app/api/v1/workflow.py,sha256=A54m9PDD7MhT6s5-8kIrefEJ5uVxigxBohelT7XCLVo,9379
+fractal_server/app/api/v1/workflow.py,sha256=TwSRMGHgLJZxwgHI24q8Z7-ONu2CL1YVpxG8yBYE_yk,8858
 fractal_server/app/api/v1/workflowtask.py,sha256=TIsCSBFImoRq0rz16ZVlFwTL-Qd9Uqywbq-DT4OxYh0,5421
 fractal_server/app/db/__init__.py,sha256=4DP-jOZDLawKwPTToOVTR0vO2bc-R7s0lwZUXFv7k5s,3464
 fractal_server/app/models/__init__.py,sha256=RuxWH8fsmkTWsjLhYjrxSt-mvk74coCilAQlX2Q6OO0,353
-fractal_server/app/models/dataset.py,sha256=CEXKMwiMMtFTShc85zzac50ADeF21SFvGR-C7lCBn7A,1628
-fractal_server/app/models/job.py,sha256=G00iw0z0n8cM3vNxPqD0GxrV90g7r2QPib4eDX0Fsk0,3729
+fractal_server/app/models/dataset.py,sha256=fcZkb2y7PXlFJAyZtndJ7Gf4c8VpkWjZe47iMybv1aE,2109
+fractal_server/app/models/job.py,sha256=DbX7OMx88eC-232C_OdYOpNeyN0tma7p8J3x7HB43os,2768
 fractal_server/app/models/linkuserproject.py,sha256=RVtl25Q_N99uoVDE7wx0IN0SgFjc7Id5XbScsgrjv_E,309
-fractal_server/app/models/project.py,sha256=U3MvLVBestug5dCCw22VA-l8BeUnGoaNye5OPexsqoA,1191
+fractal_server/app/models/project.py,sha256=SNY8CCDHjd_iv1S7theFaRuVy87BuppTrByHFkJqcpE,1137
 fractal_server/app/models/security.py,sha256=Dp54Hf7I72oo9PERdyR0_zStw2ppYlFVi5MhFWIE6Lw,2438
 fractal_server/app/models/state.py,sha256=rSTjYPfPZntEfdQudKp6yu5vsdyfHA7nMYNRIBWsiAQ,1087
 fractal_server/app/models/task.py,sha256=APndtea9A7EF7TtpVK8kWapBM01a6nk3FFCrQbbioI8,2632
-fractal_server/app/models/workflow.py,sha256=VlX-MNfqw3z-EVKMvwVR9HbnOFNHRnO-5sDYFQOSijQ,5191
+fractal_server/app/models/workflow.py,sha256=r_bdKxzGgRjiwJW2fMYV9pvqcAs2swh1xg_q8pvXSbE,5328
 fractal_server/app/runner/.gitignore,sha256=ytzN_oyHWXrGU7iFAtoHSTUbM6Rn6kG0Zkddg0xZk6s,16
-fractal_server/app/runner/__init__.py,sha256=Y-B9lpw3Hbuc9uTCG0qcDDz5uMvnWXyxd3B5nfpbEdw,12978
+fractal_server/app/runner/__init__.py,sha256=WNMxT9XFEocPOdJRN6FfMek-LecOpBYXfJxmxupMRUE,13597
 fractal_server/app/runner/_common.py,sha256=XjyE8DZE6WECeFXI6i0vHVD6JywZQxkJgZrL-ep1USQ,22642
 fractal_server/app/runner/_local/__init__.py,sha256=mSJzpF6u6rgsSYO25szNVr2B296h7_iKD1eqS3o87Qo,6532
 fractal_server/app/runner/_local/_local_config.py,sha256=-oNTsjEUmytHlsYpWfw2CrPvSxDFeEhZSdQvI_wf3Mk,3245
@@ -40,13 +41,13 @@ fractal_server/app/runner/_slurm/executor.py,sha256=ao5YuWtjsIfTYUucE1SvNS8a99Sg
 fractal_server/app/runner/_slurm/remote.py,sha256=wLziIsGdSMiO-jIXM8x77JRK82g_2hx0iBKTiMghuIo,5852
 fractal_server/app/runner/common.py,sha256=nz0ZuIro0iwZm-OV-e-Y-PrtgKcLK0d7BrzebWyEWEk,9496
 fractal_server/app/runner/handle_failed_job.py,sha256=PKgJARHjXyv33sDsl7oTINdcTu7EwmFmIkp38RqAE3Q,4641
-fractal_server/app/schemas/__init__.py,sha256=Roc1gkp3jsafkgcsY8u5S6nshj9ER9fuAkthplrX4kI,1804
+fractal_server/app/schemas/__init__.py,sha256=th51Dzbe94xatOIMVheqlq0rVFy8oI1CHRfzCbjiTSg,1859
 fractal_server/app/schemas/_validators.py,sha256=7YEbgrnGRpzkLMfZzQNfczEmcNnO__SmVOaBHhzaiXE,1819
-fractal_server/app/schemas/applyworkflow.py,sha256=gGlVSfYZlVdWRhIhQ_0tzBKfuW1y1-ZeIS5UvjpXZTM,2954
+fractal_server/app/schemas/applyworkflow.py,sha256=iT7FBWgb9EfMSUdFCSv6vPy6223nsPqdQCLTYHrM8Uw,3871
 fractal_server/app/schemas/dataset.py,sha256=PPqGTsRQ5JEwkiM4NcjPYFckxnCdi_Zov-bWXDm1LUk,3092
 fractal_server/app/schemas/json_schemas/manifest.json,sha256=yXYKHbYXPYSkSXMTLfTpfCUGBtmQuPTk1xuSXscdba4,1787
 fractal_server/app/schemas/manifest.py,sha256=xxTd39dAXMK9Ox1y-p3gbyg0zd5udW99pV4JngCUGwM,3819
-fractal_server/app/schemas/project.py,sha256=GoV1yUPVSJ7eFGXIBrYh_4FOVKYcBRzPbW7ImnBAg-4,1047
+fractal_server/app/schemas/project.py,sha256=D_HZgwkR7OZoMlZaN7hFPrbB7T5gQPucjza0ekZNdQM,1213
 fractal_server/app/schemas/state.py,sha256=CS8Rs5qF21TsnqmyzUHLqRaX1b61Oc6Yra6POYpYSQY,762
 fractal_server/app/schemas/task.py,sha256=2TBE5Ne9tO_-a2-Es0PRXMT8ZddSInTOPMor7u8-gx0,3671
 fractal_server/app/schemas/task_collection.py,sha256=mPk6E1LK2UvnHkhIQWHmTztsVT99iHZn-UZy7mGNjUk,2965
@@ -55,24 +56,26 @@ fractal_server/app/schemas/workflow.py,sha256=oFoO62JH5hfMJjKoicdpyC5hd2O9XgqoAm
 fractal_server/app/security/__init__.py,sha256=qjTt5vvtIq6eMIMBCDewrQK9A6Lw2DW2HnifWuxeDmA,10933
 fractal_server/config.py,sha256=zekTDA_FhQG_RYgOWEIxT6KyJKRpMge-pB-iYRr4sIY,14447
 fractal_server/logger.py,sha256=keri8i960WHT8Zz9Rm2MwfnrA2dw9TsrfCmojqtGDLs,4562
-fractal_server/main.py,sha256=9_T_cMqf0EfbfYwkYhKeU36v9PFi95BoydapKpmaTKc,5932
+fractal_server/main.py,sha256=JR-Q7QBFq97Wy0FTrXy9YxiyusWNuCFJMDyvJ_Vatko,6075
 fractal_server/migrations/README,sha256=4rQvyDfqodGhpJw74VYijRmgFP49ji5chyEemWGHsuw,59
 fractal_server/migrations/env.py,sha256=05EoWw0p43ojTNiz7UVG4lsl057B4ImSgXiHmiU-M80,2690
 fractal_server/migrations/script.py.mako,sha256=oMXw9LC3zRbinWWPPDgeZ4z9FJrV2zhRWiYdS5YgNbI,526
 fractal_server/migrations/versions/4c308bcaea2b_add_task_args_schema_and_task_args_.py,sha256=-wHe-fOffmYeAm0JXVl_lxZ7hhDkaEVqxgxpHkb_uL8,954
 fractal_server/migrations/versions/50a13d6138fd_initial_schema.py,sha256=zwXegXs9J40eyCWi3w0c_iIBVJjXNn4VdVnQaT3KxDg,8770
 fractal_server/migrations/versions/70e77f1c38b0_add_applyworkflow_first_task_index_and_.py,sha256=Q-DsMzG3IcUV2Ol1dhJWosDvKERamBE6QvA2zzS5zpQ,1632
+fractal_server/migrations/versions/84bf0fffde30_add_dumps_to_applyworkflow.py,sha256=NSCuhANChsg76vBkShBl-9tQ4VEHubOjtAv1etHhlvY,2684
 fractal_server/migrations/versions/8f79bd162e35_add_docs_info_and_docs_link_to_task_.py,sha256=6pgODDtyAxevZvAJBj9IJ41inhV1RpwbpZr_qfPPu1A,1115
 fractal_server/migrations/versions/99ea79d9e5d2_add_dataset_history.py,sha256=0im6TxDr53sKKcjiPgeH4ftVRGnRXZSh2lPbRQ1Ir9w,883
 fractal_server/migrations/versions/a7f4d6137b53_add_workflow_dump_to_applyworkflow.py,sha256=ekDUML7ILpmdoqEclKbEUdyLi4uw9HSG_sTjG2hp_JE,867
+fractal_server/migrations/versions/e75cac726012_make_applyworkflow_start_timestamp_not_.py,sha256=lOggSvzGWqQvnxxFuSM6W50Ui49R918A-uBuiZJ0pNM,963
 fractal_server/migrations/versions/f384e1c0cf5d_drop_task_default_args_columns.py,sha256=9BwqUS9Gf7UW_KjrzHbtViC880qhD452KAytkHWWZyk,746
 fractal_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fractal_server/syringe.py,sha256=3qSMW3YaMKKnLdgnooAINOPxnCOxP7y2jeAQYB21Gdo,2786
 fractal_server/tasks/__init__.py,sha256=Wzuxf5EoH1v0fYzRpAZHG_S-Z9f6DmbIsuSvllBCGvc,72
 fractal_server/tasks/collection.py,sha256=POKvQyS5G5ySybH0r0v21I_ZQ5AREe9kAqr_uFfGyaU,17627
 fractal_server/utils.py,sha256=b7WwFdcFZ8unyT65mloFToYuEDXpQoHRcmRNqrhd_dQ,2115
-fractal_server-1.3.14a0.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
-fractal_server-1.3.14a0.dist-info/METADATA,sha256=05R2BTkBa2A2yJEcoed4gnJvlEZqTAmRhSVvouiBJs8,3774
-fractal_server-1.3.14a0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-fractal_server-1.3.14a0.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
-fractal_server-1.3.14a0.dist-info/RECORD,,
+fractal_server-1.4.0a1.dist-info/LICENSE,sha256=QKAharUuhxL58kSoLizKJeZE3mTCBnX6ucmz8W0lxlk,1576
+fractal_server-1.4.0a1.dist-info/METADATA,sha256=2drgsD8Zsk0dNZIT_CkCRCdqCWqBcIuZAwFMfvuAYhw,3773
+fractal_server-1.4.0a1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+fractal_server-1.4.0a1.dist-info/entry_points.txt,sha256=8tV2kynvFkjnhbtDnxAqImL6HMVKsopgGfew0DOp5UY,58
+fractal_server-1.4.0a1.dist-info/RECORD,,