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

fractal_server/app/runner/v2/_slurm_common/get_slurm_config.py

@@ -67,14 +67,14 @@ def get_slurm_config(
 
     # Incorporate slurm_env.default_slurm_config
     slurm_env = load_slurm_config_file(config_path=config_path)
-    slurm_dict = slurm_env.default_slurm_config.dict(
+    slurm_dict = slurm_env.default_slurm_config.model_dump(
         exclude_unset=True, exclude={"mem"}
     )
     if slurm_env.default_slurm_config.mem:
         slurm_dict["mem_per_task_MB"] = slurm_env.default_slurm_config.mem
 
     # Incorporate slurm_env.batching_config
-    for key, value in slurm_env.batching_config.dict().items():
+    for key, value in slurm_env.batching_config.model_dump().items():
         slurm_dict[key] = value
 
     # Incorporate slurm_env.user_local_exports
@@ -82,7 +82,7 @@ def get_slurm_config(
 
     logger.debug(
         "[get_slurm_config] Fractal SLURM configuration file: "
-        f"{slurm_env.dict()=}"
+        f"{slurm_env.model_dump()=}"
     )
 
     # GPU-related options
@@ -97,7 +97,7 @@ def get_slurm_config(
         needs_gpu = False
     logger.debug(f"[get_slurm_config] {needs_gpu=}")
     if needs_gpu:
-        for key, value in slurm_env.gpu_slurm_config.dict(
+        for key, value in slurm_env.gpu_slurm_config.model_dump(
             exclude_unset=True, exclude={"mem"}
         ).items():
             slurm_dict[key] = value

fractal_server/app/runner/v2/_slurm_sudo/__init__.py

@@ -21,7 +21,7 @@ from typing import Optional
 
 from ....models.v2 import DatasetV2
 from ....models.v2 import WorkflowV2
-from ...executors.slurm.sudo.executor import FractalSlurmExecutor
+from ...executors.slurm.sudo.executor import FractalSlurmSudoExecutor
 from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _slurm_submit_setup
@@ -64,7 +64,7 @@ def process_workflow(
     if isinstance(worker_init, str):
         worker_init = worker_init.split("\n")
 
-    with FractalSlurmExecutor(
+    with FractalSlurmSudoExecutor(
         debug=True,
         keep_logs=True,
         slurm_user=slurm_user,

fractal_server/app/runner/v2/deduplicate_list.py

@@ -16,7 +16,7 @@ def deduplicate_list(
     new_list_dict = []
     new_list_objs = []
     for this_obj in this_list:
-        this_dict = this_obj.dict()
+        this_dict = this_obj.model_dump()
         if this_dict not in new_list_dict:
             new_list_dict.append(this_dict)
             new_list_objs.append(this_obj)

fractal_server/app/runner/v2/runner.py

@@ -75,10 +75,13 @@ def execute_tasks_v2(
         with next(get_sync_db()) as db:
             db_dataset = db.get(DatasetV2, dataset.id)
             new_history_item = _DatasetHistoryItemV2(
-                workflowtask=wftask,
+                workflowtask=dict(
+                    **wftask.model_dump(exclude={"task"}),
+                    task=wftask.task.model_dump(),
+                ),
                 status=WorkflowTaskStatusTypeV2.SUBMITTED,
                 parallelization=dict(),  # FIXME: re-include parallelization
-            ).dict()
+            ).model_dump()
             db_dataset.history.append(new_history_item)
             flag_modified(db_dataset, "history")
             db.merge(db_dataset)
@@ -132,7 +135,9 @@ def execute_tasks_v2(
             and current_task_output.image_list_removals == []
         ):
             current_task_output = TaskOutput(
-                **current_task_output.dict(exclude={"image_list_updates"}),
+                **current_task_output.model_dump(
+                    exclude={"image_list_updates"}
+                ),
                 image_list_updates=[
                     dict(zarr_url=img["zarr_url"]) for img in filtered_images
                 ],
@@ -141,7 +146,7 @@ def execute_tasks_v2(
         # Update image list
         current_task_output.check_zarr_urls_are_unique()
         for image_obj in current_task_output.image_list_updates:
-            image = image_obj.dict()
+            image = image_obj.model_dump()
             # Edit existing image
             tmp_image_paths = [img["zarr_url"] for img in tmp_images]
             if image["zarr_url"] in tmp_image_paths:

fractal_server/app/runner/v2/task_interface.py

@@ -1,15 +1,17 @@
 from typing import Any
 
 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 ....images import SingleImageTaskOutput
 from fractal_server.urls import normalize_url
 
 
-class TaskOutput(BaseModel, extra=Extra.forbid):
+class TaskOutput(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     image_list_updates: list[SingleImageTaskOutput] = Field(
         default_factory=list
@@ -35,21 +37,27 @@ class TaskOutput(BaseModel, extra=Extra.forbid):
                 msg = f"{msg}\n{duplicate}"
             raise ValueError(msg)
 
-    @validator("image_list_removals")
+    @field_validator("image_list_removals")
+    @classmethod
     def normalize_paths(cls, v: list[str]) -> list[str]:
         return [normalize_url(zarr_url) for zarr_url in v]
 
 
-class InitArgsModel(BaseModel, extra=Extra.forbid):
+class InitArgsModel(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     zarr_url: str
     init_args: dict[str, Any] = Field(default_factory=dict)
 
-    @validator("zarr_url")
+    @field_validator("zarr_url")
+    @classmethod
     def normalize_path(cls, v: str) -> str:
         return normalize_url(v)
 
 
-class InitTaskOutput(BaseModel, extra=Extra.forbid):
+class InitTaskOutput(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     parallelization_list: list[InitArgsModel] = Field(default_factory=list)

fractal_server/app/schemas/_filter_validators.py

@@ -5,22 +5,25 @@ from fractal_server.images.models import AttributeFiltersType
 
 
 def validate_type_filters(
-    type_filters: Optional[dict[str, bool]]
+    cls, type_filters: Optional[dict[str, bool]]
 ) -> dict[str, bool]:
     if type_filters is None:
         raise ValueError("'type_filters' cannot be 'None'.")
 
-    type_filters = valdict_keys("type_filters")(type_filters)
+    type_filters = valdict_keys("type_filters")(cls, type_filters)
     return type_filters
 
 
 def validate_attribute_filters(
+    cls,
     attribute_filters: Optional[AttributeFiltersType],
 ) -> AttributeFiltersType:
     if attribute_filters is None:
         raise ValueError("'attribute_filters' cannot be 'None'.")
 
-    attribute_filters = valdict_keys("attribute_filters")(attribute_filters)
+    attribute_filters = valdict_keys("attribute_filters")(
+        cls, attribute_filters
+    )
     for key, values in attribute_filters.items():
         if values == []:
             raise ValueError(

fractal_server/app/schemas/_validators.py

@@ -11,7 +11,7 @@ def valstr(attribute: str, accept_none: bool = False):
     If `accept_none`, the validator also accepts `None`.
     """
 
-    def val(string: Optional[str]) -> Optional[str]:
+    def val(cls, string: Optional[str]) -> Optional[str]:
         if string is None:
             if accept_none:
                 return string
@@ -28,14 +28,16 @@ def valstr(attribute: str, accept_none: bool = False):
 
 
 def valdict_keys(attribute: str):
-    def val(d: Optional[dict[str, Any]]) -> Optional[dict[str, Any]]:
+    def val(cls, d: Optional[dict[str, Any]]) -> Optional[dict[str, Any]]:
         """
         Apply valstr to every key of the dictionary, and fail if there are
         identical keys.
         """
         if d is not None:
             old_keys = list(d.keys())
-            new_keys = [valstr(f"{attribute}[{key}]")(key) for key in old_keys]
+            new_keys = [
+                valstr(f"{attribute}[{key}]")(cls, key) for key in old_keys
+            ]
             if len(new_keys) != len(set(new_keys)):
                 raise ValueError(
                     f"Dictionary contains multiple identical keys: '{d}'."
@@ -53,7 +55,7 @@ def val_absolute_path(attribute: str, accept_none: bool = False):
     Check that a string attribute is an absolute path
     """
 
-    def val(string: Optional[str]) -> Optional[str]:
+    def val(cls, string: Optional[str]) -> Optional[str]:
         if string is None:
             if accept_none:
                 return string
@@ -75,7 +77,7 @@ def val_absolute_path(attribute: str, accept_none: bool = False):
 
 
 def val_unique_list(attribute: str):
-    def val(must_be_unique: Optional[list]) -> Optional[list]:
+    def val(cls, must_be_unique: Optional[list]) -> Optional[list]:
         if must_be_unique is not None:
             if len(set(must_be_unique)) != len(must_be_unique):
                 raise ValueError(f"`{attribute}` list has repetitions")

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)