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

desdeo/api/utils/_database.py

@@ -0,0 +1,263 @@
+"""Database utils for the API."""
+
+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 DatabaseConfig as DBConfig
+
+from .logger import get_logger
+
+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(DBConfig.db_driver, 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/api/utils/database.py

@@ -0,0 +1,36 @@
+"""Utilities related to handling the database."""
+
+from sqlmodel import Session
+
+from desdeo.api.models import StateDB, UserSavedSolutionDB
+
+
+def user_save_solutions(
+    state_db: StateDB,
+    results: list,
+    user_id: int,
+    session: Session,
+):
+    """Save solutions to the user's archive and create new state in the database.
+
+    Args:
+        state_db: The state containing the solutions
+        results: List of solutions to save
+        user_id: ID of the user saving the solutions
+        session: Database session
+    """
+    # Create archive entries for selected solutions
+    for solution in results:
+        archive_entry = UserSavedSolutionDB(
+            name=solution.name if solution.name else None,
+            objective_values=solution.objective_values,
+            address_state=solution.address_state,
+            state_id=state_db.id,
+            address_result=solution.address_result,
+            user_id=user_id,
+            problem_id=state_db.problem_id,
+            state=state_db,
+        )
+        session.add(archive_entry)
+    # state is already set in UserSavedSolutionDB, so no need to add it explictly
+    session.commit()

desdeo/api/utils/emo_database.py

@@ -0,0 +1,40 @@
+"""Utility functions for EMO database operations."""
+
+
+def _convert_dataframe_to_dict_list(df):
+    """Convert DataFrame to list of dictionaries, handling different DataFrame types."""
+    if df is None:
+        return []
+
+    # Check if it's a pandas DataFrame
+    if hasattr(df, "iterrows"):
+        return [row.to_dict() for _, row in df.iterrows()]
+
+    # Check if it's a Polars DataFrame
+    elif hasattr(df, "iter_rows"):
+        # Get column names
+        columns = df.columns
+        return [dict(zip(columns, row)) for row in df.iter_rows()]
+
+    # Check if it's already a list of dictionaries
+    elif isinstance(df, list):
+        return df
+
+    # Check if it has to_dict method (pandas Series)
+    elif hasattr(df, "to_dict"):
+        return [df.to_dict()]
+
+    # Try to convert to dict if it's a single row
+    elif hasattr(df, "__iter__") and not isinstance(df, (str, dict)):
+        try:
+            # Assume it's iterable with column names
+            if hasattr(df, "columns"):
+                return [dict(zip(df.columns, row)) for row in df]
+            else:
+                # Generic conversion
+                return [dict(enumerate(row)) for row in df]
+        except Exception:
+            pass
+
+    # If all else fails, try to convert to string representation
+    return [{"data": str(df)}]

desdeo/core.py

@@ -0,0 +1,34 @@
+"""Functionalities related to managing and building the project."""
+
+import shutil
+import warnings
+from os import getenv
+
+from dotenv import load_dotenv
+
+
+def _check_executables(executable_list):
+    missing_executables = []
+    load_dotenv()
+    if getenv("CHECK_EXECUTABLES", "true").lower() == "false":
+        return
+
+    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,159 @@
+"""Imports available from the desdeo emo."""
+
+__all__ = [
+    "algorithms",
+    "crossover",
+    "generator",
+    "mutation",
+    "other",
+    "preference_handling",
+    "repair",
+    "scalar_selection",
+    "selection",
+    "templates",
+    "termination",
+]
+
+from types import SimpleNamespace
+
+from .options.algorithms import (
+    emo_constructor,
+    ibea_mixed_integer_options,
+    ibea_options,
+    nsga2_options,
+    nsga3_mixed_integer_options,
+    nsga3_options,
+    rvea_mixed_integer_options,
+    rvea_options,
+)
+from .options.crossover import (
+    BlendAlphaCrossoverOptions,
+    BoundedExponentialCrossoverOptions,
+    LocalCrossoverOptions,
+    SimulatedBinaryCrossoverOptions,
+    SingleArithmeticCrossoverOptions,
+    SinglePointBinaryCrossoverOptions,
+    UniformIntegerCrossoverOptions,
+    UniformMixedIntegerCrossoverOptions,
+)
+from .options.generator import (
+    LHSGeneratorOptions,
+    RandomBinaryGeneratorOptions,
+    RandomGeneratorOptions,
+    RandomIntegerGeneratorOptions,
+    RandomMixedIntegerGeneratorOptions,
+)
+from .options.mutation import (
+    BinaryFlipMutationOptions,
+    BoundedPolynomialMutationOptions,
+    IntegerRandomMutationOptions,
+    MixedIntegerRandomMutationOptions,
+    MPTMutationOptions,
+    NonUniformMutationOptions,
+    PowerMutationOptions,
+    SelfAdaptiveGaussianMutationOptions,
+)
+from .options.repair import ClipRepairOptions, NoRepairOptions
+from .options.scalar_selection import RouletteWheelSelectionOptions, TournamentSelectionOptions
+from .options.selection import (
+    IBEASelectorOptions,
+    NSGA2SelectorOptions,
+    NSGA3SelectorOptions,
+    ReferenceVectorOptions,
+    RVEASelectorOptions,
+)
+from .options.templates import (
+    DesirableRangesOptions,
+    NonPreferredSolutionsOptions,
+    PreferredSolutionsOptions,
+    ReferencePointOptions,
+    Template1Options,
+    Template2Options,
+)
+from .options.termination import (
+    CompositeTerminatorOptions,
+    ExternalCheckTerminatorOptions,
+    MaxEvaluationsTerminatorOptions,
+    MaxGenerationsTerminatorOptions,
+    MaxTimeTerminatorOptions,
+)
+
+# Just didn't want to have a thousand imports in the main namespace
+algorithms = SimpleNamespace(
+    rvea_options=rvea_options,
+    nsga2_options=nsga2_options,
+    nsga3_options=nsga3_options,
+    ibea_options=ibea_options,
+    rvea_mixed_integer_options=rvea_mixed_integer_options,
+    nsga3_mixed_integer_options=nsga3_mixed_integer_options,
+    ibea_mixed_integer_options=ibea_mixed_integer_options,
+    emo_constructor=emo_constructor,
+)
+
+termination = SimpleNamespace(
+    MaxEvaluationsTerminatorOptions=MaxEvaluationsTerminatorOptions,
+    MaxGenerationsTerminatorOptions=MaxGenerationsTerminatorOptions,
+    MaxTimeTerminatorOptions=MaxTimeTerminatorOptions,
+    CompositeTerminatorOptions=CompositeTerminatorOptions,
+    ExternalCheckTerminatorOptions=ExternalCheckTerminatorOptions,
+)
+
+selection = SimpleNamespace(
+    IBEASelectorOptions=IBEASelectorOptions,
+    NSGA3SelectorOptions=NSGA3SelectorOptions,
+    NSGA2SelectorOptions=NSGA2SelectorOptions,
+    RVEASelectorOptions=RVEASelectorOptions,
+)
+
+other = SimpleNamespace(
+    ReferenceVectorOptions=ReferenceVectorOptions,
+)
+
+scalar_selection = SimpleNamespace(
+    TournamentSelectionOptions=TournamentSelectionOptions,
+    RouletteWheelSelectionOptions=RouletteWheelSelectionOptions,
+)
+
+mutation = SimpleNamespace(
+    BinaryFlipMutationOptions=BinaryFlipMutationOptions,
+    BoundedPolynomialMutationOptions=BoundedPolynomialMutationOptions,
+    IntegerRandomMutationOptions=IntegerRandomMutationOptions,
+    MixedIntegerRandomMutationOptions=MixedIntegerRandomMutationOptions,
+    MPTMutationOptions=MPTMutationOptions,
+    NonUniformMutationOptions=NonUniformMutationOptions,
+    PowerMutationOptions=PowerMutationOptions,
+    SelfAdaptiveGaussianMutationOptions=SelfAdaptiveGaussianMutationOptions,
+)
+
+generator = SimpleNamespace(
+    LHSGeneratorOptions=LHSGeneratorOptions,
+    RandomBinaryGeneratorOptions=RandomBinaryGeneratorOptions,
+    RandomGeneratorOptions=RandomGeneratorOptions,
+    RandomIntegerGeneratorOptions=RandomIntegerGeneratorOptions,
+    RandomMixedIntegerGeneratorOptions=RandomMixedIntegerGeneratorOptions,
+)
+
+templates = SimpleNamespace(
+    Template1Options=Template1Options,
+    Template2Options=Template2Options,
+)
+
+repair = SimpleNamespace(NoRepairOptions=NoRepairOptions, ClipRepairOptions=ClipRepairOptions)
+
+preference_handling = SimpleNamespace(
+    ReferencePointOptions=ReferencePointOptions,
+    DesirableRangesOptions=DesirableRangesOptions,
+    PreferredSolutionsOptions=PreferredSolutionsOptions,
+    NonPreferredSolutionsOptions=NonPreferredSolutionsOptions,
+)
+
+crossover = SimpleNamespace(
+    BlendAlphaCrossoverOptions=BlendAlphaCrossoverOptions,
+    BoundedExponentialCrossoverOptions=BoundedExponentialCrossoverOptions,
+    LocalCrossoverOptions=LocalCrossoverOptions,
+    SimulatedBinaryCrossoverOptions=SimulatedBinaryCrossoverOptions,
+    SingleArithmeticCrossoverOptions=SingleArithmeticCrossoverOptions,
+    SinglePointBinaryCrossoverOptions=SinglePointBinaryCrossoverOptions,
+    UniformIntegerCrossoverOptions=UniformIntegerCrossoverOptions,
+    UniformMixedIntegerCrossoverOptions=UniformMixedIntegerCrossoverOptions,
+)