def test_agent_text_storage():
A1 = Agent('A', db_refs={'TEXT': 'A'})
A2 = Agent('A', db_refs={'TEXT': 'alpha'})
B1 = Agent('B', db_refs={'TEXT': 'bag'})
B2 = Agent('B', db_refs={'TEXT': 'bug'})
C = Agent('C')
D = Agent('D')
inp = [
Complex([A1, B1], evidence=Evidence(text='A complex bag.')),
Complex([B2, A2], evidence=Evidence(text='bug complex alpha once.')),
Complex([B2, A2], evidence=Evidence(text='bug complex alpha again.')),
Complex([A1, C, B2], evidence=Evidence(text='A complex C bug.')),
Phosphorylation(A1, B1, evidence=Evidence(text='A phospo bags.')),
Phosphorylation(A2, B2, evidence=Evidence(text='alpha phospho bugs.')),
Conversion(D, [A1, B1], [C, D],
evidence=Evidence(text='D: A bag -> C D')),
Conversion(D, [B1, A2], [C, D],
evidence=Evidence(text='D: bag a -> C D')),
Conversion(D, [B2, A2], [D, C],
evidence=Evidence(text='D: bug a -> D C')),
Conversion(D, [B1, A1], [C, D],
evidence=Evidence(text='D: bag A -> C D')),
Conversion(D, [A1], [A1, C], evidence=Evidence(text='D: A -> A C'))
]
pa = Preassembler(bio_ontology, inp)
unq1 = pa.combine_duplicates()
assert len(unq1) == 5, len(unq1)
assert all([len(ev.annotations['prior_uuids']) == 1
for s in unq1 for ev in s.evidence
if len(s.evidence) > 1]),\
'There can only be one prior evidence per uuid at this stage.'
ev_uuid_dict = {
ev.annotations['prior_uuids'][0]: ev.annotations['agents']
for s in unq1 for ev in s.evidence
}
for s in inp:
raw_text = [
ag.db_refs.get('TEXT') for ag in s.agent_list(deep_sorted=True)
]
assert raw_text == ev_uuid_dict[s.uuid]['raw_text'],\
str(raw_text) + '!=' + str(ev_uuid_dict[s.uuid]['raw_text'])
# Now run pa on the above corpus plus another statement.
inp2 = unq1 + [
Complex([A1, C, B1], evidence=Evidence(text='A complex C bag.'))
]
pa2 = Preassembler(bio_ontology, inp2)
unq2 = pa2.combine_duplicates()
assert len(unq2) == 5, len(unq2)
old_ev_list = []
new_ev = None
for s in unq2:
for ev in s.evidence:
if ev.text == inp2[-1].evidence[0].text:
new_ev = ev
else:
old_ev_list.append(ev)
assert all([len(ev.annotations['prior_uuids']) == 2 for ev in old_ev_list])
assert new_ev
assert len(new_ev.annotations['prior_uuids']) == 1
def test_normalize_opposites():
concept1 = 'wm/concept/causal_factor/food_security/food_stability'
concept2 = 'wm/concept/causal_factor/food_insecurity/food_instability'
concept3 = ('wm/concept/causal_factor/crisis_and_disaster/'
'environmental_disasters/natural_disaster/flooding')
# First test the inherently positive being the main grounding
dbr = {'WM': [(concept1, 1.0), (concept2, 0.5), (concept3, 0.1)]}
ev = Event(Concept('x', db_refs=dbr), delta=QualitativeDelta(polarity=1))
pa = Preassembler(world_ontology, stmts=[ev])
pa.normalize_opposites(ns='WM')
# We are normalizing to food supply since that is the inherently
# positive concept
assert pa.stmts[0].concept.db_refs['WM'][0] == \
(concept1, 1.0), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].concept.db_refs['WM'][1] == \
(concept1, 0.5), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].concept.db_refs['WM'][2] == \
(concept3, 0.1), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].delta.polarity == 1
# Next test the inherently negative being the main grounding
dbr = {'WM': [(concept2, 1.0), (concept1, 0.5), (concept3, 0.1)]}
ev = Event(Concept('x', db_refs=dbr), delta=QualitativeDelta(polarity=1))
pa = Preassembler(world_ontology, stmts=[ev])
pa.normalize_opposites(ns='WM')
# We are normalizing to food supply since that is the inherently
# positive concept
assert pa.stmts[0].concept.db_refs['WM'][0] == \
(concept1, 1.0), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].concept.db_refs['WM'][1] == \
(concept1, 0.5), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].concept.db_refs['WM'][2] == \
(concept3, 0.1), pa.stmts[0].concept.db_refs['WM']
assert pa.stmts[0].delta.polarity == -1
def test_split_idx():
ras = Agent('RAS', db_refs={'FPLX': 'RAS'})
kras = Agent('KRAS', db_refs={'HGNC': '6407'})
hras = Agent('HRAS', db_refs={'HGNC': '5173'})
st1 = Phosphorylation(Agent('x'), ras)
st2 = Phosphorylation(Agent('x'), kras)
st3 = Phosphorylation(Agent('x'), hras)
pa = Preassembler(bio_ontology)
maps = pa._generate_id_maps([st1, st2, st3])
assert (1, 0) in maps, maps
assert (2, 0) in maps, maps
assert pa._comparison_counter == 2
pa = Preassembler(bio_ontology)
maps = pa._generate_id_maps([st1, st2, st3], split_idx=1)
assert (2, 0) in maps, maps
assert (1, 0) not in maps, maps
assert pa._comparison_counter == 1
# Test other endpoints
refinements = pa._generate_relations([st1, st2, st3])
assert refinements == \
{st2.get_hash(): {st1.get_hash()},
st3.get_hash(): {st1.get_hash()}}, refinements
refinements = pa._generate_relation_tuples([st1, st2, st3])
assert refinements == \
{(st2.get_hash(), st1.get_hash()),
(st3.get_hash(), st1.get_hash())}
def test_event_assemble_location():
rainfall = Concept('rainfall')
loc1 = RefContext(name='x', db_refs={'GEOID': '1'})
loc2 = RefContext(name='x', db_refs={'GEOID': '2'})
ev1 = Event(rainfall, context=WorldContext(geo_location=loc1))
ev2 = Event(rainfall, context=WorldContext(geo_location=loc2))
pa = Preassembler(hierarchies=hierarchies, stmts=[ev1, ev2],
matches_fun=None)
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 1
pa = Preassembler(hierarchies=hierarchies, stmts=[ev1, ev2],
matches_fun=location_matches)
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 2
def test_association_refinement():
unrelated = 'wm/concept/causal_factor/wild_food_sources'
parent = 'wm/concept/causal_factor/health_and_life'
child = 'wm/concept/causal_factor/health_and_life/' \
'living_condition/food_safety'
parent_event = Event(Concept('parent', db_refs={'WM': [(parent, 1.0)]}))
unrelated_event = \
Event(Concept('unrelated', db_refs={'WM': [(unrelated, 1.0)]}))
child_event = Event(Concept('child', db_refs={'WM': [(child, 1.0)]}))
st1 = Association([parent_event, unrelated_event],
evidence=[Evidence(source_api='eidos1')])
st2 = Association([unrelated_event, parent_event],
evidence=[Evidence(source_api='eidos2')])
st3 = Association([parent_event, child_event],
evidence=[Evidence(source_api='eidos3')])
st4 = Association([unrelated_event, child_event],
evidence=[Evidence(source_api='eidos4')])
pa = Preassembler(world_ontology, [st1, st2, st3, st4])
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 3
top_level_stmts = pa.combine_related()
assert len(top_level_stmts) == 2, top_level_stmts
names = {
tuple(sorted(e.concept.name for e in stmt.members)): stmt
for stmt in top_level_stmts
}
stmt = names[('child', 'unrelated')]
assert len(stmt.supported_by) == 1
assert {e.concept.name for e in stmt.supported_by[0].members} == \
{'parent', 'unrelated'}
def test_combine_duplicates():
raf = Agent('RAF1')
mek = Agent('MEK1')
erk = Agent('ERK2')
p1 = Phosphorylation(raf, mek, evidence=Evidence(text='foo'))
p2 = Phosphorylation(raf, mek, evidence=Evidence(text='bar'))
p3 = Phosphorylation(raf, mek, evidence=Evidence(text='baz'))
p4 = Phosphorylation(raf, mek, evidence=Evidence(text='beep'))
p5 = Phosphorylation(mek, erk, evidence=Evidence(text='foo2'))
p6 = Dephosphorylation(mek, erk, evidence=Evidence(text='bar2'))
p7 = Dephosphorylation(mek, erk, evidence=Evidence(text='baz2'))
p8 = Dephosphorylation(mek, erk, evidence=Evidence(text='beep2'))
p9 = Dephosphorylation(Agent('SRC'),
Agent('KRAS'),
evidence=Evidence(text='beep'))
stmts = [p1, p2, p3, p4, p5, p6, p7, p8, p9]
pa = Preassembler(hierarchies, stmts=stmts)
pa.combine_duplicates()
# The statements come out sorted by their matches_key
assert (len(pa.unique_stmts) == 4)
assert (pa.unique_stmts[0].matches(p6)) # MEK dephos ERK
assert (len(pa.unique_stmts[0].evidence) == 3)
assert (pa.unique_stmts[1].matches(p9)) # SRC dephos KRAS
assert (len(pa.unique_stmts[1].evidence) == 1)
assert (pa.unique_stmts[2].matches(p5)) # MEK phos ERK
assert (len(pa.unique_stmts[2].evidence) == 1)
assert (pa.unique_stmts[3].matches(p1)) # RAF phos MEK
assert (len(pa.unique_stmts[3].evidence) == 4)
def test_pathsfromto():
bp = biopax.process_pc_pathsfromto(['MAP2K1'], ['MAPK1'])
bp.get_phosphorylation()
assert_pmids(bp.statements)
pre = Preassembler(hierarchies, bp.statements)
pre.combine_related()
assert unicode_strs(pre.unique_stmts)
def test_translocation():
st1 = Translocation(Agent('AKT'), None, None)
st2 = Translocation(Agent('AKT'), None, 'plasma membrane')
st3 = Translocation(Agent('AKT'), None, 'nucleus')
pa = Preassembler(bio_ontology, stmts=[st1, st2, st3])
pa.combine_related()
assert len(pa.related_stmts) == 2, pa.related_stmts
def test_modification_refinement_noenz2():
"""A more specific modification statement should be supported by a more
generic modification statement.
Similar to test_modification_refinement_noenz for statements where one
argument is associated with a component in the hierarchy (SIRT1 in this
case) but the other is not (BECN1).
"""
sirt1 = Agent('SIRT1',
db_refs={
'HGNC': '14929',
'UP': 'Q96EB6',
'TEXT': 'SIRT1'
})
becn1 = Agent('BECN1',
db_refs={
'HGNC': '1034',
'UP': 'Q14457',
'TEXT': 'Beclin 1'
})
st1 = Deacetylation(sirt1, becn1)
st2 = Deacetylation(None, becn1)
pa = Preassembler(bio_ontology, stmts=[st1, st2])
stmts = pa.combine_related()
# The top-level list should contain only one statement, the more specific
# modification, supported by the less-specific modification.
assert (len(stmts) == 1)
assert (stmts[0].equals(st1))
assert (len(stmts[0].supported_by) == 1)
assert (stmts[0].supported_by[0].equals(st2))
assert (stmts[0].supported_by[0].supports[0].equals(st1))
def test_flatten_evidence_hierarchy():
braf = Agent('BRAF')
mek = Agent('MAP2K1')
st1 = Phosphorylation(braf, mek, evidence=[Evidence(text='foo')])
st2 = Phosphorylation(braf,
mek,
'S',
'218',
evidence=[Evidence(text='bar')])
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_related()
assert len(pa.related_stmts) == 1
flattened = flatten_evidence(pa.related_stmts)
assert len(flattened) == 1
top_stmt = flattened[0]
assert len(top_stmt.evidence) == 2
assert 'bar' in [e.text for e in top_stmt.evidence]
assert 'foo' in [e.text for e in top_stmt.evidence]
assert len(top_stmt.supported_by) == 1
supporting_stmt = top_stmt.supported_by[0]
assert len(supporting_stmt.evidence) == 1
assert supporting_stmt.evidence[0].text == 'foo'
supporting_stmt.evidence[0].text = 'changed_foo'
assert supporting_stmt.evidence[0].text == 'changed_foo'
assert 'changed_foo' not in [e.text for e in top_stmt.evidence]
assert 'foo' in [e.text for e in top_stmt.evidence]
assert {ev.annotations.get('support_type') for ev in top_stmt.evidence} \
== {'direct', 'supported_by'}
def __init__(self, n_proc=1, batch_size=10000, print_logs=False):
self.n_proc = n_proc
self.batch_size = batch_size
self.pa = Preassembler(hierarchies)
self.__tag = 'Unpurposed'
self.__print_logs = print_logs
return
def test_modification_refinement_residue_noenz():
erbb3 = Agent('Erbb3')
st1 = Phosphorylation(None, erbb3)
st2 = Phosphorylation(None, erbb3, 'Y')
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_related()
assert len(pa.related_stmts) == 1
def test_combine_duplicates():
raf = Agent('RAF1')
mek = Agent('MEK1')
erk = Agent('ERK2')
p1 = Phosphorylation(raf, mek, evidence=Evidence(text='foo'))
p2 = Phosphorylation(raf, mek, evidence=Evidence(text='bar'))
p3 = Phosphorylation(raf, mek, evidence=Evidence(text='baz'))
p4 = Phosphorylation(raf, mek, evidence=Evidence(text='beep'))
p5 = Phosphorylation(mek, erk, evidence=Evidence(text='foo2'))
p6 = Dephosphorylation(mek, erk, evidence=Evidence(text='bar2'))
p7 = Dephosphorylation(mek, erk, evidence=Evidence(text='baz2'))
p8 = Dephosphorylation(mek, erk, evidence=Evidence(text='beep2'))
p9 = Dephosphorylation(Agent('SRC'),
Agent('KRAS'),
evidence=Evidence(text='beep'))
stmts = [p1, p2, p3, p4, p5, p6, p7, p8, p9]
pa = Preassembler(bio_ontology, stmts=stmts)
pa.combine_duplicates()
# The statements come out sorted by their matches_key
assert len(pa.unique_stmts) == 4, len(pa.unique_stmts)
num_evs = [len(s.evidence) for s in pa.unique_stmts]
assert pa.unique_stmts[0].matches(p6) # MEK dephos ERK
assert num_evs[0] == 3, num_evs[0]
assert pa.unique_stmts[1].matches(p9) # SRC dephos KRAS
assert num_evs[1] == 1, num_evs[1]
assert pa.unique_stmts[2].matches(p5) # MEK phos ERK
assert num_evs[2] == 1, num_evs[2]
assert pa.unique_stmts[3].matches(p1) # RAF phos MEK
assert num_evs[3] == 4, num_evs[3]
def test_association_refinement():
health = 'UN/entities/human/health'
food = 'UN/entities/human/food'
food_security = 'UN/entities/human/food/food_security'
eh = Event(Concept('health', db_refs={'UN': [(health, 1.0)]}))
ef = Event(Concept('food', db_refs={'UN': [(food, 1.0)]}))
efs = Event(
Concept('food security', db_refs={'UN': [(food_security, 1.0)]}))
st1 = Association([eh, ef], evidence=[Evidence(source_api='eidos1')])
st2 = Association([ef, eh], evidence=[Evidence(source_api='eidos2')])
st3 = Association([eh, efs], evidence=[Evidence(source_api='eidos3')])
st4 = Association([ef, efs], evidence=[Evidence(source_api='eidos4')])
eidos_ont = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../sources/eidos/eidos_ontology.rdf')
hm = HierarchyManager(eidos_ont, True, True)
hierarchies = {'entity': hm}
pa = Preassembler(hierarchies, [st1, st2, st3, st4])
unique_stmts = pa.combine_duplicates() # debugging
assert len(unique_stmts) == 3
rel_stmts = pa.combine_related()
assert len(rel_stmts) == 2
eh_efs_stmt = [
st for st in rel_stmts
if (st.members[0].concept.name in {'health', 'food security'}
and st.members[1].concept.name in {'health', 'food security'})
][0]
assert len(eh_efs_stmt.supported_by) == 1
assert (eh_efs_stmt.supported_by[0].members[0].concept.name
in {'food', 'health'})
assert (eh_efs_stmt.supported_by[0].members[1].concept.name
in {'food', 'health'})
def test_render_stmt_graph():
braf = Agent('BRAF', db_refs={'HGNC': '1097'})
mek1 = Agent('MAP2K1', db_refs={'HGNC': '6840'})
mek = Agent('MEK', db_refs={'FPLX': 'MEK'})
# Statements
p0 = Phosphorylation(braf, mek)
p1 = Phosphorylation(braf, mek1)
p2 = Phosphorylation(braf, mek1, position='218')
p3 = Phosphorylation(braf, mek1, position='222')
p4 = Phosphorylation(braf, mek1, 'serine')
p5 = Phosphorylation(braf, mek1, 'serine', '218')
p6 = Phosphorylation(braf, mek1, 'serine', '222')
stmts = [p0, p1, p2, p3, p4, p5, p6]
pa = Preassembler(bio_ontology, stmts=stmts)
pa.combine_related()
graph = render_stmt_graph(pa.related_stmts, reduce=False)
# One node for each statement
assert len(graph.nodes()) == 7
# Edges:
# p0 supports p1-p6 = 6 edges
# p1 supports p2-p6 = 5 edges
# p2 supports p5 = 1 edge
# p3 supports p6 = 1 edge
# p4 supports p5-p6 = 2 edges
# (p5 and p6 support none--they are top-level)
# 6 + 5 + 1 + 1 + 2 = 15 edges
assert len(graph.edges()) == 15
def test_split_idx():
ras = Agent('RAS', db_refs={'FPLX': 'RAS'})
kras = Agent('KRAS', db_refs={'HGNC': '6407'})
hras = Agent('HRAS', db_refs={'HGNC': '5173'})
st1 = Phosphorylation(Agent('x'), ras)
st2 = Phosphorylation(Agent('x'), kras)
st3 = Phosphorylation(Agent('x'), hras)
pa = Preassembler(bio_ontology)
maps = pa._generate_id_maps([st1, st2, st3])
assert (1, 0) in maps, maps
assert (2, 0) in maps, maps
assert pa._comparison_counter == 2
pa = Preassembler(bio_ontology)
maps = pa._generate_id_maps([st1, st2, st3], split_idx=1)
assert (2, 0) in maps, maps
assert (1, 0) not in maps, maps
assert pa._comparison_counter == 1
def test_uppro_assembly():
ag1 = Agent('x', db_refs={'UP': 'P01019', 'UPPRO': 'PRO_0000032457'})
ag2 = Agent('y', db_refs={'UP': 'P01019', 'UPPRO': 'PRO_0000032458'})
assert ag1.get_grounding() == ('UPPRO', ag1.db_refs['UPPRO'])
assert ag2.get_grounding() == ('UPPRO', ag2.db_refs['UPPRO'])
stmt1 = Phosphorylation(None, ag1)
stmt2 = Phosphorylation(None, ag2)
assert stmt1.matches_key() != stmt2.matches_key()
pa = Preassembler(bio_ontology, [stmt1, stmt2])
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 2, unique_stmts
from indra.tools import assemble_corpus as ac
stmts = ac.map_grounding([stmt1, stmt2])
pa = Preassembler(bio_ontology, stmts)
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 2
def test_duplicates():
src = Agent('SRC', db_refs={'HGNC': '11283'})
ras = Agent('RAS', db_refs={'FA': '03663'})
st1 = Phosphorylation(src, ras)
st2 = Phosphorylation(src, ras)
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_duplicates()
assert len(pa.unique_stmts) == 1
def process_statements(stmts, **generate_id_map_kwargs):
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
pa = Preassembler(hierarchies)
unique_stmts = make_unique_statement_set(pa, stmts)
match_key_maps = get_match_key_maps(pa, unique_stmts,
**generate_id_map_kwargs)
return unique_stmts, match_key_maps
def __init__(self, n_proc=1, batch_size=10000, print_logs=False):
self.n_proc = n_proc
self.batch_size = batch_size
self.pa = Preassembler(bio_ontology)
self.__tag = 'Unpurposed'
self.__print_logs = print_logs
self.pickle_stashes = None
return
def analyze(filename, plot=False):
# Load the file
results = load_file(filename)
# Put together a list of all statements
all_stmts = [stmt for paper_stmts in results.values()
for stmt in paper_stmts]
# Map grounding
logger.info('Mapping grounding...')
gmap = gm.GroundingMapper(gm.default_grounding_map)
map_stmts = gmap.map_agents(all_stmts)
map_stmts = gmap.rename_agents(map_stmts)
# Combine duplicates
logger.info('Removing duplicates...')
pa = Preassembler(hierarchies, map_stmts)
pa.combine_duplicates()
# Map GO IDs to genes and associated statements
logger.info('Building map from GO IDs to stmts')
go_gene_map = {}
go_name_map = {}
for stmt in pa.unique_stmts:
(bp_name, go, gene) = go_gene_pair(stmt)
if bp_name is None and go is None and gene is None:
continue
go_gene_list = go_gene_map.get(go, [])
go_gene_list.append((gene, stmt))
go_gene_map[go] = go_gene_list
go_name_set = go_name_map.get(go, set([]))
go_name_set.add(bp_name)
go_name_map[go] = go_name_set
# Iterate over all of the GO IDs and compare the annotated genes in GO
# to the ones from the given statements
go_stmt_map = {}
for ix, go_id in enumerate(go_gene_map.keys()):
logger.info('Getting genes for %s (%s) from GO (%d of %d)' %
(go_id, ','.join(list(go_name_map[go_id])),
ix+1, len(go_gene_map.keys())))
genes_from_go = get_genes_for_go_id(go_id)
gene_stmt_list = go_gene_map[go_id]
in_go = []
not_in_go = []
for (gene, stmt) in gene_stmt_list:
if gene in genes_from_go:
in_go.append(stmt)
else:
not_in_go.append(stmt)
go_stmt_map[go_id] = {'names': list(go_name_map[go_id]),
'in_go': in_go, 'not_in_go': not_in_go}
with open('go_stmt_map.pkl', 'wb') as f:
pickle.dump(go_stmt_map, f, protocol=2)
if plot:
plot_stmt_counts(go_stmt_map, 'go_stmts.pdf')
def test_grounding_aggregation():
braf1 = Agent('BRAF', db_refs={'TEXT': 'braf', 'HGNC': '1097'})
braf2 = Agent('BRAF', db_refs={'TEXT': 'BRAF'})
braf3 = Agent('BRAF', db_refs={'TEXT': 'Braf', 'UP': 'P15056'})
st1 = Phosphorylation(None, braf1)
st2 = Phosphorylation(None, braf2)
st3 = Phosphorylation(None, braf3)
pa = Preassembler(hierarchies, stmts=[st1, st2, st3])
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 3
def test_agent_coordinates():
path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'reach_coordinates.json')
stmts = reach.process_json_file(path).statements
pa = Preassembler(bio_ontology, stmts)
unique_stmt = pa.combine_duplicates()[0]
agent_annots = [ev.annotations['agents'] for ev in unique_stmt.evidence]
assert all(a['raw_text'] == ['MEK1', 'ERK2'] for a in agent_annots)
assert {tuple(a['coords'])
for a in agent_annots} == {((21, 25), (0, 4)), ((0, 4), (15, 19))}
def test_homodimer_refinement():
egfr = Agent('EGFR')
erbb = Agent('ERBB2')
st1 = Complex([erbb, erbb])
st2 = Complex([erbb, egfr])
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_duplicates()
assert len(pa.unique_stmts) == 2
pa.combine_related()
assert len(pa.related_stmts) == 2
def test_complex_refinement_order():
st1 = Complex([Agent('MED23'), Agent('ELK1')])
st2 = Complex([
Agent('ELK1', mods=[ModCondition('phosphorylation')]),
Agent('MED23')
])
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_duplicates()
pa.combine_related()
assert len(pa.related_stmts) == 1
def test_complex_refinement():
ras = Agent('RAS')
raf = Agent('RAF')
mek = Agent('MEK')
st1 = Complex([ras, raf])
st2 = Complex([mek, ras, raf])
pa = Preassembler(bio_ontology, stmts=[st1, st2])
pa.combine_related()
assert len(pa.unique_stmts) == 2
assert len(pa.related_stmts) == 2
def test_find_contradicts():
st1 = Inhibition(Agent('a'), Agent('b'))
st2 = Activation(Agent('a'), Agent('b'))
st3 = IncreaseAmount(Agent('a'), Agent('b'))
st4 = DecreaseAmount(Agent('a'), Agent('b'))
pa = Preassembler(hierarchies, [st1, st2, st3, st4])
contradicts = pa.find_contradicts()
assert len(contradicts) == 2
for s1, s2 in contradicts:
assert {s1.uuid, s2.uuid} in ({st1.uuid,
st2.uuid}, {st3.uuid, st4.uuid})
def test_grounding_aggregation_complex():
mek = Agent('MEK')
braf1 = Agent('BRAF', db_refs={'TEXT': 'braf', 'HGNC': '1097'})
braf2 = Agent('BRAF', db_refs={'TEXT': 'BRAF', 'dummy': 'dummy'})
braf3 = Agent('BRAF', db_refs={'TEXT': 'Braf', 'UP': 'P15056'})
st1 = Complex([mek, braf1])
st2 = Complex([braf2, mek])
st3 = Complex([mek, braf3])
pa = Preassembler(bio_ontology, stmts=[st1, st2, st3])
unique_stmts = pa.combine_duplicates()
assert len(unique_stmts) == 3, unique_stmts
def test_normalize_opposites_influence():
concept1 = 'wm/concept/causal_factor/food_security/food_stability'
concept2 = 'wm/concept/causal_factor/food_insecurity/food_instability'
dbr1 = {'WM': [(concept1, 1.0), (concept2, 0.5)]}
dbr2 = {'WM': [(concept2, 1.0), (concept1, 0.5)]}
stmt = Influence(
Event(Concept('x', db_refs=dbr1), delta=QualitativeDelta(polarity=1)),
Event(Concept('y', db_refs=dbr2), delta=QualitativeDelta(polarity=-1)))
pa = Preassembler(world_ontology, stmts=[stmt])
pa.normalize_opposites(ns='WM')
assert pa.stmts[0].subj.delta.polarity == 1
assert pa.stmts[0].obj.delta.polarity == 1
def test_conversion_refinement():
ras = Agent('RAS', db_refs={'FPLX': 'RAS'})
hras = Agent('HRAS', db_refs={'HGNC': '5173'})
gtp = Agent('GTP')
gdp = Agent('GDP')
st1 = Conversion(ras, gtp, gdp)
st2 = Conversion(hras, gtp, gdp)
st3 = Conversion(hras, [gtp, gdp], gdp)
st4 = Conversion(hras, [gdp, gtp], gdp)
pa = Preassembler(bio_ontology, stmts=[st1, st2, st3, st4])
toplevel_stmts = pa.combine_related()
assert len(toplevel_stmts) == 2
