space-bundle/src/optos/models.py

"""Data models for the Optimization Operating System."""

from __future__ import annotations

from dataclasses import asdict, dataclass, field
from typing import Any


@dataclass
class OptimizationRequest:
    problem_type: str
    data: dict[str, Any] = field(default_factory=dict)
    constraints: dict[str, Any] = field(default_factory=dict)
    objectives: dict[str, Any] = field(default_factory=dict)
    solver: dict[str, Any] = field(default_factory=dict)
    time_limit: float = 60.0

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)


@dataclass
class InstanceFeatures:
    n_variables: int = 0
    n_constraints: int = 0
    density: float = 0.0
    pct_integer: float = 0.0
    constraint_tightness: float = 0.0

    def to_dict(self) -> dict[str, float | int]:
        return asdict(self)


@dataclass
class ProblemInstance:
    problem_type: str
    instance_id: str
    label: str
    size: str
    seed: int
    data: dict[str, Any]
    features: InstanceFeatures
    constraints: dict[str, Any] = field(default_factory=dict)
    objectives: dict[str, Any] = field(default_factory=dict)
    known_optimum: float | None = None

    def to_dict(self) -> dict[str, Any]:
        return {
            "problem_type": self.problem_type,
            "instance_id": self.instance_id,
            "label": self.label,
            "size": self.size,
            "seed": self.seed,
            "data": self.data,
            "features": self.features.to_dict(),
            "constraints": self.constraints,
            "objectives": self.objectives,
            "known_optimum": self.known_optimum,
        }


@dataclass
class SolveMetrics:
    objective_value: float = 0.0
    best_bound: float = 0.0
    optimality_gap: float = 0.0
    elapsed_time_sec: float = 0.0
    iterations: int = 0
    constraint_violations: int = 0
    feasible: bool = False
    status: str = "unknown"
    time_to_first_feasible: float = 0.0
    memory_mb: float = 0.0

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)


@dataclass
class SolveResult:
    method_id: str
    method_label: str
    method_category: str
    solver_id: str
    solver_config: dict[str, Any]
    instance_id: str
    problem_type: str
    metrics: SolveMetrics
    solution: dict[str, Any] = field(default_factory=dict)
    log: str = ""

    def to_dict(self) -> dict[str, Any]:
        return {
            "method_id": self.method_id,
            "method_label": self.method_label,
            "method_category": self.method_category,
            "solver_id": self.solver_id,
            "solver_config": self.solver_config,
            "instance_id": self.instance_id,
            "problem_type": self.problem_type,
            "metrics": self.metrics.to_dict(),
            "solution": self.solution,
            "log": self.log,
        }


@dataclass
class ExperimentRun:
    run_id: str
    instance: ProblemInstance
    model_version: str
    solver_id: str
    solver_config: dict[str, Any]
    parameters: dict[str, Any]
    results: list[SolveResult]
    winner: str
    winner_gap_pct: float
    runtime_sec: float

    def to_dict(self) -> dict[str, Any]:
        return {
            "run_id": self.run_id,
            "instance": self.instance.to_dict(),
            "model_version": self.model_version,
            "solver_id": self.solver_id,
            "solver_config": self.solver_config,
            "parameters": self.parameters,
            "results": [r.to_dict() for r in self.results],
            "winner": self.winner,
            "winner_gap_pct": self.winner_gap_pct,
            "runtime_sec": self.runtime_sec,
        }


@dataclass
class ScenarioResult:
    scenario_type: str
    scenario_label: str
    perturbation: dict[str, Any]
    baseline_objective: float
    perturbed_objective: float
    delta_pct: float
    feasible: bool
    binding_constraints: list[str] = field(default_factory=list)

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)


@dataclass
class ExplanationReport:
    binding_constraints: list[dict[str, Any]] = field(default_factory=list)
    shadow_prices: list[dict[str, Any]] = field(default_factory=list)
    infeasibility_reason: str = ""
    what_if_suggestions: list[str] = field(default_factory=list)
    counterfactuals: list[dict[str, Any]] = field(default_factory=list)

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)