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

desdeo/api/models/state.py

@@ -0,0 +1,96 @@
+"""Defines models for representing the state of various interactive methods."""
+
+from typing import Literal
+
+from sqlalchemy.types import TypeDecorator
+from sqlmodel import JSON, Column, Field, Relationship, SQLModel
+
+from desdeo.tools import SolverResults
+
+from .preference import PreferenceDB, ReferencePoint
+from .problem import ProblemDB
+from .session import InteractiveSessionDB
+
+
+class StateType(TypeDecorator):
+    """SQLAlchemy custom type to convert states to JSON and back."""
+
+    impl = JSON
+
+    def process_bind_param(self, value, dialect):
+        """State to JSON."""
+        if isinstance(value, RPMState):
+            return value.model_dump()
+
+        msg = f"No JSON serialization set for ste of type '{type(value)}'."
+        print(msg)
+
+        return value
+
+    def process_result_value(self, value, dialect):
+        """JSON to state."""
+        if "method" in value:
+            match value["method"]:
+                case "reference_point_method":
+                    return RPMState.model_validate(value)
+                case _:
+                    msg = f"No method '{value["method"]}' found."
+                    print(msg)
+
+        return value
+
+
+class BaseState(SQLModel):
+    """The base model for representing method state."""
+
+    method: Literal["unset"] = "unset"
+    phase: Literal["unset"] = "unset"
+
+
+class RPMBaseState(BaseState):
+    """The base sate for the reference point method (RPM).
+
+    Other states of the RPM should inherit from this.
+    """
+
+    method: Literal["reference_point_method"] = "reference_point_method"
+
+
+class RPMState(RPMBaseState):
+    """State of the reference point method for computing solutions."""
+
+    phase: Literal["solve_candidates"] = "solve_candidates"
+
+    # to compute k+1 solutions
+    scalarization_options: dict[str, float | str | bool] | None = Field(sa_column=Column(JSON), default=None)
+    solver: str | None = Field(default=None)
+    solver_options: dict[str, float | str | bool] | None = Field(sa_column=Column(JSON), default=None)
+
+    # results
+    solver_results: list[SolverResults] = Field(sa_column=Column(JSON))
+
+
+class StateDB(SQLModel, table=True):
+    """Database model to store interactive method state."""
+
+    id: int | None = Field(primary_key=True, default=None)
+    problem_id: int | None = Field(foreign_key="problemdb.id", default=None)
+    preference_id: int | None = Field(foreign_key="preferencedb.id", default=None)
+    session_id: int | None = Field(foreign_key="interactivesessiondb.id", default=None)
+
+    # Reference to other StateDB
+    parent_id: int | None = Field(foreign_key="statedb.id", default=None)
+
+    state: BaseState | None = Field(sa_column=Column(StateType), default=None)
+
+    # Back populates
+    session: "InteractiveSessionDB" = Relationship(back_populates="states")
+    parent: "StateDB" = Relationship(back_populates="children", sa_relationship_kwargs={"remote_side": "StateDB.id"})
+    # if a parent node is killed, so are all its children (blood for the blood God)
+    children: list["StateDB"] = Relationship(
+        back_populates="parent", sa_relationship_kwargs={"cascade": "all, delete-orphan"}
+    )
+
+    # Parents
+    preference: "PreferenceDB" = Relationship()
+    problem: "ProblemDB" = Relationship()

desdeo/api/models/user.py

