desdeo 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

desdeo/api/config.py

@@ -1,10 +1,12 @@
 """Defines dataclasses to store configurations loaded from 'config.toml'."""
 
 import tomllib
+import os
+import json
 from pathlib import Path
-from typing import ClassVar
+from typing import List
 
-from pydantic import BaseModel
+from pydantic_settings import BaseSettings
 
 # Load the config data once
 config_path = Path(__file__).resolve().parent / "config.toml"
@@ -12,58 +14,77 @@ with config_path.open("rb") as fp:
     config_data = tomllib.load(fp)
 
 
-class SettingsConfig(BaseModel):
+class GeneralSettings(BaseSettings):
     """General settings."""
 
-    debug: ClassVar[bool] = config_data["settings"]["debug"]
+    debug: bool = config_data["settings"]["debug"]
 
 
-class ServerDebugConfig(BaseModel):
+SettingsConfig = GeneralSettings()
+
+
+class ServerDebugConfig(BaseSettings):
     """Server setup settings (development)."""
 
-    test_user_analyst_name: ClassVar[str] = config_data["server-debug"]["test_user_analyst_name"]
-    test_user_analyst_password: ClassVar[str] = config_data["server-debug"]["test_user_analyst_password"]
-    test_user_dm1_name: ClassVar[str] = config_data["server-debug"]["test_user_dm1_name"]
-    test_user_dm1_password: ClassVar[str] = config_data["server-debug"]["test_user_dm1_password"]
-    test_user_dm2_name: ClassVar[str] = config_data["server-debug"]["test_user_dm2_name"]
-    test_user_dm2_password: ClassVar[str] = config_data["server-debug"]["test_user_dm2_password"]
+    test_user_analyst_name: str = config_data["server-debug"]["test_user_analyst_name"]
+    test_user_analyst_password: str = config_data["server-debug"]["test_user_analyst_password"]
+    test_user_dm1_name: str = config_data["server-debug"]["test_user_dm1_name"]
+    test_user_dm1_password: str = config_data["server-debug"]["test_user_dm1_password"]
+    test_user_dm2_name: str = config_data["server-debug"]["test_user_dm2_name"]
+    test_user_dm2_password: str = config_data["server-debug"]["test_user_dm2_password"]
 
 
-class AuthDebugConfig(BaseModel):
-    """Authentication settings (development)."""
+class AuthDebugConfig(BaseSettings):
+    """Authentication settings (debug)."""
 
-    authjwt_secret_key: ClassVar[str] = config_data["auth-debug"]["authjwt_secret_key"]
-    authjwt_algorithm: ClassVar[str] = config_data["auth-debug"]["authjwt_algorithm"]
-    authjwt_access_token_expires: ClassVar[int] = config_data["auth-debug"]["authjwt_access_token_expires"]
-    authjwt_refresh_token_expires: ClassVar[int] = config_data["auth-debug"]["authjwt_refresh_token_expires"]
-    cors_origins: ClassVar[list[str]] = config_data["auth-debug"]["cors_origins"]
+    authjwt_secret_key: str = config_data["auth-debug"]["authjwt_secret_key"]
+    authjwt_algorithm: str = config_data["auth-debug"]["authjwt_algorithm"]
+    authjwt_access_token_expires: int = config_data["auth-debug"]["authjwt_access_token_expires"]
+    authjwt_refresh_token_expires: int = config_data["auth-debug"]["authjwt_refresh_token_expires"]
+    cors_origins: List[str] = config_data["auth-debug"]["cors_origins"]
+    cookie_domain: str = config_data["auth-debug"]["cookie_domain"]
 
 
-class DatabaseDebugConfig(BaseModel):
+class DatabaseDebugConfig(BaseSettings):
     """Database setting (development)."""
 
