def create_message_AKT1(self):
content = KQMLList('FIND-CELLULAR-LOCATION')
genes = agent_clj_from_text('AKT1')
content.set('genes', genes)
msg = get_request(content)
return msg, content
def create_message_AKT1(self):
content = KQMLList('FIND-GENE-SUMMARY')
genes = agent_clj_from_text('AKT1')
content.set('gene', genes)
msg = get_request(content)
return msg, content
def create_message_failure(self):
target = agent_clj_from_text('BRAF')
content = KQMLList('FIND-CAUSALITY-SOURCE')
content.set('target', target)
content.sets('type', 'activates')
msg = get_request(content)
return msg, content
def create_message_05_explainable_again(self):
time.sleep(2)
source = agent_clj_from_text('AKT1')
content = KQMLList('DATASET-CORRELATED-ENTITY')
content.set('source', source)
msg = get_request(content)
return msg, content
def create_message_failure(self):
source = agent_clj_from_text('MAPK1')
content = KQMLList('FIND-CAUSALITY-TARGET')
content.set('source', source)
content.sets('type', 'activation')
msg = get_request(content)
return msg, content
def create_message(self):
target = agent_clj_from_text('BRAF')
content = KQMLList('FIND-CAUSALITY-SOURCE')
content.set('target', target)
content.sets('type', 'phosphorylation')
msg = get_request(content)
return msg, content
def create_message_failure(self):
time.sleep(2)
source = ekb_kstring_from_text('ABC')
content = KQMLList('DATASET-CORRELATED-ENTITY')
content.set('source', source)
msg = get_request(content)
return msg, content
def create_message_failure_2(self):
target = ekb_kstring_from_text('ABC')
content = KQMLList('FIND-CAUSALITY-SOURCE')
content.set('target', target)
content.sets('type', 'phosphorylates')
msg = get_request(content)
return msg, content
def create_message(self):
source = ekb_kstring_from_text('MAPK1')
content = KQMLList('FIND-CAUSALITY-TARGET')
content.set('source', source)
content.sets('type', 'phosphorylation')
msg = get_request(content)
return msg, content
def create_message(self):
target = ekb_kstring_from_text(self.target)
drug = ekb_kstring_from_text(self.drug)
content = KQMLList('IS-DRUG-TARGET')
content.set('target', target)
content.set('drug', drug)
return get_request(content), content
def receive_request(self, msg, content):
"""Handle request messages and respond.
If a "request" message is received, decode the task and the content
and call the appropriate function to prepare the response. A reply_content
message is then sent back.
"""
try:
content = msg.get('content')
task_str = content.head().upper()
logger.info(task_str)
except Exception as e:
logger.error('Could not get task string from request.')
logger.error(e)
return self.error_reply(msg, 'Invalid task')
try:
if task_str == 'INDRA-TO-NL':
reply_content = self.respond_indra_to_nl(content)
else:
return self.error_reply(msg, 'Unknown task ' + task_str)
except Exception as e:
logger.error('Failed to perform task.')
logger.error(e)
reply_content = KQMLList('FAILURE')
reply_content.set('reason', 'NL_GENERATION_ERROR')
return self.reply_with_content(msg, reply_content)
def respond_is_drug_target(self, content):
"""Response content to is-drug-target request."""
try:
drug_arg = content.gets('drug')
except:
reply = make_failure('INVALID_DRUG')
try:
drug = self._get_target(drug_arg)
except Exception as e:
reply = make_failure('DRUG_NOT_FOUND')
return reply
drug_name = drug.name
try:
target_arg = content.gets('target')
target = self._get_target(target_arg)
target_name = target.name
except:
reply = make_failure('INVALID_TARGET')
return reply
try:
is_target = self.dtda.is_nominal_drug_target(
drug_name, target_name)
except DrugNotFoundException:
reply = make_failure('DRUG_NOT_FOUND')
return reply
reply = KQMLList('SUCCESS')
reply.set('is-target', 'TRUE' if is_target else 'FALSE')
return reply
def create_message2(self):
drug = agent_clj_from_text('Vemurafenib')
content = KQMLList('FIND-DRUG-TARGETS')
content.set('drug', drug)
kagents = KQMLList([agent_clj_from_text('RAF1')])
content.set('filter_agents', kagents)
return get_request(content), content
def make_failure(self, reason=None, description=None):
msg = KQMLList('FAILURE')
if reason:
msg.set('reason', reason)
if description:
msg.sets('description', description)
return msg
def subscribe_tell(self, tell_type):
msg = KQMLPerformative('subscribe')
content = KQMLList('tell')
content.append('&key')
content.set('content', KQMLList.from_string('(%s . *)' % tell_type))
msg.set('content', content)
self.send(msg)
def subscribe_request(self, req_type):
msg = KQMLPerformative('subscribe')
content = KQMLList('request')
content.append('&key')
content.set('content', KQMLList.from_string('(%s . *)' % req_type))
msg.set('content', content)
self.send(msg)
def respond_find_cellular_location(self, content):
"""Response content to find-cellular-location request"""
genes_arg = content.gets('GENES')
if not genes_arg:
return self.make_failure('MISSING_MECHANISM')
gene_names = _get_term_names(genes_arg)
if not gene_names:
return self.make_failure('MISSING_MECHANISM')
gene_list = []
for gene_name in gene_names:
gene_list.append(str(gene_name))
result = self.CA.find_most_likely_cellular_location(gene_list)
if not result:
return self.make_failure('NO_COMMON_CELLULAR_LOCATION_FOUND')
reply = KQMLList('SUCCESS')
components = KQMLList()
for r in result:
components.append(r)
reply.set('components', components)
return reply
def respond_find_qca_path(self, content):
"""Response content to find-qca-path request"""
source_arg = content.gets('SOURCE')
target_arg = content.gets('TARGET')
reltype_arg = content.get('RELTYPE')
if not source_arg:
raise ValueError("Source list is empty")
if not target_arg:
raise ValueError("Target list is empty")
target = self._get_term_name(target_arg)
source = self._get_term_name(source_arg)
if reltype_arg is None or len(reltype_arg) == 0:
relation_types = None
else:
relation_types = [str(k.data) for k in reltype_arg.data]
results_list = self.qca.find_causal_path([source], [target],
relation_types=relation_types)
if not results_list:
reply = self.make_failure('NO_PATH_FOUND')
return reply
first_result = results_list[0]
first_edges = first_result[1::2]
indra_edges = [fe[0]['INDRA json'] for fe in first_edges]
indra_edges = [json.loads(e) for e in indra_edges]
indra_edges_str = json.dumps(indra_edges)
ks = KQMLString(indra_edges_str)
reply = KQMLList('SUCCESS')
reply.set('paths', KQMLList([ks]))
return reply
def respond_find_cellular_location_from_names(self, content):
"""Response content to find-cellular-location-from-names request where genes are given as a list of names
"""
gene_names = content.get('GENES')
if not gene_names:
return self.make_failure('MISSING_MECHANISM')
if isinstance(gene_names, str):
return self.make_failure('INVALID_FORMAT')
gene_list = []
for gene_name in gene_names:
gene_list.append(str(gene_name))
result = self.CA.find_most_likely_cellular_location(gene_list)
if not result:
return self.make_failure('NO_COMMON_CELLULAR_LOCATION_FOUND')
reply = KQMLList('SUCCESS')
components = KQMLList()
for r in result:
components.append(r)
reply.set('components', components)
return reply
def respond_find_common_upstreams(self, content):
"""Response content to find-common-upstreams request"""
genes_arg = content.gets('GENES')
if not genes_arg:
return self.make_failure('MISSING_MECHANISM')
gene_names = _get_term_names(genes_arg)
if not gene_names:
return self.make_failure('MISSING_MECHANISM')
gene_list = []
for gene_name in gene_names:
gene_list.append(str(gene_name))
result = self.CA.find_common_upstreams(gene_list)
if not result:
return self.make_failure('NO_UPSTREAM_FOUND')
reply = KQMLList('SUCCESS')
upstreams = KQMLList()
for r in result:
upstreams.append(r)
reply.set('upstreams', upstreams)
return reply
def respond_find_drug_targets(self, content):
"""Response content to find-drug-target request."""
try:
drug_arg = content.gets('drug')
drug = self._get_agent(drug_arg)
drug_name = drug.name
except Exception:
return self.make_failure('INVALID_DRUG')
if '-' in drug_name:
drug_names = [drug_name, drug_name.replace('-', '')]
else:
drug_names = [drug_name]
all_targets = []
for drugn in drug_names:
logger.info('DTDA looking for targets of %s' % drugn)
drug_targets = self.dtda.find_drug_targets(drugn)
all_targets += drug_targets
all_targets = sorted(list(set(all_targets)))
reply = KQMLList('SUCCESS')
targets = KQMLList()
for target_name in all_targets:
target = KQMLList()
target.set('name', target_name)
targets.append(target)
reply.set('targets', targets)
return reply
def send_display_figure(self, path):
msg = KQMLPerformative('tell')
content = KQMLList('display-image')
content.set('type', 'simulation')
content.sets('path', path)
msg.set('content', content)
self.send(msg)
def respond_get_all_diseases(self, content):
"""Respond to the task to list all diseases we handle."""
reply = KQMLList('SUCCESS')
reply.set('diseases',
KQMLList([KQMLString(disease_name)
for disease_name in self.dtda.all_diseases]))
return reply
def make_failure(reason=None, description=None):
msg = KQMLList('FAILURE')
if reason:
msg.set('reason', reason)
if description:
msg.sets('description', description)
return msg
def respond_has_qca_path(self, content):
"""Response content to find-qca-path request."""
target_arg = content.gets('TARGET')
source_arg = content.gets('SOURCE')
reltype_arg = content.get('RELTYPE')
if not source_arg:
raise ValueError("Source list is empty")
if not target_arg:
raise ValueError("Target list is empty")
target = self._get_term_name(target_arg)
source = self._get_term_name(source_arg)
if reltype_arg is None or len(reltype_arg) == 0:
relation_types = None
else:
relation_types = [str(k.data) for k in reltype_arg.data]
has_path = self.qca.has_path([source], [target])
reply = KQMLList('SUCCESS')
reply.set('haspath', 'TRUE' if has_path else 'FALSE')
return reply
def create_message(self):
target = self.bioagent.make_cljson(Agent(self.target))
drug = self.bioagent.make_cljson(Agent(self.drug))
content = KQMLList('IS-DRUG-TARGET')
content.set('target', target)
content.set('drug', drug)
return get_request(content), content
def subscribe_request(self, req_type):
msg = KQMLPerformative('subscribe')
content = KQMLList('request')
content.append('&key')
content.set('content', KQMLList.from_string('(%s . *)' % req_type))
msg.set('content', content)
self.send(msg)
def respond_has_qca_path(self, content):
"""Response content to find-qca-path request."""
target_arg = content.gets('TARGET')
source_arg = content.gets('SOURCE')
reltype_arg = content.get('RELTYPE')
if not source_arg:
raise ValueError("Source list is empty")
if not target_arg:
raise ValueError("Target list is empty")
target = self._get_term_name(target_arg)
source = self._get_term_name(source_arg)
if reltype_arg is None or len(reltype_arg) == 0:
relation_types = None
else:
relation_types = [str(k.data) for k in reltype_arg.data]
has_path = self.qca.has_path([source], [target])
reply = KQMLList('SUCCESS')
reply.set('haspath', 'TRUE' if has_path else 'FALSE')
return reply
def subscribe_tell(self, tell_type):
msg = KQMLPerformative('subscribe')
content = KQMLList('tell')
content.append('&key')
content.set('content', KQMLList.from_string('(%s . *)' % tell_type))
msg.set('content', content)
self.send(msg)
def receive_request(self, msg, content):
"""Handle request messages and respond.
If a "request" message is received, decode the task and the content
and call the appropriate function to prepare the response. A
reply_content message is then sent back.
"""
try:
content = msg.get('content')
task_str = content.head().upper()
logger.info(task_str)
except Exception as e:
logger.error('Could not get task string from request.')
logger.error(e)
return self.error_reply(msg, 'Invalid task')
try:
if task_str == 'INDRA-TO-NL':
reply_content = self.respond_indra_to_nl(content)
else:
return self.error_reply(msg, 'Unknown task ' + task_str)
except Exception as e:
logger.error('Failed to perform task.')
logger.error(e)
reply_content = KQMLList('FAILURE')
reply_content.set('reason', 'NL_GENERATION_ERROR')
return self.reply_with_content(msg, reply_content)
def respond_find_drugs_for_mutation_dataset(self, content):
genes_arg = content.get('GENES')
if not genes_arg:
return self.make_failure('MISSING_MECHANISM')
gene_names = _get_kqml_names(genes_arg)
if not gene_names:
return self.make_failure('MISSING_MECHANISM')
dataset_arg = content.gets('DATASET')
if not dataset_arg:
dataset_arg = "CCLE" # default cell line
result = self.BA.find_drugs_for_mutation_dataset(
gene_names, dataset_arg)
if not result:
return self.make_failure('NO_DRUGS_FOUND')
reply = KQMLList('SUCCESS')
drugs = _get_drugs_cljson(result)
reply.set('drugs', drugs)
return reply
def send_display_figure(self, path):
msg = KQMLPerformative('tell')
content = KQMLList('display-image')
content.set('type', 'simulation')
content.sets('path', path)
msg.set('content', content)
self.send(msg)
def respond_is_drug_target(self, content):
"""Response content to is-drug-target request."""
try:
drug_arg = content.get('drug')
except Exception:
return self.make_failure('INVALID_DRUG')
try:
drug = self.get_agent(drug_arg)
except Exception:
return self.make_failure('DRUG_NOT_FOUND')
try:
target_arg = content.get('target')
target = self.get_agent(target_arg)
except Exception:
return self.make_failure('INVALID_TARGET')
if is_family(target):
return self.make_resolve_family_failure(target)
try:
is_target = self.dtda.is_nominal_drug_target(drug, target)
except DrugNotFoundException:
return self.make_failure('DRUG_NOT_FOUND')
reply = KQMLList('SUCCESS')
reply.set('is-target', 'TRUE' if is_target else 'FALSE')
return reply
def create_message(self):
# Here we create a KQML request that the TFTA needs to respond to
database = self.database
keyword = self.keyword
content = KQMLList('FIND-PATHWAY-DB-KEYWORD')
content.set('database', database)
content.set('keyword', keyword)
return get_request(content), content
def create_message(self):
# Here we create a KQML request that the TFTA needs to respond to
tf = ekb_kstring_from_text(self.tf)
target = ekb_kstring_from_text(self.target)
content = KQMLList('IS-TF-TARGET')
content.set('tf', tf)
content.set('target', target)
return get_request(content), content
def create_message(self):
# Here we create a KQML request that the TFTA needs to respond to
target = ekb_kstring_from_text(self.target)
mirna = ekb_kstring_from_text(self.mirna)
content = KQMLList('IS-MIRNA-TARGET')
content.set('target', target)
content.set('miRNA', mirna)
return get_request(content), content
def create_message_1(self):
content = KQMLList('FIND-DRUGS-FOR-MUTATION-DATASET')
genes = agent_clj_from_text('TP53')
content.set('genes', genes)
content.set('dataset', "CTRP")
msg = get_request(content)
return msg, content
def respond_indra_to_nl(self, content):
"""Return response content to build-model request."""
stmts_json_str = content.gets('statements')
stmts = decode_indra_stmts(stmts_json_str)
txts = assemble_english(stmts)
txts_kqml = [KQMLString(txt) for txt in txts]
txts_list = KQMLList(txts_kqml)
reply = KQMLList('OK')
reply.set('NL', txts_list)
return reply
def respond_find_target_drug(self, content):
"""Response content to find-target-drug request."""
try:
target_arg = content.gets('target')
target = self._get_agent(target_arg)
except Exception:
return self.make_failure('INVALID_TARGET')
drug_results = self.dtda.find_target_drugs(target)
drugs = self._get_drug_kqml(drug_results)
reply = KQMLList('SUCCESS')
reply.set('drugs', drugs)
return reply
def report_paths_graph(self, paths_list):
from indra.assemblers.graph import GraphAssembler
from indra.util import flatten
path_stmts = [stmts_from_json(l) for l in paths_list]
all_stmts = flatten(path_stmts)
ga = GraphAssembler(all_stmts)
ga.make_model()
resource = get_img_path('qca_paths.png')
ga.save_pdf(resource)
content = KQMLList('display-image')
content.set('type', 'simulation')
content.sets('path', resource)
self.tell(content)
def send_display_model(self, diagrams):
for diagram_type, resource in diagrams.items():
if not resource:
continue
if diagram_type == 'sbgn':
content = KQMLList('display-sbgn')
content.set('type', diagram_type)
content.sets('graph', resource)
else:
content = KQMLList('display-image')
content.set('type', diagram_type)
content.sets('path', resource)
self.tell(content)
def get_ambiguities_msg(ambiguities):
sa = []
for term_id, ambiguity in ambiguities.items():
msg = KQMLList(term_id)
pr = ambiguity[0]['preferred']
pr_dbids = '|'.join([':'.join((k, v)) for
k, v in pr['refs'].items()])
term = KQMLList('term')
term.set('ont-type', pr['type'])
term.sets('ids', pr_dbids)
term.sets('name', pr['name'])
msg.set('preferred', term)
alt = ambiguity[0]['alternative']
alt_dbids = '|'.join([':'.join((k, v)) for
k, v in alt['refs'].items()])
term = KQMLList('term')
term.set('ont-type', alt['type'])
term.sets('ids', alt_dbids)
term.sets('name', alt['name'])
msg.set('alternative', term)
sa.append(msg)
ambiguities_msg = KQMLList(sa)
return ambiguities_msg
def respond_find_disease_targets(self, content):
"""Response content to find-disease-targets request."""
try:
disease_arg = content.gets('disease')
disease = get_disease(ET.fromstring(disease_arg))
except Exception as e:
logger.error(e)
reply = self.make_failure('INVALID_DISEASE')
return reply
if not trips_isa(disease.disease_type, 'ont::cancer'):
reply = self.make_failure('DISEASE_NOT_FOUND')
return reply
logger.debug('Disease: %s' % disease.name)
try:
mut_protein, mut_percent, agents = \
self.dtda.get_top_mutation(disease.name)
except DiseaseNotFoundException:
reply = self.make_failure('DISEASE_NOT_FOUND')
return reply
# TODO: get functional effect from actual mutations
# TODO: add list of actual mutations to response (get from agents)
# TODO: get fraction not percentage from DTDA (edit get_top_mutation)
reply = KQMLList('SUCCESS')
protein = KQMLList()
protein.set('name', mut_protein)
protein.set('hgnc', mut_protein)
reply.set('protein', protein)
reply.set('prevalence', '%.2f' % (mut_percent/100.0))
reply.set('functional-effect', 'ACTIVE')
return reply
def respond_choose_sense_category(self, content):
"""Return response content to choose-sense-category request."""
ekb = content.gets('ekb-term')
category = content.gets('category')
try:
in_category = self.bs.choose_sense_category(ekb, category)
except InvalidAgentError:
msg = make_failure('INVALID_AGENT')
except UnknownCategoryError:
msg = make_failure('UNKNOWN_CATEGORY')
else:
msg = KQMLList('SUCCESS')
msg.set('in-category',
'TRUE' if in_category else 'FALSE')
return msg
def get_kagent(agent_tuple, term_id=None):
agent, ont_type, urls = agent_tuple
db_refs = '|'.join('%s:%s' % (k, v) for k, v in
agent.db_refs.items())
kagent = KQMLList(term_id) if term_id else KQMLList()
kagent.sets('name', agent.name)
kagent.sets('ids', db_refs)
url_parts = [KQMLList([':name', KQMLString(k),
':dblink', KQMLString(v)])
for k, v in urls.items()]
url_list = KQMLList()
for url_part in url_parts:
url_list.append(url_part)
kagent.set('id-urls', url_list)
kagent.set('ont-type', ont_type)
return kagent
def respond_choose_sense_what_member(self, content):
"""Return response content to choose-sense-what-member request."""
# Get the collection agent
ekb = content.gets('collection')
try:
members = self.bs.choose_sense_what_member(ekb)
except InvalidCollectionError:
msg = make_failure('INVALID_COLLECTION')
except CollectionNotFamilyOrComplexError:
msg = make_failure('COLLECTION_NOT_FAMILY_OR_COMPLEX')
else:
kagents = [get_kagent((m, 'ONT::PROTEIN', _get_urls(m)))
for m in members]
msg = KQMLList('SUCCESS')
msg.set('members', KQMLList(kagents))
return msg
def respond_model_compare_conditions(self, content):
condition_agent_ekb = content.gets('agent')
target_agent_ekb = content.gets('affected')
model_indra_str = content.gets('model')
up_dn = content.gets('up-dn')
try:
stmts = decode_indra_stmts(model_indra_str)
model = assemble_model(stmts)
except Exception as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_MODEL')
return reply_content
try:
condition_agent = get_single_molecular_entity(condition_agent_ekb)
target_agent = get_single_molecular_entity(target_agent_ekb)
except Exception as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_PATTERN')
return reply_content
try:
up_dn = 'dn' if up_dn is None else up_dn
logger.info('Checking %s against %s with polarity %s' %
(condition_agent, target_agent, up_dn))
result, fig_path = \
self.tra.compare_conditions(model, condition_agent,
target_agent, up_dn)
except tra.MissingMonomerError as e:
logger.exception(e)
reply_content = self.make_failure('MODEL_MISSING_MONOMER')
return reply_content
except tra.MissingMonomerSiteError as e:
logger.exception(e)
reply_content = self.make_failure('MODEL_MISSING_MONOMER_SITE')
return reply_content
except tra.SimulatorError as e:
logger.exception(e)
reply_content = self.make_failure('KAPPA_FAILURE')
return reply_content
self.send_display_figure(fig_path)
reply = KQMLList('SUCCESS')
reply.set('result', result)
return reply
def read_pmc(self, pmcid):
"""Read a given PMC article.
Parameters
----------
pmcid : str
The PMC ID of the article to read. Note that only
articles in the open-access subset of PMC will work.
"""
msg = KQMLPerformative('REQUEST')
msg.set('receiver', 'READER')
content = KQMLList('run-pmcid')
content.sets('pmcid', pmcid)
content.set('reply-when-done', 'true')
msg.set('content', content)
msg.set('reply-with', 'P-%s' % pmcid)
self.reply_counter += 1
self.send(msg)
def _get_qca_content(task, source, target):
"""Get the KQMLList content to be sent to the QCA for given task.
Paramters
---------
source, target : str
The strings representing the proteins for source and target,
respectively, for example 'BRAF'.
Returns
-------
content : KQMLList
The KQML content to be sent to the QCA module as part of the request.
"""
content = KQMLList(task)
content.set('source', ekb_kstring_from_text(source))
content.set('target', ekb_kstring_from_text(target))
return content
def respond_choose_sense_is_member(self, content):
"""Return response content to choose-sense-is-member request."""
agent_ekb = content.gets('ekb-term')
collection_ekb = content.gets('collection')
try:
is_member = self.bs.choose_sense_is_member(agent_ekb,
collection_ekb)
except InvalidAgentError:
msg = make_failure('INVALID_AGENT')
except InvalidCollectionError:
msg = make_failure('INVALID_COLLECTION')
except CollectionNotFamilyOrComplexError:
msg = KQMLList('SUCCESS')
msg.set('is-member', 'FALSE')
else:
msg = KQMLList('SUCCESS')
msg.set('is-member', 'TRUE' if is_member else 'FALSE')
return msg
def respond_get_synonyms(self, content):
"""Respond to a query looking for synonyms of a protein."""
ekb = content.gets('entity')
try:
synonyms = self.bs.get_synonyms(ekb)
except InvalidAgentError:
msg = self.make_failure('INVALID_AGENT')
except SynonymsUnknownError:
msg = self.make_failure('SYNONYMS_UNKNOWN')
else:
syns_kqml = KQMLList()
for s in synonyms:
entry = KQMLList()
entry.sets(':name', s)
syns_kqml.append(entry)
msg = KQMLList('SUCCESS')
msg.set('synonyms', syns_kqml)
return msg
def respond_find_drug_targets(self, content):
"""Response content to find-drug-target request."""
try:
drug_arg = content.gets('drug')
drug = self._get_agent(drug_arg)
except Exception as e:
return self.make_failure('INVALID_DRUG')
logger.info('DTDA looking for targets of %s' % drug.name)
drug_targets = self.dtda.find_drug_targets(drug)
all_targets = sorted(list(set(drug_targets)))
reply = KQMLList('SUCCESS')
targets = KQMLList()
for target_name in all_targets:
target = KQMLList()
target.sets('name', target_name)
targets.append(target)
reply.set('targets', targets)
return reply
def respond_find_treatment(self, content):
"""Response content to find-treatment request."""
try:
disease_arg = content.gets('disease')
disease = get_disease(ET.fromstring(disease_arg))
except Exception as e:
logger.error(e)
reply = self.make_failure('INVALID_DISEASE')
return reply
logger.info('Disease type: %s' % disease.disease_type)
if not trips_isa(disease.disease_type, 'ont::cancer'):
logger.info('Disease is not a type of cancer.')
reply = self.make_failure('DISEASE_NOT_FOUND')
return reply
logger.debug('Disease: %s' % disease.name)
try:
mut_protein, mut_percent, agents = \
self.dtda.get_top_mutation(disease.name)
except DiseaseNotFoundException:
reply = self.make_failure('DISEASE_NOT_FOUND')
return reply
# TODO: get functional effect from actual mutations
# TODO: add list of actual mutations to response
# TODO: get fraction not percentage from DTDA
reply = KQMLList('SUCCESS')
protein = KQMLList()
protein.set('name', mut_protein)
protein.set('hgnc', mut_protein)
reply.set('protein', protein)
reply.sets('disease', disease_arg)
reply.set('prevalence', '%.2f' % (mut_percent/100.0))
reply.set('functional-effect', 'ACTIVE')
# These differ only in mutation, which isn't relevant.
an_agent = agents[0]
drug_results = self.dtda.find_target_drugs(an_agent)
drugs = self._get_drug_kqml(drug_results)
reply.set('drugs', drugs)
return reply
def respond_model_get_upstream(self, content):
"""Return response content to model-upstream request."""
target_arg = content.gets('target')
target = get_target(target_arg)
try:
model_id = self._get_model_id(content)
except Exception:
model_id = 1
upstream = self.mra.get_upstream(target, model_id)
terms = []
names = []
for agent in upstream:
term = ekb_from_agent(agent)
if term is not None:
names.append(KQMLString(agent.name))
terms.append(KQMLString(term))
reply = KQMLList('SUCCESS')
reply.set('upstream', KQMLList(terms))
reply.set('upstream-names', KQMLList(names))
return reply
def respond_is_drug_target(self, content):
"""Response content to is-drug-target request."""
try:
drug_arg = content.gets('drug')
except Exception:
return self.make_failure('INVALID_DRUG')
try:
drug = self._get_agent(drug_arg)
except Exception:
return self.make_failure('DRUG_NOT_FOUND')
try:
target_arg = content.gets('target')
target = self._get_agent(target_arg)
except Exception:
return self.make_failure('INVALID_TARGET')
try:
is_target = self.dtda.is_nominal_drug_target(drug, target)
except DrugNotFoundException:
return self.make_failure('DRUG_NOT_FOUND')
reply = KQMLList('SUCCESS')
reply.set('is-target', 'TRUE' if is_target else 'FALSE')
return reply
def create_message(self):
target = ekb_kstring_from_text(self.target)
content = KQMLList('FIND-TARGET-DRUG')
content.set('target', target)
return get_request(content), content
def make_failure(reason):
msg = KQMLList('FAILURE')
msg.set('reason', reason)
return msg
def respond_find_qca_path(self, content):
"""Response content to find-qca-path request"""
if self.qca.ndex is None:
reply = self.make_failure('SERVICE_UNAVAILABLE')
return reply
source_arg = content.gets('SOURCE')
target_arg = content.gets('TARGET')
reltype_arg = content.get('RELTYPE')
if not source_arg:
raise ValueError("Source list is empty")
if not target_arg:
raise ValueError("Target list is empty")
target = self._get_term_name(target_arg)
if target is None:
reply = self.make_failure('NO_PATH_FOUND')
# NOTE: use the one below if it's handled by NLG
#reply = self.make_failure('TARGET_MISSING')
return reply
source = self._get_term_name(source_arg)
if source is None:
reply = self.make_failure('NO_PATH_FOUND')
# NOTE: use the one below if it's handled by NLG
#reply = self.make_failure('SOURCE_MISSING')
return reply
if reltype_arg is None or len(reltype_arg) == 0:
relation_types = None
else:
relation_types = [str(k.data) for k in reltype_arg.data]
results_list = self.qca.find_causal_path([source], [target],
relation_types=relation_types)
if not results_list:
reply = self.make_failure('NO_PATH_FOUND')
return reply
def get_path_statements(results_list):
stmts_list = []
for res in results_list:
# Edges of the first result
edges = res[1::2]
# INDRA JSON of the edges of the result
try:
indra_edges = [fe[0]['__INDRA json'] for fe in edges]
except Exception:
indra_edges = [fe[0]['INDRA json'] for fe in edges]
# Make the JSONs dicts from strings
indra_edges = [json.loads(e) for e in indra_edges]
# Now fix the edges if needed due to INDRA Statement changes
indra_edges = _fix_indra_edges(indra_edges)
stmts_list.append(indra_edges)
return stmts_list
paths_list = get_path_statements(results_list)
self.report_paths_graph(paths_list)
# Take the first one to report
indra_edges = paths_list[0]
# Get the INDRA Statement objects
indra_edge_stmts = stmts_from_json(indra_edges)
# Assemble into English
for stmt in indra_edge_stmts:
txt = EnglishAssembler([stmt]).make_model()
self.send_provenance_for_stmts(
[stmt], "the path from %s to %s (%s)" % (source, target, txt))
indra_edges_str = json.dumps(indra_edges)
ks = KQMLString(indra_edges_str)
reply = KQMLList('SUCCESS')
reply.set('paths', KQMLList([ks]))
return reply
def create_message(self):
disease = ekb_kstring_from_text('common cold')
content = KQMLList('FIND-TREATMENT')
content.set('disease', disease)
return get_request(content), content
def respond_satisfies_pattern(self, content):
"""Return response content to satisfies-pattern request."""
model_indra_str = content.gets('model')
pattern_lst = content.get('pattern')
conditions_lst = content.get('conditions')
try:
stmts = decode_indra_stmts(model_indra_str)
model = assemble_model(stmts)
except Exception as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_MODEL')
return reply_content
try:
pattern = get_temporal_pattern(pattern_lst)
except tra.InvalidTimeIntervalError as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_TIME_LIMIT')
return reply_content
except tra.InvalidTemporalPatternError as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_PATTERN')
return reply_content
except tra.InvalidMolecularEntityError as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_ENTITY_DESCRIPTION')
return reply_content
if conditions_lst is None:
conditions = None
else:
try:
conditions = []
for condition_lst in conditions_lst:
condition = get_molecular_condition(condition_lst)
conditions.append(condition)
except Exception as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_CONDITIONS')
return reply_content
try:
sat_rate, num_sim, suggestion, fig_path = \
self.tra.check_property(model, pattern, conditions)
except tra.MissingMonomerError as e:
logger.exception(e)
reply_content = self.make_failure('MODEL_MISSING_MONOMER')
return reply_content
except tra.MissingMonomerSiteError as e:
logger.exception(e)
reply_content = self.make_failure('MODEL_MISSING_MONOMER_SITE')
return reply_content
except tra.SimulatorError as e:
logger.exception(e)
reply_content = self.make_failure('KAPPA_FAILURE')
return reply_content
except Exception as e:
logger.exception(e)
reply_content = self.make_failure('INVALID_PATTERN')
return reply_content
self.send_display_figure(fig_path)
reply = KQMLList('SUCCESS')
content = KQMLList()
content.set('satisfies-rate', '%.1f' % sat_rate)
content.set('num-sim', '%d' % num_sim)
if suggestion:
sugg = KQMLList.from_string(suggestion)
content.set('suggestion', sugg)
reply.set('content', content)
return reply
