def insert_after(self, current_node_item, new_node_item):
     tmp = self._first
     while tmp:
         if tmp.val == current_node_item:
             old_next_node = tmp.next_node
             new_node = Node(new_node_item)
             tmp.next_node = new_node
             new_node.next_node = old_next_node
             self._size += 1
             break
         tmp = tmp.next_node
예제 #2
0
파일: corpus.py 프로젝트: hsensoy/uparse
def idg(filename):
    dg = DependencyGraph()
    with open(filename) as fp:
        for line in fp:
            trimmed = line.strip()

            if len(trimmed) == 0:
                yield dg
                dg = DependencyGraph()
            else:
                dg.addNode(Node.byline(trimmed))

    if dg.length() > 0:
        yield dg
예제 #3
0
    def test_no_distance(self):
        n = Node("test")

        self.assertEqual(n.distance(), 0)
        secondnode.next=firstnode
        firstnode.next=nextsecondnode



    else:
       previousfirstnode.next=secondnode
       nextsecondnode=secondnode.next
       secondnode.next=firstnode.next
       previoussecondnode.next=firstnode
       firstnode.next=nextsecondnode




firstnode=Node(4)
secondnode=Node(2)
thirdnode=Node(6)
fourthnode=Node(5)
fifthnode=Node(9)
sixthnode=Node(3)

link=Linklist()
link.insert(firstnode)
link.insert(secondnode)
link.insert(thirdnode)
link.insert(fourthnode)
link.insert(fifthnode)
link.insert(sixthnode)

swapnode(link,6,3)
예제 #5
0
 def __init__(self, title, parent, token):
     Node.__init__(self, title, parent)
     self.token = token
     self.series_nodes = {}
예제 #6
0
    def parse_graph(self, file_path, model_name, category, sub_category):
        """Method to parse file and Create a corresponding Graph object.

        Reads a tflite file into a tflite/Model Object and then extracts 
        operators, tensors, graph structure and metadata and stores it 
        into a Graph, Node and Edge objects. Nodes are operations and 
        edges are tensors.

        Args:
            file_path (str): Path of the file to parse
            model_name (str): Unique model name of the model being parsed.
            category (str): Problem category of the model.
            sub_category (str) : Problem sub category of the model.

        Returns:
            The Graph object created for the file.
        """

        model = self.parse(file_path)

        nodes = list()
        edges = list()
        adj_list = dict()
        start_node_indices = list()

        # Global list of opcodes in the model, referenced by Operators
        opcodes = list()
        for opcode_index in range(model.OperatorCodesLength()):
            opcodes.append(model.OperatorCodes(opcode_index))

        # Only considering the main model
        subgraph = model.Subgraphs(0)

        # Dictionary to store origin and destination nodes for each edge
        to_nodes = dict()
        from_nodes = dict()

        for tensor_index in range(subgraph.TensorsLength()):
            tensor = subgraph.Tensors(tensor_index)
            # Converting tensor to an Edge object
            new_edge = self._TENSOR_TO_EDGE.convert(tensor)
            edges.append(new_edge)

        # Populating to_nodes, from_nodes
        # Add proxy nodes for Input and Output of the model
        for input_index in range(subgraph.InputsLength()):
            new_node = Node.Node(label="Input_Placeholder",
                                 operator_type="Input_Placeholder")
            nodes.append(new_node)

            node_index = len(nodes) - 1
            start_node_indices.append(node_index)
            edge_index = subgraph.Inputs(input_index)

            if edge_index not in from_nodes:
                from_nodes.update({edge_index: []})
            from_nodes[edge_index].append(node_index)

        for operator_index in range(subgraph.OperatorsLength()):
            operator = subgraph.Operators(operator_index)
            builtin_opcode = opcodes[operator.OpcodeIndex()].BuiltinCode()
            opname = self._builtin_optype[builtin_opcode]

            new_node = self._OP_TO_NODE.convert(operator, opname)

            # Condition to extract Conv 2D filter sizes and
            # input and output channels as it is contained in tensors
            # and not in operators
            if new_node.label == "CONV_2D":
                weight_tensor = subgraph.Tensors(operator.Inputs(1))
                new_node.filter_height = weight_tensor.Shape(1)
                new_node.filter_width = weight_tensor.Shape(2)

            nodes.append(new_node)
            node_index = len(nodes) - 1

            for input_index in range(operator.InputsLength()):
                edge_index = operator.Inputs(input_index)
                if edge_index not in to_nodes:
                    to_nodes.update({edge_index: list()})

                to_nodes[edge_index].append(node_index)

            for output_index in range(operator.OutputsLength()):
                edge_index = operator.Outputs(output_index)
                if edge_index not in from_nodes:
                    from_nodes.update({edge_index: list()})

                from_nodes[edge_index].append(node_index)

        for output_index in range(subgraph.OutputsLength()):
            new_node = Node.Node(label="Output_Placeholder",
                                 operator_type="Output_Placeholder")
            nodes.append(new_node)

            node_index = len(nodes) - 1
            edge_index = subgraph.Outputs(output_index)

            if edge_index not in to_nodes:
                to_nodes.update({edge_index: []})
            to_nodes[edge_index].append(node_index)

        # Constructing adjacency List from to_nodes, from_nodes
        for edge_index in range(len(edges)):

            if edge_index not in from_nodes or edge_index not in to_nodes:
                continue

            for node1_index in from_nodes[edge_index]:
                for node2_index in to_nodes[edge_index]:
                    if node1_index not in adj_list:
                        adj_list.update({node1_index: list()})

                    adj_list[node1_index].append([edge_index, node2_index])

        graph = Graph.Graph(nodes, start_node_indices, edges, adj_list,
                            model_name, category, sub_category)

        # Removing nodes which are not reachable from input
        graph.process_nodes()
        graph.source = "TFLite"

        return graph
