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

fractal_server/app/schemas/v2/dumps.py

@@ -11,13 +11,13 @@ These models are used in at least two situations:
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 
 from fractal_server.images.models import AttributeFiltersType
 
 
-class ProjectDumpV2(BaseModel, extra=Extra.forbid):
-
+class ProjectDumpV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     id: int
     name: str
     timestamp_created: str
@@ -28,10 +28,10 @@ class TaskDumpV2(BaseModel):
     name: str
     type: str
 
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
     source: Optional[str] = None
-    version: Optional[str]
+    version: Optional[str] = None
 
     input_types: dict[str, bool]
     output_types: dict[str, bool]
@@ -39,29 +39,31 @@ class TaskDumpV2(BaseModel):
 
 class WorkflowTaskDumpV2(BaseModel):
     """
-    We do not include 'extra=Extra.forbid' because legacy data may include
-    'input_filters' field and we want to avoid response-validation errors
-    for the endpoints that GET datasets.
+    We do not include 'model_config = ConfigDict(extra="forbid")'
+    because legacy data may include 'input_filters' field and we want to avoid
+    response-validation errors for the endpoints that GET datasets.
     """
 
     id: int
     workflow_id: int
-    order: Optional[int]
+    order: Optional[int] = None
 
     type_filters: dict[str, bool]
 
-    task_id: Optional[int]
-    task: Optional[TaskDumpV2]
+    task_id: Optional[int] = None
+    task: Optional[TaskDumpV2] = None
 
 
-class WorkflowDumpV2(BaseModel, extra=Extra.forbid):
+class WorkflowDumpV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     id: int
     name: str
     project_id: int
     timestamp_created: str
 
 
-class DatasetDumpV2(BaseModel, extra=Extra.forbid):
+class DatasetDumpV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     id: int
     name: str
     project_id: int

fractal_server/app/schemas/v2/job.py

@@ -3,10 +3,13 @@ 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 root_validator
-from pydantic import validator
+from pydantic import field_serializer
+from pydantic import field_validator
+from pydantic import model_validator
+from pydantic import ValidationInfo
+from pydantic.types import AwareDatetime
 from pydantic.types import StrictStr
 
 from .._filter_validators import validate_attribute_filters
@@ -39,28 +42,31 @@ class JobStatusTypeV2(str, Enum):
     FAILED = "failed"
 
 
