def receive_request(self, msg, content):
try:
Bioagent.receive_request(self, msg, content)
return
except FindMe:
reply_content = self.make_failure(TestErrorHandling.reason)
self.reply_with_content(msg, reply_content)
return
def test_cljson_stmt():
gtp = Agent('GTP')
kras_bound = Agent("KRAS", bound_conditions=[BoundCondition(gtp, True)])
braf = Agent('BRAF')
stmt = Phosphorylation(kras_bound, braf, position='373')
cj = Bioagent.make_cljson(stmt)
stmt2 = Bioagent.get_statement(cj)
assert stmt.equals(stmt2)
def receive_request(self, msg, content):
try:
Bioagent.receive_request(self, msg, content)
return
except FindMe:
reply_content = self.make_failure(TestErrorHandling.reason)
self.reply_with_content(msg, reply_content)
return
def test_cljson():
ag = Agent('BRAF',
mods=[ModCondition('phosphorylation', 'T', '396', False)],
db_refs={
'TEXT': 'Braf',
'HGNC': '123'
})
cj = Bioagent.make_cljson(ag)
ag2 = Bioagent.get_agent(cj)
assert ag2.db_refs['TYPE'] == 'ONT::GENE-PROTEIN'
ag2.db_refs.pop('TYPE')
assert ag.equals(ag2), (ag, ag2)
def _agent_name_found(output, agent_name):
entities = output.get('entities-found')
if not entities:
return False
agents = Bioagent.get_agent(entities)
agent_names = {a.name for a in agents}
return agent_name in agent_names
def test_get_synonyms_chemical():
"""raises InvalidAgentError when the agent is not recognized or if the
input submitted is not valid XML or is not in the correct format
"""
synonyms = bs.get_synonyms(
Bioagent.get_agent(agent_clj_from_text('vemurafenib')))
assert synonyms
def _get_drugs_cljson(drug_names):
agents = list(
map(
lambda n: Agent(n,
db_refs={'TYPE': 'ont::pharmacologic-substance'}),
drug_names))
return Bioagent.make_cljson(agents)
def _get_drug_cljson(drug_list):
drugs = []
for name, pubchem_id in drug_list:
if pubchem_id:
db_refs = {'PUBCHEM': pubchem_id}
drugs.append(Agent(name, db_refs=db_refs))
return Bioagent.make_cljson(drugs)
def respond_find_target_drug(self, content):
"""Response content to find-target-drug request."""
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)
kfilter_agents = content.get('filter_agents')
filter_agents = Bioagent.get_agent(kfilter_agents) if kfilter_agents \
else None
drugs = self.dtda.find_target_drugs(target,
filter_agents=filter_agents)
reply = KQMLList('SUCCESS')
reply.set('drugs', Bioagent.make_cljson(drugs))
return reply
def test_respond_choose_sense_what_member():
bs = BioSense_Module(testing=True)
msg_content = KQMLList('CHOOSE-SENSE-WHAT-MEMBER')
msg_content.set('collection', mek)
print(msg_content)
res = bs.respond_choose_sense_what_member(msg_content)
print(res)
print(res.head())
assert (res.head() == 'SUCCESS')
assert (len(res.get('members')) == 2)
m1 = res.get('members')[0]
m2 = res.get('members')[1]
a1 = Bioagent.get_agent(m1)
a2 = Bioagent.get_agent(m2)
assert a1.name == 'MAP2K1'
assert a2.name == 'MAP2K2'
assert a2.db_refs['HGNC'] == '6842'
assert a1.db_refs['UP'] == 'Q02750'
def _get_query_info(self, content):
subj = _get_agent_if_present(content, 'source')
obj = _get_agent_if_present(content, 'target')
if not subj and not obj:
raise MSALookupError('MISSING_MECHANISM')
kfilter_agents = content.get('filter_agents')
filter_agents = Bioagent.get_agent(kfilter_agents) if kfilter_agents \
else []
kcontext_agents = content.get('context')
context_agents = Bioagent.get_agent(kcontext_agents) if kcontext_agents \
else []
stmt_type = content.gets('type')
if stmt_type == 'unknown':
stmt_type = None
return subj, obj, stmt_type, filter_agents, context_agents
def create_type_and_source(self):
bap1 = Bioagent.make_cljson(Agent('BAP1', db_refs={'HGNC': '950'}))
other_genes = ['CHD8', 'SCN2A', 'ARID1B']
filter_agents = \
Bioagent.make_cljson([Agent(n, db_refs=None)
for n in other_genes])
from kqml import KQMLToken
for fa in filter_agents:
fa.set('DB--REFS', KQMLToken('NIL'))
print(filter_agents)
return self._get_content('FIND-RELATIONS-FROM-LITERATURE',
type='unknown',
source=bap1,
target=NONE,
filter_agents=filter_agents)
def test_respond_choose_sense():
bs = BioSense_Module(testing=True)
msg_content = KQMLList('CHOOSE-SENSE')
msg_content.set('agent', mek1)
res = bs.respond_choose_sense(msg_content)
agent_clj = res.get('agent')
assert agent_clj
agent = Bioagent.get_agent(agent_clj)
assert agent.name == 'MAP2K1'
assert agent.db_refs['HGNC'] == '6840'
def _get_agent_if_present(content, key):
obj_clj = content.get(key)
if obj_clj is None:
return None
else:
agent = Bioagent.get_agent(obj_clj)
# This is a bug in the BA that we can handle here
if isinstance(agent, list):
agent = agent[0]
return agent
def test_family_resolve_failure():
ag = Agent('AKT', db_refs={'FPLX': 'AKT'})
msg = Bioagent.make_resolve_family_failure(ag)
assert msg.head() == 'FAILURE'
assert msg.gets('reason') == 'FAMILY_NAME'
cl = msg.get('clarification')
assert cl.head() == 'RESOLVE'
assert cl.get('term').gets('name') == 'AKT'
genes = cl.get('as')
assert len(genes) == 3
assert genes[0].gets('name') == 'AKT1'
def test_respond_choose_nonsense():
bs = BioSense_Module(testing=True)
msg_content = KQMLList('CHOOSE-SENSE')
msg_content.set('agent', agent_clj_from_text('bagel'))
res = bs.respond_choose_sense(msg_content)
print(res)
assert res.head() == 'SUCCESS'
agents_clj = res.get('agent')
agent = Bioagent.get_agent(agents_clj)
assert agent.name == 'BAGEL'
assert len(agent.db_refs) == 1
def _get_genes_cljson(gene_names):
agents = []
for name in gene_names:
db_refs={'TYPE':'ONT::GENE-PROTEIN'}
hgnc_id = hgnc_client.get_hgnc_id(name)
if hgnc_id:
db_refs['HGNC'] = hgnc_id
agents.append(Agent(name, db_refs=db_refs))
res = Bioagent.make_cljson(agents)
return res
def respond_find_drug_targets(self, content):
"""Response content to find-drug-target request."""
try:
drug_arg = content.get('drug')
drug = self.get_agent(drug_arg)
except Exception as e:
return self.make_failure('INVALID_DRUG')
kfilter_agents = content.get('filter_agents')
filter_agents = Bioagent.get_agent(kfilter_agents) if kfilter_agents \
else None
logger.info('DTDA looking for targets of %s' % drug.name)
drug_targets = self.dtda.find_drug_targets(drug,
filter_agents=filter_agents)
reply = KQMLList('SUCCESS')
targets = self.make_cljson(drug_targets)
reply.set('targets', targets)
return reply
def respond_find_treatment(self, content):
"""Response content to find-treatment request."""
try:
disease_arg = content.get('disease')
disease = self.get_agent(disease_arg)
except Exception as e:
logger.error(e)
reply = self.make_failure('INVALID_DISEASE')
return reply
disease_name = disease.name.lower().replace('-', ' ')
disease_name = disease_name.replace('cancer', 'carcinoma')
logger.debug('Disease: %s' % disease_name)
try:
res = self.dtda.get_top_mutation(disease_name)
if res is None:
return self.make_failure('NO_MUTATION_STATS')
mut_protein, mut_percent, agents = res
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 = self._get_agent_from_gene_name(mut_protein)
reply.set('protein', self.make_cljson(protein))
reply.set('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]
drugs = self.dtda.find_target_drugs(an_agent)
reply.set('drugs', Bioagent.make_cljson(drugs))
return reply
t -= 1
assert len(prov_tells) == 1, prov_tells
if t < 50:
print("WARNING: Provenance took more than 10 seconds to post.")
def _agent_name_found(output, agent_name):
entities = output.get('entities-found')
if not entities:
return False
agents = Bioagent.get_agent(entities)
agent_names = {a.name for a in agents}
return agent_name in agent_names
braf = Bioagent.make_cljson(Agent('BRAF', db_refs={'HGNC': '1097'}))
araf = Bioagent.make_cljson(Agent('ARAF', db_refs={'HGNC': '646'}))
tp53 = Bioagent.make_cljson(Agent('TP53', db_refs={'HGNC': '11998'}))
map2k1 = Bioagent.make_cljson(Agent('MAP2K1', db_refs={'HGNC': '6840'}))
mek = Bioagent.make_cljson(Agent('MEK', db_refs={'FPLX': 'MEK'}))
mapk1 = Bioagent.make_cljson(Agent('MAPK1', db_refs={'HGNC': '6871'}))
erk = Bioagent.make_cljson(Agent('ERK', db_refs={'FPLX': 'ERK'}))
jund = Bioagent.make_cljson(Agent('JUND', db_refs={'HGNC': '6206'}))
akt1 = Bioagent.make_cljson(Agent('AKT1', db_refs={'HGNC': '391'}))
vemurafenib = Bioagent.make_cljson(
Agent('Vemurafenib', db_refs={'CHEBI': 'CHEBI:63637'}))
covid19 = Bioagent.make_cljson(
Agent('COVID-19',
db_refs={
"TEXT": "COVID-19",
"NCIT": "C171133",
def _get_default_list_cljson(names):
agents = list(map(lambda n: Agent(n), names))
return Bioagent.make_cljson(agents)
class TestGetIndraRepInactiveRAFActivatesMEK(_GetIndraRepTemplate):
kqml_file = 'Inactive_RAF_activates_MEK.kqml'
def check_result(self, res):
stmts = self.bioagent.get_statement(res)
assert len(stmts) == 1, stmts
stmt = stmts[0]
assert isinstance(stmt, Activation), type(stmt)
assert stmt.subj.name == 'RAF', stmt
assert stmt.subj.activity, stmt
assert not stmt.subj.activity.is_active, stmt
assert stmt.obj.name == 'MEK', stmt
mek1 = agent_clj_from_text('MEK1')
mek1a = Bioagent.get_agent(mek1)
mek = agent_clj_from_text('MEK')
meka = Bioagent.get_agent(mek)
dusp6 = agent_clj_from_text('DUSP6')
dusp6a = Bioagent.get_agent(dusp6)
braf = agent_clj_from_text('BRAF')
brafa = Bioagent.get_agent(braf)
bs = BioSense()
def test_choose_sense_category():
cases = [(mek1a, [('kinase activity', 'TRUE'), ('enzyme', 'TRUE'),
('kinase', 'TRUE'), ('transcription-factor', 'FALSE'),
('W::KINASE', 'TRUE'), ('phosphatase', 'FALSE')]),
(dusp6a, [('phosphatase', 'TRUE'), ('enzyme', 'TRUE')]),
def encode_indra_stmts(stmts):
stmts_clj = Bioagent.make_cljson(stmts)
return stmts_clj
t -= 1
assert len(prov_tells) == 1, prov_tells
if t < 50:
print("WARNING: Provenance took more than 10 seconds to post.")
def _agent_name_found(output, agent_name):
entities = output.get('entities-found')
if not entities:
return False
agents = Bioagent.get_agent(entities)
agent_names = {a.name for a in agents}
return agent_name in agent_names
braf = Bioagent.make_cljson(Agent('BRAF', db_refs={'HGNC': '1097'}))
tp53 = Bioagent.make_cljson(Agent('TP53', db_refs={'HGNC': '11998'}))
map2k1 = Bioagent.make_cljson(Agent('MAP2K1', db_refs={'HGNC': '6840'}))
mek = Bioagent.make_cljson(Agent('MEK', db_refs={'FPLX': 'MEK'}))
mapk1 = Bioagent.make_cljson(Agent('MAPK1', db_refs={'HGNC': '6871'}))
erk = Bioagent.make_cljson(Agent('ERK', db_refs={'FPLX': 'ERK'}))
jund = Bioagent.make_cljson(Agent('JUND', db_refs={'HGNC': '6206'}))
akt1 = Bioagent.make_cljson(Agent('AKT1', db_refs={'HGNC': '391'}))
vemurafenib = Bioagent.make_cljson(
Agent('Vemurafenib', db_refs={'CHEBI': 'CHEBI:63637'}))
NONE = KQMLList()
@attr('nonpublic')
class TestMSATypeAndTargetBRAF(_TestMsaGeneralLookup):
def create_type_and_target(self):
def agent_clj_from_text(text):
"""Return an INDRA Agent CL-JSON from text."""
agent = agent_from_text(text)
clj = Bioagent.make_cljson(agent)
return clj
def _get_genes_cljson(gene_names):
agents = list(map(lambda n: _get_agent_from_gene_name(n), gene_names))
return Bioagent.make_cljson(agents)
def stmts_clj_from_text(text):
"""Return a CL-JSON representation of INDRA Statements from text."""
stmts = stmts_from_text(text)
stmts_clj = Bioagent.make_cljson(stmts)
return stmts_clj
def _get_agent_if_present(content, key):
obj_clj = content.get(key)
if obj_clj is None:
return None
else:
return Bioagent.get_agent(obj_clj)