예제 #7
0
from common import Node, parse, run

cups = [Node(i) for i in parse()]
starting = cups[0]

for i, cup in enumerate(cups):
    cup.next = cups[i + 1] if i != len(cups) - 1 else cups[0]

cups = sorted(cups, key=lambda cup: cup.value)

run(cups, starting, 100)

current = cups[0].next
order = []
while current.value != 1:
    order.append(current.value)
    current = current.next
print(''.join(str(i) for i in order))
예제 #8
0
 def __init__(self, parent):
     Node.__init__(self, "SBS", parent)
예제 #9
0
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.url = url
     self.series_map = {}
예제 #10
0
 def insert(self, value):
     if (self.root == None):
         self.root = Node(value)
         self.cts[self.root] = 1
     else:
         self.__findleaf__(value, self.root)
예제 #11
0
파일: sbs.py 프로젝트: ryanf86/AusTV-WebDL
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.video_id = url.split("/")[-1]
     self.can_download = True
예제 #12
0
 def __init__(self, parent):
     Node.__init__(self, "Yahoo Plus7 (broken!)", parent)
예제 #13
0
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.url = url
     self.can_download = True
            size = len(q)
            prev = None
            for _ in range(size):
                tmp = q.pop(0)
                if prev is not None:
                    prev.next = tmp
                if tmp.left:
                    q.append(tmp.left)
                if tmp.right:
                    q.append(tmp.right)
                prev = tmp
        return root


if __name__ == "__main__":
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)
    res = Solution().connect(root)

    while res:
        curr = res
        while curr:
            print(curr.val)
            curr = curr.next
        res = res.left
예제 #15
0
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.url = url
     self.unique_series = set()
