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 = NXGraph() lhs.add_nodes_from(["s", "c"]) rule = Rule.from_transform(lhs) rule.inject_clone_node("s") # instances = self.hierarchy.find_matching( # "base", # rule.lhs # ) self.hierarchy.rewrite("base", rule, {"s": "square", "c": "circle"})
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_clone_node(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(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_create_merging_rule(test): # Create a rule pattern = nx.DiGraph() pattern.add_nodes_from(["circle", "square", "triangle"]) rule = Rule.from_transform(pattern) rule.inject_remove_node("triangle") rule.inject_add_node("diamond") p_name, rhs_name = rule.inject_clone_node("circle") rhs_name = rule.inject_merge_nodes([p_name, "square"]) lhs_instance = { "circle": "Bob", "square": "Alice", "triangle": "Cat" } rhs_instance = { "circle": "Bob", rhs_name: "Josh", "diamond": "Harry" } rule1, rule2 = _create_merging_rule( rule, lhs_instance, rhs_instance) print(rule1) print(rule2)
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_triangle_1(self): h = self._generate_triangle_hierarchy() pattern = NXGraph() 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) h.rewrite("g1", rule, instances[0])
def test_inject_remove_node(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(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_remove_edge(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(1, 2), (3, 2)]) rule = Rule.from_transform(pattern) rule.inject_remove_edge(3, 2) check_homomorphism(rule.p, rule.lhs, rule.p_lhs) check_homomorphism(rule.p, rule.rhs, rule.p_rhs) assert ((3, 2) not in rule.p.nodes()) new_name, _ = rule.inject_clone_node(2) rule.inject_remove_edge(1, new_name) check_homomorphism(rule.p, rule.lhs, rule.p_lhs) check_homomorphism(rule.p, rule.rhs, rule.p_rhs) assert ((1, new_name) not in rule.p.edges()) assert ((1, 2) in rule.p.edges())
def test_inject_add_node(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(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_add_edge(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(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)
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 = NXGraph() 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_rhs_name in rule.rhs.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_controlled_up_propagation(self): pattern = nx.DiGraph() 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": {}, "A_hello": {p_clone} }, "n1": { "A": p_clone } } instance = {"A": "A"} nugget_1 = nx.DiGraph() 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, _ = self.hierarchy.rewrite("ag", rule, instance, p_typing=p_typing, inplace=False) primitives.print_graph(new_hierarchy.get_graph("nn1")) print(new_hierarchy.typing["nn1"]["n1"])
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_inject_remove_edge_attrs(self): pattern = NXGraph() pattern.add_nodes_from([1, 2, 3]) pattern.add_edges_from([(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.get_edge(1, 2)) new_p_node, new_rhs_node = rule.inject_clone_node(2) assert ("a12" not in rule.p.get_edge(1, new_p_node)) rule.inject_remove_edge_attrs(3, new_p_node, {"a32": {True}}) assert ("a32" in rule.p.get_edge(3, 2)) assert ("a32" not in rule.p.get_edge(3, new_p_node)) assert ("a32" in rule.rhs.get_edge(3, rule.p_rhs[2])) assert ("a32" not in rule.rhs.get_edge(3, new_rhs_node))
def test_inject_remove_node_attrs(self): pattern = NXGraph() pattern.add_nodes_from([1, (2, {"a2": {True}}), (3, {"a3": {False}})]) pattern.add_edges_from([(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.get_node(3)) assert ("a3" in rule.lhs.get_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.get_node(new_p_node)) assert ("a2" in rule.p.get_node(2)) assert ("a2" not in rule.rhs.get_node(new_rhs_node)) assert ("a2" in rule.rhs.get_node(2))
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_inject_add_node_attrs(self): pattern = NXGraph() 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.get_node(2)) rule.inject_add_node_attrs(clone_name_p, {"b": {True}}) assert ("b" in rule.rhs.get_node(clone_name_rhs)) assert ("b" not in rule.rhs.get_node(2)) rule.inject_add_node_attrs(4, {"c": {True}}) assert ("c" in rule.rhs.get_node(4)) rule.inject_add_node_attrs(merge, {"d": {True}}) assert ("d" in rule.rhs.get_node(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_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_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_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_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_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 = nx.DiGraph() 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, 1, {"a": {True}}) assert("a" in rule.rhs.adj[0][merge]) rule.inject_add_edge_attrs(0, clone_name_p, {"b": {True}}) assert("b" in rule.rhs.adj[0][clone_name_rhs]) rule.inject_add_edge_attrs(merge, clone_name_p, {"c": {True}}) assert("c" in rule.rhs.adj[merge][clone_name_rhs]) assert("c" not in rule.rhs.adj[merge][2]) rule.inject_add_edge_attrs(4, merge, {"d": {True}}) assert("d" in rule.rhs.adj[4][merge]) check_homomorphism(rule.p, rule.lhs, rule.p_lhs) check_homomorphism(rule.p, rule.rhs, rule.p_rhs)
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()))
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_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 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 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 __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"))