def test_str(self):
m = ConcreteModel()
m.b = Block()
# Note that we are testing the string representation of a slice,
# not if the slice is valid
s = m.b[...].x[:, 1:2, 1:5:2, ::1, 5, 'a'].component('foo', kwarg=1)
self.assertEqual(
str(s),
"b[...].x[:, 1:2, 1:5:2, ::1, 5, 'a'].component('foo', kwarg=1)")
# To test set / del, we want to form the IndexedComponent_slice
# without evaluating it
s = m.b[...]
self.assertEqual(
str(
IndexedComponent_slice(
s, (IndexedComponent_slice.del_attribute, 'bogus'))),
'del b[...].bogus')
self.assertEqual(
str(
IndexedComponent_slice(
s, (IndexedComponent_slice.set_attribute, 'bogus', 10))),
'b[...].bogus = 10')
def test_cuid_from_slice_errors(self):
# two getitem
m = self._slice_model()
m.b.comp = Reference(m.b.b1[:].v1)
_slice = m.b[:].comp[1][1.1]
with self.assertRaisesRegex(ValueError, r'.*Two `get_item` calls.*'):
cuid = ComponentUID(_slice)
_slice = IndexedComponent_slice(m.b[:].component('v'),
(IndexedComponent_slice.del_attribute,
('foo', )))
with self.assertRaisesRegex(
ValueError, "Cannot create a CUID from a slice that "
"contains `set` or `del` calls: got call %s "
r"with argument \('foo',\)" %
(IndexedComponent_slice.del_attribute, )):
cuid = ComponentUID(_slice)
def _processUnhashableIndex(self, idx):
"""Process a call to __getitem__ with unhashable elements
There are three basic ways to get here:
1) the index contains one or more slices or ellipsis
2) the index contains an unhashable type (e.g., a Pyomo
(Simple)Component
3) the index contains an IndexTemplate
"""
from pyomo.core.expr import current as EXPR
#
# Iterate through the index and look for slices and constant
# components
#
fixed = {}
sliced = {}
ellipsis = None
_found_numeric = False
#
# Setup the slice template (in fixed)
#
if normalize_index.flatten:
idx = normalize_index(idx)
if idx.__class__ is not tuple:
idx = (idx, )
for i, val in enumerate(idx):
if type(val) is slice:
if val.start is not None or val.stop is not None:
raise IndexError(
"Indexed components can only be indexed with simple "
"slices: start and stop values are not allowed.")
if val.step is not None:
logger.warning(
"DEPRECATION WARNING: The special wildcard slice "
"(::0) is deprecated. Please use an ellipsis (...) "
"to indicate '0 or more' indices")
val = Ellipsis
else:
if ellipsis is None:
sliced[i] = val
else:
sliced[i - len(idx)] = val
continue
if val is Ellipsis:
if ellipsis is not None:
raise IndexError(
"Indexed components can only be indexed with simple "
"slices: the Pyomo wildcard slice (Ellipsis; "
"e.g., '...') can only appear once")
ellipsis = i
continue
if hasattr(val, 'is_expression_type'):
_num_val = val
# Attempt to retrieve the numeric value .. if this
# is a template expression generation, then it
# should raise a TemplateExpressionError
try:
val = EXPR.evaluate_expression(val, constant=True)
_found_numeric = True
except TemplateExpressionError:
#
# The index is a template expression, so return the
# templatized expression.
#
from pyomo.core.expr import current as EXPR
return EXPR.GetItemExpression((self, ) + tuple(idx))
except EXPR.NonConstantExpressionError:
#
# The expression contains an unfixed variable
#
raise RuntimeError(
"""Error retrieving the value of an indexed item %s:
index %s is not a constant value. This is likely not what you meant to
do, as if you later change the fixed value of the object this lookup
will not change. If you understand the implications of using
non-constant values, you can get the current value of the object using
the value() function.""" % (self.name, i))
except EXPR.FixedExpressionError:
#
# The expression contains a fixed variable
#
raise RuntimeError(
"""Error retrieving the value of an indexed item %s:
index %s is a fixed but not constant value. This is likely not what you
meant to do, as if you later change the fixed value of the object this
lookup will not change. If you understand the implications of using
fixed but not constant values, you can get the current value using the
value() function.""" % (self.name, i))
#
# There are other ways we could get an exception such as
# evaluating a Param / Var that is not initialized.
# These exceptions will continue up the call stack.
#
# verify that the value is hashable
hash(val)
if ellipsis is None:
fixed[i] = val
else:
fixed[i - len(idx)] = val
if sliced or ellipsis is not None:
slice_dim = len(idx)
if ellipsis is not None:
slice_dim -= 1
if normalize_index.flatten:
set_dim = self.dim()
elif self._implicit_subsets is None:
# Scalar component.
set_dim = 0
else:
set_dim = len(self._implicit_subsets)
structurally_valid = False
if slice_dim == set_dim or set_dim is None:
structurally_valid = True
elif ellipsis is not None and slice_dim < set_dim:
structurally_valid = True
elif set_dim == 0 and idx == (slice(None), ):
# If dim == 0 and idx is slice(None), the component was
# a scalar passed a single slice. Since scalar components
# can be accessed with a "1-dimensional" index of None,
# this behavior is allowed.
#
# Note that x[...] is caught above, as slice_dim will be
# 0 in that case
structurally_valid = True
if not structurally_valid:
raise IndexError(
"Index %s contains an invalid number of entries for "
"component %s. Expected %s, got %s." %
(idx, self.name, set_dim, slice_dim))
return IndexedComponent_slice(self, fixed, sliced, ellipsis)
elif _found_numeric:
if len(idx) == 1:
return fixed[0]
else:
return tuple(fixed[i] for i in range(len(idx)))
else:
raise DeveloperError(
"Unknown problem encountered when trying to retrieve "
"index for component %s" % (self.name, ))
def test_cuid_from_slice_with_call(self):
m = self._slice_model()
_slice = m.b.component('b2')[:, 'a'].v2[1, :]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[*,a].v2[1,*]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
# This works as find_component is not in the
# _call_stack of the slice.
_slice = m.b.find_component('b2')[:, 'a'].v2[1, :]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[*,a].v2[1,*]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
_slice = m.b[:].component('b2')
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b[*].b2')
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
_slice = m.b[:].component('b2', 'b1')
with self.assertRaisesRegex(ValueError, '.*multiple arguments.*'):
cuid = ComponentUID(_slice)
# call of something other than component
_slice = IndexedComponent_slice(m.b[:].fix,
(IndexedComponent_slice.call,
('fix', ), {}))
with self.assertRaisesRegex(
ValueError,
"Cannot create a CUID from a slice with a call to any "
r"method other than 'component': got 'fix'\."):
cuid = ComponentUID(_slice)
_slice = IndexedComponent_slice(m.b[:].component('v'),
(IndexedComponent_slice.call,
('fix', ), {}))
with self.assertRaisesRegex(
ValueError, "Cannot create a CUID with a __call__ of anything "
"other than a 'component' attribute"):
cuid = ComponentUID(_slice)
_slice = m.b[:].component('b2', kwd=None)
with self.assertRaisesRegex(ValueError,
'.*call that contains keywords.*'):
cuid = ComponentUID(_slice)
_slice = m.b.b2[:, 'a'].component('vn')[:, 'c', 3, :, :]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[*,a].vn[*,c,3,*,*]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
_slice = m.b.b2[1, 'a'].component('vn')[:, 'c', 3, :, :]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[1,a].vn[*,c,3,*,*]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
_slice = m.b.b2[...].component('vn')[:, 'c', 3, :, :]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[**].vn[*,c,3,*,*]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)
_slice = m.b.b2[:, 'a'].component('vn')[...]
cuid = ComponentUID(_slice)
cuid_str = ComponentUID('b.b2[*,a].vn[**]')
self.assertEqual(cuid, cuid_str)
self.assertEqual(str(cuid), str(cuid_str))
self.assertListSameComponents(m, cuid, cuid_str)