fractal-server 2.12.0a1__py3-none-any.whl → 2.13.0__py3-none-any.whl

fractal_server/app/schemas/user.py

@@ -2,9 +2,10 @@ from typing import Optional
 
 from fastapi_users import schemas
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from pydantic import Field
-from pydantic import validator
+from pydantic import field_validator
+from pydantic import ValidationInfo
 
 from ._validators import val_unique_list
 from ._validators import valstr
@@ -41,12 +42,12 @@ class UserRead(schemas.BaseUser[int]):
         username:
     """
 
-    username: Optional[str]
+    username: Optional[str] = None
     group_ids_names: Optional[list[tuple[int, str]]] = None
     oauth_accounts: list[OAuthAccountRead]
 
 
-class UserUpdate(schemas.BaseUserUpdate, extra=Extra.forbid):
+class UserUpdate(schemas.BaseUserUpdate):
     """
     Schema for `User` update.
 
@@ -54,33 +55,35 @@ class UserUpdate(schemas.BaseUserUpdate, extra=Extra.forbid):
         username:
     """
 
-    username: Optional[str]
+    model_config = ConfigDict(extra="forbid")
+
+    username: Optional[str] = None
 
     # Validators
-    _username = validator("username", allow_reuse=True)(valstr("username"))
+    _username = field_validator("username")(classmethod(valstr("username")))
 
-    @validator(
+    @field_validator(
         "is_active",
         "is_verified",
         "is_superuser",
         "email",
         "password",
-        always=False,
     )
-    def cant_set_none(cls, v, field):
+    @classmethod
+    def cant_set_none(cls, v, info: ValidationInfo):
         if v is None:
-            raise ValueError(f"Cannot set {field.name}=None")
+            raise ValueError(f"Cannot set {info.field_name}=None")
         return v
 
 
-class UserUpdateStrict(BaseModel, extra=Extra.forbid):
+class UserUpdateStrict(BaseModel):
     """
     Schema for `User` self-editing.
 
     Attributes:
     """
 
-    pass
+    model_config = ConfigDict(extra="forbid")
 
 
 class UserCreate(schemas.BaseUserCreate):
@@ -91,21 +94,23 @@ class UserCreate(schemas.BaseUserCreate):
         username:
     """
 
-    username: Optional[str]
+    username: Optional[str] = None
 
     # Validators
 
-    _username = validator("username", allow_reuse=True)(valstr("username"))
+    _username = field_validator("username")(classmethod(valstr("username")))
 
 
-class UserUpdateGroups(BaseModel, extra=Extra.forbid):
+class UserUpdateGroups(BaseModel):
     """
     Schema for `POST /auth/users/{user_id}/set-groups/`
 
     """
 
-    group_ids: list[int] = Field(min_items=1)
+    model_config = ConfigDict(extra="forbid")
+
+    group_ids: list[int] = Field(min_length=1)
 
