def term_to_term(self,node_a,node_b,limit = 10000):
"""Given two diseases, check the co-occurrence """
icd9_a = list(filter( lambda x: x.startswith('ICD9'), node_a.synonyms ) )
icd9_b = list(filter( lambda x: x.startswith('ICD9'), node_b.synonyms ) )
if (len(icd9_a) == 0) or (len(icd9_b) == 0):
#can't do co-occurence unless we get icd9 codes
return
co_occurrences = []
for icd9a_curie in icd9_a:
icd9a = Text.un_curie(icd9a_curie)
if icd9a not in self.icd9_codes:
logging.getLogger('application').debug('Dont have data for {}'.format(icd9a))
continue
for icd9b_curie in icd9_b:
icd9b = Text.un_curie(icd9b_curie)
if icd9b not in self.icd9_codes:
logging.getLogger('application').debug('Dont have data for {}'.format(icd9b))
continue
#Now we have nodes that both have ICD9 codees and the both map to our results!
k = (icd9a, icd9b)
if k not in self.icd9_paircounts:
#There were less than 11 shared counts.
counta = self.icd9_codes[icd9a]
countb = self.icd9_codes[icd9b]
expected = float(counta) * float(countb) / self.total
co_occurrences.append( (k, {'c1': counta, 'c2': countb, 'c': '<11', 'e': expected, 'p':None}) )
else:
co_occurrences.append( (k, self.icd9_paircounts[k] ) )
if len(co_occurrences) > 0:
return self.make_edge(co_occurrences, node_a, node_b)
return None
def go_term_to_cell_xontology_relationships(self, go_node):
#This call is not paged!
url = "{0}/QuickGO/services/ontology/go/terms/GO:{1}/xontologyrelations".format(
self.url, Text.un_curie(go_node.id))
response = self.query(url)
if 'results' not in response:
return []
results = []
for r in response['results']:
if 'xRelations' in r:
for xrel in r['xRelations']:
if xrel['id'].startswith('CL:'):
predicate = self.get_predicate(xrel['relation'])
if predicate is None:
continue
cell_node = KNode(xrel['id'],
type=node_types.CELL,
name=xrel['term'])
edge = self.create_edge(
go_node,
cell_node,
'quickgo.go_term_to_cell_xontology_relationships',
go_node.id,
predicate,
url=url)
results.append((edge, cell_node))
return results
async def get_inchikey_data(self, inchikey_id):
conf = self.get_prefix_config('INCHIKEY')
inchikey_c_id = Text.un_curie(inchikey_id)
url = conf['url'] + inchikey_c_id
response = await self.async_get_text(url)
inchikey_dict = self.parse_flat_file_to_dict(response)
return self.extract_inchikey_data(inchikey_dict, conf['keys'])
async def get_kegg_data(self, kegg_id):
conf = self.get_prefix_config('KEGG.COMPOUND')
kegg_c_id = Text.un_curie(kegg_id)
url = conf['url'] + kegg_c_id
response = await self.async_get_text(url)
kegg_dict = self.parse_flat_file_to_dict(response)
return self.extract_kegg_data(kegg_dict, conf['keys'])
def drug_get_gene(self, subject):
""" Get a gene from a drug. """
resolved_edge_nodes = []
identifiers = subject.get_synonyms_by_prefix('CHEMBL.COMPOUND')
for s in identifiers:
pharosid = Text.un_curie(s)
original_edge_nodes = []
url = 'https://pharos.nih.gov/idg/api/v1/ligands(%s)?view=full' % pharosid
r = requests.get(url)
try:
result = r.json()
except:
#Pharos returns a 404 if it doesn't recognize the identifier, which ends up producing
# errors in turning into json. Skip to next identifier
continue
actions = set() # for testing
predicate = LabeledID(identifier='PHAROS:drug_targets', label='is_target')
for link in result['links']:
if link['kind'] == 'ix.idg.models.Target':
pharos_target_id = int(link['refid'])
hgnc = self.target_to_hgnc(pharos_target_id)
if hgnc is not None:
hgnc_node = KNode(hgnc, type=node_types.GENE)
edge = self.create_edge(subject,hgnc_node,'pharos.drug_get_gene',pharosid,predicate,url=url)
resolved_edge_nodes.append((edge, hgnc_node))
else:
logging.getLogger('application').warn('Did not get HGNC for pharosID %d' % pharos_target_id)
return resolved_edge_nodes
def execute(self):
"""Execute the query that defines the graph"""
self.logger.debug('Executing Query')
#GreenT wants a cypherquery to find transitions, and a starting point
cyphers = self.userquery.generate_cypher()
starts = self.userquery.get_start_node()
reverses = self.userquery.get_reversed()
lookups = self.userquery.get_lookups()
for cypher, start, reverse,lookup in zip(cyphers,starts,reverses,lookups):
input_name = Text.un_curie(lookup.identifier)
self.logger.debug(start)
self.logger.debug('CYPHER')
self.logger.debug(cypher)
identifier, ntype = start
start_node = KNode( identifier, ntype, label=input_name )
kedge = KEdge( 'lookup', 'lookup' )
kedge.source_node = lookup
kedge.target_node = start_node
self.add_nonsynonymous_edge( kedge )
#Fire this to rosetta, collect the result
result_graph = self.rosetta.graph([(None, start_node)],query=cypher)
#result_graph contains duplicate edges. Remove them, while preserving order:
result_graph = list(OrderedDict.fromkeys( result_graph ) )
self.add_edges( result_graph , reverse )
self.logger.debug('Query Complete')
def gene_to_drug_expanded(self, gene_node):
output = []
identifiers = gene_node.get_synonyms_by_prefix('NCBIGENE')
for identifier in identifiers:
unique = set()
geneid = Text.un_curie(identifier)
url = f"{self.url}CTD_chem_gene_expanded_geneID/ncbigene:{geneid}/"
obj = requests.get (url).json ()
for r in obj:
good_row, predicate_label, props, pmids = self.check_expanded_gene_chemical_row(r)
if not good_row:
continue
predicate = self.normalize_predicate(
LabeledID(identifier=f"CTD:{Text.snakify(predicate_label)}", label=predicate_label)
)
#Should this be substance?
drug_node = KNode(Text.upper_curie(r['chemicalID']), type=node_types.CHEMICAL_SUBSTANCE, name=r['chem_label'])
direction = r['direction']
if direction == '->':
subject = drug_node
object = gene_node
else:
subject = gene_node
object = drug_node
edge = self.create_edge(subject,object,'ctd.gene_to_drug_expanded',identifier,predicate,properties = props,url=url,publications=pmids)
#This is what we'd like it to be, but right now there's not enough real specificity on the predicates
#key = (drug_node.id, edge.standard_predicate.label)
key = (drug_node.id, edge.original_predicate.label)
if key not in unique:
output.append( (edge,drug_node) )
unique.add(key)
return output
def gene_to_drug(self, gene_node):
output = []
identifiers = gene_node.get_synonyms_by_prefix('NCBIGENE')
for identifier in identifiers:
unique = set()
geneid = Text.un_curie(identifier)
url = f"{self.url}/CTD_chem_gene_ixns_GeneID/{geneid}/"
obj = requests.get (url).json ()
for r in obj:
if r['GeneID'] != geneid:
continue
good_row, predicate_label, props = self.check_gene_chemical_row(r)
if not good_row:
continue
predicate = self.normalize_predicate(
LabeledID(identifier=f'CTD:{predicate_label}', label=predicate_label)
)
#Should this be substance?
drug_node = KNode(f"MESH:{r['ChemicalID']}", type=node_types.CHEMICAL_SUBSTANCE, name=f"{r['ChemicalName']}")
if sum([s in predicate.identifier for s in self.g2d_strings]) > 0:
subject = gene_node
obj = drug_node
else:
subject = drug_node
obj = gene_node
edge = self.create_edge(subject,obj,'ctd.gene_to_drug',identifier,predicate,
publications=[f"PMID:{x}" for x in r['PubMedIDs'].split('|') ],url=url,properties=props)
#This is what we'd like it to be, but right now there's not enough real specificity on the predicates
#key = (drug_node.id, edge.standard_predicate.label)
key = (drug_node.id, edge.original_predicate.label)
if key not in unique:
output.append( (edge,drug_node) )
unique.add(key)
return output
def disease_get_gene(self, disease_node):
""" Get a gene from a pharos disease id."""
resolved_edge_nodes = []
hgncs = set()
# WD:P2293 gene assoc with condition.
# domain is gene and range is disease or phenotype for this relationship
predicate = LabeledID(identifier='WD:P2293', label='gene_involved')
#Pharos contains multiple kinds of disease identifiers in its disease table:
# For OMIM identifiers, they can have either prefix OMIM or MIM
# UMLS doen't have any prefixes.... :(
pharos_predicates = {'DOID':('DOID',),'UMLS':(None,),'MESH':('MESH',),'OMIM':('OMIM','MIM'),'ORPHANET':('Orphanet',)}
for ppred,dbpreds in pharos_predicates.items():
pharos_candidates = [Text.un_curie(x) for x in disease_node.get_synonyms_by_prefix(ppred)]
for dbpred in dbpreds:
if dbpred is None:
pharos_ids = pharos_candidates
else:
pharos_ids = [f'{dbpred}:{x}' for x in pharos_candidates]
for pharos_id in pharos_ids:
cursor = self.db.cursor(dictionary = True, buffered = True)
query = f"select distinct x.value, p.sym from disease d join xref x on x.protein_id = d.target_id join protein p on d.target_id = p.id where x.xtype = 'HGNC' and d.dtype <> 'Expression Atlas' and d.did='{pharos_id}';"
cursor.execute(query)
for result in cursor:
label = result['sym']
hgnc = result['value']
if hgnc not in hgncs:
hgncs.add(hgnc)
gene_node = KNode(hgnc, type=node_types.GENE, name=label)
edge = self.create_edge(gene_node, disease_node, 'pharos.disease_get_gene', pharos_id, predicate)
resolved_edge_nodes.append((edge, gene_node))
return resolved_edge_nodes
def drug_get_gene(self, subject):
""" Get a gene from a pharos disease id. """
pharosid = Text.un_curie (subject.identifier)
original_edge_nodes=[]
r = requests.get('https://pharos.nih.gov/idg/api/v1/ligands(%s)?view=full' % pharosid)
result = r.json()
resolved_edge_nodes = []
actions = set() #for testing
for link in result['links']:
if link['kind'] == 'ix.idg.models.Target':
pharos_target_id = int(link['refid'])
edge_properties = {}
for prop in link['properties']:
if prop['label'] == 'Pharmalogical Action': #!
actions.add(prop['term'] )
pharos_edge = KEdge( 'pharos', 'drug_get_gene', {'properties': link['properties']} )
#Pharos returns target ids in its own numbering system. Collect other names for it.
hgnc = self.target_to_hgnc (pharos_target_id)
if hgnc is not None:
hgnc_node = KNode (hgnc, node_types.GENE)
resolved_edge_nodes.append( (pharos_edge, hgnc_node) )
else:
logging.getLogger('application').warn('Did not get HGNC for pharosID %d' % pharos_target_id)
# for a in actions:
# print ('Action: {}'.format(a) )
return resolved_edge_nodes
def graph_drugbank_to_uniprot(self, drugbank):
response = self.triplestore.query_template(inputs={
"drugID":
"DB{0}".format(Text.un_curie(drugbank.identifier))
},
outputs=["uniprotGeneID"],
template_text="""
prefix drugbank: <http://chem2bio2rdf.org/drugbank/resource/>
prefix drugbank_drug: <http://chem2bio2rdf.org/drugbank/resource/drugbank_drug/>
prefix ctd: <http://chem2bio2rdf.org/ctd/resource/>
select distinct ?uniprotGeneID where {
values ( ?drugID ) { ( drugbank_drug:${drugID} ) }
?dbInter drugbank:GeneBank_ID ?geneBankID ;
drugbank:gene ?uniprotGeneID .
?drugID drugbank:CID ?pubchemCID ;
drugbank:Generic_Name ?drugGenericName .
?ctd_disease ctd:diseaseid ?diseaseID ;
ctd:cid ?pubchemCID .
}""")
predicate = LabeledID(identifier='SIO:001257',
label='chemical to gene association')
results = []
for r in response:
node = KNode("UNIPROT:{0}".format(
r['uniprotGeneID'].split('/')[-1:][0]),
type=node_types.GENE)
edge = self.create_edge(drugbank, node,
'chembio.graph_drugbank_to_uniprot',
predicate, drugbank.id)
results.append(edge, node)
return results
def go_term_to_cell_annotation_extensions(self, go_node):
"""This is playing a little fast and loose with the annotations. Annotations relate a gene to a go term,
and they can have an extension like occurs_in(celltype). Technically, that occurs_in only relates to that
particular gene/go combination. But it's the only way to traverse from neurotransmitter release to neurons
that is currently available"""
url = '{0}/QuickGO/services/annotation/search?includeFields=goName&goId=GO:{1}&taxonId=9606&extension=occurs_in(CL)'.format(
self.url, Text.un_curie(go_node.id))
call_results = self.page_calls(url)
cell_ids = set()
results = []
for r in call_results:
for e in r['extensions']:
for c in e['connectedXrefs']:
if c['db'] == 'CL':
if c['id'] not in cell_ids:
predicate = self.get_predicate(c['qualifier'])
if predicate is None:
continue
#Bummer, don't get a name
cell_node = KNode('CL:{}'.format(c['id']),
type=node_types.CELL)
edge = self.create_edge(
go_node,
cell_node,
'quickgo.go_term_to_cell_annotation_extensions',
go_node.id,
predicate,
url=url)
results.append((edge, cell_node))
cell_ids.add(c['id'])
return results
def gene_get_drug(self, gene_node):
""" Get a drug from a gene. """
resolved_edge_nodes = []
identifiers = gene_node.get_synonyms_by_prefix('UNIPROTKB')
for s in identifiers:
try:
logger.debug(f'Call with {s}')
pharosid = Text.un_curie(s)
original_edge_nodes = []
url = 'https://pharos.nih.gov/idg/api/v1/targets(%s)?view=full' % pharosid
r = requests.get(url)
try:
result = r.json()
logger.debug('back')
except:
#If pharos doesn't know the identifier, it just 404s. move to the next
logger.debug('404')
continue
actions = set() # for testing
predicate = LabeledID(identifier='PHAROS:drug_targets', label='is_target')
chembl_id = None
for link in result['links']:
if link['kind'] == 'ix.idg.models.Ligand':
pharos_drug_id = link['refid']
chembl_id, label = self.drugid_to_identifiers(pharos_drug_id)
if chembl_id is not None:
drug_node = KNode(chembl_id, type=node_types.CHEMICAL_SUBSTANCE, name=label)
edge = self.create_edge(drug_node,gene_node, 'pharos.gene_get_drug',
pharosid,predicate, url=url)
resolved_edge_nodes.append( (edge,drug_node) )
except:
logger.debug("Error encountered calling pharos with",s)
logger.debug('ok')
return resolved_edge_nodes
def chemical_get_enzyme(self,chemnode):
"""To get an enzyme from chemicals, we first look up the reactions for the chemical.
Then we pull the reaction which gives us (1) the enzyme and (2) whether the chemical
is a reactant or a product."""
reactions = self.chemical_get_reaction(chemnode)
chemids = set([Text.un_curie(x) for x in chemnode.get_synonyms_by_prefix('KEGG')])
results = []
for reaction_id in reactions:
rxns = self.get_reaction(reaction_id)
for rxn in rxns:
if 'enzyme' in rxn:
for gene_id in rxn['enzyme']:
enzyme = KNode(gene_id, type=node_types.GENE)
if len(chemids.intersection(rxn['reactants'])) > 0:
predicate = LabeledID('CTD:increases_degradation_of', label='increases degradation of')
#predicate = LabeledID('RO:0002449','negatively regulates, entity to entity')
input_identifier = chemids.intersection(rxn['reactants']).pop()
elif len(chemids.intersection(rxn['products'])) > 0:
predicate = LabeledID('CTD:increases_synthesis_of', label='increases synthesis of')
#predicate = LabeledID('RO:0002450','positively regulates, entity to entity')
input_identifier = chemids.intersection(rxn['products']).pop()
else:
logger.error(f"Mismatch between query and answer: {rxn} {chemids}")
continue
edge = self.create_edge(enzyme, chemnode, f'kegg.chemical_get_enzyme', input_identifier, predicate)
results.append( (edge, enzyme))
return results
def graph_diseasename_to_uniprot(self, disease):
results = []
response = self.triplestore.query_template(
inputs={"diseaseName": Text.un_curie(disease.id)},
outputs=["pubChemCID"],
template_text="""
prefix ctd: <http://chem2bio2rdf.org/ctd/resource/>
select distinct ?pubChemCID where {
values ( ?diseaseName ) { ( "$diseaseName" ) }
?ctdChemDis ctd:cid ?pubChemCID;
ctd:diseasename ?diseaseNameRec.
filter regex(lcase(str(?diseaseNameRec)), lcase(?diseaseName))
} LIMIT 1""")
if len(response) > 0: # This is a disease.
response = self.triplestore.query_template(
inputs={"diseaseName": Text.un_curie(disease.id)},
outputs=["disPmids", "chemPmids", "uniprotSym"],
template_text="""
prefix ctd: <http://chem2bio2rdf.org/ctd/resource/>
select ?disPmids ?ctdChemDis ?chemPmids ?uniprotSym ?diseaseId where {
values ( ?diseaseName ) { ( "$diseaseName" ) }
?ctdChemGene ctd:cid ?pubChemCID;
ctd:pubmedids ?chemPmids;
ctd:gene ?uniprotSym.
?ctdChemDis ctd:cid ?pubChemCID;
ctd:diseaseid ?diseaseId;
ctd:diseasename ?diseaseNameRec;
ctd:pubmedids ?disPmids.
filter regex(lcase(str(?diseaseNameRec)), lcase(?diseaseName))
} LIMIT 500""")
predicate = LabeledID(identifier='NCIT:R176',
label='disease to gene association')
for r in response:
chemPmids = r['chemPmids']
disPmids = r['disPmids']
pmids = chemPmids + "|" + disPmids
node = KNode("UNIPROT:{0}".format(
r['uniprotSym'].split('/')[-1:][0]),
type=node_types.GENE)
edge = self.create_edge(disease,
node,
'chembio.graph_diseasename_to_uniprot',
disease.id,
predicate,
publications=pmids)
results.append((edge, node))
return results
def drugname_to_pharos(self, namenode):
drugname = Text.un_curie(namenode.identifier)
pharosids = drugname_string_to_pharos_string(drugname)
for pharosid, pharoslabel in pharosids:
newnode = KNode( pharosid, node_types.DRUG, label=pharoslabel)
newedge = KEdge( 'pharos', 'drugname_to_pharos', {} )
results.append( (newedge, newnode ) )
return results
def gene_get_go(self, gene):
# this function is very finicky. gene must be in uniprotkb, and the curie prefix must be correctly capitalized
url = "{0}/bioentity/gene/UniProtKB:{1}/function/".format(
self.url, Text.un_curie(gene.identifier))
response = requests.get(url).json()
# return [ (a['object']['id'] , a['object']['label']) for a in response['associations'] ]
return self.process_associations(response, 'gene_get_go',
node_types.PROCESS)
def gene_to_cell(self, gene):
result = self.query(
"MATCH (g:Gene)-[r]-(c:CellularComponent) WHERE g.name='{0}' RETURN g, r, c LIMIT 200"
.format(Text.un_curie(gene.identifier)),
labels=['CellularComponent'],
node_properties=['identifier'])
return [(self.get_edge({'res': r}, predicate='affects'),
KNode(r['identifier'], node_types.CELLULAR_COMPONENT))
for r in result]
def drugname_to_ctd(self, namenode):
drugname = Text.un_curie(namenode.identifier)
ctdids = self.drugname_string_to_ctd_string(drugname)
for ctd in ctdids:
label = drugname
newnode = KNode(ctdid, node_types.DRUG, label=label)
newedge = KEdge('CTD', 'drugname_to_ctd', {})
results.append((newedge, newnode))
return results
def gene_to_anatomy(self, gene):
result = self.query(
"MATCH (a:Anatomy)-[ar]-(g:Gene) WHERE g.name='{0}' RETURN a, ar, g LIMIT 200"
.format(Text.un_curie(gene.identifier)),
labels=['Anatomy'],
node_properties=['identifier'])
print(result)
return [(self.get_edge({'res', r}, predicate='involved_in'),
KNode(r['identifier'], node_types.ANATOMY)) for r in result]
def test_smdb_id_normalizer(hmdb):
node = KNode('HMDB:HMDB0112245', type=node_types.CHEMICAL_SUBSTANCE)
node.add_synonyms(['HMDB:HMDB0112245'])
results = hmdb.metabolite_to_pathway(node)
for r in results:
r_node = r[1]
if r_node.id.startswith('SMPDB'):
uncuried = Text.un_curie(r_node.id)
assert len(uncuried) == 10
def graph_drugname_to_gene_symbol(self, drug_name_node):
drug_name = Text.un_curie(drug_name_node.identifier)
response = self.drug_name_to_gene_symbol(drug_name)
results = []
for r in response:
edge = self.get_edge(r, predicate="targets")
node = KNode("UNIPROT:{0}".format(Text.path_last(r['uniprotSym'])),
node_types.GENE)
results.append((edge, node))
return results
def graph_name_to_drugbank(self, drug_name_node):
drug_name = Text.un_curie(drug_name_node.identifier)
response = self.drug_name_to_gene_symbol(drug_name)
results = []
for r in response:
edge = self.get_edge(r, predicate="drugname")
node = KNode ("DRUGBANK:{0}".format (Text.path_last (r['drugID'])), \
node_types.DRUG, \
label=r['drugName'])
results.append((edge, node))
return results
def request_concept (self, concept, stype=None):
#Without quotes around the keyword, this function treats space as a delimiter...
keyword = Text.un_curie (concept.identifier)
keyword = '"{0}"'.format (keyword) if ' ' in keyword else keyword
if stype is None:
url = '{0}/concepts?keywords={1}'.format (self.url, keyword)
elif stype == node_types.DISEASE:
url = '{0}/concepts?keywords={1}&semanticGroups=DISO'.format (self.url, keyword)
else:
url = '{0}/concepts?keywords={1}'.format (self.url, keyword)
return requests.get (url).json ()
def get_family_sub_family_ids_from_curie(self, curie):
"""
Splits a panther curie into family id and sub family id
when ever possible.
"""
if 'PANTHER.FAMILY' in curie:
curie = Text.un_curie(curie)
splitted = curie.split(':')
if len(splitted) == 1:
return (splitted[0], None)
return (splitted)
def drugname_to_pharos(self, namenode):
drugname = Text.un_curie(namenode.id)
pharosids = self.drugname_string_to_pharos_info(drugname)
results = []
predicate = LabeledID(identifier='RDFS:id', label='identifies')
for pharosid, pharoslabel in pharosids:
newnode = KNode(pharosid, type=node_types.CHEMICAL_SUBSTANCE, name=pharoslabel)
raise RuntimeError('namenode.id is probably not a ctime...')
newedge = KEdge(namenode, newnode, 'pharos.drugname_to_pharos', namenode.id, predicate)
results.append((newedge, newnode))
return results
def get_synonyms_by_other_ids(self, variant_node):
# Just looking for 1 hit because any hit should return all of the available synonyms and caid if they exist
hgvs_ids = variant_node.get_synonyms_by_prefix('HGVS')
if hgvs_ids:
for hgvs_id in hgvs_ids:
synonyms = self.get_synonyms_by_hgvs(Text.un_curie(hgvs_id))
if synonyms: return synonyms
dbsnp_ids = variant_node.get_synonyms_by_prefix('DBSNP')
if dbsnp_ids:
for dbsnp_id in dbsnp_ids:
rsid = Text.un_curie(dbsnp_id)
if rsid.startswith('rs'):
synonyms = self.get_synonyms_by_parameter_matching(
'dbSNP.rs', rsid[2:])
if synonyms: return synonyms
clinvar_ids = variant_node.get_synonyms_by_prefix('CLINVARVARIANT')
if clinvar_ids:
for clinvar_id in clinvar_ids:
synonyms = self.get_synonyms_by_parameter_matching(
'ClinVar.variationId', Text.un_curie(clinvar_id))
if synonyms: return synonyms
myvariant_hg38_ids = variant_node.get_synonyms_by_prefix(
'MYVARIANT_HG38')
if myvariant_hg38_ids:
for myvariant_id in myvariant_hg38_ids:
synonyms = self.get_synonyms_by_parameter_matching(
'MyVariantInfo_hg38.id', Text.un_curie(myvariant_id))
if synonyms: return synonyms
myvariant_hg19_ids = variant_node.get_synonyms_by_prefix(
'MYVARIANT_HG19')
if myvariant_hg19_ids:
for myvariant_id in myvariant_hg19_ids:
synonyms = self.get_synonyms_by_parameter_matching(
'MyVariantInfo_hg19.id', Text.un_curie(myvariant_id))
if synonyms: return synonyms
return set()
def gene_get_go(self, gene):
# this function is very finicky. gene must be in uniprotkb, and the curie prefix must be correctly capitalized
# TODO: Not actually true anymore, seems to handle most CURIEs.
uniprot_id = None
uniprot_ids = gene.get_synonyms_by_prefix('UNIPROTKB')
if len(uniprot_ids) == 0:
return None, None, None
uniprot_id = list(uniprot_ids)[0]
url = "{0}/bioentity/gene/UniProtKB:{1}/function/".format(
self.url, Text.un_curie(uniprot_id))
response = self.query(url)
return response, url, uniprot_id
async def get_chembl_data(self, chembl_id):
"""
Fetches chembl data from ebi.ac.uk
"""
conf = self.get_prefix_config('CHEMBL.COMPOUND')
keys_of_interest = conf['keys']
suffix = Text.un_curie(chembl_id)
url_part = f'{suffix}.json'
response_json = await self.async_get_json(conf['url'] + url_part)
#There are some chembl id's that 404, leading to an empty response
if len(response_json) == 0:
return response_json
return self.extract_chembl_data(response_json, keys_of_interest)
def uniprot_to_hgnc(self, uniprot_symbol):
return self.triplestore.query_template(
inputs={"uniprotID": Text.un_curie(uniprot_symbol.identifier)},
outputs=["hgncID"],
template_text="""
prefix uniprot: <http://chem2bio2rdf.org/uniprot/resource/gene/>
prefix owl: <http://www.w3.org/2002/07/owl#>
prefix hgnc: <http://chem2bio2rdf.org/rdf/resource/hgnc/>
select distinct ?hgncID where {
values ( ?uniprotID ) { ( uniprot:${uniprotID} ) }
?uniprotID <http://www.w3.org/2002/07/owl#sameAs> ?hgncID.
filter ( strstarts (str(?hgncID), "http://bio2rdf.org/gene:"))
}
""")
