Merge branch 'main' into python37-support

pyomo/contrib/cp/tests/test_logical_to_disjunctive.py

@@ -45,7 +45,10 @@
     TransformationFactory,
 )
 
-gurobi_available = SolverFactory('gurobi').available(exception_flag=False)
+gurobi_available = (
+    SolverFactory('gurobi').available(exception_flag=False)
+    and SolverFactory('gurobi').license_is_valid()
+)
 
 
 class TestLogicalToDisjunctiveVisitor(unittest.TestCase):

pyomo/contrib/fme/tests/test_fourier_motzkin_elimination.py

@@ -771,7 +771,7 @@ def test_integer_arithmetic_non1_coefficients(self):
     def test_numerical_instability_almost_canceling(self):
         # It's possible that we get almost-but-not-quite zero on the variable
         # being eliminated when we are doing this with floating point
-        # arithmetic. This can get ugly later becuase it might get muliplied by
+        # arithmetic. This can get ugly later because it might get muliplied by
         # a large number later and start to "reappear"
         m = ConcreteModel()
         m.x = Var()

pyomo/contrib/gdpopt/tests/test_enumerate.py

@@ -28,6 +28,7 @@
 
 
 @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+@unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'Gurobi not licensed')
 class TestGDPoptEnumerate(unittest.TestCase):
     def test_solve_two_term_disjunction(self):
         m = models.makeTwoTermDisj()
@@ -144,18 +145,6 @@ def test_stop_at_iteration_limit(self):
             results.solver.termination_condition, TerminationCondition.maxIterations
         )
 
-    @unittest.skipUnless(SolverFactory('ipopt').available(), 'Ipopt not available')
-    def test_infeasible_GDP(self):
-        m = models.make_infeasible_gdp_model()
-
-        results = SolverFactory('gdpopt.enumerate').solve(m)
-
-        self.assertEqual(results.solver.iterations, 2)
-        self.assertEqual(
-            results.solver.termination_condition, TerminationCondition.infeasible
-        )
-        self.assertEqual(results.problem.lower_bound, float('inf'))
-
     def test_unbounded_GDP(self):
         m = ConcreteModel()
         m.x = Var(bounds=(-1, 10))
@@ -173,7 +162,20 @@ def test_unbounded_GDP(self):
         self.assertEqual(results.problem.lower_bound, -float('inf'))
         self.assertEqual(results.problem.upper_bound, -float('inf'))
 
-    @unittest.skipUnless(SolverFactory('ipopt').available(), 'Ipopt not available')
+
+@unittest.skipUnless(SolverFactory('ipopt').available(), 'Ipopt not available')
+class TestGDPoptEnumerate_ipopt_tests(unittest.TestCase):
+    def test_infeasible_GDP(self):
+        m = models.make_infeasible_gdp_model()
+
+        results = SolverFactory('gdpopt.enumerate').solve(m)
+
+        self.assertEqual(results.solver.iterations, 2)
+        self.assertEqual(
+            results.solver.termination_condition, TerminationCondition.infeasible
+        )
+        self.assertEqual(results.problem.lower_bound, float('inf'))
+
     def test_algorithm_specified_to_solve(self):
         m = models.twoDisj_twoCircles_easy()
 

pyomo/contrib/gdpopt/tests/test_gdpopt.py

@@ -72,6 +72,11 @@
     else False
 )
 
+gurobi_available = (
+    SolverFactory('gurobi').available(exception_flag=False)
+    and SolverFactory('gurobi').license_is_valid()
+)
+
 
 class TestGDPoptUnit(unittest.TestCase):
     """Real unit tests for GDPopt"""
@@ -129,7 +134,7 @@ def test_solve_lp(self):
             self.assertAlmostEqual(results.problem.lower_bound, 1)
             self.assertAlmostEqual(results.problem.upper_bound, 1)
 
-    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+    @unittest.skipUnless(gurobi_available, 'Gurobi not available')
     def test_solve_nlp(self):
         m = ConcreteModel()
         m.x = Var(bounds=(-5, 5))
