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

desdeo/api/schema.py

@@ -47,8 +47,7 @@ class Methods(str, Enum):
     NAUTILUS = "nautilus"
     NAUT_NAVIGATOR = "NAUTILUS navigator"
     NAUTILUSII = "nautilusII"
-    RVEA = "RVEA"
-    NSGAIII = "NSGAIII"
+    EMO = "EMO"
 
 
 class MethodProperties(str, Enum):
@@ -57,6 +56,9 @@ class MethodProperties(str, Enum):
     INTERACTIVE = "interactive"
     REFERENCE_POINT = "reference_point"
     CLASSIFICATION = "classification"
+    BOUNDS = "bounds"
+    PREFERRED_SOLUTIONS = "preferred_solutions"
+    NON_PREFERRED_SOLUTIONS = "non_preferred_solutions"
     # TODO: Add more properties as needed.
 
 
@@ -73,8 +75,12 @@ class User(BaseModel):
     )
     password_hash: str = Field(description="SHA256 Hash of the user's password.")
     role: UserRole = Field(description="Role of the user.")
-    privileges: list[UserPrivileges] = Field(description="List of privileges the user has.")
-    user_group: str = Field(description="User group of the user. Used for group decision making.")
+    privileges: list[UserPrivileges] = Field(
+        description="List of privileges the user has."
+    )
+    user_group: str = Field(
+        description="User group of the user. Used for group decision making."
+    )
     # To allows for User to be initialized from database instead of just dicts.
     model_config = ConfigDict(from_attributes=True)
 

desdeo/api/tests/conftest.py

@@ -1,5 +1,9 @@
 """General fixtures for API tests are defined here."""
 
+import io
+from pathlib import Path
+
+import polars as pl
 import pytest
 from fastapi.testclient import TestClient
 from sqlmodel import Session, SQLModel, create_engine
@@ -7,9 +11,16 @@ from sqlmodel.pool import StaticPool
 
 from desdeo.api.app import app
 from desdeo.api.db import get_session
-from desdeo.api.models import ProblemDB, User, UserRole
+from desdeo.api.models import (
+    ForestProblemMetaData,
+    ProblemDB,
+    ProblemMetaDataDB,
+    RepresentativeNonDominatedSolutions,
+    User,
+    UserRole,
+)
 from desdeo.api.routers.user_authentication import get_password_hash
-from desdeo.problem.testproblems import dtlz2, river_pollution_problem
+from desdeo.problem.testproblems import dtlz2, river_pollution_problem, dmitry_forest_problem_disc
 
 
 @pytest.fixture(name="session_and_user", scope="function")
@@ -40,6 +51,48 @@ def session_fixture():
         session.commit()
         session.refresh(problem_db_river)
 
+        metadata = ProblemMetaDataDB(problem_id=problem_db_river.id)
+        session.add(metadata)
+        session.commit()
+        session.refresh(metadata)
+
+        data_path = Path(__file__).parent.parent.parent.parent / "datasets" / "river_pollution_non_dom.parquet"
+        df = pl.read_parquet(data_path)
+        dict_data = df.to_dict(as_series=False)
+        river_nondominated_meta = RepresentativeNonDominatedSolutions(
+            metadata_id=metadata.id,
+            name="Non-dom-solutions",
+            description=(
+                "Set of non-dominated solutions representing the Pareto optimal "
+                "solutions of the river pollution problem."
+            ),
+            solution_data=dict_data,
+            ideal={},
+            nadir={},
+        )
+
+        session.add(river_nondominated_meta)
+        session.commit()
+
+        forest_metadata = ForestProblemMetaData(
+            metadata_id=metadata.id,
+            map_json="type: string",
+            schedule_dict={"type": "dict"},
+            years=["type:", "list", "of", "strings"],
+            stand_id_field="type: string",
+        )
+
+        session.add(forest_metadata)
+        session.commit()
+
+        problem_db_discrete = ProblemDB.from_problem(
+            dmitry_forest_problem_disc(),
+            user=user_analyst
+        )
+        session.add(problem_db_discrete)
+        session.commit()
+        session.refresh(problem_db_discrete)
+
         yield {"session": session, "user": user_analyst}
         session.rollback()
 
@@ -57,3 +110,42 @@ def client_fixture(session_and_user):
     yield client
 
     app.dependency_overrides.clear()
