fractal-server 1.4.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

fractal_server/app/schemas/v2/manifest.py

@@ -0,0 +1,159 @@
+from typing import Any
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import HttpUrl
+from pydantic import root_validator
+from pydantic import validator
+
+
+class TaskManifestV2(BaseModel):
+    """
+    Represents a task within a V2 manifest.
+
+    Attributes:
+        name:
+            The task name
+        executable:
+            Path to the executable relative to the package root
+
+            Note: by package root we mean "as it will be installed". If a
+            package `Pkg` installs in the folder `pkg` the executable
+            `pkg/executable.py`, this attribute must contain only
+            `executable.py`.
+        input_type:
+            The input type accepted by the task
+        output_type:
+            The output type returned by the task
+        meta:
+            Additional information about the package, such as hash of the
+            executable, specific runtime requirements (e.g., need_gpu=True),
+            etc.
+        args_schema:
+            JSON Schema for task arguments
+        docs_info:
+            Additional information about the Task, coming from the docstring.
+        docs_link:
+            Link to Task docs.
+    """
+
+    name: str
+    executable_non_parallel: Optional[str] = None
+    executable_parallel: Optional[str] = None
+    input_types: dict[str, bool] = Field(default_factory=dict)
+    output_types: dict[str, bool] = Field(default_factory=dict)
+    meta_non_parallel: dict[str, Any] = Field(default_factory=dict)
+    meta_parallel: dict[str, Any] = Field(default_factory=dict)
+    args_schema_non_parallel: Optional[dict[str, Any]] = None
+    args_schema_parallel: Optional[dict[str, Any]] = None
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
+
+    @root_validator
+    def validate_executable_args_meta(cls, values):
+
+        executable_non_parallel = values.get("executable_non_parallel")
+        executable_parallel = values.get("executable_parallel")
+        if (executable_non_parallel is None) and (executable_parallel is None):
+
+            raise ValueError(
+                "`TaskManifestV2.executable_non_parallel` and "
+                "`TaskManifestV2.executable_parallel` cannot be both None."
+            )
+
+        elif executable_non_parallel is None:
+
+            meta_non_parallel = values.get("meta_non_parallel")
+            if meta_non_parallel != {}:
+                raise ValueError(
+                    "`TaskManifestV2.meta_non_parallel` must be an empty dict "
+                    "if `TaskManifestV2.executable_non_parallel` is None. "
+                    f"Given: {meta_non_parallel}."
+                )
+
+            args_schema_non_parallel = values.get("args_schema_non_parallel")
+            if args_schema_non_parallel is not None:
+                raise ValueError(
+                    "`TaskManifestV2.args_schema_non_parallel` must be None "
+                    "if `TaskManifestV2.executable_non_parallel` is None. "
+                    f"Given: {args_schema_non_parallel}."
+                )
+
+        elif executable_parallel is None:
+
+            meta_parallel = values.get("meta_parallel")
+            if meta_parallel != {}:
+                raise ValueError(
+                    "`TaskManifestV2.meta_parallel` must be an empty dict if "
+                    "`TaskManifestV2.executable_parallel` is None. "
+                    f"Given: {meta_parallel}."
+                )
+
+            args_schema_parallel = values.get("args_schema_parallel")
+            if args_schema_parallel is not None:
+                raise ValueError(
+                    "`TaskManifestV2.args_schema_parallel` must be None if "
+                    "`TaskManifestV2.executable_parallel` is None. "
+                    f"Given: {args_schema_parallel}."
+                )
+
+        return values
+
+
+class ManifestV2(BaseModel):
+    """
+    Packages containing tasks are required to include a special file
+    `__FRACTAL_MANIFEST__.json` in order to be discovered and used by Fractal.
+
+    This model class and the model classes it depends on provide the base
+    schema to read, write and validate manifests.
+
+    Attributes:
+        manifest_version:
+            A version string that provides indication for compatibility between
+            manifests as the schema evolves. This is for instance used by
+            Fractal to determine which subclass of the present base class needs
+            be used to read and validate the input.
+        task_list : list[TaskManifestType]
+            The list of tasks, represented as specified by subclasses of the
+            _TaskManifestBase (a.k.a. TaskManifestType)
+        has_args_schemas:
+            `True` if the manifest incldues JSON Schemas for the arguments of
+            each task.
+        args_schema_version:
+            Label of how `args_schema`s were generated (e.g. `pydantic_v1`).
+    """
+
+    manifest_version: str
+    task_list: list[TaskManifestV2]
+    has_args_schemas: bool = False
+    args_schema_version: Optional[str]
+
+    @root_validator()
+    def _check_args_schemas_are_present(cls, values):
+        has_args_schemas = values["has_args_schemas"]
+        task_list = values["task_list"]
+        if has_args_schemas is True:
+            for task in task_list:
+                if task.executable_parallel is not None:
+                    if task.args_schema_parallel is None:
+                        raise ValueError(
+                            f"Manifest has {has_args_schemas=}, but "
+                            f"task '{task.name}' has "
+                            f"{task.args_schema_parallel=}."
+                        )
+                if task.executable_non_parallel is not None:
+                    if task.args_schema_non_parallel is None:
+                        raise ValueError(
+                            f"Manifest has {has_args_schemas=}, but "
+                            f"task '{task.name}' has "
+                            f"{task.args_schema_non_parallel=}."
+                        )
+        return values
+
+    @validator("manifest_version")
+    def manifest_version_2(cls, value):
+        if value != "2":
+            raise ValueError(f"Wrong manifest version (given {value})")
+        return value

