Merge branch 'main' into feature/3381_quadratic_obj_highs

mrmundt · web-flow · commit 4489372d82a7 · 2025-06-30T07:56:38.000-06:00
diff --git a/.github/workflows/test_branches.yml b/.github/workflows/test_branches.yml
@@ -534,9 +534,8 @@ jobs:
         echo "DYLD_LIBRARY_PATH=${env:DYLD_LIBRARY_PATH}:$GAMS_DIR" `
             Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
         $INSTALLER = "${env:DOWNLOAD_DIR}/gams_install.exe"
-        # We are pinning to 29.1.0 because a license is required for
-        # versions after this in order to run in demo mode.
-        $URL = "https://d37drm4t2jghv5.cloudfront.net/distributions/29.1.0"
+        # Demo licenses are included for 5mo from the newest release
+        $URL = "https://d37drm4t2jghv5.cloudfront.net/distributions/50.1.0"
         if ( "${{matrix.TARGET}}" -eq "win" ) {
             $URL = "$URL/windows/windows_x64_64.exe"
         } elseif ( "${{matrix.TARGET}}" -eq "osx" ) {
diff --git a/.github/workflows/test_pr_and_main.yml b/.github/workflows/test_pr_and_main.yml
@@ -586,9 +586,8 @@ jobs:
         echo "DYLD_LIBRARY_PATH=${env:DYLD_LIBRARY_PATH}:$GAMS_DIR" `
             Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
         $INSTALLER = "${env:DOWNLOAD_DIR}/gams_install.exe"
-        # We are pinning to 29.1.0 because a license is required for
-        # versions after this in order to run in demo mode.
-        $URL = "https://d37drm4t2jghv5.cloudfront.net/distributions/29.1.0"
+        # Demo licenses are included for 5mo from the newest release
+        $URL = "https://d37drm4t2jghv5.cloudfront.net/distributions/50.1.0"
         if ( "${{matrix.TARGET}}" -eq "win" ) {
             $URL = "$URL/windows/windows_x64_64.exe"
         } elseif ( "${{matrix.TARGET}}" -eq "osx" ) {
diff --git a/pyomo/common/dependencies.py b/pyomo/common/dependencies.py
@@ -443,25 +443,9 @@ def check_min_version(module, min_version):
             module = indicator._module
         else:
             return False
-    if check_min_version._parser is None:
-        try:
-            from packaging import version as _version
-
-            _parser = _version.parse
-        except ImportError:
-            # pkg_resources is an order of magnitude slower to import than
-            # packaging.  Only use it if the preferred (but optional)
-            # packaging library is not present
-            from pkg_resources import parse_version as _parser
-        check_min_version._parser = _parser
-    else:
-        _parser = check_min_version._parser
 
     version = getattr(module, '__version__', '0.0.0')
-    return _parser(min_version) <= _parser(version)
-
-
-check_min_version._parser = None
+    return packaging.version.parse(min_version) <= packaging.version.parse(version)
 
 
 #
@@ -993,6 +977,12 @@ def _finalize_pympler(module, available):
         import pympler.muppy
 
 
+def _finalize_packaging(module, available):
+    if available:
+        # Import key subpackages that we will want to assume are present
+        import packaging.version
+
+
 def _finalize_matplotlib(module, available):
     if not available:
         return
@@ -1094,6 +1084,10 @@ def _pyutilib_importer():
     )
     random, _ = attempt_import('random')
 
+    # Necessary for minimum version checking for other optional dependencies
+    packaging, packaging_available = attempt_import(
+        'packaging', deferred_submodules=['version'], callback=_finalize_packaging
+    )
     # Commonly-used optional dependencies
     dill, dill_available = attempt_import('dill')
     mpi4py, mpi4py_available = attempt_import(
diff --git a/pyomo/common/tests/test_dependencies.py b/pyomo/common/tests/test_dependencies.py
@@ -31,6 +31,7 @@
     dill,
     dill_available,
     mpi4py_available,
+    packaging_available,
 )
 
 import pyomo.common.tests.dep_mod as dep_mod
@@ -125,6 +126,9 @@ def test_imported_deferred_import(self):
         self.assertIs(dep_mod.bogus_nonexisting_module_available, False)
         self.assertIs(type(dep_mod.bogus_nonexisting_module), ModuleUnavailable)
 
