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_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_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_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_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.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 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_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_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_graph_rollback(self):
g = VersionedGraph(self.initial_graph)
# Branch 'test'
g.branch("test")
pattern = NXGraph()
pattern.add_node("square")
rule = Rule.from_transform(pattern)
# _, rhs_clone =
rule.inject_clone_node("square")
g.rewrite(
rule, {"square": "square"},
"Clone square")
# Switch to master
g.switch_branch("master")
print("\n\n\nasserting...............")
for s, t in g._revision_graph.edges():
print(g._revision_graph.nodes[s]["message"])
print(g._revision_graph.nodes[t]["message"])
d = g._revision_graph.adj[s][t]["delta"]
assert(
set(d["rule"].rhs.nodes()) ==
set(d["rhs_instance"].keys())
)
# Add edge and triangle
pattern = NXGraph()
pattern.add_nodes_from(["circle"])
rule = Rule.from_transform(pattern)
# _, rhs_clone =
rule.inject_add_edge("circle", "circle")
rule.inject_add_node("triangle")
rule.inject_add_edge("triangle", "circle")
rhs_instance, _ = g.rewrite(
rule, {"circle": "circle"},
"Add edge to circle and triangle")
triangle = rhs_instance["triangle"]
# Clone circle
pattern = NXGraph()
pattern.add_node("circle")
rule = Rule.from_transform(pattern)
_, rhs_clone = rule.inject_clone_node("circle")
rhs_instance, rollback_commit = g.rewrite(
rule, {"circle": "circle"},
"Clone circle")
rhs_circle_clones = list({
rule.p_rhs[p] for p in rule.cloned_nodes()["circle"]
})
# Remove original circle
pattern = NXGraph()
pattern.add_node("circle")
rule = Rule.from_transform(pattern)
rule.inject_remove_node("circle")
rhs_instance, _ = g.rewrite(
rule,
{"circle": rhs_instance[rhs_circle_clones[0]]},
message="Remove circle")
# Merge circle clone and triangle
pattern = NXGraph()
pattern.add_nodes_from(["circle", "triangle"])
rule = Rule.from_transform(pattern)
rule.inject_merge_nodes(["circle", "triangle"])
rhs_instance, _ = g.rewrite(
rule,
{
"circle": rhs_instance[rhs_clone],
"triangle": triangle
},
message="Merge circle and triangle")
g.print_history()
g.rollback(rollback_commit)
g.merge_with("test")
def test_neo4j_hierarchy_versioning(self):
"""Test hierarchy versioning functionality."""
try:
hierarchy = Neo4jHierarchy(uri="bolt://localhost:7687",
user="******",
password="******")
hierarchy._clear()
hierarchy.add_graph("shapes",
node_list=[("c", {
"a": 1
}), ("s", {
"b": 2
})])
hierarchy.add_graph("colors",
node_list=[("w", {
"a": 1,
"b": 2
}), ("b", {
"a": 1,
"b": 2
})])
hierarchy.add_graph("ag",
node_list=[("wc", {
"a": 1
}), "bc", "ws", ("bs", {
"b": 2
})])
hierarchy.add_graph("nugget",
node_list=[("wc1", {
"a": 1
}), "wc2", "bc1", "ws1", ("bs2", {
"b": 2
})])
hierarchy.add_typing("ag", "shapes", {
"wc": "c",
"bc": "c",
"ws": "s",
"bs": "s"
})
hierarchy.add_typing("ag", "colors", {
"wc": "w",
"bc": "b",
"ws": "w",
"bs": "b"
})
hierarchy.add_typing("nugget", "ag", {
"wc1": "wc",
"wc2": "wc",
"bc1": "bc",
"ws1": "ws",
"bs2": "bs"
})
hierarchy.add_typing("nugget", "colors", {
"wc1": "w",
"wc2": "w",
"bc1": "b",
"ws1": "w",
"bs2": "b"
})
hierarchy.add_graph("base", node_list=[("node", {"a": 1, "b": 2})])
hierarchy.add_typing("colors", "base", {"w": "node", "b": "node"})
pattern = nx.DiGraph()
pattern.add_nodes_from(["s", "c"])
rule = Rule.from_transform(pattern)
rule.inject_add_edge("s", "c", {"c": 3})
hierarchy.rewrite("nugget", rule, {"s": "bs2", "c": "wc1"})
h = VersionedHierarchy(hierarchy)
rollback_commit = h._heads["master"]
pattern = nx.DiGraph()
primitives.add_nodes_from(pattern, [("s", {
"b": 2
}), ("c", {
"a": 1
})])
primitives.add_edges_from(pattern, [("s", "c", {"c": 3})])
rule2 = Rule.from_transform(pattern)
clone, _ = rule2.inject_clone_node("s")
rule2.inject_add_node("new_node")
rule2.inject_add_edge("new_node", "s", {"d": 4})
merged_rule_node = rule2.inject_merge_nodes([clone, "c"])
rule2.inject_remove_edge("s", "c")
rhs_instances, first_commit = h.rewrite(
"ag",
rule2, {
"s": "bs",
"c": "wc"
},
message="Rewriting neo4j graph")
merged_ag_node = rhs_instances["ag"][merged_rule_node]
h.branch('test')
pattern = nx.DiGraph()
pattern.add_nodes_from(["ws"])
rule3 = Rule.from_transform(pattern)
rule3.inject_remove_node("ws")
h.rewrite("ag", rule3, {"ws": "ws"}, message="Removed ws from ag")
h.switch_branch("master")
pattern = nx.DiGraph()
pattern.add_nodes_from([merged_ag_node])
rule4 = Rule.from_transform(pattern)
rule4.inject_clone_node(merged_ag_node)
h.rewrite("ag",
rule4, {merged_ag_node: merged_ag_node},
message="Cloned merged from ag")
h.merge_with("test")
data = h.to_json()
h1 = VersionedHierarchy.from_json(hierarchy, data)
h1.print_history()
h1.rollback(rollback_commit)
# except ServiceUnavailable as e:
# print(e)
except:
print()
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_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 apply_mod_semantics(corpus, nugget_id):
"""Apply mod semantics to the created nugget."""
template_rel = corpus._hierarchy.get_relation("mod_template", nugget_id)
bnd_template_rel = None
if "bnd_template" in corpus._hierarchy.adjacent_relations(nugget_id):
bnd_template_rel = corpus._hierarchy.get_relation(
"bnd_template", nugget_id)
enzyme = None
if "enzyme" in template_rel.keys():
enzyme = list(template_rel["enzyme"])[0]
if enzyme is None:
return None
mod_state = None
if "mod_state" in template_rel.keys():
mod_state = list(template_rel["mod_state"])[0]
mod_residue = None
if "substrate_residue" in template_rel.keys():
mod_residue = list(template_rel["substrate_residue"])[0]
mod_node = list(template_rel["mod"])[0]
ag_enzyme = None
ag_typing = corpus._hierarchy.get_typing(nugget_id,
corpus._action_graph_id)
if enzyme is not None:
ag_enzyme = ag_typing[enzyme]
enzyme_uniprot = corpus.get_uniprot(ag_enzyme)
ag_mod_node = ag_typing[mod_node]
ag_bnd_node = None
bnd_node = None
if bnd_template_rel:
bnd_node = list(bnd_template_rel["bnd"])[0]
ag_bnd_node = ag_typing[bnd_node]
ag_sag_rel = corpus._hierarchy.get_relation(corpus._action_graph_id,
"semantic_action_graph")
phospho = False
nugget = corpus.get_nugget(nugget_id)
if enzyme is not None and mod_state is not None:
if "phosphorylation" in nugget.get_node(mod_state)["name"]:
if True in nugget.get_node(mod_node)["value"]:
phospho = True
# elif False in nugget.get_node(mod_node)["test"]:
# dephospho = True
# 1. Phospho semantics
if phospho:
phospho_semantic_rel = {
"mod": "phospho",
mod_state: "phospho_state",
}
if mod_residue is not None:
phospho_semantic_rel[mod_residue] = "phospho_target_residue"
if bnd_node:
phospho_semantic_rel[bnd_node] = "protein_kinase_bnd"
if "enzyme_region" in template_rel.keys():
# Enzyme region is specified in the nugget
enz_region = list(template_rel["enzyme_region"])[0]
ag_enz_region = ag_typing[enz_region]
if ag_enz_region in ag_sag_rel.keys() and\
"protein_kinase" in ag_sag_rel[ag_enz_region]:
# This enzyme region is typed by the protein kinase
# in the action graph
phospho_semantic_rel[enz_region] = "protein_kinase"
# 1. MOD action merge
kinase_mods =\
corpus.ag_successors_of_type(
ag_enz_region, "mod")
if len(kinase_mods) > 1:
pattern = NXGraph()
pattern.add_nodes_from([ag_enz_region] + kinase_mods)
mod_merge_rule = Rule.from_transform(pattern)
new_mod_id = mod_merge_rule.inject_merge_nodes(kinase_mods)
message = (
"Merged modification actions ({}) ".format(kinase_mods)
+ "of the protein kinase {} ".format(
_generate_fragment_repr(corpus, ag_enzyme,
ag_enz_region)) +
"of the protoform with the UniProt AC '{}'".format(
enzyme_uniprot))
rhs_ag = corpus.rewrite(
corpus._action_graph_id,
mod_merge_rule,
instance={n: n
for n in mod_merge_rule.lhs.nodes()},
message=message,
update_type="auto")
# 1.5 BND action merge
if bnd_template_rel:
kinase_bnds =\
corpus.ag_successors_of_type(
ag_enz_region, "bnd")
if len(kinase_bnds) > 1:
pattern = NXGraph()
pattern.add_nodes_from([ag_enz_region] + kinase_bnds)
bnd_merge_rule = Rule.from_transform(pattern)
new_mod_id = bnd_merge_rule.inject_merge_nodes(
kinase_bnds)
message = (
"Merged binding actions ({}) ".format(kinase_bnds)
+ "of the protein kinase {} ".format(
_generate_fragment_repr(
corpus, ag_enzyme, ag_enz_region)) +
"of the protoform with the UniProt AC '{}'".format(
enzyme_uniprot))
rhs_ag = corpus.rewrite(
corpus._action_graph_id,
bnd_merge_rule,
instance={
n: n
for n in bnd_merge_rule.lhs.nodes()
},
message=message,
update_type="auto")
# 2. Autocompletion
enz_region_predecessors = nugget.predecessors(enz_region)
# Check if kinase activity is specified in the nugget
activity_found = False
for pred in enz_region_predecessors:
ag_pred = ag_typing[pred]
ag_pred_type = corpus.get_action_graph_typing()[ag_pred]
pred_attrs = nugget.get_node(pred)
if ag_pred_type == "state" and\
"activity" in pred_attrs["name"] and\
True in pred_attrs["test"]:
phospho_semantic_rel[pred] = "protein_kinase_activity"
activity_found = True
break
if activity_found is False:
# If activity is not specified, we autocomplete
# nugget with it
autocompletion_rule = Rule.from_transform(nugget)
new_activity_state = "{}_activity".format(enzyme)
autocompletion_rule.inject_add_node(
new_activity_state, {
"name": "activity",
"test": True
})
autocompletion_rule.inject_add_edge(
new_activity_state, enz_region)
# identify if there already exists the activity state
# in the action graph
rhs_typing = {corpus._action_graph_id: {}}
ag_activity = corpus.get_activity_state(ag_enz_region)
if ag_activity is not None:
rhs_typing[corpus._action_graph_id][new_activity_state] =\
ag_activity
# Apply autocompletion rule
message = (
"Autocompleted the nugget '{}' ".format(nugget_id) +
"with an activity state "
"of the protein kinase {} ".format(
_generate_fragment_repr(corpus, ag_enzyme,
ag_enz_region)) +
"of the protoform with the UniProt AC '{}'".format(
enzyme_uniprot))
rhs_g = corpus.rewrite(nugget_id,
autocompletion_rule,
rhs_typing=rhs_typing,
message=message,
update_type="auto")
phospho_semantic_rel[rhs_g[new_activity_state]] =\
"protein_kinase_activity"
else:
# Phosphorylation is performed by the region not
# identified as a protein kinase
warnings.warn(
"Region '{}' performing phosphorylation is not "
"a protein kinase region".format(ag_enz_region),
KamiHierarchyWarning)
elif "enzyme_site" in template_rel:
pass
else:
# Enzyme region is NOT specified in the nugget
enz_region = None
# Search for the unique kinase region associated
# with respective protoform in the action graph
unique_kinase_region =\
corpus.unique_kinase_region(ag_enzyme)
if unique_kinase_region is not None:
# 1. MOD action merge
kinase_mods =\
corpus.ag_successors_of_type(
unique_kinase_region, "mod")
# 1.5 BND action merge
kinase_bnds = []
if bnd_template_rel:
kinase_bnds =\
corpus.ag_successors_of_type(
unique_kinase_region, "bnd")
pattern = NXGraph()
pattern.add_nodes_from([ag_mod_node, ag_enzyme])
pattern.add_edges_from([(ag_enzyme, ag_mod_node)])
if ag_bnd_node:
pattern.add_nodes_from([ag_bnd_node])
pattern.add_edges_from([(ag_enzyme, ag_bnd_node)])
mod_merge_rule = Rule.from_transform(pattern)
mod_merge_rule.inject_remove_edge(ag_enzyme, ag_mod_node)
if ag_bnd_node:
mod_merge_rule.inject_remove_edge(ag_enzyme, ag_bnd_node)
merged_actions_str = []
merged_mods = None
if len(kinase_mods) > 0:
# generate a rule that merges mods
for n in kinase_mods:
mod_merge_rule._add_node_lhs(n)
merged_mods = [ag_mod_node] + kinase_mods
new_mod_id = mod_merge_rule.inject_merge_nodes(merged_mods)
merged_actions_str.append(
"merged MOD-mechanisms {}".
format(merged_mods) if merged_mods else "")
merged_bnds = None
if len(kinase_bnds) > 0:
for n in kinase_bnds:
mod_merge_rule._add_node_lhs(n)
merged_bnds = [ag_bnd_node] + kinase_bnds
new_bnd_id = mod_merge_rule.inject_merge_nodes(merged_bnds)
merged_actions_str.append(
"merged BND-mechanisms {}".
format(merged_bnds) if merged_bnds else "")
message = (
"Rewired phosphorylation ('{}') to be mediated by ".format(
ag_mod_node) +
"the existing protein kinase {} ".format(
_generate_fragment_repr(corpus, ag_enzyme,
unique_kinase_region)) +
"of the protoform with the UniProt AC '{}' {}".format(
enzyme_uniprot,
"({})".format(", ".join(merged_actions_str))
if len(merged_actions_str) > 0 else ""))
rhs_ag = corpus.rewrite(
corpus._action_graph_id,
mod_merge_rule,
instance={n: n
for n in mod_merge_rule.lhs.nodes()},
message=message,
update_type="auto")
# 2. Autocompletion
if len(kinase_mods) > 0:
new_ag_mod = rhs_ag[new_mod_id]
else:
new_ag_mod = ag_mod_node
if len(kinase_bnds) > 0:
new_ag_bnd = rhs_ag[new_bnd_id]
else:
new_ag_bnd = ag_bnd_node
autocompletion_rule = Rule.from_transform(nugget)
autocompletion_rule.inject_add_node(
unique_kinase_region,
corpus.action_graph.get_node(unique_kinase_region))
activity_state = "{}_activity".format(unique_kinase_region)
autocompletion_rule.inject_add_node(activity_state, {
"name": "activity",
"test": True
})
autocompletion_rule.inject_add_edge(unique_kinase_region,
enzyme)
autocompletion_rule.inject_add_edge(unique_kinase_region,
mod_node)
autocompletion_rule.inject_add_edge(activity_state,
unique_kinase_region)
rhs_typing = {
corpus._action_graph_id: {
unique_kinase_region: unique_kinase_region,
mod_node: new_ag_mod,
}
}
if ag_bnd_node:
rhs_typing[corpus._action_graph_id][bnd_node] = new_ag_bnd
ag_activity = corpus.get_activity_state(unique_kinase_region)
if ag_activity is not None:
rhs_typing[
corpus._action_graph_id][activity_state] = ag_activity
message = ("Autocompleted the nugget '{}' ".format(nugget_id) +
"with the protein kinase {} ".format(
_generate_fragment_repr(corpus, ag_enzyme,
unique_kinase_region)) +
"of the protoform with the UniProt AC '{}'".format(
enzyme_uniprot))
rhs_nugget = corpus.rewrite(
nugget_id,
autocompletion_rule,
instance={n: n
for n in autocompletion_rule.lhs.nodes()},
rhs_typing=rhs_typing,
message=message,
update_type="auto")
enz_region = rhs_nugget[unique_kinase_region]
phospho_semantic_rel[rhs_nugget[unique_kinase_region]] =\
"protein_kinase"
for k, v in corpus._hierarchy.get_typing(
nugget_id, corpus._action_graph_id).items():
if v == ag_activity:
nugget_activity = k
phospho_semantic_rel[rhs_nugget[activity_state]] =\
"protein_kinase_activity"
corpus._hierarchy.set_node_relation(nugget_id, "mod_template",
enz_region,
"enzyme_region")
else:
# The repective protoform in the action graph contains
# either no or multiple kinase regions
warnings.warn(
"Could not find the unique protein kinase "
"region associated with the protoform '%s'" % ag_enzyme,
KamiHierarchyWarning)
# Add a relation to the phosporylation semantic nugget
corpus.add_semantic_nugget_rel(nugget_id,
"phosphorylation_semantic_nugget",
phospho_semantic_rel)
# propagate this phospho semantics to the ag nodes
_propagate_semantics_to_ag(corpus, nugget_id,
"phosphorylation_semantic_nugget")
def _apply_sh2_py_semantics(region_node,
region_bnd,
partner_gene,
partner_region=None,
partner_site=None):
ag_typing = corpus._hierarchy.get_typing(nugget_id,
corpus._action_graph_id)
ag_region = ag_typing[region_node]
ag_protoform = corpus.get_protoform_of(ag_region)
protoform_uniprot = corpus.get_uniprot(ag_protoform)
ag_sag_relation = corpus._hierarchy.get_relation(
corpus._action_graph_id, "semantic_action_graph")
if ag_region in ag_sag_relation.keys() and\
"sh2_domain" in ag_sag_relation[ag_region]:
sh2_semantic_rel = {
region_node: "sh2_domain",
region_bnd: "sh2_domain_pY_bnd",
}
# Check if there are multiple bnd actions associated with the
# same SH2 domain, merge them if it's the case
ag_region_bnds = []
for bnd in corpus.ag_successors_of_type(ag_region, "bnd"):
ag_region_bnds.append(bnd)
if len(ag_region_bnds) > 1:
# generate a rule that merges bnds and loci
pattern = NXGraph()
pattern.add_nodes_from(ag_region_bnds)
bnd_merge_rule = Rule.from_transform(pattern)
bnd_merge_rule.inject_merge_nodes(ag_region_bnds)
message = (
"Merged binding actions ({}) ".format(ag_region_bnds) +
"of the SH2 {} ".format(
_generate_fragment_repr(corpus, ag_protoform,
ag_region)) +
"of the protoform with the UniProt AC '{}'".format(
protoform_uniprot))
corpus.rewrite(corpus._action_graph_id,
bnd_merge_rule,
message=message,
update_type="auto")
# Process/autocomplete pY sites and Y residues
if partner_site:
ag_partner_site = ag_typing[partner_site]
ag_partner_protoform = corpus.get_protoform_of(ag_partner_site)
partner_uniprot = corpus.get_uniprot(ag_partner_protoform)
sh2_semantic_rel[partner_site] = "pY_site"
# check if site has phosphorylated 'Y' residue
py_residue_states = []
for pred in nugget.predecessors(partner_site):
ag_pred = ag_typing[pred]
if corpus.get_action_graph_typing()[ag_pred] == "residue" and\
"Y" in nugget.get_node(pred)["aa"]:
for residue_pred in nugget.predecessors(pred):
ag_residue_pred = ag_typing[residue_pred]
if corpus.get_action_graph_typing()[
ag_residue_pred] == "state" and\
"phosphorylation" in nugget.get_node(residue_pred)["name"]:
py_residue_states.append((pred, residue_pred))
# if pY residue was not found it, autocomplete nugget with it
if len(py_residue_states) == 0:
pattern = NXGraph()
pattern.add_nodes_from([partner_site])
autocompletion_rule = Rule.from_transform(pattern)
autocompletion_rule.inject_add_node(
"pY_residue", {"aa": "Y"})
autocompletion_rule.inject_add_node(
"pY_residue_phospho", {
"name": "phosphorylation",
"test": True
})
autocompletion_rule.inject_add_edge(
"pY_residue_phospho", "pY_residue")
autocompletion_rule.inject_add_edge(
"pY_residue", partner_site)
rhs_typing = {
"meta_model": {
"pY_residue": "residue",
"pY_residue_phospho": "state"
}
}
message = (
"Autocompleted the nugget '{}' ".format(nugget_id) +
"by additing a phosphorylated Y to {}".format(
_generate_fragment_repr(
corpus, ag_partner_protoform, ag_partner_site,
"site")) +
"of the protoform with the UniProt AC '{}'".format(
partner_uniprot))
rhs_nugget = corpus.rewrite(
nugget_id,
autocompletion_rule,
instance={
n: n
for n in autocompletion_rule.lhs.nodes()
},
rhs_typing=rhs_typing,
message=message,
update_type="auto")
# add necessary semantic rels
sh2_semantic_rel[rhs_nugget["pY_residue"]] = "pY_residue"
sh2_semantic_rel[rhs_nugget["pY_residue_phospho"]] =\
"phosphorylation"
else:
# Add semantic rels
for residue, state in py_residue_states:
sh2_semantic_rel[residue] = "pY_residue"
sh2_semantic_rel[state] = "phosphorylation"
# Update action graph by merging all the sites
# sharing the same residue
residues = corpus.get_attached_residues(ag_partner_site)
if len(residues) == 1:
ag_gene = ag_typing[partner_gene]
sites_to_merge = set()
sites = [
s for s in corpus.get_attached_sites(ag_gene)
if s != ag_partner_site
]
for s in sites:
s_residues = corpus.get_attached_residues(s)
if len(s_residues) == 1:
if residues[0] == s_residues[0]:
sites_to_merge.add(s)
if len(sites_to_merge) > 0:
message = (
"Merged sites ('{}')".format(sites_to_merge) +
"with the pY {} ".format(
_generate_fragment_repr(
corpus, ag_partner_protoform,
ag_partner_site, "site")) +
"of the protoform with the UniProt AC '{}' (sites share residues)"
.format(partner_uniprot))
sites_to_merge.add(ag_partner_site)
pattern = NXGraph()
pattern.add_nodes_from(sites_to_merge)
site_merging_rule = Rule.from_transform(pattern)
site_merging_rule.inject_merge_nodes(
sites_to_merge)
corpus.rewrite(corpus._action_graph_id,
site_merging_rule,
message=message,
update_type="auto")
else:
# Generate a rule that adds pY site with a phospho Y residue
if partner_region is not None:
attached_to = partner_region
else:
attached_to = partner_gene
pattern = NXGraph()
pattern.add_nodes_from([region_bnd, attached_to])
pattern.add_edges_from([(attached_to, region_bnd)])
autocompletion_rule = Rule.from_transform(pattern)
autocompletion_rule.inject_remove_edge(attached_to, region_bnd)
autocompletion_rule.inject_add_node("pY_site")
autocompletion_rule.inject_add_node("pY_residue", {"aa": "Y"})
autocompletion_rule.inject_add_node("pY_residue_phospho", {
"name": "phosphorylation",
"test": True
})
autocompletion_rule.inject_add_edge("pY_residue_phospho",
"pY_residue")
autocompletion_rule.inject_add_edge("pY_residue", "pY_site")
autocompletion_rule.inject_add_edge("pY_site", attached_to)
autocompletion_rule.inject_add_edge("pY_site", region_bnd)
rhs_typing = {
"meta_model": {
"pY_site": "site",
"pY_residue": "residue",
"pY_residue_phospho": "state"
}
}
message = ("Autocompleted the nugget '{}' ".format(nugget_id) +
"by additing a pY site " +
"to the protoform with the UniProt AC '{}'".format(
corpus.get_uniprot(ag_typing[partner_gene])))
# Rewrite nugget and propagate to the AG
rhs_nugget = corpus.rewrite(nugget_id,
autocompletion_rule,
rhs_typing=rhs_typing,
message=message,
update_type="auto")
partner_site = rhs_nugget["pY_site"]
sh2_semantic_rel[partner_site] = "pY_site"
sh2_semantic_rel[rhs_nugget["pY_residue"]] = "pY_residue"
sh2_semantic_rel[rhs_nugget["pY_residue_phospho"]] =\
"phosphorylation"
return sh2_semantic_rel
return None
def test_networkx_hierarchy_versioning(self):
"""Test hierarchy versioning functionality."""
hierarchy = NXHierarchy()
shapes = NXGraph()
shapes.add_nodes_from(["c", "s"])
hierarchy.add_graph("shapes", shapes)
colors = NXGraph()
colors.add_nodes_from(["w", "b"])
hierarchy.add_graph("colors", colors)
ag = NXGraph()
ag.add_nodes_from(
["wc", "bc", "ws", "bs"])
hierarchy.add_graph("ag", ag)
nugget = NXGraph()
nugget.add_nodes_from(
["wc1", "wc2", "bc1", "ws1", "bs2"])
hierarchy.add_graph("nugget", nugget)
hierarchy.add_typing(
"ag", "shapes", {
"wc": "c",
"bc": "c",
"ws": "s",
"bs": "s"
})
hierarchy.add_typing(
"ag", "colors", {
"wc": "w",
"bc": "b",
"ws": "w",
"bs": "b"
})
hierarchy.add_typing(
"nugget", "ag", {
"wc1": "wc",
"wc2": "wc",
"bc1": "bc",
"ws1": "ws",
"bs2": "bs"
})
hierarchy.add_typing(
"nugget", "colors", {
"wc1": "w",
"wc2": "w",
"bc1": "b",
"ws1": "w",
"bs2": "b"
})
base = NXGraph()
base.add_nodes_from(["node"])
hierarchy.add_graph("base", base)
hierarchy.add_typing(
"colors",
"base", {
"w": "node",
"b": "node"
})
h = VersionedHierarchy(hierarchy)
h.branch("test1")
pattern = NXGraph()
pattern.add_nodes_from(["s"])
rule2 = Rule.from_transform(pattern)
rule2.inject_remove_node("s")
h.rewrite(
"shapes",
rule2, {"s": "s"},
message="Remove square in shapes")
h.switch_branch("master")
pattern = NXGraph()
pattern.add_nodes_from(["wc"])
rule1 = Rule.from_transform(pattern)
rule1.inject_clone_node("wc")
_, clone_commit = h.rewrite(
"ag",
rule1, {"wc": "wc"},
message="Clone 'wc' in ag")
pattern = NXGraph()
pattern.add_nodes_from(["wc1"])
rule3 = Rule.from_transform(pattern)
rule3.inject_add_node("new_node")
rule3.inject_add_edge("new_node", "wc1")
h.rewrite("nugget", rule3, {"wc1": "wc1"})
# print(h.print_history())
h.switch_branch("test1")
h.switch_branch("master")
h.merge_with("test1")
h.rollback(clone_commit)
h.switch_branch("test1")