fractal_server/app/schemas/v2/project.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Extra
+from pydantic import validator
+
+from .._validators import valstr
+from .._validators import valutc
+
+
+class ProjectCreateV2(BaseModel, extra=Extra.forbid):
+
+    name: str
+    # Validators
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+
+
+class ProjectReadV2(BaseModel):
+
+    id: int
+    name: str
+    timestamp_created: datetime
+    # Validators
+    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
+        valutc("timestamp_created")
+    )
+
+
+class ProjectUpdateV2(BaseModel):
+
+    name: Optional[str]
+    # Validators
+    _name = validator("name", allow_reuse=True)(valstr("name"))

fractal_server/app/schemas/v2/status.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from pydantic import Field
+
+from .workflowtask import WorkflowTaskStatusTypeV2
+
+
+class StatusReadV2(BaseModel):
+    """
+    Response type for the
+    `/project/{project_id}/status/` endpoint
+    """
+
+    status: dict[
+        str,
+        WorkflowTaskStatusTypeV2,
+    ] = Field(default_factory=dict)

fractal_server/app/schemas/v2/task.py

@@ -0,0 +1,151 @@
+from typing import Any
+from typing import Literal
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Extra
+from pydantic import Field
+from pydantic import HttpUrl
+from pydantic import root_validator
+from pydantic import validator
+
+from .._validators import valdictkeys
+from .._validators import valstr
+from ..v1.task import TaskReadV1
+
+
+class TaskCreateV2(BaseModel, extra=Extra.forbid):
+
+    name: str
+
+    command_non_parallel: Optional[str]
+    command_parallel: Optional[str]
+    source: str
+
+    meta_non_parallel: Optional[dict[str, Any]]
+    meta_parallel: Optional[dict[str, Any]]
+    version: Optional[str]
+    args_schema_non_parallel: Optional[dict[str, Any]]
+    args_schema_parallel: Optional[dict[str, Any]]
+    args_schema_version: Optional[str]
+    docs_info: Optional[str]
+    docs_link: Optional[HttpUrl]
+
+    input_types: dict[str, bool] = Field(default={})
+    output_types: dict[str, bool] = Field(default={})
+
+    # Validators
+    @root_validator
+    def validate_commands(cls, values):
+        command_parallel = values.get("command_parallel")
+        command_non_parallel = values.get("command_non_parallel")
+        if (command_parallel is None) and (command_non_parallel is None):
+            raise ValueError(
+                "Task must have at least one valid command "
+                "(parallel and/or non_parallel)"
+            )
+        return values
+
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _command_non_parallel = validator(
+        "command_non_parallel", allow_reuse=True
+    )(valstr("command_non_parallel"))
+    _command_parallel = validator("command_parallel", allow_reuse=True)(
+        valstr("command_parallel")
+    )
+    _source = validator("source", allow_reuse=True)(valstr("source"))
+    _version = validator("version", allow_reuse=True)(valstr("version"))
+
+    _meta_non_parallel = validator("meta_non_parallel", allow_reuse=True)(
+        valdictkeys("meta_non_parallel")
+    )
+    _meta_parallel = validator("meta_parallel", allow_reuse=True)(
+        valdictkeys("meta_parallel")
+    )
+    _args_schema_non_parallel = validator(
+        "args_schema_non_parallel", allow_reuse=True
+    )(valdictkeys("args_schema_non_parallel"))
+    _args_schema_parallel = validator(
+        "args_schema_parallel", allow_reuse=True
+    )(valdictkeys("args_schema_parallel"))
+    _args_schema_version = validator("args_schema_version", allow_reuse=True)(
+        valstr("args_schema_version")
+    )
+    _input_types = validator("input_types", allow_reuse=True)(
+        valdictkeys("input_types")
+    )
+    _output_types = validator("output_types", allow_reuse=True)(
+        valdictkeys("output_types")
+    )
+
+
+class TaskReadV2(BaseModel):
+
+    id: int
+    name: str
+    type: Literal["parallel", "non_parallel", "compound"]
+    source: str
+    owner: Optional[str]
+    version: Optional[str]
+
+    command_non_parallel: Optional[str]
+    command_parallel: Optional[str]
+    meta_parallel: dict[str, Any]
+    meta_non_parallel: dict[str, Any]
+    args_schema_non_parallel: Optional[dict[str, Any]] = None
+    args_schema_parallel: Optional[dict[str, Any]] = None
+    args_schema_version: Optional[str]
+    docs_info: Optional[str]
+    docs_link: Optional[HttpUrl]
+    input_types: dict[str, bool]
+    output_types: dict[str, bool]
+
+
+class TaskLegacyReadV2(TaskReadV1):
+    is_v2_compatible: bool
+
+
+class TaskUpdateV2(BaseModel):
+
+    name: Optional[str]
+    version: Optional[str]
+    command_parallel: Optional[str]
+    command_non_parallel: Optional[str]
+    input_types: Optional[dict[str, bool]]
+    output_types: Optional[dict[str, bool]]
+
+    # Validators
+    @validator("input_types", "output_types")
+    def val_is_dict(cls, v):
+        if not isinstance(v, dict):
+            raise ValueError
+        return v
+
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _version = validator("version", allow_reuse=True)(
+        valstr("version", accept_none=True)
+    )
+    _command_parallel = validator("command_parallel", allow_reuse=True)(
+        valstr("command_parallel")
+    )
+    _command_non_parallel = validator(
+        "command_non_parallel", allow_reuse=True
+    )(valstr("command_non_parallel"))
+    _input_types = validator("input_types", allow_reuse=True)(
+        valdictkeys("input_types")
+    )
+    _output_types = validator("output_types", allow_reuse=True)(
+        valdictkeys("output_types")
+    )
+
+
+class TaskImportV2(BaseModel):
+
+    source: str
+    _source = validator("source", allow_reuse=True)(valstr("source"))
+
+
+class TaskExportV2(BaseModel):
+
+    source: str
+    _source = validator("source", allow_reuse=True)(valstr("source"))