@@ -222,7 +227,7 @@ def test_is_feasible_function(self):
         with self.assertRaisesRegex(NotImplementedError, "Found active disjunct"):
             is_feasible(m, GDP_LOA_Solver.CONFIG())
 
-    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+    @unittest.skipUnless(gurobi_available, 'Gurobi not available')
     def test_infeasible_or_unbounded_mip_termination(self):
         m = ConcreteModel()
         m.x = Var()
@@ -461,9 +466,7 @@ def test_unbounded_gdp_maximization(self):
     # [ESJ 5/16/22]: Using Gurobi for this test because glpk seems to get angry
     # on Windows when the MIP is arbitrarily bounded with the large bounds. And
     # I think I blame glpk...
-    @unittest.skipUnless(
-        SolverFactory('gurobi').available(), "Gurobi solver not available"
-    )
+    @unittest.skipUnless(gurobi_available, "Gurobi solver not available")
     def test_GDP_nonlinear_objective(self):
         m = ConcreteModel()
         m.x = Var(bounds=(-1, 10))
@@ -1672,7 +1675,7 @@ def make_model(self):
         return m
 
     @unittest.skipIf(not mcpp_available(), "MC++ is not available")
-    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+    @unittest.skipUnless(gurobi_available, 'Gurobi not available')
     def test_set_options_on_config_block(self):
         m = self.make_model()
 
@@ -1711,7 +1714,7 @@ def test_set_options_on_config_block(self):
         self.assertAlmostEqual(value(m.obj), -0.25)
 
     @unittest.skipIf(not mcpp_available(), "MC++ is not available")
-    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+    @unittest.skipUnless(gurobi_available, 'Gurobi not available')
     def test_set_options_in_init(self):
         m = self.make_model()
 
@@ -1735,7 +1738,7 @@ def test_set_options_in_init(self):
         self.assertAlmostEqual(value(m.obj), -0.25)
         self.assertEqual(opt.config.mip_solver, 'gurobi')
 
-    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi not available')
+    @unittest.skipUnless(gurobi_available, 'Gurobi not available')
     def test_no_default_algorithm(self):
         m = self.make_model()
 

pyomo/contrib/piecewise/tests/test_inner_repn_gdp.py

@@ -167,6 +167,7 @@ def test_descend_into_expressions_objective_target(self):
         )
 
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
+    @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_disaggregated_convex_combo_model(self):
         m = models.make_log_x_model()
         TransformationFactory(

pyomo/contrib/piecewise/tests/test_outer_repn_gdp.py

@@ -171,10 +171,9 @@ def test_descend_into_expressions_objective_target(self):
             self, 'contrib.piecewise.outer_repn_gdp'
         )
 
-    @unittest.skipUnless(
-        SolverFactory('gurobi').available() and scipy_available,
-        'Gurobi and/or scipy is not available',
-    )
+    @unittest.skipUnless(scipy_available, "scipy is not available")
+    @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
+    @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_multiple_choice_model(self):
         m = models.make_log_x_model()
         TransformationFactory('contrib.piecewise.multiple_choice').apply_to(m)

pyomo/contrib/piecewise/tests/test_reduced_inner_repn.py

@@ -248,6 +248,7 @@ def test_descend_into_expressions_objective_target(self):
         )
 
     @unittest.skipUnless(SolverFactory('gurobi').available(), 'Gurobi is not available')
+    @unittest.skipUnless(SolverFactory('gurobi').license_is_valid(), 'No license')
     def test_solve_convex_combo_model(self):
         m = models.make_log_x_model()
         TransformationFactory('contrib.piecewise.convex_combination').apply_to(m)

pyomo/gdp/tests/test_mbigm.py

@@ -41,7 +41,10 @@
 )
 from pyomo.repn import generate_standard_repn
 
-gurobi_available = SolverFactory('gurobi').available()
+gurobi_available = (
+    SolverFactory('gurobi').available(exception_flag=False)
+    and SolverFactory('gurobi').license_is_valid()
+)
 exdir = normpath(join(PYOMO_ROOT_DIR, 'examples', 'gdp'))
 
 

