desdeo 1.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

desdeo/api/config.py

@@ -0,0 +1,90 @@
+"""Defines dataclasses to store configurations loaded from 'config.toml'."""
+
+import tomllib
+import os
+import json
+from pathlib import Path
+from typing import List
+
+from pydantic_settings import BaseSettings
+
+# Load the config data once
+config_path = Path(__file__).resolve().parent / "config.toml"
+with config_path.open("rb") as fp:
+    config_data = tomllib.load(fp)
+
+
+class GeneralSettings(BaseSettings):
+    """General settings."""
+
+    debug: bool = config_data["settings"]["debug"]
+
+
+SettingsConfig = GeneralSettings()
+
+
+class ServerDebugConfig(BaseSettings):
+    """Server setup settings (development)."""
+
+    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(BaseSettings):
+    """Authentication settings (debug)."""
+
+    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(BaseSettings):
+    """Database setting (development)."""
+
+    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

@@ -0,0 +1,64 @@
+[settings]
+# This is ignored if $DESDEO_PRODUCTION env variable is present
+debug = true
+
+# development configs
+[server-debug]
+test_user_analyst_name = "analyst"
+test_user_analyst_password = "analyst"
+test_user_dm1_name = "dm1"
+test_user_dm1_password = "dm1"
+test_user_dm2_name = "dm2"
+test_user_dm2_password = "dm2"
+
+# Auth configuration
+[auth-debug]
+authjwt_secret_key = "36b96a23d24cebdeadce6d98fa53356111e6f3e85b8144d7273dcba230b9eb18"
+authjwt_algorithm = "HS256"
+authjwt_access_token_expires = 15 # in minutes
+authjwt_refresh_token_expires = 30 # in minutes
+cors_origins = [
+    "http://localhost",
+    "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]
+# secret key should be read from env DO NOT EXPOSE!!!!
+# authjwt_secret_key = $AUTHJWT_SECRET
+authjwt_algorithm = "HS256"
+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]
+db_host = ""
+db_port = ""
+db_database = "sqlite:///./test.db"
+db_username = ""
+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 = $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

@@ -0,0 +1,27 @@
+"""Database configuration file for the API."""
+
+from sqlmodel import Session, create_engine
+
+from desdeo.api.config import DatabaseConfig, SettingsConfig
+
+if SettingsConfig.debug:
+    # debug and development stuff
+
+    # SQLite setup
+    engine = create_engine(DatabaseConfig.db_database, connect_args={"check_same_thread": False})
+
+else:
+    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():
+    """Yield the current database session."""
+    with Session(engine) as session:
+        yield session

desdeo/api/db_init.py

@@ -0,0 +1,85 @@
+"""This module initializes the database."""
+
+import warnings
+
+from sqlalchemy_utils import database_exists
+from sqlmodel import Session, SQLModel
+
+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 dtlz2, river_pollution_problem, simple_knapsack
+
+problems = [dtlz2(10, 3), simple_knapsack(), river_pollution_problem()]
+
+if __name__ == "__main__":
+    if SettingsConfig.debug:
+        # debug stuff
+
+        print("Creating database tables.")
+        if not database_exists(engine.url):
+            SQLModel.metadata.create_all(engine)
+        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=ServerConfig.test_user_analyst_name,
+                password_hash=get_password_hash(ServerConfig.test_user_analyst_password),
+                role=UserRole.analyst,
+                group="test",
+            )
+            session.add(user_analyst)
+            session.commit()
+            session.refresh(user_analyst)
+
+            for problem in problems:
+                problem_db = ProblemDB.from_problem(problem, user_analyst)
+
+                session.add(problem_db)
+
+            session.commit()
+            session.refresh(problem_db)
+
+        """
+
+        db.add(user_analyst)
+        db.commit()
+        db.refresh(user_analyst)
+
+        # add first test DM user
+        user_dm1 = db_models.User(
+            username=ServerDebugConfig.test_user_dm1_name,
+            password_hash=get_password_hash(ServerDebugConfig.test_user_dm1_password),
+            role=UserRole.DM,
+            privileges=[],
+            user_group="",
+        )
+        db.add(user_dm1)
+        db.commit()
+        db.refresh(user_dm1)
+
+        # add second test DM user
+        user_dm2 = db_models.User(
+            username=ServerDebugConfig.test_user_dm2_name,
+            password_hash=get_password_hash(ServerDebugConfig.test_user_dm2_password),
+            role=UserRole.DM,
+            privileges=[],
+            user_group="",
+        )
+        db.add(user_dm2)
+        db.commit()
+        db.refresh(user_dm2)
+
+        db.close()
+        """
+
+    else:
+        # deployment stuff
+        pass

