def test_remove_edge(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.remove_edge(1, 2)
assert_graph_eq(rule.lhs, self.pattern)
assert(('d', 'a') in rule.p.edges())
assert(('s', 'x') in rule.rhs.edges())
return
def test_add_edge(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.add_edge(4, 2)
assert_graph_eq(rule.lhs, self.pattern)
assert_graph_eq(rule.p, self.p)
assert(('s', 'y') in rule.rhs.edges())
return
def test_update_node_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.update_node_attrs(4, {'b': 2})
assert(rule.p.node['d'] is None)
test_dict = {'b': {2}}
normalize_attrs(test_dict)
assert(rule.rhs.node['s'] == test_dict)
return
def test_add_edge_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.add_edge_attrs(4, 1, {'amazing': True})
assert_graph_eq(rule.p, self.p)
t = {'amazing': {True}}
normalize_attrs(t)
assert(rule.rhs.edge['s']['x'] == t)
return
def test_update_edge_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.update_edge_attrs(2, 3, {'b': 1})
assert(rule.p.edge['b']['c'] is None)
test_dict = {'b': FiniteSet({1})}
# normalize_attrs(test_dict)
assert(rule.rhs.edge['y']['z'] == test_dict)
return
def merge_node_list(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.merge_node_list([2, 3], 'wow_name')
assert(rule.lhs == self.pattern)
assert(rule.p == self.p)
assert('wow_name' in rule.rhs.nodes())
assert(('wow_name', 'wow_name') in rule.rhs.edges())
assert(('wow_name', 'y') in rule.rhs.edges())
def test_merge_nodes(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
new_name = rule.merge_nodes(1, 4)
assert_graph_eq(rule.lhs, self.pattern)
assert_graph_eq(rule.p, self.p)
assert(new_name in rule.rhs.nodes())
assert((new_name, new_name) in rule.rhs.edges())
assert((new_name, 'y') in rule.rhs.edges())
return
def test_add_node(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.add_node('g', {'a': 1})
assert_graph_eq(rule.p, self.p)
assert_graph_eq(rule.lhs, self.pattern)
assert('g' in rule.rhs)
t = {'a': set([1])}
normalize_attrs(t)
assert(rule.rhs.node['g'] == t)
return
def test_clone_node(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.clone_node(2)
assert_graph_eq(rule.lhs, self.pattern)
assert('b1' in rule.p.nodes())
assert('y1' in rule.rhs.nodes())
assert(('a', 'b1') in rule.p.edges())
assert(('b1', 'c') in rule.p.edges())
assert(('x', 'y1') in rule.rhs.edges())
assert(('t', 'y1') in rule.rhs.edges())
return
def test_remove_node(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.remove_node(2)
assert_graph_eq(rule.lhs, self.pattern)
assert('b' not in rule.p.nodes())
assert(('a', 'b') not in rule.p.edges())
assert(('b', 'c') not in rule.p.edges())
assert('y' not in rule.rhs.nodes())
assert(('x', 'y') not in rule.rhs.edges())
assert(('t', 'y') not in rule.rhs.edges())
assert(('y', 'z') not in rule.rhs.edges())
return
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_triangle_1(self):
h = Hierarchy()
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_irreversible_hierarchy(self):
hierarchy = NXHierarchy()
d = NXGraph()
d.add_nodes_from(["c1", "c2", "s1", "s2"])
hierarchy.add_graph("d", d)
s = NXGraph()
s.add_nodes_from(["c", "s"])
hierarchy.add_graph("s", s)
hierarchy.add_typing(
"d", "s", {
"c1": "c",
"c2": "c",
"s1": "s",
"s2": "s"
})
h = VersionedHierarchy(hierarchy)
pattern = NXGraph()
pattern.add_nodes_from(["c1", "s1"])
rule = Rule.from_transform(pattern)
rule.inject_merge_nodes(["c1", "s1"])
instance = {
"c1": "c1",
"s1": "s1"
}
h.rewrite("d", rule, instance)
h.rollback(h.initial_commit())
print(h.hierarchy.get_typing("d", "s"))
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_remove_edge_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.remove_edge_attrs(2, 3, {'a': set()})
t1 = {'a': {1}}
normalize_attrs(t1)
assert(rule.p.edge['b']['c'] == t1)
assert(rule.rhs.edge['y']['z'] == t1)
rule.remove_edge_attrs(2, 3, {'a': {1}})
t2 = {'a': set()}
normalize_attrs(t2)
print(t2)
print(rule.p.edge['b']['c'])
assert(rule.p.edge['b']['c'] == t2)
assert(rule.rhs.edge['y']['z'] == t2)
return
def process_json(json_data, directed=True):
rule = Rule.from_json(json_data["rule"], directed)
if "attrs" not in json_data.keys():
attrs = dict()
else:
attrs = AttributeContainter.attrs_from_json(json_data["attrs"])
return rule, attrs
def clone_node(hie, g_id, parent, node, new_name, propagate=False):
"""Create a clone of a node. If propagate is True, also clone all the nodes typed by it"""
if isinstance(hie.node[g_id], GraphNode):
if new_name in hie.node[g_id].graph.nodes():
raise ValueError("node {} already in graph".format(new_name))
if propagate:
lhs = nx.DiGraph()
lhs.add_node(node)
ppp = nx.DiGraph()
ppp.add_node(node)
ppp.add_node(new_name)
rhs = nx.DiGraph()
rhs.add_node(node)
rhs.add_node(new_name)
rule = Rule(ppp, lhs, rhs, {node: node, new_name: node}, None)
_rewrite(hie, g_id, rule, {node: node})
else:
prim.clone_node(hie.node[g_id].graph, node, new_name)
for _, typing in hie.out_edges(g_id):
mapping = hie.edge[g_id][typing].mapping
if node in mapping.keys():
mapping[new_name] = mapping[node]
elif isinstance(hie.node[g_id], RuleNode):
hie.node[g_id].rule.clone_rhs_node(node, new_name)
for _, typing in hie.out_edges(g_id):
mapping = hie.edge[g_id][typing].rhs_mapping
if node in mapping:
mapping[new_name] = mapping[node]
else:
raise ValueError("node is neither a rule nor a graph")
def rm_node(hie, g_id, parent, node_id, force=False):
"""remove a node from a graph """
if isinstance(hie.node[g_id], GraphNode):
if [
c for c in all_children(hie, g_id)
if node_id in hie.edge[c][g_id].mapping.values()
]:
if not force:
raise ValueError("some nodes are typed by {}"
"set the force argument to"
"delete the as well".format(node_id))
lhs = nx.DiGraph()
lhs.add_node(node_id)
ppp = nx.DiGraph()
rhs = nx.DiGraph()
rule = Rule(ppp, lhs, rhs)
_rewrite(hie, g_id, rule, {node_id: node_id})
elif isinstance(hie.node[g_id], RuleNode):
hie.node[g_id].rule.remove_node_rhs(node_id)
for _, typing in hie.out_edges(g_id):
if node_id in hie.edge[g_id][typing].rhs_mapping.keys():
del hie.edge[g_id][typing].rhs_mapping[node_id]
else:
raise ValueError("node is neither a rule nor a graph")
def test_rewrite(self):
pattern = nx.DiGraph()
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 = nx.DiGraph()
add_nodes_from(p, [
(1, {'state': 'p'}),
(2, {'name': 'BND'}),
3,
4
])
p.add_edges_from([
(1, 2),
(3, 4)
])
rhs = nx.DiGraph()
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, {}, {}, {})
rule.apply_to(self.graph, instances[0], rule)
def test_rewrite(self):
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()
p.add_nodes_from([1, 2, 3])
p.add_edges_from([(2, 3)])
rhs = nx.DiGraph()
prim.add_nodes_from(
rhs, [1, (2, {
"a": {3, 5}
}), (3, {
"new_attrs": {1}
}), 4])
prim.add_edges_from(rhs, [(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.hierarchy.find_matching("g1", pattern, lhs_typing)
# print(instances[0])
self.hierarchy.rewrite("g1", rule, instances[0], lhs_typing,
rhs_typing)
def test_add_node_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.add_node_attrs(1, {'a': 1})
t1 = {'a': {1}}
t2 = {'a': {1, 2}}
t3 = {'a': {1, 2}, 'b': {1}}
normalize_attrs(t1)
normalize_attrs(t2)
normalize_attrs(t3)
assert(rule.rhs.node['x'] == t1)
rule.add_node_attrs(4, {'a': 1})
assert(rule.rhs.node['s'] == t1)
rule.add_node_attrs(4, {'a': 2})
assert(rule.rhs.node['s'] == t2)
rule.add_node_attrs(4, {'b': 1})
assert(rule.rhs.node['s'] == t3)
return
def _create_identity_delta():
"""Create an identity-delta."""
rule = Rule.identity_rule()
identity_delta = {
"rule": rule,
"lhs_instance": {},
"rhs_instance": {}
}
return identity_delta
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 _delta_from_json(json_data):
delta = {}
delta["rule_hierarchy"] = {
"rules": {},
"rule_homomorphisms": json_data["rule_hierarchy"]["rule_homomorphisms"]
}
for graph, rule in json_data["rule_hierarchy"]["rules"].items():
delta["rule_hierarchy"]["rules"][graph] = Rule.from_json(rule)
delta["lhs_instances"] = json_data["lhs_instances"]
delta["rhs_instances"] = json_data["rhs_instances"]
return delta
def test_rewrite(self):
pattern = nx.DiGraph()
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 = nx.DiGraph()
add_nodes_from(p, [(1, {'state': 'p'}), (2, {'name': 'BND'}), 3, 4])
p.add_edges_from([(1, 2), (3, 4)])
rhs = nx.DiGraph()
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, {}, {}, {})
rule.apply_to(self.graph, instances[0], rule)
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_porpagation_node_attrs_adds(self):
p = nx.DiGraph()
primitives.add_nodes_from(
p, [1, 2]
)
lhs = nx.DiGraph()
primitives.add_nodes_from(
lhs, [1, 2]
)
rhs = nx.DiGraph()
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, lhs_typing=None, rhs_typing=rhs_typing)
raise ValueError("Error was not caught!")
except RewritingError:
pass
new_hierarchy, _ = self.hierarchy.rewrite(
"n1", rule, instance,
lhs_typing=None, rhs_typing=rhs_typing,
strict=False, inplace=False)
# test propagation of the node attribute adds
assert("a1" in new_hierarchy.graph["n1"].node["A"])
assert("a2" in new_hierarchy.graph["n1"].node["A_res_1"])
assert("a3" in new_hierarchy.graph["n1"].node[3])
assert("a1" in new_hierarchy.graph["ag"].node["A"])
assert("a2" in new_hierarchy.graph["ag"].node["A_res_1"])
assert("a3" in new_hierarchy.graph["ag"].node[3])
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 remove_attributes(hie, g_id, parent, node, json_attrs):
"""remove the attributes from json_attrs from the node"""
attrs = prim.json_dict_to_attrs(json_attrs)
if isinstance(hie.node[g_id], GraphNode):
lhs = nx.DiGraph()
lhs.add_node(node)
add_node_attrs(lhs, node, attrs)
ppp = nx.DiGraph()
ppp.add_node(node)
rhs = nx.DiGraph()
rhs.add_node(node)
rule = Rule(ppp, lhs, rhs)
_rewrite(hie, g_id, rule, {node: node})
elif isinstance(hie.node[g_id], RuleNode):
hie.node[g_id].rule.remove_node_attrs_rhs(node, attrs)
else:
raise ValueError("node is neither a rule nor a graph")
def test_remove_node_attrs(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.add_node_attrs(4, {'a': 2})
rule.remove_node_attrs(4, {'a': 1})
t1 = {'a': set()}
t2 = {'a': set([2])}
normalize_attrs(t1)
normalize_attrs(t2)
assert(rule.p.node['d'] == t1)
assert(rule.rhs.node['s'] == t2)
return
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.edge[1][2])
new_p_node, new_rhs_node = rule.inject_clone_node(2)
assert ("a12" not in rule.p.edge[1][new_p_node])
rule.inject_remove_edge_attrs(3, new_p_node, {"a32": {True}})
assert ("a32" in rule.p.edge[3][2])
assert ("a32" not in rule.p.edge[3][new_p_node])
assert ("a32" in rule.rhs.edge[3][rule.p_rhs[2]])
assert ("a32" not in rule.rhs.edge[3][new_rhs_node])
def new_rule(hie, parent, name, pattern_name=None):
"""create a new rule """
if valid_child_name(hie, parent, name):
if pattern_name is None:
pattern = nx.DiGraph()
else:
pattern_id = child_from_name(hie, parent, pattern_name)
pattern = hie.node[pattern_id].graph
rule_id = hie.unique_graph_id(name)
rule = Rule(pattern, pattern, pattern)
hie.add_rule(rule_id, rule, {"name": name})
if parent is not None:
if pattern_name is None:
hie.add_rule_typing(rule_id, parent, {}, {})
else:
mapping = hie.edge[pattern_id][parent].mapping
hie.add_rule_typing(rule_id, parent, mapping, mapping)
else:
raise ValueError("Invalid new name")
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.remove_node(1)
rule.remove_edge(2, 3)
new_name, _ = rule.clone_node(2)
print(new_name)
rule.remove_node_attrs(3, {"a3": {3}})
rule.remove_edge_attrs(3, 2, {"a32": {32}})
rule.add_node_attrs(3, {"a3": {100}})
rule.add_node(4)
rule.add_edge_rhs(4, "21")
assert(rule.removed_nodes() == {1})
print(rule.removed_edges())
assert(rule.removed_edges() == {(2, 3), (new_name[0], 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_add_relation(self):
self.hierarchy.add_relation(
"a1", "a2",
[
("white_circle", "right_circle"),
("white_square", "middle_square"),
("black_circle", "left_circle"),
("black_circle", "right_circle")
],
{"name": "Some relation"}
)
# print(self.hierarchy.relations())
# print(self.hierarchy.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.clone_node("s")
# instances = self.hierarchy.find_matching(
# "base",
# rule.lhs
# )
new_hierarchy, _ = self.hierarchy.rewrite(
"base",
rule,
{"s": "square", "c": "circle"},
inplace=False
)
g, l, r = new_hierarchy.relation_to_span(
"a1", "a2"
)
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_triangle_1(self):
h = Hierarchy()
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"
},
total=True
)
h.add_typing(
"g3", "g1",
{
"1x": "1",
"1y": "1",
"2x": "2",
"2y": "2"
},
total=True
)
h.add_typing(
"g2", "g3",
{
"1a": "1x",
"1b": "1y",
"2a": "2y",
"2b": "2x"
},
total=True
)
pattern = nx.DiGraph()
pattern.add_nodes_from([
1, 2
])
rule = Rule.from_transform(pattern)
rule.remove_node(1)
rule.clone_node(2)
instances = h.find_matching("g1", pattern)
new_h, _ = h.rewrite("g1", rule, instances[0], inplace=False)
def test_all(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.clone_node(2)
rule.remove_node(1)
def test_remove_non_existing_edge(self):
rule = Rule(self.p, self.pattern, self.rhs,
self.p_lhs, self.p_rhs)
rule.remove_edge(3, 2)
return
