def test_call_GeneralRest_response_empty(self): service_config = BrainServiceConfiguration("__PUBLISHEDREST__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDREST__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._host = TemplateWordNode("hostname") root.append(node) service = ServiceFactory.get_service("__PUBLISHEDREST__") service.set_response("") self.assertEqual("", node.resolve(self._client_context)) conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) self.assertEqual("", node.resolve(self._client_context))
def test_node_GeneralRest(self): ServiceFactory.clear() root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateSRAIXNode() self.assertIsNotNone(node) node._default = "unknown" node._host = TemplateWordNode("hostname") node._method = TemplateWordNode("POST") node._query = TemplateWordNode('"userid":"1234567890"') node._header = TemplateWordNode('"Content-Type":"application/json"') node._body = TemplateWordNode("Hello") self.assertEqual("hostname", node._host.word) root.append(node) self.assertEqual(len(root.children), 1) with self.assertRaises(Exception): node.resolve_to_string(self._client_context) self.assertEqual( '[SRAIX (host=hostname, default=unknown, method=POST, ' + 'query={"userid":"1234567890"}, header={"Content-Type":"application/json"}, ' + 'body=Hello)]', node.to_string())
def test_call_PublishedBot_response_default(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botName = "testbot" node._userId = TemplateWordNode('1234567890') node._default = "unknown" node.append(TemplateWordNode("Hello")) root.append(node) service = ServiceFactory.get_service("__PUBLISHEDBOT__") service.set_response("") self.set_collection_botnames() self.assertEqual("unknown", node.resolve(self._client_context)) conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) self.assertEqual("unknown", node.resolve(self._client_context)) self.assertEqual("unknown", question.property('__SUBAGENT_EXTBOT__.testbot'))
def test_call_CustomService_response_default(self): service_config = BrainServiceConfiguration("mock") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['mock'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._service = "mock" node._default = "unknown" node.append(TemplateWordNode("Hello")) root.append(node) service = ServiceFactory.get_service("mock") service.set_response("") self.assertEqual("unknown", node.resolve(self._client_context)) conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) self.assertEqual("unknown", node.resolve(self._client_context)) self.assertEqual("unknown", question.property('__SUBAGENT__.mock'))
def test_call_GeneralRest(self): service_config = BrainServiceConfiguration("__PUBLISHEDREST__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDREST__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._host = TemplateWordNode("hostname") node._method = TemplateWordNode("POST") node._query = TemplateWordNode('"userid":"1234567890"') node._header = TemplateWordNode('"Content-Type":"application/json"') node._body = TemplateWordNode("Hello") root.append(node) self.assertEqual("asked", node.resolve(self._client_context)) conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) self.assertEqual("asked", node.resolve(self._client_context)) self.assertEqual("asked", question.property('__SUBAGENT_BODY__'))
def set_service_config(self): service1 = BrainServiceConfiguration("ask") service1._classname = "programy.services.rest.GenericRESTService" service1._host = "localhost" service2 = BrainServiceConfiguration("test") service2._classname = "programy.services.rest.GenericRESTService" service2._host = "localhost" services_config = BrainServicesConfiguration() services_config._services = {"ask": service1, "test": service2} ServiceFactory.preload_services(services_config)
def test_load_services(self): service_config = BrainServiceConfiguration("mock") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['mock'] = service_config ServiceFactory.preload_services(brain_config.services) self.assertIsNotNone(ServiceFactory.get_service("mock")) self.assertIsInstance(ServiceFactory.get_service("mock"), MockService)
def test_call_GeneralRest_only_host(self): service_config = BrainServiceConfiguration("__PUBLISHEDREST__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDREST__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._host = TemplateWordNode("hostname") root.append(node) self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot_deleteValiables(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botId = "testBot" node._deleteVariable = TemplateWordNode('true') node.append(TemplateWordNode("Hello")) root.append(node) self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot_response_none(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botId = "testBot" node.append(TemplateWordNode("Hello")) root.append(node) service = ServiceFactory.get_service("__PUBLISHEDBOT__") service.set_response(None) self.assertIsNone(node.resolve(self._client_context))
def test_call_CustomService_response_none(self): service_config = BrainServiceConfiguration("mock") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['mock'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._service = "mock" node.append(TemplateWordNode("Hello")) root.append(node) service = ServiceFactory.get_service("mock") service.set_response(None) self.assertEqual(None, node.resolve(self._client_context))
def _published_REST_interface(self, client_context): self.method = None self.query = None self.header = None self.body = None self.host = self._host.resolve(client_context) if self._method is None: self.method = 'GET' else: self.method = self._method.resolve(client_context) if self._query is not None: shift_text = self._query.resolve(client_context) self.query = self._delete_shift_code(shift_text) if self._header is not None: shift_text = self._header.resolve(client_context) self.header = self._delete_shift_code(shift_text) if self._body is not None: self.body = self._body.resolve(client_context) resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_REST) bot_service.host = self.host bot_service.method = self.method try: if self.query is None: bot_service.query = self.query else: bot_service.query = ast.literal_eval("{" + self.query + "}") if self.header is None: bot_service.header = self.header else: bot_service.header = ast.literal_eval("{" + self.header + "}") bot_service.body = self.body response = bot_service.ask_question(client_context, resolved) YLogger.debug(client_context, "SRAIX host [%s] return [%s]", self.host, response) except Exception: YLogger.debug(client_context, "SRAIX Rest parameter convet failed") response = '' conversation = client_context.bot.get_conversation(client_context) status_code = '' try: status_code = bot_service.get_status_code() except NotImplementedError: pass if conversation.has_current_question() is True: conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code) if response is not None: if response == '' and self.default is not None: response = self.default variableName = "__SUBAGENT_BODY__" if conversation.has_current_question() is True: conversation.current_question().set_property(variableName, response) return response
def test_call_PublishedBot_only_botname(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botName = "testbot" node._userId = TemplateWordNode('1234567890') root.append(node) node.append(TemplateWordNode("Hello")) self.set_collection_botnames() self.assertEqual("asked", node.resolve(self._client_context))
def test_call_service(self): service_config = BrainServiceConfiguration("mock") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['mock'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node.service = "mock" root.append(node) node.append(TemplateWordNode("Hello")) self.assertEqual("asked", node.resolve(self._client_context))
def test_call_service(self): service_config = BrainServiceConfiguration("mock") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['mock'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node.service = "mock" root.append(node) node.append(TemplateWordNode("Hello")) self.assertEqual("asked", node.resolve(self.bot, self.clientid))
def resolve_to_string(self, client_context): resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) if self._service is not None: bot_service = ServiceFactory.get_service(self._service) response = bot_service.ask_question(client_context, resolved) YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self._service, response) return response else: YLogger.error(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service) return ""
def resolve_to_string(self, client_context): conversation = client_context.bot.get_conversation(client_context) if conversation.has_current_question() is True: conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', '') if self._service is not None: resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) bot_service = ServiceFactory.get_service(self.service) response = bot_service.ask_question(client_context, resolved) YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self.service, response) status_code = '' try: status_code = bot_service.get_status_code() except NotImplementedError: pass if conversation.has_current_question() is True: conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code) if response is not None: if conversation.has_current_question() is False: if self.default is not None: response = self.default else: variableName = "__SUBAGENT__" if response != '': try: response_json = json.loads(response) save_dic = {self.service: response_json} conversation.current_question().set_property(variableName, json.dumps(save_dic)) except Exception: variableName += ".%s" % self.service conversation.current_question().set_property(variableName, response) else: if self.default is not None: response = self.default variableName += ".%s" % self.service conversation.current_question().set_property(variableName, response) return response elif self._botName is not None: response = self._published_Bot_interface(client_context) return response elif self._host is not None: response = self._published_REST_interface(client_context) return response else: YLogger.debug(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service) return ''
def test_call_PublishedBot_topic(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botId = "testBot" node.append(TemplateWordNode("Hello")) root.append(node) conversation = self._client_context.bot.get_conversation( self._client_context) conversation.set_property('topic', 'morning') self.assertEqual("asked", node.resolve(self._client_context)) node._topic = TemplateWordNode("evening") self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot(self): service_config = BrainServiceConfiguration("__PUBLISHEDBOT__") service_config._classname = 'programytest.services.test_service.MockService' brain_config = BrainConfiguration() brain_config.services._services['__PUBLISHEDBOT__'] = service_config ServiceFactory.preload_services(brain_config.services) root = TemplateNode() node = TemplateSRAIXNode() node._botName = "testbot" node._locale = TemplateWordNode('ja-JP') node._time = TemplateWordNode('2019-01-01T00:00:00+09:00') node._userId = TemplateWordNode('1234567890') node._topic = TemplateWordNode('*') node._deleteVariable = TemplateWordNode('false') node._metadata = TemplateWordNode('1234567890') node._config = TemplateWordNode('{"config":{"logLevel":"debug"}}') node.append(TemplateWordNode("Hello")) root.append(node) self.set_collection_botnames() self.assertEqual("asked", node.resolve(self._client_context)) conversation = self._client_context.bot.get_conversation( self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text( self._client_context, "Hello", self._client_context.bot.sentence_splitter) conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) service = ServiceFactory.get_service("__PUBLISHEDBOT__") service.set_response('{"response": "asked"}') self.assertEqual("asked", node.resolve(self._client_context)) self.assertEqual('{"testbot": {"response": "asked"}}', question.property('__SUBAGENT_EXTBOT__'))
def resolve_to_string(self, bot, clientid): resolved = self.resolve_children_to_string(bot, clientid) if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("[%s] resolved to [%s]", self.to_string(), resolved) if self._service is not None: bot_service = ServiceFactory.get_service(self._service) response = bot_service.ask_question(bot, clientid, resolved) if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("SRAIX service [%s] return [%s]", self._service, response) return response else: if logging.getLogger().isEnabledFor(logging.ERROR): logging.error( "Sorry SRAIX does not currently have an implementation for [%s]", self._service) return ""
def load_services(self, configuration): ServiceFactory.preload_services(configuration.services)
def _published_Bot_interface(self, client_context): self.locale = None self.time = None self.userId = None self.topic = None self.deleteVariable = None self.metadata = None self.config = None conversation = client_context.bot.get_conversation(client_context) if self._locale is not None: self.locale = self._locale.resolve(client_context) if self._time is not None: self.time = self._time.resolve(client_context) if self._userId is not None: self.userId = self._userId.resolve(client_context) if self._topic is not None: self.topic = self._topic.resolve(client_context) if self._topic is None or self.topic == '*': if conversation.property('topic') is not '*': self.topic = conversation.property('topic') if self._deleteVariable is None: self.deleteVariable = None else: self.deleteVariable = self._deleteVariable.resolve(client_context) if self.deleteVariable.upper() == 'TRUE': self.deleteVariable = True else: self.deleteVariable = False if self._metadata is not None: self.metadata = self._metadata.resolve(client_context) if self._config is not None: shift_text = self._config.resolve(client_context) self.config = self._delete_shift_code(shift_text) resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_BOT) bot_service.botId = self.botId bot_service.botHost = self.botHost bot_service.locale = self.locale bot_service.time = self.time bot_service.userId = self.userId bot_service.topic = self.topic bot_service.deleteVariable = self.deleteVariable bot_service.metadata = self.metadata bot_service.config = self.config response = bot_service.ask_question(client_context, resolved) YLogger.debug(client_context, "SRAIX botid [%s] return [%s]", self._botId, response) status_code = '' try: status_code = bot_service.get_status_code() except NotImplementedError: pass if conversation.has_current_question() is True: conversation.current_question().set_property( '__SUBAGENT_STATUS_CODE__', status_code) if response is not None: if conversation.has_current_question() is False: if response == '' and self.default is not None: response = self.default else: variableName = "__SUBAGENT_EXTBOT__" if response != '': try: response_dic = json.loads(response) save_dic = {self._botId: response_dic} conversation.current_question().set_property( variableName, json.dumps(save_dic)) response_data = response_dic['response'] if type(response_data) is dict: response = json.dumps(response_data) else: response = response_data except Exception: if self.default is not None: response = self.default else: response = '' else: if self.default is not None: response = self.default variableName += ".%s" % self._botId conversation.current_question().set_property( variableName, response) return response
def parse_expression(self, graph, expression): mode_count = 0 if 'method' in expression.attrib: YLogger.warning(self, "'method' attrib not supported in sraix, moved to config, see documentation") if 'query' in expression.attrib: YLogger.warning(self, "'query' attrib not supported in sraix, moved to config, see documentation") if 'header' in expression.attrib: YLogger.warning(self, "'header' attrib not supported in sraix, moved to config, see documentation") if 'body' in expression.attrib: YLogger.warning(self, "'body' attrib not supported in sraix, moved to config, see documentation") if 'botName' in expression.attrib: bot_name = expression.attrib['botName'] if graph.aiml_parser.brain.botnames.botInfo(bot_name) is None: raise ParserException("BotName[%s] not found" % bot_name, xml_element=expression, nodename='sraix') mode_count += 1 self._botName = bot_name if 'locale' in expression.attrib: YLogger.warning(self, "'locale' attrib not supported in sraix, moved to config, see documentation") if 'time' in expression.attrib: YLogger.warning(self, "'time' attrib not supported in sraix, moved to config, see documentation") if 'userId' in expression.attrib: YLogger.warning(self, "'userId' attrib not supported in sraix, moved to config, see documentation") if 'topic' in expression.attrib: YLogger.warning(self, "'topic' attrib not supported in sraix, moved to config, see documentation") if 'deleteVariable' in expression.attrib: YLogger.warning(self, "'deleteVariable' attrib not supported in sraix, moved to config, see documentation") if 'metadata' in expression.attrib: YLogger.warning(self, "'metadata' attrib not supported in sraix, moved to config, see documentation") if 'config' in expression.attrib: YLogger.warning(self, "'config' attrib not supported in sraix, moved to config, see documentation") if 'service' in expression.attrib: service_name = expression.attrib['service'] if ServiceFactory.service_exists(service_name) is False: raise ParserException("Service[%s] not found" % service_name, xml_element=expression, nodename='sraix') mode_count += 1 self._service = service_name if 'default' in expression.attrib: self._default = expression.attrib['default'] head_text = self.get_text_from_element(expression) self.parse_text(graph, head_text) for child in expression: tag_name = TextUtils.tag_from_text(child.tag) if tag_name == 'host': mode_count += 1 self._host = self._parse_template_node(graph, child, 'host', False) elif tag_name == 'method': self._method = self._parse_template_node(graph, child, 'method', False) elif tag_name == 'query': self._query = self._parse_template_node(graph, child, 'query', True) elif tag_name == 'header': self._header = self._parse_template_node(graph, child, 'header', True) elif tag_name == 'body': self._body = self._parse_template_node(graph, child, 'body', False) elif tag_name == 'botName': YLogger.warning(self, "'botName' element not supported in sraix, moved to config, see documentation") elif tag_name == 'locale': self._locale = self._parse_template_node(graph, child, 'locale', False) elif tag_name == 'time': self._time = self._parse_template_node(graph, child, 'time', False) elif tag_name == 'userId': self._userId = self._parse_template_node(graph, child, 'userId', False) elif tag_name == 'topic': self._topic = self._parse_template_node(graph, child, 'topic', False) elif tag_name == 'deleteVariable': self._deleteVariable = self._parse_template_node(graph, child, 'deleteVariable', False) elif tag_name == 'metadata': self._metadata = self._parse_template_node(graph, child, 'metadata', False) elif tag_name == 'config': self._config = self._parse_template_node(graph, child, 'config', True) elif tag_name == 'service': YLogger.warning(self, "'service' element not supported in sraix, moved to config, see documentation") elif tag_name == 'default': YLogger.warning(self, "'default' element not supported in sraix, moved to config, see documentation") else: graph.parse_tag_expression(child, self) tail_text = self.get_tail_from_element(child) self.parse_text(graph, tail_text) if mode_count == 0: raise ParserException("Missing type attribute or host element", xml_element=expression, nodename='sraix') elif mode_count > 1: raise ParserException("Node has Multiple type attribute or host element", xml_element=expression, nodename='sraix')
def _published_REST_interface(self, client_context): self.host = None self.method = None self.query = None self.header = None self.body = None if self._host is not None: self.host = self._host.resolve(client_context) if self._method is not None: self.method = self._method.resolve(client_context) if self._query is not None: shift_text = self._query.resolve(client_context) self.query = self._delete_shift_code(shift_text) if self._header is not None: shift_text = self._header.resolve(client_context) self.header = self._delete_shift_code(shift_text) if self._body is not None: self.body = self._body.resolve(client_context) resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) error_msg = None if self._template is None: exec_params = RestParameters(self.host) if exec_params.host is None: error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host if error_msg is None and self.body is not None: exec_params.set_body(self.body) if error_msg is None and self.method is not None: if exec_params.set_method(self.method) is False: error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method if error_msg is None and self.query is not None: if exec_params.set_query(self.query) is False: error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query if error_msg is None and self.header is not None: if exec_params.set_header(self.header) is False: error_msg = "sraix subagent-rest : invalid locale parameter [%s]" % self.header else: restParams = client_context.brain.rest_templates.rest_template( self._template) if restParams is None: error_msg = "sraix subagent-rest : REST-Template[%s] not found" % self._template YLogger.debug(client_context, error_msg) raise Exception(error_msg) exec_params = copy.copy(restParams) if self.host is not None: if exec_params.change_host(self.host) is False: error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host if error_msg is None and self.body is not None: exec_params.join_body(self.body) if error_msg is None and self.method is not None: if exec_params.set_method(self.method) is False: error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method if error_msg is None and self.query is not None: if exec_params.join_query(self.query) is False: error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query if error_msg is None and self.header is not None: if exec_params.join_header(self.header) is False: error_msg = "sraix subagent-rest : invalid header parameter [%s]" % self.header if error_msg is not None: YLogger.debug(client_context, error_msg) raise Exception(error_msg) rest_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_REST) rest_service.params = exec_params if self._timeout is None: timeout = self.SRAIX_DEFAULT_TIMEOUT else: timeout = self._timeout response = rest_service.ask_question(client_context, resolved, timeout) YLogger.debug(client_context, "SRAIX host [%s] return [%s]", exec_params.host, response) conversation = client_context.bot.get_conversation(client_context) status_code = '' latency = '' try: status_code = rest_service.get_status_code() except NotImplementedError: pass try: latency = rest_service.get_latency() except NotImplementedError: pass if conversation.has_current_question() is True: conversation.current_question().set_property( '__SUBAGENT_STATUS_CODE__', status_code) conversation.current_question().set_property( '__SUBAGENT_LATENCY__', latency) if response is not None: if response == '' and self.default is not None: response = self.default variableName = "__SUBAGENT_BODY__" if conversation.has_current_question() is True: conversation.current_question().set_property( variableName, response) return response
def _published_Bot_interface(self, client_context): self.locale = None self.time = None self.userId = None self.topic = None self.deleteVariable = None self.metadata = None self.config = None if self._userId is not None: self.userId = self._userId.resolve(client_context) if self._locale is not None: self.locale = self._locale.resolve(client_context) if self._time is not None: self.time = self._time.resolve(client_context) if self._topic is not None: self.topic = self._topic.resolve(client_context) if self._deleteVariable is not None: self.deleteVariable = self._deleteVariable.resolve(client_context) if self._config is not None: shift_text = self._config.resolve(client_context) self.config = self._delete_shift_code(shift_text) if self._metadata is not None: self.metadata = self._metadata.resolve(client_context) bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_BOT) botInfo = client_context.brain.botnames.botInfo(self.botName) if botInfo is None: error_msg = "sraix subagent-bot : botName[%s] not found" % self.botName YLogger.debug(client_context, error_msg) raise Exception(error_msg) conversation = client_context.bot.get_conversation(client_context) exec_botInfo = copy.copy(botInfo) error_msg = None if self.userId is None or self.userId == '': self.userId = conversation.current_question().property('__USER_USERID__') if self.userId is None or self.userId == '': error_msg = "sraix subagent-bot : no userId parameter" if error_msg is None and self.locale is not None: if exec_botInfo.set_locale(self.locale) is False: error_msg = "sraix subagent-bot : invalid locale parameter [%s]" % self.locale if error_msg is None and self.time is not None: if exec_botInfo.set_time(self.time) is False: error_msg = "sraix subagent-bot : invalid time parameter [%s]" % self.time if error_msg is None and self.topic is not None: if exec_botInfo.set_topic(self.topic) is False: error_msg = "sraix subagent-bot : invalid topic parameter [%s]" % self.topic if error_msg is None and self.deleteVariable is not None: if exec_botInfo.set_deleteVariable(self.deleteVariable) is False: error_msg = "sraix subagent-bot : invalid deleteVariable parameter [%s]" % self.deleteVariable if error_msg is None and self.config is not None: if exec_botInfo.set_config(self.config) is False: error_msg = "sraix subagent-bot : invalid config parameter [%s]" % self.config if error_msg is None and self.metadata is not None: if exec_botInfo.join_metadata(self.metadata) is False: error_msg = "sraix subagent-bot : invalid metadata parameter [%s]" % self.metadata if error_msg is not None: YLogger.debug(client_context, error_msg) raise Exception(error_msg) resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) bot_service.botInfo = exec_botInfo bot_service.userId = self.userId response = bot_service.ask_question(client_context, resolved) YLogger.debug(client_context, "SRAIX botName [%s] return [%s]", self._botName, response) status_code = '' try: status_code = bot_service.get_status_code() except NotImplementedError: pass if conversation.has_current_question() is True: conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code) if response is not None: if conversation.has_current_question() is False: if response == '' and self.default is not None: response = self.default else: variableName = "__SUBAGENT_EXTBOT__" if response != '': try: response_dic = json.loads(response) save_dic = {self._botName: response_dic} conversation.current_question().set_property(variableName, json.dumps(save_dic, ensure_ascii=False)) response_data = response_dic['response'] if type(response_data) is dict: response = json.dumps(response_data, ensure_ascii=False) else: response = response_data except Exception: if self.default is not None: response = self.default else: response = '' else: if self.default is not None: response = self.default variableName += ".%s" % self._botName conversation.current_question().set_property(variableName, response) return response
def load_services(self, brain_configuration): ServiceFactory.preload_services(brain_configuration.services)