-    db_host: ClassVar[str] = config_data["database-debug"]["db_host"]
-    db_port: ClassVar[str] = config_data["database-debug"]["db_port"]
-    db_database: ClassVar[str] = config_data["database-debug"]["db_database"]
-    db_username: ClassVar[str] = config_data["database-debug"]["db_username"]
-    db_password: ClassVar[str] = config_data["database-debug"]["db_password"]
-    db_pool_size: ClassVar[int] = config_data["database-debug"]["db_pool_size"]
-    db_max_overflow: ClassVar[int] = config_data["database-debug"]["db_max_overflow"]
-    db_pool: ClassVar[bool] = config_data["database-debug"]["db_pool"]
-
-
-# class DatabaseDeployConfig(BaseModel):
-# # db_host: str = config_data["database-deploy"]["db_host"]
-# db_port: str = config_data["database-deploy"]["db_port"]
-# db_database: str = config_data["database-deploy"]["db_database"]
-# db_username: str = config_data["database-deploy"]["db_username"]
-# db_password: str = config_data["database-deploy"]["db_password"]
-# db_pool_size: int = config_data["database-deploy"]["db_pool_size"]
-# db_max_overflow: int = config_data["database-deploy"]["db_max_overflow"]
-# db_pool: bool = config_data["database-deploy"]["db_pool"]
-
-# class AuthDeployConfig(BaseModel):
-# authjwt_algorithm: str = config_data["auth-deploy"]["authjwt_algorithm"]
-# authjwt_access_token_expires: int = config_data["auth-deploy"]["authjwt_access_token_expires"]
-# authjwt_refresh_token_expires: int = config_data["auth-deploy"]["authjwt_refresh_token_expires"]
-# Note: authjwt_secret_key should be retrieved securely in production
+    db_host: str = config_data["database-debug"]["db_host"]
+    db_port: str = config_data["database-debug"]["db_port"]
+    db_database: str = config_data["database-debug"]["db_database"]
+    db_username: str = config_data["database-debug"]["db_username"]
+    db_password: str = config_data["database-debug"]["db_password"]
+    db_pool_size: int = config_data["database-debug"]["db_pool_size"]
+    db_max_overflow: int = config_data["database-debug"]["db_max_overflow"]
+    db_pool: bool = config_data["database-debug"]["db_pool"]
+
+
+class DatabaseDeployConfig(BaseSettings):
+    """Database setting (deployment)."""
+
+    db_host: str = os.getenv("DB_HOST")
+    db_port: str = os.getenv("DB_PORT")
+    db_database: str = os.getenv("DB_NAME")
+    db_username: str = os.getenv("DB_USER")
+    db_password: str = os.getenv("DB_PASSWORD")
+    db_pool_size: int = config_data["database-deploy"]["db_pool_size"]
+    db_max_overflow: int = config_data["database-deploy"]["db_max_overflow"]
+    db_pool: bool = config_data["database-deploy"]["db_pool"]
+    db_driver: str = os.getenv("DB_DRIVER", config_data["database-deploy"]["db_driver"])
+
+
+class AuthDeployConfig(BaseSettings):
+    """Authentication settings (deployment)."""
+
+    authjwt_secret_key: str = os.getenv("AUTHJWT_SECRET")
+    authjwt_algorithm: str = config_data["auth-deploy"]["authjwt_algorithm"]
+    authjwt_access_token_expires: int = config_data["auth-deploy"]["authjwt_access_token_expires"]
+    authjwt_refresh_token_expires: int = config_data["auth-deploy"]["authjwt_refresh_token_expires"]
+    cors_origins: List[str] = json.loads(os.getenv("CORS_ORIGINS", "[]"))
+    cookie_domain: str = os.getenv("COOKIE_DOMAIN", "")
+
+
+AuthConfig = AuthDebugConfig() if SettingsConfig.debug else AuthDeployConfig()
+
+DatabaseConfig = DatabaseDebugConfig() if SettingsConfig.debug else DatabaseDeployConfig()
+
+ServerConfig = ServerDebugConfig() if SettingsConfig.debug else None

desdeo/api/config.toml

@@ -1,4 +1,5 @@
 [settings]
+# This is ignored if $DESDEO_PRODUCTION env variable is present
 debug = true
 
 # development configs
@@ -18,16 +19,23 @@ authjwt_access_token_expires = 15 # in minutes
 authjwt_refresh_token_expires = 30 # in minutes
 cors_origins = [
     "http://localhost",
-    "http://localhost:8080",
+    "http://localhost:8000",
     "http://localhost:5173",
+    "http://127.0.0.1",
+    "http://127.0.0.1:8000",
+    "http://127.0.0.1:5173",
 ]
