fractal-server 2.12.1__py3-none-any.whl → 2.13.1__py3-none-any.whl

fractal_server/app/schemas/v2/task.py

@@ -3,11 +3,11 @@ from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from pydantic import Field
+from pydantic import field_validator
 from pydantic import HttpUrl
-from pydantic import root_validator
-from pydantic import validator
+from pydantic import model_validator
 
 from fractal_server.app.schemas._validators import val_unique_list
 from fractal_server.app.schemas._validators import valdict_keys
@@ -15,7 +15,8 @@ from fractal_server.app.schemas._validators import valstr
 from fractal_server.string_tools import validate_cmd
 
 
-class TaskCreateV2(BaseModel, extra=Extra.forbid):
+class TaskCreateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
     name: str
 
@@ -29,7 +30,7 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
     args_schema_parallel: Optional[dict[str, Any]] = None
     args_schema_version: Optional[str] = None
     docs_info: Optional[str] = None
-    docs_link: Optional[HttpUrl] = None
+    docs_link: Optional[str] = None
 
     input_types: dict[str, bool] = Field(default={})
     output_types: dict[str, bool] = Field(default={})
@@ -40,10 +41,10 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
     authors: Optional[str] = None
 
     # Validators
-    @root_validator
-    def validate_commands(cls, values):
-        command_parallel = values.get("command_parallel")
-        command_non_parallel = values.get("command_non_parallel")
+    @model_validator(mode="after")
+    def validate_commands(self):
+        command_parallel = self.command_parallel
+        command_non_parallel = self.command_non_parallel
         if (command_parallel is None) and (command_non_parallel is None):
             raise ValueError(
                 "Task must have at least one valid command "
@@ -54,58 +55,65 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
         if command_non_parallel is not None:
             validate_cmd(command_non_parallel)
 
-        return values
+        return self
 
-    _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")
+    _name = field_validator("name")(classmethod(valstr("name")))
+    _command_non_parallel = field_validator("command_non_parallel")(
+        classmethod(valstr("command_non_parallel"))
     )
-    _version = validator("version", allow_reuse=True)(valstr("version"))
+    _command_parallel = field_validator("command_parallel")(
+        classmethod(valstr("command_parallel"))
+    )
+    _version = field_validator("version")(classmethod(valstr("version")))
 
-    _meta_non_parallel = validator("meta_non_parallel", allow_reuse=True)(
-        valdict_keys("meta_non_parallel")
+    _meta_non_parallel = field_validator("meta_non_parallel")(
+        classmethod(valdict_keys("meta_non_parallel"))
+    )
+    _meta_parallel = field_validator("meta_parallel")(
+        classmethod(valdict_keys("meta_parallel"))
     )
-    _meta_parallel = validator("meta_parallel", allow_reuse=True)(
-        valdict_keys("meta_parallel")
+    _args_schema_non_parallel = field_validator("args_schema_non_parallel")(
+        classmethod(valdict_keys("args_schema_non_parallel"))
     )
-    _args_schema_non_parallel = validator(
-        "args_schema_non_parallel", allow_reuse=True
-    )(valdict_keys("args_schema_non_parallel"))
-    _args_schema_parallel = validator(
-        "args_schema_parallel", allow_reuse=True
-    )(valdict_keys("args_schema_parallel"))
-    _args_schema_version = validator("args_schema_version", allow_reuse=True)(
-        valstr("args_schema_version")
+    _args_schema_parallel = field_validator("args_schema_parallel")(
+        classmethod(valdict_keys("args_schema_parallel"))
     )
-    _input_types = validator("input_types", allow_reuse=True)(
-        valdict_keys("input_types")
+    _args_schema_version = field_validator("args_schema_version")(
+        classmethod(valstr("args_schema_version"))
     )
-    _output_types = validator("output_types", allow_reuse=True)(
-        valdict_keys("output_types")
+    _input_types = field_validator("input_types")(
+        classmethod(valdict_keys("input_types"))
+    )
+    _output_types = field_validator("output_types")(
+        classmethod(valdict_keys("output_types"))
     )
 
-    _category = validator("category", allow_reuse=True)(
-        valstr("category", accept_none=True)
+    _category = field_validator("category")(
+        classmethod(valstr("category", accept_none=True))
     )
-    _modality = validator("modality", allow_reuse=True)(
-        valstr("modality", accept_none=True)
+    _modality = field_validator("modality")(
+        classmethod(valstr("modality", accept_none=True))
     )
-    _authors = validator("authors", allow_reuse=True)(
-        valstr("authors", accept_none=True)
+    _authors = field_validator("authors")(
+        classmethod(valstr("authors", accept_none=True))
     )
 
-    @validator("tags")
+    @field_validator("tags")
+    @classmethod
     def validate_list_of_strings(cls, value):
         for i, tag in enumerate(value):
-            value[i] = valstr(f"tags[{i}]")(tag)
-        return val_unique_list("tags")(value)
+            value[i] = valstr(f"tags[{i}]")(cls, tag)
+        return val_unique_list("tags")(cls, value)
 
+    @field_validator("docs_link", mode="after")
+    @classmethod
+    def validate_docs_link(cls, value):
+        if value is not None:
+            HttpUrl(value)
+        return value
 
-class TaskReadV2(BaseModel):
 
+class TaskReadV2(BaseModel):
     id: int
     name: str
     type: Literal["parallel", "non_parallel", "compound"]
@@ -120,7 +128,7 @@ class TaskReadV2(BaseModel):
     args_schema_parallel: Optional[dict[str, Any]] = None
     args_schema_version: Optional[str] = None
     docs_info: Optional[str] = None
-    docs_link: Optional[HttpUrl] = None
+    docs_link: Optional[str] = None
     input_types: dict[str, bool]
     output_types: dict[str, bool]
 
@@ -132,7 +140,8 @@ class TaskReadV2(BaseModel):
     tags: list[str]
 
 
-class TaskUpdateV2(BaseModel, extra=Extra.forbid):
+class TaskUpdateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
     command_parallel: Optional[str] = None
     command_non_parallel: Optional[str] = None
@@ -145,67 +154,69 @@ class TaskUpdateV2(BaseModel, extra=Extra.forbid):
     tags: Optional[list[str]] = None
 
     # Validators
-    @validator("input_types", "output_types")
+    @field_validator("input_types", "output_types")
+    @classmethod
     def val_is_dict(cls, v):
         if not isinstance(v, dict):
             raise ValueError
         return v
 
-    _command_parallel = validator("command_parallel", allow_reuse=True)(
-        valstr("command_parallel")
+    _command_parallel = field_validator("command_parallel")(
+        classmethod(valstr("command_parallel"))
+    )
+    _command_non_parallel = field_validator("command_non_parallel")(
+        classmethod(valstr("command_non_parallel"))
     )
-    _command_non_parallel = validator(
-        "command_non_parallel", allow_reuse=True
-    )(valstr("command_non_parallel"))
-    _input_types = validator("input_types", allow_reuse=True)(
-        valdict_keys("input_types")
+    _input_types = field_validator("input_types")(
+        classmethod(valdict_keys("input_types"))
     )
-    _output_types = validator("output_types", allow_reuse=True)(
-        valdict_keys("output_types")
+    _output_types = field_validator("output_types")(
+        classmethod(valdict_keys("output_types"))
     )
 
-    _category = validator("category", allow_reuse=True)(
-        valstr("category", accept_none=True)
+    _category = field_validator("category")(
+        classmethod(valstr("category", accept_none=True))
     )
-    _modality = validator("modality", allow_reuse=True)(
-        valstr("modality", accept_none=True)
+    _modality = field_validator("modality")(
+        classmethod(valstr("modality", accept_none=True))
     )
-    _authors = validator("authors", allow_reuse=True)(
-        valstr("authors", accept_none=True)
+    _authors = field_validator("authors")(
+        classmethod(valstr("authors", accept_none=True))
     )
 
-    @validator("tags")
+    @field_validator("tags")
+    @classmethod
     def validate_tags(cls, value):
         for i, tag in enumerate(value):
-            value[i] = valstr(f"tags[{i}]")(tag)
-        return val_unique_list("tags")(value)
+            value[i] = valstr(f"tags[{i}]")(cls, tag)
+        return val_unique_list("tags")(cls, value)
 
 
-class TaskImportV2(BaseModel, extra=Extra.forbid):
+class TaskImportV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
     pkg_name: str
     version: Optional[str] = None
     name: str
-    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
-    _version = validator("version", allow_reuse=True)(
-        valstr("version", accept_none=True)
+    _pkg_name = field_validator("pkg_name")(classmethod(valstr("pkg_name")))
+    _version = field_validator("version")(
+        classmethod(valstr("version", accept_none=True))
     )
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
 
 class TaskImportV2Legacy(BaseModel):
     source: str
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    _source = field_validator("source")(classmethod(valstr("source")))
 
 
 class TaskExportV2(BaseModel):
-
     pkg_name: str
     version: Optional[str] = None
     name: str
 
-    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
-    _version = validator("version", allow_reuse=True)(
-        valstr("version", accept_none=True)
+    _pkg_name = field_validator("pkg_name")(classmethod(valstr("pkg_name")))
+    _version = field_validator("version")(
+        classmethod(valstr("version", accept_none=True))
     )
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))

fractal_server/app/schemas/v2/task_collection.py

@@ -3,9 +3,9 @@ from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
-from pydantic import root_validator
-from pydantic import validator
+from pydantic import ConfigDict
+from pydantic import field_validator
+from pydantic import model_validator
 
 from .._validators import valstr
 from fractal_server.app.schemas.v2 import ManifestV2
@@ -21,7 +21,7 @@ class WheelFile(BaseModel):
     contents: bytes
 
 
-class TaskCollectPipV2(BaseModel, extra=Extra.forbid):
+class TaskCollectPipV2(BaseModel):
     """
     TaskCollectPipV2 class
 
@@ -45,35 +45,40 @@ class TaskCollectPipV2(BaseModel, extra=Extra.forbid):
 
     """
 
+    model_config = ConfigDict(extra="forbid")
     package: Optional[str] = None
     package_version: Optional[str] = None
     package_extras: Optional[str] = None
     python_version: Optional[Literal["3.9", "3.10", "3.11", "3.12"]] = None
     pinned_package_versions: Optional[dict[str, str]] = None
 
-    @validator("package")
+    @field_validator("package")
+    @classmethod
     def package_validator(cls, value: Optional[str]) -> Optional[str]:
         if value is None:
             return value
-        value = valstr("package")(value)
+        value = valstr("package")(cls, value)
         validate_cmd(value, attribute_name="package")
         return value
 
-    @validator("package_version")
+    @field_validator("package_version")
+    @classmethod
     def package_version_validator(cls, value: Optional[str]) -> Optional[str]:
         if value is None:
             return value
-        value = valstr("package_version")(value)
+        value = valstr("package_version")(cls, value)
         validate_cmd(value, attribute_name="package_version")
         return value
 
-    @validator("pinned_package_versions")
+    @field_validator("pinned_package_versions")
+    @classmethod
     def pinned_package_versions_validator(cls, value):
         if value is None:
             return value
         old_keys = list(value.keys())
         new_keys = [
-            valstr(f"pinned_package_versions[{key}]")(key) for key in old_keys
+            valstr(f"pinned_package_versions[{key}]")(cls, key)
+            for key in old_keys
         ]
         if len(new_keys) != len(set(new_keys)):
             raise ValueError(
@@ -87,16 +92,17 @@ class TaskCollectPipV2(BaseModel, extra=Extra.forbid):
             validate_cmd(version)
         return value
 
-    @validator("package_extras")
+    @field_validator("package_extras")
+    @classmethod
     def package_extras_validator(cls, value: Optional[str]) -> Optional[str]:
         if value is None:
             return value
-        value = valstr("package_extras")(value)
+        value = valstr("package_extras")(cls, value)
         validate_cmd(value, attribute_name="package_extras")
         return value
 
 
-class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
+class TaskCollectCustomV2(BaseModel):
     """
     Attributes:
         manifest: Manifest of a Fractal task package (this is typically the
@@ -114,29 +120,31 @@ class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
         version: Optional version of tasks to be collected.
     """
 
+    model_config = ConfigDict(extra="forbid")
     manifest: ManifestV2
     python_interpreter: str
     label: str
-    package_root: Optional[str]
-    package_name: Optional[str]
-    version: Optional[str]
+    package_root: Optional[str] = None
+    package_name: Optional[str] = None
+    version: Optional[str] = None
 
     # Valstr
-    _python_interpreter = validator("python_interpreter", allow_reuse=True)(
-        valstr("python_interpreter")
+    _python_interpreter = field_validator("python_interpreter")(
+        classmethod(valstr("python_interpreter"))
     )
-    _label = validator("label", allow_reuse=True)(valstr("label"))
-    _package_root = validator("package_root", allow_reuse=True)(
-        valstr("package_root", accept_none=True)
+    _label = field_validator("label")(classmethod(valstr("label")))
+    _package_root = field_validator("package_root")(
+        classmethod(valstr("package_root", accept_none=True))
     )
-    _package_name = validator("package_name", allow_reuse=True)(
-        valstr("package_name", accept_none=True)
+    _package_name = field_validator("package_name")(
+        classmethod(valstr("package_name", accept_none=True))
     )
-    _version = validator("version", allow_reuse=True)(
-        valstr("version", accept_none=True)
+    _version = field_validator("version")(
+        classmethod(valstr("version", accept_none=True))
     )
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def one_of_package_root_or_name(cls, values):
         package_root = values.get("package_root")
         package_name = values.get("package_name")
@@ -149,18 +157,20 @@ class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
             )
         return values
 
-    @validator("package_name")
+    @field_validator("package_name")
+    @classmethod
     def package_name_validator(cls, value: str):
         """
         Remove all whitespace characters, then check for invalid code.
         """
         if value is not None:
             validate_cmd(value)
-            value = valstr("package_name")(value)
+            value = valstr("package_name")(cls, value)
             value = value.replace(" ", "")
         return value
 
-    @validator("package_root")
+    @field_validator("package_root")
+    @classmethod
     def package_root_validator(cls, value):
         if (value is not None) and (not Path(value).is_absolute()):
             raise ValueError(
@@ -168,7 +178,8 @@ class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
             )
         return value
 
-    @validator("python_interpreter")
+    @field_validator("python_interpreter")
+    @classmethod
     def python_interpreter_validator(cls, value):
         if not Path(value).is_absolute():
             raise ValueError(

fractal_server/app/schemas/v2/task_group.py

@@ -3,9 +3,11 @@ from enum import Enum
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from pydantic import Field
-from pydantic import validator
+from pydantic import field_serializer
+from pydantic import field_validator
+from pydantic.types import AwareDatetime
 
 from .._validators import val_absolute_path
 from .._validators import valdict_keys
@@ -32,7 +34,8 @@ class TaskGroupActivityActionV2(str, Enum):
     REACTIVATE = "reactivate"
 
 
-class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
+class TaskGroupCreateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     user_id: int
     user_group_id: Optional[int] = None
     active: bool = True
@@ -48,21 +51,21 @@ class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
     pinned_package_versions: dict[str, str] = Field(default_factory=dict)
 
     # Validators
-    _path = validator("path", allow_reuse=True)(val_absolute_path("path"))
-    _venv_path = validator("venv_path", allow_reuse=True)(
-        val_absolute_path("venv_path")
+    _path = field_validator("path")(classmethod(val_absolute_path("path")))
+    _venv_path = field_validator("venv_path")(
+        classmethod(val_absolute_path("venv_path"))
     )
-    _wheel_path = validator("wheel_path", allow_reuse=True)(
-        val_absolute_path("wheel_path")
+    _wheel_path = field_validator("wheel_path")(
+        classmethod(val_absolute_path("wheel_path"))
     )
-    _pinned_package_versions = validator(
-        "pinned_package_versions", allow_reuse=True
-    )(valdict_keys("pinned_package_versions"))
-    _pip_extras = validator("pip_extras", allow_reuse=True)(
-        valstr("pip_extras")
+    _pinned_package_versions = field_validator("pinned_package_versions")(
+        valdict_keys("pinned_package_versions")
     )
-    _python_version = validator("python_version", allow_reuse=True)(
-        valstr("python_version")
+    _pip_extras = field_validator("pip_extras")(
+        classmethod(valstr("pip_extras"))
+    )
+    _python_version = field_validator("python_version")(
+        classmethod(valstr("python_version"))
     )
 
 
@@ -99,11 +102,16 @@ class TaskGroupReadV2(BaseModel):
     venv_file_number: Optional[int] = None
 
     active: bool
-    timestamp_created: datetime
-    timestamp_last_used: datetime
+    timestamp_created: AwareDatetime
+    timestamp_last_used: AwareDatetime
+
+    @field_serializer("timestamp_created", "timestamp_last_used")
+    def serialize_datetime(v: datetime) -> str:
+        return v.isoformat()
 
 
-class TaskGroupUpdateV2(BaseModel, extra=Extra.forbid):
+class TaskGroupUpdateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     user_group_id: Optional[int] = None
 
 
@@ -111,10 +119,21 @@ class TaskGroupActivityV2Read(BaseModel):
     id: int
     user_id: int
     taskgroupv2_id: Optional[int] = None
-    timestamp_started: datetime
-    timestamp_ended: Optional[datetime] = None
+    timestamp_started: AwareDatetime
+    timestamp_ended: Optional[AwareDatetime] = None
     pkg_name: str
     version: str
     status: TaskGroupActivityStatusV2
     action: TaskGroupActivityActionV2
     log: Optional[str] = None
+
+    @field_serializer("timestamp_started")
+    def serialize_datetime_start(v: datetime) -> str:
+        return v.isoformat()
+
+    @field_serializer("timestamp_ended")
+    def serialize_datetime_end(v: Optional[datetime]) -> Optional[str]:
+        if v is None:
+            return None
+        else:
+            return v.isoformat()

fractal_server/app/schemas/v2/workflow.py

@@ -2,8 +2,10 @@ from datetime import datetime
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
-from pydantic import validator
+from pydantic import ConfigDict
+from pydantic import field_serializer
+from pydantic import field_validator
+from pydantic.types import AwareDatetime
 
 from .._validators import valstr
 from .project import ProjectReadV2
@@ -13,12 +15,14 @@ from .workflowtask import WorkflowTaskReadV2
 from .workflowtask import WorkflowTaskReadV2WithWarning
 
 
-class WorkflowCreateV2(BaseModel, extra=Extra.forbid):
+class WorkflowCreateV2(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     name: str
 
     # Validators
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
 
 class WorkflowReadV2(BaseModel):
@@ -28,22 +32,29 @@ class WorkflowReadV2(BaseModel):
     project_id: int
     task_list: list[WorkflowTaskReadV2]
     project: ProjectReadV2
-    timestamp_created: datetime
+    timestamp_created: AwareDatetime
+
+    @field_serializer("timestamp_created")
+    def serialize_datetime(v: datetime) -> str:
+        return v.isoformat()
 
 
 class WorkflowReadV2WithWarnings(WorkflowReadV2):
     task_list: list[WorkflowTaskReadV2WithWarning]
 
 
-class WorkflowUpdateV2(BaseModel, extra=Extra.forbid):
+class WorkflowUpdateV2(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
-    name: Optional[str]
-    reordered_workflowtask_ids: Optional[list[int]]
+    name: Optional[str] = None
+    reordered_workflowtask_ids: Optional[list[int]] = None
 
     # Validators
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
-    @validator("reordered_workflowtask_ids")
+    @field_validator("reordered_workflowtask_ids")
+    @classmethod
     def check_positive_and_unique(cls, value):
         if any(i < 0 for i in value):
             raise ValueError("Negative `id` in `reordered_workflowtask_ids`")
@@ -52,7 +63,7 @@ class WorkflowUpdateV2(BaseModel, extra=Extra.forbid):
         return value
 
 
-class WorkflowImportV2(BaseModel, extra=Extra.forbid):
+class WorkflowImportV2(BaseModel):
     """
     Class for `Workflow` import.
 
@@ -60,11 +71,12 @@ class WorkflowImportV2(BaseModel, extra=Extra.forbid):
         task_list:
     """
 
+    model_config = ConfigDict(extra="forbid")
     name: str
     task_list: list[WorkflowTaskImportV2]
 
     # Validators
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
 
 class WorkflowExportV2(BaseModel):