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_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_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_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_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_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_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_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 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 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_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""")