fractal-server 2.16.6__py3-none-any.whl → 2.17.0a0__py3-none-any.whl

fractal_server/app/schemas/v2/resource.py

@@ -0,0 +1,117 @@
+from enum import StrEnum
+from typing import Annotated
+from typing import Any
+from typing import Literal
+from typing import Self
+
+from pydantic import BaseModel
+from pydantic import Discriminator
+from pydantic import model_validator
+from pydantic import Tag
+from pydantic import validate_call
+from pydantic.types import AwareDatetime
+
+from fractal_server.runner.config import JobRunnerConfigLocal
+from fractal_server.runner.config import JobRunnerConfigSLURM
+from fractal_server.tasks.config import TasksPixiSettings
+from fractal_server.tasks.config import TasksPythonSettings
+from fractal_server.types import AbsolutePathStr
+from fractal_server.types import NonEmptyStr
+
+
+class ResourceType(StrEnum):
+    SLURM_SUDO = "slurm_sudo"
+    SLURM_SSH = "slurm_ssh"
+    LOCAL = "local"
+
+
+class _ValidResourceBase(BaseModel):
+    type: ResourceType
+    name: NonEmptyStr
+
+    # Tasks
+    tasks_python_config: TasksPythonSettings
+    tasks_pixi_config: dict[NonEmptyStr, Any]
+    tasks_local_dir: AbsolutePathStr
+
+    # Jobs
+    jobs_local_dir: AbsolutePathStr
+    jobs_runner_config: dict[NonEmptyStr, Any]
+    jobs_poll_interval: int = 5
+
+    @model_validator(mode="after")
+    def _tasks_configurations(self) -> Self:
+        if self.tasks_pixi_config != {}:
+            pixi_settings = TasksPixiSettings(**self.tasks_pixi_config)
+            if (
+                self.type == ResourceType.SLURM_SSH
+                and pixi_settings.SLURM_CONFIG is None
+            ):
+                raise ValueError(
+                    "`tasks_pixi_config` must include `SLURM_CONFIG`."
+                )
+        return self
+
+
+class ValidResourceLocal(_ValidResourceBase):
+    type: Literal[ResourceType.LOCAL]
+    jobs_runner_config: JobRunnerConfigLocal
+    jobs_slurm_python_worker: None = None
+    host: None = None
+
+
+class ValidResourceSlurmSudo(_ValidResourceBase):
+    type: Literal[ResourceType.SLURM_SUDO]
+    jobs_slurm_python_worker: AbsolutePathStr
+    jobs_runner_config: JobRunnerConfigSLURM
+    host: None = None
+
+
+class ValidResourceSlurmSSH(_ValidResourceBase):
+    type: Literal[ResourceType.SLURM_SSH]
+    host: NonEmptyStr
+    jobs_slurm_python_worker: AbsolutePathStr
+    jobs_runner_config: JobRunnerConfigSLURM
+
+
+def get_discriminator_value(v: Any) -> str:
+    # See https://github.com/fastapi/fastapi/discussions/12941
+    if isinstance(v, dict):
+        return v.get("type", None)
+    return getattr(v, "type", None)
+
+
+ResourceCreate = Annotated[
+    Annotated[ValidResourceLocal, Tag(ResourceType.LOCAL)]
+    | Annotated[ValidResourceSlurmSudo, Tag(ResourceType.SLURM_SUDO)]
+    | Annotated[ValidResourceSlurmSSH, Tag(ResourceType.SLURM_SSH)],
+    Discriminator(get_discriminator_value),
+]
+
+
+class ResourceRead(BaseModel):
+    id: int
+
+    type: str
+
+    name: str
+    timestamp_created: AwareDatetime
+
+    host: str | None
+
+    jobs_local_dir: str
+    jobs_runner_config: dict[str, Any]
+    jobs_slurm_python_worker: str | None
+    jobs_poll_interval: int
+
+    tasks_local_dir: str
+    tasks_python_config: dict[str, Any]
+    tasks_pixi_config: dict[str, Any]
+
+
+@validate_call
+def validate_resource_data(_data: ResourceCreate):
+    """
+    We use `@validate_call` because `ResourceCreate` is a `Union` type and it
+    cannot be instantiated directly.
+    """

