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

fractal_server/app/schemas/v2/workflowtask.py

@@ -4,10 +4,10 @@ from typing import Optional
 from typing import Union
 
 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_validator
+from pydantic import model_validator
 
 from .._filter_validators import validate_type_filters
 from .._validators import root_validate_dict_keys
@@ -39,34 +39,35 @@ class WorkflowTaskStatusTypeV2(str, Enum):
     FAILED = "failed"
 
 
-class WorkflowTaskCreateV2(BaseModel, extra=Extra.forbid):
+class WorkflowTaskCreateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
-    meta_non_parallel: Optional[dict[str, Any]]
-    meta_parallel: Optional[dict[str, Any]]
-    args_non_parallel: Optional[dict[str, Any]]
-    args_parallel: Optional[dict[str, Any]]
+    meta_non_parallel: Optional[dict[str, Any]] = None
+    meta_parallel: Optional[dict[str, Any]] = None
+    args_non_parallel: Optional[dict[str, Any]] = None
+    args_parallel: Optional[dict[str, Any]] = None
     type_filters: dict[str, bool] = Field(default_factory=dict)
 
     # 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)
     )
-
-    _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 = validator("meta_parallel", allow_reuse=True)(
-        valdict_keys("meta_parallel")
+    _meta_parallel = field_validator("meta_parallel")(
+        classmethod(valdict_keys("meta_parallel"))
     )
 
-    @validator("args_non_parallel")
+    @field_validator("args_non_parallel")
+    @classmethod
     def validate_args_non_parallel(cls, value):
         if value is None:
             return
-        valdict_keys("args_non_parallel")(value)
+        valdict_keys("args_non_parallel")(cls, value)
         args_keys = set(value.keys())
         intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
         if intersect_keys:
@@ -76,11 +77,12 @@ class WorkflowTaskCreateV2(BaseModel, extra=Extra.forbid):
             )
         return value
 
-    @validator("args_parallel")
+    @field_validator("args_parallel")
+    @classmethod
     def validate_args_parallel(cls, value):
         if value is None:
             return
-        valdict_keys("args_parallel")(value)
+        valdict_keys("args_parallel")(cls, value)
         args_keys = set(value.keys())
         intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
         if intersect_keys:
@@ -99,16 +101,15 @@ class WorkflowTaskReplaceV2(BaseModel):
 
 
 class WorkflowTaskReadV2(BaseModel):
-
     id: int
 
     workflow_id: int
-    order: Optional[int]
-    meta_non_parallel: Optional[dict[str, Any]]
-    meta_parallel: Optional[dict[str, Any]]
+    order: Optional[int] = None
+    meta_non_parallel: Optional[dict[str, Any]] = None
+    meta_parallel: Optional[dict[str, Any]] = None
 
-    args_non_parallel: Optional[dict[str, Any]]
-    args_parallel: Optional[dict[str, Any]]
+    args_non_parallel: Optional[dict[str, Any]] = None
+    args_parallel: Optional[dict[str, Any]] = None
 
     type_filters: dict[str, bool]
 
@@ -121,34 +122,35 @@ class WorkflowTaskReadV2WithWarning(WorkflowTaskReadV2):
     warning: Optional[str] = None
 
 
-class WorkflowTaskUpdateV2(BaseModel, extra=Extra.forbid):
+class WorkflowTaskUpdateV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
-    meta_non_parallel: Optional[dict[str, Any]]
-    meta_parallel: Optional[dict[str, Any]]
-    args_non_parallel: Optional[dict[str, Any]]
-    args_parallel: Optional[dict[str, Any]]
-    type_filters: Optional[dict[str, bool]]
+    meta_non_parallel: Optional[dict[str, Any]] = None
+    meta_parallel: Optional[dict[str, Any]] = None
+    args_non_parallel: Optional[dict[str, Any]] = None
+    args_parallel: Optional[dict[str, Any]] = None
+    type_filters: Optional[dict[str, bool]] = 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)
     )
