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

desdeo/api/routers/problem.py

@@ -1,18 +1,63 @@
 """Defines end-points to access and manage problems."""
 
+import json
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlmodel import Session
+from fastapi import APIRouter, Depends, HTTPException, Request, UploadFile, status
+from fastapi.responses import JSONResponse
+from sqlmodel import Session, select
 
 from desdeo.api.db import get_session
-from desdeo.api.models import ProblemDB, ProblemGetRequest, ProblemInfo, ProblemInfoSmall, User, UserRole
+from desdeo.api.models import (
+    ForestProblemMetaData,
+    ProblemDB,
+    ProblemGetRequest,
+    ProblemInfo,
+    ProblemInfoSmall,
+    ProblemMetaDataDB,
+    ProblemMetaDataGetRequest,
+    ProblemSelectSolverRequest,
+    RepresentativeNonDominatedSolutions,
+    SolverSelectionMetadata,
+    User,
+    UserRole,
+)
 from desdeo.api.routers.user_authentication import get_current_user
 from desdeo.problem import Problem
+from desdeo.tools.utils import available_solvers
 
 router = APIRouter(prefix="/problem")
 
 
+def check_solver(problem_db: ProblemDB):
+    """Check if a preferred solver is set in the metadata.
+
+    Check if a preferred solver is set in the metadata.
+    If it exist, fetch its constructor and return it. Otherwise return None.
+    """
+    metadata: ProblemMetaDataDB = problem_db.problem_metadata
+    solver_metadata = None
+    if metadata is not None:
+        solver_metadata_list = [
+            metadata for metadata in metadata.all_metadata if metadata.metadata_type == "solver_selection_metadata"
+        ]
+        if solver_metadata_list != []:
+            solver_metadata = solver_metadata_list[-1]
+
+    if solver_metadata is not None:
+        solver = available_solvers[solver_metadata.solver_string_representation]["constructor"]
+    else:
+        solver = None
+    return solver
+
+
+# This is needed, because otherwise fields ending in an underscore fail to parse.
+async def parse_problem_json(request: Request) -> Problem:
+    """Helper function to pass by_name=True to model_validate when coercing the json object to a Problem object."""
+    data: dict = await request.json()
+    return Problem.model_validate(data, by_name=True)
+
+
 @router.get("/all")
 def get_problems(user: Annotated[User, Depends(get_current_user)]) -> list[ProblemInfoSmall]:
     """Get information on all the current user's problems.
@@ -71,7 +116,7 @@ def get_problem(
 
 @router.post("/add")
 def add_problem(
-    request: Problem,
+    request: Annotated[Problem, Depends(parse_problem_json)],
     user: Annotated[User, Depends(get_current_user)],
     session: Annotated[Session, Depends(get_session)],
 ) -> ProblemInfo:
@@ -108,3 +153,155 @@ def add_problem(
     session.refresh(problem_db)
 
     return problem_db
+
+
+@router.post("/add_json")
+def add_problem_json(
+    json_file: UploadFile,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_session)],
+) -> ProblemInfo:
+    """Adds a problem to the database based on its JSON definition.
+
+    Args:
+        json_file (UploadFile): a file in JSON format describing the problem.
+        user (Annotated[User, Depends): the usr for which the problem is added.
+        session (Annotated[Session, Depends): the database session.
+
+    Raises:
+        HTTPException: if the provided `json_file` is empty.
+        HTTPException: if the content in the provided `json_file` is not in JSON format.__annotations__
+
+    Returns:
+        ProblemInfo: a description of the added problem.
+    """
+    raw = json_file.file.read()
+
+    if not raw:
+        raise HTTPException(400, "Empty upload.")
+
+    try:
+        # for extra validation
+        json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise HTTPException(400, "Invalid JSON.") from e
+
+    problem = Problem.model_validate_json(raw, by_name=True)
+    problem_db = ProblemDB.from_problem(problem, user=user)
+
+    session.add(problem_db)
+    session.commit()
+    session.refresh(problem_db)
+
+    return problem_db
+
+
+@router.post("/get_metadata")
+def get_metadata(
+    request: ProblemMetaDataGetRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_session)],
+) -> list[ForestProblemMetaData | RepresentativeNonDominatedSolutions | SolverSelectionMetadata]:
+    """Fetch specific metadata for a specific problem.
+
+    Fetch specific metadata for a specific problem. See all the possible
+    metadata types from DESDEO/desdeo/api/models/problem.py Problem Metadata
+    section.
+
+    Args:
+        request (MetaDataGetRequest): the requested metadata type.
+        user (Annotated[User, Depends]): the current user.
+        session (Annotated[Session, Depends]): the database session.
+
+    Returns:
+        list[ForestProblemMetadata | RepresentativeNonDominatedSolutions]: list containing all the metadata
+            defined for the problem with the requested metadata type. If no match is found,
+            returns an empty list.
+    """
+    statement = select(ProblemDB).where(ProblemDB.id == request.problem_id)
+    problem_from_db = session.exec(statement).first()
+    if problem_from_db is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Problem with ID {request.problem_id} not found!"
+        )
+
+    problem_metadata = problem_from_db.problem_metadata
+
+    if problem_metadata is None:
+        # no metadata define for the problem
+        return []
+
+    # metadata is defined, try to find matching types based on request
+    return [metadata for metadata in problem_metadata.all_metadata if metadata.metadata_type == request.metadata_type]
+
+
+@router.get("/assign/solver", response_model=list[str])
+def get_available_solvers() -> list[str]:
+    """Return the list of available solver names."""
+    return list(available_solvers.keys())
+
+@router.post("/assign_solver")
+def select_solver(
+    request: ProblemSelectSolverRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_session)],
+) -> JSONResponse:
+    """Assign a specific solver for a problem.
+
+    request: ProblemSelectSolverRequest: The request containing problem id and string representation of the solver
+    user: Annotated[User, Depends(get_current_user): The user that is logged in.
+    session: Annotated[Session, Depends(get_session)]: The database session.
+
+    Raises:
+        HTTPException: Unknown solver, unauthorized user
+
+    Returns:
+        JSONResponse: A simple confirmation.
+    """
+    if request.solver_string_representation not in [x for x, _ in available_solvers.items()]:
+        raise HTTPException(
+            detail=f"Solver of unknown type: {request.solver_string_representation}",
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+
+    """Set a specific solver for a specific problem."""
+    # Get the problem
+    problem_db = session.exec(select(ProblemDB).where(ProblemDB.id == request.problem_id)).first()
+    if problem_db is None:
+        raise HTTPException(
+            detail=f"No problem with ID {request.problem_id}!",
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+    # Auth the user
+    if user.id != problem_db.user_id:
+        raise HTTPException(detail="Unauthorized user!", status_code=status.HTTP_401_UNAUTHORIZED)
+
+    # All good, get on with it.
+    problem_metadata = problem_db.problem_metadata
+    if problem_metadata is None:
+        # There's no metadata for this problem! Create some.
+        problem_metadata = ProblemMetaDataDB(problem_id=problem_db.id, problem=problem_db)
+        session.add(problem_metadata)
+        session.commit()
+        session.refresh(problem_metadata)
+
+    if problem_metadata.solver_selection_metadata:
+        session.delete(problem_metadata.solver_selection_metadata[-1])
+        session.commit()
+
+    solver_selection_metadata = SolverSelectionMetadata(
+        metadata_id=problem_metadata.id,
+        solver_string_representation=request.solver_string_representation,
+        metadata_instance=problem_metadata,
+    )
+
+    session.add(solver_selection_metadata)
+    session.commit()
+    session.refresh(solver_selection_metadata)
+
+    problem_metadata.solver_selection_metadata.append(solver_selection_metadata)
+    session.add(problem_metadata)
+    session.commit()
+    session.refresh(problem_metadata)
+
+    return JSONResponse(content={"message": "OK"}, status_code=status.HTTP_200_OK)

desdeo/api/routers/reference_point_method.py

@@ -2,8 +2,8 @@
 
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlmodel import Session, select
+from fastapi import APIRouter, Depends
+from sqlmodel import Session
 
 from desdeo.api.db import get_session
 from desdeo.api.models import (
@@ -15,11 +15,14 @@ from desdeo.api.models import (
     StateDB,
     User,
 )
+from desdeo.api.routers.problem import check_solver
 from desdeo.api.routers.user_authentication import get_current_user
 from desdeo.mcdm import rpm_solve_solutions
 from desdeo.problem import Problem
 from desdeo.tools import SolverResults
 
+from .utils import fetch_interactive_session, fetch_parent_state, fetch_user_problem
+
 router = APIRouter(prefix="/method/rpm")
 
 
@@ -29,32 +32,24 @@ def solve_solutions(
     user: Annotated[User, Depends(get_current_user)],
     session: Annotated[Session, Depends(get_session)],
 ) -> RPMState:
-    """."""
-
-    if request.session_id is not None:
-        statement = select(InteractiveSessionDB).where(InteractiveSessionDB.id == request.session_id)
-        interactive_session = session.exec(statement)
+    """Runs an iteration of the reference point method.
 
-        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)
+    Args:
+        request (RPMSolveRequest): a request with the needed information to run the method.
+        user (Annotated[User, Depends): the current user.
+        session (Annotated[Session, Depends): the current database session.
 
-        interactive_session = session.exec(statement).first()
+    Returns:
+        RPMState: a state with information on the results of iterating the reference point method
+            once.
+    """
+    # fetch interactive session, parent state, and ProblemDB
+    interactive_session: InteractiveSessionDB = fetch_interactive_session(user, request, session)
+    parent_state = fetch_parent_state(user, request, session, 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()
+    problem_db: ProblemDB = fetch_user_problem(user, request, session)
 
-    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)
 
@@ -63,7 +58,7 @@ def solve_solutions(
         problem,
         request.preference.aspiration_levels,
         request.scalarization_options,
-        request.solver,
+        solver,
         request.solver_options,
     )
 
@@ -74,25 +69,6 @@ def solve_solutions(
     session.commit()
     session.refresh(preference_db)
 
-    # fetch parent state
-    if request.parent_state_id is None:
-        # parent state is assumed to be the last sate 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}"
-            )
-
     # create state and add to DB
     rpm_state = RPMState(
         scalarization_options=request.scalarization_options,

desdeo/api/routers/session.py

@@ -5,7 +5,7 @@ from typing import Annotated
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlmodel import Session, select
 
-from desdeo.api.db import get_session
+from desdeo.api.db import get_session as get_db_session
 from desdeo.api.models import (
     CreateSessionRequest,
     GetSessionRequest,
@@ -14,6 +14,7 @@ from desdeo.api.models import (
     User,
 )
 from desdeo.api.routers.user_authentication import get_current_user
+from desdeo.api.routers.utils import fetch_interactive_session
 
 router = APIRouter(prefix="/session")
 
@@ -22,7 +23,7 @@ router = APIRouter(prefix="/session")
 def create_new_session(
     request: CreateSessionRequest,
     user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    session: Annotated[Session, Depends(get_db_session)],
 ) -> InteractiveSessionInfo:
     """."""
     interactive_session = InteractiveSessionDB(user_id=user.id, info=request.info)
@@ -40,37 +41,60 @@ def create_new_session(
     return interactive_session
 
 
-@router.post("/get")
+@router.get("/get/{session_id}")
 def get_session(
-    request: GetSessionRequest,
+    session_id: int,
     user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    session: Annotated[Session, Depends(get_db_session)],
 ) -> InteractiveSessionInfo:
-    """Return an interactive session with a given id for the current user.
-
-    Args:
-        request (GetSessionRequest): a request containing the id of the session.
-        user (Annotated[User, Depends): the current user.
-        session (Annotated[Session, Depends): the database session.
-
-    Raises:
-        HTTPException: could not find an interactive session with the given id
-            for the current user.
-
-    Returns:
-        InteractiveSessionInfo: info on the requested interactive session.
-    """
-    statement = select(InteractiveSessionDB).where(
-        InteractiveSessionDB.id == request.session_id, InteractiveSessionDB.user_id == user.id
+    """Return an interactive session with a current user."""
+    request = GetSessionRequest(session_id=session_id)
+    return fetch_interactive_session(
+        user=user,
+        request=request,
+        session=session,
     )
-    result = session.exec(statement)
 
-    interactive_session = result.first()
 
-    if interactive_session is None:
+@router.get("/get_all", status_code=status.HTTP_200_OK)
+def get_all_sessions(
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_db_session)],
+) -> list[InteractiveSessionInfo]:
+    """Return all interactive sessions of the current user."""
+    statement = select(InteractiveSessionDB).where(InteractiveSessionDB.user_id == user.id)
+    result = session.exec(statement).all()
+
+    if not result:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Could not find interactive session with id={request.session_id}.",
+            detail="No interactive sessions found for the user.",
         )
 
-    return interactive_session
+    return result
+
+
+@router.delete("/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_session(
+    session_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_db_session)],
+) -> None:
+    """Delete an interactive session and all its related states."""
+    request = GetSessionRequest(session_id=session_id)
+
+    interactive_session = fetch_interactive_session(
+        user=user,
+        request=request,
+        session=session,
+    )  # raises 404 if not found
+
+    try:
+        session.delete(interactive_session)
+        session.commit()
+    except Exception as exc:
+        session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete interactive session.",
+        ) from exc