+    @unittest.skipUnless(
+        packaging_available, "min_version tests require packaging module"
+    )
     def test_min_version(self):
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod', minimum_version='1.0', defer_import=False
@@ -177,6 +181,9 @@ def test_min_version(self):
         mod, avail = attempt_import('pyomo.common.tests.bogus', minimum_version='1.0')
         self.assertFalse(check_min_version(mod, '1.0'))
 
+    @unittest.skipUnless(
+        packaging_available, "min_version tests require packaging module"
+    )
     def test_and_or(self):
         mod0, avail0 = attempt_import('ply', defer_import=True)
         mod1, avail1 = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
@@ -231,6 +238,9 @@ def test_and_or(self):
         self.assertIsInstance(_ror, _DeferredOr)
         self.assertTrue(_ror)
 
+    @unittest.skipUnless(
+        packaging_available, "min_version tests require packaging module"
+    )
     def test_callbacks(self):
         ans = []
 
diff --git a/pyomo/contrib/appsi/solvers/maingo.py b/pyomo/contrib/appsi/solvers/maingo.py
@@ -173,11 +173,18 @@ def available(self):
         return self._available
 
     def version(self):
-        import pkg_resources
+        import importlib.metadata
 
-        version = pkg_resources.get_distribution('maingopy').version
-
-        return tuple(int(k) for k in version.split('.'))
+        try:
+            version = importlib.metadata.version('maingopy').split('.')
+        except ImportError:
+            return None
+        for i, n in enumerate(version):
+            try:
+                version[i] = int(version[i])
+            except:
+                pass
+        return tuple(version)
 
     @property
     def config(self) -> MAiNGOConfig:
diff --git a/pyomo/contrib/fme/fourier_motzkin_elimination.py b/pyomo/contrib/fme/fourier_motzkin_elimination.py
@@ -730,12 +730,9 @@ def post_process_fme_constraints(
                 continue
             # deactivate the constraint
             projected_constraints[i].deactivate()
-            m.del_component(obj)
-            # make objective to maximize its infeasibility
-            obj = Objective(
-                expr=projected_constraints[i].body - projected_constraints[i].lower
-            )
-            m.add_component(obj_name, obj)
+            # Our constraint looks like: 0 <= a^Tx - b, so make objective to
+            # maximize its infeasibility
+            obj.expr = projected_constraints[i].body - projected_constraints[i].lower
             results = solver_factory.solve(m)
             if results.solver.termination_condition == TerminationCondition.unbounded:
                 obj_val = -float('inf')
@@ -753,7 +750,6 @@ def post_process_fme_constraints(
                 obj_val = value(obj)
             # if we couldn't make it infeasible, it's useless
             if obj_val >= tolerance:
-                m.del_component(projected_constraints[i])
                 del projected_constraints[i]
             else:
                 projected_constraints[i].activate()
diff --git a/pyomo/contrib/parmest/utils/model_utils.py b/pyomo/contrib/parmest/utils/model_utils.py
@@ -134,8 +134,7 @@ def convert_params_to_vars(model, param_names=None, fix_vars=False):
             v.name in param_names for v in identify_mutable_parameters(expr)
         ):
             new_expr = replace_expressions(expr=expr, substitution_map=substitution_map)
-            model.del_component(expr)
-            model.add_component(expr.name, pyo.Expression(rule=new_expr))
+            expr.expr = new_expr
 
     # Convert Params to Vars in Constraint expressions
     num_constraints = len(list(model.component_objects(pyo.Constraint, active=True)))
diff --git a/pyomo/core/base/block.py b/pyomo/core/base/block.py
@@ -34,6 +34,7 @@
 from pyomo.common.timing import ConstructionTimer
 from pyomo.core.base.component import (
     Component,
+    ComponentData,
     ActiveComponentData,
     ModelComponentFactory,
 )
@@ -1125,16 +1126,36 @@ def del_component(self, name_or_object):
         """
         Delete a component from this block.
         """
-        obj = self.component(name_or_object)
-        # FIXME: Is this necessary?  Should this raise an exception?
-        if obj is None:
-            return
-
-        # FIXME: Is this necessary?  Should this raise an exception?
-        # if name not in self._decl:
-        #    return
+        # in-lining self.component(name_or_object) so that we can add the
+        # additional check of whether or not name_or_object is a ComponentData
+        obj = None
+        if isinstance(name_or_object, str):
+            if name_or_object in self._decl:
+                obj = self._decl_order[self._decl[name_or_object]][0]
+            else:
+                # Maintaining current behavior, but perhaps this should raise an
+                # exception?
+                return
+        else:
+            try:
+                obj = name_or_object.parent_component()
+            except AttributeError:
+                # Maintaining current behavior, but perhaps this should raise an
+                # exception?
+                return
+            if obj is not name_or_object:
+                raise ValueError(
+                    "Argument '%s' to del_component is a ComponentData object. "
+                    "Please use the Python 'del' function to delete members of "
+                    "indexed Pyomo components. The del_component function can "
+                    "only be used to delete IndexedComponents and "
+                    "ScalarComponents." % name_or_object.local_name
+                )
+            if obj.parent_block() is not self:
+                return
 
         name = obj.local_name
+
         if name in self._Block_reserved_words:
             raise ValueError(
                 "Attempting to delete a reserved block component:\n\t%s" % (obj.name,)
diff --git a/pyomo/core/base/component.py b/pyomo/core/base/component.py
@@ -732,11 +732,7 @@ class ComponentData(ComponentBase):
     This is the base class for the component data used
     in Pyomo modeling components.  Subclasses of ComponentData are
     used in indexed components, and this class assumes that indexed
-    components are subclasses of IndexedComponent.  Note that
-    ComponentData instances do not store their index.  This makes
-    some operations significantly more expensive, but these are (a)
-    associated with I/O generation and (b) this cost can be managed
-    with caches.
+    components are subclasses of IndexedComponent.
 
     Constructor arguments:
         owner           The component that owns this data object
diff --git a/pyomo/core/base/expression.py b/pyomo/core/base/expression.py
@@ -30,7 +30,11 @@
 import pyomo.core.expr.numeric_expr as numeric_expr
 from pyomo.core.base.component import ComponentData, ModelComponentFactory
 from pyomo.core.base.global_set import UnindexedComponent_index
-from pyomo.core.base.indexed_component import IndexedComponent, UnindexedComponent_set
+from pyomo.core.base.indexed_component import (
+    IndexedComponent,
+    UnindexedComponent_set,
+    IndexedComponent_NDArrayMixin,
+)
 from pyomo.core.expr.numvalue import as_numeric
 from pyomo.core.base.initializer import Initializer
 
@@ -235,7 +239,7 @@ class _GeneralExpressionData(metaclass=RenamedClass):
 @ModelComponentFactory.register(
     "Named expressions that can be used in other expressions."
 )
-class Expression(IndexedComponent):
+class Expression(IndexedComponent, IndexedComponent_NDArrayMixin):
     """A shared expression container, which may be defined over an index.
 
     Parameters
diff --git a/pyomo/core/plugins/transform/discrete_vars.py b/pyomo/core/plugins/transform/discrete_vars.py
@@ -28,6 +28,7 @@
     Constraint,
     Objective,
 )
+from pyomo.core.base.block import SubclassOf
 from pyomo.core.util import target_list
 from pyomo.gdp import Disjunct
 from pyomo.util.vars_from_expressions import get_vars_from_components
@@ -66,7 +67,7 @@ class RelaxIntegerVars(Transformation):
             doc="""
             This argument should be the reverse transformation token
             returned by a previous call to this transformation to transform
-            fixed disjunctive state in the given model.
+            fixed discrete state in the given model.
             If this argument is specified, this call to the transformation
             will reverse what the transformation did in the call that returned
             the token. Note that if there are intermediate changes to the model
@@ -116,7 +117,7 @@ def __init__(self):
         super().__init__()
 
     def _apply_to(self, model, **kwds):
-        if not model.ctype in (Block, Disjunct):
+        if model.ctype not in SubclassOf(Block):
             raise ValueError(
                 "Transformation called on %s of type %s. 'model' "
                 "must be a ConcreteModel or Block." % (model.name, model.ctype)
diff --git a/pyomo/core/tests/unit/test_block.py b/pyomo/core/tests/unit/test_block.py
@@ -50,6 +50,7 @@
     ComponentUID,
     Any,
 )
+from pyomo.common.collections import ComponentSet
 from pyomo.common.log import LoggingIntercept
 from pyomo.common.tempfiles import TempfileManager
 from pyomo.core.base.block import (
@@ -1345,6 +1346,37 @@ def test_add_del_component(self):
         self.assertFalse('x' in m.__dict__)
         self.assertIs(m.component('x'), None)
 
+    def test_del_component_data(self):
+        m = ConcreteModel()
+        self.assertFalse(m.contains_component(Var))
+        x = m.x = Var([1, 2, 3])
+        self.assertTrue(m.contains_component(Var))
+        self.assertIs(m.component('x'), x)
+        del m.x[1]
+        self.assertTrue(m.contains_component(Var))
+        self.assertTrue('x' in m.__dict__)
+        self.assertEqual(len(m.x), 2)
+        self.assertIn(m.x[2], ComponentSet(m.x.values()))
+        self.assertIn(m.x[3], ComponentSet(m.x.values()))
+
+        # This fails:
+        with self.assertRaisesRegex(
+            ValueError,
+            r"Argument 'x\[2\]' to del_component is a ComponentData object. "
+            r"Please use the Python 'del' function to delete members of "
+            r"indexed Pyomo components. The del_component function can "
+            r"only be used to delete IndexedComponents and "
+            r"ScalarComponents.",
+        ):
+            m.del_component(m.x[2])
+
+        # But we can use del
+        del m.x[2]
+        self.assertTrue(m.contains_component(Var))
+        self.assertTrue('x' in m.__dict__)
+        self.assertEqual(len(m.x), 1)
+        self.assertIn(m.x[3], ComponentSet(m.x.values()))
+
     def test_reclassify_component(self):
         m = Block()
         m.a = Var()
diff --git a/pyomo/core/tests/unit/test_expr_numpy.py b/pyomo/core/tests/unit/test_expr_numpy.py
@@ -12,7 +12,7 @@
 import pyomo.common.unittest as unittest
 
 from pyomo.common.dependencies import numpy as np, numpy_available
-from pyomo.environ import ConcreteModel, Var, Constraint
+from pyomo.environ import ConcreteModel, Var, Constraint, Param, Expression
 
 
 @unittest.skipUnless(numpy_available, "tests require numpy")
@@ -37,7 +37,7 @@ def test_scalar_operations(self):
         self.assertExpressionsEqual(np.array([5, 6]) * m.x, [5 * m.x, 6 * m.x])
         self.assertExpressionsEqual(np.array([8, m.x]) * m.x, [8 * m.x, m.x * m.x])
 
-    def test_vector_operations(self):
+    def test_variable_vector_operations(self):
         m = ConcreteModel()
         m.x = Var()
         m.y = Var([0, 1, 2])
@@ -90,6 +90,21 @@ def test_vector_operations(self):
                 m.x * m.y * a, [5 * m.y[0] * m.x, 5 * m.y[1] * m.x, 5 * m.y[2] * m.x]
             )
 
+    def test_expression_vector_operations(self):
+        m = ConcreteModel()
+        m.p = Param(range(3), range(2), initialize=lambda m, i, j: 10 * i + j)
+
+        m.e = Expression(range(3))
+        m.f = Expression(range(2))
+
+        expr = np.transpose(m.e) @ m.p @ m.f
+        print(expr)
+        self.assertExpressionsEqual(
+            expr,
+            (m.e[0] * 0 + m.e[1] * 10 + m.e[2] * 20) * m.f[0]
+            + (m.e[0] * 1 + m.e[1] * 11 + m.e[2] * 21) * m.f[1],
+        )
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/pyomo/neos/kestrel.py b/pyomo/neos/kestrel.py
@@ -122,7 +122,12 @@ def setup_connection(self):
         try:
             result = self.neos.ping()
             logger.info("OK.")
-        except (socket.error, xmlrpclib.ProtocolError, http.client.BadStatusLine):
+        except (
+            socket.error,
+            xmlrpclib.ProtocolError,
+            http.client.BadStatusLine,
+            NotImplementedError,
+        ):
             e = sys.exc_info()[1]
             self.neos = None
             logger.info("Fail: %s" % (e,))
diff --git a/pyomo/scripting/pyomo_main.py b/pyomo/scripting/pyomo_main.py
diff --git a/pyomo/version/tests/test_version.py b/pyomo/version/tests/test_version.py
diff --git a/setup.py b/setup.py