@@ -0,0 +1,51 @@
+"""Defines user models."""
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from sqlmodel import Field, Relationship, SQLModel
+
+if TYPE_CHECKING:
+    from .archive import ArchiveEntryDB
+    from .preference import PreferenceDB
+    from .schemas import ProblemDB
+    from .session import InteractiveSessionDB
+
+
+class UserRole(str, Enum):
+    """Possible user roles."""
+
+    guest = "guest"
+    dm = "dm"
+    analyst = "analyst"
+    admin = "admin"
+
+
+class UserBase(SQLModel):
+    """Base user object."""
+
+    username: str = Field(index=True)
+
+
+class User(UserBase, table=True):
+    """The table model of the user stored in the database."""
+
+    id: int | None = Field(primary_key=True, default=None)
+    password_hash: str = Field()
+    role: UserRole = Field()
+    group: str = Field(default="")
+    active_session_id: int | None = Field(default=None)
+
+    # Back populates
+    archive: list["ArchiveEntryDB"] = Relationship(back_populates="user")
+    preferences: list["PreferenceDB"] = Relationship(back_populates="user")
+    problems: list["ProblemDB"] = Relationship(back_populates="user")
+    sessions: list["InteractiveSessionDB"] = Relationship(back_populates="user")
+
+
+class UserPublic(UserBase):
+    """The object to handle public user information."""
+
+    id: int
+    role: UserRole
+    group: str

desdeo/api/routers/_NAUTILUS.py