desdeo/api/db_models.py

@@ -0,0 +1,164 @@
+"""All models for the API. I put them all in a single file for simplicity."""
+
+# TODO: ADD TIMESTAMP COLUMNS TO ALL TABLES
+
+from sqlalchemy import Enum, ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import ARRAY, FLOAT, JSON, JSONB
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from desdeo.api import schema
+from desdeo.api.db import Base
+
+
+class User(Base):
+    """A user with a password, stored problems, role, and user group."""
+
+    __tablename__ = "user"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    username: Mapped[str] = mapped_column(unique=True, nullable=False)
+    password_hash: Mapped[str] = mapped_column(nullable=False)
+    role: Mapped[schema.UserRole] = mapped_column(nullable=False)
+    user_group: Mapped[str] = mapped_column(nullable=True)
+    # privilages: Mapped[list[schema.UserPrivileges]] = mapped_column(ARRAY(Enum(schema.UserPrivileges)), nullable=False)
+    privileges: Mapped[list[schema.UserPrivileges]] = mapped_column(JSON, nullable=False)
+
+    def __repr__(self):
+        """Return a string representation of the user (username)."""
+        return f"User: ('{self.username}')"
+
+
+class Problem(Base):
+    """A model to store a problem and its associated data."""
+
+    __tablename__ = "problem"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    owner = mapped_column(Integer, ForeignKey("user.id"), nullable=True)  # Null if problem is public.
+    name: Mapped[str] = mapped_column(nullable=False)
+    # kind and obj_kind are also in value, but we need them as columns for querying. Maybe?
+    kind: Mapped[schema.ProblemKind] = mapped_column(nullable=False)
+    obj_kind: Mapped[schema.ObjectiveKind] = mapped_column(nullable=False)
+    # role_permission: Mapped[list[schema.UserRole]] = mapped_column(ARRAY(Enum(schema.UserRole)), nullable=True)
+    role_permission: Mapped[list[schema.UserRole]] = mapped_column(JSON, nullable=True)
+    # Mapped doesn't work with JSON, so we use JSON directly.
+    value = mapped_column(JSON, nullable=False)  # desdeo.problem.schema.Problem
+
+
+class UserProblemAccess(Base):
+    """A model to store user's access to problems."""
+
+    __tablename__ = "user_problem_access"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user_id = mapped_column(Integer, ForeignKey("user.id", ondelete="CASCADE"), nullable=False)
+    problem_access: Mapped[int] = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    problem = relationship("Problem", foreign_keys=[problem_access], lazy="selectin")
+
+
+class Method(Base):
+    """A model to store a method and its associated data."""
+
+    __tablename__ = "method"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    kind: Mapped[schema.Methods] = mapped_column(Enum(schema.Methods), nullable=False)
+    # properties: Mapped[list[schema.MethodProperties]] = mapped_column(
+    #    ARRAY(Enum(schema.MethodProperties)), nullable=False
+    # )
+    properties: Mapped[list[schema.MethodProperties]] = mapped_column(JSON, nullable=False)
+    name: Mapped[str] = mapped_column(nullable=False)
+    parameters = mapped_column(JSON, nullable=True)
+
+
+class Preference(Base):
+    """A model to store user preferences provided by the DM."""
+
+    __tablename__ = "preference"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user = mapped_column(Integer, ForeignKey("user.id"), nullable=False)
+    problem = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    previous_preference = mapped_column(Integer, ForeignKey("preference.id"), nullable=True)
+    method = mapped_column(Integer, ForeignKey("method.id"), nullable=False)
+    kind: Mapped[str]  # Depends on the method
+    value = mapped_column(JSON, nullable=False)
+
+
+class MethodState(Base):
+    """A model to store the state of a method. Contains all the information needed to restore the state of a method."""
+
+    __tablename__ = "method_state"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user = mapped_column(Integer, ForeignKey("user.id"), nullable=False)
+    problem = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    method = mapped_column(Integer, ForeignKey("method.id"), nullable=False)  # Honestly, this can just be a string.
+    preference = mapped_column(Integer, ForeignKey("preference.id"), nullable=True)
+    value = mapped_column(JSON, nullable=False)  # Depends on the method.
+
+
+class Results(Base):
+    """A model to store the results of a method run.
+
+    The results can be partial or complete, depending on the method. For example, NAUTILUS can return ranges instead of
+    solutions. The overlap between the Results and SolutionArchive tables is intentional. Though if you have a better
+    idea, feel free to change it.
+    """
+
+    __tablename__ = "results"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user = mapped_column(Integer, ForeignKey("user.id"), nullable=False)
+    problem = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    # TODO: The method is temporarily nullable for initial testing. It should be non-nullable.
+    method = mapped_column(Integer, ForeignKey("method.id"), nullable=True)
+    method_state = mapped_column(Integer, ForeignKey("method_state.id"), nullable=True)
+    value = mapped_column(JSON, nullable=False)  # Depends on the method
+
+
+class SolutionArchive(Base):
+    """A model to store a solution archive.
+
+    The archive can be used to store the results of a method run. Note that each entry must be a single,
+    complete solution. This is different from the Results table, which can store partial results.
+    """
+
+    __tablename__ = "solution_archive"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user = mapped_column(Integer, ForeignKey("user.id"), nullable=False)
+    problem = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    method = mapped_column(Integer, ForeignKey("method.id"), nullable=False)
+    preference = mapped_column(Integer, ForeignKey("preference.id"), nullable=True)
+    # decision_variables = mapped_column(ARRAY(FLOAT), nullable=True)
+    decision_variables = mapped_column(JSON, nullable=True)
+    # objectives = mapped_column(ARRAY(FLOAT), nullable=False)
+    objectives = mapped_column(JSON, nullable=False)
+    # constraints = mapped_column(ARRAY(FLOAT), nullable=True)
+    constraints = mapped_column(JSON, nullable=True)
+    # extra_funcs = mapped_column(ARRAY(FLOAT), nullable=True)
+    extra_funcs = mapped_column(JSON, nullable=True)
+    other_info = mapped_column(
+        JSON,
+        nullable=True,
+    )  # Depends on the method. May include things such as scalarization functions value, etc.
+    saved: Mapped[bool] = mapped_column(nullable=False)
+    current: Mapped[bool] = mapped_column(nullable=False)
+    chosen: Mapped[bool] = mapped_column(nullable=False)
+
+
+class Log(Base):
+    """A model to store logs of user actions. I have no idea what to put in this table."""
+
+    __tablename__ = "log"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    user = mapped_column(Integer, ForeignKey("user.id"), nullable=False)
+    action: Mapped[str] = mapped_column(nullable=False)
+    value = mapped_column(JSON, nullable=False)
+    timestamp: Mapped[str] = mapped_column(nullable=False)
+
+
+class Utopia(Base):
+    """A model to store user specific information relating to Utopia problems."""
+
+    __tablename__ = "utopia"
+    id: Mapped[int] = mapped_column(primary_key=True, unique=True)
+    problem: Mapped[int] = mapped_column(Integer, ForeignKey("problem.id"), nullable=False)
+    map_json: Mapped[str] = mapped_column(nullable=False)
+    schedule_dict = mapped_column(JSONB, nullable=False)
+    years: Mapped[list[str]] = mapped_column(ARRAY(String), nullable=False)
+    stand_id_field: Mapped[str] = mapped_column(String, nullable=False)
+    stand_descriptor = mapped_column(JSONB, nullable=True)

desdeo/api/malaga_db_init.py

@@ -0,0 +1,27 @@
+import json  # noqa: D100
+
+from desdeo.api.db_init import *  # noqa: F403
+from desdeo.utopia_stuff.utopia_problem import utopia_problem
+
+with open("C:/MyTemp/code/students_and_passwords.json") as file:  # noqa: PTH123
+    userdict = json.load(file)
+
+db = SessionLocal()
+
+holding_num = 1
+for name in userdict:
+    print(name)
+    user = db_models.User(
+        username=name,
+        password_hash=get_password_hash(userdict[name]),
+        role=UserRole.DM,
+        privilages=[],
+        user_group="",
+    )
+    db.add(user)
+
+db.commit()
+
+# Extra problem ends here
+
+db.close()