fractal_server/app/schemas/v2/task_collection.py

@@ -0,0 +1,109 @@
+from pathlib import Path
+from typing import Literal
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import validator
+
+from .._validators import valdictkeys
+from .._validators import valstr
+from .task import TaskReadV2
+
+
+class TaskCollectPipV2(BaseModel):
+    """
+    TaskCollectPipV2 class
+
+    This class only encodes the attributes required to trigger a
+    task-collection operation. Other attributes (that are assigned *during*
+    task collection) are defined as part of fractal-server.
+
+    Two cases are supported:
+
+        1. `package` is the path of a local wheel file;
+        2. `package` is the name of a package that can be installed via `pip`.
+
+
+    Attributes:
+        package:
+            The name of a `pip`-installable package, or the path to a local
+            wheel file.
+        package_version: Version of the package
+        package_extras: Package extras to include in the `pip install` command
+        python_version: Python version to install and run the package tasks
+        pinned_package_versions:
+            dictionary 'package':'version' used to pin versions for specific
+            packages.
+
+    """
+
+    package: str
+    package_version: Optional[str] = None
+    package_extras: Optional[str] = None
+    python_version: Optional[str] = None
+    pinned_package_versions: Optional[dict[str, str]] = None
+
+    _pinned_package_versions = validator(
+        "pinned_package_versions", allow_reuse=True
+    )(valdictkeys("pinned_package_versions"))
+    _package_extras = validator("package_extras", allow_reuse=True)(
+        valstr("package_extras")
+    )
+    _python_version = validator("python_version", allow_reuse=True)(
+        valstr("python_version")
+    )
+
+    @validator("package")
+    def package_validator(cls, value):
+        if "/" in value:
+            if not value.endswith(".whl"):
+                raise ValueError(
+                    "Local-package path must be a wheel file "
+                    f"(given {value})."
+                )
+            if not Path(value).is_absolute():
+                raise ValueError(
+                    f"Local-package path must be absolute: (given {value})."
+                )
+        return value
+
+    @validator("package_version")
+    def package_version_validator(cls, v, values):
+
+        valstr("package_version")(v)
+
+        if values["package"].endswith(".whl"):
+            raise ValueError(
+                "Cannot provide version when package is a Wheel file."
+            )
+        return v
+
+
+class TaskCollectStatusV2(BaseModel):
+    """
+    TaskCollectStatus class
+
+    Attributes:
+        status:
+        package:
+        venv_path:
+        task_list:
+        log:
+        info:
+    """
+
+    status: Literal["pending", "installing", "collecting", "fail", "OK"]
+    package: str
+    venv_path: Path
+    task_list: Optional[list[TaskReadV2]] = Field(default=[])
+    log: Optional[str]
+    info: Optional[str]
+
+    def sanitised_dict(self):
+        """
+        Return `self.dict()` after casting `self.venv_path` to a string
+        """
+        d = self.dict()
+        d["venv_path"] = str(self.venv_path)
+        return d

