def make_redo_do(i, do, redo):
'''Function adds redo and do i times to a given tree'''
sequence = TreeNode('sequence:1;', format=1)
for j in range(i):
sequence.add_child(child=redo.copy())
sequence.add_child(child=do.copy())
return sequence
def assert_depth_first_traverse_on_one_level_tree(self, function):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node12 = node1.add_child('12')
node13 = node1.add_child('13')
function(node1, self.node_visitor)
self.assertEqual([node1, node11, node12, node13], self.visited_nodes)
def test_breadth_first_traverse_on_one_level_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node12 = node1.add_child('12')
node13 = node1.add_child('13')
node1.breadth_first_traverse(self.node_visitor)
self.assertEqual([node1, node11, node12, node13], self.visited_nodes)
def test_breadth_first_traverse_gen_on_one_level_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node12 = node1.add_child('12')
node13 = node1.add_child('13')
generated_nodes = [n for n in node1.breadth_first_traverse_gen()]
self.assertEqual([node1, node11, node12, node13], generated_nodes)
def test_height_of_one_level_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node12 = node1.add_child('12')
node13 = node1.add_child('13')
self.assertEqual(1, node1.height)
self.assertEqual(0, node11.height)
self.assertEqual(0, node12.height)
self.assertEqual(0, node13.height)
def test_size_of_one_level_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node12 = node1.add_child('12')
node13 = node1.add_child('13')
self.assertEqual(4, node1.size)
self.assertEqual(1, node11.size)
self.assertEqual(1, node12.size)
self.assertEqual(1, node13.size)
def run_command(string, root: tree.TreeNode, current: tree.TreeNode):
command = string.split(' ')
function_name = command[0]
if function_name == 'ls':
if len(command) == 1:
current.list_children()
else:
path = command[1].split('/')
tmp = root.arrive_node(path)
if tmp is None:
print('No such path.')
else:
tmp.list_children()
elif function_name == 'cd':
if len(command) == 1:
print('Path is needed.')
else:
path = command[1].split('/')
tmp = root.arrive_node(path)
if tmp is None:
print('No such path.')
else:
current = tmp
elif function_name == 'pwd':
current.print_path()
elif function_name == 'mkdir':
if len(command) == 1:
print('Path is needed.')
else:
current.add_child(tree.TreeNode(command[1]))
elif function_name == 'touch':
if len(command) == 1:
print('Path is needed.')
else:
current.add_child(command[1])
elif function_name == 'rm':
if len(command) == 1:
print('Path is needed.')
else:
current.del_child(command[1])
elif function_name == 'tree':
root.show_tree()
else:
print('Command not found.')
return current
def unfold_loop(loop_nodes, max_iterations):
'''Function takes the deepest loop node and unfolds this loop into a choice between
zero and the maximum number of iterations of do and redo'''
last_loop = loop_nodes[-1]
branch_probabilities = compute_probabilities_loop(max_iterations)
'''create a new tree with a sequence as root node and three children:
-original do-child of the loop
-a choice between 0,...,max_iterations of redo and do children
-original exit-child'''
unfolded_loop = TreeNode('sequence:1;', format=1)
children_loop = last_loop.get_children()
unfolded_loop.add_child(child=children_loop[0].copy())
second_child = TreeNode('(tau:' + str(branch_probabilities[0]) +
')choice:1;',
format=1)
for i in range(max_iterations):
sequence = make_redo_do(i + 1, children_loop[0].copy(),
children_loop[1].copy())
second_child.add_child(child=sequence,
dist=branch_probabilities[i + 1])
unfolded_loop.add_child(child=second_child)
unfolded_loop.add_child(child=children_loop[2].copy())
'''replace old loop node (with subtree) by unfolded loop node'''
for child in last_loop.get_children():
child.detach()
last_loop.name = 'sequence'
for child in unfolded_loop.get_children():
last_loop.add_child(child)
def test_repr_node_with_parent(self):
root = TreeNode('a')
node = root.add_child('b')
self.assertEqual(
'[key=a, parent=None, children=[[key=b, parent=a, children=[]]]]',
repr(root))
self.assertEqual('[key=b, parent=a, children=[]]', repr(node))
class UninformedSearch:
def __init__(self, search_problem, state, container):
assert isinstance(search_problem, SearchProblem)
assert isinstance(container, Container)
# Keep search problem and container object for later use.
self.search_problem = search_problem
self.fringe = container
# Create a set of visited nodes and add the current state to it.
self.visited = set()
self.visited.add(self.search_problem.get_hashable(state))
# Create a root tree node and add it to the fringe.
self.current_node = TreeNode(None, state)
self.fringe.put_one(self.current_node)
def run(self):
while True:
# Stop searching if the fringe is empty.
if self.fringe.size() == 0:
break
# Take the next element from the fringe
self.current_node = self.fringe.take()
assert isinstance(self.current_node, TreeNode)
state = self.current_node.state
# Check if the goal has been reached.
if self.search_problem.is_goal(state):
break
# Get the children states of the current search state.
successors = self.search_problem.get_children(state)
# Generate hashable value for each of the children states.
successors = list(
map(lambda s: [s, self.search_problem.get_hashable(s)],
successors))
# Filter out those children states which have been already visited.
successors = list(
filter(lambda s: s[1] not in self.visited, successors))
# Expand the current search tree node.
child_nodes = []
for child_state, hashable in successors:
child_node = self.current_node.add_child(child_state)
child_nodes.append(child_node)
self.visited.add(hashable)
# Add the children nodes to the fringe.
self.fringe.put_many(child_nodes)
return self.current_node
def test_size_three_level_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node111 = node11.add_child('111')
node1111 = node111.add_child('1111')
node1112 = node111.add_child('1112')
node12 = node1.add_child('12')
node121 = node12.add_child('121')
node122 = node12.add_child('122')
node13 = node1.add_child('13')
self.assertEqual(9, node1.size)
self.assertEqual(4, node11.size)
self.assertEqual(3, node111.size)
self.assertEqual(1, node1111.size)
self.assertEqual(1, node1112.size)
self.assertEqual(3, node12.size)
self.assertEqual(1, node121.size)
self.assertEqual(1, node122.size)
self.assertEqual(1, node13.size)
def test_depth_first_traverse_gen_on_five_level_chain_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node111 = node11.add_child('111')
node1111 = node111.add_child('1111')
node11111 = node1111.add_child('11111')
node111111 = node11111.add_child('111111')
generated_nodes = [n for n in node1.depth_first_traverse_gen()]
self.assertEqual(
[node1, node11, node111, node1111, node11111, node111111],
generated_nodes)
def test_breadth_first_traverse_on_five_level_chain_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node111 = node11.add_child('111')
node1111 = node111.add_child('1111')
node11111 = node1111.add_child('11111')
node111111 = node11111.add_child('111111')
node1.breadth_first_traverse(self.node_visitor)
self.assertEqual(
[node1, node11, node111, node1111, node11111, node111111],
self.visited_nodes)
def spacynode_to_treenode(spacy_token, parent=None, root=None):
"""Transforms a SpaCy node (spacy.token) in a Treenode. A Treenode is a pickable version of a SpaCy token parsed
tree. Both parent and root parameters are only used internally, and should not be passed by the caller.
Args:
spacy_token: The SpaCy node itself (spacy.token).
parent: The Treenode node parent, if exists (Treenode). This is needed so references are maintained accross the
tree as to make traversing possible.
root: The Treenode root node, if exists (Treenode). This is needed so references are maintained accross the
tree as to make traversing possible.
Returns:
A Treenode pickable copy of the original SpaCy tree.
"""
# if further attributes are needed on the copied version, this constructor will need change
node = TreeNode(spacy_token.dep_, spacy_token.pos_, spacy_token.orth_,
spacy_token.idx, spacy_token.n_lefts, spacy_token.n_rights)
if isinstance(parent, TreeNode):
node.set_head(parent)
elif parent is None:
node.set_is_root()
else:
raise ValueError('Unsupported parent node provided to spacy_to_tree2 method')
if isinstance(root, TreeNode):
node.set_root(root)
elif root is None:
root = node
node.set_is_root()
else:
raise ValueError('Unsupported root node provided to spacy_to_tree2 method')
for child in spacy_token.children:
node.add_child(spacynode_to_treenode(child, node, root))
return node
def test_size_of_five_level_chain_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node111 = node11.add_child('111')
node1111 = node111.add_child('1111')
node11111 = node1111.add_child('11111')
node111111 = node11111.add_child('111111')
self.assertEqual(6, node1.size)
self.assertEqual(5, node11.size)
self.assertEqual(4, node111.size)
self.assertEqual(3, node1111.size)
self.assertEqual(2, node11111.size)
self.assertEqual(1, node111111.size)
def test_add_child(self):
key1 = 'a'
root = TreeNode(key1)
key2 = 'b'
node = root.add_child(key2)
self.assertEqual(None, root.parent)
self.assertEqual(key1, root.key)
self.assertEqual([node], root.children)
self.assertEqual(root, node.parent)
self.assertEqual(key2, node.key)
self.assertEqual([], node.children)
def test_height_of_five_level_chain_tree(self):
node1 = TreeNode('1')
node11 = node1.add_child('11')
node111 = node11.add_child('111')
node1111 = node111.add_child('1111')
node11111 = node1111.add_child('11111')
node111111 = node11111.add_child('111111')
self.assertEqual(5, node1.height)
self.assertEqual(4, node11.height)
self.assertEqual(3, node111.height)
self.assertEqual(2, node1111.height)
self.assertEqual(1, node11111.height)
self.assertEqual(0, node111111.height)
def setUp(self):
root = TreeNode('fruit')
root.add_child(TreeNode('lemon'))
root.add_child(TreeNode('strawberry'))
self.fruit = root
def test_duplicate(self):
node_01 = TreeNode('A', 1)
node_02 = TreeNode('X', 2)
node_03 = TreeNode('H', 3)
node_04 = TreeNode('G', 4)
node_05 = TreeNode('E', 5)
node_06 = TreeNode('G', 6)
node_07 = TreeNode('E', 7)
node_08 = TreeNode('H', 8)
node_09 = TreeNode('A', 9)
node_10 = TreeNode('B', 10)
node_11 = TreeNode('C', 11)
node_12 = TreeNode('H', 12)
node_13 = TreeNode('A', 13)
node_14 = TreeNode('C', 14)
node_15 = TreeNode('B', 15)
node_16 = TreeNode('E', 16)
node_17 = TreeNode('E', 17)
node_18 = TreeNode('E', 18)
node_19 = TreeNode('E', 19)
node_20 = TreeNode('A', 20)
node_21 = TreeNode('B', 21)
node_22 = TreeNode('C', 22)
node_23 = TreeNode('A', 23)
node_24 = TreeNode('B', 24)
node_25 = TreeNode('C', 25)
node_26 = TreeNode('D', 26)
node_27 = TreeNode('A', 27)
node_28 = TreeNode('B', 28)
node_29 = TreeNode('C', 29)
node_30 = TreeNode('A', 30)
node_31 = TreeNode('B', 31)
node_32 = TreeNode('C', 32)
node_33 = TreeNode('D', 33)
node_01.add_child(node_02)
node_01.add_child(node_03)
node_01.add_child(node_04)
node_03.add_child(node_05)
node_03.add_child(node_06)
node_03.add_child(node_07)
node_04.add_child(node_08)
node_05.add_child(node_09)
node_05.add_child(node_10)
node_05.add_child(node_11)
node_06.add_child(node_12)
node_07.add_child(node_13)
node_07.add_child(node_14)
node_07.add_child(node_15)
node_08.add_child(node_16)
node_08.add_child(node_17)
node_12.add_child(node_18)
node_12.add_child(node_19)
node_16.add_child(node_20)
node_16.add_child(node_21)
node_16.add_child(node_22)
node_17.add_child(node_23)
node_17.add_child(node_24)
node_17.add_child(node_25)
node_17.add_child(node_26)
node_18.add_child(node_27)
node_18.add_child(node_28)
node_18.add_child(node_29)
node_19.add_child(node_30)
node_19.add_child(node_31)
node_19.add_child(node_32)
node_19.add_child(node_33)
root = node_01
# Compare trees by structure and by values
by_struct_and_value_group_01 = {
# A leafs
node_09, node_13, node_20, node_23, node_27, node_30
}
by_struct_and_value_group_02 = {
# B leafs
node_10, node_15, node_21, node_24, node_28, node_31
}
by_struct_and_value_group_03 = {
# C leafs
node_11, node_14, node_22, node_25, node_29, node_32
}
by_struct_and_value_group_04 = {
# D leafs
node_26, node_33
}
by_struct_and_value_group_05 = {
# height 2 group 1
node_05, node_18, node_16
}
by_struct_and_value_group_06 = {
# height 2 group 2
node_17, node_19
}
by_struct_and_value_group_07 = {
# height 3
node_08, node_12
}
by_struct_and_value_group_08 = {
# height 4
node_04, node_06
}
expected_duplicate_groups = [
by_struct_and_value_group_01,
by_struct_and_value_group_02,
by_struct_and_value_group_03,
by_struct_and_value_group_04,
by_struct_and_value_group_05,
by_struct_and_value_group_06,
by_struct_and_value_group_07,
by_struct_and_value_group_08,
]
print("Expected:")
pprint(expected_duplicate_groups)
dup_groups = root.duplicates(minheight=1, compare_values=True)
print("Actual:")
pprint(dup_groups)
assert len(dup_groups) == len(expected_duplicate_groups), \
'Sizes of expected and actual groups are not equal'
match = False
for exp_set in expected_duplicate_groups:
match = False
for act_set in dup_groups:
if exp_set ^ act_set == set():
match = True
break # inner loop
assert match, \
"Expected group not found in result set. Expected: {}".format(exp_set)
#!/usr/bin/python3
from tree import TreeNode
if __name__ == '__main__':
root = TreeNode('Harry')
node1 = root.add_child('Jane')
node11 = node1.add_child('Jog')
node12 = node1.add_child('Diane')
node121 = node12.add_child('George')
node1211 = node121.add_child('Jill')
node12111 = node1211.add_child('Carol')
node122 = node12.add_child('Mary')
node13 = node1.add_child('Mark')
node2 = root.add_child('Bill')
node21 = node2.add_child('Grace')
root.display()
print('***** DEPTH-FIRST GENERATOR ITERATION *****')
for node in root.depth_first_traverse_gen():
print(node)
print('***** DEPTH-FIRST ITERATION *****')
root.depth_first_traverse(print)
print('***** BREADTH-FIRST GENERATOR ITERATION *****')
for node in root.breadth_first_traverse_gen():
print(node)
print('***** BREADTH-FIRST ITERATION *****')
invalid_input = True
break
if invalid_input:
print('Invalid input!')
continue
calc.set_infix_string(user_input)
postfix = calc.get_postfix_notation()
memory = []
i = 0
while len(postfix) > i:
current = postfix[i]
if current in operators_set:
node = TreeNode(current)
child2 = memory.pop()
child1 = memory.pop()
child1.set_parent(node)
child2.set_parent(node)
node.add_child(child1)
node.add_child(child2)
memory.append(node)
else:
node = TreeNode(current)
memory.append(node)
i += 1
tree = Tree('0')
tree.root = memory.pop()
print(tree.root)
print('result:', calc.calculate())
print()
def _TreeGenerate(self, D, A, v=None, depth=0):
"""Generate a decision tree. Note that all data vectors are Lists.
Args:
D (Tuple[x, y]): x is feature vectors and y is label vectors.
A (List[Tuple(name, type)]): arrtributes index list.
"""
root = TreeNode()
root.set_value(v)
X, y = D
# all the samples belong to the same class
if len(set(y)) == 1:
root.set_label(y[0])
return root
# A is empty set or all the samples are the same on arrtributes set A or achieving the maximum depth
if len(A) == 0 or ID3DecisionTree._is_same(X) or (
self.max_depth > 0 and depth + 1 > self.max_depth):
most_common_class = Counter(y).most_common(1)[0][0]
root.set_label(most_common_class)
return root
# get the optimal spliting attribute
optimal_attribute_idx, optimal_point = self._get_optimal_attribute_idx(
D, A)
buf_v = dict()
for index, sample in enumerate(X):
v = sample[optimal_attribute_idx]
if A[optimal_attribute_idx][1] != "CONTINUOUS":
if v not in buf_v:
buf_v[v] = [[], []]
buf_v[v][0].append(sample[:optimal_attribute_idx] +
sample[optimal_attribute_idx + 1:])
buf_v[v][1].append(y[index])
else:
if "pos" not in buf_v:
buf_v["pos"] = [[], []]
buf_v["neg"] = [[], []]
if v <= optimal_point:
buf_v["neg"][0].append(sample[:optimal_attribute_idx] +
sample[optimal_attribute_idx + 1:])
buf_v["neg"][1].append(y[index])
else:
buf_v["pos"][0].append(sample[:optimal_attribute_idx] +
sample[optimal_attribute_idx + 1:])
buf_v["pos"][1].append(y[index])
# set the optimal attribute for root
root.set_attr(A[optimal_attribute_idx][0])
root.set_attr_idx(self.attr2idx[A[optimal_attribute_idx][0]])
new_A = A[:optimal_attribute_idx] + A[optimal_attribute_idx + 1:]
for v in buf_v:
D_v = tuple(buf_v[v])
if A[optimal_attribute_idx][1] != "CONTINUOUS":
if D_v[0]:
root.add_child(self._TreeGenerate(D_v, new_A, v,
depth + 1))
else:
if D_v[0]:
if v == "pos":
root.add_child(
self._TreeGenerate(D_v, new_A,
(">", optimal_point),
depth + 1))
else:
root.add_child(
self._TreeGenerate(D_v, new_A,
("<", optimal_point),
depth + 1))
return root
class TestTreeNode(unittest.TestCase):
def setUp(self):
self.root_data = 1
self.root = TreeNode(self.root_data)
def test_data_descriptor(self):
self.assertEqual(self.root_data, self.root.data)
with self.assertRaises(AttributeError):
self.root.data = 2
def test_insert_child(self):
with self.assertRaises(TypeError):
self.root.insert_child(2)
with self.assertRaises(TypeError):
self.root.insert_child(0, 2)
with self.assertRaises(TypeError):
self.root.insert_child(TreeNode(2))
self.root.insert_child(0, TreeNode(2))
self.root.insert_child(0, TreeNode(3))
self.root.insert_child(10, TreeNode(10))
self.assertEqual(3, self.root._children[0].data)
self.assertEqual(2, self.root._children[1].data)
self.assertEqual(10, self.root._children[2].data)
def test_add_child(self):
with self.assertRaises(TypeError):
self.root.add_child(2)
for i in range(2, 5):
self.root.add_child(TreeNode(i))
for i in range(2, 5):
self.assertEqual(
i,
self.root._children[i-2].data
)
def test_children(self):
itr = self.root.children()
with self.assertRaises(StopIteration):
next(itr)
data = [2, 3, 4, 5]
for i in data:
self.root.add_child(TreeNode(i))
itr = self.root.children()
first = next(itr)
self.assertTrue(issubclass(type(first), TreeNode))
self.assertEquals(data[0], first.data)
for i, node in enumerate(itr):
self.assertEquals(data[i+1], node.data)
def test_getitem(self):
with self.assertRaises(IndexError):
tmp = self.root[0]
data = [2, 3, 4, 5]
for i in data:
self.root.add_child(TreeNode(i))
first = self.root[0]
self.assertTrue(issubclass(type(first), TreeNode))
self.assertEquals(data[0], first.data)
for i in range(1, len(data)):
self.assertEquals(data[i], self.root[i].data)
def test_duplicate(self):
node_01 = TreeNode('A', 1)
node_02 = TreeNode('X', 2)
node_03 = TreeNode('H', 3)
node_04 = TreeNode('G', 4)
node_05 = TreeNode('E', 5)
node_06 = TreeNode('G', 6)
node_07 = TreeNode('E', 7)
node_08 = TreeNode('H', 8)
node_09 = TreeNode('A', 9)
node_10 = TreeNode('B', 10)
node_11 = TreeNode('C', 11)
node_12 = TreeNode('H', 12)
node_13 = TreeNode('A', 13)
node_14 = TreeNode('C', 14)
node_15 = TreeNode('B', 15)
node_16 = TreeNode('E', 16)
node_17 = TreeNode('E', 17)
node_18 = TreeNode('E', 18)
node_19 = TreeNode('E', 19)
node_20 = TreeNode('A', 20)
node_21 = TreeNode('B', 21)
node_22 = TreeNode('C', 22)
node_23 = TreeNode('A', 23)
node_24 = TreeNode('B', 24)
node_25 = TreeNode('C', 25)
node_26 = TreeNode('D', 26)
node_27 = TreeNode('A', 27)
node_28 = TreeNode('B', 28)
node_29 = TreeNode('C', 29)
node_30 = TreeNode('A', 30)
node_31 = TreeNode('B', 31)
node_32 = TreeNode('C', 32)
node_33 = TreeNode('D', 33)
node_01.add_child(node_02)
node_01.add_child(node_03)
node_01.add_child(node_04)
node_03.add_child(node_05)
node_03.add_child(node_06)
node_03.add_child(node_07)
node_04.add_child(node_08)
node_05.add_child(node_09)
node_05.add_child(node_10)
node_05.add_child(node_11)
node_06.add_child(node_12)
node_07.add_child(node_13)
node_07.add_child(node_14)
node_07.add_child(node_15)
node_08.add_child(node_16)
node_08.add_child(node_17)
node_12.add_child(node_18)
node_12.add_child(node_19)
node_16.add_child(node_20)
node_16.add_child(node_21)
node_16.add_child(node_22)
node_17.add_child(node_23)
node_17.add_child(node_24)
node_17.add_child(node_25)
node_17.add_child(node_26)
node_18.add_child(node_27)
node_18.add_child(node_28)
node_18.add_child(node_29)
node_19.add_child(node_30)
node_19.add_child(node_31)
node_19.add_child(node_32)
node_19.add_child(node_33)
root = node_01
# Compare trees by structure and by values
by_struct_and_value_group_01 = {
# A leafs
node_09, node_13, node_20, node_23, node_27, node_30
}
by_struct_and_value_group_02 = {
# B leafs
node_10, node_15, node_21, node_24, node_28, node_31
}
by_struct_and_value_group_03 = {
# C leafs
node_11, node_14, node_22, node_25, node_29, node_32
}
by_struct_and_value_group_04 = {
# D leafs
node_26, node_33
}
by_struct_and_value_group_05 = {
# height 2 group 1
node_05, node_18, node_16
}
by_struct_and_value_group_06 = {
# height 2 group 2
node_17, node_19
}
by_struct_and_value_group_07 = {
# height 3
node_08, node_12
}
by_struct_and_value_group_08 = {
# height 4
node_04, node_06
}
expected_duplicate_groups = [
by_struct_and_value_group_01,
by_struct_and_value_group_02,
by_struct_and_value_group_03,
by_struct_and_value_group_04,
by_struct_and_value_group_05,
by_struct_and_value_group_06,
by_struct_and_value_group_07,
by_struct_and_value_group_08,
]
print("Expected:")
pprint(expected_duplicate_groups)
dup_groups = root.duplicates(minheight=1, compare_values=True)
print("Actual:")
pprint(dup_groups)
assert len(dup_groups) == len(expected_duplicate_groups), \
'Sizes of expected and actual groups are not equal'
match = False
for exp_set in expected_duplicate_groups:
match = False
for act_set in dup_groups:
if exp_set ^ act_set == set():
match = True
break # inner loop
assert match, \
"Expected group not found in result set. Expected: {}".format(exp_set)
from tree import TreeNode from dfs import dfs from dfs import width_counter tree_node1 = TreeNode(1) tree_node2 = TreeNode(2) tree_node3 = TreeNode(3) tree_node4 = TreeNode(4) tree_node5 = TreeNode(5) tree_node6 = TreeNode(6) tree_node7 = TreeNode(7) tree_node8 = TreeNode(8) tree_node1.add_child(tree_node2) tree_node1.add_child(tree_node3) tree_node2.add_child(tree_node4) tree_node2.add_child(tree_node5) tree_node3.add_child(tree_node8) tree_node8.add_child(tree_node6) tree_node8.add_child(tree_node7) goal_path = dfs(tree_node1, 7) print(width_counter(goal_path))
node_19 = TreeNode('E', 19)
node_20 = TreeNode('A', 20)
node_21 = TreeNode('B', 21)
node_22 = TreeNode('C', 22)
node_23 = TreeNode('A', 23)
node_24 = TreeNode('B', 24)
node_25 = TreeNode('C', 25)
node_26 = TreeNode('D', 26)
node_27 = TreeNode('A', 27)
node_28 = TreeNode('B', 28)
node_29 = TreeNode('C', 29)
node_30 = TreeNode('A', 30)
node_31 = TreeNode('B', 31)
node_32 = TreeNode('C', 32)
node_33 = TreeNode('D', 33)
node_01.add_child(node_02)
node_01.add_child(node_03)
node_01.add_child(node_04)
node_03.add_child(node_05)
node_03.add_child(node_06)
node_03.add_child(node_07)
node_04.add_child(node_08)
node_05.add_child(node_09)
node_05.add_child(node_10)
node_05.add_child(node_11)
node_06.add_child(node_12)
node_07.add_child(node_13)
node_07.add_child(node_14)
node_07.add_child(node_15)
node_08.add_child(node_16)
node_08.add_child(node_17)
def main():
root = TreeNode("Electronics")
laptop = TreeNode("Laptop")
laptop.add_child(TreeNode("Mac"))
laptop.add_child(TreeNode("Surface"))
laptop.add_child(TreeNode("Thinkpad"))
cellphone = TreeNode("Cell Phone")
cellphone.add_child(TreeNode("iPhone"))
cellphone.add_child(TreeNode("Google Pixel"))
cellphone.add_child(TreeNode("Vivo"))
tv = TreeNode("TV")
tv.add_child(TreeNode("Samsung"))
tv.add_child(TreeNode("LG"))
root.add_child(laptop)
root.add_child(cellphone)
root.add_child(tv)
root.print_tree()
#specify the folder with the trees
tree_files = glob.glob(tree_folder + "*.nw")
#for each tree
for filepath in tree_files:
#generate traces
t = TreeNode(filepath,format=1)
if t.get_tree_root().name == 'choice':
traces = []
children = t.get_children()
for i in range(no_cases):
child = select_child(children)
if child.is_leaf():
artificial_parent = TreeNode('sequence:1;')
artificial_parent.add_child(child=child)
simulator = TraceSimulator(artificial_parent.write(format=1,format_root_node=True),
record_timestamps)
else:
simulator = TraceSimulator(child.write(format=1,format_root_node=True),
record_timestamps)
traces.append(simulator.case.trace)
else:
simulator = LogSimulator(t.write(format=1,format_root_node=True),no_cases, record_timestamps)
traces = simulator.returnLog()
#add noise
noise_generator = NoiseGenerator(traces, noise_probability)
traces = noise_generator.resulting_traces
def test_str_node_with_parent(self):
root = TreeNode('a')
node = root.add_child('b')
self.assertEqual('a', str(root))
self.assertEqual('b', str(node))
def setUp(self):
a_node = TreeNode('A')
b_node = TreeNode('B')
a_node.add_child(b_node)
c_node = TreeNode('C')
b_node.add_child(c_node)
self.tree_one = Tree(a_node)
self.tree_one.build_caches()
a_node = TreeNode('A')
b_node = TreeNode('B')
c_node = TreeNode('C')
d_node = TreeNode('D')
a_node.add_child(b_node)
a_node.add_child(c_node)
c_node.add_child(d_node)
self.tree_two = Tree(a_node)
self.tree_two.build_caches()
a_node = TreeNode('A')
b_node = TreeNode('B')
c_node = TreeNode('C')
d_node = TreeNode('D')
e_node = TreeNode('E')
a_node.add_child(b_node)
a_node.add_child(c_node)
c_node.add_child(d_node)
d_node.add_child(e_node)
self.tree_three = Tree(a_node)
self.tree_three.build_caches()
def levelWidth(root):
END = 'end of level'
widths = [0]
queue = deque([root, END])
# END will remain after all nodes processed
while len(queue) > 1:
node = queue.popleft()
if node is END:
widths.append(0)
queue.append(END)
else:
queue.extend(node.children)
widths[-1] += 1
return widths
n = TreeNode('root')
for i in range(3):
n.add_child(f'node {i}')
for c in n.children:
c.add_child(f'node {c.data} leaf 1')
c.add_child(f'node {c.data} leaf 2')
assert levelWidth(n) == [1, 3, 6]
n.add_child('another child')
assert levelWidth(n) == [1, 4, 6]
print('All tests passed!')