@@ -0,0 +1,245 @@
+"""Endpoints for NAUTILUS ."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field, ValidationError
+from sqlalchemy.orm import Session
+
+from desdeo.api.db import get_db
+from desdeo.api.db_models import Problem as ProblemInDB
+from desdeo.api.db_models import Results
+from desdeo.api.routers.user_authentication import get_current_user
+from desdeo.api.schema import User
+from desdeo.mcdm.nautilus import (
+    NAUTILUS_Response,
+    get_current_path,
+    nautilus_init,
+    nautilus_step,
+    points_to_weights,
+    ranks_to_weights,
+    step_back_index,
+)
+from desdeo.problem.schema import Problem
+
+router = APIRouter(prefix="/nautilus")
+
+
+class InitRequest(BaseModel):
+    """The request to initialize the NAUTILUS."""
+
+    problem_id: int = Field(description="The ID of the problem to navigate.")
+    # TODO: IS total_steps needed for NAUTILUS, what is good default? now its 5.
+    total_steps: int | None = Field(
+        description=("The total number of steps in the NAUTILUS. The default value is 5."), default=5
+    )
+
+
+class NavigateRequest(BaseModel):
+    """The request to navigate the NAUTILUS."""
+
+    problem_id: int = Field(description="The ID of the problem to navigate.")
+    points: dict[str, float] | None = Field(
+        description=(
+            "Preference in the form of points given to the objectives."
+            " Higher is better. Must sum up to 100. Only one of points or ranks can be given."
+        )
+    )
+    ranks: dict[str, int] | None = Field(
+        description=(
+            "Preference in the form of ranks given to the objectives. Higher is better."
+            "Must be integers between 1 and the number of objectives. Ranks need not be unique, consecutive."
+        )
+    )
+    calculate_step: int = Field(description="The step index to calculate. Starts from 1. Max = total_steps.")
+    steps_remaining: int = Field(
+        description="The number of steps remaining. Should be total_steps - calculate_step + 1."
+    )
+
+
+class InitialResponse(BaseModel):
+    """The response from the initial endpoint of NAUTILUS."""
+
+    objective_symbols: list[str] = Field(description="The symbols/short names of the objectives.")
+    objective_long_names: list[str] = Field(description="Long/descriptive names of the objectives.")
+    units: list[str] | None = Field(description="The units of the objectives.")
+    is_maximized: list[bool] = Field(description="Whether the objectives are to be maximized or minimized.")
+    ideal: list[float] = Field(description="The ideal values of the objectives.")
+    nadir: list[float] = Field(description="The nadir values of the objectives.")
+    total_steps: int = Field(description="The total number of steps in the NAUTILUS Navigator.")
+    distance_to_front: float | None = Field(description="The distance to the front of the reachable region.")
+
+
+class Response(InitialResponse):
+    """The response from most NAUTILUS endpoints.
+
+    Contains information about the full navigation process.
+    """
+
+    lower_bounds: dict[str, list[float]] = Field(description="The lower bounds of the reachable region.")
+    upper_bounds: dict[str, list[float]] = Field(description="The upper bounds of the reachable region.")
+    preferences: dict[str, list[float]] = Field(description="The preferences used in each step.")
+
+    # TODO: ALL ABOVE SHOULD BE FINE
+
+
+@router.post("/initialize")
+def init_nautilus(
+    init_request: InitRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    db: Annotated[Session, Depends(get_db)],
+) -> InitialResponse:
+    """Initialize the NAUTILUS.
+
+    Args:
+        init_request (InitRequest): The request to initialize the NAUTILUS.
+        user (Annotated[User, Depends(get_current_user)]): The current user.
+        db (Annotated[Session, Depends(get_db)]): The database session.
+
+    Returns:
+        InitialResponse: The initial response from the NAUTILUS.
+    """
+    problem_id = init_request.problem_id
+    problem = db.query(ProblemInDB).filter(ProblemInDB.id == problem_id).first()
+
+    if problem is None:
+        raise HTTPException(status_code=404, detail="Problem not found.")
+    if problem.owner != user.index and problem.owner is not None:
+        raise HTTPException(status_code=403, detail="Unauthorized to access chosen problem.")
+    try:
+        problem = Problem.model_validate(problem.value)
+    except ValidationError:
+        raise HTTPException(status_code=500, detail="Error in parsing the problem.") from ValidationError
+
+    response = nautilus_init(problem)
+
+    # Get and delete all Results from previous runs of NAUTILUS
+    results = db.query(Results).filter(Results.problem == problem_id).filter(Results.user == user.index).all()
+    for result in results:
+        db.delete(result)
+    db.commit()
+
+    new_result = Results(
+        user=user.index,
+        problem=problem_id,
+        value=response.model_dump(mode="json"),
+    )
+    db.add(new_result)
+    db.commit()
+
+    return InitialResponse(
+        objective_symbols=[obj.symbol for obj in problem.objectives],
+        objective_long_names=[obj.name for obj in problem.objectives],
+        units=[obj.unit for obj in problem.objectives],
+        is_maximized=[obj.maximize for obj in problem.objectives],
+        ideal=[obj.ideal for obj in problem.objectives],
+        nadir=[obj.nadir for obj in problem.objectives],
+        total_steps=init_request.total_steps,
+        distance_to_front=response.distance_to_front,
+    )
+
+
+@router.post("/iterate")
+def iterate(
+    request: NavigateRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    db: Annotated[Session, Depends(get_db)],
+) -> Response:
+    """Navigate the NAUTILUS.
+
+    Runs the NAUTILUS algorithm one step at a time.
+
+    Args:
+        request (NavigateRequest): The request to navigate the NAUTILUS 1.
+
+    Raises:
+        HTTPException: _description_
+        HTTPException: _description_
+        HTTPException: _description_
+        HTTPException: _description_
+
+    Returns:
+        Response: _description_
+    """
+    problem_id, ranks, points, calculate_step, steps_remaining = (
+        request.problem_id,
+        request.ranks,
+        request.points,
+        request.calculate_step,
+        request.steps_remaining,
+    )
+
+    if ranks is not None and points is not None:
+        raise HTTPException(status_code=400, detail="Both ranks and points cannot be given.")
+    if ranks is None and points is None:
+        raise HTTPException(status_code=400, detail="Either ranks or points must be given.")
+
+    problem = db.query(ProblemInDB).filter(ProblemInDB.id == problem_id).first()
+    if problem is None:
+        raise HTTPException(status_code=404, detail="Problem not found.")
+    if problem.owner != user.index and problem.owner is not None:
+        raise HTTPException(status_code=403, detail="Unauthorized to access chosen problem.")
+    try:
+        problem = Problem.model_validate(problem.value)
+    except ValidationError:
+        raise HTTPException(status_code=500, detail="Error in parsing the problem.") from ValidationError
+
+    results = db.query(Results).filter(Results.problem == problem_id).filter(Results.user == user.index).all()
+    if not results:
+        raise HTTPException(status_code=404, detail="NAUTILUS 1 not initialized.")
+
+    responses = [NAUTILUS_Response.model_validate(result.value) for result in results]
+
+    step_to_append_index = step_back_index(responses, calculate_step - 1)
+
+    if step_to_append_index < len(responses) - 1:
+        responses.append(responses[step_back_index(responses, calculate_step - 1)])
+
+    try:
+        new_response = nautilus_step(
+            problem,
+            step_number=calculate_step,
+            steps_remaining=steps_remaining,
+            nav_point=responses[-1].navigation_point,
+            ranks=ranks,
+            points=points,
+        )
+    except IndexError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+
+    new_result = Results(
+        user=user.index,
+        problem=problem_id,
+        value=new_response.model_dump(mode="json"),
+    )
+    db.add(new_result)
+    db.commit()
+
+    responses = [*responses, new_response]
+    current_path = get_current_path(responses)
+    active_responses = [responses[i] for i in current_path]
+    lower_bounds = {}
+    upper_bounds = {}
+    preferences = {}
+    for obj in problem.objectives:
+        lower_bounds[obj.symbol] = [
+            response.reachable_bounds["lower_bounds"][obj.symbol] for response in active_responses
+        ]
+        upper_bounds[obj.symbol] = [
+            response.reachable_bounds["upper_bounds"][obj.symbol] for response in active_responses
+        ]
+        preferences[obj.symbol] = [response.preference[obj.symbol] for response in active_responses[1:]]
+
+    return Response(
+        objective_symbols=[obj.symbol for obj in problem.objectives],
+        objective_long_names=[obj.name for obj in problem.objectives],
+        units=[obj.unit for obj in problem.objectives],
+        is_maximized=[obj.maximize for obj in problem.objectives],
+        ideal=[obj.ideal for obj in problem.objectives],
+        nadir=[obj.nadir for obj in problem.objectives],
+        lower_bounds=lower_bounds,
+        upper_bounds=upper_bounds,
+        preferences=preferences,
+        total_steps=len(active_responses) - 1,
+        distance_to_front=active_responses[-1].distance_to_front,
+    )

desdeo/api/routers/_NAUTILUS_navigator.py

@@ -0,0 +1,233 @@
+"""Endpoints for NAUTILUS Navigator."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field, ValidationError
+from sqlalchemy.orm import Session
+
+from desdeo.api.db import get_db
+from desdeo.api.db_models import Problem as ProblemInDB
+from desdeo.api.db_models import Results
+from desdeo.api.routers.user_authentication import get_current_user
+from desdeo.api.schema import User
+from desdeo.mcdm.nautilus_navigator import (
+    NAUTILUS_Response,
+    get_current_path,
+    navigator_all_steps,
+    navigator_init,
+    step_back_index,
+)
+from desdeo.problem.schema import Problem
+
+router = APIRouter(prefix="/nautnavi")
+
+
+class InitRequest(BaseModel):
+    """The request to initialize the NAUTILUS Navigator."""
+
+    problem_id: int = Field(description="The ID of the problem to navigate.")
+    """The ID of the problem to navigate."""
+    total_steps: int = Field(
+        description="The total number of steps in the NAUTILUS Navigator. The default value is 100.", default=100
+    )
+    "The total number of steps in the NAUTILUS Navigator. The default value is 100."
+
+
+class NavigateRequest(BaseModel):
+    """The request to navigate the NAUTILUS Navigator."""
+
+    problem_id: int = Field(description="The ID of the problem to navigate.")
+    preference: dict[str, float] = Field(description="The preference of the DM.")
+    bounds: dict[str, float] = Field(description="The bounds preference of the DM.")
+    go_back_step: int = Field(description="The step index to go back.")
+    steps_remaining: int = Field(description="The number of steps remaining. Should be total_steps - go_back_step.")
+
+
+class InitialResponse(BaseModel):
+    """The response from the initial endpoint of NAUTILUS Navigator."""
+
+    objective_symbols: list[str] = Field(description="The symbols of the objectives.")
+    objective_long_names: list[str] = Field(description="Long/descriptive names of the objectives.")
+    units: list[str] | None = Field(description="The units of the objectives.")
+    is_maximized: list[bool] = Field(description="Whether the objectives are to be maximized or minimized.")
+    ideal: list[float] = Field(description="The ideal values of the objectives.")
+    nadir: list[float] = Field(description="The nadir values of the objectives.")
+    total_steps: int = Field(description="The total number of steps in the NAUTILUS Navigator.")
+
+
+class Response(BaseModel):
+    """The response from most NAUTILUS Navigator endpoints.
+
+    Contains information about the full navigation process.
+    """
+
+    objective_symbols: list[str] = Field(description="The symbols of the objectives.")
+    objective_long_names: list[str] = Field(description="Long/descriptive names of the objectives.")
+    units: list[str] | None = Field(description="The units of the objectives.")
+    is_maximized: list[bool] = Field(description="Whether the objectives are to be maximized or minimized.")
+    ideal: list[float] = Field(description="The ideal values of the objectives.")
+    nadir: list[float] = Field(description="The nadir values of the objectives.")
+    lower_bounds: dict[str, list[float]] = Field(description="The lower bounds of the reachable region.")
+    upper_bounds: dict[str, list[float]] = Field(description="The upper bounds of the reachable region.")
+    preferences: dict[str, list[float]] = Field(description="The preferences used in each step.")
+    bounds: dict[str, list[float]] = Field(description="The bounds preference of the DM.")
+    total_steps: int = Field(description="The total number of steps in the NAUTILUS Navigator.")
+    reachable_solution: dict = Field(description="The solution reached at the end of navigation.")
+
+
+@router.post("/initialize")
+def init_navigator(
+    init_request: InitRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    db: Annotated[Session, Depends(get_db)],
+) -> InitialResponse:
+    """Initialize the NAUTILUS Navigator.
+
+    Args:
+        init_request (InitRequest): The request to initialize the NAUTILUS Navigator.
+        user (Annotated[User, Depends(get_current_user)]): The current user.
+        db (Annotated[Session, Depends(get_db)]): The database session.
+
+    Returns:
+        InitialResponse: The initial response from the NAUTILUS Navigator.
+    """
+    problem_id = init_request.problem_id
+    problem = db.query(ProblemInDB).filter(ProblemInDB.id == problem_id).first()
+
+    if problem is None:
+        raise HTTPException(status_code=404, detail="Problem not found.")
+    if problem.owner != user.index and problem.owner is not None:
+        raise HTTPException(status_code=403, detail="Unauthorized to access chosen problem.")
+    if problem.value is None:
+        raise HTTPException(status_code=500, detail="Problem not found.")
+    try:
+        problem = Problem.model_validate(problem.value)  # Ignore the mypy error here for now.
+    except ValidationError:
+        raise HTTPException(status_code=500, detail="Error in parsing the problem.") from ValidationError
+
+    response = navigator_init(problem)
+
+    # Get and delete all Results from previous runs of NAUTILUS Navigator
+    results = db.query(Results).filter(Results.problem == problem_id).filter(Results.user == user.index).all()
+    for result in results:
+        db.delete(result)
+    db.commit()
+
+    new_result = Results(
+        user=user.index,
+        problem=problem_id,
+        value=response.model_dump(mode="json"),
+    )
+    db.add(new_result)
+    db.commit()
+
+    return InitialResponse(
+        objective_symbols=[obj.symbol for obj in problem.objectives],
+        objective_long_names=[obj.name for obj in problem.objectives],
+        units=[obj.unit or "" for obj in problem.objectives],  # For unitless objectives, return an empty string
+        is_maximized=[obj.maximize for obj in problem.objectives],
+        ideal=[obj.ideal for obj in problem.objectives],
+        nadir=[obj.nadir for obj in problem.objectives],
+        total_steps=init_request.total_steps,
+    )
+
+
+@router.post("/navigate")
+def navigate(
+    request: NavigateRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    db: Annotated[Session, Depends(get_db)],
+) -> Response:
+    """Navigate the NAUTILUS Navigator.
+
+    Runs the entire navigation process.
+
+    Args:
+        request (NavigateRequest): The request to navigate the NAUTILUS Navigator.
+
+    Raises:
+        HTTPException: _description_
+        HTTPException: _description_
+        HTTPException: _description_
+        HTTPException: _description_
+
+    Returns:
+        Response: _description_
+    """
+    problem_id, preference, go_back_step, steps_remaining, bounds = (
+        request.problem_id,
+        request.preference,
+        request.go_back_step,
+        request.steps_remaining,
+        request.bounds,
+    )
+    problem = db.query(ProblemInDB).filter(ProblemInDB.id == problem_id).first()
+    if problem is None:
+        raise HTTPException(status_code=404, detail="Problem not found.")
+    if problem.owner != user.index and problem.owner is not None:
+        raise HTTPException(status_code=403, detail="Unauthorized to access chosen problem.")
+    try:
+        problem = Problem.model_validate(problem.value)  # Ignore the mypy error here for now.
+    except ValidationError:
+        raise HTTPException(status_code=500, detail="Error in parsing the problem.") from ValidationError
+
+    results = db.query(Results).filter(Results.problem == problem_id).filter(Results.user == user.index).all()
+    if not results:
+        raise HTTPException(status_code=404, detail="NAUTILUS Navigator not initialized.")
+
+    responses = [NAUTILUS_Response.model_validate(result.value) for result in results]
+
+    responses.append(responses[step_back_index(responses, go_back_step)])
+
+    try:
+        new_responses = navigator_all_steps(
+            problem,
+            steps_remaining=steps_remaining,
+            reference_point=preference,
+            previous_responses=responses,
+            bounds=bounds,
+        )
+    except IndexError as e:
+        raise HTTPException(status_code=400, detail="Possible reason for error: bounds are too restrictive.") from e
+
+    for response in new_responses:
+        new_result = Results(
+            user=user.index,
+            problem=problem_id,
+            value=response.model_dump(mode="json"),
+        )
+        db.add(new_result)
+    db.commit()
+
+    responses = [*responses, *new_responses]
+    current_path = get_current_path(responses)
+    active_responses = [responses[i] for i in current_path]
+    lower_bounds = {}
+    upper_bounds = {}
+    preferences = {}
+    bounds = {}
+    for obj in problem.objectives:
+        lower_bounds[obj.symbol] = [
+            response.reachable_bounds["lower_bounds"][obj.symbol] for response in active_responses
+        ]
+        upper_bounds[obj.symbol] = [
+            response.reachable_bounds["upper_bounds"][obj.symbol] for response in active_responses
+        ]
+        preferences[obj.symbol] = [response.reference_point[obj.symbol] for response in active_responses[1:]]
+        bounds[obj.symbol] = [response.bounds[obj.symbol] for response in active_responses[1:]]
+
+    return Response(
+        objective_symbols=[obj.symbol for obj in problem.objectives],
+        objective_long_names=[obj.name for obj in problem.objectives],
+        units=[obj.unit or "" for obj in problem.objectives],
+        is_maximized=[obj.maximize for obj in problem.objectives],
+        ideal=[obj.ideal for obj in problem.objectives],
+        nadir=[obj.nadir for obj in problem.objectives],
+        lower_bounds=lower_bounds,
+        upper_bounds=upper_bounds,
+        bounds=bounds,
+        preferences=preferences,
+        total_steps=len(active_responses) - 1,
+        reachable_solution=active_responses[-1].reachable_solution,
+    )