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

desdeo/api/models/nimbus.py

@@ -36,11 +36,13 @@ class NIMBUSSaveRequest(SQLModel):
 
     solution_info: list[SolutionInfo]
 
+
 class NIMBUSDeleteSaveRequest(SQLModel):
     """Request model for deletion of a saved solution."""
 
-    state_id : int = Field(description="The ID of the save state.")
+    state_id: int = Field(description="The ID of the save state.")
     solution_index: int = Field(description="The ID of the solution within the above state.")
+    problem_id: int = Field(description="The ID of the problem.")
 
 
 class NIMBUSFinalizeRequest(SQLModel):
@@ -50,7 +52,7 @@ class NIMBUSFinalizeRequest(SQLModel):
     session_id: int | None = Field(default=None)
     parent_state_id: int | None = Field(default=None)
 
-    solution_info: SolutionInfo # the final solution
+    solution_info: SolutionInfo  # the final solution
 
 
 class NIMBUSClassificationResponse(SQLModel):
@@ -98,12 +100,14 @@ class NIMBUSSaveResponse(SQLModel):
 
     state_id: int | None = Field(description="The id of the newest state")
 
+
 class NIMBUSDeleteSaveResponse(SQLModel):
     """Response of NIMBUS save deletion."""
 
     response_type: str = "nimbus.delete_save"
 
-    message: str | None
+    message: str | None = None
+
 
 class NIMBUSFinalizeResponse(SQLModel):
     """The response from NIMBUS finish endpoint."""
@@ -144,7 +148,7 @@ class NIMBUSIntermediateSolutionResponse(SQLModel):
     reference_solution_1: dict[str, float] = Field(
         sa_column=Column(JSON), description="The first solution used when computing intermediate points."
     )
