Merge remote-tracking branch 'origin/main' into observer

Author: michaelbynum

examples/pyomo/piecewise/indexed.py

@@ -9,7 +9,7 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
-# A piewise approximiation of a nonconvex objective function.
+# A piecewise approximation of a nonconvex objective function.
 
 import pyomo.environ as pyo
 

pyomo/contrib/doe/tests/test_doe_solve.py

@@ -251,7 +251,9 @@ def test_reactor_obj_cholesky_solve(self):
         # Make sure FIM and Q.T @ sigma_inv @ Q are close (alternate definition of FIM)
         self.assertTrue(np.all(np.isclose(FIM, Q.T @ sigma_inv @ Q)))
 
-    def test_reactor_obj_cholesky_solve_bad_prior(self):
+    def DISABLE_test_reactor_obj_cholesky_solve_bad_prior(self):
+        # [10/2025] This test has been disabled because it frequently
+        # (and randomly) returns "infeasible" when run on Windows.
         from pyomo.contrib.doe.doe import _SMALL_TOLERANCE_DEFINITENESS
 
         fd_method = "central"

pyomo/contrib/solver/common/results.py

@@ -197,14 +197,6 @@ def __init__(
                 description="A tuple representing the version of the solver in use.",
             ),
         )
-        self.iteration_count: Optional[int] = self.declare(
-            'iteration_count',
-            ConfigValue(
-                domain=NonNegativeInt,
-                default=None,
-                description="The total number of iterations.",
-            ),
-        )
         self.timing_info: ConfigDict = self.declare(
             'timing_info', ConfigDict(implicit=True)
         )

pyomo/contrib/solver/solvers/gurobi_direct.py

@@ -14,6 +14,7 @@
 import math
 import operator
 import os
+import logging
 
 from pyomo.common.collections import ComponentMap, ComponentSet
 from pyomo.common.config import ConfigValue
@@ -43,6 +44,7 @@
 )
 from pyomo.contrib.solver.common.solution_loader import SolutionLoaderBase
 
+logger = logging.getLogger(__name__)
 
 gurobipy, gurobipy_available = attempt_import('gurobipy')
 
@@ -442,7 +444,9 @@ def _postsolve(self, timer: HierarchicalTimer, config, loader):
             results.incumbent_objective = None
             results.objective_bound = None
 
-        results.iteration_count = grb_model.getAttr('IterCount')
+        results.extra_info.IterCount = grb_model.getAttr('IterCount')
+        results.extra_info.BarIterCount = grb_model.getAttr('BarIterCount')
+        results.extra_info.NodeCount = grb_model.getAttr('NodeCount')
 
         timer.start('load solution')
         if config.load_solutions:

pyomo/contrib/solver/solvers/gurobi_persistent.py

@@ -857,7 +857,9 @@ def _postsolve(self, timer: HierarchicalTimer):
             ):
                 results.incumbent_objective = None
 
-        results.iteration_count = gprob.getAttr('IterCount')
+        results.extra_info.IterCount = gprob.getAttr('IterCount')
+        results.extra_info.BarIterCount = gprob.getAttr('BarIterCount')
+        results.extra_info.NodeCount = gprob.getAttr('NodeCount')
 
         timer.start('load solution')
         if config.load_solutions:

pyomo/contrib/solver/solvers/highs.py

@@ -750,7 +750,15 @@ def _postsolve(self, stream: io.StringIO):
                     results.objective_bound = None
             else:
                 results.objective_bound = info.mip_dual_bound
-            results.iteration_count = info.simplex_iteration_count
+
+            if info.valid:
+                results.extra_info.simplex_iteration_count = (
+                    info.simplex_iteration_count
+                )
+                results.extra_info.ipm_iteration_count = info.ipm_iteration_count
+                results.extra_info.mip_node_count = info.mip_node_count
+                results.extra_info.pdlp_iteration_count = info.pdlp_iteration_count
+                results.extra_info.qp_iteration_count = info.qp_iteration_count
 
         if config.load_solutions:
             if has_feasible_solution:

pyomo/contrib/solver/solvers/ipopt.py

@@ -473,7 +473,7 @@ def solve(self, model, **kwds) -> Results:
                 results = Results()
                 results.termination_condition = TerminationCondition.provenInfeasible
                 results.solution_loader = SolSolutionLoader(None, None)
-                results.iteration_count = 0
+                results.extra_info.iteration_count = 0
                 results.timing_info.total_seconds = 0
             elif len(nl_info.variables) == 0:
                 if len(nl_info.eliminated_vars) == 0:
@@ -487,7 +487,7 @@ def solve(self, model, **kwds) -> Results:
                     )
                     results.solution_status = SolutionStatus.optimal
                     results.solution_loader = SolSolutionLoader(None, nl_info=nl_info)
-                    results.iteration_count = 0
+                    results.extra_info.iteration_count = 0
                     results.timing_info.total_seconds = 0
             else:
                 if os.path.isfile(basename + '.sol'):
@@ -503,7 +503,9 @@ def solve(self, model, **kwds) -> Results:
                     results.solution_loader = SolSolutionLoader(None, None)
                 else:
                     try:
-                        results.iteration_count = parsed_output_data.pop('iters')
+                        results.extra_info.iteration_count = parsed_output_data.pop(
+                            'iters'
+                        )
                         cpu_seconds = parsed_output_data.pop('cpu_seconds')
                         for k, v in cpu_seconds.items():
                             results.timing_info[k] = v