+cookie_domain = "" # Not needed for testing
 
 [auth-deploy]
-# TODO
 # secret key should be read from env DO NOT EXPOSE!!!!
+# authjwt_secret_key = $AUTHJWT_SECRET
 authjwt_algorithm = "HS256"
-authjwt_access_token_expires = 15  # in minutes
-authjwt_refresh_token_expires = 30 # in minutes
+authjwt_access_token_expires = 5  # in minutes
+authjwt_refresh_token_expires = 180 # in minutes
+# These are not that sensitive info but read from env regardless
+# cors_origins = $CORS_ORIGINS
+# cookie_domain = $COOKIE_DOMAIN
 
 # SQLite setup (enabled for local development)
 [database-debug]
@@ -39,15 +47,18 @@ db_password = ""
 db_pool_size = 1
 db_max_overflow = 0
 db_pool = false
+db_driver = "postgresql+asyncpg"
 
 # Database configuration (deployment)
 [database-deploy]
 # READ FROM ENV!!!
-# db_host = "localhost"
-# db_port = "5432"
-# db_database = "test"
-# db_username = "test"
-# db_password = "testpw"
-# db_pool_size = 20
-# db_max_overflow = 20
-# db_pool = true
+# db_host = $DB_HOST
+# db_port = $DB_PORT
+# db_database = $DB_NAME
+# db_username = $DB_USER
+# db_password = $DB_PASSWORD
+db_pool_size = 20
+db_max_overflow = 20
+db_pool = true
+# Can be overridden with $DB_DRIVER env variable
+db_driver = "postgresql+asyncpg"

desdeo/api/db.py

@@ -2,21 +2,23 @@
 
 from sqlmodel import Session, create_engine
 
-from desdeo.api.config import DatabaseDebugConfig, SettingsConfig
+from desdeo.api.config import DatabaseConfig, SettingsConfig
 
 if SettingsConfig.debug:
     # debug and development stuff
 
     # SQLite setup
-    engine = create_engine(DatabaseDebugConfig.db_database, connect_args={"check_same_thread": False})
+    engine = create_engine(DatabaseConfig.db_database, connect_args={"check_same_thread": False})
 
 else:
-    # deployment stuff
-
-    # Postgresql setup
-    # check from config.toml
-    # SQLALCHEMY_DATABASE_URL = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
-    pass
+    DB_USER = DatabaseConfig.db_username
+    DB_PASSWORD = DatabaseConfig.db_password
+    DB_HOST = DatabaseConfig.db_host
+    DB_PORT = DatabaseConfig.db_port
+    DB_NAME = DatabaseConfig.db_database
+
+    # Now the use of postgres is hardcoded for deployment, which may be fine
+    engine = create_engine(f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}")
 
 
 def get_session():

desdeo/api/db_init.py

@@ -5,11 +5,13 @@ import warnings
 from sqlalchemy_utils import database_exists
 from sqlmodel import Session, SQLModel
 
-from desdeo.api.config import ServerDebugConfig, SettingsConfig
+from desdeo.api.config import ServerConfig, SettingsConfig
 from desdeo.api.db import engine
 from desdeo.api.models import ProblemDB, User, UserRole
 from desdeo.api.routers.user_authentication import get_password_hash
-from desdeo.problem.testproblems import river_pollution_problem
+from desdeo.problem.testproblems import dtlz2, river_pollution_problem, simple_knapsack
+
+problems = [dtlz2(10, 3), simple_knapsack(), river_pollution_problem()]
 
 if __name__ == "__main__":
     if SettingsConfig.debug:
@@ -21,14 +23,15 @@ if __name__ == "__main__":
         else:
             warnings.warn("Database already exists. Clearing it.", stacklevel=1)
             # Drop all tables
+            SQLModel.metadata.reflect(bind=engine)
             SQLModel.metadata.drop_all(bind=engine)
             SQLModel.metadata.create_all(engine)
         print("Database tables created.")
 
         with Session(engine) as session:
             user_analyst = User(
-                username=ServerDebugConfig.test_user_analyst_name,
-                password_hash=get_password_hash(ServerDebugConfig.test_user_analyst_password),
+                username=ServerConfig.test_user_analyst_name,
+                password_hash=get_password_hash(ServerConfig.test_user_analyst_password),
                 role=UserRole.analyst,
                 group="test",
             )
