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_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_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_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 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_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_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 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)