Add solver_capabilities.py and update codebase

FBumann · FBumann · commit 4ef32c175e52 · 2025-12-03T15:30:52.000+01:00
diff --git a/linopy/model.py b/linopy/model.py
@@ -59,11 +59,10 @@
 from linopy.matrices import MatrixAccessor
 from linopy.objective import Objective
 from linopy.remote import OetcHandler, RemoteHandler
+from linopy.solver_capabilities import SolverFeature, solver_supports
 from linopy.solvers import (
     IO_APIS,
-    NO_SOLUTION_FILE_SOLVERS,
     available_solvers,
-    quadratic_solvers,
 )
 from linopy.types import (
     ConstantLike,
@@ -1196,7 +1195,10 @@ def solve(
         if problem_fn is None:
             problem_fn = self.get_problem_file(io_api=io_api)
         if solution_fn is None:
-            if solver_name in NO_SOLUTION_FILE_SOLVERS and not keep_files:
+            if (
+                solver_supports(solver_name, SolverFeature.SOLUTION_FILE_NOT_NEEDED)
+                and not keep_files
+            ):
                 # these (solver, keep_files=False) combos do not need a solution file
                 solution_fn = None
             else:
@@ -1208,7 +1210,9 @@ def solve(
         if sanitize_infinities:
             self.constraints.sanitize_infinities()
 
-        if self.is_quadratic and solver_name not in quadratic_solvers:
+        if self.is_quadratic and not solver_supports(
+            solver_name, SolverFeature.QUADRATIC_OBJECTIVE
+        ):
             raise ValueError(
                 f"Solver {solver_name} does not support quadratic problems."
             )
@@ -1231,7 +1235,10 @@ def solve(
                     explicit_coordinate_names=explicit_coordinate_names,
                 )
             else:
-                if solver_name in ["glpk", "cbc"] and explicit_coordinate_names:
+                if (
+                    not solver_supports(solver_name, SolverFeature.LP_FILE_NAMES)
+                    and explicit_coordinate_names
+                ):
                     logger.warning(
                         f"{solver_name} does not support writing names to lp files, disabling it."
                     )
@@ -1339,10 +1346,10 @@ def compute_infeasibilities(self) -> list[int]:
         if solver_model is None:
             # Check if this is a supported solver without a stored model
             solver_name = getattr(self, "solver_name", "unknown")
-            if solver_name in ["gurobi", "xpress"]:
+            if solver_supports(solver_name, SolverFeature.IIS_COMPUTATION):
                 raise ValueError(
                     "No solver model available. The model must be solved first with "
-                    "'gurobi' or 'xpress' solver and the result must be infeasible."
+                    "a solver that supports IIS computation and the result must be infeasible."
                 )
             else:
                 # This is an unsupported solver
diff --git a/linopy/solver_capabilities.py b/linopy/solver_capabilities.py
@@ -0,0 +1,214 @@
+"""
+Linopy module for solver capability tracking.
+
+This module provides a centralized registry of solver capabilities,
+replacing scattered hardcoded checks throughout the codebase.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class SolverFeature(Enum):
+    """Enumeration of all solver capabilities tracked by linopy."""
+
+    # Objective function support
+    QUADRATIC_OBJECTIVE = auto()
+
+    # I/O capabilities
+    LP_FILE_NAMES = auto()  # Support for named variables/constraints in LP files
+    SOLUTION_FILE_NOT_NEEDED = auto()  # Solver doesn't need a solution file
+
+    # Advanced features
+    IIS_COMPUTATION = auto()  # Irreducible Infeasible Set computation
+
+    # Solver-specific
+    SOLVER_ATTRIBUTE_ACCESS = auto()  # Direct access to solver variable attributes
+
+
+@dataclass(frozen=True)
+class SolverInfo:
+    """Information about a solver's capabilities."""
+
+    name: str
+    features: frozenset[SolverFeature]
+    display_name: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.display_name:
+            object.__setattr__(self, "display_name", self.name.upper())
+
+    def supports(self, feature: SolverFeature) -> bool:
+        """Check if this solver supports a given feature."""
+        return feature in self.features
+
+
+# Define all solver capabilities
+SOLVER_REGISTRY: dict[str, SolverInfo] = {
+    "gurobi": SolverInfo(
+        name="gurobi",
+        display_name="Gurobi",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+                SolverFeature.IIS_COMPUTATION,
+                SolverFeature.SOLVER_ATTRIBUTE_ACCESS,
+            }
+        ),
+    ),
+    "highs": SolverInfo(
+        name="highs",
+        display_name="HiGHS",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+            }
+        ),
+    ),
+    "glpk": SolverInfo(
+        name="glpk",
+        display_name="GLPK",
+        features=frozenset(),  # No LP_FILE_NAMES support
+    ),
+    "cbc": SolverInfo(
+        name="cbc",
+        display_name="CBC",
+        features=frozenset(),  # No LP_FILE_NAMES support
+    ),
+    "cplex": SolverInfo(
+        name="cplex",
+        display_name="CPLEX",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+            }
+        ),
+    ),
+    "xpress": SolverInfo(
+        name="xpress",
+        display_name="FICO Xpress",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+                SolverFeature.IIS_COMPUTATION,
+            }
+        ),
+    ),
+    "scip": SolverInfo(
+        name="scip",
+        display_name="SCIP",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+            }
+        ),
+    ),
+    "mosek": SolverInfo(
+        name="mosek",
+        display_name="MOSEK",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+            }
+        ),
+    ),
+    "copt": SolverInfo(
+        name="copt",
+        display_name="COPT",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+            }
+        ),
+    ),
+    "mindopt": SolverInfo(
+        name="mindopt",
+        display_name="MindOpt",
+        features=frozenset(
+            {
+                SolverFeature.QUADRATIC_OBJECTIVE,
+                SolverFeature.LP_FILE_NAMES,
+                SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+            }
+        ),
+    ),
+}
+
+
+def solver_supports(solver_name: str, feature: SolverFeature) -> bool:
+    """
+    Check if a solver supports a given feature.
+
+    Parameters
+    ----------
+    solver_name : str
+        Name of the solver (e.g., "gurobi", "highs")
+    feature : SolverFeature
+        The feature to check for
+
+    Returns
+    -------
+    bool
+        True if the solver supports the feature, False otherwise.
+        Returns False for unknown solvers.
+    """
+    if solver_name not in SOLVER_REGISTRY:
+        return False
+    return SOLVER_REGISTRY[solver_name].supports(feature)
+
+
+def get_solvers_with_feature(feature: SolverFeature) -> list[str]:
+    """
+    Get all solvers that support a given feature.
+
+    Parameters
+    ----------
+    feature : SolverFeature
+        The feature to filter by
+
+    Returns
+    -------
+    list[str]
+        List of solver names supporting the feature
+    """
+    return [name for name, info in SOLVER_REGISTRY.items() if info.supports(feature)]
+
+
+def get_available_solvers_with_feature(
+    feature: SolverFeature, available_solvers: Sequence[str]
+) -> list[str]:
+    """
+    Get installed solvers that support a given feature.
+
+    Parameters
+    ----------
+    feature : SolverFeature
+        The feature to filter by
+    available_solvers : Sequence[str]
+        List of currently available/installed solvers
+
+    Returns
+    -------
+    list[str]
+        List of installed solver names supporting the feature
+    """
+    return [s for s in get_solvers_with_feature(feature) if s in available_solvers]
diff --git a/linopy/solvers.py b/linopy/solvers.py
@@ -31,6 +31,10 @@
     Status,
     TerminationCondition,
 )
