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

fractal_server/config.py

@@ -11,7 +11,6 @@
 # <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
 # Institute for Biomedical Research and Pelkmans Lab from the University of
 # Zurich.
-import json
 import logging
 import shutil
 import sys
@@ -25,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
@@ -46,16 +46,19 @@ class MailSettings(BaseModel):
         port: SMTP server port
         password: Sender password
         instance_name: Name of SMTP server instance
-        use_starttls: Using or not security protocol
+        use_starttls: Whether to use the security protocol
+        use_login: Whether to use login
     """
 
     sender: EmailStr
-    recipients: list[EmailStr] = Field(min_items=1)
+    recipients: list[EmailStr] = Field(min_length=1)
     smtp_server: str
     port: int
-    password: str
+    encrypted_password: Optional[str] = None
+    encryption_key: Optional[str] = None
     instance_name: str
     use_starttls: bool
+    use_login: bool
 
 
 class FractalConfigurationError(RuntimeError):
@@ -95,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"):
@@ -116,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__
@@ -134,7 +137,7 @@ class Settings(BaseSettings):
     JWT token lifetime, in seconds.
     """
 
-    JWT_SECRET_KEY: Optional[str]
+    JWT_SECRET_KEY: Optional[str] = None
     """
     JWT secret
 
@@ -148,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
@@ -196,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.
     """
@@ -212,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.
     """
@@ -264,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
@@ -287,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)
@@ -310,7 +316,6 @@ class Settings(BaseSettings):
 
     FRACTAL_RUNNER_BACKEND: Literal[
         "local",
-        "local_experimental",
         "slurm",
         "slurm_ssh",
     ] = "local"
@@ -318,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.
@@ -331,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.
     """
@@ -347,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.
     """
@@ -358,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.
@@ -405,8 +411,9 @@ class Settings(BaseSettings):
     Same as `FRACTAL_TASKS_PYTHON_3_9`, for Python 3.12.
     """
 
-    @root_validator(pre=True)
-    def check_tasks_python(cls, values) -> None:
+    @model_validator(mode="before")
+    @classmethod
+    def check_tasks_python(cls, values):
         """
         Perform multiple checks of the Python-interpreter variables.
 
@@ -416,7 +423,6 @@ class Settings(BaseSettings):
             `sys.executable` and set the corresponding
             `FRACTAL_TASKS_PYTHON_X_Y` (and unset all others).
         """
-
         # `FRACTAL_TASKS_PYTHON_X_Y` variables can only be absolute paths
         for version in ["3_9", "3_10", "3_11", "3_12"]:
             key = f"FRACTAL_TASKS_PYTHON_{version}"
@@ -510,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.
@@ -575,66 +582,108 @@ class Settings(BaseSettings):
     ###########################################################################
     # SMTP SERVICE
     ###########################################################################
-    FRACTAL_EMAIL_SETTINGS: Optional[str] = None
+
+    FRACTAL_EMAIL_SENDER: Optional[EmailStr] = None
+    """
+    Address of the OAuth-signup email sender.
+    """
+    FRACTAL_EMAIL_PASSWORD: Optional[str] = None
     """
-    Encrypted version of settings dictionary, with keys `sender`, `password`,
-    `smtp_server`, `port`, `instance_name`, `use_starttls`.
+    Password for the OAuth-signup email sender.
     """
-    FRACTAL_EMAIL_SETTINGS_KEY: Optional[str] = None
+    FRACTAL_EMAIL_PASSWORD_KEY: Optional[str] = None
     """
     Key value for `cryptography.fernet` decrypt
     """
