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):