-    reference_solution_2: dict[str, float]= Field(
+    reference_solution_2: dict[str, float] = Field(
         sa_column=Column(JSON), description="The second solution used when computing intermediate points."
     )
     current_solutions: list[SolutionReferenceResponse] = Field(

desdeo/api/routers/emo.py

@@ -15,30 +15,24 @@ import polars as pl
 from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisconnect, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import StreamingResponse
-from sqlmodel import Session, select
+from sqlmodel import select
 from websockets.asyncio.client import connect
 
 from desdeo.api.db import get_session
-from desdeo.api.models import InteractiveSessionDB, StateDB
+from desdeo.api.models import StateDB
 from desdeo.api.models.emo import (
     EMOFetchRequest,
-    EMOFetchResponse,
     EMOIterateRequest,
     EMOIterateResponse,
-    EMOSaveRequest,
     EMOScoreRequest,
     EMOScoreResponse,
-    Solution,
 )
-from desdeo.api.models.problem import ProblemDB
-from desdeo.api.models.state import EMOFetchState, EMOIterateState, EMOSaveState, EMOSCOREState
-from desdeo.api.models.user import User
-from desdeo.api.routers.user_authentication import get_current_user
+from desdeo.api.models.state import EMOIterateState, EMOSCOREState
 from desdeo.emo.options.templates import EMOOptions, PreferenceOptions, TemplateOptions, emo_constructor
 from desdeo.problem import Problem
-from desdeo.tools.score_bands import SCOREBandsConfig, SCOREBandsResult, score_json
+from desdeo.tools.score_bands import SCOREBandsConfig, score_json
 
-from .utils import fetch_interactive_session, fetch_user_problem
+from .utils import SessionContext, get_session_context
 
 router = APIRouter(prefix="/method/emo", tags=["EMO"])
 
@@ -113,7 +107,6 @@ async def websocket_endpoint(
     try:
         while True:
             data = await websocket.receive_json()
-            print(data)
             if "send_to" in data:
                 try:
                     await ws_manager.send_private_message(data, data["send_to"])
@@ -153,71 +146,55 @@ def get_templates() -> list[TemplateOptions]:
 @router.post("/iterate")
 def iterate(
     request: EMOIterateRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> EMOIterateResponse:
-    """Starts the EMO method.
+    """Fetches results from a completed EMO method.
 
-    Args:
-        request (EMOSolveRequest): The request object containing parameters for the EMO method.
-        user (Annotated[User, Depends]): The current user.
-        session (Annotated[Session, Depends]): The database session.
+    Args: request (EMOIterateRequest): The request object containing parameters for fetching results.
+        context (Annotated[SessionContext, Depends]): The session context.
 
-    Raises:
-        HTTPException: If the request is invalid or the EMO method fails.
-
-    Returns:
-        IterateResponse: A response object containing a list of IDs to be used for websocket communication.
-            Also contains the StateDB id where the results will be stored.
+    Raises: HTTPException: If the request is invalid or the EMO method fails.
+    Returns: IterateResponse: A response object containing a list of IDs to be used for websocket communication.
+        Also contains the StateDB id where the results will be stored.
     """
-    interactive_session: InteractiveSessionDB | None = fetch_interactive_session(user, request, session)
+    # Get context objects
+    db_session = context.db_session
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
 
-    problem_db = fetch_user_problem(user, request, session)
+    # Ensure problem exists
+    if context.problem_db is None:
+        raise HTTPException(status_code=404, detail="Problem not found")
+
+    problem_db = context.problem_db
     problem = Problem.from_problemdb(problem_db)
 
-    templates = request.template_options
+    # Templates
+    templates = request.template_options or get_templates()
 
-    if templates is None:
-        templates = get_templates()
+    web_socket_ids = [
+        f"{template.algorithm_name.lower()}_{datetime.now().strftime('%Y%m%d%H%M%S%f')}" for template in templates
+    ]
 
-    web_socket_ids = []
-    for template in templates:
-        # Ensure unique names
-        web_socket_ids.append(f"{template.algorithm_name.lower()}_{datetime.now().strftime('%Y%m%d%H%M%S%f')}")
     client_id = f"client_{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
-    client_id = "client"
-
-    # Save request (incomplete and EAs have not finished running yet)
-
-    # Handle parent state
-    if request.parent_state_id is None:
-        parent_state = None
-    else:
-        statement = select(StateDB).where(StateDB.id == request.parent_state_id)
-        parent_state = session.exec(statement).first()
-
-        if parent_state is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Could not find state with id={request.parent_state_id}",
-            )
 
+    # 4) Create incomplete state
     emo_iterate_state = EMOIterateState(
         template_options=jsonable_encoder(templates),
         preference_options=jsonable_encoder(request.preference_options),
     )
 
     incomplete_db_state = StateDB.create(
-        database_session=session,
+        database_session=db_session,
         problem_id=problem_db.id,
         session_id=interactive_session.id if interactive_session else None,
         parent_id=parent_state.id if parent_state else None,
         state=emo_iterate_state,
     )
 
-    session.add(incomplete_db_state)
-    session.commit()
-    session.refresh(incomplete_db_state)
+    db_session.add(incomplete_db_state)
+    db_session.commit()
+    db_session.refresh(incomplete_db_state)
 
     state_id = incomplete_db_state.id
     if state_id is None:
@@ -225,10 +202,8 @@ def iterate(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to create a new state in the database.",
         )
-    # Close db session
-    session.close()
 
-    # Spawn a new process to handle EMO method creation
+    # Start process
     Process(
         target=_spawn_emo_process,
         args=(
@@ -319,7 +294,7 @@ def _spawn_emo_process(
     session.close()
 
 
-def _ea_sync(  # noqa: PLR0913
+def _ea_sync(
     problem: Problem,
     template: TemplateOptions,
     preference_options: PreferenceOptions | None,
@@ -352,7 +327,7 @@ def _ea_sync(  # noqa: PLR0913
     )
 
 
-async def _ea_async(  # noqa: PLR0913
+async def _ea_async(
     problem: Problem,
     websocket_id: str,
     client_id: str,
@@ -388,33 +363,29 @@ async def _ea_async(  # noqa: PLR0913
 @router.post("/fetch")
 async def fetch_results(
     request: EMOFetchRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> StreamingResponse:
     """Fetches results from a completed EMO method.
 
     Args:
         request (EMOFetchRequest): The request object containing parameters for fetching results.
-        user (Annotated[User, Depends]): The current user.
-        session (Annotated[Session, Depends]): The database session.
+        context (Annotated[SessionContext, Depends]): The session context.
 
-    Raises:
-        HTTPException: If the request is invalid or the EMO method has not completed.
+    Raises: HTTPException: If the request is invalid or the EMO method has not completed.
 
-    Returns:
-        StreamingResponse: A streaming response containing the results of the EMO method.
+    Returns: StreamingResponse: A streaming response containing the results of the EMO method.
     """
-    parent_state = request.parent_state_id
-    statement = select(StateDB).where(StateDB.id == parent_state)
-    state = session.exec(statement).first()
+    # Use context instead of manual fetch
+    state = context.parent_state
+
     if state is None:
         raise HTTPException(status_code=404, detail="Parent state not found.")
 
     if not isinstance(state.state, EMOIterateState):
-        raise TypeError(f"State with id={parent_state} is not of type EMOIterateState.")
+        raise TypeError(f"State with id={request.parent_state_id} is not of type EMOIterateState.")
 
     if not (state.state.objective_values and state.state.decision_variables):
-        raise ValueError(f"State does not contain results yet.")
+        raise ValueError("State does not contain results yet.")
 
     # Convert objs: dict[str, list[float]] to objs: list[dict[str, float]]
     raw_objs: dict[str, list[float]] = state.state.objective_values
@@ -422,14 +393,15 @@ async def fetch_results(
     objs: list[dict[str, float]] = [{k: v[i] for k, v in raw_objs.items()} for i in range(n_solutions)]
 
     raw_decs: dict[str, list[float]] = state.state.decision_variables
-
     decs: list[dict[str, float]] = [{k: v[i] for k, v in raw_decs.items()} for i in range(n_solutions)]
 
-    response: list[Solution] = []
-
     def result_stream():
         for i in range(n_solutions):
-            item = {"solution_id": i, "objective_values": objs[i], "decision_variables": decs[i]}
+            item = {
+                "solution_id": i,
+                "objective_values": objs[i],
+                "decision_variables": decs[i],
+            }
             yield json.dumps(item) + "\n"
 
     return StreamingResponse(result_stream())
@@ -438,16 +410,13 @@ async def fetch_results(
 @router.post("/fetch_score")
 async def fetch_score_bands(
     request: EMOScoreRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> EMOScoreResponse:
     """Fetches results from a completed EMO method.
 
-    Args:
-        request (EMOFetchRequest): The request object containing parameters for fetching results and of the SCORE bands
-            visualization.
-        user (Annotated[User, Depends]): The current user.
-        session (Annotated[Session, Depends]): The database session.
+    Args: request (EMOFetchRequest): The request object containing parameters for fetching
+        results and of the SCORE bands visualization.
+        context (Annotated[SessionContext, Depends]): The session context.
 
     Raises:
         HTTPException: If the request is invalid or the EMO method has not completed.
@@ -455,24 +424,23 @@ async def fetch_score_bands(
     Returns:
         SCOREBandsResult: The results of the SCORE bands visualization.
     """
-    if request.config is None:
-        score_config = SCOREBandsConfig()
-    else:
-        score_config = request.config
-    parent_state = request.parent_state_id
-    statement = select(StateDB).where(StateDB.id == parent_state)
-    state = session.exec(statement).first()
-    if state is None:
+    # Use context instead of manual fetch
+    parent_state = context.parent_state
+    db_session = context.db_session
+    problem_db = context.problem_db
+
+    if parent_state is None:
         raise HTTPException(status_code=404, detail="Parent state not found.")
 
-    if not isinstance(state.state, EMOIterateState):
-        raise TypeError(f"State with id={parent_state} is not of type EMOIterateState.")
+    if not isinstance(parent_state.state, EMOIterateState):
+        raise TypeError(f"State with id={request.parent_state_id} is not of type EMOIterateState.")
 
-    if not (state.state.objective_values and state.state.decision_variables):
-        raise ValueError(f"State does not contain results yet.")
+    if not (parent_state.state.objective_values and parent_state.state.decision_variables):
+        raise ValueError("State does not contain results yet.")
 
-    # Convert objs: dict[str, list[float]] to objs: list[dict[str, float]]
-    raw_objs: dict[str, list[float]] = state.state.objective_values
+    score_config = SCOREBandsConfig() if request.config is None else request.config
+
+    raw_objs: dict[str, list[float]] = parent_state.state.objective_values
     objs = pl.DataFrame(raw_objs)
 
     results = score_json(
@@ -482,16 +450,19 @@ async def fetch_score_bands(
 
     score_state = EMOSCOREState(result=results.model_dump())
 
+    # Use the session + problem from context instead of request directly
     score_db_state = StateDB.create(
-        database_session=session,
-        problem_id=request.problem_id,
-        session_id=request.session_id,
-        parent_id=parent_state,
+        database_session=db_session,
+        problem_id=problem_db.id,
+        session_id=parent_state.session_id,
+        parent_id=parent_state.id,
         state=score_state,
     )
-    session.add(score_db_state)
-    session.commit()
-    session.refresh(score_db_state)
+
+    db_session.add(score_db_state)
+    db_session.commit()
+    db_session.refresh(score_db_state)
+
     state_id = score_db_state.id
 
     return EMOScoreResponse(result=results, state_id=state_id)

desdeo/api/routers/generic.py

@@ -5,65 +5,55 @@ from typing import Annotated
 import numpy as np
 import pandas as pd
 from fastapi import APIRouter, Depends, HTTPException, status
-from sqlmodel import Session, select
+from sqlmodel import select
 
-from desdeo.api.db import get_session
 from desdeo.api.models import (
-    InteractiveSessionDB,
     IntermediateSolutionRequest,
     IntermediateSolutionState,
-    ProblemDB,
     ScoreBandsRequest,
     ScoreBandsResponse,
     SolutionReference,
     StateDB,
-    User,
 )
 from desdeo.api.models.generic import GenericIntermediateSolutionResponse
-from desdeo.api.routers.user_authentication import get_current_user
 from desdeo.mcdm.nimbus import solve_intermediate_solutions
 from desdeo.problem import Problem
 from desdeo.tools import SolverResults
 from desdeo.tools.score_bands import calculate_axes_positions, cluster, order_dimensions
 
+from .utils import SessionContext, get_session_context
+
 router = APIRouter(prefix="/method/generic")
 
 
 @router.post("/intermediate")
 def solve_intermediate(
     request: IntermediateSolutionRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> GenericIntermediateSolutionResponse:
-    """Solve intermediate solutions between given two solutions."""
-    if request.session_id is not None:
-        statement = select(InteractiveSessionDB).where(InteractiveSessionDB.id == request.session_id)
-        interactive_session = session.exec(statement)
-
-        if interactive_session is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Could not find interactive session with id={request.session_id}.",
-            )
-    else:
-        # request.session_id is None:
-        # use active session instead
-        statement = select(InteractiveSessionDB).where(InteractiveSessionDB.id == user.active_session_id)
-
-        interactive_session = session.exec(statement).first()
+    """Solve intermediate solutions between given two solutions.
+
+    Args:
+        request (IntermediateSolutionRequest): The request object containing parameters
+            for fetching results.
+        context (Annotated[SessionContext, Depends]): The session context.
+    """
+    db_session = context.db_session
+    problem_db = context.problem_db
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
 
     # query both reference solutions' variable values
-    # stored as lit of tuples, first element of each tuple are variables values, second are objective function values
     var_and_obj_values_of_references: list[tuple[dict, dict]] = []
     reference_states = []
+
     for solution_info in [request.reference_solution_1, request.reference_solution_2]:
-        solution_state = session.exec(select(StateDB).where(StateDB.id == solution_info.state_id)).first()
+        solution_state = db_session.exec(select(StateDB).where(StateDB.id == solution_info.state_id)).first()
 
         if solution_state is None:
-            # no StateDB found with the given id
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Could not find a state with the given id{solution_state.state_id}.",
+                detail=f"Could not find a state with id={solution_info.state_id}.",
             )
 
         reference_states.append(solution_state)
@@ -71,7 +61,6 @@ def solve_intermediate(
         try:
             _var_values = solution_state.state.result_variable_values
             var_values = _var_values[solution_info.solution_index]
-
         except IndexError as exc:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -83,7 +72,6 @@ def solve_intermediate(
         try:
             _obj_values = solution_state.state.result_objective_values
             obj_values = _obj_values[solution_info.solution_index]
-
         except IndexError as exc:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -94,10 +82,7 @@ def solve_intermediate(
 
         var_and_obj_values_of_references.append((var_values, obj_values))
 
-    # fetch the problem from the DB
-    statement = select(ProblemDB).where(ProblemDB.user_id == user.id, ProblemDB.id == request.problem_id)
-    problem_db = session.exec(statement).first()
-
+    # Problem is now already loaded via context
     if problem_db is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -116,26 +101,9 @@ def solve_intermediate(
         solver_options=request.solver_options,
     )
 
-    # fetch parent state
-    if request.parent_state_id is None:
-        # parent state is assumed to be the last state added to the session.
-        parent_state = (
-            interactive_session.states[-1]
-            if (interactive_session is not None and len(interactive_session.states) > 0)
-            else None
-        )
-
-    else:
-        # request.parent_state_id is not None
-        statement = session.select(StateDB).where(StateDB.id == request.parent_state_id)
-        parent_state = session.exec(statement).first()
-
-        if parent_state is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Could not find state with id={request.parent_state_id}",
-            )
-
+    # --------------------------------------
+    # parent_state is already loaded in context
+    # --------------------------------------
     intermediate_state = IntermediateSolutionState(
         scalarization_options=request.scalarization_options,
         context=request.context,
@@ -149,16 +117,16 @@ def solve_intermediate(
 
     # create DB state and add it to the DB
     state = StateDB.create(
-        database_session=session,
+        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=intermediate_state,
     )
 
-    session.add(state)
-    session.commit()
-    session.refresh(state)
+    db_session.add(state)
+    db_session.commit()
+    db_session.refresh(state)
 
     return GenericIntermediateSolutionResponse(
         state_id=state.id,