+    FRACTAL_EMAIL_SMTP_SERVER: Optional[str] = None
+    """
+    SMPT server for the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_SMTP_PORT: Optional[int] = None
+    """
+    SMPT server port for the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_INSTANCE_NAME: Optional[str] = None
+    """
+    Fractal instance name, to be included in the OAuth-signup emails.
+    """
     FRACTAL_EMAIL_RECIPIENTS: Optional[str] = None
     """
-    List of email receivers, separated with commas
+    Comma-separated list of recipients of the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_USE_STARTTLS: Optional[bool] = True
+    """
+    Whether to use StartTLS when using the SMTP server.
     """
+    FRACTAL_EMAIL_USE_LOGIN: Optional[bool] = True
+    """
+    Whether to use login when using the SMTP server.
+    """
+    email_settings: Optional[MailSettings] = None
 
-    @property
-    def MAIL_SETTINGS(self) -> Optional[MailSettings]:
-        if (
-            self.FRACTAL_EMAIL_SETTINGS is not None
-            and self.FRACTAL_EMAIL_SETTINGS_KEY is not None
-            and self.FRACTAL_EMAIL_RECIPIENTS is not None
-        ):
-            smpt_settings = (
-                Fernet(self.FRACTAL_EMAIL_SETTINGS_KEY)
-                .decrypt(self.FRACTAL_EMAIL_SETTINGS)
-                .decode("utf-8")
-            )
-            recipients = self.FRACTAL_EMAIL_RECIPIENTS.split(",")
-            mail_settings = MailSettings(
-                **json.loads(smpt_settings), recipients=recipients
-            )
-            return mail_settings
-        elif not all(
-            [
-                self.FRACTAL_EMAIL_RECIPIENTS is None,
-                self.FRACTAL_EMAIL_SETTINGS_KEY is None,
-                self.FRACTAL_EMAIL_SETTINGS is None,
-            ]
-        ):
-            raise ValueError(
-                "You must set all SMPT config variables: "
-                f"{self.FRACTAL_EMAIL_SETTINGS=}, "
-                f"{self.FRACTAL_EMAIL_RECIPIENTS=}, "
-                f"{self.FRACTAL_EMAIL_SETTINGS_KEY=}, "
+    @model_validator(mode="before")
+    @classmethod
+    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")
+
+            if email_values.get("FRACTAL_EMAIL_USE_LOGIN", True):
+                if "FRACTAL_EMAIL_PASSWORD" not in email_values:
+                    raise ValueError(
+                        "'FRACTAL_EMAIL_USE_LOGIN' is True but "
+                        "'FRACTAL_EMAIL_PASSWORD' is not provided."
+                    )
+                elif "FRACTAL_EMAIL_PASSWORD_KEY" not in email_values:
+                    raise ValueError(
+                        "'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)}."
+                        )
+
+            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),
             )
 
+        return values
+
     ###########################################################################
     # BUSINESS LOGIC
     ###########################################################################
 
-    def check_fractal_mail_settings(self):
-        """
-        Checks that the mail settings are properly set.
-        """
-        try:
-            self.MAIL_SETTINGS
-        except Exception as e:
-            raise FractalConfigurationError(
-                f"Invalid email configuration settings. Original error: {e}"
-            )
-
     def check_db(self) -> None:
         """
         Checks that db environment variables are properly set.
@@ -740,7 +789,6 @@ class Settings(BaseSettings):
 
         self.check_db()
         self.check_runner()
-        self.check_fractal_mail_settings()
 
     def get_sanitized(self) -> dict:
         def _must_be_sanitized(string) -> bool:
@@ -753,7 +801,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

@@ -28,6 +28,7 @@ from .logger import get_logger
 from .logger import reset_logger_handlers
 from .logger import set_logger
 from .syringe import Inject
+from fractal_server import __VERSION__
 
 
 def collect_routers(app: FastAPI) -> None:
@@ -66,8 +67,8 @@ def check_settings() -> None:
 
     logger = set_logger("fractal_server_settings")
     logger.debug("Fractal Settings:")
-    for key, value in settings.dict().items():
-        if any(s in key.upper() for s in ["PASSWORD", "SECRET"]):
+    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}")
     reset_logger_handlers(logger)
