def test_inject_clone_node(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
new_p_node, new_rhs_node = rule.inject_clone_node(2)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert(new_p_node in rule.p.nodes())
assert(new_rhs_node in rule.rhs.nodes())
assert(rule.p_rhs[new_p_node] == new_rhs_node)
assert((1, new_p_node) in rule.p.edges())
assert((3, new_p_node) in rule.p.edges())
assert((1, new_rhs_node) in rule.rhs.edges())
assert((3, new_rhs_node) in rule.rhs.edges())
new_p_node, new_rhs_node = rule.inject_clone_node(2)
assert(len(keys_by_value(rule.p_lhs, 2)) == 3)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
rule.inject_remove_node(3)
try:
rule.inject_clone_node(3)
raise ValueError("Cloning of removed node was not caught")
except:
pass
def test_add_relation(self):
self.hierarchy.add_relation(
"a2", "a1",
{
"right_circle": {"white_circle", "black_circle"},
"middle_square": "white_square",
"left_circle": "black_circle"
},
{"name": "Some relation"})
g, l, r = self.hierarchy.relation_to_span(
"a1", "a2", edges=True, attrs=True)
# print_graph(g)
# print(l)
# print(r)
# print(self.hierarchy)
# self.hierarchy.remove_graph("a1")
# print(self.hierarchy.relation)
lhs = nx.DiGraph()
lhs.add_nodes_from(["s", "c"])
rule = Rule.from_transform(lhs)
rule.inject_clone_node("s")
# instances = self.hierarchy.find_matching(
# "base",
# rule.lhs
# )
new_hierarchy, _ = self.hierarchy.rewrite(
"base", rule, {"s": "square", "c": "circle"}, inplace=False)
def test_triangle_1(self):
h = NetworkXHierarchy()
g1 = nx.DiGraph()
g1.add_nodes_from([
"1", "2"
])
g2 = nx.DiGraph()
g2.add_nodes_from([
"1a", "1b", "2a", "2b"
])
g3 = nx.DiGraph()
g3.add_nodes_from([
"1x", "1y", "2x", "2y"
])
h.add_graph("g1", g1)
h.add_graph("g2", g2)
h.add_graph("g3", g3)
h.add_typing(
"g2", "g1",
{
"1a": "1",
"1b": "1",
"2a": "2",
"2b": "2"
})
h.add_typing(
"g3", "g1",
{
"1x": "1",
"1y": "1",
"2x": "2",
"2y": "2"
})
h.add_typing(
"g2", "g3",
{
"1a": "1x",
"1b": "1y",
"2a": "2y",
"2b": "2x"
})
pattern = nx.DiGraph()
pattern.add_nodes_from([
1, 2
])
rule = Rule.from_transform(pattern)
rule.inject_remove_node(1)
rule.inject_clone_node(2)
instances = h.find_matching("g1", pattern)
new_h, _ = h.rewrite("g1", rule, instances[0], inplace=False)
def test_inject_remove_node(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
rule.inject_remove_node(2)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert(2 in rule.lhs.nodes())
assert(2 not in rule.p.nodes())
assert(2 not in rule.rhs.nodes())
def test_inject_add_node(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
try:
rule.inject_add_node(3)
raise ValueError("Node duplication was not caught")
except RuleError:
pass
rule.inject_add_node(4)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert(4 in rule.rhs.nodes() and
4 not in rule.lhs.nodes() and
4 not in rule.p.nodes())
def test_inject_merge_nodes(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
new_name = rule.inject_merge_nodes([1, 2])
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((new_name, new_name) in rule.rhs.edges())
assert((3, new_name) in rule.rhs.edges())
new_p_name, new_rhs_name = rule.inject_clone_node(2)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
new_name = rule.inject_merge_nodes([2, 3])
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert(new_p_name in rule.rhs.nodes())
def test_from_commands(self):
pattern = nx.DiGraph()
prim.add_nodes_from(
pattern,
[(1, {'state': 'p'}),
(2, {'name': 'BND'}),
3,
4]
)
prim.add_edges_from(
pattern,
[(1, 2, {'s': 'p'}),
(3, 2, {'s': 'u'}),
(3, 4)]
)
p = nx.DiGraph()
prim.add_nodes_from(
p,
[(1, {'state': 'p'}), ("1_clone", {'state': 'p'}), (2, {'name': 'BND'}), 3, 4])
prim.add_edges_from(
p, [(1, 2), ('1_clone', 2), (3, 4)])
rhs = nx.DiGraph()
prim.add_nodes_from(
rhs,
[(1, {'state': 'p'}), ("1_clone", {'state': 'p'}), (2, {'name': 'BND'}), 3, 4, 5])
prim.add_edges_from(
rhs, [(1, 2, {'s': 'u'}), ('1_clone', 2), (2, 4), (3, 4), (5, 3)])
p_lhs = {1: 1, '1_clone': 1, 2: 2, 3: 3, 4: 4}
p_rhs = {1: 1, '1_clone': '1_clone', 2: 2, 3: 3, 4: 4}
rule1 = Rule(p, pattern, rhs, p_lhs, p_rhs)
commands = "clone 1.\n" +\
"delete_edge 3 2.\n" +\
"add_node 5.\n" +\
"add_edge 2 4.\n" +\
"add_edge 5 3."
rule2 = Rule.from_transform(pattern, commands)
assert((5, 3) in rule2.rhs.edges())
assert(5 in rule2.rhs.nodes() and 5 not in rule2.p.nodes())
assert((2, 4) in rule2.rhs.edges())
def test_inject_remove_edge_attrs(self):
pattern = nx.DiGraph()
prim.add_nodes_from(
pattern,
[1, 2, 3])
prim.add_edges_from(
pattern,
[(1, 2, {"a12": {True}}), (3, 2, {"a32": {True}})])
rule = Rule.from_transform(pattern)
rule.inject_remove_edge_attrs(1, 2, {"a12": {True}})
assert("a12" not in rule.p.adj[1][2])
new_p_node, new_rhs_node = rule.inject_clone_node(2)
assert("a12" not in rule.p.adj[1][new_p_node])
rule.inject_remove_edge_attrs(3, new_p_node, {"a32": {True}})
assert("a32" in rule.p.adj[3][2])
assert("a32" not in rule.p.adj[3][new_p_node])
assert("a32" in rule.rhs.adj[3][rule.p_rhs[2]])
assert("a32" not in rule.rhs.adj[3][new_rhs_node])
def test_porpagation_node_attrs_adds(self):
p = NXGraph()
primitives.add_nodes_from(p, [1, 2])
lhs = NXGraph()
primitives.add_nodes_from(lhs, [1, 2])
rhs = NXGraph()
primitives.add_nodes_from(rhs, [(1, {
"a1": True
}), (2, {
"a2": 1
}), (3, {
"a3": "x"
})])
rule = Rule(p, lhs, rhs)
instance = {1: "A", 2: "A_res_1"}
rhs_typing = {"mm": {3: "state"}}
try:
self.hierarchy.rewrite("n1",
rule,
instance,
rhs_typing=rhs_typing,
strict=True)
raise ValueError("Error was not caught!")
except RewritingError:
pass
new_hierarchy = NXHierarchy.copy(self.hierarchy)
new_hierarchy.rewrite("n1", rule, instance, rhs_typing=rhs_typing)
# test propagation of the node attribute adds
assert ("a1" in new_hierarchy.get_graph("n1").get_node("A"))
assert ("a2" in new_hierarchy.get_graph("n1").get_node("A_res_1"))
assert ("a3" in new_hierarchy.get_graph("n1").get_node(3))
assert ("a1" in new_hierarchy.get_graph("ag").get_node("A"))
assert ("a2" in new_hierarchy.get_graph("ag").get_node("A_res_1"))
assert ("a3" in new_hierarchy.get_graph("ag").get_node(3))
def test_inject_add_node_attrs(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
clone_name_p, clone_name_rhs = rule.inject_clone_node(2)
rule.inject_add_node(4)
merge = rule.inject_merge_nodes([1, 3])
rule.inject_add_node_attrs(2, {"a": {True}})
assert("a" in rule.rhs.node[2])
rule.inject_add_node_attrs(clone_name_p, {"b": {True}})
assert("b" in rule.rhs.node[clone_name_rhs])
assert("b" not in rule.rhs.node[2])
rule.inject_add_node_attrs(4, {"c": {True}})
assert("c" in rule.rhs.node[4])
rule.inject_add_node_attrs(merge, {"d": {True}})
assert("d" in rule.rhs.node[merge])
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
def test_inject_add_edge(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
rule.inject_add_node(4)
rule.inject_add_edge(1, 4)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((1, 4) in rule.rhs.edges())
merge_node = rule.inject_merge_nodes([1, 2])
rule.inject_add_edge(merge_node, 3)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((merge_node, 3) in rule.rhs.edges())
new_p_node, new_rhs_node = rule.inject_clone_node(2)
rule.inject_add_edge(new_p_node, merge_node)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((new_rhs_node, merge_node) in rule.rhs.edges())
def test_inject_add_edge(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
rule.inject_add_node(4)
rule.inject_add_edge(1, 4)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((1, 4) in rule.rhs.edges())
merge_node = rule.inject_merge_nodes([1, 2])
rule.inject_add_edge(merge_node, 3)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((merge_node, 3) in rule.rhs.edges())
new_p_node, new_rhs_node = rule.inject_clone_node(2)
rule.inject_add_edge(new_p_node, merge_node)
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert((new_rhs_node, merge_node) in rule.rhs.edges())
def test_inject_add_node_attrs(self):
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2, 3])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
clone_name_p, clone_name_rhs = rule.inject_clone_node(2)
rule.inject_add_node(4)
merge = rule.inject_merge_nodes([1, 3])
rule.inject_add_node_attrs(2, {"a": {True}})
assert("a" in rule.rhs.node[2])
assert("a" in rule.rhs.node[clone_name_rhs])
rule.inject_add_node_attrs(clone_name_p, {"b": {True}})
assert("b" in rule.rhs.node[clone_name_rhs])
assert("b" not in rule.rhs.node[2])
rule.inject_add_node_attrs(4, {"c": {True}})
assert("c" in rule.rhs.node[4])
rule.inject_add_node_attrs(merge, {"d": {True}})
assert("d" in rule.rhs.node[merge])
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
def test_inject_remove_node_attrs(self):
pattern = nx.DiGraph()
prim.add_nodes_from(
pattern,
[1, (2, {"a2": {True}}), (3, {"a3": {False}})])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
rule.inject_remove_node_attrs(3, {"a3": {False}})
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert("a3" not in rule.p.node[3])
assert("a3" in rule.lhs.node[3])
new_p_node, new_rhs_node = rule.inject_clone_node(2)
rule.inject_remove_node_attrs(new_p_node, {"a2": {True}})
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert("a2" not in rule.p.node[new_p_node])
assert("a2" in rule.p.node[2])
assert("a2" not in rule.rhs.node[new_rhs_node])
assert("a2" in rule.rhs.node[2])
def test_inject_remove_node_attrs(self):
pattern = nx.DiGraph()
prim.add_nodes_from(
pattern,
[1, (2, {"a2": {True}}), (3, {"a3": {False}})])
prim.add_edges_from(pattern, [(1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
rule.inject_remove_node_attrs(3, {"a3": {False}})
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert("a3" not in rule.p.node[3])
assert("a3" in rule.lhs.node[3])
new_p_node, new_rhs_node = rule.inject_clone_node(2)
rule.inject_remove_node_attrs(new_p_node, {"a2": {True}})
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
assert("a2" not in rule.p.node[new_p_node])
assert("a2" in rule.p.node[2])
assert("a2" not in rule.rhs.node[new_rhs_node])
assert("a2" in rule.rhs.node[2])
def test_rewrite(self):
pattern = NXGraph()
add_nodes_from(pattern, [(1, {
'state': 'p'
}), (2, {
'name': 'BND'
}), 3, 4])
add_edges_from(pattern, [(1, 2, {
's': 'p'
}), (3, 2, {
's': 'u'
}), (3, 4)])
p = NXGraph()
add_nodes_from(p, [(1, {'state': 'p'}), (2, {'name': 'BND'}), 3, 4])
p.add_edges_from([(1, 2), (3, 4)])
rhs = NXGraph()
add_nodes_from(rhs, [(1, {
'state': 'p'
}), (2, {
'name': 'BND'
}), (3, {
'merged': 'yes'
}), (4, {
'new': 'yes'
})])
add_edges_from(rhs, [(1, 2, {
's': 'u'
}), (2, 4), (3, 3), (3, 4, {
'from': 'merged'
})])
p_lhs = {1: 1, 2: 2, 3: 3, 4: 4}
p_rhs = {1: 1, 2: 2, 3: 3, 4: 3}
rule = Rule(p, pattern, rhs, p_lhs, p_rhs)
# instances = find_matching_with_types(self.graph, rule.lhs, {}, {}, {})
instances = self.graph.find_matching(rule.lhs)
self.graph.rewrite(rule, instances[0])
def test_component_getters(self):
pattern = NXGraph()
prim.add_nodes_from(pattern, [(1, {
"a1": {1}
}), (2, {
"a2": {2}
}), (3, {
"a3": {3}
})])
prim.add_edges_from(pattern, [(1, 2, {
"a12": {12}
}), (2, 3), (3, 2, {
"a32": {32}
})])
rule = Rule.from_transform(pattern)
rule.inject_remove_node(1)
rule.inject_remove_edge(2, 3)
new_p_name, new_rhs_name = rule.inject_clone_node(2)
rule.inject_remove_node_attrs(3, {"a3": {3}})
rule.inject_remove_edge_attrs(3, 2, {"a32": {32}})
rule.inject_add_node_attrs(3, {"a3": {100}})
rule.inject_add_node(4)
rule.inject_add_edge(4, new_p_name)
assert (rule.removed_nodes() == {1})
assert (rule.removed_edges() == {(2, 3), (new_p_name, 3)})
assert (len(rule.cloned_nodes()) == 1
and 2 in rule.cloned_nodes().keys())
assert (len(rule.removed_node_attrs()) == 1
and 3 in rule.removed_node_attrs()[3]["a3"])
assert (len(rule.removed_edge_attrs()) == 1
and 32 in rule.removed_edge_attrs()[(3, 2)]["a32"])
assert (rule.added_nodes() == {4})
assert (rule.added_edges() == {(4, "21")})
# rule.merged_nodes()
# rule.added_edge_attrs()
assert (len(rule.added_node_attrs()) == 1
and 100 in rule.added_node_attrs()[3]["a3"])
assert (rule.is_restrictive() and rule.is_relaxing())
def test_component_getters(self):
pattern = nx.DiGraph()
prim.add_nodes_from(
pattern,
[(1, {"a1": {1}}), (2, {"a2": {2}}), (3, {"a3": {3}})]
)
prim.add_edges_from(
pattern,
[
(1, 2, {"a12": {12}}),
(2, 3),
(3, 2, {"a32": {32}})
]
)
rule = Rule.from_transform(pattern)
rule.inject_remove_node(1)
rule.inject_remove_edge(2, 3)
new_p_name, new_rhs_name = rule.inject_clone_node(2)
rule.inject_remove_node_attrs(3, {"a3": {3}})
rule.inject_remove_edge_attrs(3, 2, {"a32": {32}})
rule.inject_add_node_attrs(3, {"a3": {100}})
rule.inject_add_node(4)
rule.inject_add_edge(4, new_p_name)
assert(rule.removed_nodes() == {1})
assert(rule.removed_edges() == {(2, 3), (new_p_name, 3)})
assert(len(rule.cloned_nodes()) == 1 and
2 in rule.cloned_nodes().keys())
assert(len(rule.removed_node_attrs()) == 1 and
3 in rule.removed_node_attrs()[3]["a3"])
assert(len(rule.removed_edge_attrs()) == 1 and
32 in rule.removed_edge_attrs()[(3, 2)]["a32"])
assert(rule.added_nodes() == {4})
assert(rule.added_edges() == {(4, "21")})
# rule.merged_nodes()
# rule.added_edge_attrs()
assert(len(rule.added_node_attrs()) == 1 and
100 in rule.added_node_attrs()[3]["a3"])
assert(rule.is_restrictive() and rule.is_relaxing())
def test_controlled_backward(self):
h = self._generate_triangle_hierarchy()
pattern = NXGraph()
pattern.add_nodes_from(["1"])
rule = Rule.from_transform(pattern)
rule.inject_clone_node("1", "11")
p_typing = {
"g2": {
"1a": {"1"},
"1b": {"11"}
},
}
old_g3_nodes = h.get_graph("g3").nodes(True)
old_g2_nodes = h.get_graph("g2").nodes(True)
h.rewrite("g1", rule, {"1": "1"}, p_typing=p_typing)
# assert(old_g3_nodes == h.get_graph("g3").nodes(True))
assert (old_g2_nodes == h.get_graph("g2").nodes(True))
def test_inject_add_edge_attrs(self):
pattern = NXGraph()
prim.add_nodes_from(pattern, [0, 1, 2, 3])
prim.add_edges_from(pattern, [(0, 1), (0, 2), (1, 2), (3, 2)])
rule = Rule.from_transform(pattern)
clone_name_p, clone_name_rhs = rule.inject_clone_node(2)
rule.inject_add_node(4)
rule.inject_add_edge(4, 3)
merge = rule.inject_merge_nodes([1, 3])
rule.inject_add_edge_attrs(0, merge, {"a": {True}})
assert ("a" in rule.rhs.get_edge(0, merge))
rule.inject_add_edge_attrs(0, clone_name_p, {"b": {True}})
assert ("b" in rule.rhs.get_edge(0, clone_name_rhs))
rule.inject_add_edge_attrs(merge, clone_name_p, {"c": {True}})
assert ("c" in rule.rhs.get_edge(merge, clone_name_rhs))
assert ("c" not in rule.rhs.get_edge(merge, 2))
rule.inject_add_edge_attrs(4, merge, {"d": {True}})
assert ("d" in rule.rhs.get_edge(4, merge))
check_homomorphism(rule.p, rule.lhs, rule.p_lhs)
check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
def test_lifting(self):
pattern = nx.DiGraph()
primitives.add_nodes_from(pattern, [
("student", {"sex": {"male", "female"}}),
"prof"
])
primitives.add_edge(pattern, "prof", "student")
p = nx.DiGraph()
primitives.add_nodes_from(p, [
("girl", {"sex": "female"}),
("boy", {"sex": "male"}),
("generic")
])
p_lhs = {
"girl": "student",
"boy": "student",
"generic": "student"
}
rule = Rule(p, pattern, p_lhs=p_lhs)
# Test non-canonical rule lifting
rule_hierarchy1, lhs_instances1 = self.hierarchy.get_rule_propagations(
"b", rule, p_typing={"c": {"Alice": {"girl", "generic"}, "Bob": "boy"}})
new_hierarchy, rhs_instances1 = self.hierarchy.apply_rule_hierarchy(
rule_hierarchy1, lhs_instances1, inplace=False)
pattern = nx.DiGraph()
primitives.add_nodes_from(pattern, [
"school",
"institute"
])
rule = Rule.from_transform(pattern)
rule.inject_add_node("phd")
rule.inject_add_edge("phd", "institute", {"type": "internship"})
rule_hierarchy2, lhs_instances2 = self.hierarchy.get_rule_propagations(
"b", rule, rhs_typing={"a": {"phd": "red"}})
new_hierarchy, rhs_instances2 = self.hierarchy.apply_rule_hierarchy(
rule_hierarchy2, lhs_instances2, inplace=False)
def test_controlled_up_propagation(self):
pattern = NXGraph()
pattern.add_nodes_from(["A"])
rule = Rule.from_transform(pattern)
p_clone, _ = rule.inject_clone_node("A")
rule.inject_add_node("D")
p_typing = {
"nn1": {
"A_bye": set(),
"A_hello": {p_clone}
},
"n1": {
"A": p_clone
}
}
instance = {"A": "A"}
nugget_1 = NXGraph()
primitives.add_nodes_from(
nugget_1, ["A_bye", "A_hello", "A_res_1", "p", "B", "mod"])
primitives.add_edges_from(nugget_1, [("A_res_1", "A_hello"),
("A_res_1", "A_bye"),
("p", "A_res_1"), ("mod", "p"),
("B", "mod")])
self.hierarchy.add_graph("nn1", nugget_1)
self.hierarchy.add_typing(
"nn1", "n1", {
"A_bye": "A",
"A_hello": "A",
"A_res_1": "A_res_1",
"p": "p",
"B": "B",
"mod": "mod"
})
new_hierarchy = NXHierarchy.copy(self.hierarchy)
new_hierarchy.rewrite("ag", rule, instance, p_typing=p_typing)
def test_controlled_forward(self):
h = self._generate_triangle_hierarchy()
pattern = NXGraph()
pattern.add_nodes_from(["1a"])
rule = Rule.from_transform(pattern)
rule.inject_add_node("1c")
rhs_typing = {"g3": {"1c": "1x"}}
old_g3_nodes = h.get_graph("g3").nodes(True)
old_g1_nodes = h.get_graph("g1").nodes(True)
h.rewrite("g2", rule, {"1a": "1a"}, rhs_typing=rhs_typing)
assert (old_g3_nodes == h.get_graph("g3").nodes(True))
assert (old_g1_nodes == h.get_graph("g1").nodes(True))
rhs_typing = {"g1": {"1c": "1"}}
h.rewrite("g2", rule, {"1a": "1a"}, rhs_typing=rhs_typing)
assert (old_g1_nodes == h.get_graph("g1").nodes(True))
assert (len(old_g3_nodes) + 1 == len(h.get_graph("g3").nodes()))
def test_add_relation(self):
self.hierarchy.add_relation(
"a2", "a1", {
"right_circle": {"white_circle", "black_circle"},
"middle_square": "white_square",
"left_circle": "black_circle"
}, {"name": "Some relation"})
g, l, r = self.hierarchy.relation_to_span("a1",
"a2",
edges=True,
attrs=True)
# print_graph(g)
# print(l)
# print(r)
# print(self.hierarchy)
# self.hierarchy.remove_graph("a1")
# print(self.hierarchy.relation)
lhs = nx.DiGraph()
lhs.add_nodes_from(["s", "c"])
rule = Rule.from_transform(lhs)
rule.inject_clone_node("s")
# instances = self.hierarchy.find_matching(
# "base",
# rule.lhs
# )
new_hierarchy, _ = self.hierarchy.rewrite("base",
rule, {
"s": "square",
"c": "circle"
},
inplace=False)
def test_add_rule(self):
lhs = nx.DiGraph()
prim.add_nodes_from(lhs, [1, 2, 3])
prim.add_edges_from(lhs, [(1, 2), (2, 1), (2, 3)])
p = nx.DiGraph()
prim.add_nodes_from(p, [1, 2, 3, 31])
prim.add_edges_from(p, [(1, 2), (2, 3), (2, 31)])
rhs = nx.DiGraph()
prim.add_nodes_from(rhs, [1, 2, 3, 31, 4])
prim.add_edges_from(rhs, [(1, 2), (4, 2), (2, 3), (2, 31)])
p_lhs = {1: 1, 2: 2, 3: 3, 31: 3}
p_rhs = {1: 1, 2: 2, 3: 3, 31: 3}
rule = Rule(p, lhs, rhs, p_lhs, p_rhs)
lhs_typing = {1: "black_circle", 2: "white_circle", 3: "white_square"}
rhs_typing = {
1: "black_circle",
2: "white_circle",
3: "white_square",
31: "white_square",
4: "black_circle"
}
self.hierarchy.add_rule("r1", rule, {"name": "First rule"})
self.hierarchy.add_rule_typing("r1", "g1", lhs_typing, rhs_typing)
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, (2, {"a": {1, 2}}), 3])
prim.add_edges_from(pattern, [(1, 2), (2, 3)])
lhs_typing = {
"g0": {
1: "circle",
2: "square",
3: "triangle"
},
"g00": {
1: 'white',
2: 'white',
3: 'black'
}
}
p = nx.DiGraph()
prim.add_nodes_from(p, [1, 11, 2, 3])
prim.add_edges_from(p, [(2, 3)])
rhs = nx.DiGraph()
prim.add_nodes_from(rhs, [
1,
11,
(2, {
"a": {3, 5}
}),
(3, {
"new_attrs": {1}
}),
])
prim.add_edges_from(rhs, [(2, 3, {"new_attrs": {4}})])
p_lhs = {1: 1, 11: 1, 2: 2, 3: 3}
p_rhs = {1: 1, 11: 11, 2: 2, 3: 3}
rule = Rule(p, pattern, rhs, p_lhs, p_rhs)
rhs_typing = {
"g0": {
1: "circle",
11: "circle",
2: "square",
3: "triangle"
},
"g00": {
1: "white",
11: "white",
2: "white",
3: "black"
}
}
instances = self.hierarchy.find_matching("g1", pattern, lhs_typing)
self.hierarchy.rewrite("g1", rule, instances[0], rhs_typing=rhs_typing)
hierarchy.graph["colors"], title="Graph 'colors'")
mmm_pos = plot_graph(
hierarchy.graph["mmm"], title="Graph 'mmm' (meta-meta-model)")
mm_pos = plot_graph(
hierarchy.graph["mm"], title="Graph 'mm' (meta-model)")
ag_pos = plot_graph(
hierarchy.graph["ag"], title="Graph 'ag' (action graph)")
n1_pos = plot_graph(
hierarchy.graph["n1"], title="Graph 'n1' (nugget)")
# define a rule that clones nodes
pattern = nx.DiGraph()
add_nodes_from(pattern, ["gene", "residue"])
add_edges_from(pattern, [("residue", "gene")])
cloning_rule = Rule.from_transform(pattern)
clone_name, _ = cloning_rule.inject_clone_node("gene")
cloning_rule.inject_remove_edge("residue", clone_name)
print("\nRule 1: contains cloning of nodes")
print("---------------------------------")
print(cloning_rule)
plot_rule(cloning_rule, title="Rule 1: contains cloning of nodes")
lhs_typing = {
"mm": {"gene": "gene", "residue": "residue"}
}
print("with the typing of the left-hand side: ", lhs_typing)
# find matching of the lhs of the cloning rule in 'ag'
instances = hierarchy.find_matching(
def test_rewrite(self):
pattern = NXGraph()
pattern.add_nodes_from([1, (2, {"a": {1, 2}}), 3])
pattern.add_edges_from([(1, 2), (2, 3)])
lhs_typing = {
"g0": {
1: "circle",
2: "square",
3: "triangle"
},
"g00": {
1: "white",
2: "white",
3: "black"
}
}
p = NXGraph()
p.add_nodes_from([1, 2, 3])
p.add_edges_from([(2, 3)])
rhs = NXGraph()
rhs.add_nodes_from([1, (2, {"a": {3, 5}}), (3, {"new_attrs": {1}}), 4])
rhs.add_edges_from([(2, 1, {
"new_attrs": {2}
}), (2, 4, {
"new_attrs": {3}
}), (2, 3, {
"new_attrs": {4}
})])
p_lhs = {1: 1, 2: 2, 3: 3}
p_rhs = {1: 1, 2: 2, 3: 3}
rule = Rule(p, pattern, rhs, p_lhs, p_rhs)
rhs_typing = {
"g0": {
1: "circle",
2: "square",
3: "triangle",
4: "triangle"
},
"g00": {
1: "white",
2: "white",
3: "black",
4: "black"
}
}
instances = self.nx_hierarchy.find_matching("g1",
pattern,
pattern_typing=lhs_typing)
old_g0_nodes = self.nx_hierarchy.get_graph("g0").nodes(data=True)
old_g0_edges = self.nx_hierarchy.get_graph("g0").edges(data=True)
old_g00_nodes = self.nx_hierarchy.get_graph("g00").nodes(data=True)
old_g00_edges = self.nx_hierarchy.get_graph("g00").edges(data=True)
self.nx_hierarchy.rewrite("g1",
rule,
instances[0],
rhs_typing=rhs_typing)
assert (set([n[0] for n in old_g0_nodes
]) == set(self.nx_hierarchy.get_graph("g0").nodes()))
assert (set([(n[0], n[1]) for n in old_g0_edges
]) == set(self.nx_hierarchy.get_graph("g0").edges()))
assert (set([n[0] for n in old_g00_nodes
]) == set(self.nx_hierarchy.get_graph("g00").nodes()))
assert (set([(n[0], n[1]) for n in old_g00_edges
]) == set(self.nx_hierarchy.get_graph("g00").edges()))
for n, attrs in old_g0_nodes:
assert (self.nx_hierarchy.get_graph("g0").get_node(n) == attrs)
for s, t, attrs in old_g0_edges:
assert (self.nx_hierarchy.get_graph("g0").get_edge(s, t) == attrs)
for n, attrs in old_g00_nodes:
assert (self.nx_hierarchy.get_graph("g00").get_node(n) == attrs)
for s, t, attrs in old_g00_edges:
assert (self.nx_hierarchy.get_graph("g00").get_edge(s, t) == attrs)
if self.neo4j_hierarchy:
instances = self.neo4j_hierarchy.find_matching(
"g1", pattern, pattern_typing=lhs_typing)
if self.neo4j_hierarchy:
old_g0_nodes = self.neo4j_hierarchy.get_graph("g0").nodes(
data=True)
old_g0_edges = self.neo4j_hierarchy.get_graph("g0").edges(
data=True)
old_g00_nodes = self.neo4j_hierarchy.get_graph("g00").nodes(
data=True)
old_g00_edges = self.neo4j_hierarchy.get_graph("g00").edges(
data=True)
self.neo4j_hierarchy.rewrite("g1",
rule,
instances[0],
rhs_typing=rhs_typing)
assert (set([n[0] for n in old_g0_nodes]) == set(
self.neo4j_hierarchy.get_graph("g0").nodes()))
assert (set([
(n[0], n[1]) for n in old_g0_edges
]) == set(self.neo4j_hierarchy.get_graph("g0").edges()))
assert (set([n[0] for n in old_g00_nodes]) == set(
self.neo4j_hierarchy.get_graph("g00").nodes()))
assert (set([
(n[0], n[1]) for n in old_g00_edges
]) == set(self.neo4j_hierarchy.get_graph("g00").edges()))
for n, attrs in old_g0_nodes:
assert (
self.neo4j_hierarchy.get_graph("g0").get_node(n) == attrs)
for s, t, attrs in old_g0_edges:
assert (self.neo4j_hierarchy.get_graph("g0").get_edge(
s, t) == attrs)
for n, attrs in old_g00_nodes:
assert (
self.neo4j_hierarchy.get_graph("g00").get_node(n) == attrs)
for s, t, attrs in old_g00_edges:
assert (self.neo4j_hierarchy.get_graph("g00").get_edge(
s, t) == attrs)
def test_propagation_node_adds(self):
"""Test propagation down of additions."""
p = nx.DiGraph()
primitives.add_nodes_from(p, ["B"])
l = nx.DiGraph()
primitives.add_nodes_from(l, ["B"])
r = nx.DiGraph()
primitives.add_nodes_from(r, ["B", "B_res_1", "X", "Y"])
primitives.add_edge(r, "B_res_1", "B")
rule = Rule(p, l, r)
instance = {"B": "B"}
rhs_typing = {
"mm": {
"B_res_1": "residue"
},
"mmm": {
"X": "component"
},
"colors": {
"Y": "red"
}
}
try:
self.hierarchy.rewrite("n1",
rule,
instance,
rhs_typing=rhs_typing,
strict=True)
raise ValueError("Error was not caught!")
except RewritingError:
pass
new_hierarchy, _ = self.hierarchy.rewrite("n1",
rule,
instance,
rhs_typing=rhs_typing,
inplace=False)
# test propagation of node adds
assert ("B_res_1" in new_hierarchy.graph["n1"].nodes())
assert ("B_res_1" in new_hierarchy.graph["ag"].nodes())
assert (new_hierarchy.typing["n1"]["ag"]["B_res_1"] == "B_res_1")
assert (new_hierarchy.typing["ag"]["mm"]["B_res_1"] == "residue")
assert (("B_res_1", "B") in new_hierarchy.graph["n1"].edges())
assert (("B_res_1", "B") in new_hierarchy.graph["ag"].edges())
assert ("X" in new_hierarchy.graph["n1"].nodes())
assert ("X" in new_hierarchy.graph["ag"].nodes())
assert ("X" in new_hierarchy.graph["mm"].nodes())
assert ("X" in new_hierarchy.graph["colors"].nodes())
assert (new_hierarchy.typing["n1"]["ag"]["X"] == "X")
assert (new_hierarchy.typing["ag"]["mm"]["X"] == "X")
assert (new_hierarchy.typing["mm"]["mmm"]["X"] == "component")
assert (new_hierarchy.typing["mm"]["colors"]["X"] == "X")
assert ("Y" in new_hierarchy.graph["n1"].nodes())
assert ("Y" in new_hierarchy.graph["ag"].nodes())
assert ("Y" in new_hierarchy.graph["mm"].nodes())
assert ("Y" in new_hierarchy.graph["mm"].nodes())
assert (new_hierarchy.typing["n1"]["ag"]["Y"] == "Y")
assert (new_hierarchy.typing["ag"]["mm"]["Y"] == "Y")
assert (new_hierarchy.typing["mm"]["mmm"]["Y"] == "Y")
assert (new_hierarchy.typing["mm"]["colors"]["Y"] == "red")
def identify_residue(self,
residue,
ref_agent,
add_aa=False,
rewriting=False):
"""Find corresponding residue.
residue : kami.entities.residue
Input residue entity to search for
ref_agent
Id of the reference agent to which residue belongs,
can reference either to a protoform, a region or a site
of the action graph
add_aa : bool
Add aa value if location is found but aa is not
rewriting : bool
If True, add aa value using SqPO rewriting, otherwise
using primitives (used if `add_aa` is True)
"""
ref_gene = self.get_protoform_of(ref_agent)
ref_uniprot = get_uniprot(self.graph.get_node(ref_gene))
residue_candidates = self.get_attached_residues(ref_gene)
if residue.loc is not None:
for res in residue_candidates:
if (self.immediate):
res_agent_edges = [self.graph.get_edge(res, ref_agent)]
else:
res_agent_edges = [
self.graph.get_edge(res, s)
for s in self.graph.successors(res)
]
for res_agent_edge in res_agent_edges:
if "loc" in res_agent_edge.keys():
if residue.loc == int(list(res_agent_edge["loc"])[0]):
res_node = self.graph.get_node(res)
if not residue.aa.issubset(
res_node["aa"]) and\
add_aa is True:
if rewriting:
pattern = nx.DiGraph()
pattern.add_node(res)
rule = Rule.from_transform(pattern)
rule.inject_add_node_attrs(
res, {"aa": {residue.aa}})
if self.hierarchy is not None:
self.hierarchy.rewrite(
self.graph_id,
rule,
instance={res: res},
message=
("Added the key '{}' to the residue '{}' "
.format(residue.aa, residue.loc) +
"of the protoform with the UniProtAC '{}'"
.fromat(ref_uniprot)),
update_type="auto")
else:
self.graph.rewrite(rule,
instance={res: res})
else:
self.graph.add_node_attrs(
res, {
"aa": res_node["aa"].union(
residue.aa)
})
return res
else:
for res in residue_candidates:
if (self.immediate):
res_agent_edges = [self.graph.get_edge(res, ref_agent)]
else:
res_agent_edges = [
self.graph.get_edge(res, s)
for s in self.graph.successors(res)
]
for res_agent_edge in res_agent_edges:
if "loc" not in res_agent_edge.keys() or\
res_agent_edge["loc"].is_empty():
res_node = self.graph.get_node(res)
if residue.aa <= res_node["aa"]:
return res
elif add_aa is True:
if rewriting:
pattern = nx.DiGraph()
pattern.add_node(res)
rule = Rule.from_transform(pattern)
rule.inject_add_node_attrs(
res, {"aa": {residue.aa}})
instance = {n: n for n in pattern.nodes()}
instance[res] = res
if self.hierarchy is not None:
self.hierarchy.rewrite(
self.graph_id,
rule,
instance=instance,
message=
("Added the key '{}' to the pool of residues "
.format(residue.aa) +
"woth no location of the protoform with the "
"UniProtAC '{}'".fromat(ref_uniprot)),
update_type="auto")
else:
self.graph.rewrite(rule, instance=instance)
else:
self.graph.add_node_attrs(
res,
{"aa": res_node["aa"].union(residue.aa)})
return res
return None
def test_from_script(self):
commands = "clone 2 as '21'.\nadd_node 'a' {'a': 1}.\ndelete_node 3."
rule = Rule.from_transform(self.pattern, commands=commands)
assert('a' in rule.rhs.nodes())
assert('21' in rule.rhs.nodes())
assert(3 not in rule.rhs.nodes())
def test_from_script(self):
commands = "clone 2 as '21'.\nadd_node 'a' {'a': 1}.\ndelete_node 3."
rule = Rule.from_transform(self.pattern, commands=commands)
assert('a' in rule.rhs.nodes())
assert('21' in rule.rhs.nodes())
assert(3 not in rule.rhs.nodes())
def test_add_rule_multiple_typing(self):
lhs = nx.DiGraph()
prim.add_nodes_from(lhs, [1, 2, 3, 4])
prim.add_edges_from(lhs, [(1, 3), (2, 3), (4, 3)])
p = nx.DiGraph()
prim.add_nodes_from(p, [1, 3, 31, 4])
prim.add_edges_from(p, [(1, 3), (1, 31), (4, 3), (4, 31)])
rhs = copy.deepcopy(p)
p_lhs = {1: 1, 3: 3, 31: 3, 4: 4}
p_rhs = {1: 1, 3: 3, 31: 31, 4: 4}
lhs_typing_g2 = {1: 1, 2: 1, 3: 2, 4: 4}
rhs_typing_g2 = {1: 1, 3: 2, 31: 2, 4: 4}
lhs_typing_g3 = {1: 1, 2: 1, 3: 1, 4: 2}
rhs_typing_g3 = {1: 1, 3: 1, 31: 1, 4: 2}
rule = Rule(p, lhs, rhs, p_lhs, p_rhs)
self.hierarchy.add_rule("r2", rule,
{"name": "Second rule: with multiple typing"})
self.hierarchy.add_rule_typing("r2", "g2", lhs_typing_g2,
rhs_typing_g2)
self.hierarchy.add_rule_typing("r2", "g3", lhs_typing_g3,
rhs_typing_g3)
pattern = nx.DiGraph()
prim.add_nodes_from(pattern, [1, 2])
prim.add_edges_from(pattern, [(2, 1)])
lhs_typing = {
"g0": {
1: "circle",
2: "circle"
},
"g00": {
1: "black",
2: "white"
}
}
p = nx.DiGraph()
prim.add_nodes_from(p, [1, 2, 21])
prim.add_edges_from(p, [(21, 1)])
rhs = copy.deepcopy(p)
p_lhs = {1: 1, 2: 2, 21: 2}
p_rhs = {1: 1, 2: 2, 21: 21}
rule = Rule(p, pattern, rhs, p_lhs, p_rhs)
rhs_typing = {
"g0": ({
1: "circle",
2: "circle",
21: "circle",
}),
"g00": ({
1: "black",
2: "white",
21: "white"
})
}
instances = self.hierarchy.find_matching("g1", pattern, lhs_typing)
self.hierarchy.rewrite("g1", rule, instances[0], rhs_typing=rhs_typing)
def test_refinement(self):
graph = NXGraph()
prim.add_nodes_from(graph, [
("a", {
"name": "Bob"
}),
("b", {
"name": "Jane"
}),
("c", {
"name": "Alice"
}),
("d", {
"name": "Joe"
}),
])
prim.add_edges_from(graph, [("a", "a", {
"type": "friends"
}), ("a", "b", {
"type": "enemies"
}), ("c", "a", {
"type": "colleages"
}), ("d", "a", {
"type": "siblings"
})])
pattern = NXGraph()
pattern.add_nodes_from(["x", "y"])
pattern.add_edges_from([("y", "x")])
instance = {"x": "a", "y": "d"}
# Remove node side-effects
rule = Rule.from_transform(NXGraph.copy(pattern))
rule.inject_remove_node("x")
new_instance = rule.refine(graph, instance)
assert (new_instance == {"x": "a", "y": "d", "b": "b", "c": "c"})
assert (prim.get_node(rule.lhs, "x") == prim.get_node(graph, "a"))
assert (prim.get_edge(rule.lhs, "x",
"b") == prim.get_edge(graph, "a", "b"))
assert (prim.get_edge(rule.lhs, "c",
"x") == prim.get_edge(graph, "c", "a"))
# Remove edge side-effects
rule = Rule.from_transform(NXGraph.copy(pattern))
rule.inject_remove_edge("y", "x")
new_instance = rule.refine(graph, instance)
assert (prim.get_edge(rule.lhs, "y",
"x") == prim.get_edge(graph, "d", "a"))
# Merge side-effects
rule = Rule.from_transform(NXGraph.copy(pattern))
rule.inject_merge_nodes(["x", "y"])
new_instance = rule.refine(graph, instance)
assert (new_instance == {"x": "a", "y": "d", "b": "b", "c": "c"})
assert (rule.lhs.get_node("x") == graph.get_node("a"))
assert (rule.lhs.get_node("y") == graph.get_node("d"))
assert (rule.lhs.get_edge("y", "x") == graph.get_edge("d", "a"))
# Combined side-effects
# Ex1: Remove cloned edge + merge with some node
graph.remove_edge("a", "a")
pattern.add_node("z")
pattern.add_edge("x", "z")
instance["z"] = "b"
rule = Rule.from_transform(NXGraph.copy(pattern))
p_node, _ = rule.inject_clone_node("x")
rule.inject_remove_node("z")
rule.inject_remove_edge("y", p_node)
rule.inject_merge_nodes([p_node, "y"])
new_instance = rule.refine(graph, instance)
assert (new_instance == {"x": "a", "y": "d", "z": "b", "c": "c"})
assert (prim.get_node(rule.lhs, "x") == prim.get_node(graph, "a"))
assert (prim.get_node(rule.lhs, "y") == prim.get_node(graph, "d"))
assert (prim.get_edge(rule.lhs, "y",
"x") == prim.get_edge(graph, "d", "a"))
# test with rule inversion
backup = NXGraph.copy(graph)
rhs_g = graph.rewrite(rule, new_instance)
inverted = rule.get_inverted_rule()
rhs_gg = graph.rewrite(inverted, rhs_g)
# print(rhs_gg)
old_node_labels = {v: new_instance[k] for k, v in rhs_gg.items()}
graph.relabel_nodes(old_node_labels)
assert (backup == graph)
def __init__(self):
"""Initialize test object."""
self.nx_graph = NXGraph()
try:
self.neo4j_graph = Neo4jGraph(uri="bolt://localhost:7687",
user="******",
password="******")
self.neo4j_graph._clear()
except:
warnings.warn("Neo4j is down, skipping Neo4j-related tests")
self.neo4j_graph = None
node_list = [("b", {
"name": "Bob",
"age": 20
}), ("a", {
"name": "Alice",
"age": 35
}), ("d", {
"name": "dummy"
})]
edge_list = [("a", "b", {
"type": "friends",
"since": 1999
}), ("d", "a"), ("b", "d")]
self.nx_graph.add_nodes_from(node_list)
self.nx_graph.add_edges_from(edge_list)
if self.neo4j_graph:
self.neo4j_graph.add_nodes_from(node_list)
self.neo4j_graph.add_edges_from(edge_list)
node = "c"
attrs = {"name": "Claire", "age": 66}
self.nx_graph.add_node(node, attrs)
if self.neo4j_graph:
self.neo4j_graph.add_node(node, attrs)
edge_attrs = {"type": "parent"}
self.nx_graph.add_edge("c", "b", edge_attrs)
if self.neo4j_graph:
self.neo4j_graph.add_edge("c", "b", edge_attrs)
self.nx_graph.remove_edge("d", "a")
if self.neo4j_graph:
self.neo4j_graph.remove_edge("d", "a")
self.nx_graph.remove_node("d")
if self.neo4j_graph:
self.neo4j_graph.remove_node("d")
self.nx_graph.update_node_attrs("a", {"name": "Alison"})
if self.neo4j_graph:
self.neo4j_graph.update_node_attrs("a", {"name": "Alison"})
self.nx_graph.update_edge_attrs("a", "b", {"type": "enemies"})
if self.neo4j_graph:
self.neo4j_graph.update_edge_attrs("a", "b", {"type": "enemies"})
self.nx_graph.set_node_attrs("a", {"age": 19}, update=False)
if self.neo4j_graph:
self.neo4j_graph.set_node_attrs("a", {"age": 19}, update=False)
self.nx_graph.set_edge_attrs("a", "b", {"since": 1945}, update=False)
if self.neo4j_graph:
self.neo4j_graph.set_edge_attrs("a",
"b", {"since": 1945},
update=False)
self.nx_graph.add_node_attrs("a", {"gender": {"M", "F"}})
if self.neo4j_graph:
self.neo4j_graph.add_node_attrs("a", {"gender": {"M", "F"}})
self.nx_graph.add_edge_attrs("a", "b", {"probability": 0.5})
if self.neo4j_graph:
self.neo4j_graph.add_edge_attrs("a", "b", {"probability": 0.5})
self.nx_graph.remove_node_attrs("a", {"gender": "F"})
if self.neo4j_graph:
self.neo4j_graph.remove_node_attrs("a", {"gender": "F"})
self.nx_graph.remove_edge_attrs("a", "b", {"probability": 0.5})
if self.neo4j_graph:
self.neo4j_graph.remove_edge_attrs("a", "b", {"probability": 0.5})
clone_id = self.nx_graph.clone_node("b", "b_clone")
if self.neo4j_graph:
self.neo4j_graph.clone_node("b", "b_clone")
# Test relabeling
self.nx_graph.relabel_node("b", "baba")
if self.neo4j_graph:
self.neo4j_graph.relabel_node("b", "baba")
self.nx_graph.relabel_node("baba", "b")
if self.neo4j_graph:
self.neo4j_graph.relabel_node("baba", "b")
self.nx_graph.relabel_nodes({
clone_id: "lala",
"b": "b1",
"a": "a1",
"c": "c1"
})
if self.neo4j_graph:
self.neo4j_graph.relabel_nodes({
clone_id: "lala",
"b": "b1",
"a": "a1",
"c": "c1"
})
self.nx_graph.relabel_nodes({
"b1": "b",
"a1": "a",
"c1": "c",
"lala": clone_id
})
if self.neo4j_graph:
self.neo4j_graph.relabel_nodes({
"b1": "b",
"a1": "a",
"c1": "c",
"lala": clone_id
})
self.nx_graph.merge_nodes(["b", "c"])
if self.neo4j_graph:
self.neo4j_graph.merge_nodes(["b", "c"])
self.nx_graph.copy_node("a", "a_copy")
if self.neo4j_graph:
self.neo4j_graph.copy_node("a", "a_copy")
# Test find matching
pattern = NXGraph()
pattern.add_nodes_from(["x", ("y", {"name": "Claire"}), "z"])
pattern.add_edges_from([("x", "y"), ("y", "y"), ("y", "z")])
instances1 = self.nx_graph.find_matching(pattern)
if self.neo4j_graph:
instances2 = self.neo4j_graph.find_matching(pattern)
assert (instances1 == instances2)
rule = Rule.from_transform(pattern)
p_n, r_n = rule.inject_clone_node("y")
rule.inject_remove_edge(p_n, "y")
rule.inject_remove_edge("y", "y")
rule.inject_add_node("w", {"name": "Frank"})
rule.inject_add_edge("w", r_n, {"type": "parent"})
rhs_g1 = self.nx_graph.rewrite(rule, instances1[0])
if self.neo4j_graph:
rhs_g2 = self.neo4j_graph.rewrite(rule, instances1[0])
self.nx_graph.relabel_node(rhs_g1[r_n], "b")
if self.neo4j_graph:
self.neo4j_graph.relabel_node(rhs_g2[r_n], "b")
self.nx_graph.relabel_node(rhs_g1["y"], "c")
if self.neo4j_graph:
self.neo4j_graph.relabel_node(rhs_g2["y"], "c")
# Test the two obtained graphs are the same
assert (self.nx_graph == self.neo4j_graph)
assert (set(self.nx_graph.predecessors("b")) == set(
self.neo4j_graph.predecessors("b")))
assert (set(self.nx_graph.successors("a")) == set(
self.neo4j_graph.successors("a")))
assert (
self.nx_graph.get_node("c") == self.neo4j_graph.get_node("c"))
assert (self.nx_graph.get_edge("c",
"b") == self.neo4j_graph.get_edge(
"c", "b"))