pyomo/gdp/tests/test_partition_disjuncts.py

@@ -455,7 +455,7 @@ def test_transformation_block_nested_disjunction_outer_disjunction_target(self):
         self.check_transformation_block_nested_disjunction(m, disj2, m.disj1.x)
 
     def test_transformation_block_nested_disjunction_badly_ordered_targets(self):
-        """This tests that we preprocess targets correctly becuase we don't
+        """This tests that we preprocess targets correctly because we don't
         want to double transform the inner disjunct, which is what would happen
         if we did things in the order given."""
         m = models.makeBetweenStepsPaperExample_Nested()

pyomo/solvers/plugins/solvers/GUROBI.py

@@ -19,6 +19,7 @@
 from pyomo.common import Executable
 from pyomo.common.collections import Bunch
 from pyomo.common.fileutils import this_file_dir
+from pyomo.common.tee import capture_output
 from pyomo.common.tempfiles import TempfileManager
 
 from pyomo.opt.base import ProblemFormat, ResultsFormat, OptSolver
@@ -32,8 +33,10 @@
 )
 from pyomo.opt.solver import ILMLicensedSystemCallSolver
 from pyomo.core.kernel.block import IBlock
+from pyomo.core import ConcreteModel, Var, Objective
 
 from .gurobi_direct import gurobipy_available
+from .ASL import ASL
 
 logger = logging.getLogger('pyomo.solvers')
 
@@ -69,14 +72,30 @@ def __new__(cls, *args, **kwds):
         if mode == 'os':
             opt = SolverFactory('_ossolver', **kwds)
         elif mode == 'nl':
-            opt = SolverFactory('asl', **kwds)
+            opt = SolverFactory('_gurobi_nl', **kwds)
         else:
             logger.error('Unknown IO type: %s' % mode)
             return
         opt.set_options('solver=gurobi_ampl')
         return opt
 
 
+@SolverFactory.register('_gurobi_nl', doc='NL interface to the Gurobi solver')
+class GUROBINL(ASL):
+    """NL interface to gurobi_ampl."""
+
+    def license_is_valid(self):
+        m = ConcreteModel()
+        m.x = Var(bounds=(1, 2))
+        m.obj = Objective(expr=m.x)
+        try:
+            with capture_output():
+                self.solve(m)
+            return abs(m.x.value - 1) <= 1e-4
+        except:
+            return False
+
+
 @SolverFactory.register(
     '_gurobi_shell', doc='Shell interface to the GUROBI LP/MIP solver'
 )

pyomo/solvers/tests/checks/test_gurobi_direct.py

@@ -22,6 +22,8 @@
 except ImportError:
     gurobipy_available = False
 
+gurobi_available = GurobiDirect().available(exception_flag=False)
+
 
 def clean_up_global_state():
     # Best efforts to dispose any gurobipy objects from previous tests
@@ -79,6 +81,7 @@ def test_gurobipy_not_installed(self):
 
 
 @unittest.skipIf(not gurobipy_available, "gurobipy is not available")
+@unittest.skipIf(not gurobi_available, "gurobi license is not valid")
 class GurobiParameterTests(GurobiBase):
     # Test parameter handling at the model and environment level
 
@@ -158,6 +161,7 @@ def test_param_changes_4(self):
 
 
 @unittest.skipIf(not gurobipy_available, "gurobipy is not available")
+@unittest.skipIf(not gurobi_available, "gurobi license is not valid")
 class GurobiEnvironmentTests(GurobiBase):
     # Test handling of gurobi environments
 
@@ -318,6 +322,7 @@ def test_nonmanaged_env(self):
 
 
 @unittest.skipIf(not gurobipy_available, "gurobipy is not available")
+@unittest.skipIf(not gurobi_available, "gurobi license is not valid")
 @unittest.skipIf(not single_use_license(), reason="test needs a single use license")
 class GurobiSingleUseTests(GurobiBase):
     # Integration tests for Gurobi single-use licenses (useful for checking all Gurobi