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

desdeo/api/routers/enautilus.py

@@ -0,0 +1,237 @@
+"""Defines end-points to access functionalities related to the E-NAUTILUS method."""
+
+from typing import Annotated
+
+import numpy as np
+import polars as pl
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel import Session, select
+
+from desdeo.api.db import get_session
+from desdeo.api.models import (
+    ENautilusRepresentativeSolutionsResponse,
+    ENautilusState,
+    ENautilusStateResponse,
+    ENautilusStepRequest,
+    ENautilusStepResponse,
+    ProblemDB,
+    RepresentativeNonDominatedSolutions,
+    StateDB,
+)
+from desdeo.mcdm import ENautilusResult, enautilus_get_representative_solutions, enautilus_step
+from desdeo.problem import Problem
+
+from .utils import (
+    SessionContext,
+    get_session_context,
+)
+
+router = APIRouter(prefix="/method/enautilus")
+
+
+@router.post("/step")
+def step(
+    request: ENautilusStepRequest,
+    context: Annotated[SessionContext, Depends(get_session_context)],
+) -> ENautilusStepResponse:
+    """Steps the E-NAUTILUS method."""
+    # user = context.user  # not used here
+    db_session = context.db_session
+
+    problem_db = context.problem_db
+    problem = Problem.from_problemdb(problem_db)
+
+    interactive_session = context.interactive_session
+
+    parent_state = context.parent_state
+
+    representative_solutions = db_session.exec(
+        select(RepresentativeNonDominatedSolutions).where(
+            RepresentativeNonDominatedSolutions.id == request.representative_solutions_id
+        )
+    ).first()
+
+    if representative_solutions is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=(
+                "Could not find the requested representative solutions for the problem with "
+                f"id={request.representative_solutions_id}."
+            ),
+        )
+
+    if request.current_iteration == 0:
+        # First iteration, nadir as 'selected_point' and all points are reachable
+        # Nadir point is expected in 'True' values, hence the multiplication by -1 for maximized objectives
+        selected_point = {
+            f"{obj.symbol}": (-1 if obj.maximize else 1)
+            * np.max(representative_solutions.solution_data[f"{obj.symbol}_min"])
+            for obj in problem.objectives
+        }
+        reachable_point_indices = list(range(len(representative_solutions.solution_data[problem.objectives[0].symbol])))
+    else:
+        # Not first iteration
+        selected_point = request.selected_point
+        reachable_point_indices = request.reachable_point_indices
+
+    # iterate E-NAUTILUS
+    results: ENautilusResult = enautilus_step(
+        problem=problem,
+        non_dominated_points=representative_solutions.solution_data,
+        current_iteration=request.current_iteration,
+        iterations_left=request.iterations_left,
+        selected_point=selected_point,
+        number_of_intermediate_points=request.number_of_intermediate_points,
+        reachable_point_indices=reachable_point_indices,
+    )
+
+    enautilus_state = ENautilusState(
+        non_dominated_solutions_id=request.representative_solutions_id,
+        current_iteration=request.current_iteration,
+        iterations_left=request.iterations_left,
+        selected_point=selected_point,
+        reachable_point_indices=reachable_point_indices,
+        number_of_intermediate_points=request.number_of_intermediate_points,
+        enautilus_results=results,
+    )
+
+    # create DB state and add it to the DB
+    state_db = StateDB.create(
+        database_session=db_session,
+        problem_id=problem_db.id,
+        session_id=interactive_session.id if interactive_session is not None else None,
+        parent_id=parent_state.id if parent_state is not None else None,
+        state=enautilus_state,
+    )
+
+    db_session.add(state_db)
+    db_session.commit()
+    db_session.refresh(state_db)
+
+    return ENautilusStepResponse(
+        state_id=state_db.id,
+        current_iteration=results.current_iteration,
+        iterations_left=results.iterations_left,
+        intermediate_points=results.intermediate_points,
+        reachable_best_bounds=results.reachable_best_bounds,
+        reachable_worst_bounds=results.reachable_worst_bounds,
+        closeness_measures=results.closeness_measures,
+        reachable_point_indices=results.reachable_point_indices,
+    )
+
+
+@router.get("/get_state/{state_id}")
+def get_state(
+    state_id: int,
+    db_session: Annotated[Session, Depends(get_session)],
+) -> ENautilusStateResponse:
+    """Fetch a previous state of the the E-NAUTILUS method."""
+    state_db: StateDB | None = db_session.exec(select(StateDB).where(StateDB.id == state_id)).first()
+
+    if state_db is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Could not find 'StateDB' with id={state_id}"
+        )
+
+    if not isinstance(state_db.state, ENautilusState):
+        raise HTTPException(
+            status_code=status.HTTP_406_NOT_ACCEPTABLE, detail="The requested state does not contain an ENautilusState."
+        )
+
+    enautilus_state: ENautilusState = state_db.state
+    results: ENautilusResult = enautilus_state.enautilus_results
+
+    request = ENautilusStepRequest(
+        problem_id=state_db.problem_id,
+        session_id=state_db.session_id,
+        parent_state_id=state_db.parent_id,
+        representative_solutions_id=enautilus_state.non_dominated_solutions_id,
+        current_iteration=enautilus_state.current_iteration,
+        iterations_left=enautilus_state.iterations_left,
+        selected_point=enautilus_state.selected_point,
+        reachable_point_indices=enautilus_state.reachable_point_indices,
+        number_of_intermediate_points=enautilus_state.number_of_intermediate_points,
+    )
+
+    response = ENautilusStepResponse(
+        state_id=state_db.id,
+        current_iteration=results.current_iteration,
+        iterations_left=results.iterations_left,
+        intermediate_points=results.intermediate_points,
+        reachable_best_bounds=results.reachable_best_bounds,
+        reachable_worst_bounds=results.reachable_worst_bounds,
+        closeness_measures=results.closeness_measures,
+        reachable_point_indices=results.reachable_point_indices,
+    )
+
+    return ENautilusStateResponse(request=request, response=response)
+
+
+@router.get("/get_representative/{state_id}")
+def get_representative(
+    state_id: int, db_session: Annotated[Session, Depends(get_session)]
+) -> ENautilusRepresentativeSolutionsResponse:
+    """Computes the representative solutions that are closest to the intermediate solutions computed by E-NAUTILUS.
+
+    This endpoint should be used to get the actual solution from the
+    non-dominated representation used in the E-NAUTILUS method's last iteration
+    (when number of iterations left is 0).
+
+    Args:
+        state_id (int): id of the `StateDB` with information on the intermediate
+            points for which the representative solutions should be computed.
+        db_session (Annotated[Session, Depends): the database session.
+
+    Raises:
+        HTTPException: 404 when a `StateDB`, `ProblemDB`, or
+            `RepresentativeNonDominatedSolutions` instance cannot be found. 406 when
+            the substate of the references `StateDB` is not an instance of
+            `ENautilusState`.
+
+    Returns:
+        ENautilusRepresentativeSolutionsResponse: the information on the representative solutions.
+    """
+    state_db: StateDB | None = db_session.exec(select(StateDB).where(StateDB.id == state_id)).first()
+
+    if state_db is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Could not find 'StateDB' with id={state_id}"
+        )
+
+    if not isinstance(state_db.state, ENautilusState):
+        raise HTTPException(
+            status_code=status.HTTP_406_NOT_ACCEPTABLE, detail="The requested state does not contain an ENautilusState."
+        )
+
+    enautilus_state: ENautilusState = state_db.state
+    enautilus_result: ENautilusResult = enautilus_state.enautilus_results
+
+    non_dom_solutions_db = db_session.exec(
+        select(RepresentativeNonDominatedSolutions).where(
+            RepresentativeNonDominatedSolutions.id == enautilus_state.non_dominated_solutions_id
+        )
+    ).first()
+
+    if non_dom_solutions_db is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=(
+                "Could not find 'RepresentativeNonDominatedSolutions' with "
+                f"id={enautilus_state.non_dominated_solutions_id}"
+            ),
+        )
+
+    non_dom_solutions = pl.DataFrame(non_dom_solutions_db.solution_data)
+
+    problem_db = db_session.exec(select(ProblemDB).where(ProblemDB.id == state_db.problem_id)).first()
+
+    if problem_db is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Could not find 'ProblemDB' with id={state_db.problem_id}"
+        )
+
+    problem = Problem.from_problemdb(problem_db)
+
+    representative_solutions = enautilus_get_representative_solutions(problem, enautilus_result, non_dom_solutions)
+
+    return ENautilusRepresentativeSolutionsResponse(solutions=representative_solutions)