fractal_server/app/security/__init__.py

@@ -58,7 +58,7 @@ from fractal_server.app.models import UserOAuth
 from fractal_server.app.models import UserSettings
 from fractal_server.app.schemas.user import UserCreate
 from fractal_server.app.security.signup_email import mail_new_oauth_signup
-from fractal_server.config import get_settings
+from fractal_server.config import get_email_settings
 from fractal_server.logger import set_logger
 from fractal_server.syringe import Inject
 
@@ -248,20 +248,17 @@ class UserManager(IntegerIDMixin, BaseUserManager[UserOAuth, int]):
             )
 
             # Send mail section
-            settings = Inject(get_settings)
+            email_settings = Inject(get_email_settings)
 
-            if (
-                this_user.oauth_accounts
-                and settings.email_settings is not None
-            ):
+            if this_user.oauth_accounts and email_settings.public is not None:
                 try:
                     logger.info(
                         "START sending email about new signup to "
-                        f"{settings.email_settings.recipients}."
+                        f"{email_settings.public.recipients}."
                     )
                     mail_new_oauth_signup(
                         msg=f"New user registered: '{this_user.email}'.",
-                        email_settings=settings.email_settings,
+                        email_settings=email_settings.public,
                     )
                     logger.info("END sending email about new signup.")
                 except Exception as e:
@@ -288,7 +285,6 @@ async def _create_first_user(
     password: str,
     is_superuser: bool = False,
     is_verified: bool = False,
-    username: str | None = None,
 ) -> None:
     """
     Private method to create the first fractal-server user
@@ -306,12 +302,11 @@ async def _create_first_user(
     See [fastapi_users docs](https://fastapi-users.github.io/fastapi-users/
     12.1/cookbook/create-user-programmatically)
 
-    Arguments:
+    Args:
         email: New user's email
         password: New user's password
         is_superuser: `True` if the new user is a superuser
         is_verified: `True` if the new user is verified
-        username:
     """
     function_logger = set_logger("fractal_server.create_first_user")
     function_logger.info(f"START _create_first_user, with email '{email}'")
@@ -339,8 +334,6 @@ async def _create_first_user(
                         is_superuser=is_superuser,
                         is_verified=is_verified,
                     )
-                    if username is not None:
-                        kwargs["username"] = username
                     user = await user_manager.create(UserCreate(**kwargs))
                     function_logger.info(f"User '{user.email}' created")
     except UserAlreadyExists:

fractal_server/app/security/signup_email.py

@@ -4,10 +4,10 @@ from email.utils import formataddr
 
 from cryptography.fernet import Fernet
 
-from fractal_server.config import MailSettings
+from fractal_server.config import PublicEmailSettings
 
 
-def mail_new_oauth_signup(msg: str, email_settings: MailSettings):
+def mail_new_oauth_signup(msg: str, email_settings: PublicEmailSettings):
     """
     Send an email using the specified settings to notify a new OAuth signup.
     """

fractal_server/app/user_settings.py

@@ -8,20 +8,12 @@ class SlurmSshUserSettings(BaseModel):
     execution when using the Slurm-SSH runner.
 
     Attributes:
-        ssh_host: SSH-reachable host where a SLURM client is available.
-        ssh_username: User on `ssh_host`.
-        ssh_private_key_path: Path of private SSH key for `ssh_username`.
-        ssh_tasks_dir: Task-venvs base folder on `ssh_host`.
-        ssh_jobs_dir: Jobs base folder on `ssh_host`.
+        project_dir: Folder where `slurm_user` can write.
         slurm_accounts:
             List of SLURM accounts, to be used upon Fractal job submission.
     """
 
-    ssh_host: str
-    ssh_username: str
-    ssh_private_key_path: str
-    ssh_tasks_dir: str
-    ssh_jobs_dir: str
+    project_dir: str
     slurm_accounts: list[str]
 
 
@@ -31,12 +23,10 @@ class SlurmSudoUserSettings(BaseModel):
     execution when using the Slurm-sudo runner.
 
     Attributes:
-        slurm_user: User to be impersonated via `sudo -u`.
         project_dir: Folder where `slurm_user` can write.
         slurm_accounts:
             List of SLURM accounts, to be used upon Fractal job submission.
     """
 
