Merge branch 'main' into pyros-discrete-coefficient-matching

Author: blnicho

doc/OnlineDocs/explanation/solvers/gdpopt.rst

@@ -20,7 +20,7 @@ Three algorithms are available in GDPopt:
 
 Usage and implementation details for GDPopt can be found in the PSE 2018 paper
 (`Chen et al., 2018`_), or via its
-`preprint <http://egon.cheme.cmu.edu/Papers/Chen_Pyomo_GDP_PSE2018.pdf>`_.
+`preprint <https://egon.cheme.cmu.edu/Papers/Chen_Pyomo_GDP_PSE2018.pdf>`_.
 
 Credit for prototyping and development can be found in the ``GDPopt`` class documentation, below.
 

doc/OnlineDocs/explanation/solvers/mindtpy.rst

@@ -17,10 +17,10 @@ The following algorithms are currently available in MindtPy:
 
 Usage and early implementation details for MindtPy can be found in the PSE 2018 paper Bernal et al.,
 (`ref <https://doi.org/10.1016/B978-0-444-64241-7.50144-0>`_,
-`preprint <http://egon.cheme.cmu.edu/Papers/Bernal_Chen_MindtPy_PSE2018Paper.pdf>`_).
+`preprint <https://egon.cheme.cmu.edu/Papers/Bernal_Chen_MindtPy_PSE2018Paper.pdf>`_).
 This solver implementation has been developed by `David Bernal <https://github.com/bernalde>`_
 and `Zedong Peng <https://github.com/ZedongPeng>`_ as part of research efforts at the `Bernal Research Group 
-<https://bernalde.github.io/>`_ and the `Grossmann Research Group <http://egon.cheme.cmu.edu/>`_
+<https://bernalde.github.io/>`_ and the `Grossmann Research Group <https://egon.cheme.cmu.edu/>`_
 at Purdue University and Carnegie Mellon University.
 
 .. _Duran & Grossmann, 1986: https://dx.doi.org/10.1007/BF02592064

doc/OnlineDocs/explanation/solvers/persistent.rst

@@ -24,16 +24,16 @@ Using Persistent Solvers
 The first step in using a persistent solver is to create a Pyomo model
 as usual.
 
->>> import pyomo.environ as pe
->>> m = pe.ConcreteModel()
->>> m.x = pe.Var()
->>> m.y = pe.Var()
->>> m.obj = pe.Objective(expr=m.x**2 + m.y**2)
->>> m.c = pe.Constraint(expr=m.y >= -2*m.x + 5)
+>>> import pyomo.environ as pyo
+>>> m = pyo.ConcreteModel()
+>>> m.x = pyo.Var()
+>>> m.y = pyo.Var()
+>>> m.obj = pyo.Objective(expr=m.x**2 + m.y**2)
+>>> m.c = pyo.Constraint(expr=m.y >= -2*m.x + 5)
 
 You can create an instance of a persistent solver through the SolverFactory.
 
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 
 This returns an instance of :py:class:`GurobiPersistent`. Now we need
 to tell the solver about our model.
@@ -48,7 +48,7 @@ variables and constraints. We can now solve the model.
 We can also add or remove variables, constraints, blocks, and
 objectives. For example,
 
->>> m.c2 = pe.Constraint(expr=m.y >= m.x)  # doctest: +SKIP
+>>> m.c2 = pyo.Constraint(expr=m.y >= m.x)  # doctest: +SKIP
 >>> opt.add_constraint(m.c2)  # doctest: +SKIP
 
 This tells the solver to add one new constraint but otherwise leave
@@ -69,29 +69,29 @@ code will run without error, but the solver will have an extra
 constraint. The solver will have both y >= -2*x + 5 and y <= x, which
 is not what was intended!
 
->>> m = pe.ConcreteModel()  # doctest: +SKIP
->>> m.x = pe.Var()  # doctest: +SKIP
->>> m.y = pe.Var()  # doctest: +SKIP
->>> m.c = pe.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> m = pyo.ConcreteModel()  # doctest: +SKIP
+>>> m.x = pyo.Var()  # doctest: +SKIP
+>>> m.y = pyo.Var()  # doctest: +SKIP
+>>> m.c = pyo.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 >>> opt.set_instance(m)  # doctest: +SKIP
 >>> # WRONG:
 >>> del m.c  # doctest: +SKIP
