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

desdeo/api/tests/test_routes.py

@@ -0,0 +1,216 @@
+"""Tests related to routes and routers."""
+
+from fastapi import status
+from fastapi.testclient import TestClient
+
+from desdeo.api.models import (
+    CreateSessionRequest,
+    GetSessionRequest,
+    InteractiveSessionDB,
+    ProblemGetRequest,
+    ProblemInfo,
+    ReferencePoint,
+    RPMSolveRequest,
+    User,
+)
+from desdeo.api.routers.user_authentication import create_access_token
+from desdeo.problem.testproblems import simple_knapsack_vectors
+
+
+def login(client: TestClient, username="analyst", password="analyst") -> str:  # noqa: S107
+    """Login, returns the access token."""
+    response_login = client.post(
+        "/login",
+        data={"username": username, "password": password, "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    ).json()
+
+    return response_login["access_token"]
+
+
+def post_json(client: TestClient, endpoint: str, json: dict, access_token: str):
+    """Makes a post request and returns the response."""
+    return client.post(
+        endpoint,
+        json=json,
+        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
+    )
+
+
+def get_json(client: TestClient, endpoint: str, access_token: str):
+    """Makes a get request and returns the response."""
+    return client.get(
+        endpoint,
+        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
+    )
+
+
+def test_user_login(client: TestClient):
+    """Test that login works."""
+    response = client.post(
+        "/login",
+        data={"username": "analyst", "password": "analyst", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+
+    assert response.status_code == 200
+    assert "access_token" in response.json()
+
+    # wrong login
+    response = client.post(
+        "/login",
+        data={"username": "analyst", "password": "anallyst", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+
+    assert response.status_code == 401
+
+
+def test_tokens():
+    """Test token generation."""
+    token_1 = create_access_token({"id": 1, "sub": "analyst"})
+    token_2 = create_access_token({"id": 1, "sub": "analyst"})
+
+    assert token_1 != token_2
+
+
+def test_refresh(client: TestClient):
+    """Test that refreshing the access token works."""
+    # check that no previous cookies exist
+    assert len(client.cookies) == 0
+
+    # no cookie
+    response_bad = client.post("/refresh")
+
+    response_good = client.post(
+        "/login",
+        data={"username": "analyst", "password": "analyst", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+
+    assert response_bad.status_code == 401
+    assert response_good.status_code == 200
+
+    assert "access_token" in response_good.json()
+    assert len(client.cookies) == 1
+    assert "refresh_token" in client.cookies
+
+    response_refresh = client.post("/refresh")
+
+    assert "access_token" in response_refresh.json()
+
+    assert response_good.json()["access_token"] != response_refresh.json()["access_token"]
+
+
+def test_get_problem(client: TestClient):
+    """Test fetching specific problems based on their id."""
+    access_token = login(client)
+
+    response = post_json(client, "/problem/get", ProblemGetRequest(problem_id=1).model_dump(), access_token)
+
+    assert response.status_code == 200
+
+    info = ProblemInfo.model_validate(response.json())
+
+    assert info.id == 1
+    assert info.name == "dtlz2"
+
+    response = post_json(client, "problem/get", ProblemGetRequest(problem_id=2).model_dump(), access_token)
+
+    assert response.status_code == 200
+
+    info = ProblemInfo.model_validate(response.json())
+
+    assert info.id == 2
+    assert info.name == "The river pollution problem"
+
+
+def test_add_problem(client: TestClient):
+    """Test that adding a problem to the database works."""
+    access_token = login(client)
+
+    problem = simple_knapsack_vectors()
+
+    response = post_json(client, "/problem/add", problem.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+
+    problem_info: ProblemInfo = ProblemInfo.model_validate(response.json())
+
+    assert problem_info.name == "Simple two-objective Knapsack problem"
+
+    response = get_json(client, "problem/all_info", access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+
+    problems = response.json()
+
+    assert len(problems) == 3
+
+
+def test_new_session(client: TestClient, session_and_user: dict):
+    """Test that creating a new session works as expected."""
+    user: User = session_and_user["user"]
+    session = session_and_user["session"]
+
+    assert user.active_session_id is None
+
+    access_token = login(client)
+
+    request = CreateSessionRequest(info="My session")
+
+    response = post_json(client, "/session/new", request.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+
+    assert user.active_session_id == 1
+    isession = session.get(InteractiveSessionDB, 1)
+
+    assert isession.info == "My session"
+
+
+def test_get_session(client: TestClient, session_and_user: dict):
+    """Test that getting a session works as intended."""
+    user: User = session_and_user["user"]
+
+    access_token = login(client)
+
+    # no sessions
+    request = GetSessionRequest(session_id=1)
+    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+    # add some sessions
+    request = CreateSessionRequest(info="My session")
+    response = post_json(client, "/session/new", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+
+    assert user.active_session_id == 1
+
+    request = CreateSessionRequest(info="My session")
+    response = post_json(client, "/session/new", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+
+    assert user.active_session_id == 2
+
+    # sessions with id 1 and 2 should exist
+    request = GetSessionRequest(session_id=1)
+    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+
+    request = GetSessionRequest(session_id=2)
+    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+
+
+def test_rpm_solve(client: TestClient):
+    """Test that using the reference point method works as expected."""
+    access_token = login(client)
+
+    request = RPMSolveRequest(
+        problem_id=1, preference=ReferencePoint(aspiration_levels={"f_1": 0.5, "f_2": 0.3, "f_3": 0.4})
+    )
+
+    response = post_json(client, "/method/rpm/solve", request.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK

desdeo/api/utils/database.py

@@ -0,0 +1,274 @@
+"""Database utils for the API."""
+
+from os import getenv
+from typing import TypeVar
+
+from sqlalchemy.engine import URL, Result
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncScalarResult,
+    AsyncSession,
+    create_async_engine,
+)
+from sqlalchemy.future import select as sa_select
+from sqlalchemy.orm import DeclarativeMeta, declarative_base, sessionmaker
+from sqlalchemy.pool import NullPool
+from sqlalchemy.sql import Executable
+from sqlalchemy.sql.expression import Delete
+from sqlalchemy.sql.expression import delete as sa_delete
+from sqlalchemy.sql.expression import exists as sa_exists
+from sqlalchemy.sql.functions import count
+from sqlalchemy.sql.selectable import Exists, Select
+
+from desdeo.api.config import SettingsConfig
+
+from .logger import get_logger
+
+if SettingsConfig.debug:
+    from desdeo.api.config import DatabaseDebugConfig
+
+    DBConfig = DatabaseDebugConfig
+else:
+    # set development setting, e.g., DBConfig = DatabaseDeployConfig
+    pass
+
+T = TypeVar("T")
+
+
+def select(entity) -> Select:
+    """Shortcut for :meth:`sqlalchemy.future.select`.
+
+    Args:
+        entity (sqlalchemy.sql.expression.FromClause): Entities / DB model to SELECT from.
+
+    Returns:
+        Select: A Select class object
+    """
+    return sa_select(entity)
+
+
+def filter_by(cls, *args, **kwargs) -> Select:
+    """Shortcut for :meth:`sqlalchemy.future.Select.filter_by`.
+
+    Args:
+        cls (sqlalchemy.sql.expression.FromClause): Entities / DB model to SELECT from.
+        *args (tuple): Positional arguments.
+        **kwargs (dict): Keyword arguments.
+
+    Returns:
+        Select: A Select class object with a WHERE clause
+    """
+    return select(cls, *args).filter_by(**kwargs)
+
+
+def exists(*entities, **kwargs) -> Exists:
+    """Shortcut for :meth:`sqlalchemy.sql.expression.exists`.
+
+    Args:
+        *entities (tuple): Positional arguments.
+        **kwargs (dict): Keyword arguments.
+
+    Returns:
+        Exists: A new Exists construct
+    """
+    return sa_exists(*entities, **kwargs)
+
+
+def delete(table) -> Delete:
+    """Shortcut for :meth:`sqlalchemy.sql.expression.delete`.
+
+    Args:
+        table (sqlalchemy.sql.expression.FromClause): Entities / DB model.
+
+    Returns:
+        Delete: A Delete object
+    """
+    return sa_delete(table)
+
+
+class DB:
+    """An async SQLAlchemy ORM wrapper."""
+
+    Base: DeclarativeMeta
+    _engine: AsyncEngine
+    _session: AsyncSession
+
+    def __init__(self, driver: str, options: dict | None = None, **kwargs):
+        """Init the class.
+
+        Args:
+            driver (str): Drivername for db url.
+            options (dict, optional): Options for AsyncEngine instance.
+            **kwargs (dict): Keyword arguments.
+        """
+        if options is None:
+            options = {"pool_size": 20, "max_overflow": 20}
+
+        url: str = URL.create(drivername=driver, **kwargs)
+        self._engine = create_async_engine(url, echo=True, pool_pre_ping=True, pool_recycle=300, **options)
+        self.Base = declarative_base()
+        self._session: AsyncSession = sessionmaker(self._engine, expire_on_commit=False, class_=AsyncSession)()
+
+    async def create_tables(self):
+        """Creates all Model Tables."""
+        async with self._engine.begin() as conn:
+            await conn.run_sync(self.Base.metadata.create_all)
+
+    async def add(self, obj: T) -> T:
+        """Adds an Row to the Database.
+
+        Args:
+            obj (T): Object to add.
+
+        Returns:
+            T: Added object.
+        """
+        self._session.add(obj)
+        return obj
+
+    async def delete(self, obj: T) -> T:
+        """Deletes a Row from the Database.
+
+        Args:
+            obj (T): Object to delete.
+
+        Returns:
+            T: Deleted object.
+        """
+        await self._session.delete(obj)
+        return obj
+
+    async def exec(self, statement: Executable, *args, **kwargs) -> Result:
+        """Executes a SQL Statement.
+
+        Args:
+            statement (Executable): SQL statement.
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            Result: A buffered Result object.
+        """
+        return await self._session.execute(statement, *args, **kwargs)
+
+    async def stream(self, statement: Executable, *args, **kwargs) -> AsyncScalarResult:
+        """Returns an Stream of Query Results.
+
+        Args:
+            statement (Executable): SQL statement.
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            AsyncScalarResult: An AsyncScalarResult filtering object.
+        """
+        return (await self._session.stream(statement, *args, **kwargs)).scalars()
+
+    async def all(self, statement: Executable, *args, **kwargs) -> list[T]:
+        """Returns all matches for a Query.
+
+        Args:
+            statement (Executable): SQL statement.
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            list[T]: List of rows.
+        """
+        return [x async for x in await self.stream(statement, *args, **kwargs)]
+
+    async def first(self, *args, **kwargs) -> dict | None:
+        """Returns first match for a Query.
+
+        Args:
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            dict | None: First match for the Query, or None if there is no match.
+        """
+        return (await self.exec(*args, **kwargs)).scalar()
+
+    async def exists(self, *args, **kwargs) -> bool:
+        """Checks if there is a match for this Query.
+
+        Args:
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            bool: Whether there is a match for this Query
+        """
+        return await self.first(exists(*args, **kwargs).select())
+
+    async def count(self, *args, **kwargs) -> int:
+        """Counts matches for a Query.
+
+        Args:
+            *args (tuple): Positional arguments.
+            **kwargs (dict): Keyword arguments.
+
+        Returns:
+            int: Number of matches for a Query
+        """
+        return await self.first(select(count()).select_from(*args, **kwargs))
+
+    async def commit(self):
+        """Commits/Saves changes to Database."""
+        await self._session.commit()
+
+
+logger = get_logger(__name__)
+
+
+class DatabaseDependency:
+    """A class to represent a database dependency."""
+
+    db: DB
+    database_url_options: dict
+    engine_options: dict
+    initialized: bool = False
+
+    def __init__(self):
+        """Initialize the class."""
+        self.database_url_options = {
+            "host": DBConfig.db_host,
+            "port": DBConfig.db_port,
+            "database": DBConfig.db_database,
+            "username": DBConfig.db_username,
+            "password": DBConfig.db_password,
+        }
+        self.database_url_options = {k: v for k, v in self.database_url_options.items() if v != ""}
+        self.engine_options: dict = {
+            # "pool_size": DB_POOL_SIZE, ## not used by sqlite
+            # "max_overflow": DB_MAX_OVERFLOW, ## not used by sqlite
+            "poolclass": DBConfig.db_pool,
+        }
+        self.engine_options = {k: int(v) for k, v in self.engine_options.items() if v != ""}
+        if self.engine_options["poolclass"] == 0:
+            self.engine_options["poolclass"] = NullPool
+        else:
+            del self.engine_options["poolclass"]
+        self.db = DB(
+            getenv("DB_DRIVER", "postgresql+asyncpg"), options=self.engine_options, **self.database_url_options
+        )
+        logger.info("Connected to Database")
+
+    async def init(self) -> None:
+        """Set whether the dependency is initialized or not."""
+        if self.initialized:
+            return
+
+        # logger.info("Create Tables")
+        self.initialized = True
+        # await self.db.create_tables()
+
+    async def __call__(self) -> DB:
+        """Define __call__."""
+        if not self.initialized:
+            await self.init()
+        return self.db
+
+
+database_dependency: DatabaseDependency = DatabaseDependency()
+Base: DeclarativeMeta = database_dependency.db.Base

desdeo/api/utils/logger.py

@@ -0,0 +1,29 @@
+import logging
+import sys
+from dotenv import load_dotenv
+from os import getenv
+
+load_dotenv()
+LOG_LEVEL = getenv("LOG_LEVEL", "INFO")
+
+logging_formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(message)s")
+
+logging_handler = logging.StreamHandler(sys.stdout)
+logging_handler.setFormatter(logging_formatter)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger with a given name.
+
+    Args:
+        name (str): Logger name.
+
+    Returns:
+        logging.Logger: logging.Logger object.
+    """
+
+    logger: logging.Logger = logging.getLogger(name)
+    logger.addHandler(logging_handler)
+    logger.setLevel(LOG_LEVEL.upper())
+
+    return logger

desdeo/core.py

@@ -0,0 +1,27 @@
+"""Functionalities related to managing and building the project."""
+
+import shutil
+import warnings
+
+
+def _check_executables(executable_list):
+    missing_executables = []
+    for executable in executable_list:
+        if shutil.which(executable) is None:
+            missing_executables.append(executable)
+
+    if missing_executables:
+        warnings.warn(
+            f"""
+            \nThe following required highly recommended executables cannot be found: {", ".join(missing_executables)}\n
+            DESDEO relies on powerful 3rd party solvers to solve multiobjective
+            optimization problems.  Without these solvers, sub-optimal defaults
+            will be used instead, which can lead to not optimal, or even wrong,
+            results.\n
+            It is highly recommended to have these solvers available
+            in the environment DESDEO is utilized!\n
+            For more information, see DESDEO's documentation: https://desdeo.readthedocs.io/en/latest/howtoguides/installing/#third-party-optimizers
+            """,
+            UserWarning,
+            stacklevel=2,
+        )

desdeo/emo/__init__.py

@@ -0,0 +1,29 @@
+"""Imports available from the desdeo emo."""
+
+__all__ = [
+    "rvea",
+    "nsga3",
+    "template1",
+    "NSGAIII_select",
+    "RVEASelector",
+    "SimulatedBinaryCrossover",
+    "BoundedPolynomialMutation",
+    "LHSGenerator",
+    "RandomGenerator",
+    "EMOEvaluator",
+    "MaxEvaluationsTerminator",
+    "MaxGenerationsTerminator",
+    "Archive",
+    "FeasibleArchive",
+    "NonDominatedArchive",
+]
+
+from .hooks.archivers import Archive, FeasibleArchive, NonDominatedArchive
+from .methods.bases import template1
+from .methods.EAs import nsga3, rvea
+from .operators.crossover import SimulatedBinaryCrossover
+from .operators.evaluator import EMOEvaluator
+from .operators.generator import LHSGenerator, RandomGenerator
+from .operators.mutation import BoundedPolynomialMutation
+from .operators.selection import NSGAIII_select, RVEASelector
+from .operators.termination import MaxEvaluationsTerminator, MaxGenerationsTerminator