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

desdeo/api/routers/nimbus.py

@@ -6,9 +6,7 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from numpy import allclose
 from sqlmodel import Session, select
 
-from desdeo.api.db import get_session
 from desdeo.api.models import (
-    InteractiveSessionDB,
     IntermediateSolutionRequest,
     NIMBUSClassificationRequest,
     NIMBUSClassificationResponse,
@@ -25,7 +23,6 @@ from desdeo.api.models import (
     NIMBUSSaveRequest,
     NIMBUSSaveResponse,
     NIMBUSSaveState,
-    ProblemDB,
     ReferencePoint,
     SavedSolutionReference,
     SolutionReference,
@@ -38,11 +35,12 @@ from desdeo.api.models.generic import SolutionInfo
 from desdeo.api.models.state import IntermediateSolutionState
 from desdeo.api.routers.generic import solve_intermediate
 from desdeo.api.routers.problem import check_solver
-from desdeo.api.routers.user_authentication import get_current_user
 from desdeo.mcdm.nimbus import generate_starting_point, solve_sub_problems
 from desdeo.problem import Problem
 from desdeo.tools import SolverResults
 
+from .utils import SessionContext, get_session_context
+
 router = APIRouter(prefix="/method/nimbus")
 
 
@@ -50,7 +48,7 @@ router = APIRouter(prefix="/method/nimbus")
 def filter_duplicates(solutions: list[SavedSolutionReference]) -> list[SavedSolutionReference]:
     """Filters out the duplicate values of objectives."""
     # No solutions or only one solution. There can not be any duplicates.
-    if len(solutions) < 2:
+    if len(solutions) < 2:  # noqa: PLR2004
         return solutions
 
     # Get the objective values
@@ -110,58 +108,24 @@ def collect_all_solutions(user: User, problem_id: int, session: Session) -> list
 @router.post("/solve")
 def solve_solutions(
     request: NIMBUSClassificationRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> NIMBUSClassificationResponse:
     """Solve the problem using the NIMBUS method."""
-    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()
-
-    # 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()
+    db_session = context.db_session
+    user = context.user
+    problem_db = context.problem_db
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
 
+    # Ensure problem exists
     if problem_db is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail=f"Problem with id={request.problem_id} could not be found."
         )
 
     solver = check_solver(problem_db=problem_db)
-
     problem = Problem.from_problemdb(problem_db)
 
-    # 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 = 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}"
-            )
-
     solver_results: list[SolverResults] = solve_sub_problems(
         problem=problem,
         current_objectives=request.current_objectives,
@@ -185,24 +149,24 @@ def solve_solutions(
 
     # 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=nimbus_state,
     )
 
-    session.add(state)
-    session.commit()
-    session.refresh(state)
+    db_session.add(state)
+    db_session.commit()
+    db_session.refresh(state)
 
     # Collect all current solutions
     current_solutions: list[SolutionReference] = []
     for i, _ in enumerate(solver_results):
         current_solutions.append(SolutionReference(state=state, solution_index=i))
 
-    saved_solutions = collect_saved_solutions(user, request.problem_id, session)
-    all_solutions = collect_all_solutions(user, request.problem_id, session)
+    saved_solutions = collect_saved_solutions(user, request.problem_id, db_session)
+    all_solutions = collect_all_solutions(user, request.problem_id, db_session)
 
     return NIMBUSClassificationResponse(
         state_id=state.id,
@@ -217,31 +181,14 @@ def solve_solutions(
 @router.post("/initialize")
 def initialize(
     request: NIMBUSInitializationRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> NIMBUSInitializationResponse:
     """Initialize the problem for the NIMBUS method."""
-    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()
-
-    print(interactive_session)
-
-    # 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()
+    db_session = context.db_session
+    user = context.user
+    problem_db = context.problem_db
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
 
     if problem_db is None:
         raise HTTPException(
@@ -249,18 +196,15 @@ def initialize(
         )
 
     solver = check_solver(problem_db=problem_db)
-
     problem = Problem.from_problemdb(problem_db)
 
     if isinstance(ref_point := request.starting_point, ReferencePoint):
-        # ReferencePoint
         starting_point = ref_point.aspiration_levels
 
     elif isinstance(info := request.starting_point, SolutionInfo):
-        # SolutionInfo
         # fetch the solution
         statement = select(StateDB).where(StateDB.id == info.state_id)
-        state = session.exec(statement).first()
+        state = db_session.exec(statement).first()
 
         if state is None:
             raise HTTPException(
@@ -270,7 +214,6 @@ def initialize(
         starting_point = state.state.result_objective_values[info.solution_index]
 
     else:
-        # if not starting point is provided, generate it
         starting_point = None
 
     start_result = generate_starting_point(
@@ -281,18 +224,6 @@ def initialize(
         solver_options=request.solver_options,
     )
 
-    # fetch parent state if it is given
-    if request.parent_state_id is None:
-        parent_state = None
-    else:
-        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}"
-            )
-
     initialization_state = NIMBUSInitializationState(
         reference_point=starting_point,
         scalarization_options=request.scalarization_options,
@@ -302,20 +233,20 @@ def initialize(
 
     # 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,
+        session_id=interactive_session.id if interactive_session else None,
+        parent_id=parent_state.id if parent_state else None,
         state=initialization_state,
     )
 
-    session.add(state)
-    session.commit()
-    session.refresh(state)
+    db_session.add(state)
+    db_session.commit()
+    db_session.refresh(state)
 
     current_solutions = [SolutionReference(state=state, solution_index=0)]
-    saved_solutions = collect_saved_solutions(user, request.problem_id, session)
-    all_solutions = collect_all_solutions(user, request.problem_id, session)
+    saved_solutions = collect_saved_solutions(user, request.problem_id, db_session)
+    all_solutions = collect_all_solutions(user, request.problem_id, db_session)
 
     return NIMBUSInitializationResponse(
         state_id=state.id,
@@ -327,40 +258,22 @@ def initialize(
 
 @router.post("/save")
 def save(
-    request: NIMBUSSaveRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    request: NIMBUSSaveRequest, context: Annotated[SessionContext, Depends(get_session_context)]
 ) -> NIMBUSSaveResponse:
     """Save 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)
+    db_session = context.db_session
+    user = context.user
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
 
-        interactive_session = session.exec(statement).first()
-
-    # 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 = select(StateDB).where(StateDB.id == request.parent_state_id)
-        parent_state = session.exec(statement).first()
+        parent_state = db_session.exec(select(StateDB).where(StateDB.id == request.parent_state_id)).first()
 
         if parent_state is None:
             raise HTTPException(
@@ -372,7 +285,7 @@ def save(
     new_solutions: list[UserSavedSolutionDB] = []
 
     for info in request.solution_info:
-        existing_solution = session.exec(
+        existing_solution = db_session.exec(
             select(UserSavedSolutionDB).where(
                 UserSavedSolutionDB.origin_state_id == info.state_id,
                 UserSavedSolutionDB.solution_index == info.solution_index,
@@ -380,42 +293,38 @@ def save(
         ).first()
 
         if existing_solution is not None:
-            # Update the name of the existing solution
             existing_solution.name = info.name
-
-            session.add(existing_solution)
-
+            db_session.add(existing_solution)
             updated_solutions.append(existing_solution)
+
         else:
-            # This is a new solution
             new_solution = UserSavedSolutionDB.from_state_info(
-                session, user.id, request.problem_id, info.state_id, info.solution_index, info.name
+                db_session, user.id, request.problem_id, info.state_id, info.solution_index, info.name
             )
 
-            session.add(new_solution)
-
+            db_session.add(new_solution)
             new_solutions.append(new_solution)
 
     # Commit existing and new solutions
-    if updated_solutions or new_solution:
-        session.commit()
-        [session.refresh(row) for row in updated_solutions + new_solutions]
+    if updated_solutions or new_solutions:
+        db_session.commit()
+        [db_session.refresh(row) for row in updated_solutions + new_solutions]
 
-    # save solver results for state in SolverResults format just for consistency (dont save name field to state)
+    # save solver results for state in SolverResults format just for consistency
     save_state = NIMBUSSaveState(solutions=updated_solutions + new_solutions)
 
     # create DB state
     state = StateDB.create(
-        database_session=session,
+        database_session=db_session,
         problem_id=request.problem_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=save_state,
     )
 
-    session.add(state)
-    session.commit()
-    session.refresh(state)
+    db_session.add(state)
+    db_session.commit()
+    db_session.refresh(state)
 
     return NIMBUSSaveResponse(state_id=state.id)
 
@@ -423,20 +332,22 @@ def save(
 @router.post("/intermediate")
 def solve_nimbus_intermediate(
     request: IntermediateSolutionRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> NIMBUSIntermediateSolutionResponse:
     """Solve intermediate solutions by forwarding the request to generic intermediate endpoint with context nimbus."""
+    db_session = context.db_session
+    user = context.user
+
     # Add NIMBUS context to request
     request.context = "nimbus"
+
     # Forward to generic endpoint
-    intermediate_response = solve_intermediate(request, user, session)
+    intermediate_response = solve_intermediate(request, context)
 
     # Get saved solutions for this user and problem
-    saved_solutions = collect_saved_solutions(user, request.problem_id, session)
-
+    saved_solutions = collect_saved_solutions(user, request.problem_id, db_session)
     # Get all solutions including the newly generated intermediate ones
-    all_solutions = collect_all_solutions(user, request.problem_id, session)
+    all_solutions = collect_all_solutions(user, request.problem_id, db_session)
 
     return NIMBUSIntermediateSolutionResponse(
         state_id=intermediate_response.state_id,
@@ -451,24 +362,17 @@ def solve_nimbus_intermediate(
 @router.post("/get-or-initialize")
 def get_or_initialize(
     request: NIMBUSInitializationRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
-) -> NIMBUSInitializationResponse | NIMBUSClassificationResponse | \
-        NIMBUSIntermediateSolutionResponse | NIMBUSFinalizeResponse:
+    context: Annotated[SessionContext, Depends(get_session_context)],
+) -> (
+    NIMBUSInitializationResponse
+    | NIMBUSClassificationResponse
+    | NIMBUSIntermediateSolutionResponse
+    | NIMBUSFinalizeResponse
+):
     """Get the latest NIMBUS state if it exists, or initialize a new one if it doesn't."""
-    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:
-        # use active session instead
-        statement = select(InteractiveSessionDB).where(InteractiveSessionDB.id == user.active_session_id)
-        interactive_session = session.exec(statement).first()
+    db_session = context.db_session
+    user = context.user
+    interactive_session = context.interactive_session
 
     # Look for latest relevant state in the session
     statement = (
@@ -479,7 +383,7 @@ def get_or_initialize(
         )
         .order_by(StateDB.id.desc())
     )
-    states = session.exec(statement).all()
+    states = db_session.exec(statement).all()
 
     # Find the latest relevant state (NIMBUS classification, initialization, or intermediate with NIMBUS context)
     latest_state = None
@@ -491,17 +395,15 @@ def get_or_initialize(
             break
 
     if latest_state is not None:
-        saved_solutions = collect_saved_solutions(user, request.problem_id, session)
-        all_solutions = collect_all_solutions(user, request.problem_id, session)
-        # Handle both single result and list of results cases
+        saved_solutions = collect_saved_solutions(user, request.problem_id, db_session)
+        all_solutions = collect_all_solutions(user, request.problem_id, db_session)
+
         solver_results = latest_state.state.solver_results
-        if isinstance(solver_results, list):
-            current_solutions = [
-                SolutionReference(state=latest_state, solution_index=i) for i in range(len(solver_results))
-            ]
-        else:
-            # Single result case (NIMBUSInitializationState)
-            current_solutions = [SolutionReference(state=latest_state, solution_index=0)]
+        current_solutions = (
+            [SolutionReference(state=latest_state, solution_index=i) for i in range(len(solver_results))]
+            if isinstance(solver_results, list)
+            else [SolutionReference(state=latest_state, solution_index=0)]
+        )
 
         if isinstance(latest_state.state, NIMBUSClassificationState):
             return NIMBUSClassificationResponse(
@@ -524,7 +426,6 @@ def get_or_initialize(
             )
 
         if isinstance(latest_state.state, NIMBUSFinalState):
-
             solution_index = latest_state.state.solution_result_index
             origin_state_id = latest_state.state.solution_origin_state_id
 
@@ -532,7 +433,7 @@ def get_or_initialize(
                 solution_index=solution_index,
                 state_id=origin_state_id,
                 objective_values=latest_state.state.solver_results.optimal_objectives,
-                variable_values=latest_state.state.solver_results.optimal_variables
+                variable_values=latest_state.state.solver_results.optimal_variables,
             )
 
             return NIMBUSFinalizeResponse(
@@ -541,7 +442,6 @@ def get_or_initialize(
                 saved_solutions=saved_solutions,
                 all_solutions=all_solutions,
             )
-
         # NIMBUSInitializationState
         return NIMBUSInitializationResponse(
             state_id=latest_state.id,
@@ -551,21 +451,18 @@ def get_or_initialize(
         )
 
     # No relevant state found, initialize a new one
-    return initialize(request, user, session)
+    return initialize(request, context)
 
 
 @router.post("/finalize")
 def finalize_nimbus(
-    request: NIMBUSFinalizeRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)]
+    request: NIMBUSFinalizeRequest, context: Annotated[SessionContext, Depends(get_session_context)]
 ) -> NIMBUSFinalizeResponse:
     """An endpoint for finishing up the nimbus process.
 
     Args:
         request (NIMBUSFinalizeRequest): The request containing the final solution, etc.
-        user (Annotated[User, Depends): The current user.
-        session (Annotated[Session, Depends): The database session.
+        context (Annotated[User, get_session_context): The current context.
 
     Raises:
         HTTPException
@@ -573,47 +470,17 @@ def finalize_nimbus(
     Returns:
         NIMBUSFinalizeResponse: Response containing info on the final solution.
     """
-    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()
-
-    if request.parent_state_id is None:
-        parent_state = None
-    else:
-        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}"
-            )
-
-    # 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()
-
-    if problem_db is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail=f"Problem with id={request.problem_id} could not be found."
-        )
+    db_session = context.db_session
+    user = context.user
+    interactive_session = context.interactive_session
+    parent_state = context.parent_state
+    problem_db = context.problem_db
 
     solution_state_id = request.solution_info.state_id
     solution_index = request.solution_info.solution_index
 
-    statement = select(StateDB).where(StateDB.id == solution_state_id)
-    actual_state = session.exec(statement).first().state
+    state = db_session.exec(select(StateDB).where(StateDB.id == solution_state_id)).first()
+    actual_state = state.state if state else None
     if actual_state is None:
         raise HTTPException(
             detail="No concrete substate!",
@@ -623,22 +490,22 @@ def finalize_nimbus(
     final_state = NIMBUSFinalState(
         solution_origin_state_id=solution_state_id,
         solution_result_index=solution_index,
-        solver_results=actual_state.solver_results[solution_index]
+        solver_results=actual_state.solver_results[solution_index],
     )
 
     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=final_state,
     )
 
-    session.add(state)
-    session.commit()
-    session.refresh(state)
+    db_session.add(state)
+    db_session.commit()
+    db_session.refresh(state)
 
-    solution_reference_response=SolutionReferenceResponse(
+    solution_reference_response = SolutionReferenceResponse(
         solution_index=solution_index,
         state_id=solution_state_id,
         objective_values=final_state.solver_results.optimal_objectives,
@@ -648,22 +515,21 @@ def finalize_nimbus(
     return NIMBUSFinalizeResponse(
         state_id=state.id,
         final_solution=solution_reference_response,
-        saved_solutions=collect_saved_solutions(user=user, problem_id=problem_db.id, session=session),
-        all_solutions=collect_all_solutions(user=user, problem_id=problem_db.id, session=session),
+        saved_solutions=collect_saved_solutions(user=user, problem_id=problem_db.id, session=db_session),
+        all_solutions=collect_all_solutions(user=user, problem_id=problem_db.id, session=db_session),
     )
 
+
 @router.post("/delete_save")
 def delete_save(
     request: NIMBUSDeleteSaveRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)]
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> NIMBUSDeleteSaveResponse:
     """Endpoint for deleting saved solutions.
 
     Args:
         request (NIMBUSDeleteSaveRequest): request containing necessary information for deleting a save
-        user (Annotated[User, Depends): the current  (logged in) user
-        session (Annotated[Session, Depends): database session
+        context (Annotated[SessionContext, Depends): session context
 
     Raises:
         HTTPException
@@ -671,7 +537,9 @@ def delete_save(
     Returns:
         NIMBUSDeleteSaveResponse: Response acknowledging the deletion of save and other useful info.
     """
-    to_be_deleted = session.exec(
+    db_session = context.db_session
+
+    to_be_deleted = db_session.exec(
         select(UserSavedSolutionDB).where(
             UserSavedSolutionDB.origin_state_id == request.state_id,
             UserSavedSolutionDB.solution_index == request.solution_index,
@@ -679,15 +547,12 @@ def delete_save(
     ).first()
 
     if to_be_deleted is None:
-        raise HTTPException(
-            detail="Unable to find a saved solution!",
-            status_code=status.HTTP_404_NOT_FOUND
-        )
+        raise HTTPException(detail="Unable to find a saved solution!", status_code=status.HTTP_404_NOT_FOUND)
 
-    session.delete(to_be_deleted)
-    session.commit()
+    db_session.delete(to_be_deleted)
+    db_session.commit()
 
-    to_be_deleted = session.exec(
+    to_be_deleted = db_session.exec(
         select(UserSavedSolutionDB).where(
             UserSavedSolutionDB.origin_state_id == request.state_id,
             UserSavedSolutionDB.solution_index == request.solution_index,
@@ -696,10 +561,6 @@ def delete_save(
 
     if to_be_deleted is not None:
         raise HTTPException(
-            detail="Could not delete the saved solution!",
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            detail="Could not delete the saved solution!", status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
         )
-
-    return NIMBUSDeleteSaveResponse(
-        message="Save deleted."
-    )
+    return NIMBUSDeleteSaveResponse(message="Save deleted.")