-class JobCreateV2(BaseModel, extra=Extra.forbid):
+class JobCreateV2(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     first_task_index: Optional[int] = None
     last_task_index: Optional[int] = None
     slurm_account: Optional[StrictStr] = None
-    worker_init: Optional[str]
+    worker_init: Optional[str] = None
 
     attribute_filters: AttributeFiltersType = Field(default_factory=dict)
 
     # Validators
-    _worker_init = validator("worker_init", allow_reuse=True)(
-        valstr("worker_init")
+    _worker_init = field_validator("worker_init")(
+        classmethod(valstr("worker_init"))
     )
-    _dict_keys = root_validator(pre=True, allow_reuse=True)(
-        root_validate_dict_keys
+    _dict_keys = model_validator(mode="before")(
+        classmethod(root_validate_dict_keys)
     )
-    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
-        validate_attribute_filters
+    _attribute_filters = field_validator("attribute_filters")(
+        classmethod(validate_attribute_filters)
     )
 
-    @validator("first_task_index", always=True)
-    def first_task_index_non_negative(cls, v, values):
+    @field_validator("first_task_index")
+    @classmethod
+    def first_task_index_non_negative(cls, v):
         """
         Check that `first_task_index` is non-negative.
         """
@@ -70,8 +76,9 @@ class JobCreateV2(BaseModel, extra=Extra.forbid):
             )
         return v
 
-    @validator("last_task_index", always=True)
-    def first_last_task_indices(cls, v, values):
+    @field_validator("last_task_index")
+    @classmethod
+    def first_last_task_indices(cls, v, info: ValidationInfo):
         """
         Check that `last_task_index` is non-negative, and that it is not
         smaller than `first_task_index`.
@@ -81,7 +88,7 @@ class JobCreateV2(BaseModel, extra=Extra.forbid):
                 f"last_task_index cannot be negative (given: {v})"
             )
 
-        first_task_index = values.get("first_task_index")
+        first_task_index = info.data.get("first_task_index")
         last_task_index = v
         if first_task_index is not None and last_task_index is not None:
             if first_task_index > last_task_index:
@@ -95,26 +102,39 @@ class JobCreateV2(BaseModel, extra=Extra.forbid):
 class JobReadV2(BaseModel):
 
     id: int
-    project_id: Optional[int]
+    project_id: Optional[int] = None
     project_dump: ProjectDumpV2
     user_email: str
-    slurm_account: Optional[str]
-    workflow_id: Optional[int]
+    slurm_account: Optional[str] = None
+    workflow_id: Optional[int] = None
     workflow_dump: WorkflowDumpV2
-    dataset_id: Optional[int]
+    dataset_id: Optional[int] = None
     dataset_dump: DatasetDumpV2
-    start_timestamp: datetime
-    end_timestamp: Optional[datetime]
+    start_timestamp: AwareDatetime
+    end_timestamp: Optional[AwareDatetime] = None
     status: str
-    log: Optional[str]
-    working_dir: Optional[str]
-    working_dir_user: Optional[str]
-    first_task_index: Optional[int]
-    last_task_index: Optional[int]
-    worker_init: Optional[str]
+    log: Optional[str] = None
+    working_dir: Optional[str] = None
+    working_dir_user: Optional[str] = None
+    first_task_index: Optional[int] = None
+    last_task_index: Optional[int] = None
+    worker_init: Optional[str] = None
     attribute_filters: AttributeFiltersType
 
+    @field_serializer("start_timestamp")
+    def serialize_datetime_start(v: datetime) -> str:
+        return v.isoformat()
+
+    @field_serializer("end_timestamp")
+    def serialize_datetime_end(v: Optional[datetime]) -> Optional[str]:
+        if v is None:
+            return None
+        else:
+            return v.isoformat()
+
+
+class JobUpdateV2(BaseModel):
 
-class JobUpdateV2(BaseModel, extra=Extra.forbid):
+    model_config = ConfigDict(extra="forbid")
 
     status: JobStatusTypeV2

fractal_server/app/schemas/v2/manifest.py

@@ -3,9 +3,9 @@ from typing import Optional
 
 from pydantic import BaseModel
 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 .._validators import valstr
 
@@ -50,27 +50,24 @@ class TaskManifestV2(BaseModel):
     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
+    docs_link: Optional[str] = None
 
     category: Optional[str] = None
     modality: Optional[str] = None
     tags: list[str] = Field(default_factory=list)
 
-    @root_validator
-    def validate_executable_args_meta(cls, values):
-
-        executable_non_parallel = values.get("executable_non_parallel")
-        executable_parallel = values.get("executable_parallel")
+    @model_validator(mode="after")
+    def validate_executable_args_meta(self):
+        executable_non_parallel = self.executable_non_parallel
+        executable_parallel = self.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")
+            meta_non_parallel = self.meta_non_parallel
             if meta_non_parallel != {}:
                 raise ValueError(
                     "`TaskManifestV2.meta_non_parallel` must be an empty dict "
@@ -78,7 +75,7 @@ class TaskManifestV2(BaseModel):
                     f"Given: {meta_non_parallel}."
                 )
 
-            args_schema_non_parallel = values.get("args_schema_non_parallel")
+            args_schema_non_parallel = self.args_schema_non_parallel
             if args_schema_non_parallel is not None:
                 raise ValueError(
                     "`TaskManifestV2.args_schema_non_parallel` must be None "
@@ -87,8 +84,7 @@ class TaskManifestV2(BaseModel):
                 )
 
         elif executable_parallel is None:
-
-            meta_parallel = values.get("meta_parallel")
+            meta_parallel = self.meta_parallel
             if meta_parallel != {}:
                 raise ValueError(
                     "`TaskManifestV2.meta_parallel` must be an empty dict if "
@@ -96,7 +92,7 @@ class TaskManifestV2(BaseModel):
                     f"Given: {meta_parallel}."
                 )
 
-            args_schema_parallel = values.get("args_schema_parallel")
+            args_schema_parallel = self.args_schema_parallel
             if args_schema_parallel is not None:
                 raise ValueError(
                     "`TaskManifestV2.args_schema_parallel` must be None if "
@@ -104,7 +100,14 @@ class TaskManifestV2(BaseModel):
                     f"Given: {args_schema_parallel}."
                 )
 
-        return values
+        return self
+
+    @field_validator("docs_link", mode="after")
+    @classmethod
+    def validate_docs_link(cls, value):
+        if value is not None:
+            HttpUrl(value)
+        return value
 
 
 class ManifestV2(BaseModel):
@@ -137,10 +140,10 @@ class ManifestV2(BaseModel):
     args_schema_version: Optional[str] = None
     authors: Optional[str] = None
 
-    @root_validator()
-    def _check_args_schemas_are_present(cls, values):
-        has_args_schemas = values["has_args_schemas"]
-        task_list = values["task_list"]
+    @model_validator(mode="after")
+    def _check_args_schemas_are_present(self):
+        has_args_schemas = self.has_args_schemas
+        task_list = self.task_list
         if has_args_schemas is True:
             for task in task_list:
                 if task.executable_parallel is not None:
@@ -157,11 +160,11 @@ class ManifestV2(BaseModel):
                             f"task '{task.name}' has "
                             f"{task.args_schema_non_parallel=}."
                         )
-        return values
+        return self
 
-    @root_validator()
-    def _unique_task_names(cls, values):
-        task_list = values["task_list"]
+    @model_validator(mode="after")
+    def _unique_task_names(self):
+        task_list = self.task_list
         task_list_names = [t.name for t in task_list]
         if len(set(task_list_names)) != len(task_list_names):
             raise ValueError(
@@ -170,14 +173,15 @@ class ManifestV2(BaseModel):
                     f"Given: {task_list_names}.",
                 )
             )
-        return values
+        return self
 
-    @validator("manifest_version")
+    @field_validator("manifest_version")
+    @classmethod
     def manifest_version_2(cls, value):
         if value != "2":
             raise ValueError(f"Wrong manifest version (given {value})")
         return value
 
-    _authors = validator("authors", allow_reuse=True)(
-        valstr("authors", accept_none=True)
+    _authors = field_validator("authors")(
+        classmethod(valstr("authors", accept_none=True))
     )

fractal_server/app/schemas/v2/project.py

@@ -2,28 +2,38 @@ 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
 
 
-class ProjectCreateV2(BaseModel, extra=Extra.forbid):
+class ProjectCreateV2(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 ProjectReadV2(BaseModel):
 
     id: int
     name: str
-    timestamp_created: datetime
+    timestamp_created: AwareDatetime
+
+    @field_serializer("timestamp_created")
+    def serialize_datetime(v: datetime) -> str:
+        return v.isoformat()
+
 
+class ProjectUpdateV2(BaseModel):
 
-class ProjectUpdateV2(BaseModel, extra=Extra.forbid):
+    model_config = ConfigDict(extra="forbid")
 
-    name: Optional[str]
+    name: Optional[str] = None
     # Validators
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))

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")))