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