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

fractal_server/app/schemas/v2/task_group.py

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

fractal_server/app/schemas/v2/workflow.py

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

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,
@@ -252,15 +252,18 @@ class UserManager(IntegerIDMixin, BaseUserManager[UserOAuth, int]):
             # Send mail section
             settings = Inject(get_settings)
 
-            if this_user.oauth_accounts and settings.MAIL_SETTINGS is not None:
+            if (
+                this_user.oauth_accounts
+                and settings.email_settings is not None
+            ):
                 try:
                     logger.info(
                         "START sending email about new signup to "
-                        f"{settings.MAIL_SETTINGS.recipients}."
+                        f"{settings.email_settings.recipients}."
                     )
                     mail_new_oauth_signup(
                         msg=f"New user registered: '{this_user.email}'.",
-                        mail_settings=settings.MAIL_SETTINGS,
+                        email_settings=settings.email_settings,
                     )
                     logger.info("END sending email about new signup.")
                 except Exception as e:

fractal_server/app/security/signup_email.py

@@ -2,38 +2,47 @@ import smtplib
 from email.message import EmailMessage
 from email.utils import formataddr
 
+from cryptography.fernet import Fernet
+
 from fractal_server.config import MailSettings
 
 
-def mail_new_oauth_signup(msg: str, mail_settings: MailSettings):
+def mail_new_oauth_signup(msg: str, email_settings: MailSettings):
     """
     Send an email using the specified settings to notify a new OAuth signup.
     """
 
     mail_msg = EmailMessage()
     mail_msg.set_content(msg)
-    mail_msg["From"] = formataddr((mail_settings.sender, mail_settings.sender))
+    mail_msg["From"] = formataddr(
+        (email_settings.sender, email_settings.sender)
+    )
     mail_msg["To"] = ", ".join(
         [
             formataddr((recipient, recipient))
-            for recipient in mail_settings.recipients
+            for recipient in email_settings.recipients
         ]
     )
     mail_msg[
         "Subject"
-    ] = f"[Fractal, {mail_settings.instance_name}] New OAuth signup"
+    ] = f"[Fractal, {email_settings.instance_name}] New OAuth signup"
 
-    with smtplib.SMTP(mail_settings.smtp_server, mail_settings.port) as server:
+    with smtplib.SMTP(
+        email_settings.smtp_server, email_settings.port
+    ) as server:
         server.ehlo()
-        if mail_settings.use_starttls:
+        if email_settings.use_starttls:
             server.starttls()
             server.ehlo()
-
-        server.login(
-            user=mail_settings.sender, password=mail_settings.password
-        )
+        if email_settings.use_login:
+            password = (
+                Fernet(email_settings.encryption_key)
+                .decrypt(email_settings.encrypted_password)
+                .decode("utf-8")
+            )
+            server.login(user=email_settings.sender, password=password)
         server.sendmail(
-            from_addr=mail_settings.sender,
-            to_addrs=mail_settings.recipients,
+            from_addr=email_settings.sender,
+            to_addrs=email_settings.recipients,
             msg=mail_msg.as_string(),
         )