Ejemplo n.º 1
0
 def determine_kind(self, graph : Graph, shapes, shape):
     if graph.get_node(shape.id).has_edges():
         if graph.get_node(shape.id).has_mutual_edge():
             return "mutual"
         else:
             return "one_direction"
     else:
         return "no_edges"
Ejemplo n.º 2
0
def main():
    '''
    1. We first read in the file.  The challenge said that each new line is a single Venmo payment written in JSON format
    so we import
    '''
    f = open("venmo_input/venmo-trans_short.txt")
    graph= Graph()

    # this holds a list of median degrees
    rollingMedianDegree = []
    storeFile =[]
    for line in f:
        newStr = line.strip('\n')
        storeFile.append(newStr)

    for line in storeFile:
        #find the current max time of the graph
        max = findMaxTime(graph)

        newStr = line.strip('\n')
        data = json.loads(newStr)
        if add_to_graph(data['created_time'], max):
            node = Node(data['actor'])
            neighbor = Node(data['target'])
            graph.add_node(node)
            graph.add_node(neighbor)
            graph.add_edge(node, neighbor)
            key = data['actor'] + "->" + data['target']
            metadata = data['created_time']
            graph_node = graph.get_node(node.id)
            graph_node.add_metadata(key, metadata)
        else:
            continue
        #get new max
        max = findMaxTime(graph)
        # set the weight in this case it is the number of neighbors the node has
        setWeight(graph)

        #find expired edges
        expiredNode = findExpiredNode(graph, 60, max)

        #remove those relationships
        for actor, target in expiredNode.items():
            graph.get_node(actor).remove_metadata(actor + "->" + target)
            graph.remove_edge(actor, target)

        #find the median degree
        degree = getMedianDegree(graph)

        #add to rolling median degree records.  this is what will be saved in the output.
        rollingMedianDegree.append(degree)
        

    
    print(graph)
    print(rollingMedianDegree)
Ejemplo n.º 3
0
 def test_present_in_components(self):
     f = Graph({"A", "B"})
     f.add_not_oriented_connections([["A", "B"]])
     s = Graph({"C"})
     t = Graph({"D", "E", "F"})
     t.add_not_oriented_connections([["D", "E"], ["E", "F"]])
     self.assertTrue(self.g.present_in_components(f.get_node("A"), {f, s}))
     self.assertTrue(
         self.g.present_in_components(t.get_node("F"), {f, s, t}))
     self.assertFalse(self.g.present_in_components(t.get_node("F"), {f, s}))
     self.assertFalse(self.g.present_in_components(f.get_node("B"), {s, t}))
     self.assertFalse(self.g.present_in_components(f.get_node("B"), {t}))
     self.assertTrue(f.present_in_components(f.get_node("A"), {f}))
Ejemplo n.º 4
0
 def test_get_node(self):
     try:
         graph = Graph('static_map', "/map")
         graph.nodes[10, 10].cost = 10
         pose = graph.get_pose(10, 10)
         n = graph.get_node(pose)
         self.assertEquals(n.cost, 10)
     except Exception as e:
         self.fail(UtilTests.error_str(self.test_get_node.__name__, e))
Ejemplo n.º 5
0
    destinationNodes = divided[1].split(",")
    for node in destinationNodes:
        node, value = node.split("(")
        value = value.replace(')', '')
        connections.append([sourceNode, node, value])
for conn in connections:
    if "+" in conn[0]:
        conn[0] = conn[0].replace('+', '')
        conn[2] = int(conn[2]) + int(1)
connections = [conn for conn in connections if conn[0] != conn[1]]
from src.Graph import Graph
g = Graph(
    set([row[0]
         for row in connections]).union(set([row[1] for row in connections])))
g.add_not_oriented_valued_connections(connections)
start_node = g.get_node(connections[0][0])
end_node = g.get_node(connections[-1][0])
g.invert_connection_values()

nodes_to_print = g.get_shortest_path_nodes(start_node, end_node)
distance = None
for node in nodes_to_print:
    if node == end_node:
        distance = -int(end_node.distance)

result = ""
for node in nodes_to_print:
    if result == "":
        result = result + node.name
    else:
        result = result + " -> " + node.name
