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

desdeo/api/routers/utopia.py

@@ -0,0 +1,230 @@
+"""Utopia router."""
+
+import json
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlmodel import Session, select
+
+from desdeo.api.db import get_session
+from desdeo.api.models import (
+    ForestProblemMetaData,
+    NIMBUSFinalState,
+    NIMBUSInitializationState,
+    NIMBUSSaveState,
+    ProblemMetaDataDB,
+    StateDB,
+    User,
+    UtopiaRequest,
+    UtopiaResponse,
+)
+from desdeo.api.routers.user_authentication import get_current_user
+
+router = APIRouter(prefix="/utopia")
+
+
+@router.post("/")
+def get_utopia_data(
+    request: UtopiaRequest,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[Session, Depends(get_session)],
+) -> UtopiaResponse:
+    """Request and receive the Utopia map corresponding to the decision variables sent.
+
+    Args:
+        request (UtopiaRequest): the set of decision variables and problem for which the utopia forest map is requested
+        for.
+        user (Annotated[User, Depend(get_current_user)]) the current user
+        session (Annotated[Session, Depends(get_session)]) the current database session
+    Raises:
+        HTTPException:
+    Returns:
+        UtopiaResponse: the map for the forest, to be rendered in frontend
+    """
+    empty_response = UtopiaResponse(is_utopia=False, map_name="", map_json={}, options={}, description="", years=[])
+
+    state = session.exec(select(StateDB).where(StateDB.id == request.solution.state_id)).first()
+    if state is None or not hasattr(state, "state"):
+        return empty_response
+
+    actual_state = state.state
+
+    if type(actual_state) is NIMBUSSaveState:
+        decision_variables = actual_state.result_variable_values[0]
+
+    elif type(actual_state) in [NIMBUSInitializationState, NIMBUSFinalState]:
+        decision_variables = actual_state.solver_results.optimal_variables
+
+    else:
+        # Check if solver_results exists and has the needed index
+        if (
+            not hasattr(actual_state, "solver_results")
+            or request.solution.solution_index >= len(actual_state.solver_results)
+            or actual_state.solver_results[request.solution.solution_index] is None
+        ):
+            return empty_response
+
+        result = actual_state.solver_results[request.solution.solution_index]
+        if not hasattr(result, "optimal_variables") or not result.optimal_variables:
+            return empty_response
+        decision_variables = result.optimal_variables  # expects a list of variables, won't work without.
+
+    from_db_metadata = session.exec(
+        select(ProblemMetaDataDB).where(ProblemMetaDataDB.problem_id == request.problem_id)
+    ).first()
+    if from_db_metadata is None:
+        return empty_response
+
+    # Get the last instance of forest related metadata from the database.
+    # If for some reason there's more than one forest metadata, return the latest.
+    forest_metadata: ForestProblemMetaData = [
+        metadata for metadata in from_db_metadata.all_metadata if metadata.metadata_type == "forest_problem_metadata"
+    ][-1]
+    if forest_metadata is None:
+        return empty_response
+
+    # Figure out the treatments from the decision variables and utopia data
+
+    def treatment_index(part: str) -> str:
+        if "clearcut" in part:
+            return 1
+        if "below" in part:
+            return 2
+        if "above" in part:
+            return 3
+        if "even" in part:
+            return 4
+        if "first" in part:
+            return 5
+        return -1
+
+    treatments_dict = {}
+    for key in decision_variables:
+        if not key.startswith("X"):
+            continue
+        # The dict keys get converted to ints to strings when it's loaded from database
+        try:
+            treatments = forest_metadata.schedule_dict[key][str(decision_variables[key].index(1))]
+        except ValueError as e:
+            # if the optimization didn't choose any decision alternative, it's safe to assume
+            #  that nothing is being done at that forest stand
+            treatments = forest_metadata.schedule_dict[key]["0"]
+            # print(e)
+        treatments_dict[key] = {forest_metadata.years[0]: 0, forest_metadata.years[1]: 0, forest_metadata.years[2]: 0}
+        for year in treatments_dict[key]:
+            if year in treatments:
+                for part in treatments.split():
+                    if year in part:
+                        treatments_dict[key][year] = treatment_index(part)
+
+    # Create the options for the webui
+
+    treatment_colors = {
+        0: "#4daf4a",
+        1: "#e41a1c",
+        2: "#984ea3",
+        3: "#e3d802",
+        4: "#ff7f00",
+        5: "#377eb8",
+    }
+
+    description_dict = {
+        0: "Do nothing",
+        1: "Clearcut",
+        2: "Thinning from below",
+        3: "Thinning from above",
+        4: "Even thinning",
+        5: "First thinning",
+    }
+
+    map_name = "ForestMap"  # This isn't visible anywhere on the ui
+
+    options = {}
+    for year in forest_metadata.years:
+        options[year] = {
+            "tooltip": {
+                "trigger": "item",
+                "showDelay": 0,
+                "transitionDuration": 0.2,
+            },
+            "visualMap": {  # // vis eg. stock levels
+                "left": "right",
+                "showLabel": True,
+                "type": "piecewise",  # // for different plans
+                "pieces": [],
+                "text": ["Management plans"],
+                "calculable": True,
+            },
+            # // predefined symbols for visumap'circle': 'rect': 'roundRect': 'triangle': 'diamond': 'pin':'arrow':
+            # // can give custom svgs also
+            "toolbox": {
+                "show": True,
+                #   //orient: 'vertical',
+                "left": "left",
+                "top": "top",
+                "feature": {
+                    "dataView": {"readOnly": True},
+                    "restore": {},
+                    "saveAsImage": {},
+                },
+            },
+            # // can draw graphic components to indicate different things at least
+            "series": [
+                {
+                    "name": year,
+                    "type": "map",
+                    "roam": True,
+                    "map": map_name,
+                    "nameProperty": forest_metadata.stand_id_field,
+                    "label": {
+                        "show": False  # Hide text labels on the map
+                    },
+                    # "colorBy": "data",
+                    # "itemStyle": {"symbol": "triangle", "color": "red"},
+                    "data": [],
+                    "nameMap": {},
+                }
+            ],
+        }
+
+        for key in decision_variables:
+            if not key.startswith("X"):
+                continue
+            stand = int(forest_metadata.schedule_dict[key]["unit"])
+            treatment_id = treatments_dict[key][year]
+            piece = {
+                "value": treatment_id,
+                "symbol": "circle",
+                "label": description_dict[treatment_id],
+                "color": treatment_colors[treatment_id],
+            }
+            if piece not in options[year]["visualMap"]["pieces"]:
+                options[year]["visualMap"]["pieces"].append(piece)
+            if forest_metadata.stand_descriptor:
+                name = forest_metadata.stand_descriptor[str(stand)] + description_dict[treatment_id]
+            else:
+                name = "Stand " + str(stand) + " " + description_dict[treatment_id]
+            options[year]["series"][0]["data"].append(
+                {
+                    "name": name,
+                    "value": treatment_id,
+                }
+            )
+            options[year]["series"][0]["nameMap"][stand] = name
+
+    # Let's also generate a nice description for the map
+    map_description = (
+        f"Income from harvesting in the first period {int(decision_variables['P_1'])}€.\n"
+        + f"Income from harvesting in the second period {int(decision_variables['P_2'])}€.\n"
+        + f"Income from harvesting in the third period {int(decision_variables['P_3'])}€.\n"
+        + f"The discounted value of the remaining forest at the end of the plan {int(decision_variables['V_end'])}€."
+    )
+
+    return UtopiaResponse(
+        is_utopia=True,
+        map_name=map_name,
+        options=options,
+        map_json=json.loads(forest_metadata.map_json),
+        description=map_description,
+        years=forest_metadata.years,
+    )

