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

desdeo/__init__.py

@@ -1,9 +1,9 @@
-__all__ = [
-    "desdeo_problem",
-    "desdeo_tools",
-    "desdeo_mcdm",
-]
+"""Configuration stuff of the DESDEO framework."""
 
-import desdeo_mcdm
-import desdeo_problem
-import desdeo_tools
+from desdeo.core import _check_executables
+
+# List of required executables
+required_executables = ["bonmin", "cbc", "ipopt"]
+
+# Check for executables when the library is imported
+_check_executables(required_executables)

desdeo/api/README.md

@@ -0,0 +1,73 @@
+# DESDEO web API
+Experimental. The instructions below assume that the current working directory
+is `desdeo/api` and that the DESDEO framework has been installed successfully
+with the extra dependencies in the `api` group.
+
+## API configuration
+
+The API configuration is handled by the settings found in `config.toml`. This
+file should be used for reading existing configuration parameters and adding
+new ones. Except for deployment (TODO).
+
+## Initializing the database
+
+To initialize the database, run the script `db_init.py` with the following command:
+
+```shell
+python db_init.py
+```
+
+This will create an initial databse, which allows testing for, e.g., testing
+the databse. However, the tests themselves (see below), do not depend on this
+database, and handle the database for running the tests on their own.
+
+Importantly, this will create an analyst user, which can be used to test out
+the end-points using the FastAPI generated documentation (see below). The
+default name of the analyst user will be 'analyst' with the password 'analyst'.
+
+This is mainly for testing purposes, which will create and manage a local
+dblite-databse.
+
+## Running the API
+
+To run the API, invoke `uvicorn` as followsi:
+
+```shell
+uvicorn --app-dir=./ app:app --reload
+```
+See the outputs of the command to figure out where the API is running. This is
+likely something along the lines `http:127.0.0.1:8000`, but may vary.
+
+## Exploring the API
+
+Once the API is running, its endpoints can be interactively explored by accessing
+`<api_url>/docs`. For example, `http:127.0.0:8000/docs`. The `analyst` user created by
+invoking `init_db.py` can be used to authorize and access the protected endpoints.
+
+## Running (unit) tests
+
+Pytest can be used to run tests relate to the API with the following command:
+
+```shell
+pytest
+```
+Again, it is assumed for the current working directory to be `desdeo/api`.
+Otherwise a lot of tests will be executed.
+
+## How the API works
+
+The API consists of two important concepts: __models__ and __routers__. At the
+core of the API, is a database.
+
+Models utilize SQLite to define databse models. In other words, it describes
+stuff we want to store in the databse. These models are very similar to
+pydantic models, and are almost interchangeable. One major difference is that
+the models are relational. This means that models often relate to each other.
+E.g., an `ArchiveEntryDB` is the child of the model `User`.
+
+Routers define HTTP endpoints to access and database and the models within.
+These endpoints often modify the contents of the database, e.g., by solving a
+problem with an interactive method, and then saving the solutions back to the
+database. Endpoints often make use of code found in the core-logic (the
+algorithms containing part of DESDEO), and are, in fact, a way to utilize this
+code through the web (which is the whole point of this API!).

desdeo/api/__init__.py

@@ -0,0 +1,15 @@
+"""Exports for desdeo.api."""
+
+__all__ = [
+    "AuthDebugConfig",
+    "DatabaseDebugConfig",
+    "ServerDebugConfig",
+    "SettingsConfig",
+]
+
+from .config import (
+    AuthDebugConfig,
+    DatabaseDebugConfig,
+    ServerDebugConfig,
+    SettingsConfig,
+)

desdeo/api/app.py

