def test_default_batch_query(self):
# These are non-simple queries
queries = [message["message"] for message in self.queries[2:8]]
interface = TrapiInterface(query=queries, client_id='default')
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_mix_batch_query(self):
# These are mix batch of simple and default queries
queries = [message["message"] for message in self.queries]
interface = TrapiInterface(query=queries, client_id='default')
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_batch_drug_wildcard_query(self):
for trapi_version, queries in self.drug_batch_queries.items():
query = Query.load(trapi_version, None, query=queries[0])
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_simple_single_query(self):
# This is a simple query
message = self.queries[1]
query = message["message"]
interface = TrapiInterface(query=query, client_id='default')
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_batch_drug_onehop_query(self):
queries = [message["message"] for message in self.gene_queries]
interface = TrapiInterface(query=queries,
client_id='default',
max_results=10)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_simple_single_query(self):
# This is a simple query
logger.info('Running single simple query test.')
for trapi_version, queries in self.queries.items():
query = Query.load(trapi_version, None, query=queries[1])
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_single_gene_wildcard_query(self):
message = self.gene_queries[0]
query = message["message"]
interface = TrapiInterface(query=query,
client_id='default',
max_results=10)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_mix_batch_reasoner_test_queries(self):
with open('query_samples/test_reasoner_coulomb_queries.pk',
'rb') as f_:
_queries = pickle.load(f_)
queries = [message["message"] for message in _queries]
interface = TrapiInterface(query=queries, client_id='default')
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_simple_batch_query(self):
# These are simple queries
logger.info('Running batch simple query test.')
for trapi_version, queries in self.batch_queries.items():
query = Query.load(trapi_version, None, query=queries[0])
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_wildcard_batch_onehop_query(self):
for trapi_version, queries in self.wildcard_batch_queries.items():
for name, query_dict in queries.items():
#if name != 'gene_to_disease_proxy_context':
# continue
query = Query.load(trapi_version, None, query=query_dict)
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_inverse_wildcard_query(self):
for trapi_version, queries in self.gene_queries.items():
query = Query.load(trapi_version, None, query=queries[0])
for edge_id, edge in query.message.query_graph.edges.items():
predicate = edge.predicates[0]
inverse = edge.predicates[0].get_inverse()
edge.set_predicates(inverse)
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_inverse_query(self):
# This is a simple query
logger.info('Running default inverse query test.')
for trapi_version, queries in self.queries.items():
query = Query.load(trapi_version, None, query=queries[1])
for edge_id, edge in query.message.query_graph.edges.items():
predicate = edge.predicates[0]
inverse = edge.predicates[0].get_inverse()
edge.set_predicates(inverse)
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_inverse_onehop_query(self):
for trapi_version, queries in self.standard_single_queries.items():
for name, query_dict in queries.items():
#if name != 'gene_to_disease_proxy_context':
# continue
query = Query.load(trapi_version, None, query=query_dict)
for edge_id, edge in query.message.query_graph.edges.items():
predicate = edge.predicates[0]
inverse = edge.predicates[0].get_inverse()
if inverse is not None:
edge.set_predicates(inverse)
interface = TrapiInterface(query=query)
interface.build_chp_queries()
interface.run_chp_queries()
response = interface.construct_trapi_response()
def test_default_survival(self):
""" Test default survival
"""
# empty response
reasoner_std = {"query_graph": dict()}
# empty query graph
reasoner_std["query_graph"] = {"edges": dict(), "nodes": dict()}
# add in evidence gene
gene1 = ('RAF1', 'ENSEMBL:ENSG00000132155')
reasoner_std['query_graph']['nodes']['n0'] = {
'category': BIOLINK_GENE,
'id': '{}'.format(gene1[1])
}
# add in disease node
disease = ('Breast_Cancer', 'MONDO:0007254')
reasoner_std['query_graph']['nodes']['n1'] = {
'category': BIOLINK_DISEASE,
'id': '{}'.format(disease[1])
}
# add target survival node
phenotype = ('Survival_Time', 'EFO:0000714')
reasoner_std['query_graph']['nodes']['n2'] = {
'category': BIOLINK_PHENOTYPIC_FEATURE,
'id': '{}'.format(phenotype[1]),
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e0'] = {
'predicate': BIOLINK_GENE_TO_DISEASE_PREDICATE,
'subject': 'n0',
'object': 'n1'
}
# link disease to target
reasoner_std['query_graph']['edges']['e1'] = {
'predicate': BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n1',
'object': 'n2',
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final['message']['knowledge_graph']
for edge_key in KG['edges'].keys():
edge = KG['edges'][edge_key]
if edge['predicate'] == BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE:
p_survival = edge['attributes'][0]['value']
print("probability of survival:", p_survival)
def test_no_evidence_omitting_KG_and_results(self):
""" Test with no evidence, but omitting KG and Results (should be handled by handler)
"""
# empty response
reasoner_std = {
"query_graph": dict(),
}
# empty query graph
reasoner_std["query_graph"] = {"edges": dict(), "nodes": dict()}
# add in disease node
disease = ('Breast_Cancer', 'MONDO:0007254')
reasoner_std['query_graph']['nodes']['n0'] = {
'category': BIOLINK_DISEASE,
'id': '{}'.format(disease[1])
}
# add target survival node
phenotype = ('Survival_Time', 'EFO:0000714')
reasoner_std['query_graph']['nodes']['n1'] = {
'category': BIOLINK_PHENOTYPIC_FEATURE,
'id': '{}'.format(phenotype[1]),
}
# link disease to target
reasoner_std['query_graph']['edges']['e0'] = {
'predicate': BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n0',
'object': 'n1',
'properties': {
'qualifier': '>=',
'days': 970
}
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final['message']['knowledge_graph']
for edge_key in KG['edges'].keys():
edge = KG['edges'][edge_key]
if edge['predicate'] == BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE:
p_survival = edge['attributes'][0]['value']
print("probability of survival:", p_survival)
def get_responses(self, queries=None, trapi_queries=None):
# Initialize interface
interface = TrapiInterface(
bkb_handler=self.bkb_handler,
dynamic_reasoner=self.dynamic_reasoner,
joint_reasoner=self.joint_reasoner,
)
# Load queries
if trapi_queries is None:
trapi_queries = [
Query.load(query["trapi_version"], None, query=query)
for query in queries
]
# Process trapi query
interface.setup_trapi_queries(trapi_queries)
# Build CHP queries
interface.build_chp_queries()
# Run CHP queries
interface.run_chp_queries()
# Get Responses
responses = interface.construct_trapi_responses()
return responses
def test_sparse_drug(self):
""" queries the drug Gemzar which has a sparsity issue. Used to throw an error.
Should be handled.
"""
# empty response
reasoner_std = {"query_graph": {}}
# empty query graph
reasoner_std["query_graph"] = {"edges": {}, "nodes": {}}
# add in evidence drug
drug = ('GEMZAR', 'CHEMBL:CHEMBL888')
reasoner_std['query_graph']['nodes']['n{}'.format('0')] = {
'category': BIOLINK_DRUG,
'id': '{}'.format(drug[1])
}
# add in gene node (to be filled by contribution analysis
reasoner_std['query_graph']['nodes']['n{}'.format('1')] = {
'category': BIOLINK_GENE,
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e{}'.format(0)] = {
'predicate': BIOLINK_CHEMICAL_TO_GENE_PREDICATE,
'subject': 'n1',
'object': 'n0'
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std, max_results=2)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final["message"]['knowledge_graph']
res = reasoner_std_final["message"]['results']
res_pretty = json.dumps(reasoner_std_final, indent=2)
print(res_pretty)
def test_no_gene_drug_phenotypic_evidence_with_drug_wildcard(self):
""" queries with no gene/drug/survival evidence, but with drug wildcard
"""
# empty response
reasoner_std = {"query_graph": {}}
# empty query graph
reasoner_std["query_graph"] = {"edges": {}, "nodes": {}}
# add in gene node (to be filled by contribution analysis
reasoner_std['query_graph']['nodes']['n0'] = {'category': BIOLINK_DRUG}
#add in disease node
disease = ('Breast_Cancer', 'MONDO:0007254')
reasoner_std['query_graph']['nodes']['n1'] = {
'category': BIOLINK_DISEASE,
'id': '{}'.format(disease[1])
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e1'] = {
'predicate':
BIOLINK_CHEMICAL_TO_DISEASE_OR_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n0',
'object': 'n1'
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std, max_results=2)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final["message"]['knowledge_graph']
res_pretty = json.dumps(reasoner_std_final, indent=2)
print(res_pretty)
def test_no_target(self):
""" Test with no target (should crash)
"""
with self.assertRaises(SystemExit) as se:
# empty response
reasoner_std = {"query_graph": dict()}
# empty query graph
reasoner_std["query_graph"] = {"edges": dict(), "nodes": dict()}
handler = TrapiInterface(query=reasoner_std)
queries = handler.build_chp_queries()
self.assertEqual(
se.exception.code,
'Survival Node not found. Node category must be \'biolink:PhenotypicFeature\' and id must be in: EFO:0000714'
)
def test_gene(self):
""" queries TP53. Should return 2 drugs.
"""
# empty response
reasoner_std = {"query_graph": dict()}
# empty query graph
reasoner_std["query_graph"] = {"edges": {}, "nodes": {}}
# add in evidence drug
reasoner_std['query_graph']['nodes']['n{}'.format('0')] = {
'category': BIOLINK_DRUG
}
# add in gene node (to be filled by contribution analysis
reasoner_std['query_graph']['nodes']['n{}'.format('1')] = {
'category': BIOLINK_GENE,
'id': 'ENSEMBL:ENSG00000141510',
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e{}'.format(0)] = {
'predicate': BIOLINK_CHEMICAL_TO_GENE_PREDICATE,
'subject': 'n0',
'object': 'n1'
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std, max_results=2)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final["message"]['knowledge_graph']
res = reasoner_std_final["message"]['results']
res_pretty = json.dumps(reasoner_std_final, indent=2)
print(res_pretty)
def test_no_disease(self):
""" Test with no disease
"""
with self.assertRaises(SystemExit) as se:
# empty response
reasoner_std = {"query_graph": dict()}
# empty query graph
reasoner_std["query_graph"] = {"edges": dict(), "nodes": dict()}
# add target survival node
phenotype = ('Survival_Time', 'EFO:0000714')
reasoner_std['query_graph']['nodes']['n2'] = {
'category': BIOLINK_PHENOTYPIC_FEATURE,
'id': '{}'.format(phenotype[1]),
}
handler = TrapiInterface(query=reasoner_std)
queries = handler.build_chp_queries()
self.assertEqual(
se.exception.code,
'Disease node not found. Node type must be \'biolink:Disease\' and curie must be in: MONDO:0007254'
)
def get_response(self, query):
""" Main function of the processor that handles primary logic for obtaining
a cached or calculated query response.
"""
query_copy = query.get_copy()
start_time = time.time()
logger.info('Running query.')
# Instaniate CHP TRAPI Interface
interface = TrapiInterface(
hosts_filename=self.chp_config.hosts_filename,
num_processes_per_host=self.chp_config.num_processes_per_host,
bkb_handler=self.chp_config.bkb_handler,
joint_reasoner=self.chp_config.joint_reasoner,
dynamic_reasoner=self.chp_config.dynamic_reasoner,
)
# Expand
expand_queries = self.expand_batch_query(query)
# Normalize to Preferred Curies
normalization_time = time.time()
normalize_queries, normalization_map = self.normalize_to_preferred(
expand_queries,
meta_knowledge_graph=interface.get_meta_knowledge_graph(),
with_normalization_map=True,
)
logger.info(
'Normalizaion time: {} seconds.'.format(time.time() -
normalization_time))
# Conflate
conflation_time = time.time()
conflate_queries = self.conflate_categories(
normalize_queries,
conflation_map=interface.get_conflation_map(),
)
logger.info('Conflation time: {} seconds.'.format(time.time() -
conflation_time))
# Onto Expand
onto_time = time.time()
onto_queries = self.expand_supported_ontological_descendants(
conflate_queries,
curies_database=interface.get_curies(),
)
logger.info(
'Ontological expansion time: {} seconds.'.format(time.time() -
onto_time))
# Semantic Ops Expand
semops_time = time.time()
semops_queries = self.expand_with_semantic_ops(
onto_queries,
meta_knowledge_graph=interface.get_meta_knowledge_graph(),
)
logger.info('Sem ops time: {} seconds.'.format(time.time() -
semops_time))
# Filter out inconsistent queries
filter_time = time.time()
consistent_queries, inconsistent_queries = self.filter_queries_inconsistent_with_meta_knowledge_graph(
semops_queries,
meta_knowledge_graph=interface.get_meta_knowledge_graph(),
with_inconsistent_queries=True)
logger.info('Consistency filter time: {} seconds.'.format(time.time() -
filter_time))
# Ensure that there are actually consistent queries that have been extracted
if len(consistent_queries) == 0:
# Add all logs from inconsistent queries
query_copy = self.add_logs_from_query_list(query_copy,
inconsistent_queries)
query_copy.set_status('Bad request. See description.')
query_copy.set_description(
'Could not extract any supported queries from query graph.')
self.add_transaction(query_copy)
return JsonResponse(query_copy.to_dict())
logger.info(
'Number of consistent queries derived from passed query: {}.'.
format(len(consistent_queries)))
# Get disease specific interfaces if a subdomain was not used
try:
interface_dict = self.setup_queries_based_on_disease_interfaces(
consistent_queries)
except ValueError as ex:
# Add logs from consistent queries
query_copy = self.add_logs_from_query_list(query_copy,
consistent_queries)
query_copy.set_status('Bad request. See description.')
query_copy.set_description('Problem during setup. ' + str(ex))
self.add_transaction(query_copy)
return JsonResponse(query_copy.to_dict())
# Setup for CHP inferencing
try:
setup_time = time.time()
for interface, queries in interface_dict.items():
interface.setup_trapi_queries(queries)
logger.info(
'Trapi Interface setup time: {} seconds.'.format(time.time() -
setup_time))
except Exception as ex:
# Add logs from consistent queries
query_copy = self.add_logs_from_query_list(query_copy,
consistent_queries)
# Add logs from interfaces level
for interface in interface_dict:
query_copy.logger.add_logs(interface.logger.to_dict())
query_copy.set_status('Bad request. See description.')
query_copy.set_description('Problem during interface setup. ' +
str(ex))
self.add_transaction(query_copy)
return JsonResponse(query_copy.to_dict())
# Build CHP queries
try:
build_time = time.time()
for interface in interface_dict:
interface.build_chp_queries()
logger.info(
'CHP query build time: {} seconds.'.format(time.time() -
build_time))
except Exception as ex:
# Add logs from consistent queries
query_copy = self.add_logs_from_query_list(query_copy,
consistent_queries)
# Add logs from interfaces level
for interface in interface_dict:
query_copy.logger.add_logs(interface.logger.to_dict())
query_copy.set_status('Bad request. See description.')
query_copy.set_description('Problem during CHP query building. ' +
str(ex))
self.add_transaction(query_copy)
return JsonResponse(query_copy.to_dict())
logger.info('Built Queries.')
# Run queries
try:
reasoning_start_time = time.time()
for interface in interface_dict:
interface.run_chp_queries()
logger.info('Completed Reasoning in {} seconds.'.format(
time.time() - reasoning_start_time))
except Exception as ex:
# Add logs from consistent queries
query_copy = self.add_logs_from_query_list(query_copy,
consistent_queries)
# Add logs from interfaces level
for interface in interface_dict:
query_copy.logger.add_logs(interface.logger.to_dict())
query_copy.set_status('Unexpected error. See description.')
query_copy.set_description('Problem during reasoning. ' + str(ex))
self.add_transaction(query_copy)
# Report critical error to logs
logger.critical('Error during reasoning. Check query: {}'.format(
query_copy.id))
return JsonResponse(query_copy.to_dict())
# Construct Response
responses = []
for interface in interface_dict:
responses.extend(interface.construct_trapi_responses())
# Check if any responses came back
if len(responses) == 0:
# Add logs from consistent queries
query_copy = self.add_logs_from_query_list(query_copy,
consistent_queries)
# Add logs from interfaces level
for interface in interface_dict:
query_copy.logger.add_logs(interface.logger.to_dict())
query_copy.set_status('No results.')
self.add_transaction(query_copy)
return JsonResponse(query_copy.to_dict())
# Add responses into database
self.add_transactions(responses)
# Construct merged response
response = self.merge_responses(query_copy, responses)
# Now merge all interface level log messages from each interface
for interface in interface_dict:
response.logger.add_logs(interface.logger.to_dict())
# Unnormalize
unnormalized_response = self.undo_normalization(
response, normalization_map)
logger.info('Constructed TRAPI response.')
logger.info('Responded in {} seconds'.format(time.time() - start_time))
unnormalized_response.set_status('Success')
# Add workflow
unnormalized_response.add_workflow("lookup")
# Set the used biolink version
unnormalized_response.biolink_version = TOOLKIT.get_model_version()
# Add response to database
self.add_transaction(unnormalized_response)
return JsonResponse(unnormalized_response.to_dict())
def test_normal_two_genes_and_drug(self):
""" Normal request with two genes and a drug
"""
# empty response
reasoner_std = {"query_graph": dict()}
# empty query graph
reasoner_std["query_graph"] = {"edges": dict(), "nodes": dict()}
# add in evidence gene
gene1 = ('RAF1', 'ENSEMBL:ENSG00000132155')
reasoner_std['query_graph']['nodes']['n0'] = {
'category': BIOLINK_GENE,
'id': '{}'.format(gene1[1])
}
gene2 = ('BRCA1', 'ENSEMBL:ENSG00000012048')
reasoner_std['query_graph']['nodes']['n1'] = {
'category': 'biolink:Gene',
'id': '{}'.format(gene2[1])
}
# add in evidence drug
drug = ('CYCLOPHOSPHAMIDE', 'CHEMBL:CHEMBL88')
reasoner_std['query_graph']['nodes']['n2'] = {
'category': BIOLINK_DRUG,
'id': '{}'.format(drug[1])
}
# add in disease node
disease = ('Breast_Cancer', 'MONDO:0007254')
reasoner_std['query_graph']['nodes']['n3'] = {
'category': BIOLINK_DISEASE,
'id': '{}'.format(disease[1])
}
# add target survival node
phenotype = ('Survival_Time', 'EFO:0000714')
reasoner_std['query_graph']['nodes']['n4'] = {
'category': BIOLINK_PHENOTYPIC_FEATURE,
'id': '{}'.format(phenotype[1]),
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e0'] = {
'predicate': BIOLINK_GENE_TO_DISEASE_PREDICATE,
'subject': 'n0',
'object': 'n3'
}
reasoner_std['query_graph']['edges']['e1'] = {
'predicate': BIOLINK_GENE_TO_DISEASE_PREDICATE,
'subject': 'n1',
'object': 'n3'
}
reasoner_std['query_graph']['edges']['e2'] = {
'predicate':
BIOLINK_CHEMICAL_TO_DISEASE_OR_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n2',
'object': 'n3'
}
# link disease to target
reasoner_std['query_graph']['edges']['e3'] = {
'predicate': BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n3',
'object': 'n4',
'properties': {
'qualifier': '>=',
'days': 970
}
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final['message']['knowledge_graph']
for edge_key in KG['edges'].keys():
edge = KG['edges'][edge_key]
if edge['predicate'] == BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE:
p_survival = edge['attributes'][0]['value']
print("probability of survival:", p_survival)
def test_no_gene_drug_evidence_with_drug_wildcard(self):
""" queries with no gene/drug evidence, but with drug wildcard
"""
# empty response
reasoner_std = {"query_graph": {}}
# empty query graph
reasoner_std["query_graph"] = {"edges": {}, "nodes": {}}
# add in gene node (to be filled by contribution analysis
reasoner_std['query_graph']['nodes']['n0'] = {'category': BIOLINK_DRUG}
#add in disease node
disease = ('Breast_Cancer', 'MONDO:0007254')
reasoner_std['query_graph']['nodes']['n1'] = {
'category': BIOLINK_DISEASE,
'id': '{}'.format(disease[1])
}
# add target survival node
phenotype = ('Survival_Time', 'EFO:0000714')
reasoner_std['query_graph']['nodes']['n2'] = {
'category': BIOLINK_PHENOTYPIC_FEATURE,
'id': '{}'.format(phenotype[1]),
}
# link disease to target survival node
reasoner_std['query_graph']['edges']['e0'] = {
'predicate': BIOLINK_DISEASE_TO_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n1',
'object': 'n2',
'properties': {
'qualifier': '>=',
'days': 1000
}
}
# link genes/drugs to disease
reasoner_std['query_graph']['edges']['e1'] = {
'predicate':
BIOLINK_CHEMICAL_TO_DISEASE_OR_PHENOTYPIC_FEATURE_PREDICATE,
'subject': 'n0',
'object': 'n1'
}
# test input is TRAPI compliant
validate_Message(
reasoner_std
) # doesn't return True/False for some reason... Will just present exception if not compliant
handler = TrapiInterface(query=reasoner_std, max_results=2)
queries = handler.build_chp_queries()
queries = handler.run_chp_queries()
reasoner_std_final = handler.construct_trapi_response()
# test output is TRAPI compliant
validate_Message(reasoner_std_final['message'])
KG = reasoner_std_final["message"]['knowledge_graph']
res_pretty = json.dumps(reasoner_std_final, indent=2)
print(res_pretty)
# extract probability
for _, edge in KG['edges'].items():
if edge['predicate'] == 'biolink:has_phenotype':
p_survival = edge['attributes'][0]['value']
break
print("probability of survival:", p_survival)