desdeo/api/schema.py

@@ -0,0 +1,100 @@
+"""Pydantic schemas for the API."""
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UserRole(str, Enum):
+    """Enum of user roles."""
+
+    GUEST = "guest"
+    DM = "dm"
+    ANALYST = "analyst"
+
+
+class UserPrivileges(str, Enum):
+    """Enum of user privileges."""
+
+    CREATE_PROBLEMS = "Create problems"
+    CREATE_USERS = "Create users"
+    ACCESS_ALL_PROBLEMS = "Access all problems"
+    EDIT_USERS = "Change user privileges, roles, groups, etc."
+
+
+class ProblemKind(str, Enum):
+    """Enum of problem kinds."""
+
+    CONTINUOUS = "continuous"
+    DISCRETE = "discrete"
+    MIXED = "mixed"
+    BINARY = "binary"
+
+
+class ObjectiveKind(str, Enum):
+    """Enum of objective kinds."""
+
+    ANALYTICAL = "analytical"
+    DATABASED = "databased"
+    SIMULATED = "simulated"
+    SURROGATE = "surrogate"
+
+
+class Methods(str, Enum):
+    """Enum of methods."""
+
+    NIMBUS = "nimbus"
+    NAUTILUS = "nautilus"
+    NAUT_NAVIGATOR = "NAUTILUS navigator"
+    NAUTILUSII = "nautilusII"
+    EMO = "EMO"
+
+
+class MethodProperties(str, Enum):
+    """Enum of method properties."""
+
+    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.
+
+
+class User(BaseModel):
+    """Model for a user. Temporary."""
+
+    username: str = Field(description="Username of the user.")
+    index: int | None = Field(
+        description=(
+            "Index of the user in the database. "
+            "Supposed to be automatically generated by the database. "
+            "So the programmer should not have to worry about it."
+        )
+    )
+    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."
+    )
+    # To allows for User to be initialized from database instead of just dicts.
+    model_config = ConfigDict(from_attributes=True)
+
+
+class Solvers(Enum):
+    """Enum of available solvers."""
+
+    # These should match available_solvers in desdeo.tools.utils
+
+    SCIPY_MIN = "scipy_minimize"
+    SCIPY_DE = "scipy_de"
+    PROXIMAL = "proximal"
+    NEVERGRAD = "nevergrad"
+    PYOMO_BONMIN = "pyomo_bonmin"
+    PYOMO_IPOPT = "pyomo_ipopt"
+    PYOMO_GUROBI = "pyomo_gurobi"
+    GUROBIPY = "gurobipy"