@@ -0,0 +1,40 @@
+"""The main FastAPI application for the DESDEO API."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from desdeo.api.config import AuthDebugConfig, SettingsConfig
+from desdeo.api.routers import (
+    problem,
+    reference_point_method,
+    session,
+    user_authentication,
+)
+
+if SettingsConfig.debug:
+    # debug and development stuff
+
+    app = FastAPI(
+        title="DESDEO (fast)API",
+        version="0.1.0",
+        description="A rest API for the DESDEO framework.",
+    )
+
+    app.include_router(user_authentication.router)
+    app.include_router(problem.router)
+    app.include_router(session.router)
+    app.include_router(reference_point_method.router)
+
+    origins = AuthDebugConfig.cors_origins
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+else:
+    # deployment stuff
+    pass

desdeo/api/config.py

@@ -0,0 +1,69 @@
+"""Defines dataclasses to store configurations loaded from 'config.toml'."""
+
+import tomllib
+from pathlib import Path
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+# 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 SettingsConfig(BaseModel):
+    """General settings."""
+
+    debug: ClassVar[bool] = config_data["settings"]["debug"]
+
+
+class ServerDebugConfig(BaseModel):
+    """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"]
+
+
+class AuthDebugConfig(BaseModel):
+    """Authentication settings (development)."""
+
+    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"]
+
+
+class DatabaseDebugConfig(BaseModel):
+    """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

desdeo/api/config.toml

@@ -0,0 +1,53 @@
+[settings]
+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:8080",
+    "http://localhost:5173",
+]
+
+[auth-deploy]
+# TODO
+# secret key should be read from env DO NOT EXPOSE!!!!
+authjwt_algorithm = "HS256"
+authjwt_access_token_expires = 15  # in minutes
+authjwt_refresh_token_expires = 30 # in minutes
+
+# 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
+
+# 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

desdeo/api/db.py

@@ -0,0 +1,25 @@
+"""Database configuration file for the API."""
+
+from sqlmodel import Session, create_engine
+
+from desdeo.api.config import DatabaseDebugConfig, SettingsConfig
+
+if SettingsConfig.debug:
+    # debug and development stuff
+
+    # SQLite setup
+    engine = create_engine(DatabaseDebugConfig.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
+
+
+def get_session():
+    """Yield the current database session."""
+    with Session(engine) as session:
+        yield session

desdeo/api/db_init.py

@@ -0,0 +1,79 @@
+"""This module initializes the database."""
+
+import warnings
+
+from sqlalchemy_utils import database_exists
+from sqlmodel import Session, SQLModel
+
+from desdeo.api.config import ServerDebugConfig, 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
+
+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.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),
+                role=UserRole.analyst,
+                group="test",
+            )
+            session.add(user_analyst)
+            session.commit()
+            session.refresh(user_analyst)
+
+            problem_db = ProblemDB.from_problem(river_pollution_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()

desdeo/api/models/__init__.py

@@ -0,0 +1,66 @@
+"""Model exports."""
+
+__all__ = [
+    "ArchiveEntryBase",
+    "ArchiveEntryDB",
+    "Bounds",
+    "ConstantDB",
+    "ConstraintDB",
+    "CreateSessionRequest",
+    "DiscreteRepresentationDB",
+    "ExtraFunctionDB",
+    "GetSessionRequest",
+    "User",
+    "UserBase",
+    "UserPublic",
+    "UserRole",
+    "ObjectiveDB",
+    "ScalarizationFunctionDB",
+    "TensorConstantDB",
+    "SimulatorDB",
+    "TensorVariableDB",
+    "PreferenceBase",
+    "PreferenceDB",
+    "ProblemGetRequest",
+    "ProblemDB",
+    "ProblemInfo",
+    "ProblemInfoSmall",
+    "ReferencePoint",
+    "RPMSolveRequest",
+    "VariableDB",
+    "InteractiveSessionBase",
+    "InteractiveSessionDB",
+    "InteractiveSessionInfo",
+    "RPMBaseState",
+    "RPMState",
+    "StateDB",
+]
+
+from .archive import ArchiveEntryBase, ArchiveEntryDB
+from .preference import Bounds, PreferenceBase, PreferenceDB, ReferencePoint
+from .problem import (
+    ConstantDB,
+    ConstraintDB,
+    DiscreteRepresentationDB,
+    ExtraFunctionDB,
+    ObjectiveDB,
+    ProblemDB,
+    ProblemGetRequest,
+    ProblemInfo,
+    ProblemInfoSmall,
+    ScalarizationFunctionDB,
+    SimulatorDB,
+    TensorConstantDB,
+    TensorVariableDB,
+    VariableDB,
+)
+from .reference_point_method import RPMSolveRequest
+from .session import (
+    CreateSessionRequest,
+    GetSessionRequest,
+    InteractiveSessionBase,
+    InteractiveSessionDB,
+    InteractiveSessionInfo,
+)
+from .state import RPMBaseState, RPMState, StateDB
+from .user import User, UserBase, UserPublic, UserRole

desdeo/api/models/archive.py

@@ -0,0 +1,34 @@
+"""Defines models for archiving solutions."""
+
+from typing import TYPE_CHECKING
+
+from sqlmodel import JSON, Column, Field, Relationship, SQLModel
+
+from .preference import PreferenceDB
+
+if TYPE_CHECKING:
+    from .problem import ProblemDB
+    from .user import User
+
+
+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")