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

desdeo/api/models/gdm/gdm_score_bands.py

@@ -0,0 +1,114 @@
+"""Models for GDM Score Bands.
+
+Idea is that in the very first iteration, the filtered indices contains the clustering
+information on the entire data. Since on each iteration, the clustering is different,
+we need to include the indices over and over again. Of course with time the amount of
+indices will get smaller and smaller, and eventually be only ~10 solutions.
+
+The names of the classes can be renamed to fit the purpose better, currently they are
+more or less just the first thing that came to my mind.
+"""
+
+from sqlmodel import JSON, Column, Field, SQLModel
+
+from desdeo.api.models.gdm.gdm_base import BaseGroupInfoContainer
+from desdeo.gdm.score_bands import SCOREBandsGDMConfig, SCOREBandsGDMResult
+from desdeo.problem.schema import VariableType
+from desdeo.tools.score_bands import SCOREBandsResult
+
+
+class GDMSCOREBandInformation(BaseGroupInfoContainer):
+    """Class for containing info on which band was voted for."""
+    method: str = "gdm-score-bands"
+    user_votes: dict[str, int] = Field(
+        description="Dictionary of votes."
+    )
+    user_confirms: list[int] = Field(
+        description="List of users who want to move on."
+    )
+    score_bands_config: SCOREBandsGDMConfig = Field(
+        description="The configuration that led to this classification."
+    )
+    score_bands_result: SCOREBandsGDMResult = Field(
+        description="The results of the score bands."
+    )
+
+
+class GDMSCOREBandFinalSelection(BaseGroupInfoContainer):
+    """Class for containing the final 10 or less solutions, the final solution and the votes that led to it."""
+    method: str = "gdm-score-bands-final"
+    user_votes: dict[str, int] = Field(
+        description="Dictionary of votes."
+    )
+    user_confirms: list[int] = Field(
+        description="List of users who want to move on."
+    )
+
+    """The 10 or less solutions to choose from"""
+    solution_variables: dict[str, list[VariableType]] = Field(sa_column=Column(JSON))
+    solution_objectives: dict[str, list[float]] = Field(sa_column=Column(JSON))
+
+    """The selected (or generated??) of those 10 or less."""
+    winner_solution_variables: dict[str, VariableType] = Field(sa_column=Column(JSON))
+    winner_solution_objectives: dict[str, float] = Field(sa_column=Column(JSON))
+
+
+class GDMScoreBandsInitializationRequest(SQLModel):
+    """Request class for initialization of score bands."""
+    group_id: int = Field(
+        description="The group to be initialized."
+    )
+    score_bands_config: SCOREBandsGDMConfig = Field(
+        description="The configuration for the initial score banding."
+    )
+
+class GDMScoreBandsVoteRequest(SQLModel):
+    """Request for voting for a band."""
+    group_id: int = Field(
+        description="ID of the group in question"
+    )
+    vote: int = Field(
+        description="The vote. Vaalisalaisuus."
+    )
+
+class GDMSCOREBandsRevertRequest(SQLModel):
+    """Request for reverting to a previous setup."""
+    group_id: int = Field(
+        description="Group ID."
+    )
+    iteration_number: int = Field(
+        description="The number of the iteration that we want to revert to."
+    )
+
+class GDMSCOREBandsResponse(SQLModel):
+    """Response class for GDMSCOREBands, whether it is initialization or not."""
+    method: str = "gdm-score-bands"
+    group_id: int = Field(
+        description="The group in question."
+    )
+    group_iter_id: int = Field(
+        description="ID of the latest group iteration."
+    )
+    latest_iteration: int = Field(
+        description="The latest GDM iteration number. Different from Group Iteration id."
+    )
+    result: SCOREBandsResult = Field(
+        description="The results of the score bands procedure."
+    )
+
+class GDMSCOREBandsDecisionResponse(SQLModel):
+    """Response class for gdm score bands that includes the last 10 or less solutions."""
+    method: str = "gdm-score-bands-final"
+    group_id: int = Field(
+        description="The group in question."
+    )
+    group_iter_id: int = Field(
+        description="ID of the latest group iteration."
+    )
+    result: GDMSCOREBandFinalSelection = Field(
+        description="The container for the solutions and the winner solution."
+    )
+
+class GDMSCOREBandsHistoryResponse(SQLModel):
+    """Response class for all history. Allows for going to a previous iteration."""
+    history: list[GDMSCOREBandsResponse | GDMSCOREBandsDecisionResponse]