-    _group_ids = validator("group_ids", allow_reuse=True)(
-        val_unique_list("group_ids")
+    _group_ids = field_validator("group_ids")(
+        classmethod(val_unique_list("group_ids"))
     )

fractal_server/app/schemas/user_group.py

@@ -2,9 +2,11 @@ from datetime import datetime
 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 val_unique_list
@@ -32,12 +34,16 @@ class UserGroupRead(BaseModel):
 
     id: int
     name: str
-    timestamp_created: datetime
+    timestamp_created: AwareDatetime
     user_ids: Optional[list[int]] = None
     viewer_paths: list[str]
 
+    @field_serializer("timestamp_created")
+    def serialize_datetime(v: datetime) -> str:
+        return v.isoformat()
 
-class UserGroupCreate(BaseModel, extra=Extra.forbid):
+
+class UserGroupCreate(BaseModel):
     """
     Schema for `UserGroup` creation
 
@@ -45,27 +51,35 @@ class UserGroupCreate(BaseModel, extra=Extra.forbid):
         name: Group name
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     name: str
     viewer_paths: list[str] = Field(default_factory=list)
 
-    @validator("viewer_paths")
+    @field_validator("viewer_paths")
+    @classmethod
     def viewer_paths_validator(cls, value):
         for i, path in enumerate(value):
-            value[i] = val_absolute_path(f"viewer_paths[{i}]")(path)
-        value = val_unique_list("viewer_paths")(value)
+            value[i] = val_absolute_path(f"viewer_paths[{i}]")(cls, path)
+        value = val_unique_list("viewer_paths")(cls, value)
         return value
 
 
-class UserGroupUpdate(BaseModel, extra=Extra.forbid):
+class UserGroupUpdate(BaseModel):
     """
     Schema for `UserGroup` update
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     viewer_paths: Optional[list[str]] = None
 
-    @validator("viewer_paths")
+    @field_validator("viewer_paths")
+    @classmethod
     def viewer_paths_validator(cls, value):
+        if value is None:
+            raise ValueError("Cannot set `viewer_paths=None`.")
         for i, path in enumerate(value):
-            value[i] = val_absolute_path(f"viewer_paths[{i}]")(path)
-        value = val_unique_list("viewer_paths")(value)
+            value[i] = val_absolute_path(f"viewer_paths[{i}]")(cls, path)
+        value = val_unique_list("viewer_paths")(cls, value)
         return value

fractal_server/app/schemas/user_settings.py

@@ -1,8 +1,8 @@
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
-from pydantic import validator
+from pydantic import ConfigDict
+from pydantic import field_validator
 from pydantic.types import StrictStr
 
 from ._validators import val_absolute_path
@@ -41,11 +41,13 @@ class UserSettingsReadStrict(BaseModel):
     project_dir: Optional[str] = None
 
 
-class UserSettingsUpdate(BaseModel, extra=Extra.forbid):
+class UserSettingsUpdate(BaseModel):
     """
     Schema reserved for superusers
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     ssh_host: Optional[str] = None
     ssh_username: Optional[str] = None
     ssh_private_key_path: Optional[str] = None
@@ -55,46 +57,51 @@ class UserSettingsUpdate(BaseModel, extra=Extra.forbid):
     slurm_accounts: Optional[list[StrictStr]] = None
     project_dir: Optional[str] = None
 
-    _ssh_host = validator("ssh_host", allow_reuse=True)(
-        valstr("ssh_host", accept_none=True)
+    _ssh_host = field_validator("ssh_host")(
+        classmethod(valstr("ssh_host", accept_none=True))
+    )
+    _ssh_username = field_validator("ssh_username")(
+        classmethod(valstr("ssh_username", accept_none=True))
     )
-    _ssh_username = validator("ssh_username", allow_reuse=True)(
-        valstr("ssh_username", accept_none=True)
+    _ssh_private_key_path = field_validator("ssh_private_key_path")(
+        classmethod(
+            val_absolute_path("ssh_private_key_path", accept_none=True)
+        )
     )
-    _ssh_private_key_path = validator(
-        "ssh_private_key_path", allow_reuse=True
-    )(val_absolute_path("ssh_private_key_path", accept_none=True))
 
-    _ssh_tasks_dir = validator("ssh_tasks_dir", allow_reuse=True)(
-        val_absolute_path("ssh_tasks_dir", accept_none=True)
+    _ssh_tasks_dir = field_validator("ssh_tasks_dir")(
+        classmethod(val_absolute_path("ssh_tasks_dir", accept_none=True))
     )
-    _ssh_jobs_dir = validator("ssh_jobs_dir", allow_reuse=True)(
-        val_absolute_path("ssh_jobs_dir", accept_none=True)
+    _ssh_jobs_dir = field_validator("ssh_jobs_dir")(
+        classmethod(val_absolute_path("ssh_jobs_dir", accept_none=True))
     )
 
-    _slurm_user = validator("slurm_user", allow_reuse=True)(
-        valstr("slurm_user", accept_none=True)
+    _slurm_user = field_validator("slurm_user")(
+        classmethod(valstr("slurm_user", accept_none=True))
     )
 
-    @validator("slurm_accounts")
+    @field_validator("slurm_accounts")
+    @classmethod
     def slurm_accounts_validator(cls, value):
         if value is None:
             return value
         for i, item in enumerate(value):
-            value[i] = valstr(f"slurm_accounts[{i}]")(item)
-        return val_unique_list("slurm_accounts")(value)
+            value[i] = valstr(f"slurm_accounts[{i}]")(cls, item)
+        return val_unique_list("slurm_accounts")(cls, value)
 
-    @validator("project_dir")
+    @field_validator("project_dir")
+    @classmethod
     def project_dir_validator(cls, value):
         if value is None:
             return None
         validate_cmd(value)
-        return val_absolute_path("project_dir")(value)
+        return val_absolute_path("project_dir")(cls, value)
 
 
-class UserSettingsUpdateStrict(BaseModel, extra=Extra.forbid):
+class UserSettingsUpdateStrict(BaseModel):
+    model_config = ConfigDict(extra="forbid")
     slurm_accounts: Optional[list[StrictStr]] = None
 
-    _slurm_accounts = validator("slurm_accounts", allow_reuse=True)(
-        val_unique_list("slurm_accounts")
+    _slurm_accounts = field_validator("slurm_accounts")(
+        classmethod(val_unique_list("slurm_accounts"))
     )

fractal_server/app/schemas/v2/dataset.py

@@ -3,10 +3,12 @@ from typing import Any
 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.types import AwareDatetime
 
 from .._filter_validators import validate_attribute_filters
 from .._filter_validators import validate_type_filters
@@ -27,13 +29,14 @@ class _DatasetHistoryItemV2(BaseModel):
 
     workflowtask: WorkflowTaskDumpV2
     status: WorkflowTaskStatusTypeV2
-    parallelization: Optional[dict]
+    parallelization: Optional[dict] = None
 
 
 # CRUD
 
 
-class DatasetCreateV2(BaseModel, extra=Extra.forbid):
+class DatasetCreateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
     name: str
 
@@ -44,19 +47,20 @@ class DatasetCreateV2(BaseModel, extra=Extra.forbid):
 
     # Validators
 
-    _dict_keys = root_validator(pre=True, allow_reuse=True)(
-        root_validate_dict_keys
+    _dict_keys = model_validator(mode="before")(
+        classmethod(root_validate_dict_keys)
     )
-    _type_filters = validator("type_filters", allow_reuse=True)(
-        validate_type_filters
+    _type_filters = field_validator("type_filters")(
+        classmethod(validate_type_filters)
     )
-    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
-        validate_attribute_filters
+    _attribute_filters = field_validator("attribute_filters")(
+        classmethod(validate_attribute_filters)
     )
 
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
-    @validator("zarr_dir")
+    @field_validator("zarr_dir")
+    @classmethod
     def normalize_zarr_dir(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
             return normalize_url(v)
@@ -64,7 +68,6 @@ class DatasetCreateV2(BaseModel, extra=Extra.forbid):
 
 
 class DatasetReadV2(BaseModel):
-
     id: int
     name: str
 
@@ -73,42 +76,48 @@ class DatasetReadV2(BaseModel):
 
     history: list[_DatasetHistoryItemV2]
 
-    timestamp_created: datetime
+    timestamp_created: AwareDatetime
 
     zarr_dir: str
     type_filters: dict[str, bool]
     attribute_filters: AttributeFiltersType
 
+    @field_serializer("timestamp_created")
+    def serialize_datetime(v: datetime) -> str:
+        return v.isoformat()
+
 
-class DatasetUpdateV2(BaseModel, extra=Extra.forbid):
+class DatasetUpdateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
-    name: Optional[str]
-    zarr_dir: Optional[str]
-    type_filters: Optional[dict[str, bool]]
-    attribute_filters: Optional[dict[str, list[Any]]]
+    name: Optional[str] = None
+    zarr_dir: Optional[str] = None
+    type_filters: Optional[dict[str, bool]] = None
+    attribute_filters: Optional[dict[str, list[Any]]] = None
 
     # Validators
 
-    _dict_keys = root_validator(pre=True, allow_reuse=True)(
-        root_validate_dict_keys
+    _dict_keys = model_validator(mode="before")(
+        classmethod(root_validate_dict_keys)
     )
-    _type_filters = validator("type_filters", allow_reuse=True)(
-        validate_type_filters
+    _type_filters = field_validator("type_filters")(
+        classmethod(validate_type_filters)
     )
-    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
-        validate_attribute_filters
+    _attribute_filters = field_validator("attribute_filters")(
+        classmethod(validate_attribute_filters)
     )
 
-    _name = validator("name", allow_reuse=True)(valstr("name"))
+    _name = field_validator("name")(classmethod(valstr("name")))
 
-    @validator("zarr_dir")
+    @field_validator("zarr_dir")
+    @classmethod
     def normalize_zarr_dir(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
             return normalize_url(v)
         return v
 
 
-class DatasetImportV2(BaseModel, extra=Extra.forbid):
+class DatasetImportV2(BaseModel):
     """
     Class for `Dataset` import.
 
@@ -121,6 +130,8 @@ class DatasetImportV2(BaseModel, extra=Extra.forbid):
         attribute_filters:
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     name: str
     zarr_dir: str
     images: list[SingleImage] = Field(default_factory=list)
@@ -129,7 +140,8 @@ class DatasetImportV2(BaseModel, extra=Extra.forbid):
     type_filters: dict[str, bool] = Field(default_factory=dict)
     attribute_filters: AttributeFiltersType = Field(default_factory=dict)
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def update_legacy_filters(cls, values: dict):
         """
         Transform legacy filters (created with fractal-server<2.11.0)
@@ -159,14 +171,15 @@ class DatasetImportV2(BaseModel, extra=Extra.forbid):
 
         return values
 
-    _type_filters = validator("type_filters", allow_reuse=True)(
-        validate_type_filters
+    _type_filters = field_validator("type_filters")(
+        classmethod(validate_type_filters)
     )
-    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
-        validate_attribute_filters
+    _attribute_filters = field_validator("attribute_filters")(
+        classmethod(validate_attribute_filters)
     )
 
-    @validator("zarr_dir")
+    @field_validator("zarr_dir")
+    @classmethod
     def normalize_zarr_dir(cls, v: str) -> str:
         return normalize_url(v)
 

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