fix: improve exception handling in compute_infeasibilities for unsupported solvers

- Fix CI test failures by raising NotImplementedError instead of ValueError for unsupported solvers
- Improve logic flow to check solver support first, then solver model availability
- Add better test coverage for different error scenarios (unsolved models vs missing solver models)
- Maintain backward compatibility for supported solvers (gurobi/xpress)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: FabianHofmann

linopy/model.py

@@ -1293,18 +1293,15 @@ def compute_infeasibilities(self) -> list[int]:
             Labels of the infeasible constraints.
         """
         solver_model = getattr(self, "solver_model", None)
-        if solver_model is None:
-            raise ValueError(
-                "No solver model available. The model must be solved first with "
-                "'gurobi' or 'xpress' solver and the result must be infeasible."
-            )
 
         # Check for Gurobi
         if "gurobi" in available_solvers:
             try:
                 import gurobipy
 
-                if isinstance(solver_model, gurobipy.Model):
+                if solver_model is not None and isinstance(
+                    solver_model, gurobipy.Model
+                ):
                     return self._compute_infeasibilities_gurobi(solver_model)
             except ImportError:
                 pass
@@ -1314,15 +1311,34 @@ def compute_infeasibilities(self) -> list[int]:
             try:
                 import xpress
 
-                if isinstance(solver_model, xpress.problem):
+                if solver_model is not None and isinstance(
+                    solver_model, xpress.problem
+                ):
                     return self._compute_infeasibilities_xpress(solver_model)
             except ImportError:
                 pass
 
-        raise NotImplementedError(
-            "Computing infeasibilities is only supported for Gurobi and Xpress solvers. "
-            f"Current solver model type: {type(solver_model).__name__}"
-        )
+        # If we get here, either the solver doesn't support IIS or no solver model is available
+        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"]:
+                raise ValueError(
+                    "No solver model available. The model must be solved first with "
+                    "'gurobi' or 'xpress' solver and the result must be infeasible."
+                )
+            else:
+                # This is an unsupported solver
+                raise NotImplementedError(
+                    f"Computing infeasibilities is not supported for '{solver_name}' solver. "
+                    "Only Gurobi and Xpress solvers support IIS computation."
+                )
+        else:
+            # We have a solver model but it's not a supported type
+            raise NotImplementedError(
+                "Computing infeasibilities is only supported for Gurobi and Xpress solvers. "
+                f"Current solver model type: {type(solver_model).__name__}"
+            )
 
     def _compute_infeasibilities_gurobi(self, solver_model: Any) -> list[int]:
         """Compute infeasibilities for Gurobi solver."""

test/test_infeasibility.py

@@ -136,9 +136,22 @@ def test_multi_dimensional_infeasibility(
         assert isinstance(labels, list)
         assert len(labels) > 0
 
+    def test_unsolved_model_error(self) -> None:
+        """Test error when model hasn't been solved yet."""
+        m = Model()
+        x = m.add_variables(name="x")
+        m.add_constraints(x >= 0)
+        m.add_objective(1 * x)  # Convert to LinearExpression
+
+        # Don't solve the model - should raise NotImplementedError for unsolved models
+        with pytest.raises(
+            NotImplementedError, match="Computing infeasibilities is not supported"
+        ):
+            m.compute_infeasibilities()
+
     @pytest.mark.parametrize("solver", ["gurobi", "xpress"])
     def test_no_solver_model_error(self, solver: str) -> None:
-        """Test error when no solver model is available."""
+        """Test error when solver model is not available after solving."""
         if solver not in available_solvers:
             pytest.skip(f"{solver} not available")
 
@@ -147,7 +160,14 @@ def test_no_solver_model_error(self, solver: str) -> None:
         m.add_constraints(x >= 0)
         m.add_objective(1 * x)  # Convert to LinearExpression
 
-        # Don't solve the model - should raise error
+        # Solve the model first
+        m.solve(solver_name=solver)
+
+        # Manually remove the solver_model to simulate cleanup
+        m.solver_model = None
+        m.solver_name = solver  # But keep the solver name
+
+        # Should raise ValueError since we know it was solved with supported solver
         with pytest.raises(ValueError, match="No solver model available"):
             m.compute_infeasibilities()