def solve(self, model, timer: HierarchicalTimer = None):
self.available(exception_flag=True)
if timer is None:
timer = HierarchicalTimer()
try:
TempfileManager.push()
if self.config.filename is None:
self._filename = TempfileManager.create_tempfile()
else:
self._filename = self.config.filename
TempfileManager.add_tempfile(self._filename + '.lp', exists=False)
TempfileManager.add_tempfile(self._filename + '.soln',
exists=False)
TempfileManager.add_tempfile(self._filename + '.log', exists=False)
timer.start('write lp file')
self._writer.write(model, self._filename + '.lp', timer=timer)
timer.stop('write lp file')
res = self._apply_solver(timer)
if self.config.report_timing:
logger.info('\n' + str(timer))
return res
finally:
# finally, clean any temporary files registered with the
# temp file manager, created/populated *directly* by this
# plugin.
TempfileManager.pop(remove=not self.config.keepfiles)
if not self.config.keepfiles:
self._filename = None
if self.config.report_timing:
print(timer)
def test_clear(self):
"""Test clear logic"""
TempfileManager.push()
OUTPUT = open(tempdir + 'pushpop2', 'w')
OUTPUT.write('tempfile\n')
OUTPUT.close()
os.mkdir(tempdir + 'pushpopdir2')
TempfileManager.add_tempfile(tempdir + 'pushpop2')
TempfileManager.add_tempfile(tempdir + 'pushpopdir2')
TempfileManager.push()
OUTPUT = open(tempdir + 'pushpop2a', 'w')
OUTPUT.write('tempfile\n')
OUTPUT.close()
os.mkdir(tempdir + 'pushpopdir2a')
TempfileManager.add_tempfile(tempdir + 'pushpop2a')
TempfileManager.add_tempfile(tempdir + 'pushpopdir2a')
TempfileManager.clear_tempfiles()
if os.path.exists(tempdir + 'pushpop2a'):
self.fail("clear_tempfiles() failed to clean out files")
if os.path.exists(tempdir + 'pushpopdir2a'):
self.fail("clear_tempfiles() failed to clean out directories")
if os.path.exists(tempdir + 'pushpop2'):
self.fail("clear_tempfiles() failed to clean out files")
if os.path.exists(tempdir + 'pushpopdir2'):
self.fail("clear_tempfiles() failed to clean out directories")
def test_open_tempfile_windows(self):
TempfileManager.push()
fname = TempfileManager.create_tempfile()
f = open(fname)
try:
_orig = tempfiles.deletion_errors_are_fatal
tempfiles.deletion_errors_are_fatal = True
with self.assertRaisesRegex(WindowsError,
".*process cannot access the file"):
TempfileManager.pop()
finally:
tempfiles.deletion_errors_are_fatal = _orig
f.close()
os.remove(fname)
TempfileManager.push()
fname = TempfileManager.create_tempfile()
f = open(fname)
log = StringIO()
try:
_orig = tempfiles.deletion_errors_are_fatal
tempfiles.deletion_errors_are_fatal = False
with LoggingIntercept(log, 'pyomo.common'):
TempfileManager.pop()
self.assertIn("Unable to delete temporary file", log.getvalue())
finally:
tempfiles.deletion_errors_are_fatal = _orig
f.close()
os.remove(fname)
def test_deprecated_tempdir(self):
TempfileManager.push()
try:
tmpdir = TempfileManager.create_tempdir()
_orig = pyutilib_mngr.tempdir
pyutilib_mngr.tempdir = tmpdir
TempfileManager.tempdir = None
log = StringIO()
with LoggingIntercept(log, 'pyomo'):
fname = TempfileManager.create_tempfile()
self.assertIn(
"The use of the PyUtilib TempfileManager.tempdir "
"to specify the default location for Pyomo "
"temporary files",
log.getvalue().replace("\n", " "))
log = StringIO()
with LoggingIntercept(log, 'pyomo'):
dname = TempfileManager.create_tempdir()
self.assertIn(
"The use of the PyUtilib TempfileManager.tempdir "
"to specify the default location for Pyomo "
"temporary directories",
log.getvalue().replace("\n", " "))
finally:
TempfileManager.pop()
pyutilib_mngr.tempdir = _orig
def _presolve(self, *args, **kwds):
"""
Peform presolves.
"""
TempfileManager.push()
self._keepfiles = kwds.pop("keepfiles", False)
self._define_signal_handlers = kwds.pop('use_signal_handling', None)
OptSolver._presolve(self, *args, **kwds)
#
# Verify that the input problems exists
#
for filename in self._problem_files:
if not os.path.exists(filename):
msg = 'Solver failed to locate input problem file: %s'
raise ValueError(msg % filename)
#
# Create command line
#
self._command = self.create_command_line(self.executable(),
self._problem_files)
self._log_file = self._command.log_file
#
# The pre-cleanup is probably unncessary, but also not harmful.
#
if (self._log_file is not None) and \
os.path.exists(self._log_file):
os.remove(self._log_file)
if (self._soln_file is not None) and \
os.path.exists(self._soln_file):
os.remove(self._soln_file)
def solve(self, model, timer: HierarchicalTimer = None):
avail = self.available()
if not avail:
raise PyomoException(
f'Solver {self.__class__} is not available ({avail}).')
if self._last_results_object is not None:
self._last_results_object.solution_loader.invalidate()
if timer is None:
timer = HierarchicalTimer()
try:
TempfileManager.push()
if self.config.filename is None:
self._filename = TempfileManager.create_tempfile()
else:
self._filename = self.config.filename
TempfileManager.add_tempfile(self._filename + '.lp', exists=False)
TempfileManager.add_tempfile(self._filename + '.log', exists=False)
timer.start('write lp file')
self._writer.write(model, self._filename + '.lp', timer=timer)
timer.stop('write lp file')
res = self._apply_solver(timer)
self._last_results_object = res
if self.config.report_timing:
logger.info('\n' + str(timer))
return res
finally:
# finally, clean any temporary files registered with the
# temp file manager, created/populated *directly* by this
# plugin.
TempfileManager.pop(remove=not self.config.keepfiles)
if not self.config.keepfiles:
self._filename = None
def solve(self, sp, *args, **kwds):
"""
Solve a stochastic program.
See the 'solve' method on the base class for
additional keyword documentation.
Args:
sp: The stochastic program to solve.
keep_solver_files (bool): Retain temporary solver
input and output files after the solve completes.
*args: Passed to the derived solver class
(see the _solve_impl method).
**kwds: Passed to the derived solver class
(see the _solve_impl method).
Returns: A results object with information about the solution.
"""
self._files.clear()
assert self.executable is not None
keep_solver_files = kwds.pop("keep_solver_files", False)
TempfileManager.push()
try:
return super(SPSolverShellCommand, self).solve(sp, *args, **kwds)
finally:
# cleanup
TempfileManager.pop(remove=not keep_solver_files)
if keep_solver_files:
logger.info("Retaining the following solver files:\n" +
pprint.pformat(self.files))
def test_pushpop1_dir(self):
"""Test pushpop logic with directories"""
TempfileManager.push()
os.mkdir(tempdir + 'pushpop1')
TempfileManager.add_tempfile(tempdir + 'pushpop1')
TempfileManager.pop()
if os.path.exists(tempdir + 'pushpop1'):
self.fail("pop() failed to clean out directories")
def do_setup(self, flag):
TempfileManager.push()
if flag:
if not cplexamp_available:
self.skipTest("The 'cplexamp' command is not available")
self.asl = SolverFactory('asl:cplexamp')
else:
self.asl = SolverFactory('_mock_asl:cplexamp')
def _presolve(self, *args, **kwds):
# create a context in the temporary file manager for
# this plugin - is "pop"ed in the _postsolve method.
TempfileManager.push()
# if the first argument is a string (representing a filename),
# then we don't have an instance => the solver is being applied
# to a file.
self._warm_start_solve = kwds.pop('warmstart', False)
self._warm_start_file_name = kwds.pop('warmstart_file', None)
user_warmstart = False
if self._warm_start_file_name is not None:
user_warmstart = True
# the input argument can currently be one of two things: an
# instance or a filename. if a filename is provided and a
# warm-start is indicated, we go ahead and create the temporary
# file - assuming that the user has already, via some external
# mechanism, invoked warm_start() with a instance to create the
# warm start file.
if self._warm_start_solve and \
isinstance(args[0], str):
# we assume the user knows what they are doing...
pass
elif self._warm_start_solve and \
(not isinstance(args[0], str)):
# assign the name of the warm start file *before* calling
# the base class presolve - the base class method ends up
# creating the command line, and the warm start file-name is
# (obviously) needed there.
if self._warm_start_file_name is None:
assert not user_warmstart
self._warm_start_file_name = TempfileManager.create_tempfile(
suffix='.gurobi.mst')
# let the base class handle any remaining keywords/actions.
ILMLicensedSystemCallSolver._presolve(self, *args, **kwds)
# NB: we must let the base class presolve run first so that the
# symbol_map is actually constructed!
if (len(args) > 0) and (not isinstance(args[0], str)):
if len(args) != 1:
raise ValueError(
"GUROBI _presolve method can only handle a single "
"problem instance - %s were supplied" % (len(args), ))
# write the warm-start file - currently only supports MIPs.
# we only know how to deal with a single problem instance.
if self._warm_start_solve and (not user_warmstart):
start_time = time.time()
self._warm_start(args[0])
end_time = time.time()
if self._report_timing is True:
print("Warm start write time=%.2f seconds" %
(end_time - start_time))
def _run_ipopt_with_stats(model, solver, max_iter=500, max_cpu_time=120):
"""
Run the solver (must be ipopt) and return the convergence statistics
Parameters
----------
model : Pyomo model
The pyomo model to be solved
solver : Pyomo solver
The pyomo solver to use - it must be ipopt, but with whichever options
are preferred
max_iter : int
The maximum number of iterations to allow for ipopt
max_cpu_time : int
The maximum cpu time to allow for ipopt (in seconds)
Returns
-------
Returns a tuple with (solve status object, bool (solve successful or
not), number of iters, solve time)
"""
# ToDo: Check that the "solver" is, in fact, IPOPT
TempfileManager.push()
tempfile = TempfileManager.create_tempfile(suffix='ipopt_out', text=True)
opts = {
'output_file': tempfile,
'max_iter': max_iter,
'max_cpu_time': max_cpu_time
}
status_obj = solver.solve(model, options=opts, tee=True)
solved = True
if status_obj.solver.termination_condition != TerminationCondition.optimal:
solved = False
iters = 0
time = 0
# parse the output file to get the iteration count, solver times, etc.
with open(tempfile, 'r') as f:
for line in f:
if line.startswith('Number of Iterations....:'):
tokens = line.split()
iters = int(tokens[3])
elif line.startswith(
'Total CPU secs in IPOPT (w/o function evaluations) ='):
tokens = line.split()
time += float(tokens[9])
elif line.startswith(
'Total CPU secs in NLP function evaluations ='):
tokens = line.split()
time += float(tokens[8])
TempfileManager.pop(remove=True)
return status_obj, solved, iters, time
def test_pushpop1(self):
"""Test pushpop logic"""
TempfileManager.push()
OUTPUT = open(tempdir + 'pushpop1', 'w')
OUTPUT.write('tempfile\n')
OUTPUT.close()
TempfileManager.add_tempfile(tempdir + 'pushpop1')
TempfileManager.pop()
if os.path.exists(tempdir + 'pushpop1'):
self.fail("pop() failed to clean out files")
def __enter__(self):
self._cwd = os.getcwd()
# Add a new context
TempfileManager.push()
# Create a new tempdir in this context
self._tempdir = TempfileManager.create_tempdir(
suffix=self._suffix,
prefix=self._prefix,
dir=self._dir,
)
os.chdir(self._tempdir)
def setUp(self):
if not scip_available:
self.skipTest("The 'scipampl' command is not available")
TempfileManager.push()
self.scip = SolverFactory('scip', solver_io='nl')
m = self.model = ConcreteModel()
m.v = Var()
m.o = Objective(expr=m.v)
m.c = Constraint(expr=m.v >= 1)
def _presolve(self, **kwds):
warmstart_flag = kwds.pop('warmstart', False)
self._keepfiles = kwds.pop('keepfiles', False)
self._save_results = kwds.pop('save_results', True)
self._integer_only_warmstarts = kwds.pop('integer_only_warmstarts',
False)
# create a context in the temporary file manager for
# this plugin - is "pop"ed in the _postsolve method.
TempfileManager.push()
self.results = None
model = self._pyomo_model
# this implies we have a custom solution "parser",
# preventing the OptSolver _presolve method from
# creating one
self._results_format = ResultsFormat.soln
# use the base class _presolve to consume the
# important keywords
OptSolver._presolve(self, **kwds)
# ***********************************************************
# The following code is only needed for backwards compatability of load_solutions=False.
# If we ever only want to support the load_vars, load_duals, etc. methods, then this can be deleted.
if self._save_results:
self._smap_id = id(self._symbol_map)
if isinstance(self._pyomo_model, IBlock):
# BIG HACK (see pyomo.core.kernel write function)
if not hasattr(self._pyomo_model, "._symbol_maps"):
setattr(self._pyomo_model, "._symbol_maps", {})
getattr(self._pyomo_model,
"._symbol_maps")[self._smap_id] = self._symbol_map
else:
self._pyomo_model.solutions.add_symbol_map(self._symbol_map)
# ***********************************************************
if warmstart_flag:
if self.warm_start_capable():
self._warm_start()
else:
raise ValueError(
'{0} solver plugin is not capable of warmstart.'.format(
type(self)))
if self._log_file is None:
self._log_file = TempfileManager.create_tempfile(suffix='.log')
def setUp(self):
if not ipopt_available:
self.skipTest("The 'ipopt' command is not available")
TempfileManager.push()
self.asl = pyomo.opt.SolverFactory('asl:ipopt', keepfiles=True)
self.ipopt = pyomo.opt.SolverFactory('ipopt', keepfiles=True)
# The sisser CUTEr instance
# Formulated in Pyomo by Carl D. Laird, Daniel P. Word, Brandon
# C. Barrera and Saumyajyoti Chaudhuri
# Taken from:
# Source:
# F.S. Sisser,
# "Elimination of bounds in optimization problems by transforming
# variables",
# Mathematical Programming 20:110-121, 1981.
# See also Buckley#216 (p. 91)
# SIF input: Ph. Toint, Dec 1989.
# classification OUR2-AN-2-0
sisser_instance = ConcreteModel()
sisser_instance.N = RangeSet(1, 2)
sisser_instance.xinit = Param(sisser_instance.N,
initialize={
1: 1.0,
2: 0.1
})
def fa(model, i):
return value(model.xinit[i])
sisser_instance.x = Var(sisser_instance.N, initialize=fa)
def f(model):
return 3 * model.x[1]**4 - 2 * (model.x[1] *
model.x[2])**2 + 3 * model.x[2]**4
sisser_instance.f = Objective(rule=f, sense=minimize)
self.sisser_instance = sisser_instance
def generate_scenario_tree_image(options):
with ScenarioTreeInstanceFactory(
options.model_location, options.scenario_tree_location) as factory:
scenario_tree = factory.generate_scenario_tree(
downsample_fraction=options.scenario_tree_downsample_fraction,
bundles=options.scenario_bundle_specification,
random_bundles=options.create_random_bundles,
random_seed=options.scenario_tree_random_seed,
verbose=options.verbose)
with TempfileManager.push():
tmpdotfile = TempfileManager.create_tempfile(suffix=".dot")
scenario_tree.save_to_dot(tmpdotfile)
os.system('dot -Tpdf -o %s %s' % (options.output_file, tmpdotfile))
print("Output Saved To: %s" % (options.output_file))
def setUp(self):
TempfileManager.push()
self.mock_model = self.get_mock_model()
self.mock_cplex_shell = self.get_mock_cplex_shell(self.mock_model)
self.mock_cplex_shell._priorities_file_name = TempfileManager.create_tempfile(
suffix=".cplex.ord")
def setUp(self):
TempfileManager.push()
def test_warm_start(self):
m = ConcreteModel()
m.x = Var()
m.z = Var(domain=Integers)
m.w = Var(domain=Boolean)
m.c = Constraint(expr=m.x + m.z + m.w >= 0)
m.o = Objective(expr=m.x + m.z + m.w)
TempfileManager.push()
tempdir = os.path.dirname(TempfileManager.create_tempfile())
TempfileManager.pop()
sameDrive = os.path.splitdrive(tempdir)[0] == \
os.path.splitdrive(os.getcwd())[0]
# At the moment, CBC does not cleanly handle windows-style drive
# names in the MIPSTART file name (though at least 2.10.5).
#
# See https://github.com/coin-or/Cbc/issues/32
# The problematic source is https://github.com/coin-or/Cbc/blob/3dcedb27664ae458990e9d4d50bc11c2c55917a0/src/CbcSolver.cpp#L9445-L9459
#
# We will try two different situations: running from the current
# directory (which may or may not be on the same drive), and
# then from the tempdir (which will be on the same drive).
# Set some initial values for warm start.
m.x.set_value(10)
m.z.set_value(5)
m.w.set_value(1)
with SolverFactory("cbc") as opt, capture_output() as output:
opt.solve(m, tee=True, warmstart=True, options={
'sloglevel': 2, 'loglevel': 2})
log = output.getvalue()
# Check if CBC loaded the warmstart file.
self.assertIn('opening mipstart file', log)
if sameDrive:
# Only integer and binary variables are considered by CBC.
self.assertIn('MIPStart values read for 2 variables.', log)
# m.x is ignored because it is continuous, so cost should be 5+1
self.assertIn('MIPStart provided solution with cost 6', log)
else:
self.assertNotIn('MIPStart values read', log)
# Set some initial values for warm start.
m.x.set_value(10)
m.z.set_value(5)
m.w.set_value(1)
try:
_origDir = os.getcwd()
os.chdir(tempdir)
with SolverFactory("cbc") as opt, capture_output() as output:
opt.solve(m, tee=True, warmstart=True, options={
'sloglevel': 2, 'loglevel': 2})
finally:
os.chdir(_origDir)
log = output.getvalue()
# Check if CBC loaded the warmstart file.
self.assertIn('opening mipstart file', log)
# Only integer and binary variables are considered by CBC.
self.assertIn('MIPStart values read for 2 variables.', log)
# m.x is ignored because it is continuous, so cost should be 5+1
self.assertIn('MIPStart provided solution with cost 6', log)
def _presolve(self, *args, **kwds):
# create a context in the temporary file manager for
# this plugin - is "pop"ed in the _postsolve method.
TempfileManager.push()
# if the first argument is a string (representing a filename),
# then we don't have an instance => the solver is being applied
# to a file.
self._warm_start_solve = kwds.pop('warmstart', False)
self._warm_start_file_name = kwds.pop('warmstart_file', None)
user_warmstart = False
if self._warm_start_file_name is not None:
user_warmstart = True
# the input argument can currently be one of two things: an
# instance or a filename. if a filename is provided and a
# warm-start is indicated, we go ahead and create the temporary
# file - assuming that the user has already, via some external
# mechanism, invoked warm_start() with a instance to create the
# warm start file.
if self._warm_start_solve and isinstance(args[0], str):
# we assume the user knows what they are doing...
pass
elif self._warm_start_solve and (not isinstance(args[0], str)):
# assign the name of the warm start file *before* calling
# the base class presolve - the base class method ends up
# creating the command line, and the warm start file-name is
# (obviously) needed there.
if self._warm_start_file_name is None:
assert not user_warmstart
self._warm_start_file_name = TempfileManager.create_tempfile(
suffix='.cbc.soln')
# CBC does not cleanly handle windows-style drive names in the
# MIPSTART file name (though at least 2.10.5).
#
# See https://github.com/coin-or/Cbc/issues/32
# The problematic source is https://github.com/coin-or/Cbc/blob/3dcedb27664ae458990e9d4d50bc11c2c55917a0/src/CbcSolver.cpp#L9445-L9459
if self._warm_start_file_name is not None:
_drive, _path = os.path.splitdrive(self._warm_start_file_name)
if _drive:
_cwd_drive = os.path.splitdrive(os.getcwd())[0]
if _cwd_drive.lower() == _drive.lower():
self._warm_start_file_name = _path
else:
logger.warning(
"warmstart_file points to a file on a drive "
"different from the current working directory. "
"CBC is likely to (silently) ignore the warmstart.")
# let the base class handle any remaining keywords/actions.
# let the base class handle any remaining keywords/actions.
super(CBCSHELL, self)._presolve(*args, **kwds)
# NB: we must let the base class presolve run first so that the
# symbol_map is actually constructed!
if (len(args) > 0) and (not isinstance(args[0], str)):
if len(args) != 1:
raise ValueError(
"CBCplugin _presolve method can only handle a single "
"problem instance - %s were supplied" % (len(args), ))
# write the warm-start file - currently only supports MIPs.
# we only know how to deal with a single problem instance.
if self._warm_start_solve and (not user_warmstart):
start_time = time.time()
self._warm_start(args[0])
end_time = time.time()
if self._report_timing is True:
print("Warm start write time=%.2f seconds" %
(end_time - start_time))
def setUp(self):
TempfileManager.tempdir = tempdir
TempfileManager.push()
if os.path.exists(tempdir):
shutil.rmtree(tempdir)
os.mkdir(tempdir)
def setUp(self):
global tempdir
tempdir = tempfile.mkdtemp() + os.sep
TempfileManager.tempdir = tempdir
TempfileManager.push()
def run_command(command=None,
parser=None,
args=None,
name='unknown',
data=None,
options=None):
"""
Execute a function that processes command-line arguments and
then calls a command-line driver.
This function provides a generic facility for executing a command
function is rather generic. This function is segregated from
the driver to enable profiling of the command-line execution.
Required:
command: The name of a function that will be executed to perform process the command-line
options with a parser object.
parser: The parser object that is used by the command-line function.
Optional:
options: If this is not None, then ignore the args option and use
this to specify command options.
args: Command-line arguments that are parsed. If this value is `None`, then the
arguments in `sys.argv` are used to parse the command-line.
name: Specifying the name of the command-line (for error messages).
data: A container of labeled data.
Returned:
retval: Return values from the command-line execution.
errorcode: 0 if Pyomo ran successfully
"""
#
#
# Parse command-line options
#
#
retval = None
errorcode = 0
if options is None:
try:
if type(args) is argparse.Namespace:
_options = args
else:
_options = parser.parse_args(args=args)
# Replace the parser options object with a pyutilib.misc.Options object
options = Options()
for key in dir(_options):
if key[0] != '_':
val = getattr(_options, key)
if not isinstance(val, types.MethodType):
options[key] = val
except SystemExit:
# the parser throws a system exit if "-h" is specified - catch
# it to exit gracefully.
return Container(retval=retval, errorcode=errorcode)
#
# Configure loggers
#
configure_loggers(options=options)
#
# Call the main Pyomo runner with profiling
#
TempfileManager.push()
pcount = options.runtime.profile_count
if pcount > 0:
# Defer import of profiling packages until we know that they
# are needed
try:
try:
import cProfile as profile
except ImportError:
import profile
import pstats
except ImportError:
configure_loggers(shutdown=True)
raise ValueError(
"Cannot use the 'profile' option: the Python "
"'profile' or 'pstats' package cannot be imported!")
tfile = TempfileManager.create_tempfile(suffix=".profile")
tmp = profile.runctx(
command.__name__ + '(options=options,parser=parser)',
command.__globals__, locals(), tfile)
p = pstats.Stats(tfile).strip_dirs()
p.sort_stats('time', 'cumulative')
p = p.print_stats(pcount)
p.print_callers(pcount)
p.print_callees(pcount)
p = p.sort_stats('cumulative', 'calls')
p.print_stats(pcount)
p.print_callers(pcount)
p.print_callees(pcount)
p = p.sort_stats('calls')
p.print_stats(pcount)
p.print_callers(pcount)
p.print_callees(pcount)
retval = tmp
else:
#
# Call the main Pyomo runner without profiling
#
TempfileManager.push()
try:
retval = command(options=options, parser=parser)
except SystemExit:
err = sys.exc_info()[1]
#
# If debugging is enabled or the 'catch' option is specified, then
# exit. Otherwise, print an "Exiting..." message.
#
if __debug__ and (options.runtime.logging == 'debug'
or options.runtime.catch_errors):
configure_loggers(shutdown=True)
sys.exit(0)
print('Exiting %s: %s' % (name, str(err)))
errorcode = err.code
except Exception:
err = sys.exc_info()[1]
#
# If debugging is enabled or the 'catch' option is specified, then
# pass the exception up the chain (to pyomo_excepthook)
#
if __debug__ and (options.runtime.logging == 'debug'
or options.runtime.catch_errors):
configure_loggers(shutdown=True)
TempfileManager.pop(remove=not options.runtime.keep_files)
raise
if not options.model is None and not options.model.save_file is None:
model = "model " + options.model.save_file
else:
model = "model"
global filter_excepthook
if filter_excepthook:
action = "loading"
else:
action = "running"
msg = "Unexpected exception while %s %s:\n " % (action, model)
#
# This handles the case where the error is propagated by a KeyError.
# KeyError likes to pass raw strings that don't handle newlines
# (they translate "\n" to "\\n"), as well as tacking on single
# quotes at either end of the error message. This undoes all that.
#
errStr = str(err)
if type(err) == KeyError and errStr != "None":
errStr = str(err).replace(r"\n", "\n")[1:-1]
logger.error(msg + errStr)
errorcode = 1
configure_loggers(shutdown=True)
if options.runtime.disable_gc:
gc.enable()
TempfileManager.pop(remove=not options.runtime.keep_files)
return Container(retval=retval, errorcode=errorcode)
def __init__(self, pyomo_model):
"""
Pyomo nonlinear program interface
Parameters
----------
pyomo_model: pyomo.environ.ConcreteModel
Pyomo concrete model
"""
TempfileManager.push()
try:
# get the temp file names for the nl file
nl_file = TempfileManager.create_tempfile(
suffix='pynumero.nl')
# The current AmplInterface code only supports a single
# objective function Therefore, we throw an error if there
# is not one (and only one) active objective function. This
# is better than adding a dummy objective that the user does
# not know about (since we do not have a good place to
# remove this objective later)
#
# TODO: extend the AmplInterface and the AslNLP to correctly
# handle this
#
# This currently addresses issue #1217
objectives = list(pyomo_model.component_data_objects(
ctype=pyo.Objective, active=True, descend_into=True))
if len(objectives) != 1:
raise NotImplementedError(
'The ASL interface and PyomoNLP in PyNumero currently '
'only support single objective problems. Deactivate '
'any extra objectives you may have, or add a dummy '
'objective (f(x)=0) if you have a square problem.')
self._objective = objectives[0]
# write the nl file for the Pyomo model and get the symbolMap
fname, symbolMap = WriterFactory('nl')(
pyomo_model, nl_file, lambda x:True, {})
# create component maps from vardata to idx and condata to idx
self._vardata_to_idx = vdidx = ComponentMap()
self._condata_to_idx = cdidx = ComponentMap()
# TODO: Are these names totally consistent?
for name, obj in six.iteritems(symbolMap.bySymbol):
if name[0] == 'v':
vdidx[obj()] = int(name[1:])
elif name[0] == 'c':
cdidx[obj()] = int(name[1:])
# The NL writer advertises the external function libraries
# through the PYOMO_AMPLFUNC environment variable; merge it
# with any preexisting AMPLFUNC definitions
amplfunc = "\n".join(
val for val in (
os.environ.get('AMPLFUNC', ''),
os.environ.get('PYOMO_AMPLFUNC', ''),
) if val)
with CtypesEnviron(AMPLFUNC=amplfunc):
super(PyomoNLP, self).__init__(nl_file)
# keep pyomo model in cache
self._pyomo_model = pyomo_model
# Create ComponentMap corresponding to equality constraint indices
# This must be done after the call to super-init.
full_to_equality = self._con_full_eq_map
equality_mask = self._con_full_eq_mask
self._condata_to_eq_idx = ComponentMap(
(con, full_to_equality[i])
for con, i in six.iteritems(self._condata_to_idx)
if equality_mask[i]
)
full_to_inequality = self._con_full_ineq_map
inequality_mask = self._con_full_ineq_mask
self._condata_to_ineq_idx = ComponentMap(
(con, full_to_inequality[i])
for con, i in six.iteritems(self._condata_to_idx)
if inequality_mask[i]
)
finally:
# delete the nl file
TempfileManager.pop()
def run_command(command=None,
parser=None,
args=None,
name='unknown',
data=None,
options=None):
"""
Execute a function that processes command-line arguments and
then calls a command-line driver.
This function provides a generic facility for executing a command
function is rather generic. This function is segregated from
the driver to enable profiling of the command-line execution.
Required:
command: The name of a function that will be executed to perform process the command-line
options with a parser object.
parser: The parser object that is used by the command-line function.
Optional:
options: If this is not None, then ignore the args option and use
this to specify command options.
args: Command-line arguments that are parsed. If this value is `None`, then the
arguments in `sys.argv` are used to parse the command-line.
name: Specifying the name of the command-line (for error messages).
data: A container of labeled data.
Returned:
retval: Return values from the command-line execution.
errorcode: 0 if Pyomo ran successfully
"""
#
#
# Parse command-line options
#
#
if options is None:
try:
if type(args) is argparse.Namespace:
_options = args
else:
_options = parser.parse_args(args=args)
# Replace the parser options object with a
# pyomo.common.collections.Options object
options = Bunch()
for key in dir(_options):
if key[0] != '_':
val = getattr(_options, key)
if not isinstance(val, types.MethodType):
options[key] = val
except SystemExit:
# the parser throws a system exit if "-h" is specified - catch
# it to exit gracefully.
return Bunch(retval=None, errorcode=0)
#
# Configure loggers
#
TempfileManager.push()
try:
with PyomoCommandLogContext(options):
retval, errorcode = _run_command_impl(command, parser, args, name,
data, options)
finally:
if options.runtime.disable_gc:
gc.enable()
TempfileManager.pop(remove=not options.runtime.keep_files)
return Bunch(retval=retval, errorcode=errorcode)
def setUp(self):
if not 'glpk' in solvers:
self.skipTest("GLPK is not installed")
TempfileManager.push()
def setUp(self):
TempfileManager.push()
TempfileManager.tempdir = currdir
