def test_find_sub_dag(self): with DAG(dag_id='d1', default_args=DEFAULT_DAG_ARGS) as dag: def fn0(): print("hi") def fn1(): math.pow(1, 2) def fn2(): math.factorial(1) op1 = DummyOperator(task_id='op1') op2 = DummyOperator(task_id='op2') op3 = PythonOperator(task_id='op3', python_callable=fn0) op4 = DummyOperator(task_id='op4') op1 >> [op2, op3] >> op4 op5 = PythonOperator(task_id='op5', python_callable=fn1) op6 = PythonOperator(task_id='op6', python_callable=fn0) op7 = DummyOperator(task_id='op7') op8 = PythonOperator(task_id='op8', python_callable=fn2) op2 >> op5 >> [op6, op7] >> op8 op1_matcher = ClassTaskMatcher(DummyOperator) op2_matcher = ClassTaskMatcher(DummyOperator) op3_matcher = PythonCallTaskMatcher(print) op4_matcher = ClassTaskMatcher(DummyOperator) op1_matcher >> [op2_matcher, op3_matcher] >> op4_matcher op5_matcher = PythonCallTaskMatcher(math.pow) op6_matcher = ClassTaskMatcher(PythonOperator) op7_matcher = ClassTaskMatcher(DummyOperator) op8_matcher = PythonCallTaskMatcher(math.factorial) op5_matcher >> [op6_matcher, op7_matcher] >> op8_matcher expected_sub_dag = nx.DiGraph([(op5, op6), (op5, op7), (op6, op8), (op7, op8)]) dag_dg, found_sub_dags = TransformerUtils.find_sub_dag( dag, [op5_matcher]) self.assertEqual(len(found_sub_dags), 1) diff_dg: nx.DiGraph = nx.symmetric_difference(expected_sub_dag, found_sub_dags[0]) self.assertEqual(len(diff_dg.edges), 0) expected_sub_dag = nx.DiGraph([(op1, op2), (op1, op3), (op2, op4), (op3, op4)]) dag_dg, found_sub_dags = TransformerUtils.find_sub_dag( dag, [op1_matcher]) self.assertEqual(len(found_sub_dags), 1) diff_dg: nx.DiGraph = nx.symmetric_difference(expected_sub_dag, found_sub_dags[0]) self.assertEqual(len(diff_dg.edges), 0)
def test_consistent_generation(self): uni1 = Universe('config/Universe_config.json') uni2 = Universe('config/Universe_config.json') g1 = uni1.generate_networkx(uni1.systems) g2 = uni2.generate_networkx(uni2.systems) d1 = nx.symmetric_difference(g1, g2) d2 = nx.symmetric_difference(g2, g1) # d1 and d2 contain only the edges which are different, # 0 edges in the d# graph means they are the same self.assertEqual(d1.number_of_edges(),0) self.assertEqual(d2.number_of_edges(),0)
def test_consistent_generation(self): uni1 = Universe("config/Universe_config.json") uni2 = Universe("config/Universe_config.json") g1 = uni1.generate_networkx(uni1.systems) g2 = uni2.generate_networkx(uni2.systems) d1 = nx.symmetric_difference(g1, g2) d2 = nx.symmetric_difference(g2, g1) # d1 and d2 contain only the edges which are different, # 0 edges in the d# graph means they are the same self.assertEqual(d1.number_of_edges(),0) self.assertEqual(d2.number_of_edges(),0)
def _addChild(self, child, value=None): if isinstance(child, GraphPuzzle): if self.graph != child.graph: if child.name == self.name: raise ValueError("Cannot have move to self") intersection = set(child.graph) & set(self.graph) for node in intersection: if child.graph.nodes[node] != self.graph.nodes[node]: raise ValueError( "Contradictory values on node {}".format(node)) if nx.symmetric_difference(child.graph.subgraph(intersection), self.graph.subgraph(intersection)): raise ValueError( "Intersection between graphs contain contradictory edges" ) self.graph.update(child.graph) self.solutions.update(child.solutions) for node in self.graph: if 'obj' in self.graph.nodes[node]: puzzle = self.graph.nodes[node]['obj'] puzzle.graph = self.graph puzzle.solutions = self.solutions value = child.value child = child.name self.graph.nodes[child]['value'] = value return child
def symmetric_difference(self, other_kg): """ Returns the symmetric difference of the knowledge graph and other_kg :param other_kg: The other knowledge graph :type other_kg: :class:`.KnowledgeGraph` """ # Returns a KnowledgeGraph containing edges that exist in self or other_kg but not both return KnowledgeGraph(nx.symmetric_difference(self.net, other_kg.net))
def test_symmetric_defference(testgraph): """ Test the Symmetric Difference of the two graphs are same """ a = nx.symmetric_difference(testgraph[0], testgraph[1]) b = sg.digraph_operations.symmetric_difference(testgraph[2], testgraph[3]) digraph_equals(a, b)
def test_symmetric_defference(testgraph): """ Test the Symmetric Difference of the two graphs are same """ a = nx.symmetric_difference(testgraph[0], testgraph[1]) b = sg.graph_operations.symmetric_difference(testgraph[2], testgraph[3]) graph_equals(a, b)
def test_symmetric_difference_multigraph(): g = nx.MultiGraph() g.add_edge(0, 1, key=0) g.add_edge(0, 1, key=1) g.add_edge(0, 1, key=2) h = nx.MultiGraph() h.add_edge(0, 1, key=0) h.add_edge(0, 1, key=3) gh = nx.symmetric_difference(g, h) assert_equal(set(gh.nodes()), set(g.nodes())) assert_equal(set(gh.nodes()), set(h.nodes())) assert_equal(sorted(gh.edges()), 3 * [(0, 1)]) assert_equal(sorted(sorted(e) for e in gh.edges(keys=True)), [[0, 1, 1], [0, 1, 2], [0, 1, 3]])
def test_adapted_type(c=adapted.Connectivity()): dj.errors._switch_adapted_types(True) graphs = [ nx.lollipop_graph(4, 2), nx.star_graph(5), nx.barbell_graph(3, 1), nx.cycle_graph(5), ] c.insert((i, g) for i, g in enumerate(graphs)) returned_graphs = c.fetch("conn_graph", order_by="connid") for g1, g2 in zip(graphs, returned_graphs): assert_true(isinstance(g2, nx.Graph)) assert_equal(len(g1.edges), len(g2.edges)) assert_true(0 == len(nx.symmetric_difference(g1, g2).edges)) c.delete() dj.errors._switch_adapted_types(False)
def test_difference(): G=nx.Graph() H=nx.Graph() G.add_nodes_from([1,2,3,4]) G.add_edge(1,2) G.add_edge(2,3) H.add_nodes_from([1,2,3,4]) H.add_edge(2,3) H.add_edge(3,4) D=nx.difference(G,H) assert_equal( set(D.nodes()) , set([1,2,3,4]) ) assert_equal( sorted(D.edges()) , [(1,2)] ) D=nx.difference(H,G) assert_equal( set(D.nodes()) , set([1,2,3,4]) ) assert_equal( sorted(D.edges()) , [(3,4)] ) D=nx.symmetric_difference(G,H) assert_equal( set(D.nodes()) , set([1,2,3,4]) ) assert_equal( sorted(D.edges()) , [(1,2),(3,4)] )
def test_difference(): G = nx.Graph() H = nx.Graph() G.add_nodes_from([1, 2, 3, 4]) G.add_edge(1, 2) G.add_edge(2, 3) H.add_nodes_from([1, 2, 3, 4]) H.add_edge(2, 3) H.add_edge(3, 4) D = nx.difference(G, H) assert_equal(set(D.nodes()), set([1, 2, 3, 4])) assert_equal(sorted(D.edges()), [(1, 2)]) D = nx.difference(H, G) assert_equal(set(D.nodes()), set([1, 2, 3, 4])) assert_equal(sorted(D.edges()), [(3, 4)]) D = nx.symmetric_difference(G, H) assert_equal(set(D.nodes()), set([1, 2, 3, 4])) assert_equal(sorted(D.edges()), [(1, 2), (3, 4)])
def test_difference(): G = nx.Graph() H = nx.Graph() G.add_nodes_from([1, 2, 3, 4]) G.add_edge(1, 2) G.add_edge(2, 3) H.add_nodes_from([1, 2, 3, 4]) H.add_edge(2, 3) H.add_edge(3, 4) D = nx.difference(G, H) assert set(D.nodes()) == {1, 2, 3, 4} assert sorted(D.edges()) == [(1, 2)] D = nx.difference(H, G) assert set(D.nodes()) == {1, 2, 3, 4} assert sorted(D.edges()) == [(3, 4)] D = nx.symmetric_difference(G, H) assert set(D.nodes()) == {1, 2, 3, 4} assert sorted(D.edges()) == [(1, 2), (3, 4)]
def test_get_digraph_from_airflow_dag(self): with DAG(dag_id='d1', default_args=DEFAULT_DAG_ARGS) as dag: op1 = DummyOperator(task_id='op1') op2 = DummyOperator(task_id='op2') op3 = DummyOperator(task_id='op3') op4 = DummyOperator(task_id='op4') op1 >> [op2, op3] >> op4 expected_dg = nx.DiGraph() expected_dg.add_edge(op1, op2) expected_dg.add_edge(op1, op3) expected_dg.add_edge(op2, op4) expected_dg.add_edge(op3, op4) actual_dg = TransformerUtils.get_digraph_from_airflow_dag(dag) diff_dg: nx.DiGraph = nx.symmetric_difference(expected_dg, actual_dg) self.assertEqual(len(diff_dg.edges), 0)
def is_graph_equal(G1, G2, data=False): if G1.is_directed() != G2.is_directed(): return False if G1.is_multigraph() != G2.is_multigraph(): return False if G1.name != G2.name: return False if data is True: if G1.graph != G2.graph: return False if G1.number_of_nodes() != G2.number_of_nodes(): return False nodes_1 = sorted(G1.nodes(data=data)) nodes_2 = sorted(G2.nodes(data=data)) for idx in range(0, len(nodes_1)): # if the nodes have a data dict, this also compares its keys and values if nodes_1[idx] != nodes_2[idx]: return False if G1.number_of_edges() != G2.number_of_edges(): return False # NetworkX can find edge differences quite easily edge_diff_graph = nx.symmetric_difference(G1, G2) edge_diff = edge_diff_graph.edges(data=False) if len(edge_diff) > 0: return False # two undirected graphs can have the same edges represented differently, e.g. (1, 2) vs (2, 1), # so we ask the edge data to NetworkX, which handles those differences if data is True: edges_1 = sorted(G1.edges(data=False)) for u, v in edges_1: if G1.edge[u][v] != G2.edge[u][v]: return False return True
def test_adapted_virtual(): dj.errors._switch_adapted_types(True) c = virtual_module.Connectivity() graphs = [ nx.lollipop_graph(4, 2), nx.star_graph(5), nx.barbell_graph(3, 1), nx.cycle_graph(5), ] c.insert((i, g) for i, g in enumerate(graphs)) c.insert1({"connid": 100}) # test work with NULLs returned_graphs = c.fetch("conn_graph", order_by="connid") for g1, g2 in zip_longest(graphs, returned_graphs): if g1 is None: assert_true(g2 is None) else: assert_true(isinstance(g2, nx.Graph)) assert_equal(len(g1.edges), len(g2.edges)) assert_true(0 == len(nx.symmetric_difference(g1, g2).edges)) c.delete() dj.errors._switch_adapted_types(False)
def diff(*args): graphs = [] for i, j in enumerate(args): graphs.append(restore(j)) DIFF = [] LIST = [] for k, l in enumerate(list(itertools.combinations(range(len(graphs)), 2))): G = nx.symmetric_difference(graphs[l[0]], graphs[l[1]]) DIFF.append(G) LIST.append([G, nx.nodes(G), nx.edges(G)]) #DIFF.append((nx.difference(graphs[l[0]],graphs[l[1]]),nx.difference(graphs[l[1]],graphs[l[0]]))) fig, ax = plt.subplots(1, 1) #cl=[(('k','r'),('b','g'))] #for m,n in enumerate(DIFF): # nx.draw_kamada_kawai(n[0], node_color='w',edgecolors=cl[m][0][0],scale=5,node_shape='s',node_size=0,with_labels=True, font_weight='bold',font_color=cl[m][0][1],font_size=10,labels=labdic(n[0].nodes())) # nx.draw_kamada_kawai(n[1], node_color='w',edgecolors=cl[m][1][0],scale=5,node_shape='s',node_size=0,with_labels=True, font_weight='bold',font_color=cl[m][1][1],font_size=10,labels=labdic(n[1].nodes())) cl = [('k', 'r')] for m, n in enumerate(DIFF): label = labdic(n.nodes()) nx.draw_kamada_kawai(n, node_color='w', edgecolors=cl[m][0], scale=5, node_shape='s', node_size=0, with_labels=True, font_weight='bold', font_color=cl[m][1], font_size=10, labels=label) plt.show() plt.close() return LIST
for frame in range(num_frames, len(graph_test.img_nodes)): for node in graph_test.img_nodes[frame]: graph_test.G.remove_node(node) # Enforce min_area on ground-truth graph154 for frame in range(0, num_frames)[::-1]: for node_ind in range(0, len(graph_ground_truth.img_nodes[frame])): node = graph_ground_truth.img_nodes[frame][node_ind] contour = graph_ground_truth.contours[frame][node_ind] if cv2.contourArea(contour) < min_area: graph_ground_truth.G.remove_node(node) # Get edge statistics... # Exist in first graph but not second graph_ground_truth.G = nx.convert_node_labels_to_integers(graph_ground_truth.G) graph_test.G = nx.convert_node_labels_to_integers(graph_test.G) gt_diff_vt = nx.difference(graph_ground_truth.G, graph_test.G) vt_diff_gt = nx.difference(graph_test.G, graph_ground_truth.G) # Exist in either but not both symm_diff = nx.symmetric_difference(graph_ground_truth.G, graph_test.G).number_of_edges() # Exist in both intersect = nx.intersection(graph_ground_truth.G, graph_test.G).number_of_edges() # Calculate error print "Number of edges in truth: " + format(graph_ground_truth.G.number_of_edges()) print "Number of edges in test: " + format(graph_test.G.number_of_edges()) print "Edges in both: " + format(float(intersect)) print "Diff truth vs test: " + format(float(gt_diff_vt.number_of_edges())) print "Diff test vs truth: " + format(float(vt_diff_gt.number_of_edges())) print "Total different: " + format(float(symm_diff))
def test_symmetric_difference_raise(): G = nx.path_graph(4) H = nx.path_graph(3) GH = nx.symmetric_difference(G, H)
def test_mixed_type_symmetric_difference(): G = nx.Graph() H = nx.MultiGraph() U = nx.symmetric_difference(G,H)
#[1,2,3,4] GH4.edges() #[(1,2)] """ Difference de graphes """ # Les noeuds de H et G doivent etre les memes GH5=nx.difference(G,H) GH5.nodes() # [1,2,3,4] GH5.edges() # [((2,3),(3,4)] # Retourne un graphe avec des aretes qui existent dans G mais pas dans H """ Difference symetrique de graphes """ # Les noeuds de H et G doivent etre les memes GH6=nx.symmetric_difference(G,H) GH6.nodes() # [1,2,3,4] GH6.edges() # [((2,3),(3,4)] # Retourne un graphe avec des aretes qui sont soit dans G soit dans H mais pas les deux ##### Graphes classiques ##### petersen=nx.petersen_graph() petersen.nodes() #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] petersen.edges() #[(0, 1), (0, 4), (0, 5), (1, 2), (1, 6), (2, 3), (2, 7), (3, 8), (3, 4), (4, 9), (5, 8), (5, 7), (6, 8), (6, 9), (7, 9)]
def test_mixed_type_symmetric_difference(): G = nx.Graph() H = nx.MultiGraph() U = nx.symmetric_difference(G, H)