-    slurm_user: str
     project_dir: str
     slurm_accounts: list[str]

fractal_server/config/__init__.py

@@ -0,0 +1,23 @@
+from ._database import DatabaseSettings
+from ._email import EmailSettings
+from ._email import PublicEmailSettings  # noqa F401
+from ._init_data import InitDataSettings
+from ._main import Settings
+
+
+def get_db_settings(db_settings=DatabaseSettings()) -> DatabaseSettings:
+    return db_settings
+
+
+def get_settings(settings=Settings()) -> Settings:
+    return settings
+
+
+def get_email_settings(email_settings=EmailSettings()) -> EmailSettings:
+    return email_settings
+
+
+def get_init_data_settings(
+    init_data_settings=InitDataSettings(),
+) -> InitDataSettings:
+    return init_data_settings

fractal_server/config/_database.py

@@ -0,0 +1,58 @@
+from pydantic import SecretStr
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+from sqlalchemy.engine import URL
+
+from ._settings_config import SETTINGS_CONFIG_DICT
+from fractal_server.types import NonEmptyStr
+
+
+class DatabaseSettings(BaseSettings):
+    """
+    Minimal set of configurations needed for operating on the database (e.g
+    for schema migrations).
+    """
+
+    model_config = SettingsConfigDict(**SETTINGS_CONFIG_DICT)
+
+    DB_ECHO: bool = False
+    """
+    If `True`, make database operations verbose.
+    """
+    POSTGRES_USER: NonEmptyStr | None = None
+    """
+    User to use when connecting to the PostgreSQL database.
+    """
+    POSTGRES_PASSWORD: SecretStr | None = None
+    """
+    Password to use when connecting to the PostgreSQL database.
+    """
+    POSTGRES_HOST: NonEmptyStr | None = "localhost"
+    """
+    URL to the PostgreSQL server or path to a UNIX domain socket.
+    """
+    POSTGRES_PORT: NonEmptyStr | None = "5432"
+    """
+    Port number to use when connecting to the PostgreSQL server.
+    """
+    POSTGRES_DB: NonEmptyStr
+    """
+    Name of the PostgreSQL database to connect to.
+    """
+
+    @property
+    def DATABASE_URL(self) -> URL:
+        if self.POSTGRES_PASSWORD is None:
+            password = None
+        else:
+            password = self.POSTGRES_PASSWORD.get_secret_value()
+
+        url = URL.create(
+            drivername="postgresql+psycopg",
+            username=self.POSTGRES_USER,
+            password=password,
+            host=self.POSTGRES_HOST,
+            port=self.POSTGRES_PORT,
+            database=self.POSTGRES_DB,
+        )
+        return url

fractal_server/config/_email.py