->>> m.c = pe.Constraint(expr=m.y <= m.x)  # doctest: +SKIP
+>>> m.c = pyo.Constraint(expr=m.y <= m.x)  # doctest: +SKIP
 >>> opt.add_constraint(m.c)  # doctest: +SKIP
 
 The correct way to do this is:
 
->>> m = pe.ConcreteModel()  # doctest: +SKIP
->>> m.x = pe.Var()  # doctest: +SKIP
->>> m.y = pe.Var()  # doctest: +SKIP
->>> m.c = pe.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> m = pyo.ConcreteModel()  # doctest: +SKIP
+>>> m.x = pyo.Var()  # doctest: +SKIP
+>>> m.y = pyo.Var()  # doctest: +SKIP
+>>> m.c = pyo.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 >>> opt.set_instance(m)  # doctest: +SKIP
 >>> # Correct:
 >>> opt.remove_constraint(m.c)  # doctest: +SKIP
 >>> del m.c  # doctest: +SKIP
->>> m.c = pe.Constraint(expr=m.y <= m.x)  # doctest: +SKIP
+>>> m.c = pyo.Constraint(expr=m.y <= m.x)  # doctest: +SKIP
 >>> opt.add_constraint(m.c)  # doctest: +SKIP
 
 .. warning:: Components removed from a pyomo model must be removed
@@ -100,14 +100,14 @@ The correct way to do this is:
 Additionally, unexpected behavior may result if a component is
 modified before being removed.
 
->>> m = pe.ConcreteModel()  # doctest: +SKIP
->>> m.b = pe.Block()  # doctest: +SKIP
->>> m.b.x = pe.Var()  # doctest: +SKIP
->>> m.b.y = pe.Var()  # doctest: +SKIP
->>> m.b.c = pe.Constraint(expr=m.b.y >= -2*m.b.x + 5)  # doctest: +SKIP
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> m = pyo.ConcreteModel()  # doctest: +SKIP
+>>> m.b = pyo.Block()  # doctest: +SKIP
+>>> m.b.x = pyo.Var()  # doctest: +SKIP
+>>> m.b.y = pyo.Var()  # doctest: +SKIP
+>>> m.b.c = pyo.Constraint(expr=m.b.y >= -2*m.b.x + 5)  # doctest: +SKIP
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 >>> opt.set_instance(m)  # doctest: +SKIP
->>> m.b.c2 = pe.Constraint(expr=m.b.y <= m.b.x)  # doctest: +SKIP
+>>> m.b.c2 = pyo.Constraint(expr=m.b.y <= m.b.x)  # doctest: +SKIP
 >>> # ERROR: The constraint referenced by m.b.c2 does not
 >>> # exist in the solver model.
 >>> opt.remove_block(m.b)  # doctest: +SKIP 
@@ -117,12 +117,12 @@ the solver instance, modify it with Pyomo, and then add it back to the
 solver instance. The only exception is with variables. Variables may
 be modified and then updated with with solver:
 
->>> m = pe.ConcreteModel()  # doctest: +SKIP
->>> m.x = pe.Var()  # doctest: +SKIP
->>> m.y = pe.Var()  # doctest: +SKIP
->>> m.obj = pe.Objective(expr=m.x**2 + m.y**2)  # doctest: +SKIP
->>> m.c = pe.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> m = pyo.ConcreteModel()  # doctest: +SKIP
+>>> m.x = pyo.Var()  # doctest: +SKIP
+>>> m.y = pyo.Var()  # doctest: +SKIP
+>>> m.obj = pyo.Objective(expr=m.x**2 + m.y**2)  # doctest: +SKIP
+>>> m.c = pyo.Constraint(expr=m.y >= -2*m.x + 5)  # doctest: +SKIP
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 >>> opt.set_instance(m)  # doctest: +SKIP
 >>> m.x.setlb(1.0)  # doctest: +SKIP
 >>> opt.update_var(m.x)  # doctest: +SKIP
@@ -160,13 +160,13 @@ Persistent Solver Performance
 In order to get the best performance out of the persistent solvers, use the
 "save_results" flag:
 