-
-    _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 = validator("meta_parallel", allow_reuse=True)(
-        valdict_keys("meta_parallel")
+    _meta_parallel = field_validator("meta_parallel")(
+        classmethod(valdict_keys("meta_parallel"))
     )
 
-    @validator("args_non_parallel")
+    @field_validator("args_non_parallel")
+    @classmethod
     def validate_args_non_parallel(cls, value):
         if value is None:
             return
-        valdict_keys("args_non_parallel")(value)
+        valdict_keys("args_non_parallel")(cls, value)
         args_keys = set(value.keys())
         intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
         if intersect_keys:
@@ -158,11 +160,12 @@ class WorkflowTaskUpdateV2(BaseModel, extra=Extra.forbid):
             )
         return value
 
-    @validator("args_parallel")
+    @field_validator("args_parallel")
+    @classmethod
     def validate_args_parallel(cls, value):
         if value is None:
             return
-        valdict_keys("args_parallel")(value)
+        valdict_keys("args_parallel")(cls, value)
         args_keys = set(value.keys())
         intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
         if intersect_keys:
@@ -173,7 +176,8 @@ class WorkflowTaskUpdateV2(BaseModel, extra=Extra.forbid):
         return value
 
 
-class WorkflowTaskImportV2(BaseModel, extra=Extra.forbid):
+class WorkflowTaskImportV2(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
     meta_non_parallel: Optional[dict[str, Any]] = None
     meta_parallel: Optional[dict[str, Any]] = None
@@ -185,7 +189,8 @@ class WorkflowTaskImportV2(BaseModel, extra=Extra.forbid):
     task: Union[TaskImportV2, TaskImportV2Legacy]
 
     # Validators
-    @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)
@@ -197,7 +202,6 @@ class WorkflowTaskImportV2(BaseModel, extra=Extra.forbid):
                     "Cannot set filters both through the legacy field "
                     "('filters') and the new one ('type_filters')."
                 )
-
             else:
                 # As of 2.11.0, WorkflowTask do not have attribute filters
                 # any more.
@@ -213,26 +217,24 @@ class WorkflowTaskImportV2(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)
     )