@@ -77,7 +78,7 @@ def check_settings() -> None:
 async def lifespan(app: FastAPI):
     app.state.jobsV2 = []
     logger = set_logger("fractal_server.lifespan")
-    logger.info("Start application startup")
+    logger.info(f"[startup] START (fractal-server {__VERSION__})")
     check_settings()
     settings = Inject(get_settings)
 
@@ -88,31 +89,31 @@ async def lifespan(app: FastAPI):
         app.state.fractal_ssh_list = FractalSSHList()
 
         logger.info(
-            "Added empty FractalSSHList to app.state "
+            "[startup] Added empty FractalSSHList to app.state "
             f"(id={id(app.state.fractal_ssh_list)})."
         )
     else:
         app.state.fractal_ssh_list = None
 
     config_uvicorn_loggers()
-    logger.info("End application startup")
+    logger.info("[startup] END")
     reset_logger_handlers(logger)
 
     yield
 
     logger = get_logger("fractal_server.lifespan")
-    logger.info("Start application shutdown")
+    logger.info("[teardown] START")
 
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
         logger.info(
-            "Close FractalSSH connections "
+            "[teardown] Close FractalSSH connections "
             f"(current size: {app.state.fractal_ssh_list.size})."
         )
 
         app.state.fractal_ssh_list.close_all()
 
     logger.info(
-        f"Current worker with pid {os.getpid()} is shutting down. "
+        f"[teardown] Current worker with pid {os.getpid()} is shutting down. "
         f"Current jobs: {app.state.jobsV2=}"
     )
     if _backend_supports_shutdown(settings.FRACTAL_RUNNER_BACKEND):
@@ -128,9 +129,11 @@ async def lifespan(app: FastAPI):
                 f"Original error: {e}"
             )
     else:
-        logger.info("Shutdown not available for this backend runner.")
+        logger.info(
+            "[teardown] Shutdown not available for this backend runner."
+        )
 
-    logger.info("End application shutdown")
+    logger.info("[teardown] END")
     reset_logger_handlers(logger)
 
 

fractal_server/migrations/env.py

@@ -1,16 +1,11 @@
-import asyncio
 from logging.config import fileConfig
 
 from alembic import context
-from sqlalchemy.engine import Connection
 from sqlmodel import SQLModel
 
-from fractal_server.config import get_settings
 from fractal_server.migrations.naming_convention import NAMING_CONVENTION
-from fractal_server.syringe import Inject
 
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
+# Alembic Config object (provides access to the values within the .ini file)
 config = context.config
 
 
@@ -20,77 +15,35 @@ if config.config_file_name is not None:
     fileConfig(config.config_file_name)
 
 
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
 target_metadata = SQLModel.metadata
 target_metadata.naming_convention = NAMING_CONVENTION
-# Importing `fractal_server.app.models` after defining
+# Importing `fractal_server.app.models` *after* defining
 # `SQLModel.metadata.naming_convention` in order to apply the naming convention
 # when autogenerating migrations (see issue #1819).
 from fractal_server.app import models  # noqa
 
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
 
+def run_migrations_online() -> None:
     """
-    settings = Inject(get_settings)
-    settings.check_db()
-    context.configure(
-        url=settings.DATABASE_ASYNC_URL,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-        render_as_batch=True,
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def do_run_migrations(connection: Connection) -> None:
-    context.configure(
-        connection=connection,
-        target_metadata=target_metadata,
-        render_as_batch=True,
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-async def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
+    Run migrations in 'online' mode.
 
     In this scenario we need to create an Engine
     and associate a connection with the context.
-
     """
     from fractal_server.app.db import DB
 
-    engine = DB.engine_async()
-    async with engine.connect() as connection:
-        await connection.run_sync(do_run_migrations)
+    engine = DB.engine_sync()
+    with engine.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            render_as_batch=True,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
 
-    await engine.dispose()
+    engine.dispose()
 
 
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    asyncio.run(run_migrations_online())
+run_migrations_online()