desdeo/api/models/gdm/gnimbus.py

@@ -0,0 +1,138 @@
+"""GNIMBUS specific data classes; REMEMBER to add SER/DES into aggregator!"""
+
+import json
+
+from pydantic import ValidationError
+from sqlmodel import JSON, Column, Field, SQLModel, TypeDecorator
+
+from desdeo.api.models.gdm.gdm_base import (
+    BaseGroupInfoContainer,
+    BooleanDictTypeDecorator,
+    ReferencePoint,
+    ReferencePointDictType,
+)
+from desdeo.api.models.generic_states import SolutionReference, SolutionReferenceLite
+from desdeo.tools import SolverResults
+
+
+class SolverResultType(TypeDecorator):
+    """Not sure why the solver results wouldn't serialize but this should do the trick."""
+
+    impl = JSON
+
+    def process_bind_param(self, value, dialect):
+        """Turns solver results into json."""
+        if isinstance(value, list):
+            solver_list = []
+            for item in value:
+                if isinstance(item, SolverResults):
+                    solver_list.append(item.model_dump_json())
+            return json.dumps(solver_list)
+        return None
+
+    def process_result_value(self, value, dialect):
+        """And back."""
+        if value is not None:
+            value_list = json.loads(value)
+            solver_list: SolverResults = []
+            for item in value_list:
+                item_dict = json.loads(item)
+                try:
+                    solver_list.append(SolverResults.model_validate(item_dict))
+                except ValidationError as e:
+                    print(f"Validation error when deserializing SolverResults: {e}")
+                    continue
+            return solver_list
+        return None
+
+
+class GNIMBUSSwitchPhaseRequest(SQLModel):
+    """A request for a certain phase. Comes from the group owner/analyst."""
+
+    group_id: int
+    new_phase: str
+
+
+class GNIMBUSSwitchPhaseResponse(SQLModel):
+    """A response for the above request."""
+
+    old_phase: str
+    new_phase: str
+
+
+class OptimizationPreference(BaseGroupInfoContainer):
+    """A structure for storing optimization preferences. See GNIMBUS for details."""
+
+    method: str = "optimization"
+    phase: str = Field(default="learning")
+    set_preferences: dict[int, ReferencePoint] = Field(sa_column=Column(ReferencePointDictType))
+
+
+class VotingPreference(BaseGroupInfoContainer):
+    """A structure for storing voting preferences."""
+
+    method: str = "voting"
+    set_preferences: dict[int, int] = Field(
+        sa_column=Column(JSON)
+    )  # A user votes for an index from the results (or something)
+
+
+class EndProcessPreference(BaseGroupInfoContainer):
+    """A structure for storing info on whether everyone is happy to end the gnimbus process."""
+
+    method: str = "end"
+    success: bool | None = Field()
+
+    # We check if everyone agrees to stop.
+    set_preferences: dict[int, bool] = Field(sa_column=Column(BooleanDictTypeDecorator))
+
+
+class GNIMBUSResultResponse(SQLModel):
+    """The response for getting GNIMBUS results. NOTE: OBSOLETE!"""
+
+    method: str
+    phase: str
+    preferences: VotingPreference | OptimizationPreference
+    common_results: list[SolutionReference]
+    user_results: list[SolutionReference]
+    personal_result_index: int | None
+
+
+class FullIteration(SQLModel):
+    """A full iteration item containing results from a complete or incomplete iteration.
+
+    This is a format to send information to the user interface.
+    """
+
+    phase: str = Field(
+        description="The phase of the iteration."
+    )
+    optimization_preferences: OptimizationPreference | None = Field(
+        description="The preferences related to the optimization stage of the full iteration."
+    )
+    voting_preferences: VotingPreference | EndProcessPreference | None = Field(
+        description="The preferences related to the voting phase of the iteration. \
+            either actual votes or a vote to see whether to just continue."
+    )
+    starting_result: SolutionReferenceLite | None = Field(
+        description="The starting result of the optimization process. Fetched from the previous \
+            iteration's final result."
+    )
+    common_results: list[SolutionReferenceLite] = Field(
+        description="The common results (1 to 4) generated by gnimbus."
+    )
+    user_results: list[SolutionReferenceLite] = Field(
+        description="The user specific results generated by gnimbus in phases learning and crp."
+    )
+    personal_result_index: int | None = Field(
+        description="The user result index of requester."
+    )
+    final_result: SolutionReferenceLite | None = Field(
+        description="The final result after voting."
+    )
+
+
+class GNIMBUSAllIterationsResponse(SQLModel):
+    """The response model for getting all found solutions among others."""
+
+    all_full_iterations: list[FullIteration]