Ejemplo n.º 6
0
class GraphTest(unittest.TestCase):
    def setUp(self):
        self.g = Graph(["A", "B", "C", "D", "E", "F"])

    def test_get_node(self):
        self.assertEqual(self.g.get_node("A").name, "A")
        self.assertEqual(self.g.get_node("A").name, "A")
        self.assertEqual(self.g.get_node("B").name, "B")
        self.assertIsNone(self.g.get_node("Z"))

    def test_add_node(self):
        self.assertTrue(self.g.has_node("A"))
        self.assertFalse(self.g.has_node("Z"))

    def test_has_node(self):
        self.assertTrue(self.g.has_node("A"))
        self.assertTrue(self.g.has_node(Node("A").name))

    def test_add_not_oriented_connection(self):
        self.g.add_not_oriented_connection(Node("A"), Node("B"))
        self.assertTrue(self.g.is_connection("A", "B"))
        self.assertTrue(self.g.is_connection("B", "A"))
        self.assertFalse(self.g.is_connection("A", "C"))
        with self.assertRaises(ValueError):
            self.g.add_not_oriented_connection(Node("A"), Node("Z"))

    def test_add_oriented_connection(self):
        self.assertFalse(self.g.is_connection("A", "B"))
        self.g.add_oriented_connection("A", "B")
        self.assertTrue(self.g.is_connection("A", "B"))
        self.assertFalse(self.g.is_connection("D", "E"))
        self.g.add_oriented_connection("D", "E")
        self.assertTrue(self.g.is_connection("D", "E"))

    def test_add_oriented_connections(self):
        self.g.add_oriented_connections([["A", "B"], ["C", "B"], ["F", "E"]])
        self.assertFalse(self.g.is_connection("B", "C"))
        self.assertTrue(self.g.is_connection("C", "B"))
        self.assertFalse(self.g.is_connection("C", "E"))
        self.assertTrue(self.g.is_connection("F", "E"))

    def test_add_not_oriented_connections(self):
        self.g.add_not_oriented_connections([[Node("A"), Node("B")],
                                             [Node("B"), Node("C")],
                                             [Node("D"), Node("E")]])
        self.assertTrue(self.g.is_connection("B", "C"))
        self.assertTrue(self.g.is_connection("C", "B"))
        self.assertFalse(self.g.is_connection("C", "E"))

    def test_remove_node(self):
        self.g.add_not_oriented_connections([[Node("A"), Node("B")],
                                             [Node("B"), Node("C")],
                                             [Node("D"), Node("E")]])
        self.g.remove_node(Node("B"))
        self.assertEqual(5, len(self.g.nodes))
        self.assertEqual(1, len(self.g.connections))

    def test_get_leaving_edges_size(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
        self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
        self.assertEqual(1, self.g.get_leaving_edges_size(Node("C")))
        self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
        self.g.add_oriented_connections([["C", "A"]])
        self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
        self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
        self.assertEqual(2, self.g.get_leaving_edges_size(Node("C")))
        self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))

    def test_get_degree(self):
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]])
        self.assertEqual(1, self.g.get_degree(Node("A")))
        self.assertEqual(2, self.g.get_degree(Node("B")))
        self.assertEqual(1, self.g.get_degree(Node("C")))
        self.assertEqual(1, self.g.get_degree(Node("D")))
        self.assertEqual(0, self.g.get_degree(Node("F")))

    def test_get_node_with_highest_degree(self):
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]])
        self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
        self.g.add_oriented_connections([["B", "A"], ["D", "E"]])
        self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
        self.g.add_oriented_connections([["D", "A"], ["A", "E"]])
        self.assertEqual(Node("A"), self.g.get_node_with_highest_degree())

    def test_is_oriented(self):
        self.assertFalse(self.g.is_oriented())
        self.g.add_not_oriented_connections([["D", "B"]])
        self.assertFalse(self.g.is_oriented())
        self.g.add_oriented_connections([["A", "B"]])
        self.assertTrue(self.g.is_oriented())
        self.g.add_oriented_connections([["D", "A"], ["A", "E"]])
        self.assertTrue(self.g.is_oriented())

    def test_is_multigraph(self):
        self.assertFalse(self.g.is_multigraph())
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]])
        self.assertFalse(self.g.is_multigraph())
        self.g.add_oriented_connections([["A", "B"]])
        self.assertTrue(self.g.is_multigraph())

    def test_is_tree(self):
        self.assertFalse(self.g.is_tree())
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["B", "D"]])
        self.assertFalse(self.g.is_tree())
        self.g.add_not_oriented_connections([["D", "E"], ["E", "F"]])
        self.assertTrue(self.g.is_tree())
        self.g.add_not_oriented_connections([["A", "F"]])
        self.assertFalse(self.g.is_tree())

    def test_is_connected(self):
        self.assertFalse(self.g.is_connected())
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["B", "D"]])
        self.assertFalse(self.g.is_connected())
        self.g.add_not_oriented_connections([["D", "E"], ["E", "F"]])
        self.assertTrue(self.g.is_connected())
        self.g.add_not_oriented_connections([["A", "F"]])
        self.assertTrue(self.g.is_connected())

    def test_has_loop(self):
        self.assertFalse(self.g.has_loop())
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]])
        self.assertFalse(self.g.has_loop())
        self.g.add_oriented_connections([["A", "A"]])
        self.assertTrue(self.g.has_loop())

    def test_has_connectivity(self):
        self.assertFalse(self.g.has_connectivity())
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["F", "E"]])
        self.assertFalse(self.g.has_connectivity())
        self.g.add_not_oriented_connections([["A", "D"], ["C", "E"]])
        self.assertTrue(self.g.has_connectivity())

    def test_reachable_nodes(self):
        self.assertEqual(1, len(self.g.reachable_nodes(Node("A"))))
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertEqual(3, len(self.g.reachable_nodes(Node("A"))))
        self.assertEqual(2, len(self.g.reachable_nodes(Node("D"))))
        self.assertEqual(1, len(self.g.reachable_nodes(Node("F"))))

    def test_get_neighbors(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertEqual({Node("B")}, self.g.get_neighbors(Node("A")))
        self.assertEqual({Node("A"), Node("C")},
                         self.g.get_neighbors(Node("B")))
        self.assertEqual({Node("D")}, self.g.get_neighbors(Node("E")))

    def test_is_complete(self):
        self.assertFalse(self.g.is_complete())
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertFalse(self.g.is_complete())
        import itertools
        for conn in itertools.product(["A", "B", "C", "D", "E", "F"],
                                      repeat=2):
            self.g.add_not_oriented_connection(conn[0], conn[1])
        self.assertTrue(self.g.is_complete())

    def test_has_bidirectional_edge(self):
        self.assertFalse(self.g.has_bidirectional_edge())
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]])
        self.assertFalse(self.g.has_bidirectional_edge())
        self.g.add_oriented_connections([["B", "A"]])
        self.assertTrue(self.g.has_bidirectional_edge())

    def test_is_bidirectional(self):
        self.g.add_oriented_connections([["A", "B"], ["B", "A"], ["B", "C"],
                                         ["D", "E"]])
        self.assertFalse(self.g.is_bidirectional())
        self.g.add_oriented_connections([["C", "B"], ["E", "D"]])
        self.assertTrue(self.g.is_bidirectional())

    def test_total_cost(self):
        self.assertEqual(0, self.g.total_cost())
        self.g.add_not_oriented_valued_connections([["A", "B",
                                                     1], ["B", "C", 5],
                                                    ["B", "D", 4]])
        self.assertEqual(10, self.g.total_cost())
        self.g.add_not_oriented_valued_connections([["D", "E", 3],
                                                    ["E", "F", 2]])
        self.assertEqual(15, self.g.total_cost())

    def test_get_minimal_spanning_tree(self):
        self.g.add_not_oriented_valued_connections([["A", "B",
                                                     1], ["B", "C", 2],
                                                    ["B", "D",
                                                     1], ["D", "E", 4],
                                                    ["E", "F", 2],
                                                    ["A", "F", 10],
                                                    ["A", "C", 7]])
        h = self.g.get_minimal_spanning_tree(printing=False)
        self.assertEqual(5, len(h.connections))
        self.assertEqual(10, h.total_cost())

    def test_present_in_components(self):
        f = Graph({"A", "B"})
        f.add_not_oriented_connections([["A", "B"]])
        s = Graph({"C"})
        t = Graph({"D", "E", "F"})
        t.add_not_oriented_connections([["D", "E"], ["E", "F"]])
        self.assertTrue(self.g.present_in_components(f.get_node("A"), {f, s}))
        self.assertTrue(
            self.g.present_in_components(t.get_node("F"), {f, s, t}))
        self.assertFalse(self.g.present_in_components(t.get_node("F"), {f, s}))
        self.assertFalse(self.g.present_in_components(f.get_node("B"), {s, t}))
        self.assertFalse(self.g.present_in_components(f.get_node("B"), {t}))
        self.assertTrue(f.present_in_components(f.get_node("A"), {f}))

    def test_components(self):
        self.assertEqual(len(self.g.nodes), len(self.g.components()))
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"]])
        self.assertEqual(len(self.g.nodes) - 2, len(self.g.components()))

    def test_is_bridge(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["C", "D"], ["A", "C"]])
        self.assertFalse(self.g.is_bridge(Connection("A", "B", False)))
        self.assertTrue(self.g.is_bridge(Connection("C", "D", False)))

    def test_bridges(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["C", "D"], ["A", "C"]])
        self.assertEqual([Connection("C", "D", False)], self.g.bridges())

    def test_separating_set(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B",
                                                          "C"], ["C", "D"],
                                             ["A", "C"], ["C", "E"]])
        self.assertEqual({Node("C"), Node("F")}, self.g.separating_set())

    def test_build_avl_tree(self):
        self.g = Graph(set())
        # self.g.build_avl_tree([5,15,10])
        # self.assertEqual(2,len(self.g.connections))
        # self.assertTrue(self.g.is_connection(5,10))
        # self.assertTrue(self.g.is_connection(10,15))

    def test_get_incoming_degree(self):
        self.assertEqual(self.g.get_incoming_degree("A"), 0)
        self.g.add_oriented_connections([["A", "B"]])
        self.assertEqual(self.g.get_incoming_degree("A"), 0)
        self.assertEqual(self.g.get_incoming_degree("B"), 1)
        self.g.add_not_oriented_connections([["B", "C"]])
        self.assertEqual(self.g.get_incoming_degree("B"), 2)
        self.assertEqual(self.g.get_incoming_degree("C"), 1)

    def test_all_nodes_have_equal_in_out_degree(self):
        self.assertTrue(self.g.all_nodes_have_equal_in_out_degree())
        self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["C", "D"]])
        self.assertFalse(self.g.all_nodes_have_equal_in_out_degree())
        self.g.add_oriented_connections([["D", "A"]])
        self.assertTrue(self.g.all_nodes_have_equal_in_out_degree())

    def test_get_num_of_unique_neigbors(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertEqual(1, self.g.get_num_of_unique_neigbors({Node("A")}))
        self.assertEqual(0, self.g.get_num_of_unique_neigbors({Node("F")}))
        self.assertEqual(2, self.g.get_num_of_unique_neigbors({Node("B")}))
        self.assertEqual(
            2, self.g.get_num_of_unique_neigbors({Node("A"),
                                                  Node("D")}))
        self.assertEqual(
            2,
            self.g.get_num_of_unique_neigbors(
                {Node("A"), Node("B"), Node("D")}))

    def test_get_node_with_lowest_value(self):
        a = Node("A", "B", 3)
        nodes = {a}
        self.assertEqual(a, self.g.get_node_with_lowest_value(nodes))
        b = Node("B", "C", 2)
        nodes.add(b)
        self.assertEqual(b, self.g.get_node_with_lowest_value(nodes))
        c = Node("C", None, 0)
        d = Node("D", None, None)
        nodes.add(c)
        nodes.add(d)
        self.assertEqual(c, self.g.get_node_with_lowest_value(nodes))

    def test_get_path_from(self):
        self.g = Graph(["A", "B", "C", "D"])
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "C"]])
        self.assertEqual(7, len(self.g.get_path_from(Node("A"))))

    def test_add_connection_to_every_node(self):
        self.g.add_connection_to_every_node(self.g.nodes[0], 0, False)
        self.assertEqual(len(self.g.nodes) - 1, len(self.g.connections))

    def test_invert_connection_values(self):
        self.g.add_not_oriented_valued_connections([["A", "B", 2],
                                                    ["B", "C", -2],
                                                    ["C", "D", 0]])
        self.g.invert_connection_values()
        self.assertEqual(-2, self.g.connections[0].value)
        self.assertEqual(2, self.g.connections[1].value)
        self.assertEqual(0, self.g.connections[2].value)

    def test_get_shortest_path_nodes(self):
        self.g.add_not_oriented_valued_connections([["A", "B",
                                                     1], ["B", "C", 3],
                                                    ["C", "D", -2],
                                                    ["D", "E", 1],
                                                    ["E", "F", 1],
                                                    ["A", "F", 10],
                                                    ["D", "B", -2],
                                                    ["B", "E", 4]])
        nodes = self.g.get_shortest_path_nodes(Node("A"), Node("F"))
        self.assertEqual(
            [Node("A"), Node("B"),
             Node("D"), Node("E"),
             Node("F")], nodes)

    def test_get_hamilton_path(self):
        self.g = Graph(["A", "B", "C", "D"])
        connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2],
                       ["B", "C", 1], ["B", "D", 5], ["C", "D", 7]]
        self.g.add_not_oriented_valued_connections(connections)
        self.assertEqual(7, len(self.g.get_hamilton_path()))

    def test_get_hamilton_path_nodes(self):
        self.g = Graph(["A", "B", "C", "D"])
        connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2],
                       ["B", "C", 1], ["B", "D", 5], ["C", "D", 7]]
        self.g.add_not_oriented_valued_connections(connections)
        self.assertEqual(4, len(self.g.get_hamilton_path_nodes()))
        self.assertIn(self.g.get_hamilton_path_nodes(),
                      [[Node("B"), Node("C"),
                        Node("A"), Node("D")],
                       [Node("A"), Node("D"),
                        Node("C"), Node("B")]])

    def test_get_hamilton_path_nodes2(self):
        self.g = Graph(["A", "B", "C", "D"])
        connections = [["A", "B", 1], ["B", "C", 2], ["C", "D", 1],
                       ["D", "A", 3], ["A", "C", 3], ["B", "D", 2]]
        self.g.add_not_oriented_valued_connections(connections)
        self.assertEqual(4, len(self.g.get_hamilton_path_nodes()))
        self.assertIn(self.g.get_hamilton_path_nodes(),
                      [[Node("A"), Node("B"),
                        Node("C"), Node("D")],
                       [Node("A"), Node("B"),
                        Node("D"), Node("C")],
                       [Node("C"), Node("D"),
                        Node("B"), Node("A")],
                       [Node("D"), Node("C"),
                        Node("B"), Node("A")],
                       [Node("A"), Node("D"),
                        Node("C"), Node("B")],
                       [Node("B"), Node("C"),
                        Node("D"), Node("A")]])

    def test_get_hamilton_path_distance(self):
        self.g = Graph(["A", "B", "C", "D"])
        connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2],
                       ["B", "C", 1], ["B", "D", 5], ["C", "D", 7]]
        self.g.add_not_oriented_valued_connections(connections)
        self.assertTrue(14 > self.g.get_hamilton_path_distance())

    def test_get_three_node_combinations_without_repetition(self):
        self.assertEqual(
            20, len(self.g.get_three_node_combinations_without_repetition()))

    def test_get_three_nodes_with_most_unique_neigbors(self):
        self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
                                             ["D", "E"]])
        self.assertTrue(
            {Node("B"), Node("D"), Node("F")
             } == self.g.get_three_nodes_with_most_unique_neigbors()
            or {Node("B"), Node("E"), Node("F")
                } == self.g.get_three_nodes_with_most_unique_neigbors())

    def test_nodes_as_str(self):
        self.assertEqual("A, B, C", self.g.nodes_as_str(['A', "B", "C"]))