fractal-server 1.3.0a2__py3-none-any.whl → 1.3.0a3__py3-none-any.whl

fractal_server/common/schemas/applyworkflow.py

@@ -1,20 +1,19 @@
 from datetime import datetime
-from typing import List
 from typing import Optional
 
+from pydantic import BaseModel
 from pydantic import validator
-from sqlmodel import SQLModel
 
 from ._validators import valstr
 
 __all__ = (
-    "ApplyWorkflowBase",
+    "_ApplyWorkflowBase",
     "ApplyWorkflowCreate",
     "ApplyWorkflowRead",
 )
 
 
-class ApplyWorkflowBase(SQLModel):
+class _ApplyWorkflowBase(BaseModel):
     """
     Base class for ApplyWorkflow
 
@@ -25,7 +24,7 @@ class ApplyWorkflowBase(SQLModel):
     worker_init: Optional[str]
 
 
-class ApplyWorkflowCreate(ApplyWorkflowBase):
+class ApplyWorkflowCreate(_ApplyWorkflowBase):
 
     # Validators
     _worker_init = validator("worker_init", allow_reuse=True)(
@@ -33,7 +32,7 @@ class ApplyWorkflowCreate(ApplyWorkflowBase):
     )
 
 
-class ApplyWorkflowRead(ApplyWorkflowBase):
+class ApplyWorkflowRead(_ApplyWorkflowBase):
     id: int
     project_id: int
     workflow_id: int
@@ -43,7 +42,7 @@ class ApplyWorkflowRead(ApplyWorkflowBase):
     end_timestamp: Optional[datetime]
     status: str
     log: Optional[str]
-    history: Optional[List[str]]
+    history: Optional[list[str]]
     working_dir: Optional[str]
     working_dir_user: Optional[str]
 

fractal_server/common/schemas/manifest.py

@@ -1,13 +1,11 @@
-from pathlib import Path
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import TypeVar
 
 from pydantic import BaseModel
+from pydantic import Field
+from pydantic import root_validator
 from pydantic import validator
-from sqlmodel import Field
 
 
 __all__ = ("TaskManifestV1", "ManifestV1")
@@ -15,7 +13,7 @@ __all__ = ("TaskManifestV1", "ManifestV1")
 
 class _TaskManifestBase(BaseModel):
     """
-    Base class for TaskManifest
+    Base class for `TaskManifest`
 
     Represents a task within a manfest
 
@@ -33,21 +31,20 @@ class _TaskManifestBase(BaseModel):
             The input type accepted by the task
         output_type:
             The output type returned by the task
-        default_args:
-            An arbitrary, JSON-serializable dictionary containing the default
-            parameters that will be passed to 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
     """
 
     name: str
-    executable: Path
+    executable: str
     input_type: str
     output_type: str
-    default_args: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    meta: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    meta: Optional[dict[str, Any]] = Field(default_factory=dict)
+    args_schema: Optional[dict[str, Any]]
 
 
 TaskManifestType = TypeVar("TaskManifestType", bound=_TaskManifestBase)
@@ -69,13 +66,33 @@ class _ManifestBase(BaseModel):
             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]
+        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[TaskManifestType]  # type: ignore
+    task_list: list[TaskManifestType]
+    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:
+            for task in task_list:
+                if task.args_schema is None:
+                    raise ValueError(
+                        f'has_args_schemas={has_args_schemas} but task "'
+                        f'{task.name}" has args_schema={task.args_schema}.'
+                    )
+        return values
 
 
 class TaskManifestV1(_TaskManifestBase):
@@ -87,9 +104,9 @@ class ManifestV1(_ManifestBase):
     Manifest schema version 1
     """
 
-    task_list: List[TaskManifestV1]
+    task_list: list[TaskManifestV1]
 
     @validator("manifest_version")
     def manifest_version_1(cls, value):
         if value != "1":
-            raise ValueError("Wrong manifest version")
+            raise ValueError(f"Wrong manifest version (given {value})")

fractal_server/common/schemas/project.py

@@ -1,11 +1,9 @@
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 
+from pydantic import BaseModel
 from pydantic import Field
 from pydantic import validator
-from sqlmodel import SQLModel
 
 from ._validators import val_absolute_path
 from ._validators import valstr