-
-    _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 = validator("meta_parallel", allow_reuse=True)(
-        valdict_keys("meta_parallel")
+    _meta_parallel = field_validator("meta_parallel")(
+        classmethod(valdict_keys("meta_parallel"))
     )
-    _args_non_parallel = validator("args_non_parallel", allow_reuse=True)(
-        valdict_keys("args_non_parallel")
+    _args_non_parallel = field_validator("args_non_parallel")(
+        classmethod(valdict_keys("args_non_parallel"))
     )
-    _args_parallel = validator("args_parallel", allow_reuse=True)(
-        valdict_keys("args_parallel")
+    _args_parallel = field_validator("args_parallel")(
+        classmethod(valdict_keys("args_parallel"))
     )
 
 
 class WorkflowTaskExportV2(BaseModel):
-
     meta_non_parallel: Optional[dict[str, Any]] = None
     meta_parallel: Optional[dict[str, Any]] = None
     args_non_parallel: Optional[dict[str, Any]] = None

fractal_server/app/security/__init__.py

@@ -83,7 +83,7 @@ class SQLModelUserDatabaseAsync(Generic[UP, ID], BaseUserDatabase[UP, ID]):
 
     session: AsyncSession
     user_model: Type[UP]
-    oauth_account_model: Optional[Type[OAuthAccount]]
+    oauth_account_model: Optional[Type[OAuthAccount]] = None
 
     def __init__(
         self,

fractal_server/config.py

@@ -24,11 +24,12 @@ from typing import TypeVar
 from cryptography.fernet import Fernet
 from dotenv import load_dotenv
 from pydantic import BaseModel
-from pydantic import BaseSettings
 from pydantic import EmailStr
 from pydantic import Field
-from pydantic import root_validator
-from pydantic import validator
+from pydantic import field_validator
+from pydantic import model_validator
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
 from sqlalchemy.engine import URL
 
 import fractal_server
@@ -50,7 +51,7 @@ class MailSettings(BaseModel):
     """
 
     sender: EmailStr
-    recipients: list[EmailStr] = Field(min_items=1)
+    recipients: list[EmailStr] = Field(min_length=1)
     smtp_server: str
     port: int
     encrypted_password: Optional[str] = None
@@ -97,10 +98,11 @@ class OAuthClientConfig(BaseModel):
     CLIENT_NAME: str
     CLIENT_ID: str
     CLIENT_SECRET: str
-    OIDC_CONFIGURATION_ENDPOINT: Optional[str]
+    OIDC_CONFIGURATION_ENDPOINT: Optional[str] = None
     REDIRECT_URL: Optional[str] = None
 
-    @root_validator
+    @model_validator(mode="before")
+    @classmethod
     def check_configuration(cls, values):
         if values.get("CLIENT_NAME") not in ["GOOGLE", "GITHUB"]:
             if not values.get("OIDC_CONFIGURATION_ENDPOINT"):
@@ -118,8 +120,7 @@ class Settings(BaseSettings):
     The attributes of this class are set from the environment.
     """
 
-    class Config:
-        case_sensitive = True
+    model_config = SettingsConfigDict(case_sensitive=True)
 
     PROJECT_NAME: str = "Fractal Server"
     PROJECT_VERSION: str = fractal_server.__VERSION__
@@ -136,7 +137,7 @@ class Settings(BaseSettings):
     JWT token lifetime, in seconds.
     """
 
-    JWT_SECRET_KEY: Optional[str]
+    JWT_SECRET_KEY: Optional[str] = None
     """
     JWT secret
 
@@ -150,7 +151,8 @@ class Settings(BaseSettings):
     Cookie token lifetime, in seconds.
     """
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def collect_oauth_clients(cls, values):
         """
         Automatic collection of OAuth Clients
@@ -198,11 +200,11 @@ class Settings(BaseSettings):
     """
     If `True`, make database operations verbose.
     """
-    POSTGRES_USER: Optional[str]
+    POSTGRES_USER: Optional[str] = None
     """
     User to use when connecting to the PostgreSQL database.
     """
-    POSTGRES_PASSWORD: Optional[str]
+    POSTGRES_PASSWORD: Optional[str] = None
     """
     Password to use when connecting to the PostgreSQL database.
     """
@@ -214,7 +216,7 @@ class Settings(BaseSettings):
     """
     Port number to use when connecting to the PostgreSQL server.
     """
-    POSTGRES_DB: Optional[str]
+    POSTGRES_DB: Optional[str] = None
     """
     Name of the PostgreSQL database to connect to.
     """
@@ -266,13 +268,14 @@ class Settings(BaseSettings):
     default admin credentials.
     """
 
-    FRACTAL_TASKS_DIR: Optional[Path]
+    FRACTAL_TASKS_DIR: Optional[Path] = None
     """
     Directory under which all the tasks will be saved (either an absolute path
     or a path relative to current working directory).
     """
 
-    @validator("FRACTAL_TASKS_DIR", always=True)
+    @field_validator("FRACTAL_TASKS_DIR")
+    @classmethod
     def make_FRACTAL_TASKS_DIR_absolute(cls, v):
         """
         If `FRACTAL_TASKS_DIR` is a non-absolute path, make it absolute (based
@@ -289,7 +292,8 @@ class Settings(BaseSettings):
             )
         return FRACTAL_TASKS_DIR_path
 
-    @validator("FRACTAL_RUNNER_WORKING_BASE_DIR", always=True)
+    @field_validator("FRACTAL_RUNNER_WORKING_BASE_DIR")
+    @classmethod
     def make_FRACTAL_RUNNER_WORKING_BASE_DIR_absolute(cls, v):
         """
         (Copy of make_FRACTAL_TASKS_DIR_absolute)
@@ -312,7 +316,6 @@ class Settings(BaseSettings):
 
     FRACTAL_RUNNER_BACKEND: Literal[
         "local",
-        "local_experimental",
         "slurm",
         "slurm_ssh",
     ] = "local"
@@ -320,7 +323,7 @@ class Settings(BaseSettings):
     Select which runner backend to use.
     """
 
-    FRACTAL_RUNNER_WORKING_BASE_DIR: Optional[Path]
+    FRACTAL_RUNNER_WORKING_BASE_DIR: Optional[Path] = None
     """
     Base directory for running jobs / workflows. All artifacts required to set
     up, run and tear down jobs are placed in subdirs of this directory.
@@ -333,7 +336,7 @@ class Settings(BaseSettings):
     Only logs of with this level (or higher) will appear in the console logs.
     """
 
-    FRACTAL_LOCAL_CONFIG_FILE: Optional[Path]
+    FRACTAL_LOCAL_CONFIG_FILE: Optional[Path] = None
     """
     Path of JSON file with configuration for the local backend.
     """
@@ -349,7 +352,7 @@ class Settings(BaseSettings):
     Waiting time for the shutdown phase of executors
     """
 
-    FRACTAL_SLURM_CONFIG_FILE: Optional[Path]
+    FRACTAL_SLURM_CONFIG_FILE: Optional[Path] = None
     """
     Path of JSON file with configuration for the SLURM backend.
     """
@@ -360,7 +363,8 @@ class Settings(BaseSettings):
     nodes. If not specified, the same interpreter that runs the server is used.
     """
 
-    @validator("FRACTAL_SLURM_WORKER_PYTHON", always=True)
+    @field_validator("FRACTAL_SLURM_WORKER_PYTHON")
+    @classmethod
     def absolute_FRACTAL_SLURM_WORKER_PYTHON(cls, v):
         """
         If `FRACTAL_SLURM_WORKER_PYTHON` is a relative path, fail.
@@ -407,7 +411,8 @@ class Settings(BaseSettings):
     Same as `FRACTAL_TASKS_PYTHON_3_9`, for Python 3.12.
     """
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def check_tasks_python(cls, values):
         """
         Perform multiple checks of the Python-interpreter variables.
@@ -511,7 +516,8 @@ class Settings(BaseSettings):
     `--no-cache-dir` is used.
     """
 
-    @validator("FRACTAL_PIP_CACHE_DIR", always=True)
+    @field_validator("FRACTAL_PIP_CACHE_DIR")
+    @classmethod
     def absolute_FRACTAL_PIP_CACHE_DIR(cls, v):
         """
         If `FRACTAL_PIP_CACHE_DIR` is a relative path, fail.
@@ -605,73 +611,80 @@ class Settings(BaseSettings):
     """
     Comma-separated list of recipients of the OAuth-signup emails.
     """
-    FRACTAL_EMAIL_USE_STARTTLS: Optional[bool] = True
+    FRACTAL_EMAIL_USE_STARTTLS: Literal["true", "false"] = "true"
     """
     Whether to use StartTLS when using the SMTP server.
+    Accepted values: 'true', 'false'.
     """
-    FRACTAL_EMAIL_USE_LOGIN: Optional[bool] = True
+    FRACTAL_EMAIL_USE_LOGIN: Literal["true", "false"] = "true"
     """
     Whether to use login when using the SMTP server.
+    If 'true', FRACTAL_EMAIL_PASSWORD and FRACTAL_EMAIL_PASSWORD_KEY must be
+    provided.
+    Accepted values: 'true', 'false'.
     """
     email_settings: Optional[MailSettings] = None
 
-    @root_validator(pre=True)
-    def validate_email_settings(cls, values):
-        email_values = {
-            k: v for k, v in values.items() if k.startswith("FRACTAL_EMAIL")
-        }
-        if email_values:
-
-            def assert_key(key: str):
-                if key not in email_values:
-                    raise ValueError(f"Missing '{key}'")
-
-            assert_key("FRACTAL_EMAIL_SENDER")
-            assert_key("FRACTAL_EMAIL_SMTP_SERVER")
-            assert_key("FRACTAL_EMAIL_SMTP_PORT")
-            assert_key("FRACTAL_EMAIL_INSTANCE_NAME")
-            assert_key("FRACTAL_EMAIL_RECIPIENTS")
+    @model_validator(mode="after")
+    def validate_email_settings(self):
+        email_values = [
+            self.FRACTAL_EMAIL_SENDER,
+            self.FRACTAL_EMAIL_SMTP_SERVER,
+            self.FRACTAL_EMAIL_SMTP_PORT,
+            self.FRACTAL_EMAIL_INSTANCE_NAME,
+            self.FRACTAL_EMAIL_RECIPIENTS,
+        ]
+        if len(set(email_values)) == 1:
+            # All required EMAIL attributes are None
+            pass
+        elif None in email_values:
+            # Not all required EMAIL attributes are set
+            error_msg = (
+                "Invalid FRACTAL_EMAIL configuration. "
+                f"Given values: {email_values}."
+            )
+            raise ValueError(error_msg)
+        else:
+            use_starttls = self.FRACTAL_EMAIL_USE_STARTTLS == "true"
+            use_login = self.FRACTAL_EMAIL_USE_LOGIN == "true"
 
-            if email_values.get("FRACTAL_EMAIL_USE_LOGIN", True):
-                if "FRACTAL_EMAIL_PASSWORD" not in email_values:
+            if use_login:
+                if self.FRACTAL_EMAIL_PASSWORD is None:
                     raise ValueError(
-                        "'FRACTAL_EMAIL_USE_LOGIN' is True but "
+                        "'FRACTAL_EMAIL_USE_LOGIN' is 'true' but "
                         "'FRACTAL_EMAIL_PASSWORD' is not provided."
                     )
-                elif "FRACTAL_EMAIL_PASSWORD_KEY" not in email_values:
+                if self.FRACTAL_EMAIL_PASSWORD_KEY is None:
                     raise ValueError(
-                        "'FRACTAL_EMAIL_USE_LOGIN' is True but "
+                        "'FRACTAL_EMAIL_USE_LOGIN' is 'true' but "
                         "'FRACTAL_EMAIL_PASSWORD_KEY' is not provided."
                     )
-                else:
-                    try:
-                        (
-                            Fernet(email_values["FRACTAL_EMAIL_PASSWORD_KEY"])
-                            .decrypt(email_values["FRACTAL_EMAIL_PASSWORD"])
-                            .decode("utf-8")
-                        )
-                    except Exception as e:
-                        raise ValueError(
-                            "Invalid pair (FRACTAL_EMAIL_PASSWORD, "
-                            "FRACTAL_EMAIL_PASSWORD_KEY). "
-                            f"Original error: {str(e)}."
-                        )
+                try:
+                    (
+                        Fernet(self.FRACTAL_EMAIL_PASSWORD_KEY)
+                        .decrypt(self.FRACTAL_EMAIL_PASSWORD)
+                        .decode("utf-8")
+                    )
+                except Exception as e:
+                    raise ValueError(
+                        "Invalid pair (FRACTAL_EMAIL_PASSWORD, "
+                        "FRACTAL_EMAIL_PASSWORD_KEY). "
+                        f"Original error: {str(e)}."
+                    )
 
-            values["email_settings"] = MailSettings(
-                sender=email_values["FRACTAL_EMAIL_SENDER"],
-                recipients=email_values["FRACTAL_EMAIL_RECIPIENTS"].split(","),
-                smtp_server=email_values["FRACTAL_EMAIL_SMTP_SERVER"],
-                port=email_values["FRACTAL_EMAIL_SMTP_PORT"],
-                encrypted_password=email_values.get("FRACTAL_EMAIL_PASSWORD"),
-                encryption_key=email_values.get("FRACTAL_EMAIL_PASSWORD_KEY"),
-                instance_name=email_values["FRACTAL_EMAIL_INSTANCE_NAME"],
-                use_starttls=email_values.get(
-                    "FRACTAL_EMAIL_USE_STARTTLS", True
-                ),
-                use_login=email_values.get("FRACTAL_EMAIL_USE_LOGIN", True),
+            self.email_settings = MailSettings(
+                sender=self.FRACTAL_EMAIL_SENDER,
+                recipients=self.FRACTAL_EMAIL_RECIPIENTS.split(","),
+                smtp_server=self.FRACTAL_EMAIL_SMTP_SERVER,
+                port=self.FRACTAL_EMAIL_SMTP_PORT,
+                encrypted_password=self.FRACTAL_EMAIL_PASSWORD,
+                encryption_key=self.FRACTAL_EMAIL_PASSWORD_KEY,
+                instance_name=self.FRACTAL_EMAIL_INSTANCE_NAME,
+                use_starttls=use_starttls,
+                use_login=use_login,
             )
 
-        return values
+        return self
 
     ###########################################################################
     # BUSINESS LOGIC
@@ -794,7 +807,7 @@ class Settings(BaseSettings):
                 return False
 
         sanitized_settings = {}
-        for k, v in self.dict().items():
+        for k, v in self.model_dump().items():
             if _must_be_sanitized(k):
                 sanitized_settings[k] = "***"
             else:

fractal_server/images/models.py

@@ -4,7 +4,7 @@ from typing import Union
 
 from pydantic import BaseModel
 from pydantic import Field
-from pydantic import validator
+from pydantic import field_validator
 
 from fractal_server.app.schemas._validators import valdict_keys
 from fractal_server.urls import normalize_url
@@ -30,16 +30,18 @@ class _SingleImageBase(BaseModel):
     types: dict[str, bool] = Field(default_factory=dict)
 
     # Validators
-    _attributes = validator("attributes", allow_reuse=True)(
-        valdict_keys("attributes")
+    _attributes = field_validator("attributes")(
+        classmethod(valdict_keys("attributes"))
     )
-    _types = validator("types", allow_reuse=True)(valdict_keys("types"))
+    _types = field_validator("types")(classmethod(valdict_keys("types")))
 
-    @validator("zarr_url")
+    @field_validator("zarr_url")
+    @classmethod
     def normalize_zarr_url(cls, v: str) -> str:
         return normalize_url(v)
 
-    @validator("origin")
+    @field_validator("origin")
+    @classmethod
     def normalize_orig(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
             return normalize_url(v)
@@ -50,7 +52,8 @@ class SingleImageTaskOutput(_SingleImageBase):
     `SingleImageBase`, with scalar `attributes` values (`None` included).
     """
 
-    @validator("attributes")
+    @field_validator("attributes")
+    @classmethod
     def validate_attributes(
         cls, v: dict[str, Any]
     ) -> dict[str, Union[int, float, str, bool, None]]:
@@ -69,7 +72,8 @@ class SingleImage(_SingleImageBase):
     `SingleImageBase`, with scalar `attributes` values (`None` excluded).
     """
 
-    @validator("attributes")
+    @field_validator("attributes")
+    @classmethod
     def validate_attributes(
         cls, v: dict[str, Any]
     ) -> dict[str, Union[int, float, str, bool]]:
@@ -87,17 +91,19 @@ class SingleImageUpdate(BaseModel):
     attributes: Optional[dict[str, Any]] = None
     types: Optional[dict[str, bool]] = None
 
-    @validator("zarr_url")
+    @field_validator("zarr_url")
+    @classmethod
     def normalize_zarr_url(cls, v: str) -> str:
         return normalize_url(v)
 
-    @validator("attributes")
+    @field_validator("attributes")
+    @classmethod
     def validate_attributes(
         cls, v: dict[str, Any]
     ) -> dict[str, Union[int, float, str, bool]]:
         if v is not None:
             # validate keys
-            valdict_keys("attributes")(v)
+            valdict_keys("attributes")(cls, v)
             # validate values
             for key, value in v.items():
                 if not isinstance(value, (int, float, str, bool)):
@@ -108,4 +114,4 @@ class SingleImageUpdate(BaseModel):
                     )
         return v
 
-    _types = validator("types", allow_reuse=True)(valdict_keys("types"))
+    _types = field_validator("types")(classmethod(valdict_keys("types")))

fractal_server/main.py

@@ -67,7 +67,7 @@ def check_settings() -> None:
 
     logger = set_logger("fractal_server_settings")
     logger.debug("Fractal Settings:")
-    for key, value in settings.dict().items():
+    for key, value in settings.model_dump().items():
         if any(s in key.upper() for s in ["PASSWORD", "SECRET", "KEY"]):
             value = "*****"
         logger.debug(f"  {key}: {value}")