+
+
+def login(client: TestClient, username="analyst", password="analyst") -> str:  # noqa: S107
+    """Login, returns the access token."""
+    response_login = client.post(
+        "/login",
+        data={"username": username, "password": password, "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    ).json()
+
+    return response_login["access_token"]
+
+
+def post_json(client: TestClient, endpoint: str, json: dict, access_token: str):
+    """Makes a post request and returns the response."""
+    return client.post(
+        endpoint,
+        json=json,
+        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
+    )
+
+
+def post_file_multipart(
+    client: TestClient, endpoint: str, file_bytes: bytes, access_token: str, filename: str = "test.json"
+):
+    """Makes a post request with an uploaded file and returns the response."""
+    return client.post(
+        endpoint,
+        files={"json_file": (filename, io.BytesIO(file_bytes), "application/json")},
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+
+def get_json(client: TestClient, endpoint: str, access_token: str):
+    """Makes a get request and returns the response."""
+    return client.get(
+        endpoint,
+        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
+    )

desdeo/api/tests/test_enautilus.py

@@ -0,0 +1,330 @@
+"""Tests related to E-NAUTILUS models and routes."""
+
+import json
+
+import numpy as np
+from fastapi.testclient import TestClient
+from sqlmodel import Session, select
+
+from desdeo.api.models import (
+    ENautilusRepresentativeSolutionsResponse,
+    ENautilusStateResponse,
+    ENautilusStepRequest,
+    ENautilusStepResponse,
+    ProblemDB,
+    ProblemMetaDataDB,
+    RepresentativeNonDominatedSolutions,
+    user,
+)
+
+from .conftest import get_json, login, post_json
+
+
+def test_enautilus_step_request(session_and_user: dict[str, Session | list[user]]):
+    """Tests the E-NAUTILUS step request model."""
+    problem_id = 42
+    session_id = 69
+    parent_state_id = 20
+    representative_solutions_id = 10
+
+    current_iteration = 3
+    iterations_left = 4
+    selected_point = {"f_1": 2.3, "f_2": 4.3, "f_3": -22222.3}
+    reachable_point_indices = [1, 2, 3, 46, 9]
+    number_of_intermediate_points = 9001
+
+    request = ENautilusStepRequest(
+        problem_id=problem_id,
+        session_id=session_id,
+        parent_state_id=parent_state_id,
+        representative_solutions_id=representative_solutions_id,
+        current_iteration=current_iteration,
+        iterations_left=iterations_left,
+        selected_point=selected_point,
+        reachable_point_indices=reachable_point_indices,
+        number_of_intermediate_points=number_of_intermediate_points,
+    )
+
+    assert request.problem_id == problem_id
+    assert request.session_id == session_id
+    assert request.parent_state_id == parent_state_id
+    assert request.current_iteration == current_iteration
+    assert request.iterations_left == iterations_left
+    assert request.selected_point == selected_point
+    assert request.reachable_point_indices == reachable_point_indices
+    assert request.number_of_intermediate_points == number_of_intermediate_points
+
+
+def test_enautilus_step_router(client: TestClient, session_and_user: dict[str, Session | list[user]]):
+    """Test the E-NAUTILUS stepping endpoint."""
+    session, user = session_and_user["session"], session_and_user["user"]
+    access_token = login(client)
+
+    problem_db = session.exec(select(ProblemDB).where(ProblemDB.name == "The river pollution problem")).first()
+
+    representative_solutions = session.exec(
+        select(RepresentativeNonDominatedSolutions)
+        .join(RepresentativeNonDominatedSolutions.metadata_instance)
+        .where(ProblemMetaDataDB.problem_id == problem_db.id)
+    ).first()
+
+    current_iteration = 0
+    total_iterations = 5
+    selected_point = None  # nadir point
+    reachable_point_indices = []  # empty for first iteration
+    number_of_intermediate_points = 3
+
+    request = ENautilusStepRequest(
+        problem_id=problem_db.id,
+        session_id=None,
+        parent_state_id=None,
+        representative_solutions_id=representative_solutions.id,
+        current_iteration=current_iteration,
+        iterations_left=total_iterations,
+        selected_point=selected_point,
+        reachable_point_indices=reachable_point_indices,
+        number_of_intermediate_points=number_of_intermediate_points,
+    )
+
+    raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    step_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    assert step_response.state_id == 1  # there should be no prior StateDB in the test instance of the DB
+    assert step_response.current_iteration == current_iteration + 1  # advances by 1
+    assert step_response.iterations_left == total_iterations - 1  # decrement by 1
+    assert len(step_response.intermediate_points) == number_of_intermediate_points
+    assert len(step_response.reachable_best_bounds) == number_of_intermediate_points  # one for each point
+    assert len(step_response.reachable_worst_bounds) == number_of_intermediate_points  # one for each point
+    assert len(step_response.closeness_measures) == number_of_intermediate_points  # one for each point
+    assert len(step_response.reachable_point_indices) == number_of_intermediate_points  # one set for each point
+
+    # second iteration
+    previous_step = step_response
+    new_number_of_intermediate_points = 2
+
+    request = ENautilusStepRequest(
+        problem_id=problem_db.id,
+        session_id=None,
+        parent_state_id=previous_step.state_id,
+        representative_solutions_id=representative_solutions.id,
+        current_iteration=previous_step.current_iteration,
+        iterations_left=previous_step.iterations_left,
+        selected_point=previous_step.intermediate_points[0],
+        reachable_point_indices=previous_step.reachable_point_indices[0],
+        number_of_intermediate_points=new_number_of_intermediate_points,
+    )
+
+    raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    step_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    assert step_response.state_id == 2  # there should be one prior StateDB in the test instance of the DB
+    assert step_response.current_iteration == previous_step.current_iteration + 1  # advances by 1
+    assert step_response.iterations_left == previous_step.iterations_left - 1  # decrement by 1
+    assert len(step_response.intermediate_points) == new_number_of_intermediate_points
+    assert len(step_response.reachable_best_bounds) == new_number_of_intermediate_points  # one for each point
+    assert len(step_response.reachable_worst_bounds) == new_number_of_intermediate_points  # one for each point
+    assert len(step_response.closeness_measures) == new_number_of_intermediate_points  # one for each point
+    assert len(step_response.reachable_point_indices) == new_number_of_intermediate_points  # one set for each point
+
+
+def test_enautilus_get_state(client: TestClient, session_and_user: dict[str, Session | list[user]]):
+    """Test fetching a previous state for the the E-NAUTILUS method."""
+    session, _ = session_and_user["session"], session_and_user["user"]
+    access_token = login(client)
+
+    problem_db = session.exec(select(ProblemDB).where(ProblemDB.name == "The river pollution problem")).first()
+
+    representative_solutions = session.exec(
+        select(RepresentativeNonDominatedSolutions)
+        .join(RepresentativeNonDominatedSolutions.metadata_instance)
+        .where(ProblemMetaDataDB.problem_id == problem_db.id)
+    ).first()
+
+    current_iteration = 0
+    total_iterations = 5
+    selected_point = None  # nadir point
+    reachable_point_indices = []  # empty for first iteration
+    number_of_intermediate_points = 3
+
+    session_id = None
+    parent_state_id = None
+
+    request = ENautilusStepRequest(
+        problem_id=problem_db.id,
+        session_id=session_id,
+        parent_state_id=parent_state_id,
+        representative_solutions_id=representative_solutions.id,
+        current_iteration=current_iteration,
+        iterations_left=total_iterations,
+        selected_point=selected_point,
+        reachable_point_indices=reachable_point_indices,
+        number_of_intermediate_points=number_of_intermediate_points,
+    )
+
+    raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    step1_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    assert step1_response.state_id == 1  # there should be no prior StateDB in the test instance of the DB
+    assert step1_response.current_iteration == current_iteration + 1  # advances by 1
+    assert step1_response.iterations_left == total_iterations - 1  # decrement by 1
+    assert len(step1_response.intermediate_points) == number_of_intermediate_points
+    assert len(step1_response.reachable_best_bounds) == number_of_intermediate_points  # one for each point
+    assert len(step1_response.reachable_worst_bounds) == number_of_intermediate_points  # one for each point
+    assert len(step1_response.closeness_measures) == number_of_intermediate_points  # one for each point
+    assert len(step1_response.reachable_point_indices) == number_of_intermediate_points  # one set for each point
+
+    # second iteration
+    previous_step = step1_response
+    new_number_of_intermediate_points = 2
+
+    request = ENautilusStepRequest(
+        problem_id=problem_db.id,
+        session_id=None,
+        parent_state_id=previous_step.state_id,
+        representative_solutions_id=representative_solutions.id,
+        current_iteration=previous_step.current_iteration,
+        iterations_left=previous_step.iterations_left,
+        selected_point=previous_step.intermediate_points[0],
+        reachable_point_indices=previous_step.reachable_point_indices[0],
+        number_of_intermediate_points=new_number_of_intermediate_points,
+    )
+
+    raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    step2_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    assert step2_response.state_id == 2  # there should be one prior StateDB in the test instance of the DB
+    assert step2_response.current_iteration == previous_step.current_iteration + 1  # advances by 1
+    assert step2_response.iterations_left == previous_step.iterations_left - 1  # decrement by 1
+    assert len(step2_response.intermediate_points) == new_number_of_intermediate_points
+    assert len(step2_response.reachable_best_bounds) == new_number_of_intermediate_points  # one for each point
+    assert len(step2_response.reachable_worst_bounds) == new_number_of_intermediate_points  # one for each point
+    assert len(step2_response.closeness_measures) == new_number_of_intermediate_points  # one for each point
+    assert len(step2_response.reachable_point_indices) == new_number_of_intermediate_points  # one set for each point
+
+    raw_response = get_json(client, f"/method/enautilus/get_state/{step1_response.state_id}", access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    state_response = ENautilusStateResponse.model_validate(json.loads(raw_response.content))
+
+    previous_request = state_response.request
+    previous_response = state_response.response
+
+    # response is the result of the state
+    assert previous_response.state_id == step1_response.state_id
+    assert previous_response.current_iteration == step1_response.current_iteration
+    assert previous_response.iterations_left == step1_response.iterations_left
+    assert previous_response.intermediate_points == step1_response.intermediate_points
+    assert previous_response.reachable_best_bounds == step1_response.reachable_best_bounds
+    assert previous_response.reachable_worst_bounds == step1_response.reachable_worst_bounds
+    assert previous_response.closeness_measures == step1_response.closeness_measures
+    assert previous_response.reachable_point_indices == step1_response.reachable_point_indices
+
+    nadir_point = {
+        f"{obj.symbol}": (-1 if obj.maximize else 1)
+        * np.max(representative_solutions.solution_data[f"{obj.symbol}_min"])
+        for obj in problem_db.objectives
+    }
+
+    reachable_point_indices_ = list(range(len(representative_solutions.solution_data[problem_db.objectives[0].symbol])))
+
+    # request is the origin of the state
+    assert previous_request.problem_id == problem_db.id
+    assert previous_request.session_id == session_id
+    assert previous_request.parent_state_id == parent_state_id
+    assert previous_request.representative_solutions_id == representative_solutions.id
+    assert previous_request.current_iteration == current_iteration
+    assert previous_request.iterations_left == total_iterations
+    assert previous_request.selected_point == nadir_point  # should be the nadir, because first iteration
+    assert previous_request.reachable_point_indices == reachable_point_indices_  # all in the first iteration
+    assert previous_request.number_of_intermediate_points == number_of_intermediate_points
+
+
+def test_enautilus_get_representative(client: TestClient, session_and_user: dict[str, Session | list[user]]):
+    """Test the E-NAUTILUS endpoint for getting representative solutions."""
+    session, _ = session_and_user["session"], session_and_user["user"]
+    access_token = login(client)
+
+    problem_db = session.exec(select(ProblemDB).where(ProblemDB.name == "The river pollution problem")).first()
+
+    representative_solutions = session.exec(
+        select(RepresentativeNonDominatedSolutions)
+        .join(RepresentativeNonDominatedSolutions.metadata_instance)
+        .where(ProblemMetaDataDB.problem_id == problem_db.id)
+    ).first()
+
+    current_iteration = 0
+    total_iterations = 5
+    selected_point = None  # nadir point
+    reachable_point_indices = []  # empty for first iteration
+    number_of_intermediate_points = 3
+
+    request = ENautilusStepRequest(
+        problem_id=problem_db.id,
+        session_id=None,
+        parent_state_id=None,
+        representative_solutions_id=representative_solutions.id,
+        current_iteration=current_iteration,
+        iterations_left=total_iterations,
+        selected_point=selected_point,
+        reachable_point_indices=reachable_point_indices,
+        number_of_intermediate_points=number_of_intermediate_points,
+    )
+
+    raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+    assert raw_response.status_code == 200  # OK
+
+    step_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    # iterate until last
+    while step_response.iterations_left > 0:
+        previous_step = step_response
+
+        request = ENautilusStepRequest(
+            problem_id=problem_db.id,
+            session_id=None,
+            parent_state_id=previous_step.state_id,
+            representative_solutions_id=representative_solutions.id,
+            current_iteration=previous_step.current_iteration,
+            iterations_left=previous_step.iterations_left,
+            selected_point=previous_step.intermediate_points[0],
+            reachable_point_indices=previous_step.reachable_point_indices[0],
+            number_of_intermediate_points=number_of_intermediate_points,
+        )
+
+        raw_response = post_json(client, "/method/enautilus/step", request.model_dump(), access_token)
+
+        assert raw_response.status_code == 200  # OK
+
+        step_response = ENautilusStepResponse.model_validate(json.loads(raw_response.content))
+
+    # no iterations left, last iteration
+    raw_response = get_json(client, "/method/enautilus/get_representative/3", access_token)
+
+    assert raw_response.status_code == 200
+
+    int_response = ENautilusRepresentativeSolutionsResponse.model_validate(json.loads(raw_response.content))
+
+    assert len(int_response.solutions) == number_of_intermediate_points
+
+    # try also a previous iteration
+    raw_response = get_json(client, "/method/enautilus/get_representative/2", access_token)
+
+    assert raw_response.status_code == 200
+
+    int_response = ENautilusRepresentativeSolutionsResponse.model_validate(json.loads(raw_response.content))
+
+    assert len(int_response.solutions) == number_of_intermediate_points