Merge branch 'main' into fix-pyros-intersection-set

Author: shermanjasonaf

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/common/tests/test_unittest.py

@@ -12,6 +12,7 @@
 import datetime
 import multiprocessing
 import os
+import pickle
 import time
 
 import pyomo.common.unittest as unittest
@@ -191,23 +192,24 @@ def test_timeout_timeout(self):
         time.sleep(1)
         self.assertEqual(0, 0)
 
-    @unittest.timeout(10)
-    def test_timeout_skip(self):
-        if TestPyomoUnittest.test_timeout_skip.skip:
+    def timeout_skip(self, skip):
+        if skip:
             self.skipTest("Skipping this test")
         self.assertEqual(0, 1)
 
-    test_timeout_skip.skip = True
+    @unittest.timeout(10)
+    def test_timeout_skip(self):
+        self.timeout_skip(True)
 
-    def test_timeout_skip_fails(self):
-        try:
-            with self.assertRaisesRegex(unittest.SkipTest, r"Skipping this test"):
-                self.test_timeout_skip()
-            TestPyomoUnittest.test_timeout_skip.skip = False
-            with self.assertRaisesRegex(AssertionError, r"0 != 1"):
-                self.test_timeout_skip()
-        finally:
-            TestPyomoUnittest.test_timeout_skip.skip = True
+    @unittest.timeout(10)
+    def test_timeout_skip_pass(self):
+        with self.assertRaisesRegex(AssertionError, r"0 != 1"):
+            self.timeout_skip(False)
+
+    @unittest.expectedFailure
+    @unittest.timeout(10)
+    def test_timeout_skip_fail(self):
+        self.timeout_skip(False)
 
     @unittest.timeout(10)
     def bound_function(self):
@@ -218,7 +220,9 @@ def test_bound_function(self):
             self.bound_function()
             return
         with LoggingIntercept() as LOG:
-            with self.assertRaises((TypeError, EOFError, AttributeError)):
+            with self.assertRaises(
+                (TypeError, EOFError, AttributeError, pickle.PicklingError)
+            ):
                 self.bound_function()
         self.assertIn("platform that does not support 'fork'", LOG.getvalue())
         self.assertIn("one of its arguments is not serializable", LOG.getvalue())

pyomo/common/unittest.py

@@ -318,10 +318,28 @@ def _runner(pipe, qualname):
         resultType = _RunnerResult.unittest
 
         def fcn():
-            s = _unittest.TestLoader().loadTestsFromName(qualname)
-            r = _unittest.TestResult()
-            s.run(r)
-            return r.errors + r.failures, r.skipped
+            suite = _unittest.TestLoader().loadTestsFromName(qualname)
+            result = _unittest.TestResult()
+            # Starting in Python 3.14, the default interface is
+            # forkserver, so timeout will fall back on spawn (getting us
+            # here).  Unfortunately, starting in pytest 9.0, if the
+            # test is expecting to fail, pytest will completely suppress
+            # recording the failure from the subTest, causing the main
+            # test to unexpectedly succeed.  We will resolve this by
+            # looking at the testmethod we just loaded and if we are
+            # expecting a failure, then we will turn that off *in the
+            # subTest* so that the result is properly propagated.
+            for test in suite:
+                test.__unittest_expecting_failure__ = False
+                # Note: fetch the unbound function off the class and not
+                # the bound method.
+                func = getattr(test.__class__, test._testMethodName)
+                if hasattr(func, '__unittest_expecting_failure__'):
+                    delattr(func, '__unittest_expecting_failure__')
+            # Now we can actually run the test (including all necessary
+            # setUp/tearDown)
+            suite.run(result)
+            return result.errors + result.failures, result.skipped
 
         args = ()
         kwargs = {}

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/observer/__init__.py

@@ -0,0 +1,10 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________

pyomo/contrib/observer/component_collector.py

@@ -0,0 +1,115 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+
+from pyomo.core.expr.visitor import StreamBasedExpressionVisitor
+from pyomo.core.expr.numeric_expr import (
+    ExternalFunctionExpression,
+    NegationExpression,
+    PowExpression,
+    MaxExpression,
+    MinExpression,
+    ProductExpression,
+    MonomialTermExpression,
+    DivisionExpression,
+    SumExpression,
+    Expr_ifExpression,
+    UnaryFunctionExpression,
+    AbsExpression,
+)
+from pyomo.core.expr.relational_expr import (
+    RangedExpression,
+    InequalityExpression,
+    EqualityExpression,
+)
+from pyomo.core.base.var import VarData, ScalarVar
+from pyomo.core.base.param import ParamData, ScalarParam
+from pyomo.core.base.expression import ExpressionData, ScalarExpression
+from pyomo.repn.util import ExitNodeDispatcher
+from pyomo.common.collections import ComponentSet
+
+
+def handle_var(node, collector):
+    collector.variables.add(node)
+    return None
+
+
+def handle_param(node, collector):
+    collector.params.add(node)
+    return None
+
+
+def handle_named_expression(node, collector):
+    collector.named_expressions.add(node)
+    return None
+
+
+def handle_external_function(node, collector):
+    collector.external_functions.add(node)
+    return None
+
+
+def handle_skip(node, collector):
+    return None
+
+
+collector_handlers = ExitNodeDispatcher()
+collector_handlers[VarData] = handle_var
+collector_handlers[ParamData] = handle_param
+collector_handlers[ExpressionData] = handle_named_expression
+collector_handlers[ScalarExpression] = handle_named_expression
+collector_handlers[ExternalFunctionExpression] = handle_external_function
+collector_handlers[NegationExpression] = handle_skip
+collector_handlers[PowExpression] = handle_skip
+collector_handlers[MaxExpression] = handle_skip
+collector_handlers[MinExpression] = handle_skip
+collector_handlers[ProductExpression] = handle_skip
+collector_handlers[MonomialTermExpression] = handle_skip
+collector_handlers[DivisionExpression] = handle_skip
+collector_handlers[SumExpression] = handle_skip
+collector_handlers[Expr_ifExpression] = handle_skip
+collector_handlers[UnaryFunctionExpression] = handle_skip
+collector_handlers[AbsExpression] = handle_skip
+collector_handlers[RangedExpression] = handle_skip
+collector_handlers[InequalityExpression] = handle_skip
+collector_handlers[EqualityExpression] = handle_skip
+collector_handlers[int] = handle_skip
+collector_handlers[float] = handle_skip
+
+
+class _ComponentFromExprCollector(StreamBasedExpressionVisitor):
+    def __init__(self, **kwds):
+        self.named_expressions = ComponentSet()
+        self.variables = ComponentSet()
+        self.params = ComponentSet()
+        self.external_functions = ComponentSet()
+        super().__init__(**kwds)
+
+    def exitNode(self, node, data):
+        return collector_handlers[node.__class__](node, self)
+
+    def beforeChild(self, node, child, child_idx):
+        if child in self.named_expressions:
+            return False, None
+        return True, None
+
+
+_visitor = _ComponentFromExprCollector()
+
+
+def collect_components_from_expr(expr):
+    _visitor.__init__()
+    _visitor.walk_expression(expr)
+    return (
+        _visitor.named_expressions,
+        _visitor.variables,
+        _visitor.params,
+        _visitor.external_functions,
+    )