def test_ast_plan_strategy(requests_mock):
set_mock(requests_mock, "workflow-5")
print("test_ast_plan_strategy ()")
tranql = TranQL()
tranql.resolve_names = False
# QueryPlanStrategy always uses /schema regardless of the `FROM` clause.
ast = tranql.parse("""
SELECT cohort_diagnosis:disease->diagnoses:disease
FROM '/schema'
WHERE cohort_diagnosis = 'MONDO:0004979' --asthma
AND Sex = '0'
AND cohort = 'all_patients'
AND max_p_value = '0.5'
SET '$.knowledge_graph.nodes.[*].id' AS diagnoses
""")
select = ast.statements[0]
plan = select.planner.plan(select.query)
# Assert that it has planned to query both gamma and rtx
assert ((plan[0][1] == "/graph/gamma/quick" and plan[1][1] == "/graph/rtx")
or (plan[1][1] == "/graph/rtx"
and plan[1][1] == "/graph/gamma/quick"))
# Both should be querying the same thing (disease->diseasee), differing only in the sub_schema that they are querying
for sub_schema_plan in plan:
assert sub_schema_plan[2][0][0].type_name == "disease"
assert sub_schema_plan[2][0][0].name == "cohort_diagnosis"
assert sub_schema_plan[2][0][0].nodes == ["MONDO:0004979"]
assert sub_schema_plan[2][0][1].direction == "->"
assert sub_schema_plan[2][0][1].predicate == None
assert sub_schema_plan[2][0][2].type_name == "disease"
assert sub_schema_plan[2][0][2].name == "diagnoses"
assert sub_schema_plan[2][0][2].nodes == []
def test_ast_bidirectional_query (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Validate that we parse and generate queries correctly for bidirectional queries. """
print ("test_ast_bidirectional_query ()")
app = TranQL ()
app.resolve_names = False
disease_id = "MONDO:0004979"
chemical = "PUBCHEM:2083"
app.context.set ("drug", chemical)
app.context.set ("disease", disease_id)
mocker = MockHelper ()
expectations = {
"cop.tranql" : mocker.get_obj ("bidirectional_question.json")
}
queries = { os.path.join (os.path.dirname (__file__), "..", "queries", k) : v
for k, v in expectations.items () }
for program, expected_output in queries.items ():
ast = app.parse_file (program)
statement = ast.statements
""" This uses an unfortunate degree of knowledge about the implementation,
both of the AST, and of theq query. Consider alternatives. """
questions = ast.statements[2].generate_questions (app)
nodes = questions[0]['question_graph']['nodes']
edges = questions[0]['question_graph']['edges']
node_index = { n['id'] : i for i, n in enumerate (nodes) }
assert nodes[-1]['curie'] == disease_id
assert nodes[0]['curie'] == chemical
assert node_index[edges[-1]['target_id']] == node_index[edges[-1]['source_id']] - 1
def assert_parse_tree(code, expected):
""" Parse a block of code into a parse tree. Then assert the equality
of that parse tree to a list of expected tokens. """
tranql = TranQL()
tranql.resolve_names = False
actual = tranql.parser.parse(code).parse_tree
#print (f"{actual}")
assert_lists_equal(actual, expected)
def test_ast_set_graph (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Set a variable to a graph passed as a result. """
print ("test_ast_set_graph ()")
tranql = TranQL ()
tranql.resolve_names = False
statement = SetStatement (variable="variable", value=None, jsonpath_query=None)
statement.execute (tranql, context={ 'result' : { "a" : 1 } })
assert tranql.context.resolve_arg ("$variable")['a'] == 1
def test_ast_set_variable (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Test setting a varaible to an explicit value. """
print ("test_ast_set_variable ()")
tranql = TranQL ()
tranql.resolve_names = False
statement = SetStatement (variable="variable", value="x")
statement.execute (tranql)
assert tranql.context.resolve_arg ("$variable") == 'x'
def test_ast_set_graph(requests_mock):
set_mock(requests_mock, "workflow-5")
""" Set a variable to the value returned by executing a JSONPath query. """
print("test_ast_set_graph ()")
tranql = TranQL()
tranql.resolve_names = False
statement = SetStatement(variable="variable",
value=None,
jsonpath_query="$.nodes.[*]")
statement.execute(tranql, context={'result': {"nodes": [{"id": "x:y"}]}})
assert tranql.context.resolve_arg("$variable")[0]['id'] == "x:y"
def test_ast_plan_statements (requests_mock):
set_mock(requests_mock, "workflow-5")
print("test_ast_plan_statements ()")
tranql = TranQL ()
tranql.resolve_names = False
# QueryPlanStrategy always uses /schema regardless of the `FROM` clause.
ast = tranql.parse ("""
SELECT cohort_diagnosis:disease->diagnoses:disease
FROM '/schema'
WHERE cohort_diagnosis = 'MONDO:0004979' --asthma
AND Sex = '0'
AND cohort = 'all_patients'
AND max_p_value = '0.5'
SET '$.knowledge_graph.nodes.[*].id' AS diagnoses
""")
select = ast.statements[0]
statements = select.plan (select.planner.plan (select.query))
assert len(statements) == 2
for statement in statements:
assert_lists_equal(
list(statement.query.concepts.keys()),
[
"cohort_diagnosis",
"diagnoses"
]
)
assert statement.query.concepts['cohort_diagnosis'].nodes == ["MONDO:0004979"]
assert statement.query.concepts['diagnoses'].nodes == []
# TODO: figure out why there are duplicates generated??
assert_lists_equal(statement.where, [
['cohort_diagnosis', '=', 'MONDO:0004979'],
['Sex', '=', '0'], ['Sex', '=', '0'],
['cohort', '=', 'all_patients'],
['cohort', '=', 'all_patients'],
['max_p_value', '=', '0.5'],
['max_p_value', '=', '0.5']
])
assert statement.set_statements == []
assert (
(statements[0].service == "/graph/gamma/quick" and statements[1].service == "/graph/rtx") or
(statements[0].service == "/graph/rtx" and statements[1].service == "/graph/gamma/quick")
)
def test_interpreter_set (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Test set statements by executing a few and checking values after. """
print ("test_interpreter_set ()")
tranql = TranQL ()
tranql.resolve_names = False
tranql.execute ("""
-- Test set statements.
SET disease = 'asthma'
SET max_p_value = '0.5'
SET cohort = 'COHORT:22'
SET population_density = 2
SET icees.population_density_cluster = 'http://localhost/ICEESQuery'
SET gamma.quick = 'http://robokop.renci.org:80/api/simple/quick/' """)
variables = [ "disease", "max_p_value", "cohort", "icees.population_density_cluster", "gamma.quick" ]
output = { k : tranql.context.resolve_arg (f"${k}") for k in variables }
#print (f"resolved variables --> {json.dumps(output, indent=2)}")
assert output['disease'] == "asthma"
assert output['cohort'] == "COHORT:22"
def test_ast_generate_questions (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Validate that
-- named query concepts work.
-- the question graph is build incorporating where clause constraints.
"""
print ("test_ast_set_generate_questions ()")
app = TranQL ()
app.resolve_names = False
ast = app.parse ("""
SELECT cohort_diagnosis:disease->diagnoses:disease
FROM '/clinical/cohort/disease_to_chemical_exposure'
WHERE cohort_diagnosis = 'MONDO:0004979' --asthma
AND Sex = '0'
AND cohort = 'all_patients'
AND max_p_value = '0.5'
SET '$.knowledge_graph.nodes.[*].id' AS diagnoses
""")
questions = ast.statements[0].generate_questions (app)
assert questions[0]['question_graph']['nodes'][0]['curie'] == 'MONDO:0004979'
assert questions[0]['question_graph']['nodes'][0]['type'] == 'disease'
def test_ast_merge_results (requests_mock):
set_mock(requests_mock, "workflow-5")
""" Validate that
-- Results from the query plan are being merged together correctly
"""
print("test_ast_merge_answers ()")
tranql = TranQL ()
tranql.resolve_names = False
ast = tranql.parse ("""
SELECT cohort_diagnosis:disease->diagnoses:disease
FROM '/clinical/cohort/disease_to_chemical_exposure'
WHERE cohort_diagnosis = 'MONDO:0004979' --asthma
AND Sex = '0'
AND cohort = 'all_patients'
AND max_p_value = '0.5'
SET '$.knowledge_graph.nodes.[*].id' AS diagnoses
""")
select = ast.statements[0]
# What is the proper format for the name of a mock file? This should be made into one
mock_responses = [
{
'knowledge_graph': {
'nodes': [
{'id': 'CHEBI:28177', 'type': 'chemical_substance'},
{'id': 'HGNC:2597', 'type': 'gene'},
{
'id': 'egg',
'name':'test_name_merge',
'type': 'foo_type',
'test_attr': ['a','b']
},
{
'id': 'equivalent_identifier_merge',
'equivalent_identifiers': ['TEST:00000'],
'merged_property': [
'a',
'b'
]
}
],
'edges': [
{'id': 'e0', 'source_id': 'CHEBI:28177', 'target_id': 'HGNC:2597'},
{
# Test if edges that are connected to merged nodes will be successfully merged with other duplicate edges
'source_id' : 'CHEBI:28177',
'target_id' : 'egg',
'type': ['merge_this'],
'merge_this_list' : ['edge_1'],
'unique_attr_e_1' : 'e_1',
'id' : 'winning_edge_id'
},
]
},
'knowledge_map': [
{
'node_bindings': {
'chemical_substance': 'CHEBI:28177',
'gene': 'HGNC:2597'
},
'edge_bindings': {}
}
]
},
{
'knowledge_graph': {
'nodes': [
{'id': 'CHEBI:28177', 'type': 'chemical_substance'},
{
'id': 'also_test_array_type_and_string_type_merge',
'name':'test_name_merge',
'type': ['foo_type','bar_type'],
'test_attr': ['a','c']
},
{'id': 'TEST:00000', 'type': 'test', 'merged_property': ['a','c']},
],
'edges': [
{'id': 'e0', 'source_id': 'CHEBI:28177', 'target_id': 'TEST:00000'},
{
'source_id' : 'CHEBI:28177',
'target_id' : 'also_test_array_type_and_string_type_merge',
'type': ['merge_this'],
'merge_this_list' : ['edge_2'],
'unique_attr_e_2' : 'e_2'
}
]
},
'knowledge_map': [
{
'node_bindings': {
'chemical_substance': 'CHEBI:28177',
'test': 'TEST:00000'
},
'edge_bindings': {}
}
]
}
]
expected_result = {
"knowledge_graph": {
"edges": [
{
"id": "e0",
"source_id": "CHEBI:28177",
"target_id": "HGNC:2597",
"type": []
},
{
"id": "e0",
"source_id": "CHEBI:28177",
"target_id": "equivalent_identifier_merge",
"type": []
},
{
"id" : "winning_edge_id",
"source_id" : "CHEBI:28177",
"target_id" : "egg",
"type" : ["merge_this"],
"merge_this_list" : ["edge_1", "edge_2"],
"unique_attr_e_1" : "e_1",
"unique_attr_e_2" : "e_2"
}
],
"nodes": [
{
"equivalent_identifiers": [
"CHEBI:28177"
],
"id": "CHEBI:28177",
"type": ["chemical_substance"]
},
{
"equivalent_identifiers": [
"HGNC:2597"
],
"id": "HGNC:2597",
"type": ["gene"]
},
{
"equivalent_identifiers": [
"also_test_array_type_and_string_type_merge",
"egg"
],
"type": [
"foo_type",
"bar_type"
],
"id": "egg",
"name": "test_name_merge",
"test_attr": [
"a",
"b",
"c"
]
},
{
"equivalent_identifiers": [
"TEST:00000",
"equivalent_identifier_merge"
],
"merged_property": ["a", "b", "c"],
"id": "equivalent_identifier_merge",
"type": ["test"]
}
]
},
"knowledge_map": [
{
"edge_bindings": {},
"node_bindings": {
"chemical_substance": "CHEBI:28177",
"gene": "HGNC:2597"
}
},
{
"edge_bindings": {},
"node_bindings": {
"chemical_substance": "CHEBI:28177",
"test": "equivalent_identifier_merge"
}
}
],
'question_graph': {
'edges': [
{
'id': 'foo',
'type': 'test'
}
],
'nodes': [
{
'id': 'bar',
'type': 'bartest'
}
]
}
}
merged_results = select.merge_results (
mock_responses,
tranql,
{
'edges': [
{
'id': 'foo',
'type': 'test'
}
],
'nodes': [
{
'id': 'bar',
'type': 'bartest'
}
]
},
root_order=None
)
assert ordered(merged_results) == ordered(expected_result)
def test_ast_merge_knowledge_maps (requests_mock):
set_mock(requests_mock, "workflow-5")
tranql = TranQL ()
tranql.asynchronous = False
tranql.resolve_names = False
ast = tranql.parse ("""
select chemical_substance->disease->gene
from "/schema"
where chemical_substance="CHEMBL:CHEMBL3"
""")
# select = ast.statements[0]
# statements = select.plan (select.planner.plan (select.query))
# print(statements[0].query.order)
# (select.execute_plan(tranql))
responses = [
{
'knowledge_map' : [
{
'node_bindings' : {
'chemical_substance' : 'CHEBI:100',
'disease' : 'MONDO:50'
},
'edge_bindings' : {
'e0' : 'ROOT_EDGE'
}
}
],
'question_order' : ['chemical_substance','disease']
},
{
'knowledge_map' : [
{
'node_bindings' : {
'disease' : 'MONDO:50',
'gene' : 'HGNC:1',
'metabolite' : 'KEGG:C00017'
},
'edge_bindings' : {
'e1' : 'TEST_EDGE'
}
}
],
'question_order' : ['disease','gene','metabolite']
},
{
'knowledge_map' : [
{
'node_bindings' : {
'disease' : 'MONDO:50',
'gene' : 'HGNC:1',
'metabolite' : 'KEGG:FOOBAR'
},
'edge_bindings' : {
}
}
],
'question_order' : ['disease','gene','metabolite']
},
{
'knowledge_map' : [
{
'node_bindings' : {
'metabolite' : 'KEGG:FOOBAR',
'protein' : 'UniProtKB:TESTING'
},
'edge_bindings' : {
}
}
],
'question_order' : ['metabolite','protein']
},
{
'knowledge_map' : [
{
'node_bindings' : {
'metabolite' : 'KEGG:C00017',
'protein' : 'UniProtKB:Q9NZJ5'
},
'edge_bindings' : {
}
}
],
'question_order' : ['metabolite','protein']
}
]
merged = SelectStatement.connect_knowledge_maps(responses,[
'chemical_substance',
'disease',
'gene',
'metabolite',
'protein'
])
assert_lists_equal(ordered(merged), ordered([
{
"node_bindings" : {
"chemical_substance" : "CHEBI:100",
"disease" : "MONDO:50",
"gene" : "HGNC:1",
"metabolite" : "KEGG:FOOBAR",
"protein" : "UniProtKB:TESTING"
},
"edge_bindings" : {
"e0" : "ROOT_EDGE"
}
},
{
"node_bindings" : {
"chemical_substance" : "CHEBI:100",
"disease" : "MONDO:50",
"gene" : "HGNC:1",
"metabolite" : "KEGG:C00017",
"protein" : "UniProtKB:Q9NZJ5"
},
"edge_bindings" : {
"e0" : "ROOT_EDGE",
"e1" : "TEST_EDGE",
}
}
]))
def test_ast_merge_results(requests_mock):
set_mock(requests_mock, "workflow-5")
""" Validate that
-- Results from the query plan are being merged together correctly
"""
print("test_ast_merge_answers ()")
tranql = TranQL()
tranql.resolve_names = False
ast = tranql.parse("""
SELECT cohort_diagnosis:disease->diagnoses:disease
FROM '/clinical/cohort/disease_to_chemical_exposure'
WHERE cohort_diagnosis = 'MONDO:0004979' --asthma
AND Sex = '0'
AND cohort = 'all_patients'
AND max_p_value = '0.5'
SET '$.knowledge_graph.nodes.[*].id' AS diagnoses
""")
select = ast.statements[0]
# What is the proper format for the name of a mock file? This should be made into one
mock_responses = [{
'knowledge_graph': {
'nodes': [{
'id': 'CHEBI:28177',
'type': 'chemical_substance'
}, {
'id': 'HGNC:2597',
'type': 'gene'
}],
'edges': [{
'id': 'e0',
'source_id': 'CHEBI:28177',
'target_id': 'HGNC:2597'
}]
},
'knowledge_map': [{
'node_bindings': {
'chemical_substance': 'CHEBI:28177',
'gene': 'HGNC:2597'
},
'edge_bindings': {
'e1': ['e0'],
's0': '1cdd83d6-7f6b-4b17-9139-63f8e81f2122'
},
'score': 0.09722323258334348
}]
}, {
'knowledge_graph': {
'nodes': [{
'id': 'CHEBI:28177',
'type': 'chemical_substance'
}, {
'id': 'TEST:00000',
'type': 'test'
}],
'edges': [{
'id': 'e0',
'source_id': 'CHEBI:28177',
'target_id': 'TEST:00000'
}]
},
'knowledge_map': [{
'node_bindings': {
'chemical_substance': 'CHEBI:28177',
'test': 'TEST:00000'
},
'edge_bindings': {
'e1': ['e0'],
's0': '1cdd83d6-7f6b-4b17-9139-63f8e81f2122'
},
'score': 0.09722323258334348
}]
}]
expected_result = {
"knowledge_graph": {
"edges": [{
"id": "e0",
"source_id": "CHEBI:28177",
"target_id": "HGNC:2597"
}, {
"id": "e0",
"source_id": "CHEBI:28177",
"target_id": "TEST:00000"
}],
"nodes": [{
"equivalent_identifiers": ["CHEBI:28177"],
"id": "CHEBI:28177",
"type": "chemical_substance"
}, {
"equivalent_identifiers": ["HGNC:2597"],
"id": "HGNC:2597",
"type": "gene"
}, {
"equivalent_identifiers": ["TEST:00000"],
"id": "TEST:00000",
"type": "test"
}]
},
"knowledge_map": [{
"edge_bindings": {
"e1": ["e0"],
"s0": "1cdd83d6-7f6b-4b17-9139-63f8e81f2122"
},
"node_bindings": {
"chemical_substance": "CHEBI:28177",
"gene": "HGNC:2597"
},
"score": 0.09722323258334348
}, {
"edge_bindings": {
"e1": ["e0"],
"s0": "1cdd83d6-7f6b-4b17-9139-63f8e81f2122"
},
"node_bindings": {
"chemical_substance": "CHEBI:28177",
"test": "TEST:00000"
},
"score": 0.09722323258334348
}]
}
merged_results = select.merge_results(mock_responses, select.service,
tranql)
assert (merged_results == expected_result)