fractal-server 2.11.0a10__py3-none-any.whl → 2.12.0a0__py3-none-any.whl

fractal_server/app/models/v1/dataset.py

@@ -1,71 +0,0 @@
-from datetime import datetime
-from typing import Any
-from typing import Optional
-
-from sqlalchemy import Column
-from sqlalchemy.ext.orderinglist import ordering_list
-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.v1.dataset import _DatasetBaseV1
-from ...schemas.v1.dataset import _ResourceBaseV1
-
-
-class Resource(_ResourceBaseV1, SQLModel, table=True):
-    id: Optional[int] = Field(default=None, primary_key=True)
-    dataset_id: int = Field(foreign_key="dataset.id")
-
-
-class Dataset(_DatasetBaseV1, SQLModel, table=True):
-    """
-    Represent a dataset
-
-    Attributes:
-        id:
-            Primary key
-        project_id:
-            ID of the project the workflow belongs to.
-        meta:
-            Metadata of the Dataset
-        history:
-            History of the Dataset
-        resource_list:
-            (Mapper attribute)
-
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    project_id: int = Field(foreign_key="project.id")
-    project: "Project" = Relationship(  # noqa: F821
-        sa_relationship_kwargs=dict(lazy="selectin"),
-    )
-
-    resource_list: list[Resource] = Relationship(
-        sa_relationship_kwargs={
-            "lazy": "selectin",
-            "order_by": "Resource.id",
-            "collection_class": ordering_list("id"),
-            "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)
-    )
-
-    timestamp_created: datetime = Field(
-        default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True), nullable=False),
-    )
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    @property
-    def paths(self) -> list[str]:
-        return [r.path for r in self.resource_list]

fractal_server/app/models/v1/job.py

@@ -1,101 +0,0 @@
-from datetime import datetime
-from typing import Any
-from typing import Optional
-
-from sqlalchemy import Column
-from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
-from sqlmodel import Field
-from sqlmodel import SQLModel
-
-from ....utils import get_timestamp
-from ...schemas.v1 import JobStatusTypeV1
-from ...schemas.v1.applyworkflow import _ApplyWorkflowBaseV1
-
-
-class ApplyWorkflow(_ApplyWorkflowBaseV1, SQLModel, table=True):
-    """
-    Represent a workflow run
-
-    This table is responsible for storing the state of a workflow execution in
-    the database.
-
-    Attributes:
-        id:
-            Primary key.
-        project_id:
-            ID of the project the workflow belongs to, or `None` if the project
-            was deleted.
-        input_dataset_id:
-            ID of the input dataset, or `None` if the dataset was deleted.
-        output_dataset_id:
-            ID of the output dataset, or `None` if the dataset was deleted.
-        workflow_id:
-            ID of the workflow being applied, or `None` if the workflow was
-            deleted.
-        status:
-            Job status
-        workflow_dump:
-            Copy of the submitted workflow at submission.
-        input_dataset_dump:
-            Copy of the input_dataset at submission.
-        output_dataset_dump:
-            Copy of the output_dataset at submission.
-        start_timestamp:
-            Timestamp of when the run began.
-        end_timestamp:
-            Timestamp of when the run ended or failed.
-        status:
-            Status of the run.
-        log:
-            Forward of the workflow logs.
-        user_email:
-            Email address of the user who submitted the job.
-        slurm_account:
-            Account to be used when submitting the job to SLURM (see "account"
-            option in [`sbatch`
-            documentation](https://slurm.schedmd.com/sbatch.html#SECTION_OPTIONS)).
-        first_task_index:
-        last_task_index:
-    """
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-
-    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)
-    slurm_account: Optional[str]
-
-    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)
-    )
-    workflow_dump: dict[str, Any] = Field(
-        sa_column=Column(JSON, nullable=False)
-    )
-    project_dump: dict[str, Any] = Field(
-        sa_column=Column(JSON, nullable=False)
-    )
-
-    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), nullable=False),
-    )
-    end_timestamp: Optional[datetime] = Field(
-        default=None, sa_column=Column(DateTime(timezone=True))
-    )
-    status: str = JobStatusTypeV1.SUBMITTED
-    log: Optional[str] = None

fractal_server/app/models/v1/project.py

@@ -1,29 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from sqlalchemy import Column
-from sqlalchemy.types import DateTime
-from sqlmodel import Field
-from sqlmodel import Relationship
-from sqlmodel import SQLModel
-
-from . import LinkUserProject
-from ....utils import get_timestamp
-from ...schemas.v1.project import _ProjectBaseV1
-from fractal_server.app.models import UserOAuth
-
-
-class Project(_ProjectBaseV1, SQLModel, table=True):
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    timestamp_created: datetime = Field(
-        default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True), nullable=False),
-    )
-
-    user_list: list[UserOAuth] = Relationship(
-        link_model=LinkUserProject,
-        sa_relationship_kwargs={
-            "lazy": "selectin",
-        },
-    )

fractal_server/app/models/v1/state.py

@@ -1,34 +0,0 @@
-from datetime import datetime
-from typing import Any
-from typing import Optional
-
-from sqlalchemy import Column
-from sqlalchemy.types import DateTime
-from sqlalchemy.types import JSON
-from sqlmodel import Field
-from sqlmodel import SQLModel
-
-from ....utils import get_timestamp
-
-
-class State(SQLModel, table=True):
-    """
-    Store arbitrary data in the database
-
-    This table is just a state interchange that allows the system to store
-    arbitrary data for later retrieval. This is particuarly important for long
-    background tasks, in which it is not possible to return a meaningful
-    response to the client within a single request lifespan.
-
-    Attributes:
-        id: Primary key
-        data: Content of the `State`
-        timestamp: Timestap of the `State`
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    data: dict[str, Any] = Field(sa_column=Column(JSON), default={})
-    timestamp: datetime = Field(
-        default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True)),
-    )

