def test_get_latest_results():
db = _get_test_db()
models = ['aml', 'luad']
# Fill up the database.
for query in test_queries:
db.put_queries('joshua', 1, query, models)
for model in models:
db.put_results(model, [(query, 'pysb', _get_random_result())
for query in test_queries])
# Add the same statements over again
time.sleep(10)
for model in models:
db.put_results(model, [(query, 'pysb', _get_random_result())
for query in test_queries])
# Try to get the results. Make sure we only get the one set.
results = db.get_results('joshua')
assert len(results) == len(test_queries) * len(models), len(results)
assert all(isinstance(result, tuple) for result in results)
assert all(result[0] in models for result in results)
assert any(results[0][1].matches(q) for q in test_queries)
assert all(isinstance(result[2], str) for result in results)
assert all(isinstance(result[3], dict) for result in results)
def test_get_subscribed_users():
db = _get_test_db()
db.put_queries('*****@*****.**', 1, test_queries[0], ['aml'], True)
db.put_queries('*****@*****.**', 2, test_queries[1], ['aml'], False)
# Only return users that subscribed for something
emails = db.get_subscribed_users()
assert len(emails) == 1
assert emails[0] == '*****@*****.**'
def test_get_subscribed_queries():
db = _get_test_db()
db.put_queries('*****@*****.**', 1, test_queries[0], ['aml'], True)
db.put_queries('*****@*****.**', 1, test_queries[1], ['aml'], False)
# Only return queries for which subscription is True
queries = db.get_subscribed_queries('*****@*****.**')
assert len(queries) == 1
assert queries[0][2] == test_queries[0].get_hash_with_model('aml')
def test_answer_get_registered_queries():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
# Put all types of queries in db, answer together
qm.db.put_queries(test_email, 1, query_object, ['test'], subscribe=True)
qm.db.put_queries(test_email, 1, dyn_query, ['test'], subscribe=True)
qm.db.put_queries(test_email, 1, open_query, ['test'], subscribe=True)
qm.db.put_queries(test_email, 1, interv_query, ['test'], subscribe=True)
qm.answer_registered_queries('test')
# Retrieve results for path query
results = qm.get_registered_queries(test_email, 'path_property')
qh = query_object.get_hash_with_model('test')
assert qh in results
assert len(results) == 1
assert results[qh]['model'] == 'test'
assert results[qh]['query'] == simple_query
assert isinstance(results[qh]['date'], str)
assert results[qh]['pysb'] == ['Pass', [test_response['3801854542']]], \
(results[qh]['pysb'], test_response['3801854542'])
assert results[qh]['pybel'] == ['Pass', [test_response['3801854542']]]
assert results[qh]['signed_graph'][0] == 'Pass'
assert results[qh]['unsigned_graph'][0] == 'Pass'
# Retrieve results for dynamic query
results = qm.get_registered_queries(test_email, 'dynamic_property')
qh = dyn_query.get_hash_with_model('test')
assert qh in results
assert results[qh]['model'] == 'test'
assert results[qh]['query'] == 'Active MAP2K1 is eventually high.'
assert isinstance(results[qh]['date'], str)
assert results[qh]['result'] == [
'Pass', 'Satisfaction rate is 100% after 2 simulations.'
]
assert isinstance(results[qh]['image'], str)
# Retrieve results for open query
results = qm.get_registered_queries(test_email, 'open_search_query')
qh = open_query.get_hash_with_model('test')
assert qh in results
assert results[qh]['model'] == 'test'
assert results[qh]['query'] == 'What does BRAF activate?'
assert isinstance(results[qh]['date'], str)
for mc_type in ['pysb', 'pybel', 'signed_graph', 'unsigned_graph']:
assert results[qh][mc_type][0] == 'Pass'
assert isinstance(results[qh][mc_type][1], list)
assert test_response['3801854542']['path'] in [
res['path'] for res in results[qh][mc_type][1]
]
# Retrieve results for intervention query
results = qm.get_registered_queries(test_email,
'simple_intervention_property')
qh = interv_query.get_hash_with_model('test')
assert qh in results, results
assert results[qh]['model'] == 'test'
assert results[qh]['query'] == 'BRAF increases active MAP2K1.'
assert isinstance(results[qh]['date'], str)
assert results[qh]['result'] == [
'Pass', 'Yes, the amount of target entity increased.'
]
assert isinstance(results[qh]['image'], str)
def test_put_results():
db = _get_test_db()
db.put_queries('joshua', 1, test_queries[0], ['aml', 'luad'])
queries = db.get_queries('aml')
results = [(query, '', _get_random_result()) for query in queries]
db.put_results('aml', results)
with db.get_session() as sess:
db_results = sess.query(Result).all()
assert len(db_results) == len(results)
def test_get_number_results():
db = _get_test_db()
db.put_queries('*****@*****.**', 1, test_queries[0], ['aml'])
db.put_results('aml', [(test_queries[0], 'pysb', _get_random_result())])
time.sleep(1)
db.put_results('aml', [(test_queries[0], 'pysb', _get_random_result())])
time.sleep(1)
db.put_results('aml', [(test_queries[0], 'pysb', _get_random_result())])
qh = test_queries[0].get_hash_with_model('aml')
assert db.get_number_of_results(qh, 'pysb') == 3
def test_put_queries():
db = _get_test_db()
db.put_queries('joshua', 1, test_queries[0], ['aml', 'luad'])
with db.get_session() as sess:
queries = sess.query(Query).all()
assert len(queries) == 2, len(queries)
# Not logged in user
db.put_queries(None, None, test_queries[1], ['aml'])
with db.get_session() as sess:
queries = sess.query(Query).all()
assert len(queries) == 3, len(queries)
def test_get_queries():
db = _get_test_db()
for query in test_queries:
db.put_queries('joshua', 1, query, ['aml', 'luad'])
db.put_queries('test_user', 2, query, ['aml'])
# We should only get distinct queries, independent of number of users
queries = db.get_queries('aml')
assert len(queries) == 2, len(queries)
assert all(isinstance(query, PathProperty) for query in queries)
queries = db.get_queries('luad')
assert len(queries) == 2, len(queries)
assert all(isinstance(query, PathProperty) for query in queries)
def test_user_query_delta():
db = _get_test_db()
# Using results from db
db.put_queries(test_email, 1, query_object, ['test'], subscribe=True)
db.put_results('test', [(query_object, 'pysb', test_response)])
db.put_results('test', [(query_object, 'pysb', query_not_appl)])
str_rep, html_rep = get_user_query_delta(db, user_email=test_email)
assert str_rep, print(str_rep)
assert html_rep, print(html_rep)
assert '</html>' in html_rep
assert '</body>' in html_rep
assert 'pysb' in html_rep
assert 'unsubscribe' in html_rep
def test_model_subscription():
db = _get_test_db()
db.subscribe_to_model('*****@*****.**', 1, 'aml')
db.subscribe_to_model('*****@*****.**', 1, 'paad')
db.subscribe_to_model('*****@*****.**', 2, 'aml')
aml_users = db.get_model_users('aml')
paad_users = db.get_model_users('paad')
ms_users = db.get_model_users('ms')
assert len(aml_users) == 2
assert set(aml_users) == {'*****@*****.**', '*****@*****.**'}
assert len(paad_users) == 1
assert paad_users == ['*****@*****.**']
assert ms_users == []
def test_answer_queries_from_s3():
# Local imports are recommended when using moto
from emmaa.answer_queries import answer_queries_from_s3
db = _get_test_db()
client = setup_bucket(add_mm=True)
db.put_queries('*****@*****.**',
1,
query_object, ['test'],
subscribe=True)
answer_queries_from_s3('test', db=db, bucket=TEST_BUCKET_NAME)
results = db.get_results('*****@*****.**', latest_order=1)
# Each model type has its own result
assert len(results) == 4, len(results)
def test_update_email_subscription():
db = _get_test_db()
db.put_queries('*****@*****.**', 1, test_queries[0], ['aml'], True)
qh = test_queries[0].get_hash_with_model('aml')
with db.get_session() as sess:
q = sess.query(UserQuery.subscription).filter(
UserQuery.user_id == 1, UserQuery.query_hash == qh)
assert [q[0] for q in q.all()][0] # True
db.update_email_subscription('*****@*****.**', [qh], [], False)
with db.get_session() as sess:
q = sess.query(UserQuery.subscription).filter(
UserQuery.user_id == 1,
UserQuery.query_hash == test_queries[0].get_hash_with_model('aml'))
assert not [q[0] for q in q.all()][0] # new subscription status is False
def test_user_query_delta():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
# Using results from db
qm.db.put_queries(test_email, 1, query_object, ['test'],
subscribe=True)
qm.db.put_results('test', [(query_object, 'pysb', test_response)])
qm.db.put_results('test', [(query_object, 'pysb', query_not_appl)])
str_rep, html_rep = qm.get_user_query_delta(user_email=test_email)
assert str_rep, print(str_rep)
assert html_rep, print(html_rep)
assert '</html>' in html_rep
assert '</body>' in html_rep
assert 'pysb' in html_rep
assert 'unsubscribe' in html_rep
def test_immediate_dynamic():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
query_hashes = qm.answer_immediate_query(
test_email, 1, dyn_query, ['test'], subscribe=False)[
'dynamic_property']
assert query_hashes == [-27775603206605897], query_hashes
results = qm.retrieve_results_from_hashes(query_hashes, 'dynamic_property')
assert len(results) == 1, results
assert query_hashes[0] in results
result_values = results[query_hashes[0]]
assert result_values['model'] == 'test'
assert result_values['query'] == 'Active MAP2K1 is eventually high.'
assert isinstance(result_values['date'], str)
assert result_values['result'] == [
'Pass', 'Satisfaction rate is 100% after 2 simulations.']
assert isinstance(result_values['image'], str)
def test_path_counts():
db = _get_test_db('stmt')
# Put statements in the database
model_id = 'test'
date = '2021-01-01'
stmts = [
Activation(Agent('A', db_refs={'HGNC': '1234'}),
Agent('B', db_refs={'HGNC': '2345'}),
evidence=[
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1234'}),
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1235'})
]),
Phosphorylation(Agent('B', db_refs={'HGNC': '2345'}),
Agent('C', db_refs={'HGNC': '3456'}),
evidence=[
Evidence(text='B phosphorylates C.',
source_api='assertion',
text_refs={'TRID': '2345'})
])
]
hash0 = str(stmts[0].get_hash())
hash1 = str(stmts[1].get_hash())
stmt_jsons = stmts_to_json(stmts)
db.add_statements(model_id, date, stmt_jsons)
# All path counts should be 0
path_counts = db.get_path_counts(model_id, date)
assert len(path_counts) == 0
# Can update path counts multiple times, can be a subset of hashes
db.update_statements_path_counts(model_id, date, {hash0: 7})
path_counts = db.get_path_counts(model_id, date)
assert len(path_counts) == 1, path_counts
assert path_counts[hash0] == 7
db.update_statements_path_counts(model_id, date, {hash0: 1, hash1: 5})
path_counts = db.get_path_counts(model_id, date)
assert len(path_counts) == 2
assert path_counts[hash0] == 8 # 7 + 1
assert path_counts[hash1] == 5
db.update_statements_path_counts(model_id, date, {hash0: 3})
path_counts = db.get_path_counts(model_id, date)
assert len(path_counts) == 2
assert path_counts[hash0] == 11 # 7 + 1 + 3
assert path_counts[hash1] == 5 # Only added 5
def test_immediate_intervention():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
query_hashes = qm.answer_immediate_query(
test_email, 1, interv_query, ['test'],
subscribe=False)['simple_intervention_property']
assert query_hashes == [14834228758745381], query_hashes
results = qm.retrieve_results_from_hashes(query_hashes,
'simple_intervention_property')
assert len(results) == 1, results
assert query_hashes[0] in results
result_values = results[query_hashes[0]]
assert result_values['model'] == 'test'
assert result_values['query'] == 'BRAF increases active MAP2K1.'
assert isinstance(result_values['date'], str)
assert result_values['result'] == [
'Pass', 'Yes, the amount of target entity increased.'
]
assert isinstance(result_values['image'], str)
def test_answer_immediate_query():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
query_hashes = qm.answer_immediate_query(
test_email, 1, query_object, ['test'], subscribe=False)[
'path_property']
assert query_hashes == [35683418474694258], query_hashes
results = qm.retrieve_results_from_hashes(query_hashes)
assert len(results) == 1
assert query_hashes[0] in results
result_values = results[query_hashes[0]]
assert result_values['model'] == 'test'
assert result_values['query'] == simple_query
assert isinstance(result_values['date'], str)
assert result_values['pysb'] == ['Pass', [test_response['3801854542']]], \
result_values['pysb']
assert result_values['pybel'] == ['Pass', [test_response['3801854542']]]
assert result_values['signed_graph'][0] == 'Pass'
assert result_values['unsigned_graph'][0] == 'Pass'
def test_get_dates_and_delete():
db = _get_test_db('stmt')
model_id = 'test'
# At first there are no statements in the database
assert db.get_number_of_dates(model_id) == 0
assert db.get_oldest_date(model_id) is None
# Put statements in the database
date = '2021-01-01'
stmts = [
Activation(Agent('A', db_refs={'HGNC': '1234'}),
Agent('B', db_refs={'HGNC': '2345'}),
evidence=[
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1234'}),
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1235'})
]),
Phosphorylation(Agent('B', db_refs={'HGNC': '2345'}),
Agent('C', db_refs={'HGNC': '3456'}),
evidence=[
Evidence(text='B phosphorylates C.',
source_api='assertion',
text_refs={'TRID': '2345'})
])
]
stmt_jsons = stmts_to_json(stmts)
db.add_statements(model_id, date, stmt_jsons)
# There should be one date
assert db.get_number_of_dates(model_id) == 1
assert db.get_oldest_date(model_id) == date
# Add another date
date2 = '2022-01-01'
db.add_statements(model_id, date2, stmt_jsons)
assert db.get_number_of_dates(model_id) == 2
# Oldest date is still the first one
assert db.get_oldest_date(model_id) == date
# Delete statements from the first date
db.delete_statements(model_id, date)
# There should be one date left
assert db.get_number_of_dates(model_id) == 1
assert db.get_oldest_date(model_id) == date2
def test_immediate_open():
db = _get_test_db()
qm = QueryManager(db=db, model_managers=[test_mm])
query_hashes = qm.answer_immediate_query(
test_email, 1, open_query, ['test'], subscribe=False)[
'open_search_query']
assert query_hashes == [-13552944417558866], query_hashes
results = qm.retrieve_results_from_hashes(query_hashes)
assert len(results) == 1
assert query_hashes[0] in results
result_values = results[query_hashes[0]]
assert result_values['model'] == 'test'
assert result_values['query'] == 'What does BRAF activate?'
assert isinstance(result_values['date'], str)
for mc_type in ['pysb', 'pybel', 'signed_graph', 'unsigned_graph']:
assert result_values[mc_type][0] == 'Pass'
assert isinstance(result_values[mc_type][1], list)
assert test_response['3801854542']['path'] in [
res['path'] for res in result_values[mc_type][1]]
def test_get_all_result_hashes_and_delta():
db = _get_test_db()
db.put_queries('*****@*****.**', 1, test_queries[0], ['aml'])
qh = test_queries[0].get_hash_with_model('aml')
# If there are no older results, all hashes is None
assert db.get_all_result_hashes(qh, 'pysb') is None
db.put_results('aml', [(test_queries[0], 'pysb', {'1234': 'result'})])
assert db.get_all_result_hashes(qh, 'pysb') == {'1234'}
# First result is not delta
results = db.get_results_from_hashes([qh])
assert results[0][4] == [], results[0]
# All hashes keeps growing
time.sleep(1)
db.put_results('aml', [(test_queries[0], 'pysb', {'345': 'other'})])
assert db.get_all_result_hashes(qh, 'pysb') == {'1234', '345'}
results = db.get_results_from_hashes([qh])
assert results[0][4] == ['345'], results[0]
# When we go to previous result, it's not delta
time.sleep(1)
db.put_results('aml', [(test_queries[0], 'pysb', {'1234': 'result'})])
assert db.get_all_result_hashes(qh, 'pysb') == {'1234', '345'}
results = db.get_results_from_hashes([qh])
assert results[0][4] == [], results[0]
def test_get_statements_by_hash():
db = _get_test_db('stmt')
# Put statements in the database
model_id = 'test'
date = '2021-01-01'
stmts = [
Activation(Agent('A', db_refs={'HGNC': '1234'}),
Agent('B', db_refs={'HGNC': '2345'}),
evidence=[
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1234'}),
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1235'})
]),
Phosphorylation(Agent('B', db_refs={'HGNC': '2345'}),
Agent('C', db_refs={'HGNC': '3456'}),
evidence=[
Evidence(text='B phosphorylates C.',
source_api='assertion',
text_refs={'TRID': '2345'})
])
]
hash0 = stmts[0].get_hash()
hash1 = stmts[1].get_hash()
stmt_jsons = stmts_to_json(stmts)
db.add_statements(model_id, date, stmt_jsons)
# Load statements by hash
stmts_loaded = db.get_statements_by_hash(model_id, date, [hash0, hash1])
assert len(stmts_loaded) == 2
assert stmts_loaded[0].get_hash() == hash0
assert stmts_loaded[1].get_hash() == hash1
stmts_loaded = db.get_statements_by_hash(model_id, date, [hash0])
assert len(stmts_loaded) == 1
assert stmts_loaded[0].get_hash() == hash0
def test_instantiation():
db = _get_test_db()
assert db
return
def test_get_statements():
db = _get_test_db('stmt')
# Put statements and path counts in the database
model_id = 'test'
date = '2021-01-01'
stmts = [
Activation(Agent('A', db_refs={'HGNC': '1234'}),
Agent('B', db_refs={'HGNC': '2345'}),
evidence=[
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1234'}),
Evidence(text='A activates B.',
source_api='assertion',
text_refs={'TRID': '1235'})
]),
Phosphorylation(Agent('B', db_refs={'HGNC': '2345'}),
Agent('C', db_refs={'HGNC': '3456'}),
evidence=[
Evidence(text='B phosphorylates C.',
source_api='assertion',
text_refs={'TRID': '2345'})
]),
IncreaseAmount(Agent('A', db_refs={'HGNC': '1234'}),
Agent('C', db_refs={'HGNC': '3456'}))
]
stmts[0].belief = 0.8
stmts[1].belief = 0.9
stmts[2].belief = 0.5
hash0 = stmts[0].get_hash()
hash1 = stmts[1].get_hash()
hash2 = stmts[2].get_hash()
stmt_jsons = stmts_to_json(stmts)
db.add_statements(model_id, date, stmt_jsons)
db.update_statements_path_counts(model_id, date, {
str(hash0): 1,
str(hash1): 5
})
# Load statements with different sort/filter options
# Sort by evidence count
stmts_loaded = db.get_statements(model_id, date, sort_by='evidence')
assert len(stmts_loaded) == 3
assert stmts_loaded[0].get_hash() == hash0, len(stmts_loaded[0].evidence)
assert stmts_loaded[1].get_hash() == hash1, len(stmts_loaded[1].evidence)
assert stmts_loaded[2].get_hash() == hash2 # stmt with no evidence is last
# Sort by belief
stmts_loaded = db.get_statements(model_id, date, sort_by='belief')
assert len(stmts_loaded) == 3
assert stmts_loaded[0].get_hash() == hash1
assert stmts_loaded[1].get_hash() == hash0
# Sort by path count
stmts_loaded = db.get_statements(model_id, date, sort_by='paths')
assert len(stmts_loaded) == 3
assert stmts_loaded[0].get_hash() == hash1, stmts_loaded
assert stmts_loaded[1].get_hash() == hash0
# Filter by statement type
stmts_loaded = db.get_statements(model_id, date, stmt_types=['Activation'])
assert len(stmts_loaded) == 1
assert stmts_loaded[0].get_hash() == hash0
stmts_loaded = db.get_statements(model_id,
date,
stmt_types=['Phosphorylation'])
assert len(stmts_loaded) == 1
assert stmts_loaded[0].get_hash() == hash1
# Filter by belief
stmts_loaded = db.get_statements(model_id, date, min_belief=0.85)
assert len(stmts_loaded) == 1
assert stmts_loaded[0].get_hash() == hash1
stmts_loaded = db.get_statements(model_id, date, max_belief=0.85)
assert len(stmts_loaded) == 2
assert set([stmt.get_hash() for stmt in stmts_loaded]) == {hash0, hash2}
stmts_loaded = db.get_statements(model_id,
date,
min_belief=0.85,
max_belief=0.85)
assert len(stmts_loaded) == 0
# Use offset and limit
stmts_loaded = db.get_statements(model_id, date)
assert len(stmts_loaded) == 3
stmts_loaded = db.get_statements(model_id, date, offset=1)
assert len(stmts_loaded) == 2, stmts_loaded
stmts_loaded = db.get_statements(model_id, date, limit=1)
assert len(stmts_loaded) == 1
# Returns only remaining statements after upset even if limit is larger
stmts_loaded = db.get_statements(model_id, date, offset=1, limit=5)
assert len(stmts_loaded) == 2