예제 #16
0
    def parse_models(self, parse_stateful = False):
        """Method to query and read data from database.

        Method to query database and read models into Graph objects.

        Args:
            parse_stateful (bool) : Boolean to indicate whether graphs with 
                stateful partitioned call should be parsed, these graphs do not
                contain a graph structure or tensors. Defaults to False.

        Returns:
            List of Graph objects corresponding to the graph objects the models
            in the spanner database have been parsed into.
        """

        model_graphs = list()
        
        # Query to get all models from Models table
        with self.database.snapshot() as snapshot:
            qresult_models = snapshot.execute_sql(
                "SELECT model_name, category, sub_category, source, num_inputs"
                " FROM Models"
                )

        for row in qresult_models:

            # Checking num_inputs for presence of graph structure
            if row[4] == 0 and not parse_stateful:
                continue

            # Extracting model attributes
            model_name = row[0]
            category = row[1]
            sub_category = row[2]
            source = row[3]

            nodes = list()
            edges = list()
            start_node_indices = list()

            adj_list = dict()

            # Querying Operators of model_name
            with self.database.snapshot() as snapshot:
                qresult_operators = snapshot.execute_sql(
                    "SELECT * from Models JOIN Operators"
                    " ON Models.model_name = Operators.model_name"
                    " WHERE Models.model_name = '" + model_name + "'"
                    " ORDER BY operator_id"
                )
            
            # Dictionary to hold which field is in which index of query results
            field_to_index = dict()

            # Boolean to check if field_to_dict needs to be populated
            populate_dicts = True

            # Extracting Node attributes
            for row in qresult_operators:
                if populate_dicts:
                    for index in range(len(qresult_operators.metadata.row_type.fields)):
                        field_name = qresult_operators.metadata.row_type.fields[index].name
                        field_to_index[field_name] = index
                    
                    populate_dicts = False

                new_node = Node.Node(None, None)

                for attr in vars(new_node).keys():
                    if attr in field_to_index:
                        setattr(new_node, attr, row[field_to_index[attr]])

                nodes.append(new_node)

                # populating start_node_indices using is_input field
                if row[field_to_index['is_input']]:
                    start_node_indices.append(len(nodes) - 1)
            
            # Querying Tensors of model_name
            with self.database.snapshot() as snapshot:
                qresult_tensors = snapshot.execute_sql(
                    "SELECT * from Models JOIN Tensors"
                    " ON Models.model_name = Tensors.model_name"
                    " WHERE Models.model_name = '" + model_name + "'"
                    " ORDER BY tensor_id"
                )

            # Dictionary to hold which field is in which index of query results
            field_to_index.clear()

            # Boolean to check if field_to_dict needs to be populated
            populate_dicts = True

            # Extracting Edge attributes
            for row in qresult_tensors:
                if populate_dicts:
                    for index in range(len(qresult_tensors.metadata.row_type.fields)):
                        field_name = qresult_tensors.metadata.row_type.fields[index].name
                        field_to_index[field_name] = index
                    
                    populate_dicts = False

                new_edge = Edge.Edge(None, None)

                for attr in vars(new_edge).keys():
                    if attr in field_to_index:
                        setattr(new_edge, attr, row[field_to_index[attr]])

                edges.append(new_edge)

                to_operator_ids = row[field_to_index['to_operator_ids']]
                from_operator_ids = row[field_to_index['from_operator_ids']]

                edge_index = len(edges) - 1

                for src_node_index in from_operator_ids:
                    src_node_index -= 1
                    for dest_node_index in to_operator_ids:
                        dest_node_index -= 1

                        if src_node_index not in adj_list:
                            adj_list.update({src_node_index : []})
                        
                        adj_list[src_node_index].append([edge_index, 
                                                            dest_node_index])

            new_graph = Graph.Graph(nodes, start_node_indices, edges, adj_list, 
                                    model_name, category, sub_category)
            new_graph.source = source

            model_graphs.append(new_graph)

        return model_graphs
예제 #17
0
	def __init__(self, title, parent, url):
		Node.__init__(self, title, parent)
		self.url = url
		self.can_download = True
예제 #18
0
파일: sbs.py 프로젝트: ryanf86/AusTV-WebDL
 def __init__(self, parent):
     Node.__init__(self, "SBS", parent)
예제 #19
0
    def test_simple_distance(self):
        com = Node("COM")
        b = Node("B", com)
        c = Node("C", b)

        self.assertEqual(c.distance(), 2)
예제 #20
0
 def __init__(self, title, parent, token, video_id):
     Node.__init__(self, title, parent)
     self.can_download = True
     self.token = token
     self.video_id = video_id
예제 #21
0
 def __init__(self, title, parent, video_key):
     Node.__init__(self, title, parent)
     self.video_key = video_key
     self.filename = title + ".ts"
     self.can_download = True
예제 #22
0
 def __init__(self, title, parent, token):
     Node.__init__(self, title, parent)
     self.token = token
     self.series_nodes = {}
예제 #23
0
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.url = url
예제 #24
0
from common import Node

class Solution(object):
    def levelOrder(self, root):
        if not root:
            return []
        nodes = [root]
        traversal = []
        while nodes:
            level = [node.val for node in nodes]
            traversal.append(level)
            new = []
            for node in nodes:
                new.extend(node.children)
            nodes = new
        return traversal