desdeo/api/models/generic.py

@@ -0,0 +1,104 @@
+"""Generic models for the DESDEO API."""
+
+from pydantic import ConfigDict
+from sqlmodel import JSON, Column, Field, SQLModel
+
+from desdeo.tools.score_bands import SCOREBandsConfig, SCOREBandsResult
+
+from .generic_states import SolutionReferenceResponse
+
+
+class SolutionInfo(SQLModel):
+    """Used when we wish to reference a solution in some `StateDB` stored in the database."""
+
+    state_id: int = Field(description="State of the desired solution.")
+    solution_index: int = Field(description="Index of the desired solution.")
+    name: str | None = Field(description="Name to be given to the solution. Optional.", default=None)
+
+
+class IntermediateSolutionRequest(SQLModel):
+    """Model of the request to solve intermediate solutions between two solutions."""
+
+    problem_id: int
+    session_id: int | None = Field(default=None)
+    parent_state_id: int | None = Field(default=None)
+    context: str | None = None  # Method context (nimbus, rpm, etc.)
+    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)
+
+    num_desired: int | None = Field(default=1)
+
+    reference_solution_1: SolutionInfo
+    reference_solution_2: SolutionInfo
+
+
+class GenericIntermediateSolutionResponse(SQLModel):
+    """The response from computing intermediate values."""
+
+    state_id: int | None = Field(description="The newly created state id")
+    reference_solution_1: SolutionReferenceResponse = Field(
+        sa_column=Column(JSON),
+        description="The first solution used when computing intermediate solutions.",
+    )
+    reference_solution_2: SolutionReferenceResponse = Field(
+        sa_column=Column(JSON),
+        description="The second solution used when computing intermediate solutions.",
+    )
+    intermediate_solutions: list[SolutionReferenceResponse] = Field(
+        sa_column=Column(JSON), description="The intermediate solutions computed."
+    )
+
+
+class ScoreBandsRequest(SQLModel):
+    """Model of the request to calculate SCORE bands parameters."""
+
+    data: list[list[float]] = Field(description="Matrix of objective values")
+    objs: list[str] = Field(description="Array of objective names for each column")
+
+    # Optional parameters with defaults matching the score_bands.py functions
+    dist_parameter: float = Field(default=0.05, description="Distance parameter for axis positioning")
+    use_absolute_corr: bool = Field(default=False, description="Use absolute correlation values")
+    distance_formula: int = Field(default=1, description="Distance formula (1 or 2)")
+    flip_axes: bool = Field(default=True, description="Whether to flip axes based on correlation signs")
+    clustering_algorithm: str = Field(default="DBSCAN", description="Clustering algorithm (DBSCAN or GMM)")
+    clustering_score: str = Field(default="silhoutte", description="Clustering score metric")
+
+
+class ScoreBandsResponse(SQLModel):
+    """Model of the response containing SCORE bands parameters."""
+
+    groups: list[int] = Field(description="Cluster group assignments for each data point")
+    axis_dist: list[float] = Field(description="Normalized axis positions")
+    axis_signs: list[int] | None = Field(description="Axis direction signs (1 or -1)")
+    obj_order: list[int] = Field(description="Optimal order of objectives")
+
+
+class GroupScoreRequest(SQLModel):
+    """A generic model for requesting SCORE Bands for a state."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    problem_id: int
+    group_id: int
+    """Database ID of the problem to solve."""
+    session_id: int | None = Field(default=None)
+    parent_state_id: int | None = Field(default=None)
+    """State ID of the parent state, if any."""
+
+    config: SCOREBandsConfig | None = Field(default=None)
+    """Configuration for the SCORE bands visualization."""
+
+    solution_ids: list[int] = Field()
+    """List of solution IDs to score."""
+
+
+class GroupScoreResponse(SQLModel):
+    """Model of the response to an EMO score request."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    group_iteration_id: int | None = Field(default=None)
+    """The state ID of the newly created group iteration."""
+
+    result: SCOREBandsResult