def respond_simulate_model(self, content_list):
'''
Response content to simulate-model request
'''
model_str = content_list.get_keyword_arg(':model')
try:
#model_str = model_str.to_string()
model = self.decode_model(model_str)
except InvalidModelDescriptionError as e:
logger.error(e)
reply_content =\
KQMLList.from_string('(FAILURE :reason INVALID_MODEL)')
return reply_content
except Exception as e:
logger.error(e)
reply_content =\
KQMLList.from_string('(FAILURE :reason INVALID_MODEL)')
return reply_content
target_entity = content_list.get_keyword_arg(':target_entity')
if target_entity is not None:
target_entity = target_entity.to_string()[1:-1]
else:
reply_content =\
KQMLList.from_string('(FAILURE :reason MISSING_PARAMETER)')
return reply_content
target_pattern = content_list.get_keyword_arg(':target_pattern')
if target_pattern is not None:
target_pattern = target_pattern.to_string().lower()
else:
reply_content =\
KQMLList.from_string('(FAILURE :reason MISSING_PARAMETER)')
return reply_content
condition_entity = content_list.get_keyword_arg(':condition_entity')
if condition_entity is not None:
condition_entity = condition_entity.to_string()[1:-1]
condition_type = content_list.get_keyword_arg(':condition_type')
if condition_type is not None:
condition_type = condition_type.to_string().lower()
self.get_context(model)
if condition_entity is None:
target_match = self.mea.check_pattern(model, target_entity,
target_pattern)
else:
target_match = self.mea.compare_conditions(model, target_entity,
target_pattern,
condition_entity,
condition_type)
target_match_str = 'TRUE' if target_match else 'FALSE'
reply_content = KQMLList()
reply_content.add('SUCCESS :content (:target_match %s)' %
target_match_str)
return reply_content
def respond_find_treatment(self, content_list):
'''
Response content to find-treatment request
'''
reply_content = KQMLList()
#TODO: eliminate code duplication here
disease_arg = content_list.get_keyword_arg(':disease')
try:
disease = self.get_disease(disease_arg)
except Exception as e:
logger.error(e)
msg_str = '(FAILURE :reason INVALID_DISEASE)'
reply_content = KQMLList.from_string(msg_str)
return reply_content
if disease.disease_type != 'cancer':
reply_content.add('FAILURE :reason DISEASE_NOT_FOUND')
return reply_content
logger.debug('Disease: %s' % disease.name)
try:
mut_protein, mut_percent = \
self.dtda.get_top_mutation(disease.name)
except DiseaseNotFoundException:
reply_content.add('FAILURE :reason DISEASE_NOT_FOUND')
return reply_content
# TODO: get functional effect from actual mutations
# TODO: add list of actual mutations to response
# TODO: get fraction not percentage from DTDA
reply_content.add(
KQMLList.from_string('(SUCCESS ' +
':protein (:name %s :hgnc %s) ' %
(mut_protein, mut_protein) +
':prevalence %.2f ' % (mut_percent / 100.0) +
':functional-effect ACTIVE)'))
# Try to find a drug
drug_names, chebi_ids = self.dtda.find_target_drugs(mut_protein)
drug_list_str = ''
for dn, ci in zip(drug_names, chebi_ids):
if ci is None:
drug_list_str += '(:name %s) ' % dn.encode('ascii', 'ignore')
else:
drug_list_str += '(:name %s :chebi_id %s) ' % (dn, ci)
reply_content.add(
KQMLList.from_string('(SUCCESS :drugs (' + drug_list_str + '))'))
return reply_content
def respond_start(self, arguments):
'''
Response content to start message
'''
if "CODE" not in arguments:
response_content = self.response_error(["Missing code"])
elif "NB_PLOT" not in arguments:
response_content =\
self.response_error(["Missing number of plot points"])
else:
try:
parameter = {}
parameter["nb_plot"] = arguments["NB_PLOT"]
if "MAX_TIME" in arguments:
parameter["max_time"] = float(arguments["MAX_TIME"])
if "MAX_EVENTS" in arguments:
parameter["max_events"] = int(arguments["MAX_EVENTS"])
request_code = arguments["CODE"]
request_code = request_code[1:-1]
request_code = request_code.decode('string_escape')
parameter["code"] = request_code
try:
logger.debug(parameter)
response = self.kappa.start(parameter)
response_message = '(SUCCESS :id %d)' % response
response_content = KQMLList.from_string(response_message)
except RuntimeError as e:
response_content = self.response_error(e.errors)
except ValueError as e:
response_content = self.response_error([str(e)])
return response_content
def respond_dont_know(self, msg, content_string):
resp = '(ONT::TELL :content (ONT::DONT-KNOW :content %s))' %\
content_string
resp_list = KQMLList.from_string(resp)
reply_msg = KQMLPerformative('reply')
reply_msg.set_parameter(':content', resp_list)
self.reply(msg, reply_msg)
def test_get_molecular_condition_dec():
lst = KQMLList.from_string('(:type "decrease" :quantity (:type "total" ' +\
':entity (:description "%s")))' % ekb_braf)
mc = tra_module.get_molecular_condition(lst)
assert mc.condition_type == 'decrease'
assert mc.quantity.quant_type == 'total'
assert mc.quantity.entity.name == 'BRAF'
def test_get_disease():
disease_str = '(CANCER :DBNAME "pancreatic carcinoma" :DBID "EFO:0002618")'
kl = KQMLList.from_string(disease_str)
disease = DTDA_Module.get_disease(kl)
assert (disease.disease_type == 'cancer')
assert (disease.name == 'pancreatic carcinoma')
assert (disease.db_refs == {'EFO': '0002618'})
def test_get_disease():
disease_str = '(CANCER :DBNAME "pancreatic carcinoma" :DBID "EFO:0002618")'
kl = KQMLList.from_string(disease_str)
disease = DTDA_Module.get_disease(kl)
assert(disease.disease_type == 'cancer')
assert(disease.name == 'pancreatic carcinoma')
assert(disease.db_refs == {'EFO': '0002618'})
def respond_build_model(self, content_list):
'''
Response content to build-model request
'''
try:
descr_arg = content_list.get_keyword_arg(':description')
descr = descr_arg[0].to_string()
descr = self.decode_description(descr)
model = self.mra.build_model_from_ekb(descr)
except Exception as e:
raise InvalidModelDescriptionError(e)
if model is None:
raise InvalidModelDescriptionError
self.get_context(model)
self.models.append(model)
model_id = len(self.models)
model_enc = self.encode_model(model)
try:
model_diagram = self.get_model_diagram(model, model_id)
except DiagramGenerationError as e:
logger.error('Could not generate model diagram.')
logger.error(e)
model_diagram = ''
except DiagramConversionError as e:
logger.error('Could not save model diagram.')
logger.error(e)
model_diagram = ''
reply_content =\
KQMLList.from_string(
'(SUCCESS :model-id %s :model "%s" :diagram "%s")' %\
(model_id, model_enc, model_diagram))
return reply_content
def test_get_time_interval_lb():
ts = '(:lower-bound 4 :unit "hour")'
lst = KQMLList.from_string(ts)
ti = tra_module.get_time_interval(lst)
assert ti.lb == 4 * units.hours
assert ti.ub is None
assert ti.get_lb_seconds() == 14400
def test_get_time_interval_full():
ts = '(:lower-bound 2 :upper-bound 4 :unit "hour")'
lst = KQMLList.from_string(ts)
ti = tra_module.get_time_interval(lst)
assert ti.lb == 2 * units.hour
assert ti.ub == 4 * units.hour
assert ti.get_lb_seconds() == 7200
assert ti.get_ub_seconds() == 14400
def test_apply_condition_multiple():
model = _get_gk_model()
lst = KQMLList.from_string('(:type "multiple" :value 2.5 ' +
':quantity (:type "total" ' +
':entity (:description "%s")))' % ekb_map2k1)
mc = tra_module.get_molecular_condition(lst)
apply_condition(model, mc)
assert model.parameters['MAP2K1_0'].value == 250
def test_get_molecular_condition_multiple():
lst = KQMLList.from_string('(:type "multiple" :value 2 ' +
':quantity (:type "total" ' +
':entity (:description "%s")))' % ekb_braf)
mc = tra_module.get_molecular_condition(lst)
assert mc.condition_type == 'multiple'
assert mc.value == 2.0
assert mc.quantity.quant_type == 'total'
assert mc.quantity.entity.name == 'BRAF'
def test_apply_condition_decrease():
model = _get_gk_model()
lst = KQMLList.from_string('(:type "decrease" ' +
':quantity (:type "total" ' +
':entity (:description "%s")))' % ekb_map2k1)
mc = tra_module.get_molecular_condition(lst)
pold = model.parameters['MAP2K1_0'].value
apply_condition(model, mc)
assert model.parameters['MAP2K1_0'].value < pold
def test_get_molecular_condition_exact():
lst = KQMLList.from_string(
'(:type "exact" :value (:value 0 :type "number") ' +
':quantity (:type "total" ' +
':entity (:description "%s")))' % ekb_braf)
mc = tra_module.get_molecular_condition(lst)
assert mc.condition_type == 'exact'
assert mc.value.quant_type == 'number'
assert mc.quantity.quant_type == 'total'
assert mc.quantity.entity.name == 'BRAF'
def respond_version(self):
'''
Response content to version message
'''
response = self.kappa.version()
reply_content = KQMLList.from_string(
'(SUCCESS ' + ':VERSION "%s" ' % response['version'] +
':BUILD "%s")' % response['build'])
logger.debug(reply_content.to_string())
return reply_content
def test_get_temporal_pattern_eventual():
pattern_msg = '(:type "eventual_value" :entities ((:description ' + \
'"%s")) :value (:type "qualitative" :value "high"))' % \
ekb_complex
lst = KQMLList.from_string(pattern_msg)
pattern = tra_module.get_temporal_pattern(lst)
assert pattern.pattern_type == 'eventual_value'
assert pattern.value is not None
assert pattern.value.quant_type == 'qualitative'
assert pattern.value.value == 'high'
def respond_stop(self, arguments):
if "ID" not in arguments:
response_content = self.response_error(["Missing simulation id"])
else:
try:
token = int(arguments["ID"])
status = self.kappa.stop(token)
response_content = KQMLList.from_string('(SUCCESS)')
except RuntimeError as e:
response_content = self.response_error(e.errors)
return response_content
def respond_test(self):
'''
Response content to version message
'''
reply_content = KQMLList()
version_response = KQMLList.from_string( '' +\
'(ONT::TELL :content ' +\
')')
reply_content.add(KQMLList(version_response))
return reply_content
def test_apply_condition_exact():
model = _get_gk_model()
lst = KQMLList.from_string(
'(:type "exact" :value (:value 0 :type "number") ' +
':quantity (:type "total" ' +
':entity (:description "%s")))' % ekb_map2k1)
mc = tra_module.get_molecular_condition(lst)
apply_condition(model, mc)
assert model.parameters['MAP2K1_0'].value == 0
mc.value.value = 2000
apply_condition(model, mc)
assert model.parameters['MAP2K1_0'].value == 2000
def receive_request(self, msg, content):
'''
If a "request" message is received, decode the task and the content
and call the appropriate function to prepare the response. A reply
"tell" message is then sent back.
'''
try:
task_str = content[0].to_string().upper()
except Exception as e:
logger.error('Could not get task string from request.')
logger.error(e)
self.error_reply(msg, 'Invalid task')
if task_str == 'BUILD-MODEL':
try:
reply_content = self.respond_build_model(content)
except InvalidModelDescriptionError as e:
logger.error('Invalid model description.')
logger.error(e)
fail_msg = '(FAILURE :reason INVALID_DESCRIPTION)'
reply_content = KQMLList.from_string(fail_msg)
elif task_str == 'EXPAND-MODEL':
try:
reply_content = self.respond_expand_model(content)
except InvalidModelIdError as e:
logger.error('Invalid model ID.')
logger.error(e)
fail_msg = '(FAILURE :reason INVALID_MODEL_ID)'
reply_content = KQMLList.from_string(fail_msg)
except InvalidModelDescriptionError as e:
logger.error('Invalid model description.')
logger.error(e)
fail_msg = '(FAILURE :reason INVALID_DESCRIPTION)'
reply_content = KQMLList.from_string(fail_msg)
else:
self.error_reply(msg, 'Unknown task ' + task_str)
return
reply_msg = KQMLPerformative('reply')
reply_msg.set_parameter(':content', reply_content)
self.reply(msg, reply_msg)
def respond_find_disease_targets(self, content_list):
'''
Response content to find-disease-targets request
'''
disease_arg = content_list.get_keyword_arg(':disease')
try:
disease = self.get_disease(disease_arg)
except Exception as e:
logger.error(e)
msg_str = '(FAILURE :reason INVALID_DISEASE)'
reply_content = KQMLList.from_string(msg_str)
return reply_content
if disease.disease_type != 'cancer':
msg_str = '(FAILURE :reason DISEASE_NOT_FOUND)'
reply_content = KQMLList.from_string(msg_str)
return reply_content
logger.debug('Disease: %s' % disease.name)
try:
mut_protein, mut_percent =\
self.dtda.get_top_mutation(disease.name)
except DiseaseNotFoundException:
msg_str = '(FAILURE :reason DISEASE_NOT_FOUND)'
reply_content = KQMLList.from_string(msg_str)
return reply_content
# TODO: get functional effect from actual mutations
# TODO: add list of actual mutations to response
# TODO: get fraction not percentage from DTDA
reply_content =\
KQMLList.from_string(
'(SUCCESS ' +
':protein (:name %s :hgnc %s) ' % (mut_protein, mut_protein) +
':prevalence %.2f ' % (mut_percent/100.0) +
':functional-effect ACTIVE)')
return reply_content
def respond_find_target_drug(self, content_list):
'''
Response content to find-target-drug request
'''
target = content_list.get_keyword_arg(':target')
target_str = target.to_string()[1:-1]
drug_names, chebi_ids = self.dtda.find_target_drugs(target_str)
drug_list_str = ''
for dn, ci in zip(drug_names, chebi_ids):
if ci is None:
drug_list_str += '(:name %s) ' % dn.encode('ascii', 'ignore')
else:
drug_list_str += '(:name %s :chebi_id %s) ' % (dn, ci)
reply_content = KQMLList.from_string('(SUCCESS :drugs (' +
drug_list_str + '))')
return reply_content
def respond_expand_model(self, content_list):
'''
Response content to expand-model request
'''
try:
descr_arg = content_list.get_keyword_arg(':description')
descr = descr_arg[0].to_string()
descr = self.decode_description(descr)
except Exception as e:
raise InvalidModelDescriptionError(e)
model_id_arg = content_list.get_keyword_arg(':model-id')
if model_id_arg is None:
logger.error('Model ID missing.')
raise InvalidModelIdError
try:
model_id_str = model_id_arg.to_string()
model_id = int(model_id_str)
except Exception as e:
logger.error('Could not get model ID as integer.')
raise InvalidModelIdError(e)
if model_id < 1 or model_id > len(self.models):
logger.error('Model ID does not refer to an existing model.')
raise InvalidModelIdError
try:
model = self.mra.expand_model_from_ekb(descr, model_id)
except Exception as e:
raise InvalidModelDescriptionError
self.get_context(model)
self.models.append(model)
new_model_id = len(self.models)
model_enc = self.encode_model(model)
try:
model_diagram = self.get_model_diagram(model, new_model_id)
except DiagramGenerationError:
model_diagram = ''
except DiagramConversionError:
model_diagram = ''
reply_content =\
KQMLList.from_string(
'(SUCCESS :model-id %s :model "%s" :diagram "%s")' %\
(new_model_id, model_enc, model_diagram))
return reply_content
def respond_parse(self, arguments):
'''
Response content to parse message
'''
if "CODE" not in arguments:
reply_content = self.response_error(["Missing code"])
else:
request_code = arguments["CODE"]
request_code = request_code[1:-1]
logger.debug('raw {0}'.format(request_code))
request_code = request_code.decode('string_escape')
logger.debug('respond_parse {0}'.format(request_code))
reply_content = KQMLList()
try:
response = self.kappa.parse(request_code)
logger.debug(response)
reply_content = KQMLList.from_string('(SUCCESS)')
except RuntimeError as e:
logger.debug(e.errors)
reply_content = self.response_error(e.errors)
return reply_content
def test_molecular_quantity_conc2():
s = '(:type "concentration" :value 200 :unit "nM")'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
assert mq.quant_type == 'concentration'
assert mq.value == 200 * units.nano * units.mol / units.liter
def test_molecular_quantity_conc_badval():
s = '(:type "concentration" :value "xyz" :unit "nM")'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
def format_error(self, message):
response_content = KQMLList.from_string('(FAILURE :reason %s)' %
message)
return response_content
def test_molecular_quantity_conc_badunit():
s = '(:type "concentration" :value 200 :unit "meter")'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
def test_molecular_quantity_num():
s = '(:type "number" :value 20000)'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
assert mq.quant_type == 'number'
assert mq.value == 20000
def test_molecular_quantity_num_badval():
s = '(:type "number" :value -1)'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
def test_molecular_quantity_qual():
s = '(:type "qualitative" :value "high")'
lst = KQMLList.from_string(s)
mq = tra_module.get_molecular_quantity(lst)
assert mq.quant_type == 'qualitative'
assert mq.value == 'high'
