def test_OLD_beforeChild_acceptChildResult_afterChild(self):
counts = [0,0,0]
def before(node, child):
counts[0] += 1
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, None
def accept(node, data, child_result):
counts[1] += 1
def after(node, child):
counts[2] += 1
os = StringIO()
with LoggingIntercept(os, 'pyomo'):
walker = StreamBasedExpressionVisitor(
beforeChild=before, acceptChildResult=accept, afterChild=after)
self.assertIn(
"Note that the API for the StreamBasedExpressionVisitor "
"has changed to include the child index for the "
"beforeChild() method", os.getvalue().replace('\n',' '))
self.assertIn(
"Note that the API for the StreamBasedExpressionVisitor "
"has changed to include the child index for the "
"acceptChildResult() method", os.getvalue().replace('\n',' '))
self.assertIn(
"Note that the API for the StreamBasedExpressionVisitor "
"has changed to include the child index for the "
"afterChild() method", os.getvalue().replace('\n',' '))
ans = walker.walk_expression(self.e)
m = self.m
self.assertEqual(ans, None)
self.assertEquals(counts, [9,9,9])
def test_enterNode_noLeafList(self):
# This is an alternative way to implement the beforeChild test:
def enter(node):
if type(node) in nonpyomo_leaf_types \
or not node.is_expression_type():
return (), node
return node.args, []
walker = StreamBasedExpressionVisitor(
enterNode=enter)
m = self.m
ans = walker.walk_expression(self.e)
ref = [
[m.x, 2],
m.y,
[m.z, [m.x, m.y]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = m.x
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = 2
self.assertEqual(str(ans), str(ref))
def test_enterNode_withFinalize(self):
# This is an alternative way to implement the beforeChild test:
def enter(node):
if type(node) in nonpyomo_leaf_types \
or not node.is_expression_type():
return (), node
return node.args, []
def finalize(result):
if type(result) is list:
return result
else:
return [result]
walker = StreamBasedExpressionVisitor(enterNode=enter,
finalizeResult=finalize)
m = self.m
ans = walker.walk_expression(self.e)
ref = [[m.x, 2], m.y, [m.z, [m.x, m.y]]]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = [m.x]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = [2]
self.assertEqual(str(ans), str(ref))
def test_exitNode(self):
# This is an alternative way to implement the beforeChild test:
def exit(node, data):
if data:
return data
else:
return [node]
walker = StreamBasedExpressionVisitor(exitNode=exit)
m = self.m
ans = walker.walk_expression(self.e)
ref = [
[[m.x], [2]],
[m.y],
[[m.z], [[m.x], [m.y]]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = [m.x]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = [2]
self.assertEqual(str(ans), str(ref))
def test_old_beforeChild(self):
def before(node, child):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, [child]
os = StringIO()
with LoggingIntercept(os, 'pyomo'):
walker = StreamBasedExpressionVisitor(beforeChild=before)
self.assertIn(
"Note that the API for the StreamBasedExpressionVisitor "
"has changed to include the child index for the beforeChild() "
"method",
os.getvalue().replace('\n', ' '))
ans = walker.walk_expression(self.e)
m = self.m
ref = [[[m.x], [2]], [m.y], [[m.z], [[m.x], [m.y]]]]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = []
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = []
self.assertEqual(str(ans), str(ref))
def test_exitNode(self):
# This is an alternative way to implement the beforeChild test:
def exit(node, data):
if data:
return data
else:
return [node]
walker = StreamBasedExpressionVisitor(exitNode=exit)
m = self.m
ans = walker.walk_expression(self.e)
ref = [
[[m.x], [2]],
[m.y],
[[m.z], [[m.x], [m.y]]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = [m.x]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = [2]
self.assertEqual(str(ans), str(ref))
def test_finalize(self):
ans = []
def before(node, child, child_idx):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, child
def accept(node, data, child_result, child_idx):
if data is not child_result:
data.append(child_result)
return data
def enter(node):
return node.args, ans
def finalize(result):
return len(result)
walker = StreamBasedExpressionVisitor(enterNode=enter,
beforeChild=before,
acceptChildResult=accept,
finalizeResult=finalize)
ans = walker.walk_expression(self.e)
self.assertEqual(ans, 6)
def test_enterNode_withFinalize(self):
# This is an alternative way to implement the beforeChild test:
def enter(node):
if type(node) in nonpyomo_leaf_types \
or not node.is_expression_type():
return (), node
return node.args, []
def finalize(result):
if type(result) is list:
return result
else:
return[result]
walker = StreamBasedExpressionVisitor(
enterNode=enter, finalizeResult=finalize)
m = self.m
ans = walker.walk_expression(self.e)
ref = [
[m.x, 2],
m.y,
[m.z, [m.x, m.y]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = [m.x]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = [2]
self.assertEqual(str(ans), str(ref))
def test_enterNode_noLeafList(self):
# This is an alternative way to implement the beforeChild test:
def enter(node):
if type(node) in nonpyomo_leaf_types \
or not node.is_expression_type():
return (), node
return node.args, []
walker = StreamBasedExpressionVisitor(
enterNode=enter)
m = self.m
ans = walker.walk_expression(self.e)
ref = [
[m.x, 2],
m.y,
[m.z, [m.x, m.y]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = m.x
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = 2
self.assertEqual(str(ans), str(ref))
def test_default(self):
walker = StreamBasedExpressionVisitor()
ans = walker.walk_expression(self.e)
ref = [[[], []], [], [
[],
[[], []],
]]
self.assertEqual(ans, ref)
def test_reduce_in_accept(self):
def enter(node):
return None, 1
def accept(node, data, child_result):
return data + child_result
walker = StreamBasedExpressionVisitor(
enterNode=enter, acceptChildResult=accept)
# 4 operators, 6 leaf nodes
self.assertEquals(walker.walk_expression(self.e), 10)
def test_reduce_in_accept(self):
def enter(node):
return None, 1
def accept(node, data, child_result):
return data + child_result
walker = StreamBasedExpressionVisitor(
enterNode=enter, acceptChildResult=accept)
# 4 operators, 6 leaf nodes
self.assertEquals(walker.walk_expression(self.e), 10)
def test_default(self):
walker = StreamBasedExpressionVisitor()
ans = walker.walk_expression(self.e)
ref = [
[[],[]],
[],
[[],[[],[]],]
]
self.assertEqual(ans, ref)
def resolve_template(expr):
"""Resolve a template into a concrete expression
This takes a template expression and returns the concrete equivalent
by substituting the current values of all IndexTemplate objects and
resolving (evaluating and removing) all GetItemExpression,
GetAttrExpression, and TemplateSumExpression expression nodes.
"""
def beforeChild(node, child, child_idx):
# Efficiency: do not decend into leaf nodes.
if type(child) in native_types or not child.is_expression_type():
if hasattr(child, '_resolve_template'):
return False, child._resolve_template(())
return False, child
else:
return True, None
def exitNode(node, args):
if hasattr(node, '_resolve_template'):
return node._resolve_template(args)
if len(args) == node.nargs() and all(a is b
for a, b in zip(node.args, args)):
return node
return node.create_node_with_local_data(args)
return StreamBasedExpressionVisitor(
initializeWalker=lambda x: beforeChild(None, x, None),
beforeChild=beforeChild,
exitNode=exitNode,
).walk_expression(expr)
def test_beforeChild_acceptChildResult_afterChild(self):
counts = [0,0,0]
def before(node, child):
counts[0] += 1
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, None
def accept(node, data, child_result):
counts[1] += 1
def after(node, child):
counts[2] += 1
walker = StreamBasedExpressionVisitor(
beforeChild=before, acceptChildResult=accept, afterChild=after)
ans = walker.walk_expression(self.e)
m = self.m
self.assertEqual(ans, None)
self.assertEquals(counts, [9,9,9])
def test_beforeChild_acceptChildResult_afterChild(self):
counts = [0,0,0]
def before(node, child):
counts[0] += 1
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, None
def accept(node, data, child_result):
counts[1] += 1
def after(node, child):
counts[2] += 1
walker = StreamBasedExpressionVisitor(
beforeChild=before, acceptChildResult=accept, afterChild=after)
ans = walker.walk_expression(self.e)
m = self.m
self.assertEqual(ans, None)
self.assertEquals(counts, [9,9,9])
def test_enterNode_acceptChildResult_beforeChild(self):
ans = []
def before(node, child):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, child
def accept(node, data, child_result):
if data is not child_result:
data.append(child_result)
return data
def enter(node):
return node.args, ans
walker = StreamBasedExpressionVisitor(
enterNode=enter, beforeChild=before, acceptChildResult=accept)
ans = walker.walk_expression(self.e)
m = self.m
ref = [m.x, 2, m.y, m.z, m.x, m.y]
self.assertEqual(str(ans), str(ref))
def test_enterNode_acceptChildResult_beforeChild(self):
ans = []
def before(node, child):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, child
def accept(node, data, child_result):
if data is not child_result:
data.append(child_result)
return data
def enter(node):
return node.args, ans
walker = StreamBasedExpressionVisitor(
enterNode=enter, beforeChild=before, acceptChildResult=accept)
ans = walker.walk_expression(self.e)
m = self.m
ref = [m.x, 2, m.y, m.z, m.x, m.y]
self.assertEqual(str(ans), str(ref))
def test_finalize(self):
ans = []
def before(node, child):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, child
def accept(node, data, child_result):
if data is not child_result:
data.append(child_result)
return data
def enter(node):
return node.args, ans
def finalize(result):
return len(result)
walker = StreamBasedExpressionVisitor(
enterNode=enter, beforeChild=before, acceptChildResult=accept,
finalizeResult=finalize)
ans = walker.walk_expression(self.e)
self.assertEqual(ans, 6)
def test_beforeChild(self):
def before(node, child, child_idx):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, [child]
walker = StreamBasedExpressionVisitor(beforeChild=before)
ans = walker.walk_expression(self.e)
m = self.m
ref = [[[m.x], [2]], [m.y], [[m.z], [[m.x], [m.y]]]]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = []
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = []
self.assertEqual(str(ans), str(ref))
def test_beforeChild(self):
def before(node, child):
if type(child) in nonpyomo_leaf_types \
or not child.is_expression_type():
return False, [child]
walker = StreamBasedExpressionVisitor(beforeChild=before)
ans = walker.walk_expression(self.e)
m = self.m
ref = [
[[m.x], [2]],
[m.y],
[[m.z], [[m.x], [m.y]]]
]
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(m.x)
ref = []
self.assertEqual(str(ans), str(ref))
ans = walker.walk_expression(2)
ref = []
self.assertEqual(str(ans), str(ref))
def _check_cut_coefficients_are_numerically_reasonable(cut):
def enter_node(node):
return None, []
def exit_node(node, data):
node_type = type(node)
if node_type in nonpyomo_leaf_types:
return np.isfinite(node)
elif not node.is_expression_type() and not node.is_variable_type():
return np.isfinite(node.value)
return True
return StreamBasedExpressionVisitor(
enterNode=enter_node,
exitNode=exit_node,
).walk_expression(cut)
def test_all_function_pointers(self):
ans = []
def name(x):
if type(x) in nonpyomo_leaf_types:
return str(x)
else:
return x.name
def enter(node):
ans.append("Enter %s" % (name(node)))
def exit(node, data):
ans.append("Exit %s" % (name(node)))
def before(node, child, child_idx):
ans.append("Before %s (from %s)" % (name(child), name(node)))
def accept(node, data, child_result, child_idx):
ans.append("Accept into %s" % (name(node)))
def after(node, child, child_idx):
ans.append("After %s (from %s)" % (name(child), name(node)))
def finalize(result):
ans.append("Finalize")
walker = StreamBasedExpressionVisitor(enterNode=enter,
exitNode=exit,
beforeChild=before,
acceptChildResult=accept,
afterChild=after,
finalizeResult=finalize)
self.assertIsNone(walker.walk_expression(self.e))
self.assertEqual(
"\n".join(ans), """Enter sum
Before pow (from sum)
Enter pow
Before x (from pow)
Enter x
Exit x
Accept into pow
After x (from pow)
Before 2 (from pow)
Enter 2
Exit 2
Accept into pow
After 2 (from pow)
Exit pow
Accept into sum
After pow (from sum)
Before y (from sum)
Enter y
Exit y
Accept into sum
After y (from sum)
Before prod (from sum)
Enter prod
Before z (from prod)
Enter z
Exit z
Accept into prod
After z (from prod)
Before sum (from prod)
Enter sum
Before x (from sum)
Enter x
Exit x
Accept into sum
After x (from sum)
Before y (from sum)
Enter y
Exit y
Accept into sum
After y (from sum)
Exit sum
Accept into prod
After sum (from prod)
Exit prod
Accept into sum
After prod (from sum)
Exit sum
Finalize""")
def test_all_function_pointers(self):
ans = []
def name(x):
if type(x) in nonpyomo_leaf_types:
return str(x)
else:
return x.name
def enter(node):
ans.append("Enter %s" % (name(node)))
def exit(node, data):
ans.append("Exit %s" % (name(node)))
def before(node, child):
ans.append("Before %s (from %s)" % (name(child), name(node)))
def accept(node, data, child_result):
ans.append("Accept into %s" % (name(node)))
def after(node, child):
ans.append("After %s (from %s)" % (name(child), name(node)))
def finalize(result):
ans.append("Finalize")
walker = StreamBasedExpressionVisitor(
enterNode=enter, exitNode=exit, beforeChild=before,
acceptChildResult=accept, afterChild=after, finalizeResult=finalize)
self.assertIsNone( walker.walk_expression(self.e) )
self.assertEqual("\n".join(ans),"""Enter sum
Before pow (from sum)
Enter pow
Before x (from pow)
Enter x
Exit x
Accept into pow
After x (from pow)
Before 2 (from pow)
Enter 2
Exit 2
Accept into pow
After 2 (from pow)
Exit pow
Accept into sum
After pow (from sum)
Before y (from sum)
Enter y
Exit y
Accept into sum
After y (from sum)
Before prod (from sum)
Enter prod
Before z (from prod)
Enter z
Exit z
Accept into prod
After z (from prod)
Before sum (from prod)
Enter sum
Before x (from sum)
Enter x
Exit x
Accept into sum
After x (from sum)
Before y (from sum)
Enter y
Exit y
Accept into sum
After y (from sum)
Exit sum
Accept into prod
After sum (from prod)
Exit prod
Accept into sum
After prod (from sum)
Exit sum
Finalize""")
def test_bad_args(self):
with self.assertRaisesRegexp(
RuntimeError, "Unrecognized keyword arguments: {'foo': None}"):
StreamBasedExpressionVisitor(foo=None)