def test_min_version(self): mod, avail = attempt_import('pyomo.common.tests.dep_mod', minimum_version='1.0', defer_check=False) self.assertTrue(avail) self.assertTrue(inspect.ismodule(mod)) self.assertTrue(check_min_version(mod, '1.0')) self.assertFalse(check_min_version(mod, '2.0')) mod, avail = attempt_import('pyomo.common.tests.dep_mod', minimum_version='2.0', defer_check=False) self.assertFalse(avail) self.assertIs(type(mod), ModuleUnavailable) with self.assertRaisesRegex( DeferredImportError, "The pyomo.common.tests.dep_mod module " "version 1.5 does not satisfy the minimum version 2.0"): mod.hello mod, avail = attempt_import('pyomo.common.tests.dep_mod', error_message="Failed import", minimum_version='2.0', defer_check=False) self.assertFalse(avail) self.assertIs(type(mod), ModuleUnavailable) with self.assertRaisesRegex( DeferredImportError, "Failed import " r"\(version 1.5 does not satisfy the minimum version 2.0\)"): mod.hello # Verify check_min_version works with deferred imports mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True) self.assertTrue(check_min_version(mod, '1.0')) mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True) self.assertFalse(check_min_version(mod, '2.0')) # Verify check_min_version works when called directly mod, avail = attempt_import('pyomo.common.tests.dep_mod', minimum_version='1.0') self.assertTrue(check_min_version(mod, '1.0')) mod, avail = attempt_import('pyomo.common.tests.bogus', minimum_version='1.0') self.assertFalse(check_min_version(mod, '1.0'))
def test_importer(self): attempted_import = [] def _importer(): attempted_import.append(True) return attempt_import('pyomo.common.tests.dep_mod', defer_check=False)[0] mod, avail = attempt_import('foo', importer=_importer, defer_check=True) self.assertEqual(attempted_import, []) self.assertIsInstance(mod, DeferredImportModule) self.assertTrue(avail) self.assertEqual(attempted_import, [True]) self.assertIs(mod._indicator_flag._module, dep_mod)
def test_generate_warning(self): mod, avail = attempt_import('pyomo.common.tests.dep_mod_except', defer_check=True, only_catch_importerror=False) # Test generate warning log = StringIO() with LoggingIntercept(log, 'pyomo.common'): mod.generate_import_warning() self.assertEqual( log.getvalue(), "The pyomo.common.tests.dep_mod_except module " "(an optional Pyomo dependency) failed to import\n") log = StringIO() with LoggingIntercept(log, 'pyomo.core.base'): mod.generate_import_warning('pyomo.core.base') self.assertEqual( log.getvalue(), "The pyomo.common.tests.dep_mod_except module " "(an optional Pyomo dependency) failed to import\n")
from idaes.core import FlowsheetBlock, Component, LiquidPhase, VaporPhase from idaes.generic_models.properties.core.generic.generic_property import ( GenericParameterBlock) from idaes.generic_models.properties.core.state_definitions import FTPx from idaes.generic_models.properties.core.eos.ceos import Cubic, CubicType from idaes.core.util import get_solver from idaes.generic_models.properties.core.pure.ConstantProperties import \ Constant from idaes.generic_models.properties.core.coolprop.coolprop_wrapper import ( CoolPropWrapper, CoolPropExpressionError, CoolPropPropertyError) CoolProp, coolprop_available = attempt_import('CoolProp.CoolProp') solver = get_solver() @pytest.mark.skipif(not coolprop_available, reason="CoolProp not installed") class TestWrapper: @pytest.mark.unit def test_load_component(self): # Clear cached components to be sure CoolPropWrapper._cached_components = {} # Load parameters for oxygen prop_dict = CoolPropWrapper._load_component_data("Oxygen") assert prop_dict is not None assert "Oxygen" in CoolPropWrapper._cached_components
import argparse import io import logging import os import platform import re import sys import subprocess from . import envvar from .deprecation import deprecated from .errors import DeveloperError import pyomo.common from pyomo.common.dependencies import attempt_import request = attempt_import('urllib.request')[0] ssl = attempt_import('ssl')[0] zipfile = attempt_import('zipfile')[0] gzip = attempt_import('gzip')[0] distro, distro_available = attempt_import('distro') logger = logging.getLogger('pyomo.common.download') DownloadFactory = pyomo.common.Factory('library downloaders') class FileDownloader(object): _os_version = None def __init__(self, insecure=False, cacert=None): self._fname = None self.target = None
# package that is provided by NEOS: http://www.neos-server.org # import io import os import re import sys import time import socket import base64 import tempfile import logging from pyomo.common.dependencies import attempt_import xmlrpclib = attempt_import('xmlrpc.client')[0] gzip = attempt_import('gzip')[0] logger = logging.getLogger('pyomo.neos') _email_re = re.compile(r'([^@]+@[^@]+\.[a-zA-Z0-9]+)$') class NEOS(object): # NEOS currently only supports HTTPS access scheme = 'https' host = 'neos-server.org' port = '3333' # Legacy NEOS HTTP interface #urlscheme = 'http' #port = '3332'
'sinh': casadi.sinh, 'tanh': casadi.tanh, 'asin': casadi.asin, 'acos': casadi.acos, 'atan': casadi.atan, 'exp': casadi.exp, 'sqrt': casadi.sqrt, 'asinh': casadi.asinh, 'acosh': casadi.acosh, 'atanh': casadi.atanh, 'ceil': casadi.ceil, 'floor': casadi.floor, }) casadi, casadi_available = attempt_import('casadi', callback=_finalize_casadi) def _check_getitemexpression(expr, i): """ Accepts an equality expression and an index value. Checks the GetItemExpression at expr.arg(i) to see if it is a :py:class:`DerivativeVar<pyomo.dae.DerivativeVar>`. If so, return the GetItemExpression for the :py:class:`DerivativeVar<DerivativeVar>` and the RHS. If not, return None. """ if type(expr.arg(i).arg(0)) is DerivativeVar: return [expr.arg(i), expr.arg(1 - i)] else: return None
# ___________________________________________________________________________ # # Pyomo: Python Optimization Modeling Objects # Copyright (c) 2008-2022 # 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.common.dependencies import attempt_import __version__ = '1.5' numpy, numpy_available = attempt_import('numpy', defer_check=True) bogus_nonexisting_module, bogus_nonexisting_module_available \ = attempt_import('bogus_nonexisting_module', alt_names=['bogus_nem'], defer_check=True)
# cyipopt before version 1.0.3 put the __version__ flag in the ipopt # module (which was deprecated starting in 1.0.3) if not hasattr(cyipopt, '__version__'): import ipopt cyipopt.__version__ = ipopt.__version__ # Beginning in 1.0.3, STATUS_MESSAGES is in a separate # ipopt_wrapper module if not hasattr(cyipopt, 'STATUS_MESSAGES'): import ipopt_wrapper cyipopt.STATUS_MESSAGES = ipopt_wrapper.STATUS_MESSAGES return cyipopt cyipopt, cyipopt_available = attempt_import( 'ipopt', error_message='cyipopt solver relies on the ipopt module from cyipopt. ' 'See https://github.com/mechmotum/cyipopt.git for cyipopt ' 'installation instructions.', importer=_cyipopt_importer, ) # Because pynumero.interfaces requires numpy, we will leverage deferred # imports here so that the solver can be registered even when numpy is # not available. pyomo_nlp = attempt_import('pyomo.contrib.pynumero.interfaces.pyomo_nlp')[0] pyomo_grey_box = attempt_import('pyomo.contrib.pynumero.interfaces.pyomo_grey_box_nlp')[0] egb = attempt_import('pyomo.contrib.pynumero.interfaces.external_grey_box')[0] from pyomo.common.config import ConfigBlock, ConfigValue from pyomo.common.timing import TicTocTimer from pyomo.core.base import Block, Objective, minimize from pyomo.opt import (
# In some versions of XPRESS (notably 8.9.0), `import # xpress` temporarily changes the CWD. If the import fails # (e.g., due to an expired license), the CWD is not always # restored. This block ensures that the CWD is preserved. os.chdir(_cwd) self.import_message += OUT.getvalue() return xpress _xpress_importer = _xpress_importer_class() xpress, xpress_available = attempt_import( 'xpress', error_message=_xpress_importer, # Other forms of exceptions can be thrown by the xpress python # import. For example, an xpress.InterfaceError exception is thrown # if the Xpress license is not valid. Unfortunately, you can't # import without a license, which means we can't test for that # explicit exception! catch_exceptions=(Exception, ), importer=_xpress_importer, callback=_finalize_xpress_import, ) @SolverFactory.register('xpress_direct', doc='Direct python interface to XPRESS') class XpressDirect(DirectSolver): _name = None _version = None XpressException = RuntimeError
def _importer(): attempted_import.append(True) return attempt_import('pyomo.common.tests.dep_mod', defer_check=False)[0]
import logging from operator import attrgetter import os import re from pathlib import Path import shutil import sys from typing import List from uuid import uuid4 from zipfile import ZipFile import json # third-party import click # third-party slow nb_exporters = attempt_import("nbconvert.exporters")[0] nb_writers = attempt_import("nbconvert.writers")[0] traitlets_config = attempt_import("traitlets.config")[0] nbformat = attempt_import("nbformat")[0] requests = attempt_import("requests")[0] # package from idaes.commands import cb from idaes.commands.base import how_to_report_an_error from idaes.ver import package_version as V __author__ = "Dan Gunter" _log = logging.getLogger("idaes.commands.examples") # Constants
solve_NLP_subproblem, handle_NLP_subproblem_optimal, handle_NLP_subproblem_infeasible, handle_NLP_subproblem_other_termination, solve_NLP_feas) from pyomo.contrib.mindtpy.cut_generation import (add_oa_cuts, add_int_cut) from pyomo.contrib.gdpopt.util import copy_var_list_values, identify_variables from math import copysign from pyomo.environ import * from pyomo.core import Constraint, minimize, value from pyomo.core.expr import current as EXPR from math import fabs from pyomo.repn import generate_standard_repn from pyomo.common.dependencies import attempt_import single_tree, single_tree_available = attempt_import( 'pyomo.contrib.mindtpy.single_tree') def solve_OA_master(solve_data, config): solve_data.mip_iter += 1 MindtPy = solve_data.mip.MindtPy_utils config.logger.info('MIP %s: Solve master problem.' % (solve_data.mip_iter, )) # Set up MILP for c in MindtPy.constraint_list: if c.body.polynomial_degree() not in (1, 0): c.deactivate() MindtPy.MindtPy_linear_cuts.activate() main_objective = next( solve_data.mip.component_data_objects(Objective, active=True))
from pyomo.solvers.plugins.solvers.gurobi_direct import gurobipy from pyomo.contrib.mindtpy.cut_generation import add_oa_cuts, add_no_good_cuts from pyomo.contrib.mindtpy.mip_solve import handle_main_optimal, solve_main, handle_regularization_main_tc from pyomo.opt.results import ProblemSense from pyomo.contrib.mcpp.pyomo_mcpp import McCormick as mc, MCPP_Error import logging from pyomo.repn import generate_standard_repn from pyomo.core.expr import current as EXPR import pyomo.environ as pyo from math import copysign from pyomo.contrib.mindtpy.util import get_integer_solution, update_dual_bound, update_primal_bound from pyomo.contrib.gdpopt.util import copy_var_list_values, identify_variables, get_main_elapsed_time, time_code from pyomo.contrib.mindtpy.nlp_solve import solve_subproblem, solve_feasibility_subproblem, handle_nlp_subproblem_tc from pyomo.opt import TerminationCondition as tc from pyomo.core import Constraint, minimize, value, maximize cplex, cplex_available = attempt_import('cplex') class LazyOACallback_cplex( cplex.callbacks.LazyConstraintCallback if cplex_available else object): """Inherent class in Cplex to call Lazy callback.""" def copy_lazy_var_list_values(self, opt, from_list, to_list, config, skip_stale=False, skip_fixed=True, ignore_integrality=False): """This function copies variable values from one list to another.
# ___________________________________________________________________________ import logging import os import re import six import sys from pyomo.common.dependencies import attempt_import from pyomo.opt import SolverFactory, SolverManagerFactory, OptSolver from pyomo.opt.parallel.manager import ActionManagerError, ActionStatus from pyomo.opt.parallel.async_solver import (AsynchronousSolverManager) from pyomo.core.base import Block import pyomo.neos.kestrel xmlrpc_client = attempt_import('six.moves.xmlrpc_client')[0] logger = logging.getLogger('pyomo.neos') def _neos_error(msg, results, current_message): error_re = re.compile('error', flags=re.I) warn_re = re.compile('warn', flags=re.I) logger.error("%s NEOS log:\n%s" % ( msg, current_message, ), exc_info=sys.exc_info()) soln_data = results.data if six.PY3:
from pyomo.common.dependencies import ( matplotlib, matplotlib_available, numpy as np, numpy_available, pandas as pd, pandas_available, scipy, scipy_available, check_min_version, attempt_import ) plt = matplotlib.pyplot stats = scipy.stats # occasionally dependent conda packages for older distributions # (e.g. python 3.5) get released that are either broken not # compatible, resulting in a SyntaxError sns, seaborn_available = attempt_import( 'seaborn', alt_names=['sns'], catch_exceptions=(ImportError, SyntaxError) ) imports_available = numpy_available & scipy_available & pandas_available \ & matplotlib_available & seaborn_available def _get_variables(ax,columns): sps = ax.get_subplotspec() nx = sps.get_geometry()[1] ny = sps.get_geometry()[0] cell = sps.get_geometry()[2] xloc = int(np.mod(cell,nx)) yloc = int(np.mod((cell-xloc)/nx, ny)) xvar = columns[xloc] yvar = columns[yloc]
import unittest import pyomo.environ as pe from pyomo.core.base import ConcreteModel, Var, Constraint, Objective from pyomo.common.dependencies import attempt_import from pyomo.contrib.pynumero.asl import AmplInterface import parapint from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface ma27_available = MA27Interface.available() mumps, mumps_available = attempt_import('mumps', 'Interior point requires mumps') asl_available = AmplInterface.available() if not asl_available: raise unittest.SkipTest('Regularization tests require ASL') def make_model(): m = ConcreteModel() m.x = Var([1, 2, 3], initialize=0) m.f = Var([1, 2, 3], initialize=0) m.F = Var(initialize=0) m.f[1].fix(1) m.f[2].fix(2) m.sum_con = Constraint(expr=(1 == m.x[1] + m.x[2] + m.x[3])) def bilin_rule(m, i): return m.F * m.x[i] == m.f[i] m.bilin_con = Constraint([1, 2, 3], rule=bilin_rule) m.obj = Objective(expr=m.F**2)
import pyomo.common.unittest as unittest from pyomo.common.dependencies import attempt_import np, np_available = attempt_import('numpy', minimum_version='1.13.0') scipy, scipy_available = attempt_import('scipy.sparse') mumps, mumps_available = attempt_import('mumps') if not np_available or not scipy_available: raise unittest.SkipTest( 'numpy and scipy are needed for interior point tests') import numpy as np from scipy.sparse import coo_matrix, tril from pyomo.contrib import interior_point as ip from pyomo.contrib.pynumero.linalg.base import LinearSolverStatus if scipy_available: from pyomo.contrib.interior_point.linalg.scipy_interface import ScipyInterface if mumps_available: from pyomo.contrib.interior_point.linalg.mumps_interface import MumpsInterface from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface ma27_available = MA27Interface.available() if ma27_available: from pyomo.contrib.interior_point.linalg.ma27_interface import InteriorPointMA27Interface def get_base_matrix(use_tril): if use_tril: row = [0, 1, 1, 2, 2] col = [0, 0, 1, 0, 2] data = [1, 7, 4, 3, 6] else: row = [0, 0, 0, 1, 1, 2, 2] col = [0, 1, 2, 0, 1, 0, 2] data = [1, 7, 3, 7, 4, 3, 6]
from typing import Dict from pyomo.core.base.expression import _GeneralExpressionData, ScalarExpression from pyomo.core.expr.visitor import ExpressionValueVisitor, nonpyomo_leaf_types from pyomo.core.expr.numvalue import value, is_constant from pyomo.core.expr import current as _expr from pyomo.common.dependencies import attempt_import cmodel, cmodel_available = attempt_import('pyomo.contrib.appsi.cmodel.cmodel', 'Appsi requires building a small c++ extension. ' 'Please use thye "pyomo build-extensions" command') class PyomoToCModelWalker(ExpressionValueVisitor): def __init__(self, pyomo_var_to_cvar_map: Dict, pyomo_param_to_c_param_map: Dict): self._pyomo_var_to_cvar_map = pyomo_var_to_cvar_map self._pyomo_param_to_cparam_map = pyomo_param_to_c_param_map self._constant_pool = set() def finalize(self, ans): if isinstance(ans, cmodel.Node): return ans else: if len(self._constant_pool) == 0: self._constant_pool = set(cmodel.create_constants(100)) const = self._constant_pool.pop() const.value = value(ans) return const def visit(self, node, values): if node.__class__ in _pyomo_to_cmodel_map:
# Pyomo: Python Optimization Modeling Objects # Copyright 2017 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 .base_linear_solver_interface import LinearSolverInterface from .results import LinearSolverStatus, LinearSolverResults from pyomo.common.dependencies import attempt_import from scipy.sparse import isspmatrix_coo, tril from collections import OrderedDict mumps, mumps_available = attempt_import( name='pyomo.contrib.pynumero.linalg.mumps_interface', error_message='pymumps is required to use the MumpsInterface') class MumpsInterface(LinearSolverInterface): @classmethod def getLoggerName(cls): return 'mumps' def __init__(self, par=1, comm=None, cntl_options=None, icntl_options=None): self._mumps = mumps.MumpsCentralizedAssembledLinearSolver(sym=2, par=par,
# ___________________________________________________________________________ # # Pyomo: Python Optimization Modeling Objects # Copyright (c) 2008-2022 # 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. # ___________________________________________________________________________ import pyomo.common.unittest as unittest import pyomo.environ as pyo from pyomo.common.dependencies import attempt_import np, numpy_available = attempt_import('numpy', 'Interior point requires numpy', minimum_version='1.13.0') scipy, scipy_available = attempt_import('scipy', 'Interior point requires scipy') mumps, mumps_available = attempt_import('mumps', 'Interior point requires mumps') if not (numpy_available and scipy_available): raise unittest.SkipTest('Interior point tests require numpy and scipy') if scipy_available: from pyomo.contrib.interior_point.linalg.scipy_interface import ScipyInterface if mumps_available: from pyomo.contrib.interior_point.linalg.mumps_interface import MumpsInterface import numpy as np from pyomo.contrib.pynumero.asl import AmplInterface asl_available = AmplInterface.available()
import pyomo.environ as pe from pyomo.common.dependencies import attempt_import import pyomo.common.unittest as unittest parameterized, param_available = attempt_import('parameterized') if not param_available: raise unittest.SkipTest('Parameterized is not available.') parameterized = parameterized.parameterized from pyomo.contrib.appsi.base import TerminationCondition, Results, PersistentSolver from pyomo.contrib.appsi.cmodel import cmodel_available from pyomo.contrib.appsi.solvers import Gurobi, Ipopt, Cplex, Cbc from typing import Type from pyomo.core.expr.numeric_expr import LinearExpression import os all_solvers = [('gurobi', Gurobi), ('ipopt', Ipopt), ('cplex', Cplex), ('cbc', Cbc)] mip_solvers = [('gurobi', Gurobi), ('cplex', Cplex), ('cbc', Cbc)] nlp_solvers = [('ipopt', Ipopt)] qcp_solvers = [('gurobi', Gurobi), ('ipopt', Ipopt), ('cplex', Cplex)] miqcqp_solvers = [('gurobi', Gurobi), ('cplex', Cplex)] """ The tests in this file are used to ensure basic functionality/API works with all solvers Feature Tested ------- ------ config time_limit config tee config load_solution True x config load_solution False x results termination condition optimal x results termination condition infeasible x
) # Check integrator availability # scipy_available = True # try: # import platform # if platform.python_implementation() == "PyPy": # pragma:nocover # # scipy is importable into PyPy, but ODE integrators don't work. (2/18) # raise ImportError # import scipy.integrate as scipy # except ImportError: # scipy_available = False import platform is_pypy = platform.python_implementation() == "PyPy" scipy, scipy_available = attempt_import('scipy.integrate', alt_names=['scipy']) casadi_intrinsic = {} def _finalize_casadi(casadi, available): if available: casadi_intrinsic.update({ 'log': casadi.log, 'log10': casadi.log10, 'sin': casadi.sin, 'cos': casadi.cos, 'tan': casadi.tan, 'cosh': casadi.cosh, 'sinh': casadi.sinh, 'tanh': casadi.tanh, 'asin': casadi.asin, 'acos': casadi.acos,
# ___________________________________________________________________________ import pyomo.common.unittest as unittest import filecmp import glob import os import os.path import subprocess import sys from itertools import zip_longest from pyomo.opt import check_available_solvers from pyomo.common.dependencies import attempt_import, check_min_version from pyomo.common.fileutils import this_file_dir from pyomo.common.tee import capture_output parameterized, param_available = attempt_import('parameterized') if not param_available: raise unittest.SkipTest('Parameterized is not available.') # Find all *.txt files, and use them to define baseline tests currdir = this_file_dir() datadir = currdir solver_dependencies = { # abstract_ch 'test_abstract_ch_wl_abstract_script': ['glpk'], 'test_abstract_ch_pyomo_wl_abstract': ['glpk'], 'test_abstract_ch_pyomo_solve1': ['glpk'], 'test_abstract_ch_pyomo_solve2': ['glpk'], 'test_abstract_ch_pyomo_solve3': ['glpk'], 'test_abstract_ch_pyomo_solve4': ['glpk'],
import unittest from pyomo.common.dependencies import attempt_import import numpy as np from scipy.sparse import coo_matrix, tril import parapint from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface ma27_available = MA27Interface.available() mumps, mumps_available = attempt_import('mumps') def get_base_matrix(use_tril): if use_tril: row = [0, 1, 1, 2, 2] col = [0, 0, 1, 0, 2] data = [1, 7, 4, 3, 6] else: row = [0, 0, 0, 1, 1, 2, 2] col = [0, 1, 2, 0, 1, 0, 2] data = [1, 7, 3, 7, 4, 3, 6] mat = coo_matrix((data, (row, col)), shape=(3,3), dtype=np.double) return mat def get_base_matrix_wrong_order(use_tril): if use_tril: row = [1, 0, 1, 2, 2] col = [0, 0, 1, 0, 2] data = [7, 1, 4, 3, 6] else: row = [1, 0, 0, 0, 1, 2, 2]
'asinh': sympy.asinh, 'cos': sympy.cos, 'acos': sympy.acos, 'cosh': sympy.cosh, 'acosh': sympy.acosh, 'tan': sympy.tan, 'atan': sympy.atan, 'tanh': sympy.tanh, 'atanh': sympy.atanh, 'ceil': sympy.ceiling, 'floor': sympy.floor, 'sqrt': sympy.sqrt, }) sympy, sympy_available = attempt_import('sympy', callback=_configure_sympy) def _prod(*x): ans = x[0] for i in x[1:]: ans *= i return ans def _sum(*x): return sum(x_ for x_ in x) def _nondifferentiable(*x): if type(x[1]) is tuple:
import pyutilib.th as unittest import pyomo.environ as pe from pyomo.opt import check_optimal_termination from pyomo.common.dependencies import attempt_import np, numpy_available = attempt_import('numpy', 'inverse_reduced_hessian numpy', minimum_version='1.13.0') scipy, scipy_available = attempt_import( 'scipy', 'inverse_reduced_hessian requires scipy') if numpy_available: from pyomo.contrib.pynumero.asl import AmplInterface asl_available = AmplInterface.available() else: asl_available = False if not (numpy_available and scipy_available and asl_available): raise unittest.SkipTest( 'inverse_reduced_hessian tests require numpy, scipy, and asl') from pyomo.common.dependencies import (pandas as pd, pandas_available) import pyomo.environ as pe ipopt_solver = pe.SolverFactory('ipopt') if not ipopt_solver.available(exception_flag=False): raise unittest.SkipTest('ipopt is not available') numdiff_available = True try: import numdifftools as nd except: numdiff_available = False
# # This module supports testing the attempt_import() functionality when # used at the module scope. It cannot be in the actual test module, as # pytest accesses objects in the module scope during test collection # (which would inadvertantly trigger premature module import) # from pyomo.common.dependencies import attempt_import from pyomo.common.tests.dep_mod import ( bogus_nonexisting_module as bogus_nem, bogus_nonexisting_module_available as has_bogus_nem, ) bogus, bogus_available \ = attempt_import('nonexisting.module.bogus', defer_check=True) pyo, pyo_available = attempt_import('pyomo', alt_names=['pyo'], deferred_submodules={ 'version': None, 'common.tests.dep_mod': ['dm'] }) dm = pyo.common.tests.dep_mod def test_access_bogus_hello(): bogus_nem.hello
import sys import subprocess import inspect import argparse from pyutilib.misc import import_file from pyomo.common.tempfiles import TempfileManager from pyomo.common.errors import ApplicationError from pyomo.common.gc_manager import PauseGC from pyomo.opt.base import ConverterError from pyomo.common.dependencies import attempt_import from pyomo.common.plugin import (ExtensionPoint, SingletonPlugin) from pysp.util.config import PySPConfigBlock from pysp.util.configured_object import PySPConfiguredObject pyu_pyro = attempt_import('pyutilib.pyro', alt_names=['pyu_pyro'])[0] logger = logging.getLogger('pysp') def _generate_unique_module_name(): import uuid name = str(uuid.uuid4()) while name in sys.modules: name = str(uuid.uuid4()) return name def load_external_module(module_name, unique=False, clear_cache=False,
# ___________________________________________________________________________ # # Unit Tests for pyomo.base.misc # import re import sys import subprocess from collections import namedtuple from six import iteritems, itervalues import pyutilib.th as unittest from pyomo.common.dependencies import numpy_available, attempt_import pyro4, pyro4_available = attempt_import('Pyro4') class ImportData(object): def __init__(self): self.tpl = {} self.pyomo = {} self.pyutilib = {} def update(self, other): self.tpl.update(other.tpl) self.pyomo.update(other.pyomo) self.pyutilib.update(other.pyutilib) def collect_import_time(module):