@@ -27,7 +25,7 @@ __all__ = (
 # RESOURCE
 
 
-class _ResourceBase(SQLModel):
+class _ResourceBase(BaseModel):
     """
     Base class for Resource
     """
@@ -53,7 +51,7 @@ class ResourceRead(_ResourceBase):
 # DATASET
 
 
-class _DatasetBase(SQLModel):
+class _DatasetBase(BaseModel):
     """
     Base class for Dataset
 
@@ -66,13 +64,13 @@ class _DatasetBase(SQLModel):
 
     name: str
     type: Optional[str]
-    meta: Dict[str, Any] = Field(default={})
+    meta: dict[str, Any] = Field(default={})
     read_only: bool = False
 
 
 class DatasetUpdate(_DatasetBase):
     name: Optional[str]
-    meta: Optional[Dict[str, Any]] = None
+    meta: Optional[dict[str, Any]] = None
     read_only: Optional[bool]
 
     # Validators
@@ -88,7 +86,7 @@ class DatasetCreate(_DatasetBase):
 
 class DatasetRead(_DatasetBase):
     id: int
-    resource_list: List[ResourceRead]
+    resource_list: list[ResourceRead]
     project_id: int
     read_only: bool
 
@@ -96,7 +94,7 @@ class DatasetRead(_DatasetBase):
 # PROJECT
 
 
-class _ProjectBase(SQLModel):
+class _ProjectBase(BaseModel):
     """
     Base class for Project
 
@@ -121,7 +119,7 @@ class ProjectCreate(_ProjectBase):
 
 class ProjectRead(_ProjectBase):
     id: int
-    dataset_list: List[DatasetRead] = []
+    dataset_list: list[DatasetRead] = []
 
 
 class ProjectUpdate(_ProjectBase):

fractal_server/common/schemas/state.py

@@ -1,9 +1,8 @@
 from datetime import datetime
 from typing import Any
-from typing import Dict
 from typing import Optional
 
-from sqlmodel import SQLModel
+from pydantic import BaseModel
 
 
 __all__ = (
@@ -12,7 +11,7 @@ __all__ = (
 )
 
 
-class _StateBase(SQLModel):
+class _StateBase(BaseModel):
     """
     Base class for `State`
 
@@ -22,7 +21,7 @@ class _StateBase(SQLModel):
         timestamp: Time stamp of the state
     """
 
-    data: Dict[str, Any]
+    data: dict[str, Any]
     timestamp: datetime
 
     def sanitised_dict(self):

fractal_server/common/schemas/task.py

@@ -1,14 +1,9 @@
-from pathlib import Path
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
+from pydantic import Field
 from pydantic import validator
-from sqlmodel import Field
-from sqlmodel import SQLModel
 
 from ._validators import valstr
 
@@ -18,37 +13,22 @@ __all__ = (
     "TaskRead",
     "TaskImport",
     "TaskExport",
-    "TaskCollectPip",
-    "TaskCollectStatus",
 )
 
 
-class _TaskBase(SQLModel):
-    """# TODO fix me
-    Task base class
+class _TaskBase(BaseModel):
+    """
 
-    A Task is the elemental unit of a workflow, and must be a self-standing
-    executable.
+    Base class for `Task` and `Task{Create,Read,Update,Import,Export}` models
 
     Attributes
-        name:
-            A human readable name for the task
-        command:
-            The command(s) that executes the task
         source:
-            Path or url to task source. This is the information is used to
-            match tasks across fractal installations when a workflow is
-            imported.
-        input_type:
-            The type of data the task expects as input
-        output_type:
-            The type of data the task expects as output
-        default_args: Optional[Dict[str, Any]]
-            Dictionary (saved as JSON) of the default parameters of the task
+            This is the information is used to match tasks across fractal
+            installations when a workflow is imported.
     """
 
-    name: str
     source: str
+    _source = validator("source", allow_reuse=True)(valstr("source"))
 
 
 class TaskUpdate(_TaskBase):
@@ -57,8 +37,10 @@ class TaskUpdate(_TaskBase):
     output_type: Optional[str]
     command: Optional[str]
     source: Optional[str]
-    default_args: Optional[Dict[str, Any]]
-    meta: Optional[Dict[str, Any]]
+    meta: Optional[dict[str, Any]]
+    version: Optional[str]
+    args_schema: Optional[dict[str, Any]]
+    args_schema_version: Optional[str]
 
     # Validators
     _name = validator("name", allow_reuse=True)(valstr("name"))
@@ -69,12 +51,11 @@ class TaskUpdate(_TaskBase):
         valstr("output_type")
     )
     _command = validator("command", allow_reuse=True)(valstr("command"))
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    _version = validator("version", allow_reuse=True)(valstr("version"))
 
 
 class TaskImport(_TaskBase):
-    _name = validator("name", allow_reuse=True)(valstr("name"))
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    pass
 
 
 class TaskExport(_TaskBase):
@@ -83,19 +64,26 @@ class TaskExport(_TaskBase):
 
 class TaskRead(_TaskBase):
     id: int
+    name: str
     command: str
     input_type: str
     output_type: str
-    default_args: Optional[Dict[str, Any]] = Field(default={})
-    meta: Optional[Dict[str, Any]] = Field(default={})
+    meta: Optional[dict[str, Any]] = Field(default={})
+    owner: Optional[str]
+    version: Optional[str]
+    args_schema: Optional[dict[str, Any]]
+    args_schema_version: Optional[str]
 
 
 class TaskCreate(_TaskBase):
+    name: str
     command: str
     input_type: str
     output_type: str
-    default_args: Optional[Dict[str, Any]] = Field(default={})
-    meta: Optional[Dict[str, Any]] = Field(default={})
+    meta: Optional[dict[str, Any]] = Field(default={})
+    version: Optional[str]
+    args_schema: Optional[dict[str, Any]]
+    args_schema_version: Optional[str]
 
     # Validators
     _name = validator("name", allow_reuse=True)(valstr("name"))
@@ -106,64 +94,7 @@ class TaskCreate(_TaskBase):
         valstr("output_type")
     )
     _command = validator("command", allow_reuse=True)(valstr("command"))
-    _source = validator("source", allow_reuse=True)(valstr("source"))
-
-
-class _TaskCollectBase(BaseModel):
-    pass
-
-
-class TaskCollectPip(_TaskCollectBase):
-    """
-    TaskCollectPip class
-
-    Attributes:
-        package: TBD
-        version: TBD
-        python_version: TBD
-        package_extras: TBD
-    """
-
-    package: str
-    version: Optional[str]
-    python_version: Optional[str] = None
-    package_extras: Optional[str]
-
-    @validator("package")
-    def package_path_absolute(cls, value):
-        if "/" in value:
-            package_path = Path(value)
-            if not package_path.is_absolute():
-                raise ValueError(
-                    f"Package path must be absolute: {package_path}"
-                )
-        return value
-
-
-class TaskCollectStatus(_TaskCollectBase):
-    """
-    TaskCollectStatus class
-
-    Attributes:
-        status: TBD
-        package: TBD
-        venv_path: TBD
-        task_list: TBD
-        log: TBD
-        info: TBD
-    """
-
-    status: Literal["pending", "installing", "collecting", "fail", "OK"]
-    package: str
-    venv_path: Path
-    task_list: Optional[List[TaskRead]] = 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
+    _version = validator("version", allow_reuse=True)(valstr("version"))
+    _args_schema_version = validator("args_schema_version", allow_reuse=True)(
+        valstr("args_schema_version")
+    )

fractal_server/common/schemas/task_collection.py

@@ -0,0 +1,101 @@
+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 valstr
+from .task import TaskRead
+
+__all__ = (
+    "TaskCollectPip",
+    "TaskCollectStatus",
+)
+
+
+class _TaskCollectBase(BaseModel):
+    pass
+
+
+class TaskCollectPip(_TaskCollectBase):
+    """
+    TaskCollectPip 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
+    """
+
+    package: str
+    package_version: Optional[str] = None
+    package_extras: Optional[str] = None
+    python_version: Optional[str] = None
+
+    _package_version = validator("package_version", allow_reuse=True)(
+        valstr("package_version")
+    )
+    _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
+
+
+class TaskCollectStatus(_TaskCollectBase):
+    """
+    TaskCollectStatus class
+
+    Attributes:
+        status: TBD
+        package: TBD
+        venv_path: TBD
+        task_list: TBD
+        log: TBD
+        info: TBD
+    """
+
+    status: Literal["pending", "installing", "collecting", "fail", "OK"]
+    package: str
+    venv_path: Path
+    task_list: Optional[list[TaskRead]] = 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/common/schemas/user.py

@@ -17,16 +17,19 @@ __all__ = (
 class UserRead(schemas.BaseUser[int]):
     slurm_user: Optional[str]
     cache_dir: Optional[str]
+    username: Optional[str]
 
 
 class UserUpdate(schemas.BaseUserUpdate):
     slurm_user: Optional[str]
     cache_dir: Optional[str]
+    username: Optional[str]
 
     # Validators
     _slurm_user = validator("slurm_user", allow_reuse=True)(
         valstr("slurm_user")
     )
+    _username = validator("username", allow_reuse=True)(valstr("username"))
     _cache_dir = validator("cache_dir", allow_reuse=True)(
         val_absolute_path("cache_dir")
     )
@@ -35,11 +38,13 @@ class UserUpdate(schemas.BaseUserUpdate):
 class UserCreate(schemas.BaseUserCreate):
     slurm_user: Optional[str]
     cache_dir: Optional[str]
+    username: Optional[str]
 
     # Validators
     _slurm_user = validator("slurm_user", allow_reuse=True)(
         valstr("slurm_user")
     )
+    _username = validator("username", allow_reuse=True)(valstr("username"))
     _cache_dir = validator("cache_dir", allow_reuse=True)(
         val_absolute_path("cache_dir")
     )

fractal_server/common/schemas/workflow.py

@@ -1,10 +1,8 @@
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 
+from pydantic import BaseModel
 from pydantic import validator
-from sqlmodel import SQLModel
 
 from ._validators import valint
 from ._validators import valstr
@@ -27,10 +25,10 @@ __all__ = (
 )
 
 
-class _WorkflowTaskBase(SQLModel):
+class _WorkflowTaskBase(BaseModel):
 
-    meta: Optional[Dict[str, Any]] = None
-    args: Optional[Dict[str, Any]] = None
+    meta: Optional[dict[str, Any]] = None
+    args: Optional[dict[str, Any]] = None
 
 
 class WorkflowTaskCreate(_WorkflowTaskBase):
@@ -66,14 +64,14 @@ class WorkflowTaskUpdate(_WorkflowTaskBase):
         return m
 
 
-class _WorkflowBase(SQLModel):
+class _WorkflowBase(BaseModel):
     name: str
 
 
 class WorkflowRead(_WorkflowBase):
     id: int
     project_id: int
-    task_list: List[WorkflowTaskRead]
+    task_list: list[WorkflowTaskRead]
 
 
 class WorkflowCreate(_WorkflowBase):
@@ -83,7 +81,7 @@ class WorkflowCreate(_WorkflowBase):
 
 class WorkflowUpdate(_WorkflowBase):
     name: Optional[str]
-    reordered_workflowtask_ids: Optional[List[int]]
+    reordered_workflowtask_ids: Optional[list[int]]
 
     # Validators
     _name = validator("name", allow_reuse=True)(valstr("name"))
@@ -98,11 +96,11 @@ class WorkflowUpdate(_WorkflowBase):
 
 
 class WorkflowImport(_WorkflowBase):
-    task_list: List[WorkflowTaskImport]
+    task_list: list[WorkflowTaskImport]
 
     # Validators
     _name = validator("name", allow_reuse=True)(valstr("name"))
 
 
 class WorkflowExport(_WorkflowBase):
-    task_list: List[WorkflowTaskExport]
+    task_list: list[WorkflowTaskExport]

fractal_server/common/tests/test_manifest.py

@@ -8,15 +8,47 @@ from schemas import TaskManifestV1
 
 def test_ManifestV1():
 
-    t = TaskManifestV1(
-        name="task",
+    task_without_args_schema = TaskManifestV1(
+        name="Task A",
         executable="executable",
         input_type="input_type",
         output_type="output_type",
         default_args={"arg": "val"},
     )
-    m = ManifestV1(manifest_version="1", task_list=[t])
+    task_with_args_schema = TaskManifestV1(
+        name="Task B",
+        executable="executable",
+        input_type="input_type",
+        output_type="output_type",
+        default_args={"arg": "val"},
+        args_schema={"something": "else"},
+    )
+
+    m = ManifestV1(
+        manifest_version="1",
+        task_list=[task_without_args_schema],
+    )
+    debug(m)
+    m = ManifestV1(
+        manifest_version="1",
+        has_args_schemas=False,
+        task_list=[task_without_args_schema],
+    )
     debug(m)
+    m = ManifestV1(
+        manifest_version="1",
+        has_args_schemas=True,
+        task_list=[task_with_args_schema],
+    )
+    debug(m)
+
+    with pytest.raises(ValidationError) as e:
+        m = ManifestV1(
+            manifest_version="1",
+            task_list=[task_without_args_schema, task_with_args_schema],
+            has_args_schemas=True,
+        )
+    debug(e.value)
 
     with pytest.raises(ValidationError):
-        ManifestV1(manifest_version="2", task_list=[])
+        ManifestV1(manifest_version="2", task_list=[task_with_args_schema])