desdeo/api/tests/conftest.py

@@ -0,0 +1,151 @@
+"""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
+from sqlmodel.pool import StaticPool
+
+from desdeo.api.app import app
+from desdeo.api.db import get_session
+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, dmitry_forest_problem_disc
+
+
+@pytest.fixture(name="session_and_user", scope="function")
+def session_fixture():
+    """Create a session for testing."""
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+
+    SQLModel.metadata.create_all(engine)
+
+    with Session(engine) as session:
+        user_analyst = User(
+            username="analyst",
+            password_hash=get_password_hash("analyst"),
+            role=UserRole.analyst,
+            group="test",
+        )
+        session.add(user_analyst)
+        session.commit()
+        session.refresh(user_analyst)
+
+        problem_db = ProblemDB.from_problem(dtlz2(5, 3), user=user_analyst)
+        session.add(problem_db)
+        session.commit()
+        session.refresh(problem_db)
+
+        problem_db_river = ProblemDB.from_problem(river_pollution_problem(), user=user_analyst)
+        session.add(problem_db_river)
+        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()
+
+
+@pytest.fixture(name="client", scope="function")
+def client_fixture(session_and_user):
+    """Create a client for testing."""
+
+    def get_session_override():
+        return session_and_user["session"]
+
+    app.dependency_overrides[get_session] = get_session_override
+    client = TestClient(app)
+
+    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"},
+    )