desdeo/api/routers/gdm/gdm_aggregate.py

@@ -0,0 +1,234 @@
+"""A structure for group decision making.
+
+When preferences are sent through the websockets, they are validated.
+Then, the preferences are saved into a database. When all group members have articulated their
+preferences, system begins optimization. The results are then saved into the database and the system notifies all
+connected users that the solutions are ready to be fetched. If a user is not connected to the server, the server will
+notify the user when they connect next time.
+
+"""
+
+import asyncio
+import logging
+import sys
+from datetime import UTC, datetime
+from typing import Annotated
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    Query,
+    WebSocket,
+    WebSocketDisconnect,
+)
+from jose import ExpiredSignatureError, JWTError, jwt
+from sqlmodel import Session, select
+
+from desdeo.api import AuthConfig
+from desdeo.api.db import get_session
+from desdeo.api.models import (
+    Group,
+    User,
+)
+from desdeo.api.routers.gdm.gdm_base import GroupManager
+from desdeo.api.routers.gdm.gdm_score_bands.gdm_score_bands_manager import GDMScoreBandsManager
+from desdeo.api.routers.gdm.gnimbus.gnimbus_manager import GNIMBUSManager
+from desdeo.api.routers.user_authentication import get_user
+
+logging.basicConfig(
+    stream=sys.stdout, format="[%(filename)s:%(lineno)d] %(levelname)s: %(message)s", level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/gdm")
+
+
+class ManagerManager:
+    """A singleton class to manage group managers. Spawns them and deletes them.
+
+    TODO: Also check on manager type! If a Group has a NIMBUSManager, but for
+    example a RPMManager is requested, create it.
+    """
+
+    def __init__(self):
+        """Class constructor."""
+        # self.group_managers: dict[int, GroupManager] = {}
+        self.group_managers: dict[int, dict[str, GroupManager]] = {}
+        self.lock = asyncio.Lock()
+
+    async def get_group_manager(
+        self, group_id: int, method: str, db_session: Session
+    ) -> GroupManager | GNIMBUSManager | GDMScoreBandsManager | None:
+        """Return the correct group manager for the caller.
+
+        Args:
+            group_id (int): The ID of the group of the mgr
+            method (str): The method of the group mgr
+            db_session (Session): the database session passed to the manager.
+
+        Returns:
+            GroupManager | GNIMBUSManager | GDMScoreBandsManager | None: The manager (or not if not implemented.)
+        """
+        async with self.lock:
+            if group_id in self.group_managers:
+                managers = self.group_managers[group_id]
+                if method in managers:
+                    return managers[method]
+                # If there is no manager, create it.
+                match method:
+                    case "gnimbus":
+                        manager = GNIMBUSManager(group_id=group_id, db_session=db_session)
+                        self.group_managers[group_id][method] = manager
+                        return manager
+                    case "gdm-score-bands":
+                        manager = GDMScoreBandsManager(group_id=group_id, db_session=db_session)
+                        self.group_managers[group_id][method] = manager
+                        return manager
+            else:
+                self.group_managers[group_id] = {}
+                match method:
+                    case "gnimbus":
+                        manager = GNIMBUSManager(group_id=group_id, db_session=db_session)
+                        self.group_managers[group_id][method] = manager
+                        return manager
+                    case "gdm-score-bands":
+                        manager = GDMScoreBandsManager(group_id=group_id, db_session=db_session)
+                        self.group_managers[group_id][method] = manager
+                        return manager
+
+    async def check_disconnect(self, group_id: int, method: str):
+        """Checks if a group manager has active connections. If no, delete it.
+
+        Args:
+            group_id (int): ID of the group
+            method (str): method of the manager
+
+        Returns:
+            Nothing.
+        """
+        async with self.lock:
+            # check if group has any managers
+            if group_id in self.group_managers:
+                managers = self.group_managers[group_id]
+                # Check if method has a manager
+                if method in managers:
+                    manager = managers[method]
+                    # check if the manager has any active websockets
+                    for _, socket in manager.sockets.items():
+                        if socket is not None:
+                            return
+                    # No active sockets, delete the manager.
+                    async with manager.lock:
+                        del self.group_managers[group_id][method]
+                        # If group has no managers, delete the group entry.
+                        if self.group_managers[group_id] == {}:
+                            del self.group_managers[group_id]
+
+
+manager = ManagerManager()
+
+
+async def auth_user(token: str, session: Session, websocket: WebSocket) -> User:
+    """Authenticate the user.
+
+    token: str: the access token of the user.
+    session: Session: the database session from where the user is received
+    websocket: WebSocket: the websocket that the user has connected with
+
+    """
+
+    async def error_and_close():
+        await websocket.send_text("Could not validate credencials. Try logging in again.")
+        await websocket.close()
+
+    try:
+        payload = jwt.decode(token, AuthConfig.authjwt_secret_key, algorithms=[AuthConfig.authjwt_algorithm])
+        username = payload.get("sub")
+        expire_time: datetime = payload.get("exp")
+
+        if username is None or expire_time is None or expire_time < datetime.now(UTC).timestamp():
+            return await error_and_close()
+
+    except ExpiredSignatureError:
+        return await error_and_close()
+
+    except JWTError:
+        return await error_and_close()
+
+    user = get_user(session, username=username)
+
+    if user is None:
+        return await error_and_close()
+
+    return user
+
+
+@router.websocket("/ws")
+async def websocket_endpoint(
+    session: Annotated[Session, Depends(get_session)],
+    websocket: WebSocket,
+    token: str = Query(),
+    group_id: int = Query(),
+    method: str = Query(),
+):
+    """The websocket endpoint to which the user connects.
+
+    Both the access token and the group id is given as a query parameter to the endpoint.
+    The call to this endpoint looks like the following:
+
+    ws://[DOMAIN]:[PORT]/gdm/ws?token=[TOKEN]&group_id=[GROUP_ID]&method=[METHOD]
+
+    See further details in the documentation. (Explanations -> GDM and websockets)
+    """
+    # Accept the websocket (to send back stuff if something goes wrong)
+    await websocket.accept()
+
+    user = await auth_user(token, session, websocket)
+    if user is None:
+        return
+
+    group = session.exec(select(Group).where(Group.id == group_id)).first()
+    if group is None:
+        await websocket.send_text(f"There is no group with ID {group_id}.")
+        await websocket.close()
+        return
+
+    if not (user.id in group.user_ids or user.id is group.owner_id):
+        await websocket.send_text(f"User {user.username} doesn't belong in group {group.name}")
+        await websocket.close()
+        return
+
+    # We don't need the session here any more, so we can just close it.
+    # I believe this releases connections to the pool
+    session.close()
+
+    # Get the group manager object from the manager of group managers
+    group_manager = await manager.get_group_manager(group_id=group_id, method=method)
+    if group_manager is None:
+        await websocket.send_text(f"Unknown method: {method}")
+        await websocket.close()
+        return
+
+    await group_manager.connect(user.id, websocket)
+    logger.info(f"Group ID {group_id} manager's active connections {group_manager.sockets}")
+    logger.info(f"Existing GroupManagers: {manager.group_managers}")
+    while True:
+        try:
+            # Get data from socket
+            data = await websocket.receive_text()
+            # send data for preference setting
+            if user.id in group.user_ids:
+                await group_manager.run_method(user.id, data)
+            else:
+                logger.warning(
+                    f"User {user.username} is not part of group {group.name}! They're likely the group owner."
+                )
+        except WebSocketDisconnect:
+            await group_manager.disconnect(user.id, websocket)
+            await manager.check_disconnect(group_id=group_id, method=method)
+            logger.info(f"Group ID {group_id} manager's active connections {group_manager.sockets}")
+            logger.info(f"Existing GroupManagers: {manager.group_managers}")
+            break
+        except RuntimeError as e:
+            logger.warning(f"RuntimeError: {e}")
+            break