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_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)
def test_symmetric_difference_raise():
G = nx.path_graph(4)
H = nx.path_graph(3)
GH = nx.symmetric_difference(G, H)
