def respond_get_paper_model(self, content): """Get and display the model from a paper, indicated by pmid.""" pmid_raw = content.gets('pmid') prefix = 'PMID-' if pmid_raw.startswith(prefix) and pmid_raw[len(prefix):].isdigit(): pmid = pmid_raw[len(prefix):] else: return self.make_failure('BAD_INPUT') try: stmts = get_statements_for_paper([('pmid', pmid)], simple_response=True) except IndraDBRestAPIError as e: if e.status_code == 404 and 'Invalid or unavailable' in e.reason: logger.error("Could not find pmid: %s" % e.reason) return self.make_failure('MISSING_MECHANISM') else: raise e if not stmts: resp = KQMLPerformative('SUCCESS') resp.set('relations-found', 0) return resp stmts = ac.map_grounding(stmts) stmts = ac.map_sequence(stmts) unique_stmts = ac.run_preassembly(stmts, return_toplevel=True) diagrams = _make_diagrams(stmts) self.send_display_model(diagrams) resp = KQMLPerformative('SUCCESS') resp.set('relations-found', len(unique_stmts)) resp.set('dump-limit', str(DUMP_LIMIT)) return resp
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 reply_with_content(self, msg, reply_content): "A wrapper around the reply method from KQMLModule." if not self.testing: reply_msg = KQMLPerformative('reply') reply_msg.set('content', reply_content) self.reply(msg, reply_msg) return (msg, reply_content)
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_remove_mechanism(self, content): """Return response content to model-remove-mechanism request.""" ekb = content.gets('description') model_id = self._get_model_id(content) no_display = content.get('no-display') try: res = self.mra.remove_mechanism(ekb, model_id) except Exception as e: raise InvalidModelDescriptionError(e) model_id = res.get('model_id') if model_id is None: raise InvalidModelDescriptionError('Could not find model id.') # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add the INDRA model json model = res.get('model') model_msg = encode_indra_stmts(model) msg.sets('model', model_msg) # Add the removed statements removed = res.get('removed') if removed: removed_msg = encode_indra_stmts(removed) msg.sets('removed', removed_msg) # Add the diagram diagrams = res.get('diagrams') if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(rxn_diagram) return 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_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 respond_confirm_relation_from_literature(self, content): """Confirm a protein-protein interaction given subject, object, verb""" try: subj, obj, stmt_type, filter_agents = self._get_query_info(content) finder = \ self.msa.find_mechanism_from_input(subj, obj, None, stmt_type, ev_limit=5, persist=False, timeout=5, filter_agents=filter_agents) self._send_provenance_async(finder, 'confirming that some statements match') except MSALookupError as mle: return self.make_failure(mle.args[0]) stmts = finder.get_statements(timeout=20) if stmts is None: # TODO: Handle this more gracefully, if possible. return self.make_failure('MISSING_MECHANISM') num_stmts = len(stmts) description = finder.describe(include_negative=False) \ if stmts else None #self.say(description) resp = KQMLPerformative('SUCCESS') resp.set('some-relations-found', 'TRUE' if num_stmts else 'FALSE') resp.set('num-relations-found', str(num_stmts)) resp.set('dump-limit', str(DUMP_LIMIT)) resp.sets('suggestion', description if description else 'nil') return resp
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 message is then sent back. ''' content_list = content task_str = content_list[0].to_string().upper() if task_str == 'IS-DRUG-TARGET': reply_content = self.respond_is_drug_target(content_list) elif task_str == 'FIND-TARGET-DRUG': reply_content = self.respond_find_target_drug(content_list) elif task_str == 'FIND-DISEASE-TARGETS': reply_content = self.respond_find_disease_targets(content_list) elif task_str == 'FIND-TREATMENT': reply_content = self.respond_find_treatment(content_list) if reply_content is None: self.respond_dont_know(msg, '(ONT::A X1 :instance-of ONT::DRUG)') return else: self.error_reply(msg, 'unknown request task ' + task_str) return reply_msg = KQMLPerformative('reply') reply_msg.set_parameter(':content', reply_content) self.reply(msg, reply_msg)
def insert_data(self, receiver, data, wm_only=False): msg = KQMLPerformative('insert') msg.set('sender', self.name) msg.set('receiver', receiver) if wm_only: msg.append(':wm-only?') msg.set('content', listify(data)) self.connect(self.host, self.port) self.send(msg)
def reply(self,): reply_msg = KQMLPerformative('reply') reply_content = KQMLList() for t in self.tests: print 'reply {0}'.format(t) t_content = t.get_content() if t_content: reply_content.add(t_content.to_string()) reply_msg.setParameter(':content', reply_content) return reply_msg
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. ''' content_list = content task_str = content_list[0].to_string().upper() arguments = self.request_arguments(content_list) if task_str == 'KAPPA-VERSION': try: reply_content = self.respond_version() except Exception as e: message = 'Could not get Kappa version: (%s)' % e self.error_reply(msg, message) return elif task_str == 'KAPPA-PARSE': try: reply_content = self.respond_parse(arguments) except Exception as e: message = 'Could not parse Kappa model: (%s)' % e self.error_reply(msg, message) return elif task_str == 'KAPPA-START': try: reply_content = self.respond_start(arguments) except Exception as e: message = 'Could not start Kappa simulation: (%s)' % e self.error_reply(msg, message) return elif task_str == 'KAPPA-STATUS': try: reply_content = self.respond_status(arguments) except Exception as e: message = 'Could not get Kappa status: (%s)' % e self.error_reply(msg, message) return elif task_str == 'KAPPA-STOP': try: reply_content = self.respond_stop(arguments) except Exception as e: message = 'Could not stop Kappa simulation: (%s)' % e self.error_reply(msg, message) return else: message = '"unknown request task ' + task_str + '"' self.error_reply(msg, message) return reply_msg = KQMLPerformative('reply') reply_msg.set_parameter(':content', reply_content) logger.debug(reply_content.to_string()) self.reply(msg, reply_msg)
def respond_get_common(self, content): """Find the common up/down streams of a protein.""" # TODO: This entire function could be part of the MSA. if not CAN_CHECK_STATEMENTS: return self.make_failure( 'NO_KNOWLEDGE_ACCESS', 'Cannot access the database through the web api.' ) genes_ekb = content.gets('genes') agents = _get_agents(genes_ekb) if len(agents) < 2: return self.make_failure('NO_TARGET', 'Only %d < 2 agents given.' % len(agents)) direction = content.gets('up-down') logger.info("Got genes: %s and direction %s." % (agents, direction)) # Choose some parameters based on direction. if direction == 'ONT::MORE': method = 'common_upstreams' prefix = 'up' elif direction == 'ONT::SUCCESSOR': method = 'common_downstreams' prefix = 'down' else: # TODO: With the new MSA we could handle common neighbors. return self.make_failure("UNKNOWN_ACTION", direction) # Find the commonalities. try: finder = self.msa.find_mechanisms(method, *agents) except EntityError as e: return self.make_failure("MISSING_TARGET", e.args[0]) # Get post statements to provenance. if len(agents) > 2: name_list = ', '.join(ag.name for ag in agents[:-1]) + ',' else: name_list = agents[0].name name_list += ' and ' + agents[-1].name msg = ('%sstreams of ' % prefix).capitalize() + name_list self.send_provenance_for_stmts(finder.get_statements(), msg, ev_counts=finder.get_ev_totals()) # Create the reply resp = KQMLPerformative('SUCCESS') gene_list = KQMLList() for gene in finder.get_common_entities(): gene_list.append(gene) resp.set('commons', gene_list) resp.sets('prefix', prefix) return resp
def create_message(self): content = KQMLPerformative('SATISFIES-PATTERN') content.set('model', self.model) patt = KQMLList() patt.sets('type', 'eventual_value') ents = KQMLList() ent = KQMLList() ent.sets('description', agent_clj_from_text('phosphorylated MAPK1')) ents.append(ent) patt.set('entities', ents) val = KQMLList() val.sets('type', 'qualitative') val.sets('value', 'low') patt.set('value', val) content.set('pattern', patt) conds = KQMLList() cond = KQMLList() cond.sets('type', 'multiple') quant = KQMLList() quant.sets('type', 'total') ent = KQMLList() ent.sets('description', agent_clj_from_text('DUSP6')) quant.set('entity', ent) cond.sets('quantity', quant) #val = KQMLList() #val.sets('type', 'number') cond.set('value', KQMLToken('10')) #cond.set('value', val) conds.append(cond) content.set('conditions', conds) msg = get_request(content) return msg, content
def insert_data(self, receiver, data, wm_only=False): """Takes the data input by the user and processes it into an insert message which is subsequently sent off to Companions. Arguments: receiver {str} -- name of the receiver data {[type]} -- anything that can be listified Keyword Arguments: wm_only {bool} -- whether or not this should only be inserted into the working memory (default: {False}) """ msg = KQMLPerformative('insert') msg.set('sender', self.name) msg.set('receiver', receiver) if wm_only: msg.data.append(':wm-only?') # KMQLPerformative has no function # append, instead we must access the KQMLList inside the # KQMLPerformative .data attribute... msg.set('content', listify(data)) # pylint: disable=no-member # pylint was unable to pick up on the host and port variables being in # a defaults dict which is then used to do __setattr__ with the key # value pairs from the dict. # self.connect(self.host, self.port) self.send(msg)
def respond_phosphorylation_activating(self, content): """Return response content to phosphorylation_activating request.""" if not CAN_CHECK_STATEMENTS: return self.make_failure( 'NO_KNOWLEDGE_ACCESS', 'Cannot access the database through the web api.' ) heading = content.head() m = re.match('(\w+)-(\w+)', heading) if m is None: return self.make_failure('UNKNOWN_ACTION') action, polarity = [s.lower() for s in m.groups()] target_ekb = content.gets('target') if target_ekb is None or target_ekb == '': return self.make_failure('MISSING_TARGET') agent = _get_agent(target_ekb) logger.debug('Found agent (target): %s.' % agent.name) site = content.gets('site') if site is None: residue = None position = None else: try: residue, position = site.split('-') except: return self.make_failure('INVALID_SITE') finder = self.msa.find_phos_activeforms(agent, residue=residue, position=position, action=action, polarity=polarity) stmts = finder.get_statements() self.say(finder.describe()) logger.info("Found %d matching statements." % len(stmts)) if not len(stmts): return self.make_failure( 'MISSING_MECHANISM', "Could not find statement matching phosphorylation activating " "%s, %s, %s, %s." % (agent.name, residue, position, 'phosphorylation') ) else: msg = "phosphorylation at %s%s activates %s." \ % (residue, position, agent.name) self.send_provenance_for_stmts(stmts, msg, ev_counts=finder.get_ev_totals()) msg = KQMLPerformative('SUCCESS') msg.set('is-activating', 'TRUE') return msg
def respond_get_paper_model(self, content): """Get and display the model from a paper, indicated by pmid.""" pmid_raw = content.gets('pmid') prefix = 'PMID-' if pmid_raw.startswith(prefix) and pmid_raw[len(prefix):].isdigit(): pmid = pmid_raw[len(prefix):] else: return self.make_failure('BAD_INPUT') try: stmts = get_statements_for_paper([('pmid', pmid)]) except IndraDBRestAPIError as e: if e.status_code == 404 and 'Invalid or unavailable' in e.reason: logger.error("Could not find pmid: %s" % e.reason) return self.make_failure('MISSING_MECHANISM') else: raise e if not stmts: resp = KQMLPerformative('SUCCESS') resp.set('relations-found', 0) return resp stmts = ac.map_grounding(stmts) stmts = ac.map_sequence(stmts) unique_stmts = ac.run_preassembly(stmts, return_toplevel=True) diagrams = _make_diagrams(stmts) self.send_display_model(diagrams) resp = KQMLPerformative('SUCCESS') resp.set('relations-found', len(unique_stmts)) resp.set('dump-limit', str(DUMP_LIMIT)) return resp
def achieve_on_agent(self, receiver, data): msg = KQMLPerformative('achieve') msg.set('sender', self.name) msg.set('receiver', receiver) msg.set('content', listify(data)) self.connect(self.host, self.port) self.send(msg)
def send_generic(msg: KQMLPerformative, out: BufferedWriter): """Basic send mechanism copied (more or less) from pykqml. Writes the msg as a string to the output buffer then flushes it. Args: msg (KQMLPerformative): Message to be sent out (BufferedWriter): The output to write to, needed for sending to Companions and sending on our own port. """ LOGGER.debug('Sending: %s', msg) try: msg.write(out) except IOError: LOGGER.error('IOError during message sending') out.write(b'\n') out.flush()
def __init__(self, argv): super(TRA_Module, self).__init__(argv) self.tasks = ["SATISFIES-PATTERN"] parser = argparse.ArgumentParser() parser.add_argument("--kappa_url", help="kappa endpoint") args = parser.parse_args() if args.kappa_url: self.kappa_url = args.kappa_url else: logger.error("No Kappa URL given.") sys.exit() # Generate a basic model as placeholder (for testing) # model_text = 'MAPK1 binds MAP2K1.' # pa = PysbAssembler() # pa.add_statements(trips.process_text(model_text).statements) # self.model = pa.make_model() # Send subscribe messages for task in self.tasks: msg_txt = "(subscribe :content (request &key :content (%s . *)))" % task self.send(KQMLPerformative.from_string(msg_txt)) # Instantiate a singleton TRA agent try: kappa = kappa_client.KappaRuntime(self.kappa_url) self.tra = TRA(kappa) except Exception as e: logger.error("Could not instantiate TRA with Kappa service.") self.tra = None self.ready() super(TRA_Module, self).start()
def _get_perf(text, msg_id): text = text.encode('utf-8') msg = KQMLPerformative('REQUEST') msg.set('receiver', 'DRUM') content = KQMLList('run-text') content.sets('text', text) msg.set('content', content) msg.set('reply-with', msg_id) return msg
def _get_perf(text, msg_id): """Return a request message for a given text.""" msg = KQMLPerformative('REQUEST') msg.set('receiver', 'READER') content = KQMLList('run-text') content.sets('text', text) msg.set('content', content) msg.set('reply-with', msg_id) return msg
def respond_model_remove_mechanism(self, content): """Return response content to model-remove-mechanism request.""" model_id = self._get_model_id(content) descr = content.get('description') js = json.dumps(self.converter.cl_to_json(descr)) no_display = content.get('no-display') try: res = self.mra.remove_mechanism(js, model_id) except Exception as e: raise InvalidModelDescriptionError(e) model_id = res.get('model_id') if model_id is None: raise InvalidModelDescriptionError('Could not find model id.') # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add the INDRA model json model = res.get('model') model_msg = encode_indra_stmts(model) msg.set('model', model_msg) # Handle empty model if not model: self.send_clean_model() # Get the action and add it to the message removed = res.get('removed') if not removed: msg = self.make_failure('REMOVE_FAILED') return msg else: actionl = KQMLList('remove_stmts') actionl.set('statements', encode_indra_stmts(removed)) msg.set('action', actionl) # Add the diagram diagrams = res.get('diagrams') logger.info(diagrams) if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) return msg
def respond_choose_sense(self, content): """Return response content to choose-sense request.""" ekb = content.gets('ekb-term') msg = KQMLPerformative('SUCCESS') try: agents, ambiguities = self.bs.choose_sense(ekb) except InvalidAgentError: logger.info("agent not recognized:\n{}\n".format(ekb)) else: kagents = [] for term_id, agent_tuple in agents.items(): kagent = get_kagent(agent_tuple, term_id) kagents.append(kagent) msg.set('agents', KQMLList(kagents)) if ambiguities: ambiguities_msg = get_ambiguities_msg(ambiguities) msg.set('ambiguities', ambiguities_msg) return msg
def register(self): if self.name is not None: perf = KQMLPerformative('register') perf.set('sender', self.name) perf.set('receiver', 'facilitator') content = KQMLList([ '"socket://' + self.host + ':' + str(self.localPort) + '"', 'nil', 'nil', self.localPort ]) perf.set('content', content) self.send(perf)
def get_content(self): """Convert the entry to a message.""" if not self.content: maxlen = 100000 if len(self.message) <= maxlen: self.content = KQMLPerformative.from_string(self.message) else: raise KQMLException('Message is longer than %d characters' % maxlen) return self.content
def achieve_on_agent(self, receiver, data): """Sends a KQML message to the proper receiver with the data formatted properly as a list. Arguments: receiver {str} -- name of the receiver data {[type]} -- anything """ msg = KQMLPerformative('achieve') msg.set('sender', self.name) msg.set('receiver', receiver) msg.set('content', listify(data)) self.send(msg)
def send_provenance(self, result): id1 = result['id1'] mods1 = result['mods1'] id2 = result['id2'] mods2 = result['mods2'] rel = result['rel'] title = str(id1) + ' ' + str(rel) + ' ' + str(id2) uri_str = result['uri_str'] pc_url = 'http://www.pathwaycommons.org/pc2/get?' + uri_str + 'format=SBGN' html = '<a href= \'' + pc_url + '\' target= \'_blank\' > PC link</a>' msg = KQMLPerformative('tell') content = KQMLList('add-provenance') content.sets('html', html) pc_url_formatted = "http://www.pathwaycommons.org/pc2/get?" + uri_str + "format=SBGN" content.sets('pc', pc_url_formatted) content.sets('title', title) msg.set('content', content) self.send(msg)
def register(self): if self.name is not None: perf = KQMLPerformative('register') perf.set('name', self.name) if self.group_name is not None: try: if self.group_name.startswith('('): perf.sets('group', self.group_name) else: perf.set('group', self.group_name) except IOError: logger.error('bad group name: ' + self.group_name) self.send(perf)
def performative(string: str) -> KQMLPerformative: """Wrapper for KQMLPerformative.from_string, produces a performative object from a KQML string Arguments: string (str): well formed KQML performative as a string Returns: KQMLPerformative """ return KQMLPerformative.from_string(string)
def __init__(self, argv): super(MRA_Module, self).__init__(argv) self.tasks = ["BUILD-MODEL", "EXPAND-MODEL", "MODEL-HAS-MECHANISM"] self.models = [] for task in self.tasks: msg_txt = "(subscribe :content (request &key :content (%s . *)))" % task self.send(KQMLPerformative.from_string(msg_txt)) # Instantiate a singleton MRA agent self.mra = MRA() self.ready() super(MRA_Module, self).start()
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) elif task_str == "MODEL-HAS-MECHANISM": reply_content = self.respond_has_mechanism(content) 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 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. """ content_list = content task_str = content_list[0].to_string().upper() if task_str == "SIMULATE-MODEL": try: reply_content = self.respond_simulate_model(content_list) except Exception as e: self.error_reply(msg, "Error in performing simulation task.") return else: self.error_reply(msg, "Unknown request task " + task_str) return reply_msg = KQMLPerformative("reply") reply_msg.set_parameter(":content", reply_content) self.reply(msg, reply_msg)
def full_remove_packaging(perf: KQMLPerformative): """Take a performative and strip package info from it Args: perf (KQMLPerformative): performative to strip Returns: KQMLPerformative: striped of package info """ filter_list = [remove_packaging(s) for s in perf.to_string().split()] temp_perf = ' '.join(filter_list) return performative('(' + temp_perf if temp_perf[0] != '(' else temp_perf)
def respond_build_model(self, content): """Return response content to build-model request.""" descr = content.gets('description') descr_format = content.gets('format') no_display = content.get('no-display') if not descr_format or descr_format == 'ekb': res = self.mra.build_model_from_ekb(descr) elif descr_format == 'indra_json': res = self.mra.build_model_from_json(descr) else: err_msg = 'Invalid description format: %s' % descr_format raise InvalidModelDescriptionError(err_msg) if res.get('error'): raise InvalidModelDescriptionError(res.get('error')) model_id = res.get('model_id') if model_id is None: raise InvalidModelDescriptionError() # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add the INDRA model json model = res.get('model') if model: self.send_background_support(model) model_msg = encode_indra_stmts(model) msg.sets('model', model_msg) # Add the diagrams diagrams = res.get('diagrams') if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) ambiguities = res.get('ambiguities') if ambiguities: ambiguities_msg = get_ambiguities_msg(ambiguities) msg.set('ambiguities', ambiguities_msg) return msg
def receive_subscribe(self, msg, content): """Override of KQMLModule default, expects a performative of ask-all. Gets the ask-all query from the message contents (the contents of the content variable is the query that we care about), then checks to see if the query head is in the dictionary of available asks and checks if the query string is in the dictionary of subscribers. If both of these are true we then append the message to the subscriber query, clean out any previous subscription data, and reply with a tell ok message. Arguments: msg {KQMLPerformative} -- performative to be passed along in reply and stored in the subscribers dictionary content {KQMLPerformative} -- ask-all for a query """ LOGGER.debug('received subscribe: %s', content) # lazy logging if content.head() == 'ask-all': # TODO - track msg ideas and use for filtering query = content.get('content') query_string = query.to_string() if query.head() in self.asks and query_string in self.subscribers: self.subscribers[query_string].append(msg) self.subcribe_data_old[query_string] = None self.subcribe_data_new[query_string] = None reply_msg = KQMLPerformative('tell') reply_msg.set(':sender', self.name) reply_msg.set('content', ':ok') self.reply(msg, reply_msg)
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. """ if self.tra is None: reply_content = KQMLList.from_string("(FAILURE :reason KAPPA_FAILURE)") reply_msg = KQMLPerformative("reply") reply_msg.set_parameter(":content", reply_content) self.reply(msg, reply_msg) return content_list = content task_str = content_list[0].to_string().upper() if task_str == "SATISFIES-PATTERN": try: reply_content = self.respond_satisfies_pattern(content_list) except Exception as e: self.error_reply(msg, "Error in performing satisfies " + "pattern task.") return else: self.error_reply(msg, "Unknown request task " + task_str) return reply_msg = KQMLPerformative("reply") reply_msg.set_parameter(":content", reply_content) self.reply(msg, reply_msg)
def receive_other_performative(self, msg): """Override of KQMLModule default... ping isn't currently supported by pykqml so we handle other to catch ping and otherwise throw an error. Arguments: msg {KQMLPerformative} -- other type of performative, if ping we reply with a ping update otherwise error """ if msg.head() == 'ping': reply_content = KQMLList([':agent', self.name]) reply_content.append(':uptime') reply_content.append(self._uptime()) # TODO - check if .set('status', ':OK') can be used here instead reply_content.append(':status') reply_content.append(':OK') reply_content.append(':state') reply_content.append('idle') reply_content.append(':machine') reply_content.append(socket.gethostname()) reply = KQMLPerformative('update') reply.set('sender', self.name) # reply.set('receiver', msg.get('sender')) # reply.set('in-reply-to', msg.get('reply-with')) reply.set('content', reply_content) self.reply(msg, reply) else: self.error_reply(msg, 'unexpected performative: ' + str(msg))
def respond_model_remove_mechanism(self, content): """Return response content to model-remove-mechanism request.""" ekb = content.gets('description') model_id = self._get_model_id(content) no_display = content.get('no-display') try: res = self.mra.remove_mechanism(ekb, model_id) except Exception as e: raise InvalidModelDescriptionError(e) model_id = res.get('model_id') if model_id is None: raise InvalidModelDescriptionError('Could not find model id.') # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add the INDRA model json model = res.get('model') model_msg = encode_indra_stmts(model) msg.sets('model', model_msg) # Handle empty model if not model: self.send_clean_model() # Get the action and add it to the message removed = res.get('removed') if not removed: msg = self.make_failure('REMOVE_FAILED') return msg else: actionl = KQMLList('remove_stmts') actionl.sets('statements', encode_indra_stmts(removed)) msg.set('action', actionl) # Add the diagram diagrams = res.get('diagrams') logger.info(diagrams) if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) return msg
def respond_model_undo(self, content): """Return response content to model-undo request.""" res = self.mra.model_undo() no_display = content.get('no-display') model_id = res.get('model_id') # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', 'NIL' if model_id is None else str(model_id)) # Add the INDRA model json model = res.get('model') # Handle empty model if not model: self.send_clean_model() model_msg = encode_indra_stmts(model) msg.set('model', model_msg) # Get the action and add it to the message action = res.get('action') actionl = KQMLList() # Here we handle no action as effectively an empty remove action if action['action'] in ('no_op', 'remove_stmts'): actionl.append('remove_stmts') actionl.set( 'statements', encode_indra_stmts(action['statements']) ) msg.set('action', actionl) # Add the diagram diagrams = res.get('diagrams') if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) return msg
def send_display_model(self, model, diagrams): msg = KQMLPerformative('tell') content = KQMLList('display-model') content.set('type', 'indra') content.sets('model', model) msg.set('content', content) self.send(msg) for diagram_type, path in diagrams.items(): if not path: continue msg = KQMLPerformative('tell') content = KQMLList('display-image') content.set('type', diagram_type) content.sets('path', path) msg.set('content', content) self.send(msg)
def register(self): """Overrides the KQMLModule default and uses Companions standards to send proper registration. """ if self.name is not None: perf = KQMLPerformative('register') perf.set('sender', self.name) perf.set('receiver', 'facilitator') # pylint: disable=no-member # pylint was unable to pick up on the host variable being in a # defaults dict which is then used to do __setattr__ with the key # value pairs from the dict. socket_url = f'"socket://{self.host}:{self.local_port}"' content = KQMLList([socket_url, 'nil', 'nil', self.local_port]) perf.set('content', content) self.send(perf)
def init(self): ''' Initialize TRIPS module ''' super(Test_Module, self).init() # Send subscribe messages for task, subtasks in self.tasks.iteritems(): for subtask in subtasks: msg_txt = '(subscribe :content (request &key :content ' +\ '(%s &key :content (%s . *))))' % (task, subtask) self.send(KQMLPerformative.from_string(msg_txt)) # Send ready message self.ready() return None
def respond_phosphorylation_activating(self, content): """Return response content to phosphorylation_activating request.""" heading = content.head() m = re.match('(\w+)-(\w+)', heading) if m is None: return self.make_failure('UNKNOWN_ACTION') action, polarity = [s.lower() for s in m.groups()] target_ekb = content.gets('target') if target_ekb is None or target_ekb == '': return self.make_failure('MISSING_TARGET') agent = self._get_agent(target_ekb) logger.debug('Found agent (target): %s.' % agent.name) residue = content.gets('residue') position = content.gets('position') related_results = [ s for s in self.signor_afs if self._matching(s, agent, residue, position, action, polarity) ] if not len(related_results): return self.make_failure( 'MISSING_MECHANISM', "Could not find statement matching phosphorylation activating " "%s, %s, %s, %s." % (agent.name, residue, position, 'phosphorylation') ) else: self.send_provenance_for_stmts( related_results, "Phosphorylation at %s%s activates %s." % ( residue, position, agent.name ) ) msg = KQMLPerformative('SUCCESS') msg.set('is-activating', 'TRUE') return msg
def respond_phosphorylation_activating(self, content): """Return response content to phosphorylation_activating request.""" if not CAN_CHECK_STATEMENTS: return self.make_failure( 'NO_KNOWLEDGE_ACCESS', 'Cannot access the database through the web api.') heading = content.head() m = re.match(r'(\w+)-(\w+)', heading) if m is None: return self.make_failure('UNKNOWN_ACTION') action, polarity = [s.lower() for s in m.groups()] target_cljson = content.get('target') if target_cljson is None or not len(target_cljson): return self.make_failure('MISSING_TARGET') agent = self.get_agent(target_cljson) # This is a bug in the BA that we can handle here if isinstance(agent, list): agent = agent[0] logger.debug('Found agent (target): %s.' % agent.name) site = content.gets('site') if site is None: residue = None position = None else: try: residue, position = site.split('-') except: return self.make_failure('INVALID_SITE') finder = self.msa.find_phos_activeforms(agent, residue=residue, position=position, action=action, polarity=polarity) stmts = finder.get_statements() logger.info("Found %d matching statements." % len(stmts)) if not len(stmts): return self.make_failure( 'MISSING_MECHANISM', "Could not find statement matching phosphorylation activating " "%s, %s, %s, %s." % (agent.name, residue, position, 'phosphorylation')) else: description = finder.describe(include_negative=False) # self.say(description) msg = "phosphorylation at %s%s activates %s." \ % (residue, position, agent.name) self.send_provenance_for_stmts( stmts, msg, ev_counts=finder.get_ev_totals(), source_counts=finder.get_source_counts()) msg = KQMLPerformative('SUCCESS') msg.set('is-activating', 'TRUE') msg.sets('suggestion', description) return msg
def __init__(self, argv): # Call the constructor of TripsModule super(DTDA_Module, self).__init__(argv) self.tasks = ['IS-DRUG-TARGET', 'FIND-TARGET-DRUG', 'FIND-DISEASE-TARGETS', 'FIND-TREATMENT'] # Send subscribe messages for task in self.tasks: msg_txt =\ '(subscribe :content (request &key :content (%s . *)))' % task self.send(KQMLPerformative.from_string(msg_txt)) # Instantiate a singleton DTDA agent self.dtda = DTDA() # Send ready message self.ready() super(DTDA_Module, self).start()
def __init__(self, argv): super(MEA_Module, self).__init__(argv) self.tasks = ["SIMULATE-MODEL"] parser = argparse.ArgumentParser() parser.add_argument("--kappa_url", help="kappa endpoint") args = parser.parse_args() if args.kappa_url: self.kappa_url = args.kappa_url # Send subscribe messages for task in self.tasks: msg_txt = "(subscribe :content (request &key :content (%s . *)))" % task self.send(KQMLPerformative.from_string(msg_txt)) # Instantiate a singleton MEA agent self.mea = MEA() self.ready() super(MEA_Module, self).start()
def respond_model_undo(self, content): """Return response content to model-undo request.""" res = self.mra.model_undo() no_display = content.get('no-display') model_id = res.get('model_id') # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', 'NIL' if model_id is None else str(model_id)) # Add the INDRA model json model = res.get('model') # Handle empty model if not model: self.send_clean_model() model_msg = encode_indra_stmts(model) msg.sets('model', model_msg) # Get the action and add it to the message action = res.get('action') actionl = KQMLList() # Here we handle no action as effectively an empty remove action if action['action'] in ('no_op', 'remove_stmts'): actionl.append('remove_stmts') actionl.sets( 'statements', encode_indra_stmts(action['statements']) ) msg.set('action', actionl) # Add the diagram diagrams = res.get('diagrams') if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) return msg
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 respond_model_has_mechanism(self, content): """Return response content to model-has-mechanism request.""" ekb = content.gets('description') model_id = self._get_model_id(content) try: res = self.mra.has_mechanism(ekb, model_id) except Exception as e: raise InvalidModelDescriptionError(e) # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add TRUE or FALSE for has-mechanism has_mechanism_msg = 'TRUE' if res['has_mechanism'] else 'FALSE' msg.set('has-mechanism', has_mechanism_msg) query = res.get('query') if query: query_msg = encode_indra_stmts([query]) msg.sets('query', query_msg) return msg
def __init__(self, argv): # Call the constructor of TripsModule super(Kappa_Module, self).__init__(argv) self.tasks = ['KAPPA-VERSION', 'KAPPA-PARSE', 'KAPPA-START', 'KAPPA-STATUS', 'KAPPA-STOP'] parser = argparse.ArgumentParser() parser.add_argument("--kappa_url", help="kappa endpoint") args = parser.parse_args() if args.kappa_url: self.kappa_url = args.kappa_url else: logger.error('No Kappa URL given.') sys.exit() # Send subscribe messages for task in self.tasks: msg_txt =\ '(subscribe :content (request &key :content (%s . *)))' % task self.send(KQMLPerformative.from_string(msg_txt)) # Instantiate a kappa runtime self.kappa = KappaRuntime(self.kappa_url) # Send ready message self.ready() super(Kappa_Module, self).start()
def respond_confirm_relation_from_literature(self, content): """Confirm a protein-protein interaction given subject, object, verb""" try: subj, obj, stmt_type = self._get_query_info(content) finder = \ self.msa.find_mechanism_from_input(subj, obj, None, stmt_type, ev_limit=5, persist=False, timeout=5) self._send_provenance_async(finder, 'confirming that some statements match') except MSALookupError as mle: return self.make_failure(mle.args[0]) stmts = finder.get_statements(timeout=20) if stmts is None: # TODO: Handle this more gracefully, if possible. return self.make_failure('MISSING_MECHANISM') num_stmts = len(stmts) self.say(finder.describe()) resp = KQMLPerformative('SUCCESS') resp.set('some-relations-found', 'TRUE' if num_stmts else 'FALSE') resp.set('num-relations-found', str(num_stmts)) resp.set('dump-limit', str(DUMP_LIMIT)) return resp
def error_reply(self, msg, comment): reply_msg = KQMLPerformative('error') reply_msg.sets('comment', comment) self.reply(msg, reply_msg)
def respond_build_model(self, content): """Return response content to build-model request.""" descr = content.gets('description') descr_format = content.gets('format') no_display = content.get('no-display') if not descr_format or descr_format == 'ekb': res = self.mra.build_model_from_ekb(descr) elif descr_format == 'indra_json': res = self.mra.build_model_from_json(descr) else: err_msg = 'Invalid description format: %s' % descr_format raise InvalidModelDescriptionError(err_msg) if res.get('error'): raise InvalidModelDescriptionError(res.get('error')) model_id = res.get('model_id') if model_id is None: raise InvalidModelDescriptionError() # Start a SUCCESS message msg = KQMLPerformative('SUCCESS') # Add the model id msg.set('model-id', str(model_id)) # Add the INDRA model json model = res.get('model') if model and (descr_format == 'ekb' or not descr_format): self.send_background_support(model) model_msg = encode_indra_stmts(model) msg.sets('model', model_msg) # Add the diagrams diagrams = res.get('diagrams') if not no_display: if diagrams: rxn_diagram = diagrams.get('reactionnetwork') if rxn_diagram: msg.sets('diagram', rxn_diagram) self.send_display_model(diagrams) # Indicate whether the goal has been explained has_expl = res.get('has_explanation') if has_expl is not None: msg.set('has_explanation', str(has_expl).upper()) # Send out various model diagnosis messages self.send_model_diagnoses(res) # Once we sent out the diagnosis messages, we make sure we keep # track of whether we have an explanation if has_expl: self.have_explanation = True # Analyze the model for issues # Report ambiguities ambiguities = res.get('ambiguities') if ambiguities: ambiguities_msg = get_ambiguities_msg(ambiguities) msg.set('ambiguities', ambiguities_msg) return msg
def send_clean_model(self): msg = KQMLPerformative('request') content = KQMLList('clean-model') msg.set('content', content) self.send(msg)