pyomo/contrib/solver/solvers/knitro/base.py

@@ -82,7 +82,7 @@ def solve(self, model: BlockData, **kwds) -> Results:
         if config.restore_variable_values_after_solve:
             self._save_var_values()
 
-        with capture_output(TeeStream(self._stream, *config.tee), capture_fd=False):
+        with capture_output(TeeStream(self._stream, *config.tee), capture_fd=True):
             self._solve(config, timer)
 
         if config.restore_variable_values_after_solve:
@@ -141,7 +141,7 @@ def _postsolve(self, config: KnitroConfig, timer: HierarchicalTimer) -> Results:
         results.solution_status = self._get_solution_status(status)
         results.termination_condition = self._get_termination_condition(status)
         results.incumbent_objective = self._engine.get_obj_value()
-        results.iteration_count = self._engine.get_num_iters()
+        results.extra_info.iteration_count = self._engine.get_num_iters()
         results.timing_info.solve_time = self._engine.get_solve_time()
         results.timing_info.timer = timer
 

pyomo/contrib/solver/tests/solvers/test_ipopt.py

@@ -594,13 +594,13 @@ def test_ipopt_quiet_print_level(self):
         result = ipopt.Ipopt().solve(model, solver_options={'print_level': 0})
         # IPOPT doesn't tell us anything about the iters if the print level
         # is set to 0
-        self.assertIsNone(result.iteration_count)
+        self.assertFalse(hasattr(result.extra_info, 'iteration_count'))
         self.assertFalse(hasattr(result.extra_info, 'iteration_log'))
         model = self.create_model()
         result = ipopt.Ipopt().solve(model, solver_options={'print_level': 3})
         # At a slightly higher level, we get some of the info, like
         # iteration count, but NOT iteration_log
-        self.assertEqual(result.iteration_count, 11)
+        self.assertEqual(result.extra_info.iteration_count, 11)
         self.assertFalse(hasattr(result.extra_info, 'iteration_log'))
 
     def test_ipopt_loud_print_level(self):
@@ -609,13 +609,13 @@ def test_ipopt_loud_print_level(self):
             result = ipopt.Ipopt().solve(model, solver_options={'print_level': 8})
             # Nothing unexpected should be in the results object at this point,
             # except that the solver_log is significantly longer
-            self.assertEqual(result.iteration_count, 11)
+            self.assertEqual(result.extra_info.iteration_count, 11)
             self.assertEqual(result.incumbent_objective, 7.013645951336496e-25)
             self.assertIn('Optimal Solution Found', result.extra_info.solver_message)
             self.assertTrue(hasattr(result.extra_info, 'iteration_log'))
             model = self.create_model()
             result = ipopt.Ipopt().solve(model, solver_options={'print_level': 12})
-            self.assertEqual(result.iteration_count, 11)
+            self.assertEqual(result.extra_info.iteration_count, 11)
             self.assertEqual(result.incumbent_objective, 7.013645951336496e-25)
             self.assertIn('Optimal Solution Found', result.extra_info.solver_message)
             self.assertTrue(hasattr(result.extra_info, 'iteration_log'))
@@ -624,7 +624,7 @@ def test_ipopt_results(self):
         model = self.create_model()
         results = ipopt.Ipopt().solve(model)
         self.assertEqual(results.solver_name, 'ipopt')
-        self.assertEqual(results.iteration_count, 11)
+        self.assertEqual(results.extra_info.iteration_count, 11)
         self.assertEqual(results.incumbent_objective, 7.013645951336496e-25)
         self.assertIn('Optimal Solution Found', results.extra_info.solver_message)
 

pyomo/contrib/solver/tests/solvers/test_knitro_direct.py

@@ -9,6 +9,9 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
+import io
+from contextlib import redirect_stdout
+
 import pyomo.common.unittest as unittest
 
 from pyomo.contrib.solver.solvers.knitro.config import KnitroConfig
@@ -87,6 +90,32 @@ class TestKnitroDirectSolver(unittest.TestCase):
     def setUp(self):
         self.opt = KnitroDirectSolver()
 
+    def test_solve_tee(self):
+        m = pyo.ConcreteModel()
+        m.x = pyo.Var(initialize=1.5, bounds=(-5, 5))
+        m.y = pyo.Var(initialize=1.5, bounds=(-5, 5))
+        m.obj = pyo.Objective(
+            expr=(1.0 - m.x) + 100.0 * (m.y - m.x), sense=pyo.minimize
+        )
+        stream = io.StringIO()
+        with redirect_stdout(stream):
+            self.opt.solve(m, tee=True)
+        output = stream.getvalue()
+        self.assertTrue(bool(output.strip()))
+
+    def test_solve_no_tee(self):
+        m = pyo.ConcreteModel()
+        m.x = pyo.Var(initialize=1.5, bounds=(-5, 5))
+        m.y = pyo.Var(initialize=1.5, bounds=(-5, 5))
+        m.obj = pyo.Objective(
+            expr=(1.0 - m.x) + 100.0 * (m.y - m.x), sense=pyo.minimize
+        )
+        stream = io.StringIO()
+        with redirect_stdout(stream):
+            self.opt.solve(m, tee=False)
+        output = stream.getvalue()
+        self.assertFalse(bool(output.strip()))
+
     def test_solve(self):
         m = pyo.ConcreteModel()
         m.x = pyo.Var(initialize=1.5, bounds=(-5, 5))