->>> import pyomo.environ as pe
->>> m = pe.ConcreteModel()
->>> m.x = pe.Var()
->>> m.y = pe.Var()
->>> m.obj = pe.Objective(expr=m.x**2 + m.y**2)
->>> m.c = pe.Constraint(expr=m.y >= -2*m.x + 5)
->>> opt = pe.SolverFactory('gurobi_persistent')  # doctest: +SKIP
+>>> import pyomo.environ as pyo
+>>> m = pyo.ConcreteModel()
+>>> m.x = pyo.Var()
+>>> m.y = pyo.Var()
+>>> m.obj = pyo.Objective(expr=m.x**2 + m.y**2)
+>>> m.c = pyo.Constraint(expr=m.y >= -2*m.x + 5)
+>>> opt = pyo.SolverFactory('gurobi_persistent')  # doctest: +SKIP
 >>> opt.set_instance(m)  # doctest: +SKIP
 >>> results = opt.solve(save_results=False)  # doctest: +SKIP
 

doc/OnlineDocs/explanation/solvers/pynumero/tutorial.nlp_interfaces.rst

@@ -10,7 +10,7 @@ Relevant imports
 .. doctest::
    :skipif: not numpy_available or not scipy_available or not asl_available
 
-   >>> import pyomo.environ as pe
+   >>> import pyomo.environ as pyo
    >>> from pyomo.contrib.pynumero.interfaces.pyomo_nlp import PyomoNLP
    >>> import numpy as np
 
@@ -19,12 +19,12 @@ Create a Pyomo model
 .. doctest::
    :skipif: not numpy_available or not scipy_available or not asl_available
 
-   >>> m = pe.ConcreteModel()
-   >>> m.x = pe.Var(bounds=(-5, None))
-   >>> m.y = pe.Var(initialize=2.5)
-   >>> m.obj = pe.Objective(expr=m.x**2 + m.y**2)
-   >>> m.c1 = pe.Constraint(expr=m.y == (m.x - 1)**2)
-   >>> m.c2 = pe.Constraint(expr=m.y >= pe.exp(m.x))
+   >>> m = pyo.ConcreteModel()
+   >>> m.x = pyo.Var(bounds=(-5, None))
+   >>> m.y = pyo.Var(initialize=2.5)
+   >>> m.obj = pyo.Objective(expr=m.x**2 + m.y**2)
+   >>> m.c1 = pyo.Constraint(expr=m.y == (m.x - 1)**2)
+   >>> m.c2 = pyo.Constraint(expr=m.y >= pyo.exp(m.x))
 
 Create a :py:class:`pyomo.contrib.pynumero.interfaces.pyomo_nlp.PyomoNLP` instance
 

examples/gdp/small_lit/ex1_Lee.py

@@ -13,7 +13,7 @@
 Taken from Example 1 of the paper "New Algorithms for Nonlinear Generalized Disjunctive Programming" by Lee and Grossmann
 
 This GDP problem has one disjunction containing three terms, and exactly one of them must be true. The literature can be found here:
-http://egon.cheme.cmu.edu/Papers/LeeNewAlgo.pdf
+https://egon.cheme.cmu.edu/Papers/LeeNewAlgo.pdf
 
 """
 

pyomo/common/log.py

@@ -21,6 +21,7 @@
 import inspect
 import io
 import logging
+import os
 import re
 import sys
 import textwrap
@@ -286,14 +287,22 @@ class LoggingIntercept(object):
     ----------
     output: io.TextIOBase
         the file stream to send log messages to
+
     module: str
-        the target logger name to intercept
+        the target logger name to intercept. `logger` and `module` are
+        mutually exclusive.
+
     level: int
         the logging level to intercept
+
     formatter: logging.Formatter
         the formatter to use when rendering the log messages.  If not
         specified, uses `'%(message)s'`
 
+    logger: logging.Logger
+        the target logger to intercept. `logger` and `module` are
+        mutually exclusive.
+
     Examples
     --------
     >>> import io, logging
@@ -306,17 +315,36 @@ class LoggingIntercept(object):
 
     """
 
-    def __init__(self, output=None, module=None, level=logging.WARNING, formatter=None):
+    def __init__(
+        self,
+        output=None,
+        module=None,
+        level=logging.WARNING,
+        formatter=None,
+        logger=None,
+    ):
         self.handler = None
         self.output = output
