def main(args=None):
#
# Top-level command that executes everything
#
#
# Import plugins
#
import pyomo.environ
#
# Parse command-line options.
#
options = PySPConfigBlock()
convertddsip_register_options(options)
#
# Prevent the compile_scenario_instances option from
# appearing on the command line. This script relies on
# the original constraints being present on the model
#
argparse_val = options.get('compile_scenario_instances')._argparse
options.get('compile_scenario_instances')._argparse = None
try:
ap = argparse.ArgumentParser(prog='pyomo.pysp.convert.ddsip')
options.initialize_argparse(ap)
# restore the option so the class validation does not
# raise an exception
options.get('compile_scenario_instances')._argparse = argparse_val
options.import_argparse(ap.parse_args(args=args))
except SystemExit as _exc:
# the parser throws a system exit if "-h" is specified
# - catch it to exit gracefully.
return _exc.code
return launch_command(run_convertddsip,
options,
error_label="pyomo.pysp.convert.ddsip: ",
disable_gc=options.disable_gc,
profile_count=options.profile,
traceback=options.traceback)
def main(args=None):
#
# Top-level command that executes everything
#
#
# Import plugins
#
import pyomo.environ
#
# Parse command-line options.
#
options = PySPConfigBlock()
pysp2smps_register_options(options)
#
# Prevent the compile_scenario_instances option from
# appearing on the command line. This script relies on
# the original constraints being present on the model
#
argparse_val = options.get('compile_scenario_instances')._argparse
options.get('compile_scenario_instances')._argparse = None
try:
ap = argparse.ArgumentParser(prog='pysp2smps')
options.initialize_argparse(ap)
# restore the option so the class validation does not
# raise an exception
options.get('compile_scenario_instances')._argparse = argparse_val
options.import_argparse(ap.parse_args(args=args))
except SystemExit as _exc:
# the parser throws a system exit if "-h" is specified
# - catch it to exit gracefully.
return _exc.code
return launch_command(run_pysp2smps,
options,
error_label="pysp2smps: ",
disable_gc=options.disable_gc,
profile_count=options.profile,
traceback=options.traceback)
def parse_command_line(args,
register_options_callback,
with_extensions=None,
**kwds):
import pyomo.pysp.plugins
pyomo.pysp.plugins.load()
from pyomo.pysp.util.config import _domain_tuple_of_str
registered_extensions = {}
if with_extensions is not None:
for name in with_extensions:
plugins = ExtensionPoint(with_extensions[name])
for plugin in plugins(all=True):
registered_extensions.setdefault(name,[]).\
append(plugin.__class__.__module__)
def _get_argument_parser(options):
# if we modify this and don't copy it,
# the this output will appear twice the second
# time this function gets called
_kwds = dict(kwds)
if len(registered_extensions) > 0:
assert with_extensions is not None
epilog = _kwds.pop('epilog',"")
if epilog != "":
epilog += "\n\n"
epilog += "Registered Extensions:\n"
for name in registered_extensions:
epilog += " - "+str(with_extensions[name].__name__)+": "
epilog += str(registered_extensions[name])+"\n"
_kwds['epilog'] = epilog
ap = argparse.ArgumentParser(
add_help=False,
formatter_class=argparse.RawDescriptionHelpFormatter,
**_kwds)
options.initialize_argparse(ap)
ap.add_argument("-h", "--help", dest="show_help",
action="store_true", default=False,
help="show this help message and exit")
return ap
#
# Register options
#
options = PySPConfigBlock()
register_options_callback(options)
if with_extensions is not None:
for name in with_extensions:
configval = options.get(name, None)
assert configval is not None
assert configval._domain is _domain_tuple_of_str
ap = _get_argument_parser(options)
# First parse known args, then import any extension plugins
# specified by the user, regenerate the options block and
# reparse to pick up plugin specific registered options
opts, _ = ap.parse_known_args(args=args)
options.import_argparse(opts)
extensions = {}
if with_extensions is None:
if opts.show_help:
pass
else:
if all(len(options.get(name).value()) == 0
for name in with_extensions) and \
opts.show_help:
ap.print_help()
sys.exit(0)
for name in with_extensions:
extensions[name] = load_extensions(
options.get(name).value(),
with_extensions[name])
# regenerate the options
options = PySPConfigBlock()
register_options_callback(options)
for name in extensions:
for plugin in extensions[name]:
if isinstance(plugin, PySPConfiguredObject):
plugin.register_options(options)
# do a dummy access to option to prevent
# a warning about it not being used
options.get(name).value()
ap = _get_argument_parser(options)
opts = ap.parse_args(args=args)
options.import_argparse(opts)
for name in extensions:
for plugin in extensions[name]:
if isinstance(plugin, PySPConfiguredObject):
plugin.set_options(options)
if opts.show_help:
ap.print_help()
sys.exit(0)
if with_extensions:
for name in extensions:
extensions[name] = sort_extensions_by_precedence(extensions[name])
return options, extensions
else:
return options
def register_options(cls, *args, **kwds):
"""Cls.register_options([options]) -> options. Fills an
options block will all registered options for this
class. The optional argument 'options' can be a previously
existing options block, which would be both updated and
returned by this function. The optional flag 'prefix' can be
set to indicate that all class options should be registered
with the given prefix prepended to their original name."""
prefix = kwds.pop('prefix', "")
assert isinstance(prefix, six.string_types)
if len(kwds) != 0:
raise ValueError("Unexpected keywords: %s" % (str(kwds)))
if len(args) == 0:
options = PySPConfigBlock()
else:
if len(args) != 1:
raise TypeError(
"register_options(...) takes at most 1 argument (%s given)"
% (len(args)))
options = args[0]
if not isinstance(options, PySPConfigBlock):
raise TypeError(
"register_options(...) argument must be of type PySPConfigBlock, "
"not %s" % (type(options).__name__))
bases = inspect.getmro(cls)
assert bases[-1] is object
#
# Register options in order of most derived class
# first. This allows derived classes to update
# option default values. The safe_declare_option
# function will simply validate that an existing
# option matches when a base class attempts to
# register an option that is already registered (in
# which cases we tell it to accept differences in
# default values).
#
for base in bases:
#
# The check here is that PySPConfiguredObject needs to
# appear as an immediate base in a class definition for us
# to check the list of _registered options declared in
# that class definitions immediate scope. This allows
# _declared_options to be distributed across different
# containers in the class hierarchy, while leaving the
# ability for derived classes to NOT have to define an
# empty _declared_options block if they don't have any
# new options to add but are derived from some class which
# does use PySPConfiguredObject as a base class. By not
# declaring PySPConfiguredObject as an immediate base
# class, we know not to check for a _declared_options
# data member in this derived class's scope (because
# otherwise we'd be getting some base class's definition)
#
if any(base is PySPConfiguredObject for base in base.__bases__):
for name in base._declared_options:
configval = base._declared_options.get(name)
assert configval._parent is base._declared_options
configval._parent = None
declare_for_argparse = False
if (configval._argparse is None) and \
(options.get(prefix+name, None) is None):
declare_for_argparse = True
safe_declare_option(
options,
prefix + name,
configval,
relax_default_check=True,
declare_for_argparse=declare_for_argparse)
configval._parent = base._declared_options
return options
def register_options(cls, *args, **kwds):
"""Cls.register_options([options]) -> options. Fills an
options block will all registered options for this
class. The optional argument 'options' can be a previously
existing options block, which would be both updated and
returned by this function. The optional flag 'prefix' can be
set to indicate that all class options should be registered
with the given prefix prepended to their original name."""
prefix = kwds.pop('prefix',"")
assert isinstance(prefix, six.string_types)
if len(kwds) != 0:
raise ValueError("Unexpected keywords: %s"
% (str(kwds)))
if len(args) == 0:
options = PySPConfigBlock()
else:
if len(args) != 1:
raise TypeError(
"register_options(...) takes at most 1 argument (%s given)"
% (len(args)))
options = args[0]
if not isinstance(options, PySPConfigBlock):
raise TypeError(
"register_options(...) argument must be of type PySPConfigBlock, "
"not %s" % (type(options).__name__))
bases = inspect.getmro(cls)
assert bases[-1] is object
#
# Register options in order of most derived class
# first. This allows derived classes to update
# option default values. The safe_declare_option
# function will simply validate that an existing
# option matches when a base class attempts to
# register an option that is already registered (in
# which cases we tell it to accept differences in
# default values).
#
for base in bases:
#
# The check here is that PySPConfiguredObject needs to
# appear as an immediate base in a class definition for us
# to check the list of _registered options declared in
# that class definitions immediate scope. This allows
# _declared_options to be distributed across different
# containers in the class hierarchy, while leaving the
# ability for derived classes to NOT have to define an
# empty _declared_options block if they don't have any
# new options to add but are derived from some class which
# does use PySPConfiguredObject as a base class. By not
# declaring PySPConfiguredObject as an immediate base
# class, we know not to check for a _declared_options
# data member in this derived class's scope (because
# otherwise we'd be getting some base class's definition)
#
if any(base is PySPConfiguredObject for base in base.__bases__):
for name in base._declared_options:
configval = base._declared_options.get(name)
assert configval._parent is base._declared_options
configval._parent = None
declare_for_argparse = False
if (configval._argparse is None) and \
(options.get(prefix+name, None) is None):
declare_for_argparse = True
safe_declare_option(
options,
prefix+name,
configval,
relax_default_check=True,
declare_for_argparse=declare_for_argparse)
configval._parent = base._declared_options
return options