+from linopy.solver_capabilities import (
+    SolverFeature,
+    get_solvers_with_feature,
+)
 
 if TYPE_CHECKING:
     import gurobipy
@@ -39,27 +43,11 @@
 
 EnvType = TypeVar("EnvType")
 
-QUADRATIC_SOLVERS = [
-    "gurobi",
-    "xpress",
-    "cplex",
-    "highs",
-    "scip",
-    "mosek",
-    "copt",
-    "mindopt",
-]
-
-# Solvers that don't need a solution file when keep_files=False
-NO_SOLUTION_FILE_SOLVERS = [
-    "xpress",
-    "gurobi",
-    "highs",
-    "mosek",
-    "scip",
-    "copt",
-    "mindopt",
-]
+# Generated from solver_capabilities registry for backward compatibility
+QUADRATIC_SOLVERS = get_solvers_with_feature(SolverFeature.QUADRATIC_OBJECTIVE)
+NO_SOLUTION_FILE_SOLVERS = get_solvers_with_feature(
+    SolverFeature.SOLUTION_FILE_NOT_NEEDED
+)
 
 FILE_IO_APIS = ["lp", "lp-polars", "mps"]
 IO_APIS = FILE_IO_APIS + ["direct"]
diff --git a/linopy/variables.py b/linopy/variables.py
@@ -53,6 +53,7 @@
 )
 from linopy.config import options
 from linopy.constants import HELPER_DIMS, TERM_DIM
+from linopy.solver_capabilities import SolverFeature, solver_supports
 from linopy.types import (
     ConstantLike,
     DimsLike,
@@ -849,7 +850,9 @@ def get_solver_attribute(self, attr: str) -> DataArray:
         xr.DataArray
         """
         solver_model = self.model.solver_model
-        if self.model.solver_name != "gurobi":
+        if not solver_supports(
+            self.model.solver_name, SolverFeature.SOLVER_ATTRIBUTE_ACCESS
+        ):
             raise NotImplementedError(
                 "Solver attribute getter only supports the Gurobi solver for now."
             )
