def __init__(self, *args, **kwargs):
deprecation_warning(
"DEPRECATED: The PIDBlock model is deprecated and will be removed."
"Use PIDController instead.",
version=1.12,
)
super().__init__(*args, **kwargs)
def load(self, arg, namespaces=[None], profile_memory=0, report_timing=None):
"""
Load the model with data from a file, dictionary or DataPortal object.
"""
if report_timing is not None:
deprecation_warning(
"The report_timing argument to Model.load() is deprecated. "
"Use pyomo.common.timing.report_timing() to enable reporting "
"construction timing")
if arg is None or isinstance(arg, basestring):
dp = DataPortal(filename=arg, model=self)
elif type(arg) is DataPortal:
dp = arg
elif type(arg) is dict:
dp = DataPortal(data_dict=arg, model=self)
elif isinstance(arg, SolverResults):
if len(arg.solution):
logger.warning(
"""DEPRECATION WARNING: the Model.load() method is deprecated for
loading solutions stored in SolverResults objects. Call
Model.solutions.load_from().""")
self.solutions.load_from(arg)
else:
logger.warning(
"""DEPRECATION WARNING: the Model.load() method is deprecated for
loading solutions stored in SolverResults objects. By default, results
from solvers are immediately loaded into the original model instance.""")
return
else:
msg = "Cannot load model model data from with object of type '%s'"
raise ValueError(msg % str( type(arg) ))
self._load_model_data(dp,
namespaces,
profile_memory=profile_memory)
def load(self, arg, namespaces=[None], profile_memory=0, report_timing=None):
"""
Load the model with data from a file, dictionary or DataPortal object.
"""
if report_timing is not None:
deprecation_warning(
"The report_timing argument to Model.load() is deprecated. "
"Use pyomo.common.timing.report_timing() to enable reporting "
"construction timing")
if arg is None or isinstance(arg, basestring):
dp = DataPortal(filename=arg, model=self)
elif type(arg) is DataPortal:
dp = arg
elif type(arg) is dict:
dp = DataPortal(data_dict=arg, model=self)
elif isinstance(arg, SolverResults):
if len(arg.solution):
logger.warning(
"""DEPRECATION WARNING: the Model.load() method is deprecated for
loading solutions stored in SolverResults objects. Call
Model.solutions.load_from().""")
self.solutions.load_from(arg)
else:
logger.warning(
"""DEPRECATION WARNING: the Model.load() method is deprecated for
loading solutions stored in SolverResults objects. By default, results
from solvers are immediately loaded into the original model instance.""")
return
else:
msg = "Cannot load model model data from with object of type '%s'"
raise ValueError(msg % str( type(arg) ))
self._load_model_data(dp,
namespaces,
profile_memory=profile_memory)
def __init__(self,
substitute=None,
descend_into_named_expressions=True,
remove_named_expressions=True):
if substitute is None:
substitute = {}
# Note: preserving the attribute names from the previous
# implementation of the expression walker.
self.substitute = substitute
self.enter_named_expr = descend_into_named_expressions
self.rm_named_expr = remove_named_expressions
kwds = {}
if hasattr(self, 'visiting_potential_leaf'):
deprecation_warning(
"ExpressionReplacementVisitor: this walker has been ported "
"to derive from StreamBasedExpressionVisitor. "
"visiting_potential_leaf() has been replaced by beforeChild()"
"(note to implementers: the sense of the bool return value "
"has been inverted).",
version='6.2')
def beforeChild(node, child, child_idx):
is_leaf, ans = self.visiting_potential_leaf(child)
return not is_leaf, ans
kwds['beforeChild'] = beforeChild
if hasattr(self, 'visit'):
raise DeveloperError(
"ExpressionReplacementVisitor: this walker has been ported "
"to derive from StreamBasedExpressionVisitor. "
"overriding visit() has no effect (and is likely to generate "
"invalid expression trees)")
super().__init__(**kwds)
def target_list(x):
deprecation_msg = ("In future releases ComponentUID targets will no "
"longer be supported in the core.add_slack_variables "
"transformation. Specify targets as a Constraint or "
"list of Constraints.")
if isinstance(x, ComponentUID):
if deprecation_msg:
deprecation_warning(deprecation_msg)
# only emit the message once
deprecation_msg = None
# [ESJ 07/15/2020] We have to just pass it through because we need the
# instance in order to be able to do anything about it...
return [ x ]
elif isinstance(x, (Constraint, _ConstraintData)):
return [ x ]
elif hasattr(x, '__iter__'):
ans = []
for i in x:
if isinstance(i, ComponentUID):
if deprecation_msg:
deprecation_warning(deprecation_msg)
deprecation_msg = None
# same as above...
ans.append(i)
elif isinstance(i, (Constraint, _ConstraintData)):
ans.append(i)
else:
raise ValueError(
"Expected Constraint or list of Constraints."
"\n\tRecieved %s" % (type(i),))
return ans
else:
raise ValueError(
"Expected Constraint or list of Constraints."
"\n\tRecieved %s" % (type(x),))
def __init__(self, *args, **kwargs):
deprecation_warning(
"DEPRECATED: The idaes.power_generation.control.pid_controller.PIDController"
" model is deprecated and will be removed. Use"
" idaes.generic_models.control.PIDController instead.",
version=1.12,
)
super().__init__(*args, **kwargs)
def xsequence(*args):
from pyomo.common.deprecation import deprecation_warning
deprecation_warning(
"The xsequence function is deprecated. Use the sequence() "
"function, which returns a generator.",
version='5.5.1',
remove_in='6.0')
return sequence(*args)
def __new__(cls, *args, **kwds):
if cls != Model:
return super(Model, cls).__new__(cls)
deprecation_warning(
"Using the 'Model' class is deprecated. Please use the "
"AbstractModel or ConcreteModel class instead.",
version='4.3.11323')
return AbstractModel.__new__(AbstractModel)
def __nonzero__(self):
if _using_chained_inequality and not self.is_constant(): #pragma: no cover
deprecation_warning("Chained inequalities are deprecated. "
"Use the inequality() function to "
"express ranged inequality expressions.") # Remove in Pyomo 6.0
_chainedInequality.call_info = traceback.extract_stack(limit=2)[-2]
_chainedInequality.prev = self
return True
#return bool(self()) # This is needed to apply simple evaluation of inequalities
return bool(self())
def __contains__(self, val):
if val not in Reals:
deprecation_warning(
"The default domain for Param objects is 'Any'. However, "
"we will be changing that default to 'Reals' in the "
"future. If you really intend the domain of this Param (%s) "
"to be 'Any', you can suppress this warning by explicitly "
"specifying 'within=Any' to the Param constructor."
% ('Unknown' if self._owner is None else self._owner().name,),
version='5.6.9', remove_in='6.0')
return True
def alias(name, doc=None, subclass=None):
if subclass is not None:
deprecation_warning(
"The Pyomo plugin infrastructure alias() function does "
"not support the subclass flag.", version='6.0')
calling_frame = inspect.currentframe().f_back
locals_ = calling_frame.f_locals
#
# Some sanity checks
#
assert locals_ is not calling_frame.f_globals and '__module__' in locals_, \
'implements() can only be used in a class definition'
#
locals_.setdefault('__plugin_aliases__', []).append((name, doc))
def list_of_phase_types(arg):
'''Domain validator for lists of PhaseTypes
Args:
arg : argument to be cast to list of PhaseTypes and validated
Returns:
List of PhaseTypes
'''
deprecation_warning(
"The list_of_phase_types function is deprecated. Use the "
"ListOf(PhaseType) validator from pyomo.common.config instead.",
version='1.11', remove_in='1.13')
return ListOf(PhaseType)(arg)
def __contains__(self, val):
if val not in Reals:
if self._owner is None or self._owner() is None:
name = 'Unknown'
else:
name = self._owner().name
deprecation_warning(
f"Param '{name}' declared with an implicit domain of 'Any'. "
"The default domain for Param objects is 'Any'. However, "
"we will be changing that default to 'Reals' in the "
"future. If you really intend the domain of this Param"
"to be 'Any', you can suppress this warning by explicitly "
"specifying 'within=Any' to the Param constructor.",
version='5.6.9', remove_in='6.0')
return True
def list_of_floats(arg):
'''Domain validator for lists of floats
Args:
arg : argument to be cast to list of floats and validated
Returns:
List of floats
'''
deprecation_warning(
"The list_of_floats function is deprecated. Use the ListOf(float) "
"validator from pyomo.common.config instead.", version='1.11',
remove_in='1.13')
return ListOf(float)(arg)
def _resolve_tempdir(self, dir=None):
if dir is not None:
return dir
elif self.tempdir is not None:
return self.tempdir
elif self.manager().tempdir is not None:
return self.manager().tempdir
elif pyutilib_mngr is not None and pyutilib_mngr.tempdir is not None:
deprecation_warning(
"The use of the PyUtilib TempfileManager.tempdir "
"to specify the default location for Pyomo "
"temporary files has been deprecated. "
"Please set TempfileManager.tempdir in "
"pyomo.common.tempfiles",
version='5.7.2')
return pyutilib_mngr.tempdir
return None
def as_binary(self):
"""Return the binary variable associated with this Boolean variable.
This method returns the associated binary variable along with a
deprecation warning about using the Boolean variable in a numeric
context.
"""
deprecation_warning(
"Implicit conversion of the Boolean indicator_var '%s' to a "
"binary variable is deprecated and will be removed. "
"Either express constraints on indicator_var using "
"LogicalConstraints or work with the associated binary "
"variable from indicator_var.get_associated_binary()" %
(self.name, ),
version='6.0')
return self.get_associated_binary()
def transform(self, name=None, **kwds):
if name is None:
deprecation_warning(
"Use the TransformationFactory iterator to get the list "
"of known transformations.", version='4.3.11323')
return list(TransformationFactory)
deprecation_warning(
"Use TransformationFactory('%s') to construct a transformation "
"object, or TransformationFactory('%s').apply_to(model) to "
"directly apply the transformation to the model instance." % (
name,name,), version='4.3.11323')
xfrm = TransformationFactory(name)
if xfrm is None:
raise ValueError("Unknown model transformation '%s'" % name)
return xfrm.apply_to(self, **kwds)
def implements(interface, inherit=None, namespace=None, service=False):
if namespace is not None:
deprecation_warning(
"The Pyomo plugin infrastructure only supports a "
"single global namespace.", version='6.0')
calling_frame = inspect.currentframe().f_back
locals_ = calling_frame.f_locals
#
# Some sanity checks
#
assert locals_ is not calling_frame.f_globals and '__module__' in locals_, \
'implements() can only be used in a class definition'
assert issubclass(interface, Interface)
#
locals_.setdefault('__implements__', []).append(
(interface, inherit, service)
)
def __call__(self):
deprecation_warning(
"Relying on core.logical_to_linear to transform "
"BooleanVars that do not appear in LogicalConstraints "
"is deprecated. Please associate your own binaries if "
"you have BooleanVars not used in logical expressions.",
version='6.2')
parent_block = self._boolvar().parent_block()
new_var = Var(domain=Binary)
parent_block.add_component(
unique_component_name(parent_block,
self._boolvar().local_name + "_asbinary"),
new_var)
self._boolvar()._associated_binary = None
self._boolvar().associate_binary_var(new_var)
return new_var
def create_tempfile(self, suffix=None, prefix=None, text=False, dir=None):
"""Create a unique temporary file
Returns the absolute path of a temporary filename that is
guaranteed to be unique. This function generates the file and
returns the filename.
"""
if suffix is None:
suffix = ''
if prefix is None:
prefix = 'tmp'
if dir is None:
dir = self.tempdir
if dir is None and pyutilib_mngr is not None:
dir = pyutilib_mngr.tempdir
if dir is not None:
deprecation_warning(
"The use of the PyUtilib TempfileManager.tempdir "
"to specify the default location for Pyomo "
"temporary files has been deprecated. "
"Please set TempfileManager.tempdir in "
"pyomo.common.tempfiles",
version='5.7.2')
ans = tempfile.mkstemp(suffix=suffix,
prefix=prefix,
text=text,
dir=dir)
ans = list(ans)
if not os.path.isabs(ans[1]): #pragma:nocover
fname = os.path.join(dir, ans[1])
else:
fname = ans[1]
os.close(ans[0])
if self._ctr >= 0:
new_fname = os.path.join(dir, prefix + str(self._ctr) + suffix)
# Delete any file having the sequential name and then
# rename
if os.path.exists(new_fname):
os.remove(new_fname)
shutil.move(fname, new_fname)
fname = new_fname
self._ctr += 1
self._tempfiles[-1].append(fname)
return fname
def test_deprecation_warning(self):
DEP_OUT = StringIO()
with LoggingIntercept(DEP_OUT, 'pyomo'):
deprecation_warning(None, version='1.2', remove_in='3.4')
self.assertIn('DEPRECATED: This has been deprecated',
DEP_OUT.getvalue())
self.assertIn('(deprecated in 1.2, will be removed in (or after) 3.4)',
DEP_OUT.getvalue().replace('\n',' '))
DEP_OUT = StringIO()
with LoggingIntercept(DEP_OUT, 'pyomo'):
deprecation_warning("custom message here", version='1.2', remove_in='3.4')
self.assertIn('DEPRECATED: custom message here',
DEP_OUT.getvalue())
self.assertIn('(deprecated in 1.2, will be removed in (or after) 3.4)',
DEP_OUT.getvalue().replace('\n',' '))
def getname(self,
fully_qualified=False,
name_buffer=None,
relative_to=None):
"""Returns the component name associated with this object.
Parameters
----------
fully_qualified: bool
Generate full name from nested block names
relative_to: Block
Generate fully_qualified names reletive to the specified block.
"""
local_name = self._name
if fully_qualified:
pb = self.parent_block()
if relative_to is None:
relative_to = self.model()
if pb is not None and pb is not relative_to:
ans = pb.getname(fully_qualified, name_buffer, relative_to) \
+ "." + name_repr(local_name)
elif pb is None and relative_to != self.model():
raise RuntimeError(
"The relative_to argument was specified but not found "
"in the block hierarchy: %s" % str(relative_to))
else:
ans = name_repr(local_name)
else:
# Note: we want "getattr(x.parent_block(), x.local_name) == x"
# so we do not want to call _safe_name_str, as that could
# add quotes or otherwise escape the string.
ans = local_name
if name_buffer is not None:
deprecation_warning(
"The 'name_buffer' argument to getname is deprecated. "
"The functionality is no longer necessary since getting names "
"is no longer a quadratic operation. Additionally, note that "
"use of this argument poses risks if the buffer contains "
"names relative to different Blocks in the model hierarchy or "
"a mixture of local and fully_qualified names.",
version='TODO')
name_buffer[id(self)] = ans
return ans
def create_tempdir(self, suffix=None, prefix=None, dir=None):
"""Create a unique temporary directory
Returns the absolute path of a temporary directory that is
guaranteed to be unique. This function generates the directory
and returns the directory name.
"""
if suffix is None:
suffix = ''
if prefix is None:
prefix = 'tmp'
if dir is None:
dir = self.tempdir
if dir is None and pyutilib_mngr is not None:
dir = pyutilib_mngr.tempdir
if dir is not None:
deprecation_warning(
"The use of the PyUtilib TempfileManager.tempdir "
"to specify the default location for Pyomo "
"temporary directories has been deprecated. "
"Please set TempfileManager.tempdir in "
"pyomo.common.tempfiles",
version='5.7.2')
dirname = tempfile.mkdtemp(suffix=suffix, prefix=prefix, dir=dir)
if self._tempfiles[-1].ctr >= 0:
new_dirname = os.path.join(
os.path.dirname(dirname),
prefix + str(self._tempfiles[-1].ctr) + suffix)
# Delete any directory having the sequential name and then
# rename
if os.path.exists(new_dirname):
shutil.rmtree(new_dirname)
shutil.move(dirname, new_dirname)
dirname = new_dirname
self._tempfiles[-1].ctr += 1
self._tempfiles[-1].append(dirname)
return dirname
def __init__(self, **kwds):
# This is slightly tricky: We want derived classes to be able to
# override the "None" defaults here, and for keyword arguments
# to override both. The hasattr check prevents the "None"
# defaults from overriding attributes or methods defined on
# derived classes.
for field in self.client_methods:
if field in kwds:
setattr(self, field, kwds.pop(field))
elif not hasattr(self, field):
setattr(self, field, None)
if kwds:
raise RuntimeError("Unrecognized keyword arguments: %s" % (kwds, ))
# Handle deprecated APIs
_fcns = (('beforeChild', 2), ('acceptChildResult', 3), ('afterChild',
2))
for name, nargs in _fcns:
fcn = getattr(self, name)
if fcn is None:
continue
_args = inspect.getfullargspec(fcn)
_self_arg = 1 if inspect.ismethod(fcn) else 0
if len(_args.args) == nargs + _self_arg and _args.varargs is None:
deprecation_warning(
"Note that the API for the StreamBasedExpressionVisitor "
"has changed to include the child index for the %s() "
"method. Please update your walker callbacks." % (name, ),
version='5.7.0')
def wrap(fcn, nargs):
def wrapper(*args):
return fcn(*args[:nargs])
return wrapper
setattr(self, name, wrap(fcn, nargs))
from pyomo.common.deprecation import deprecation_warning
try:
deprecation_warning("The use of pyomo.contrib.simple model is deprecated. "
"This capability is now supported in the "
"pyomo_simplemodel package, which is included in the "
"pyomo_community distribution.", version='TBD',
remove_in='TBD')
from pyomocontrib_simplemodel import *
except:
# Only raise exception if nose is NOT running
import sys
if 'nose' not in sys.modules and 'nose2' not in sys.modules:
raise RuntimeError(
"The pyomocontrib_simplemodel package is not installed.")
def _apply_to_impl(self, instance, **kwds):
config = self.CONFIG(kwds.pop('options', {}))
# We will let args override suffixes and estimate as a last
# resort. More specific args/suffixes override ones anywhere in
# the tree. Suffixes lower down in the tree override ones higher
# up.
if 'default_bigM' in kwds:
deprecation_warning("the 'default_bigM=' argument has been "
"replaced by 'bigM='", version='5.4')
config.bigM = kwds.pop('default_bigM')
config.set_value(kwds)
bigM = config.bigM
self.assume_fixed_vars_permanent = config.assume_fixed_vars_permanent
targets = config.targets
if targets is None:
targets = (instance, )
# We need to check that all the targets are in fact on instance. As we
# do this, we will use the set below to cache components we know to be
# in the tree rooted at instance.
knownBlocks = {}
for t in targets:
# check that t is in fact a child of instance
if not is_child_of(parent=instance, child=t,
knownBlocks=knownBlocks):
raise GDP_Error(
"Target '%s' is not a component on instance '%s'!"
% (t.name, instance.name))
elif t.ctype is Disjunction:
if t.is_indexed():
self._transform_disjunction(t, bigM)
else:
self._transform_disjunctionData( t, bigM, t.index())
elif t.ctype in (Block, Disjunct):
if t.is_indexed():
self._transform_block(t, bigM)
else:
self._transform_blockData(t, bigM)
else:
raise GDP_Error(
"Target '%s' was not a Block, Disjunct, or Disjunction. "
"It was of type %s and can't be transformed."
% (t.name, type(t)))
# issue warnings about anything that was in the bigM args dict that we
# didn't use
if bigM is not None:
unused_args = ComponentSet(bigM.keys()) - \
ComponentSet(self.used_args.keys())
if len(unused_args) > 0:
warning_msg = ("Unused arguments in the bigM map! "
"These arguments were not used by the "
"transformation:\n")
for component in unused_args:
if hasattr(component, 'name'):
warning_msg += "\t%s\n" % component.name
else:
warning_msg += "\t%s\n" % component
logger.warning(warning_msg)
from pyomo.common.deprecation import deprecation_warning
deprecation_warning(
'The pyomo.gdp.plugins.chull module is deprecated. '
'Import the Hull reformulation objects from pyomo.gdp.plugins.hull.',
version='5.7')
from .hull import _Deprecated_Name_Hull as ConvexHull_Transformation
def create_instance(self,
filename=None,
data=None,
name=None,
namespace=None,
namespaces=None,
profile_memory=0,
report_timing=False,
**kwds):
"""
Create a concrete instance of an abstract model, possibly using data
read in from a file.
Parameters
----------
filename: `str`, optional
The name of a Pyomo Data File that will be used to load data into
the model.
data: `dict`, optional
A dictionary containing initialization data for the model to be
used if there is no filename
name: `str`, optional
The name given to the model.
namespace: `str`, optional
A namespace used to select data.
namespaces: `list`, optional
A list of namespaces used to select data.
profile_memory: `int`, optional
A number that indicates the profiling level.
report_timing: `bool`, optional
Report timing statistics during construction.
"""
#
# Generate a warning if this is a concrete model but the
# filename is specified. A concrete model is already
# constructed, so passing in a data file is a waste of time.
#
if self.is_constructed() and isinstance(filename, str):
msg = "The filename=%s will not be loaded - supplied as an " \
"argument to the create_instance() method of a "\
"concrete instance with name=%s." % (filename, name)
logger.warning(msg)
if 'clone' in kwds:
kwds.pop('clone')
deprecation_warning(
"Model.create_instance() no longer accepts the 'clone' "
"argument: the base abstract model is always cloned.",
version='5.4')
if 'preprocess' in kwds:
kwds.pop('preprocess')
deprecation_warning(
"Model.create_instance() no longer accepts the preprocess' "
"argument: preprocessing is always deferred to when the "
"model is sent to the solver",
version='5.4')
if kwds:
msg = \
"""Model.create_instance() passed the following unrecognized keyword
arguments (which have been ignored):"""
for k in kwds:
msg = msg + "\n '%s'" % (k, )
logger.error(msg)
if self.is_constructed():
deprecation_warning(
"Cannot call Model.create_instance() on a constructed "
"model; returning a clone of the current model instance.",
version='5.4')
return self.clone()
if report_timing:
timing.report_timing()
if name is None:
# Preserve only the local name (not the FQ name, as that may
# have been quoted or otherwise escaped)
name = self.local_name
if filename is not None:
if data is not None:
logger.warning(
"Model.create_instance() passed both 'filename' "
"and 'data' keyword arguments. Ignoring the "
"'data' argument")
data = filename
if data is None:
data = {}
#
# Clone the model and load the data
#
instance = self.clone()
if name is not None:
instance._name = name
# If someone passed a rule for creating the instance, fire the
# rule before constructing the components.
if instance._rule is not None:
instance._rule(instance, next(iter(self.index_set())))
if namespaces:
_namespaces = list(namespaces)
else:
_namespaces = []
if namespace is not None:
_namespaces.append(namespace)
if None not in _namespaces:
_namespaces.append(None)
instance.load(data,
namespaces=_namespaces,
profile_memory=profile_memory)
#
# Indicate that the model is concrete/constructed
#
instance._constructed = True
#
# Change this class from "Abstract" to "Concrete". It is
# absolutely crazy that this is allowed in Python, but since the
# AbstractModel and ConcreteModel are basically identical, we
# can "reassign" the new concrete instance to be an instance of
# ConcreteModel
#
instance.__class__ = ConcreteModel
return instance
def create_instance( self, filename=None, data=None, name=None,
namespace=None, namespaces=None,
profile_memory=0, report_timing=False,
**kwds ):
"""
Create a concrete instance of an abstract model, possibly using data
read in from a file.
Parameters
----------
filename: `str`, optional
The name of a Pyomo Data File that will be used to load data into
the model.
data: `dict`, optional
A dictionary containing initialization data for the model to be
used if there is no filename
name: `str`, optional
The name given to the model.
namespace: `str`, optional
A namespace used to select data.
namespaces: `list`, optional
A list of namespaces used to select data.
profile_memory: `int`, optional
A number that indicates the profiling level.
report_timing: `bool`, optional
Report timing statistics during construction.
"""
#
# Generate a warning if this is a concrete model but the
# filename is specified. A concrete model is already
# constructed, so passing in a data file is a waste of time.
#
if self.is_constructed() and isinstance(filename, string_types):
msg = "The filename=%s will not be loaded - supplied as an " \
"argument to the create_instance() method of a "\
"concrete instance with name=%s." % (filename, name)
logger.warning(msg)
if 'clone' in kwds:
kwds.pop('clone')
deprecation_warning(
"Model.create_instance() no longer accepts the 'clone' "
"argument: the base abstract model is always cloned.")
if 'preprocess' in kwds:
kwds.pop('preprocess')
deprecation_warning(
"Model.create_instance() no longer accepts the preprocess' "
"argument: preprocessing is always deferred to when the "
"model is sent to the solver")
if kwds:
msg = \
"""Model.create_instance() passed the following unrecognized keyword
arguments (which have been ignored):"""
for k in kwds:
msg = msg + "\n '%s'" % (k,)
logger.error(msg)
if self.is_constructed():
deprecation_warning(
"Cannot call Model.create_instance() on a constructed "
"model; returning a clone of the current model instance.")
return self.clone()
if report_timing:
pyomo.common.timing.report_timing()
if name is None:
name = self.name
if filename is not None:
if data is not None:
logger.warning("Model.create_instance() passed both 'filename' "
"and 'data' keyword arguments. Ignoring the "
"'data' argument")
data = filename
if data is None:
data = {}
#
# Clone the model and load the data
#
instance = self.clone()
if name is not None:
instance._name = name
# If someone passed a rule for creating the instance, fire the
# rule before constructing the components.
if instance._rule is not None:
instance._rule(instance)
if namespaces:
_namespaces = list(namespaces)
else:
_namespaces = []
if namespace is not None:
_namespaces.append(namespace)
if None not in _namespaces:
_namespaces.append(None)
instance.load( data,
namespaces=_namespaces,
profile_memory=profile_memory )
#
# Preprocess the new model
#
if False and preprocess is True:
if report_timing is True:
start_time = time.time()
instance.preprocess()
if report_timing is True:
total_time = time.time() - start_time
print(" %6.2f seconds required for preprocessing" % total_time)
if (pympler_available is True) and (profile_memory >= 2):
mem_used = muppy.get_size(muppy.get_objects())
print(" Total memory = %d bytes following instance preprocessing" % mem_used)
print("")
if (pympler_available is True) and (profile_memory >= 2):
print("")
print(" Summary of objects following instance preprocessing")
post_preprocessing_summary = summary.summarize(muppy.get_objects())
summary.print_(post_preprocessing_summary, limit=100)
#
# Indicate that the model is concrete/constructed
#
instance._constructed = True
#
# Change this class from "Abstract" to "Concrete". It is
# absolutely crazy that this is allowed in Python, but since the
# AbstractModel and ConcreteModel are basically identical, we
# can "reassign" the new concrete instance to be an instance of
# ConcreteModel
#
instance.__class__ = ConcreteModel
return instance
def xsequence(*args):
from pyomo.common.deprecation import deprecation_warning
deprecation_warning("The xsequence function is deprecated. Use the sequence() function, which returns a generator.") # Remove in Pyomo 6.0
return sequence(*args)
# ___________________________________________________________________________
#
# 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.collections import ComponentMap
from pyomo.common.deprecation import deprecation_warning
deprecation_warning(
'The pyomo.core.kernel.component_map module is deprecated. '
'Import ComponentMap from pyomo.common.collections.',
version='5.7.1')
# 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.
# ___________________________________________________________________________
# TODO
# . rename 'filter' to something else
# . confirm that filtering is efficient
__all__ = ['Set', 'set_options', 'simple_set_rule', 'SetOf']
from .set import (
process_setarg,
set_options,
simple_set_rule,
_SetDataBase,
_SetData,
Set,
SetOf,
IndexedSet,
)
from pyomo.common.deprecation import deprecation_warning
deprecation_warning(
'The pyomo.core.base.sets module is deprecated. '
'Import Set objects from pyomo.core.base.set or pyomo.core.',
version='5.7')
# ___________________________________________________________________________
#
# 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.
# ___________________________________________________________________________
__all__ = ['RangeSet']
from .set import RangeSet
from pyomo.common.deprecation import deprecation_warning
deprecation_warning(
'The pyomo.core.base.rangeset module is deprecated. '
'Import RangeSet objects from pyomo.core.base.set or pyomo.core.',
version='TBD')