@@ -36,13 +39,16 @@ if __name__ == "__main__":
             session.commit()
             session.refresh(user_analyst)
 
-            problem_db = ProblemDB.from_problem(river_pollution_problem(), user_analyst)
+            for problem in problems:
+                problem_db = ProblemDB.from_problem(problem, user_analyst)
+
+                session.add(problem_db)
 
-            session.add(problem_db)
             session.commit()
             session.refresh(problem_db)
 
         """
+
         db.add(user_analyst)
         db.commit()
         db.refresh(user_analyst)

desdeo/api/models/__init__.py

@@ -1,55 +1,241 @@
 """Model exports."""
 
-__all__ = [
-    "ArchiveEntryBase",
-    "ArchiveEntryDB",
+__all__ = [  # noqa: RUF022
     "Bounds",
     "ConstantDB",
     "ConstraintDB",
     "CreateSessionRequest",
     "DiscreteRepresentationDB",
+    "EMOSaveState",
+    "EMOSolveRequest",
+    "EMOIterateState",
+    "ENautilusRepresentativeSolutionsResponse",
+    "ENautilusState",
+    "ENautilusStateResponse",
+    "ENautilusStepRequest",
+    "ENautilusStepResponse",
     "ExtraFunctionDB",
+    "ForestProblemMetaData",
+    "GenericIntermediateSolutionResponse",
     "GetSessionRequest",
-    "User",
-    "UserBase",
-    "UserPublic",
-    "UserRole",
+    "GNIMBUSOptimizationState",
+    "GNIMBUSVotingState",
+    "GNIMBUSEndState",
+    "InteractiveSessionBase",
+    "InteractiveSessionDB",
+    "InteractiveSessionInfo",
+    "IntermediateSolutionRequest",
+    "IntermediateSolutionResponse",
+    "IntermediateSolutionState",
+    "NIMBUSClassificationRequest",
+    "NIMBUSClassificationState",
+    "NIMBUSDeleteSaveRequest",
+    "NIMBUSDeleteSaveResponse",
+    "NIMBUSInitializationRequest",
+    "NIMBUSInitializationState",
+    "NIMBUSIntermediateSolutionResponse",
+    "NIMBUSSaveRequest",
+    "NIMBUSClassificationResponse",
+    "NIMBUSInitializationResponse",
+    "NIMBUSSaveResponse",
+    "NIMBUSFinalizeRequest",
+    "NIMBUSFinalizeResponse",
+    "NIMBUSFinalState",
+    "NIMBUSSaveState",
+    "NonPreferredSolutions",
     "ObjectiveDB",
-    "ScalarizationFunctionDB",
-    "TensorConstantDB",
-    "SimulatorDB",
-    "TensorVariableDB",
     "PreferenceBase",
     "PreferenceDB",
-    "ProblemGetRequest",
+    "PreferredSolutions",
+    "PreferredRanges",
     "ProblemDB",
+    "ProblemAddFromJSONRequest",
+    "ProblemGetRequest",
     "ProblemInfo",
     "ProblemInfoSmall",
+    "ProblemMetaDataDB",
+    "ProblemMetaDataGetRequest",
+    "ProblemSelectSolverRequest",
     "ReferencePoint",
+    "RepresentativeNonDominatedSolutions",
     "RPMSolveRequest",
-    "VariableDB",
-    "InteractiveSessionBase",
-    "InteractiveSessionDB",
-    "InteractiveSessionInfo",
-    "RPMBaseState",
     "RPMState",
+    "SavedSolutionReference",
+    "ScalarizationFunctionDB",
+    "SimulatorDB",
+    "State",
     "StateDB",
+    "SolutionInfo",
+    "TensorConstantDB",
+    "TensorVariableDB",
+    "User",
+    "UserBase",
+    "UserPublic",
+    "UserRole",
+    "VariableDB",
+    "ProblemMetaDataDB",
+    "BaseProblemMetaData",
+    "ForestProblemMetaData",
+    "Group",
+    "GroupModifyRequest",
+    "GroupCreateRequest",
+    "GroupRevertRequest",
+    "GroupIteration",
+    "GroupPublic",
+    "GroupInfoRequest",
+    "BaseGroupInfoContainer",
+    "ReferencePointDictType",
+    "BooleanDictTypeDecorator",
+    "EMOSolveRequest",
+    "PreferredRanges",
+    "PreferedSolutions",
+    "NonPreferredSolutions",
+    "EMOFetchRequest",
+    "EMOFetchResponse",
+    "EMOIterateRequest",
+    "EMOIterateResponse",
+    "EMOSaveRequest",
+    "EMOScoreRequest",
+    "EMOScoreResponse",
+    "Solution",
+    "SolutionReference",
+    "SolutionReferenceLite",
+    "SolutionReferenceResponse",
+    "SolverSelectionMetadata",
+    "UserSavedEMOResults",
+    "UserSavedSolutionDB",
+    "UtopiaRequest",
+    "UtopiaResponse",
+    "VariableDB",
+    "ScoreBandsRequest",
+    "ScoreBandsResponse",
+    "OptimizationPreference",
+    "VotingPreference",
+    "EndProcessPreference",
+    "GNIMBUSResultResponse",
+    "FullIteration",
+    "GNIMBUSAllIterationsResponse",
+    "GNIMBUSSwitchPhaseRequest",
+    "GNIMBUSSwitchPhaseResponse",
+    "GDMScoreBandsInitializationRequest",
+    "GDMSCOREBandInformation",
+    "GDMSCOREBandsResponse",
+    "GDMScoreBandsVoteRequest",
+    "GDMSCOREBandFinalSelection",
+    "GDMSCOREBandsDecisionResponse",
+    "GDMSCOREBandsRevertRequest",
+    "GDMSCOREBandsHistoryResponse",
 ]
 
-from .archive import ArchiveEntryBase, ArchiveEntryDB
-from .preference import Bounds, PreferenceBase, PreferenceDB, ReferencePoint
+
+from .archive import UserSavedEMOResults
+from .emo import (
+    EMOFetchRequest,
+    EMOFetchResponse,
+    EMOIterateRequest,
+    EMOIterateResponse,
+    EMOSaveRequest,
+    EMOScoreRequest,
+    EMOScoreResponse,
+    Solution,
+)
+from .enautilus import (
+    ENautilusRepresentativeSolutionsResponse,
+    ENautilusStateResponse,
+    ENautilusStepRequest,
+    ENautilusStepResponse,
+)
+from .gdm.gdm_aggregate import (
+    Group,
+    GroupCreateRequest,
+    GroupInfoRequest,
+    GroupIteration,
+    GroupModifyRequest,
+    GroupPublic,
+    GroupRevertRequest,
+)
+from .gdm.gdm_base import (
+    BaseGroupInfoContainer,
+    BooleanDictTypeDecorator,
+    ReferencePointDictType,
+)
+from .gdm.gdm_score_bands import (
+    GDMSCOREBandFinalSelection,
+    GDMSCOREBandInformation,
+    GDMSCOREBandsDecisionResponse,
+    GDMSCOREBandsHistoryResponse,
+    GDMScoreBandsInitializationRequest,
+    GDMSCOREBandsResponse,
+    GDMSCOREBandsRevertRequest,
+    GDMScoreBandsVoteRequest,
+)
+from .gdm.gnimbus import (
+    EndProcessPreference,
+    FullIteration,
+    GNIMBUSAllIterationsResponse,
+    GNIMBUSResultResponse,
+    GNIMBUSSwitchPhaseRequest,
+    GNIMBUSSwitchPhaseResponse,
+    OptimizationPreference,
+    VotingPreference,
+)
+from .generic import (
+    GenericIntermediateSolutionResponse,
+    IntermediateSolutionRequest,
+    ScoreBandsRequest,
+    ScoreBandsResponse,
+    SolutionInfo,
+)
+from .generic_states import (
+    SavedSolutionReference,
+    SolutionReference,
+    SolutionReferenceLite,
+    SolutionReferenceResponse,
+    State,
+    StateDB,
+    UserSavedSolutionDB,
+)
+from .nimbus import (
+    NIMBUSClassificationRequest,
+    NIMBUSClassificationResponse,
+    NIMBUSDeleteSaveRequest,
+    NIMBUSDeleteSaveResponse,
+    NIMBUSFinalizeRequest,
+    NIMBUSFinalizeResponse,
+    NIMBUSInitializationRequest,
+    NIMBUSInitializationResponse,
+    NIMBUSIntermediateSolutionResponse,
+    NIMBUSSaveRequest,
+    NIMBUSSaveResponse,
+)
+from .preference import (
+    Bounds,
+    NonPreferredSolutions,
+    PreferenceBase,
+    PreferenceDB,
+    PreferredRanges,
+    PreferredSolutions,
+    ReferencePoint,
+)
 from .problem import (
     ConstantDB,
     ConstraintDB,
     DiscreteRepresentationDB,
     ExtraFunctionDB,
+    ForestProblemMetaData,
     ObjectiveDB,
+    ProblemAddFromJSONRequest,
     ProblemDB,
     ProblemGetRequest,
     ProblemInfo,
     ProblemInfoSmall,
+    ProblemMetaDataDB,
+    ProblemMetaDataGetRequest,
+    ProblemSelectSolverRequest,
+    RepresentativeNonDominatedSolutions,
     ScalarizationFunctionDB,
     SimulatorDB,
+    SolverSelectionMetadata,
     TensorConstantDB,
     TensorVariableDB,
     VariableDB,
@@ -62,5 +248,19 @@ from .session import (
     InteractiveSessionDB,
     InteractiveSessionInfo,
 )
-from .state import RPMBaseState, RPMState, StateDB
+from .state import (
+    EMOIterateState,
+    EMOSaveState,
+    ENautilusState,
+    GNIMBUSEndState,
+    GNIMBUSOptimizationState,
+    GNIMBUSVotingState,
+    IntermediateSolutionState,
+    NIMBUSClassificationState,
+    NIMBUSFinalState,
+    NIMBUSInitializationState,
+    NIMBUSSaveState,
+    RPMState,
+)
 from .user import User, UserBase, UserPublic, UserRole
+from .utopia import UtopiaRequest, UtopiaResponse

desdeo/api/models/archive.py

@@ -1,34 +1,23 @@
 """Defines models for archiving solutions."""
 
-from typing import TYPE_CHECKING
+from sqlmodel import Field
 
-from sqlmodel import JSON, Column, Field, Relationship, SQLModel
+from desdeo.tools.generics import EMOResult
 
-from .preference import PreferenceDB
 
-if TYPE_CHECKING:
-    from .problem import ProblemDB
-    from .user import User
+class UserSavedEMOResults(EMOResult):
+    """Defines a schema for storing emo solutions."""
 
+    name: str | None = Field(
+        description="An optional name for the solution, useful for archiving purposes.",
+        default=None,
+    )
 
-class ArchiveEntryBase(SQLModel):
-    """The base model of an archive entry."""
-
-    variable_values: dict[str, float | list] = Field(sa_column=Column(JSON, nullable=False))
-    objective_values: dict[str, float] = Field(sa_column=Column(JSON, nullable=False))
-    constraint_values: dict[str, float] | None = Field(sa_column=Column(JSON), default=None)
-    extra_func_values: dict[str, float] | None = Field(sa_column=Column(JSON), default=None)
-
-
-class ArchiveEntryDB(ArchiveEntryBase, table=True):
-    """Database model of an archive entry."""
-
-    id: int | None = Field(primary_key=True, default=None)
-    user_id: int | None = Field(foreign_key="user.id", default=None)
-    problem_id: int | None = Field(foreign_key="problemdb.id", default=None)
-    preference_id: int | None = Field(foreign_key="preferencedb.id", default=None)
-
-    # Back populates
-    user: "User" = Relationship(back_populates="archive")
-    preference: "PreferenceDB" = Relationship(back_populates="solutions")
-    problem: "ProblemDB" = Relationship(back_populates="solutions")
+    def to_emo_results(self) -> EMOResult:
+        """Convert to SolverResults without the name field."""
+        return EMOResult(
+            optimal_variables=self.optimal_variables,
+            optimal_objectives=self.optimal_objectives,
+            constraint_values=self.constraint_values,
+            extra_func_values=self.extra_func_values,
+        )