children = [Node(1, []), Node(2, []), Node(3, [])]
root = Node(0, children)
sol = Solution()
print(sol.levelOrder(root))
예제 #25
0
class LinkedList(object):
    """
    链表
    """

    head = None
    tail = None
    size = 0
    cursor = Node()

    def __init__(self):
        pass

    def __str__(self):
        return f"<LinkedList-{id(self)}: element size={self.size}, head={self.head}, tail={self.tail}>"

    def data_init(self, element_list: List[object]):
        """
        链表元素初始化
        :param element_list:
        :return:
        """
        raise NotImplementedError("需要实现链表的元素初始化")

    def data_iter(self):
        """
        链表元素迭代
        :return:
        """
        pass

    def add_element(self, element, index=-1):
        """
        链表元素新增
        :param element: 新增元素
        :param index: 元素添加的位置,默认=-1: 表示在链表尾部添加元素
        :return:
        """
        raise NotImplementedError("需要实现链表的元素添加逻辑")

    def remove_element(self, element):
        """
        链表元素删除
        :param element: 删除元素
        :return:
        """
        raise NotImplementedError("需要实现链表的元素删除逻辑")

    def get_element(self, element):
        """
        链表元素查询
        :param element: 查询元素
        :return:
        """
        raise NotImplementedError("需要实现链表的元素查询逻辑")

    def has_loop(self):
        """
        判断链表是否有环
        :return:
        """
        pass

    def is_empty(self):
        """
        判断链表是否为空
        :return:
        """
        pass

    pass
예제 #26
0
 def push(self, val):
     node = Node(val)
     old = self._first
     self._first = node
     self._first.next_node = old
     self._size += 1
예제 #27
0
from common import Node, parse, run

cups = [Node(i) for i in parse()]
starting = cups[0]
rest = [Node(i) for i in range(10, 1000000 + 1)]

for i, cup in enumerate(cups):
    cup.next = cups[i + 1] if i != len(cups) - 1 else rest[0]

for i, cup in enumerate(rest):
    cup.next = rest[i + 1] if i != len(rest) - 1 else cups[0]

cups = sorted(cups, key=lambda cup: cup.value) + rest

run(cups, starting, 10000000)

print(cups[0].next.value * cups[0].next.next.value)
예제 #28
0
 def attr_level_score(self) -> Node:  # {{{1
     ret = Node("attribute", dict(
                     NAME="markdown-level",
                     VALUE=Text(self.n_level),
                ))
     return ret
예제 #29
0
 def __init__(self, title, parent, token, video_id):
     Node.__init__(self, title, parent)
     self.can_download = True
     self.token = token
     self.video_id = video_id
예제 #30
0
	def __init__(self, title, parent, url):
		Node.__init__(self, title, parent)
		self.url = url
예제 #31
0
 def indexed_child_nodes():
     for entry in node.metadata_entries:
         if (entry == 0 or entry - 1 >= len(node.child_nodes)):
             yield Node.empty()
         else:
             yield node.child_nodes[entry - 1]
예제 #32
0
    def test_distance_distance(self):
        com = Node("COM")
        b = Node("B", com)

        c = Node("C", b)
        d = Node("D", c)
        e = Node("E", d)
        f = Node("F", e)

        g = Node("G", b)
        h = Node("H", g)

        i = Node("I", d)
        san = Node("SAN", i)

        j = Node("J", e)
        k = Node("K", j)
        l = Node("L", k)
        you = Node("YOU", k)

        self.assertEqual(you.distance_with(san), 4)
    while execution != 0:
        currentnode = link.head
        previousnode = None
        iteration = execution
        while iteration != 0:
            if currentnode.data > currentnode.next.data:
                swap_nodes(link, previousnode, currentnode, currentnode.next)
                break
            else:
                previousnode = currentnode
                currentnode = currentnode.next
                iteration -= 1
        execution -= 1


firstnode = Node(4)
secondnode = Node(2)
thirdnode = Node(6)
fourthnode = Node(5)
# fifthnode=Node(9)
# sixthnode=Node(3)

link = Linklist()
link.insert(firstnode)
link.insert(secondnode)
link.insert(thirdnode)
link.insert(fourthnode)
# link.insert(fifthnode)
# link.insert(sixthnode)

sort_linklist(link)
예제 #34
0
 def __init__(self, title, parent, query, expected_tv_show):
     Node.__init__(self, title, parent)
     self.title = title
     self.query = query
     self.expected_tv_show = expected_tv_show
     self.video_ids = set()
예제 #35
0
	def __init__(self, parent):
		Node.__init__(self, "Yahoo Plus7 (broken!)", parent)
예제 #36
0
 def __init__(self, title, parent, video_url):
     Node.__init__(self, title, parent)
     self.can_download = True
     self.video_url = video_url
예제 #37
0
 def __init__(self, title, parent, url):
     Node.__init__(self, title, parent)
     self.video_id = url.split("/")[-1]
     self.can_download = True
예제 #38
0
 def append_script(nod: Nod1) -> None:
     if self.f_disable_script:
         return
     cmds = cmn.compose_script(mode.t())
     nod.attr_replace("script1", cmds)