@@ -0,0 +1,170 @@
+from typing import Literal
+
+from cryptography.fernet import Fernet
+from pydantic import BaseModel
+from pydantic import EmailStr
+from pydantic import Field
+from pydantic import model_validator
+from pydantic import SecretStr
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+from ._settings_config import SETTINGS_CONFIG_DICT
+
+
+class PublicEmailSettings(BaseModel):
+    """
+    Schema for `EmailSettings.public`, namely the ready-to-use settings.
+
+    Attributes:
+        sender: Sender email address
+        recipients: List of recipients email address
+        smtp_server: SMTP server address
+        port: SMTP server port
+        password: Sender password
+        instance_name: Name of SMTP server instance
+        use_starttls: Whether to use the security protocol
+        use_login: Whether to use login
+    """
+
+    sender: EmailStr
+    recipients: list[EmailStr] = Field(min_length=1)
+    smtp_server: str
+    port: int
+    encrypted_password: SecretStr | None = None
+    encryption_key: SecretStr | None = None
+    instance_name: str
+    use_starttls: bool
+    use_login: bool
+
+
+class EmailSettings(BaseSettings):
+    """
+    Class with settings for email-sending feature.
+    """
+
+    model_config = SettingsConfigDict(**SETTINGS_CONFIG_DICT)
+
+    FRACTAL_EMAIL_SENDER: EmailStr | None = None
+    """
+    Address of the OAuth-signup email sender.
+    """
+    FRACTAL_EMAIL_PASSWORD: SecretStr | None = None
+    """
+    Password for the OAuth-signup email sender.
+    """
+    FRACTAL_EMAIL_PASSWORD_KEY: SecretStr | None = None
+    """
+    Key value for `cryptography.fernet` decrypt
+    """
+    FRACTAL_EMAIL_SMTP_SERVER: str | None = None
+    """
+    SMTP server for the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_SMTP_PORT: int | None = None
+    """
+    SMTP server port for the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_INSTANCE_NAME: str | None = None
+    """
+    Fractal instance name, to be included in the OAuth-signup emails.
+    """
+    FRACTAL_EMAIL_RECIPIENTS: str | None = None
+    """
+    Comma-separated list of recipients of the OAuth-signup emails.
+    """
+    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: 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'.
+    """
+
+    public: PublicEmailSettings | None = None
+    """
+    The validated field which is actually used in `fractal-server
+    (automatically populated upon creation).
+    """
+
+    @model_validator(mode="after")
+    def validate_email_settings(self):
+        """
+        Set `self.public`.
+        """
+
+        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 use_login:
+                if self.FRACTAL_EMAIL_PASSWORD is None:
+                    raise ValueError(
+                        "'FRACTAL_EMAIL_USE_LOGIN' is 'true' but "
+                        "'FRACTAL_EMAIL_PASSWORD' is not provided."
+                    )
+                if self.FRACTAL_EMAIL_PASSWORD_KEY is None:
+                    raise ValueError(
+                        "'FRACTAL_EMAIL_USE_LOGIN' is 'true' but "
+                        "'FRACTAL_EMAIL_PASSWORD_KEY' is not provided."
+                    )
+                try:
+                    (
+                        Fernet(
+                            self.FRACTAL_EMAIL_PASSWORD_KEY.get_secret_value()
+                        )
+                        .decrypt(
+                            self.FRACTAL_EMAIL_PASSWORD.get_secret_value()
+                        )
+                        .decode("utf-8")
+                    )
+                except Exception as e:
+                    raise ValueError(
+                        "Invalid pair (FRACTAL_EMAIL_PASSWORD, "
+                        "FRACTAL_EMAIL_PASSWORD_KEY). "
+                        f"Original error: {str(e)}."
+                    )
+                password = self.FRACTAL_EMAIL_PASSWORD.get_secret_value()
+            else:
+                password = None
+
+            if self.FRACTAL_EMAIL_PASSWORD_KEY is not None:
+                key = self.FRACTAL_EMAIL_PASSWORD_KEY.get_secret_value()
+            else:
+                key = None
+
+            self.public = PublicEmailSettings(
+                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=password,
+                encryption_key=key,
+                instance_name=self.FRACTAL_EMAIL_INSTANCE_NAME,
+                use_starttls=use_starttls,
+                use_login=use_login,
+            )
+
+        return self

fractal_server/config/_init_data.py

@@ -0,0 +1,27 @@
+from pydantic import SecretStr
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+from ._settings_config import SETTINGS_CONFIG_DICT
+
+
+class InitDataSettings(BaseSettings):
+    model_config = SettingsConfigDict(**SETTINGS_CONFIG_DICT)
+
+    FRACTAL_DEFAULT_ADMIN_EMAIL: str = "admin@fractal.xy"
+    """
+    Admin default email, used upon creation of the first superuser during
+    server startup.
+
+    ⚠️  **IMPORTANT**: After the server startup, you should always edit the
+    default admin credentials.
+    """
+
+    FRACTAL_DEFAULT_ADMIN_PASSWORD: SecretStr = "1234"
+    """
+    Admin default password, used upon creation of the first superuser during
+    server startup.
+
+    ⚠️ **IMPORTANT**: After the server startup, you should always edit the
+    default admin credentials.
+    """