def __init__(self, id, opcode, op_array, context):
""" Create a tree representaiton of an Opcode
Arguments :
id : The id representing the new OPcode
opcode : An OPcode struct
op_array : The op_array of the OPcode
context : An OPcacheParser instance
"""
Tree.__init__(self)
# Identifier to be used by the tree and nodes
id_with_hash = str(hash(str(op_array))) + "_" + id
# OP name
op = OPcodeParser.get_opcode_name(opcode['opcode'])
# Parser
context = OPcodeParser(context)
# Parse operands and result
(op1, op2, result) = context.parse_operands(opcode, op_array)
# Create nodes
op1_node = Node("Operand 1: " + op1, id_with_hash + "_op1")
op2_node = Node("Operand 2: " + op2, id_with_hash + "_op2")
result_node = Node("Result: " + result, id_with_hash + "_result")
# Link nodes to tree
self.create_node(id + ": " + op, id_with_hash + "_opcode")
self.add_node(op1_node, parent=id_with_hash + "_opcode")
self.add_node(op2_node, parent=id_with_hash + "_opcode")
self.add_node(result_node, parent=id_with_hash + "_opcode")
def program(self):
'''
Program → Statement SEMICO Program |ε
P -> S ; P
'''
# node = Node (tag= 'a')
self.root = Node(tag='Program')
self.token = self.lexer.getToken()
self.tree.add_node(self.root)
node = self.root
while (self.token.type != Token_Type.NONTOKEN):
node1 = Node(tag='Statement')
node2 = Node(tag=';')
node3 = Node(tag='Program')
self.tree.add_node(node1, node)
self.tree.add_node(node2, node)
self.tree.add_node(node3, node)
self.statement(node1)
# self.token = self.lexer.getToken ()
# print (self.token.type)
self.typecheck(Token_Type.SEMICO)
self.token = self.lexer.getToken()
node = node3
if (self.state == self.ERROR):
raise SyntaxError('SyntaxError !')
self.add_node('Empty', node)
print('---------------------Object Tree----------------------')
self.tree.show()
self.getValue()
def __init__(self, http_entry): assert isinstance(http_entry, HTTPLogEntry) Node.__init__(self) self._dummy = 0 # help to process dummy nodes self.aem_pred = None # the classified type for preceeding entity by AEM model self.aem_last = None # the classified type for LAST entity by AEM model self.fake_link = True # if the link is fake derived from referrer self.pl = http_entry # http log entries self.tag = self.gen_tag() # formated tag to show by tree
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "identifier 1")
self.assertEqual(self.node1.expanded, True)
self.assertEqual(self.node1.bpointer, None)
self.assertEqual(self.node1.fpointer, [])
self.assertEqual(self.node1.data, None)
def test_set_tag(self):
self.node1.tag = "Test 1"
self.assertEqual(self.node1.tag, "Test 1")
self.node1.tag = "Test One"
def test_object_as_node_tag(self):
node = Node(tag=(0, 1))
self.assertEqual(node.tag, (0, 1))
self.assertTrue(node.__repr__().startswith('Node'))
def test_set_identifier(self):
self.node1.identifier = "ID1"
self.assertEqual(self.node1.identifier, "ID1")
self.node1.identifier = "identifier 1"
def test_set_fpointer(self):
self.node1.update_fpointer("identifier 2")
self.assertEqual(self.node1.fpointer, ['identifier 2'])
self.node1.fpointer = []
def test_set_bpointer(self):
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node2.bpointer, 'identifier 1')
self.node2.bpointer = None
def test_set_is_leaf(self):
self.node1.update_fpointer("identifier 2")
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node1.is_leaf(), False)
self.assertEqual(self.node2.is_leaf(), True)
def test_data(self):
class Flower(object):
def __init__(self, color):
self.color = color
def __str__(self):
return "%s" % self.color
self.node1.data = Flower("red")
self.assertEqual(self.node1.data.color, "red")
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "identifier 1")
self.assertEqual(self.node1.expanded, True)
self.assertEqual(self.node1.bpointer, None)
self.assertEqual(self.node1.fpointer, [])
self.assertEqual(self.node1.data, None)
def test_set_tag(self):
self.node1.tag = "Test 1"
self.assertEqual(self.node1.tag, "Test 1")
self.node1.tag = "Test One"
def test_object_as_node_tag(self):
node = Node(tag=(0, 1))
self.assertEqual(node.tag, (0, 1))
self.assertTrue(node.__repr__().startswith('Node'))
def test_set_identifier(self):
self.node1.identifier = "ID1"
self.assertEqual(self.node1.identifier, "ID1")
self.node1.identifier = "identifier 1"
def test_set_fpointer(self):
self.node1.update_fpointer("identifier 2")
self.assertEqual(self.node1.fpointer, ['identifier 2'])
self.node1.fpointer = []
def test_set_bpointer(self):
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node2.bpointer, 'identifier 1')
self.node2.bpointer = None
def test_set_is_leaf(self):
self.node1.update_fpointer("identifier 2")
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node1.is_leaf(), False)
self.assertEqual(self.node2.is_leaf(), True)
def test_data(self):
class Flower(object):
def __init__(self, color):
self.color = color
def __str__(self):
return "%s" % self.color
self.node1.data = Flower("red")
self.assertEqual(self.node1.data.color, "red")
def build_ast(parent, task):
root = Node(parent)
for key in list(task.keys()):
node_key = Node(key, parent=root)
value_element = task[key]
Node(value_element, parent=node_key)
return root
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "identifier 1")
self.assertEqual(self.node1.expanded, True)
self.assertEqual(self.node1.bpointer, None)
self.assertEqual(self.node1.fpointer, [])
self.assertEqual(self.node1.data, None)
def test_set_tag(self):
self.node1.tag = "Test 1"
self.assertEqual(self.node1.tag, "Test 1")
self.node1.tag = "Test One"
def test_set_identifier(self):
self.node1.identifier = "ID1"
self.assertEqual(self.node1.identifier, "ID1")
self.node1.identifier = "identifier 1"
def test_set_fpointer(self):
self.node1.update_fpointer("identifier 2")
self.assertEqual(self.node1.fpointer, ["identifier 2"])
self.node1.fpointer = []
def test_set_bpointer(self):
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node2.bpointer, "identifier 1")
self.node2.bpointer = None
def test_set_is_leaf(self):
self.node1.update_fpointer("identifier 2")
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node1.is_leaf(), False)
self.assertEqual(self.node2.is_leaf(), True)
def test_data(self):
class Flower(object):
def __init__(self, color):
self.color = color
def __str__(self):
return "%s" % self.color
self.node1.data = Flower("red")
self.assertEqual(self.node1.data.color, "red")
def tearDown(self):
pass
def fit_tree(k, preds, y, i, parent=None):
if k > 0:
l_preds, l_y, l_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'l' + str(k),
data=l_model),
parent=parent)
fit_tree(k - 1, l_preds, l_y, i + 1, parent + 'l' + str(k))
r_preds, r_y, r_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'r' + str(k),
data=r_model),
parent=parent)
fit_tree(k - 1, r_preds, r_y, i + 1, parent + 'r' + str(k))
def node2TreeOfTwo(self, tuple1, tuple2):
t = Tree()
node1 = Node(tuple1, tuple1[0])
node2 = Node(tuple2, tuple2[0])
freq = tuple1[1] + tuple2[1]
tag = tuple1[0] + tuple2[0]
t.create_node("(" + str(tag) + ", " + str(freq) + ")", tag, None)
if tuple1[1] >= tuple2[1]:
t.add_node(node1, tag)
t.add_node(node2, tag)
else:
t.add_node(node2, tag)
t.add_node(node1, tag)
return t
def __init__(self, *args, document, **kwargs):
if 'tag' not in kwargs:
kwargs['tag'] = self.__class__.__name__
name = kwargs.get('name', kwargs['tag'])
self.document = document
# node consumes data
Node.__init__(self, *args, **kwargs)
State.__init__(
self,
name,
on_enter=kwargs.get('on_enter'),
on_exit=kwargs.get('on_exit'),
ignore_invalid_triggers=kwargs.get('ignore_invalid_triggers'))
self.data = self
def __init__( self, record, offset, tag=None, identifier=None, expanded=True ):
Node.__init__( self, tag=tag, identifier=identifier, expanded=expanded )
self.record = record
self.offset = offset
self.payload_offset = 0
self.xattrs = {}
self.xattrs[ "offset" ] = str( offset )
for k, v in record.headers:
self.xattrs[ k ] = v
if record.type == WarcRecord.RESPONSE and record.url.startswith( "http" ):
mime, data = record.content
if data.startswith( "HTTP" ):
match = re.search( "\r?\n(\r?\n)+", data, re.MULTILINE )
self.xattrs[ "http.headers" ] = data[ 0:match.end() ]
self.payload_offset = match.end()
def _create_tree(self, initial_state):
"""
A tree object for visualization purposes is created.
Parameters
----------
initial_state: state
An initial state
"""
self.tree = Tree()
self.tree.add_node(
Node(f'({0}:{initial_state}:{self.policy[(0, initial_state)]})',
f'({0}:{initial_state}:{self.policy[(0, initial_state)]})'))
def add_sons(s, t):
a = self.policy[(t, s)]
if t == self.T:
for st in self.Q(s, a):
n = Node(f'({t + 1}:{st})', f'({t + 1}:{st})')
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
elif t < self.T - 1:
for st in self.Q(s, a):
at = self.policy[(t + 1, st)]
n = Node(f'({t + 1}:{st}:{at})', f'({t + 1}:{st}:{at})')
if n.identifier not in map(lambda x: x.identifier,
self.tree.all_nodes()):
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
add_sons(st, t + 1)
add_sons(initial_state, 0)
def is_faithful(self, required_folders: Node = None, directory_path: str = None) -> bool:
"""Recursive method to know if a directory contains all the structure required.
The method will check if the repository contains all the sub folders into required_folders.
Then it will check the sub folders into each sub folders from the initial list recursively.
:param required_folders: The list of the first sub folders
:type required_folders: Node
:param directory_path: The directory to test
:type directory_path: str
:return: If the directory contains all the required folders
:rtype: boolean
.. seealso:: The tree structure documentation (`link <http://treelib.readthedocs.io/en/latest/>`_)
"""
if required_folders is None:
required_folders = required_tree.children("Root")
if directory_path is None:
directory_path = self.directory_path
if required_folders.__len__() == 0:
return True
result = True
list_folders = list_folders_into_directory(directory_path)
for required_folder in required_folders:
required_folder_tag = required_folder.tag
required_folders_children = required_tree.children(required_folder_tag)
new_directory_path = join(directory_path, required_folder_tag)
if result and required_folder_tag in list_folders and required_folders_children.__len__() != 0:
result = result and self.is_faithful(required_folders_children, new_directory_path)
if required_folder_tag not in list_folders:
return False
return result
def save(self,
f,
nid=None,
level=Tree.ROOT,
idhidden=True,
filter=None,
cmp=None,
key=None,
reverse=False):
leading = ''
lasting = ''
nid = self.root if (nid is None) else Node.sanitize_id(nid)
label = ("{0}".format(self[nid].tag)) if idhidden else (
"{0}[{1}]".format(self[nid].tag, self[nid].identifier))
filter = (self._real_true) if (filter is None) else filter
if level == self.ROOT:
f.write(label + '\n')
else:
leading += '\t' * level
f.write("{0}{1}{2}\n".format(leading, lasting, label))
if filter(self[nid]) and self[nid].expanded:
queue = [self[i] for i in self[nid].fpointer if filter(self[i])]
key = (lambda x: x) if (key is None) else key
queue.sort(cmp=cmp, key=key, reverse=reverse)
level += 1
for element in queue:
self.save(f, element.identifier, level, idhidden, filter, cmp,
key, reverse)
def add_sons(s, t):
a = self.policy[(t, s)]
if t == self.T:
for st in self.Q(s, a):
n = Node(f'({t + 1}:{st})', f'({t + 1}:{st})')
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
elif t < self.T - 1:
for st in self.Q(s, a):
at = self.policy[(t + 1, st)]
n = Node(f'({t + 1}:{st}:{at})', f'({t + 1}:{st}:{at})')
if n.identifier not in map(lambda x: x.identifier,
self.tree.all_nodes()):
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
add_sons(st, t + 1)
def get_move(self, board, player):
self.board = board
self.player = player # The chess color [BLACK or WHITE] represent the player
empty_set, a, b = self.board.get_board_item()
if len(a) == 0 and len(b) == 0:
return (MIDDLE, MIDDLE)
if len(empty_set) == 1:
return (empty_set[0][0], empty_set[0][1])
if len(empty_set) == 0:
print("No place to play")
return None
self.MCTS_tree = Tree()
self.HeadNode = Node('HeadNode', 0)
self.MCTS_tree.add_node(self.HeadNode)
self.plays = {}
self.wins = {}
simulations = 0
start = time.time()
while time.time() - start < (self.max_cal_time - 0.5):
board_for_MCTS = copy.deepcopy(self.board)
player_for_MCTS = self.player
self.run_simulation(board_for_MCTS, player_for_MCTS)
simulations += 1
print("total simuations = ", simulations)
move = self.select_best_move()
print("MCTS move:", move[0], move[1])
return move
def help_func_compoundStmt(grammar, tokens):
# Called only by the help_func_manager
# PLACEHOLDER RETURN STATEMENT
print("Compound:", tokens)
tree = Tree()
tree.add_node(Node(tag="Placeholder Compound"), parent=None)
return [tree, 0]
def test_depth(self):
# Try getting the level of this tree
self.assertEqual(self.tree.depth(), 2)
self.tree.create_node("Jill", "jill", parent="george")
self.assertEqual(self.tree.depth(), 3)
self.tree.create_node("Mark", "mark", parent="jill")
self.assertEqual(self.tree.depth(), 4)
# Try getting the level of the node
"""
self.tree.show()
Hárry
|___ Bill
| |___ George
| |___ Jill
| |___ Mark
|___ Jane
| |___ Diane
"""
self.assertEqual(self.tree.depth(self.tree.get_node("mark")), 4)
self.assertEqual(self.tree.depth(self.tree.get_node("jill")), 3)
self.assertEqual(self.tree.depth(self.tree.get_node("george")), 2)
self.assertEqual(self.tree.depth("jane"), 1)
self.assertEqual(self.tree.depth("bill"), 1)
self.assertEqual(self.tree.depth("hárry"), 0)
# Try getting Exception
node = Node("Test One", "identifier 1")
self.assertRaises(NodeIDAbsentError, self.tree.depth, node)
# Reset the test case
self.tree.remove_node("jill")
def _build_tree(self, scores: ndarray, bin_edges: ndarray) -> Tree:
# Build tree with specified number of children at each level
tree = Tree()
tree.add_node(Node()) # root node
nodes_prev = [tree.get_node(tree.root)]
for level in range(self.depth):
nodes_current = []
for node in nodes_prev:
children = []
for _ in range(self.n_children[level]):
child = Node()
tree.add_node(child, parent=node)
children.append(child)
nodes_current.extend(children)
nodes_prev = nodes_current
assignments = np.digitize(scores, bin_edges) - 1
# Store instance ids in leaves
leaves = tree.leaves()
for k, node in enumerate(leaves):
instance_ids = np.where(assignments == k)[0]
if instance_ids.size == 0:
tree.remove_node(node.identifier)
else:
node.data = instance_ids
# Prune empty leaves
check_for_empty_leaves = True
while check_for_empty_leaves:
check_for_empty_leaves = False
leaves = tree.leaves()
for node in leaves:
if node.data is None and len(node.successors(
tree.identifier)) == 0:
# Node is empty and has no siblings
tree.remove_node(node.identifier)
check_for_empty_leaves = True
# Simplify tree: remove nodes that only have one child
for nid in tree.expand_tree(mode=tree.WIDTH):
children = tree.children(nid)
if len(children) == 1:
tree.link_past_node(nid)
return tree
def shrink(self, node: Node):
"""
Shrink sub-tree into one node.
Args:
node (Node): List of nodes to be merged.
"""
node_name = node.identifier
parent_node = self[node.predecessor(self.tree_identifier)]
# Keep successors of parent.
brothers = deepcopy(parent_node.successors(self.tree_identifier))
child = node.successors(self.tree_identifier)[0]
self.move_node(source=child,
destination=node.predecessor(self.tree_identifier))
self.remove(node)
brothers[brothers.index(node_name)] = child
parent_node.set_successors(brothers, tree_id=self.tree_identifier)
def parseDigit():
nonlocal ast, curr_node
if match(cst_nodes[curr_cst_node].data.type_, 'T_digit'):
cst_nodes[curr_cst_node].data.type_ = 'T_k_int'
digit_node = Node(cst_nodes[curr_cst_node].tag,
data=cst_nodes[curr_cst_node].data)
nextCSTNode()
return digit_node
else:
pass
def node2Tree(self, tuple1, tuple2, tuple3):
t = Tree()
#Id of each node = freq of that node(i[1])
#Node(tag,identifier(ID)) #create_node(tag,identifier(ID),parent)
#Nodes added in decreasing order of Frequency
node1 = Node(tuple1, tuple1[0])
node2 = Node(tuple2, tuple2[0])
node3 = Node(tuple3, tuple3[0])
freq = tuple1[1] + tuple2[1] + tuple3[1]
tag = tuple1[0] + tuple2[0] + tuple3[0]
t.create_node("(" + str(tag) + ", " + str(freq) + ")", tag, None)
#Addded the nodes as left right mid according to there frequency
#so the first node has always the highest frequency
if tuple1[1] >= tuple2[1] and tuple1[1] >= tuple3[1]:
if tuple2[1] >= tuple3[1]:
t.add_node(node1, tag)
t.add_node(node2, tag)
t.add_node(node3, tag)
else:
t.add_node(node1, tag)
t.add_node(node3, tag)
t.add_node(node2, tag)
elif tuple2[1] >= tuple3[1] and tuple2[1] >= tuple1[1]:
if tuple1[1] >= tuple3[1]:
t.add_node(node2, tag)
t.add_node(node1, tag)
t.add_node(node3, tag)
else:
t.add_node(node2, tag)
t.add_node(node3, tag)
t.add_node(node1, tag)
else:
if tuple1[1] >= tuple2[1]:
t.add_node(node3, tag)
t.add_node(node1, tag)
t.add_node(node2, tag)
else:
t.add_node(node3, tag)
t.add_node(node2, tag)
t.add_node(node1, tag)
#t.show()
return t
def _walk_to_leaf_node(self, node: Node, instance):
if (node.is_leaf()):
return node.decision
if (self.attribute_types[node.attribute] == 'discrete'):
for c in self.children(node.identifier):
if (instance[node.attribute] == c.parent_attribute_value):
return self._walk_to_leaf_node(c, instance)
else:
for c in self.children(node.identifier):
if (c.division_criterion(instance[node.attribute])):
return self._walk_to_leaf_node(c, instance)
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "identifier 1")
self.assertEqual(self.node1.expanded, True)
self.assertEqual(self.node1.bpointer, None)
self.assertEqual(self.node1.fpointer, [])
def test_set_tag(self):
self.node1.tag = "Test 1"
self.assertEqual(self.node1.tag, "Test 1")
self.node1.tag = "Test One"
def test_set_identifier(self):
self.node1.identifier = "ID1"
self.assertEqual(self.node1.identifier, "ID1")
self.node1.identifier = "identifier 1"
def test_set_fpointer(self):
self.node1.update_fpointer("identifier 2")
self.assertEqual(self.node1.fpointer, ['identifier 2'])
self.node1.fpointer = []
def test_set_bpointer(self):
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node2.bpointer, 'identifier 1')
self.node2.bpointer = None
def test_set_is_leaf(self):
self.node1.update_fpointer("identifier 2")
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node1.is_leaf(), False)
self.assertEqual(self.node2.is_leaf(), True)
def tearDown(self):
pass
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "identifier 1")
self.assertEqual(self.node1.expanded, True)
self.assertEqual(self.node1.bpointer, None)
self.assertEqual(self.node1.fpointer, [])
def test_set_tag(self):
self.node1.tag = "Test 1"
self.assertEqual(self.node1.tag, "Test 1")
self.node1.tag = "Test One"
def test_set_identifier(self):
self.node1.identifier = "ID1"
self.assertEqual(self.node1.identifier, "ID1")
self.node1.identifier = "identifier 1"
def test_set_fpointer(self):
self.node1.update_fpointer("identifier 2")
self.assertEqual(self.node1.fpointer, ['identifier 2'])
self.node1.fpointer = []
def test_set_bpointer(self):
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node2.bpointer, 'identifier 1')
self.node2.bpointer = None
def test_set_is_leaf(self):
self.node1.update_fpointer("identifier 2")
self.node2.update_bpointer("identifier 1")
self.assertEqual(self.node1.is_leaf(), False)
self.assertEqual(self.node2.is_leaf(), True)
def tearDown(self):
pass
def shrink(self, node: Node):
"""
Shrink sub-tree into one node.
Use child node to replace its ancestor.
Args:
node (Node): List of nodes to be merged.
"""
node_name = node.identifier
parent_node = self[node.predecessor(self.tree_identifier)]
# Keep successors of parent.
brothers = deepcopy(parent_node.successors(self.tree_identifier))
# Because shrink occurs when node has only one child,
# so we take index-0.
child = node.successors(self.tree_identifier)[0]
self.move_node(source=child,
destination=node.predecessor(self.tree_identifier))
self.remove(node)
brothers[brothers.index(node_name)] = child
parent_node.set_successors(brothers, tree_id=self.tree_identifier)
def __init__(self, holes=0):
self.data = np.zeros((3, 3, 3, 3), dtype='int')
element = range(3)
order = direct_product(element, element, element, element)
i = 0
genTree = Tree()
root = Node(i, 'root', data=[order[0], self.data.copy()])
genTree.add_node(root)
currentNode = root
getData = lambda node: node.data[1][tuple(node.data[0])]
while i < len(order):
i += 1
a, b, c, d = order[i - 1]
numPool = pool(self.data, a, b, c, d) - set(
map(getData, genTree.children(currentNode.identifier)))
if numPool:
self.data[a, b, c, d] = np.random.choice(list(numPool))
node = Node(i, data=[order[i - 1], self.data.copy()])
genTree.add_node(node, currentNode)
currentNode = node
else:
prev = genTree.parent(currentNode.identifier)
while len(genTree.children(prev.identifier)) == len(
pool(prev.data[1], *(prev.data[0]))):
currentNode = prev
prev = genTree.parent(currentNode.identifier)
else:
currentNode = prev
self.data = currentNode.data[1].copy()
i = currentNode.tag
continue
h = np.random.choice(len(order), size=holes, replace=False)
self._answer = self.data.copy()
self.holes = np.array(order)[h]
self.data[tuple(self.holes.T.tolist())] = 0
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "ide ntifier 1 ")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "ide_ntifier_1")
self.assertEqual(self.node1.expanded, True)
def test_set_fpointer(self):
self.node1.update_fpointer(" identi fier 2")
self.assertEqual(self.node1.fpointer, ["identi_fier_2"])
def test_set_bpointer(self):
self.node1.bpointer = " identi fier 1"
self.assertEqual(self.node1.bpointer, "identi_fier__1")
def test_set_data(self):
self.node1.data = {1: "hello", "two": "world"}
self.assertEqual(self.node1.data, {1: "hello", "two": "world"})
def tearDown(self):
pass
class NodeCase(unittest.TestCase):
def setUp(self):
self.node1 = Node("Test One", "ide ntifier 1 ")
def test_initialization(self):
self.assertEqual(self.node1.tag, "Test One")
self.assertEqual(self.node1.identifier, "ide_ntifier_1")
self.assertEqual(self.node1.expanded, True)
def test_set_fpointer(self):
self.node1.update_fpointer(" identi fier 2")
self.assertEqual(self.node1.fpointer, ['identi_fier_2'])
def test_set_bpointer(self):
self.node1.bpointer = " identi fier 1"
self.assertEqual(self.node1.bpointer, 'identi_fier__1')
def test_set_data(self):
self.node1.data = {1: 'hello', "two": 'world'}
self.assertEqual(self.node1.data, {1: 'hello', "two": 'world'})
def tearDown(self):
pass
def help_func_return(grammar, tokens, function=None):
tree = Tree()
return_node = Node(tag=tokens[0][1])
tree.add_node(return_node, parent=None)
skip_tokens = 0
if (tokens[1][0] != ';'):
expr_help_out = help_func_expression(grammar,
tokens[1:],
function=function)
tree.paste(return_node.identifier, expr_help_out[0])
skip_tokens = expr_help_out[1]
return [tree, skip_tokens + 2]
def parseBoolVal():
nonlocal ast, curr_node
bool_node = None
if match(cst_nodes[curr_cst_node].data.type_, 'T_k_true') or match(
cst_nodes[curr_cst_node].data.type_, 'T_k_false'):
cst_nodes[curr_cst_node].data.type_ = 'T_k_boolean'
bool_node = Node(cst_nodes[curr_cst_node].tag,
data=cst_nodes[curr_cst_node].data)
nextCSTNode()
else:
pass
if bool_node:
return bool_node
def most_similarity_nodes(T1, T2):
node_pairs = {}
for node1 in T1.all_nodes_itr():
highest_simil = -1
similar_node = Node()
for node2 in T2.all_nodes_itr():
node_simil = node_similarity(node1, node2)
if highest_simil < node_simil:
highest_simil = node_simil
similar_node = node2
node_pairs[node1] = similar_node
return node_pairs
def generate_expression(self, length: int) -> str:
self.state = State(target_len=length,
root_node=Node(tag="root", identifier=0))
logging.debug("Starting generation...")
self.__choose_generation_type()
self.__fix_length()
logging.debug(string_serializer.debug_serialize(self.state.tree))
logging.info("Result: {}".format(
string_serializer.serialize(self.state.tree)))
return string_serializer.serialize(self.state.tree)
def create_branch(tree_structure, types):
if not (tree_structure, types):
return
previous = None
for class_type in types:
node = Node(identifier=class_type, data=[])
if previous is None:
if tree_structure.get_node(node.identifier) is None:
tree_structure.add_node(node)
else:
if tree_structure.get_node(node.identifier) is None:
tree_structure.add_node(node, previous.identifier)
previous = node
def run_parser(tokens,
grammar,
look_for_brace=False,
root_name="program",
clear_symbol_table=False):
# Create dictionary of symbol tables
global __symbol_tables
if (clear_symbol_table):
__symbol_tables = {}
# Create base abstract syntax tree
tree = Tree()
# create root node
root = Node(tag=root_name)
tree.add_node(root, parent=None)
num_tokens_to_skip = 0
list_of_tokens = []
for i in range(0, len(tokens)):
if (num_tokens_to_skip > 0):
num_tokens_to_skip -= 1
continue
if (look_for_brace and tokens[i][0] == "}"):
break
list_of_tokens.append(tokens[i]) # append token and metadata
result = check_rules("program", list_of_tokens, grammar)
if (result[0] > 1): #matches more than one possible rule
continue
elif (result[0] == 1): #matches one possible rule
help_fun_tuple = help_func_manager(
result, grammar, tokens[i - len(list_of_tokens) + 1:])
sub_tree = help_fun_tuple[0]
num_tokens_to_skip = help_fun_tuple[1] - len(list_of_tokens)
tree.paste(root.identifier, sub_tree)
#call helper function
list_of_tokens = []
elif (result[0] == 0):
#matches zero rules. parser crash
tree.show(key=lambda x: x.identifier, line_type='ascii')
print("ERRONEOUS RESULT:", result)
print("ERRONEOUS TOKEN LIST:", list_of_tokens)
raise Exception(errors.ERR_NO_RULE + " '" + tokens[i][0] +
"' on line " + str(tokens[i][2]))
return [tree, num_tokens_to_skip, __symbol_tables]
def save(self, f, nid=None, level=Tree.ROOT, idhidden=True, filter=None, cmp=None, key=None, reverse=False):
leading = ''
lasting = ''
nid = self.root if (nid is None) else Node.sanitize_id(nid)
label = ("{0}".format(self[nid].tag)) if idhidden else ("{0}[{1}]".format(self[nid].tag, self[nid].identifier))
filter = (self._real_true) if (filter is None) else filter
if level == self.ROOT:
f.write(label + '\n')
else:
leading += '\t' * level
f.write("{0}{1}{2}\n".format(leading, lasting, label))
if filter(self[nid]) and self[nid].expanded:
queue = [self[i] for i in self[nid].fpointer if filter(self[i])]
key = (lambda x: x) if (key is None) else key
queue.sort(cmp=cmp, key=key, reverse=reverse)
level += 1
for element in queue:
self.save(f, element.identifier, level, idhidden, filter, cmp, key, reverse)
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def setUp(self):
self.node1 = Node("Test One", "ide ntifier 1 ")
def test_object_as_node_tag(self):
node = Node(tag=(0, 1))
self.assertEqual(node.tag, (0, 1))
self.assertTrue(node.__repr__().startswith('Node'))