fractal_server/app/schemas/v2/workflow.py

@@ -0,0 +1,79 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Extra
+from pydantic import validator
+
+from .._validators import valstr
+from .._validators import valutc
+from .project import ProjectReadV2
+from .workflowtask import WorkflowTaskExportV2
+from .workflowtask import WorkflowTaskImportV2
+from .workflowtask import WorkflowTaskReadV2
+
+
+class WorkflowCreateV2(BaseModel, extra=Extra.forbid):
+
+    name: str
+
+    # Validators
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+
+
+class WorkflowReadV2(BaseModel):
+
+    id: int
+    name: str
+    project_id: int
+    task_list: list[WorkflowTaskReadV2]
+    project: ProjectReadV2
+    timestamp_created: datetime
+
+    _timestamp_created = validator("timestamp_created", allow_reuse=True)(
+        valutc("timestamp_created")
+    )
+
+
+class WorkflowUpdateV2(BaseModel):
+
+    name: Optional[str]
+    reordered_workflowtask_ids: Optional[list[int]]
+
+    # Validators
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+
+    @validator("reordered_workflowtask_ids")
+    def check_positive_and_unique(cls, value):
+        if any(i < 0 for i in value):
+            raise ValueError("Negative `id` in `reordered_workflowtask_ids`")
+        if len(value) != len(set(value)):
+            raise ValueError("`reordered_workflowtask_ids` has repetitions")
+        return value
+
+
+class WorkflowImportV2(BaseModel):
+    """
+    Class for `Workflow` import.
+
+    Attributes:
+        task_list:
+    """
+
+    name: str
+    task_list: list[WorkflowTaskImportV2]
+
+    # Validators
+    _name = validator("name", allow_reuse=True)(valstr("name"))
+
+
+class WorkflowExportV2(BaseModel):
+    """
+    Class for `Workflow` export.
+
+    Attributes:
+        task_list:
+    """
+
+    name: str
+    task_list: list[WorkflowTaskExportV2]