-        self.module = module
+        if logger is not None:
+            if module is not None:
+                raise ValueError(
+                    "LoggingIntercept: only one of 'module' and 'logger' is allowed"
+                )
+            self._logger = logger
+        else:
+            self._logger = logging.getLogger(module)
         self._level = level
         if formatter is None:
             formatter = logging.Formatter('%(message)s')
         self._formatter = formatter
         self._save = None
 
     def __enter__(self):
+        # Get the logger for the scope we will be overriding
+        logger = self._logger
+        self._save = logger.level, logger.propagate, logger.handlers
+        if self._level is None:
+            self._level = logger.getEffectiveLevel()
         # Set up the handler
         output = self.output
         if output is None:
@@ -326,23 +354,25 @@ def __enter__(self):
         self.handler.setFormatter(self._formatter)
         self.handler.setLevel(self._level)
         # Register the handler with the appropriate module scope
-        logger = logging.getLogger(self.module)
-        self._save = logger.level, logger.propagate, logger.handlers
         logger.handlers = []
-        logger.propagate = 0
+        logger.propagate = False
         logger.setLevel(self.handler.level)
         logger.addHandler(self.handler)
         return output
 
     def __exit__(self, et, ev, tb):
-        logger = logging.getLogger(self.module)
+        logger = self._logger
         logger.removeHandler(self.handler)
         self.handler = None
         logger.setLevel(self._save[0])
         logger.propagate = self._save[1]
         assert not logger.handlers
         logger.handlers.extend(self._save[2])
 
+    @property
+    def module(self):
+        return self._logger.name
+
 
 class LogStream(io.TextIOBase):
     """
@@ -357,6 +387,8 @@ def __init__(self, level, logger):
         self._buffer = ''
 
     def write(self, s: str) -> int:
+        if not s:
+            return 0
         res = len(s)
         if self._buffer:
             s = self._buffer + s
@@ -369,3 +401,78 @@ def write(self, s: str) -> int:
     def flush(self):
         if self._buffer:
             self.write('\n')
+
+    def redirect_streams(self, redirects):
+        """Redirect StreamHandler objects to the original file descriptors
+
+        This utility method for py:class:`~pyomo.common.tee.capture_output`
+        locates any StreamHandlers that would process messages from the
+        logger assigned to this :py:class:`LogStream` that would write
+        to the file descriptors redirected by `capture_output` and
+        yields context managers that will redirect those StreamHandlers
+        back to duplicates of the original file descriptors.
+
+        """
+        found = 0
+        logger = self._logger
+        while isinstance(logger, logging.LoggerAdapter):
+            logger = logger.logger
+        while logger:
+            for handler in logger.handlers:
+                found += 1
+                if not isinstance(handler, logging.StreamHandler):
+                    continue
+                try:
+                    fd = handler.stream.fileno()
+                except (AttributeError, OSError):
+                    fd = None
+                if fd not in redirects:
+                    continue
+                yield _StreamRedirector(handler, redirects[fd].original_fd)
+            if not logger.propagate:
+                break
+            else:
+                logger = logger.parent
+        if not found:
+            fd = logging.lastResort.stream.fileno()
+            if not redirects:
+                yield _LastResortRedirector(fd)
+            elif fd in redirects:
+                yield _LastResortRedirector(redirects[fd].original_fd)
+
+
+class _StreamRedirector(object):
+    def __init__(self, handler, fd):
+        self.handler = handler
+        self.fd = fd
+        self.orig_stream = None
+
+    def __enter__(self):
+        self.orig_stream = self.handler.stream
+        self.handler.stream = os.fdopen(
+            os.dup(self.fd), mode="w", closefd=True
+        ).__enter__()
+
+    def __exit__(self, et, ev, tb):
+        try:
+            self.handler.stream.__exit__(et, ev, tb)
+        finally:
+            self.handler.stream = self.orig_stream
+
+
+class _LastResortRedirector(object):
+    def __init__(self, fd):
+        self.fd = fd
+        self.orig_stream = None
+
+    def __enter__(self):
+        self.orig = logging.lastResort
+        logging.lastResort = logging.StreamHandler(
+            os.fdopen(os.dup(self.fd), mode="w", closefd=True).__enter__()
+        )
+
+    def __exit__(self, et, ev, tb):
+        try:
+            logging.lastResort.stream.close()
+        finally:
+            logging.lastResort = self.orig