fractal_server/app/models/v1/task.py

@@ -1,85 +0,0 @@
-import json
-import logging
-from typing import Any
-from typing import Optional
-
-from pydantic import HttpUrl
-from sqlalchemy import Column
-from sqlalchemy.types import JSON
-from sqlmodel import Field
-from sqlmodel import SQLModel
-
-from ...schemas.v1.task import _TaskBaseV1
-
-
-class Task(_TaskBaseV1, SQLModel, table=True):
-    """
-    Task model
-
-    Attributes:
-        id: Primary key
-        command: Executable command
-        input_type: Expected type of input `Dataset`
-        output_type: Expected type of output `Dataset`
-        meta:
-            Additional metadata related to execution (e.g. computational
-            resources)
-        source: inherited from `_TaskBase`
-        name: inherited from `_TaskBase`
-        args_schema: JSON schema of task arguments
-        args_schema_version:
-            label pointing at how the JSON schema of task arguments was
-            generated
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    name: str
-    command: str
-    source: str = Field(unique=True)
-    input_type: str
-    output_type: str
-    meta: Optional[dict[str, Any]] = Field(sa_column=Column(JSON), default={})
-    owner: Optional[str] = None
-    version: Optional[str] = None
-    args_schema: Optional[dict[str, Any]] = Field(
-        sa_column=Column(JSON), default=None
-    )
-    args_schema_version: Optional[str]
-    docs_info: Optional[str] = None
-    docs_link: Optional[HttpUrl] = None
-
-    @property
-    def parallelization_level(self) -> Optional[str]:
-        try:
-            return self.meta["parallelization_level"]
-        except KeyError:
-            return None
-
-    @property
-    def is_parallel(self) -> bool:
-        return bool(self.parallelization_level)
-
-    @property
-    def default_args_from_args_schema(self) -> dict[str, Any]:
-        """
-        Extract default arguments from args_schema
-        """
-        # Return {} if there is no args_schema
-        if self.args_schema is None:
-            return {}
-        # Try to construct default_args
-        try:
-            default_args = {}
-            properties = self.args_schema["properties"]
-            for prop_name, prop_schema in properties.items():
-                default_value = prop_schema.get("default", None)
-                if default_value is not None:
-                    default_args[prop_name] = default_value
-            return default_args
-        except KeyError as e:
-            logging.warning(
-                "Cannot set default_args from args_schema="
-                f"{json.dumps(self.args_schema)}\n"
-                f"Original KeyError: {str(e)}"
-            )
-            return {}

fractal_server/app/models/v1/workflow.py

@@ -1,133 +0,0 @@
-from datetime import datetime
-from typing import Any
-from typing import Optional
-from typing import Union
-
-from pydantic import validator
-from sqlalchemy import Column
-from sqlalchemy.ext.orderinglist import ordering_list
-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.v1.workflow import _WorkflowBaseV1
-from ...schemas.v1.workflow import _WorkflowTaskBaseV1
-from .task import Task
-
-
-class WorkflowTask(_WorkflowTaskBaseV1, SQLModel, table=True):
-    """
-    A Task as part of a Workflow
-
-    This is a crossing table between Task and Workflow. In addition to the
-    foreign keys, it allows for parameter overriding and keeps the order
-    within the list of tasks of the workflow.
-
-
-    Attributes:
-        id:
-            Primary key
-        workflow_id:
-            ID of the `Workflow` the `WorkflowTask` belongs to
-        task_id:
-            ID of the task corresponding to the `WorkflowTask`
-        order:
-            Positional order of the `WorkflowTask` in `Workflow.task_list`
-        meta:
-            Additional parameters useful for execution
-        args:
-            Task arguments
-        task:
-            `Task` object associated with the current `WorkflowTask`
-
-    """
-
-    class Config:
-        arbitrary_types_allowed = True
-        fields = {"parent": {"exclude": True}}
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-
-    workflow_id: int = Field(foreign_key="workflow.id")
-    task_id: int = Field(foreign_key="task.id")
-    order: Optional[int]
-    meta: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
-    args: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
-    task: Task = Relationship(sa_relationship_kwargs=dict(lazy="selectin"))
-
-    @validator("args")
-    def validate_args(cls, value: dict = None):
-        """
-        Prevent fractal task reserved parameter names from entering args
-
-        Forbidden argument names are `input_paths`, `output_path`, `metadata`,
-        `component`.
-        """
-        if value is None:
-            return
-        forbidden_args_keys = {
-            "input_paths",
-            "output_path",
-            "metadata",
-            "component",
-        }
-        args_keys = set(value.keys())
-        intersect_keys = forbidden_args_keys.intersection(args_keys)
-        if intersect_keys:
-            raise ValueError(
-                "`args` contains the following forbidden keys: "
-                f"{intersect_keys}"
-            )
-        return value
-
-    @property
-    def is_parallel(self) -> bool:
-        return self.task.is_parallel
-
-    @property
-    def parallelization_level(self) -> Union[str, None]:
-        return self.task.parallelization_level
-
-
-class Workflow(_WorkflowBaseV1, SQLModel, table=True):
-    """
-    Workflow
-
-    Attributes:
-        id:
-            Primary key
-        project_id:
-            ID of the project the workflow belongs to.
-        task_list:
-            List of associations to tasks.
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    project_id: int = Field(foreign_key="project.id")
-    project: "Project" = Relationship(  # noqa: F821
-        sa_relationship_kwargs=dict(lazy="selectin"),
-    )
-
-    task_list: list[WorkflowTask] = Relationship(
-        sa_relationship_kwargs=dict(
-            lazy="selectin",
-            order_by="WorkflowTask.order",
-            collection_class=ordering_list("order"),
-            cascade="all, delete-orphan",
-        ),
-    )
-    timestamp_created: datetime = Field(
-        default_factory=get_timestamp,
-        sa_column=Column(DateTime(timezone=True), nullable=False),
-    )
-
-    @property
-    def input_type(self):
-        return self.task_list[0].task.input_type
-
-    @property
-    def output_type(self):
-        return self.task_list[-1].task.output_type