def resolve_type3_condition(self, client_context): try: for condition in self.children: value = self.get_condition_variable_value(client_context, condition.var_type, condition.name) if condition.value is not None: condition_value = condition.value.resolve(client_context) # Condition comparison is always case insensetive if value.upper() == condition_value.upper(): resolved = client_context.brain.tokenizer.words_to_texts([child_node.resolve(client_context) for child_node in condition.children]) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) if condition.loop is True: resolved = resolved.strip() + " " + self.resolve(client_context).strip() return resolved default = self.get_default() if default is not None: resolved = client_context.brain.tokenizer.words_to_texts([child_node.resolve(client_context) for child_node in default.children]) if default.loop is True: resolved = resolved.strip() + " " + self.resolve(client_context).strip() else: resolved = "" YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved except Exception as excep: YLogger.exception(client_context, "Failed to resolve type3 condition", excep) return ""
def equals(self, client_context, words, word_no): word = words.word(word_no) if self.userid != '*': if self.userid != client_context.userid: return EqualsMatch(False, word_no) if self._pattern_template is not None: template = client_context.brain.regex_templates[self._pattern_template] if template is not None: result = template.match(word) if result is not None: YLogger.debug(client_context, "Match word [%s] regex", word) return EqualsMatch(True, word_no, word) else: YLogger.error(client_context, "No word [%s] matched regex", word) return EqualsMatch(False, word_no) else: return EqualsMatch(False, word_no) else: result = self.pattern.match(word) if result is not None: YLogger.debug(client_context, "Match word [%s] regex", word) return EqualsMatch(True, word_no, word) else: YLogger.error(client_context, "No word [%s] matched regex", word) return EqualsMatch(False, word_no)
def execute(self, context, data): YLogger.debug(context, "GeoCode [%s]", data) words = data.split(" ") if words[0] == 'POSTCODE1': location = words[1] elif words[0] == 'POSTCODE2': location = words[1] + words[2] elif words[0] == 'LOCATION': location = " ".join(words[1:]) else: return None googlemaps = self.get_geo_locator() latlng = googlemaps.get_latlong_for_location(location) if latlng is not None: str_lat = str(latlng.latitude) str_lng = str(latlng.longitude) lats = str_lat.split(".") lngs = str_lng.split(".") return "LATITUDE DEC %s FRAC %s LONGITUDE DEC %s FRAC %s"%( lats[0], lats[1], lngs[0], lngs[1] ) return None
def execute(self, client_context, data): YLogger.debug(client_context, "Transcript Admin - [%s]", data) show_props = True if data == "PROPERTIES" else False transcript = "" if client_context.bot.has_conversation(client_context): conversation = client_context.bot.conversation(client_context) transcript += "Questions:<br /><ul>" for question in conversation.questions: transcript += "<li>%s - %s</li>"%(question.combine_sentences(), question.combine_answers()) transcript += "</ul>" transcript += "<br />" if data == "PROPERTIES": transcript += "Properties:<br /><ul>" for name, value in conversation.properties.items(): transcript += "<li>%s = %s</li>"%(name, value) transcript += "</ul>" transcript += "<br />" else: transcript += "No conversation currently available" return transcript
def execute(self, client_context, data): YLogger.debug(client_context, "RDF Admin - [%s]", data) rdf = "" segments = data.split() if segments[0] == 'SUBJECTS': subjects = client_context.brain.rdf.subjects() if segments[1] == 'LIST': rdf += "<ul>" for subject in subjects: rdf += "<li>%s</li>"%subject rdf += "</ul>" else: return str(len(subjects)) elif segments[0] == "PREDICATES": subject = segments[1] predicates = client_context.brain.rdf.predicates(subject) rdf += "<ul>" for predicate in predicates: rdf += "<li>%s</li>" % predicate rdf += "</ul>" elif segments[0] == "OBJECT": subject = segments[1] predicate = segments[2] objects = client_context.brain.rdf.objects(subject, predicate) rdf += "<ul>" for object in objects: rdf += "<li>%s</li>" % object rdf += "</ul>" return rdf
def handle_message(self, message): try: if self.configuration.client_configuration.debug is True: self.dump_request(message) self.renderer.print_payload("Incoming", message) # Facebook Messenger ID for user so we know where to send response back to recipient_id = self.get_recipitent_id(message) if recipient_id: client_context = self.create_client_context(recipient_id) message_text = self.get_message_text(message) # We have been send a text message, we can respond if message_text is not None: response_text = self.handle_text_message(client_context, message_text) # else if user sends us a GIF, photo,video, or any other non-text item elif self.has_attachements(message): response_text = self.handle_attachement(client_context, message) # otherwise its a general error else: YLogger.error(client_context, "Facebook general error handling message") response_text = "Sorry, I do not understand you!" YLogger.debug(client_context, "Facebook message response: [%s]", response_text) self.render_response(client_context, response_text) except Exception as e: YLogger.exception(None, "Error handling facebook message", e)
def load_users(self, yaml_data): users = {} if 'users' in yaml_data: for user_name in yaml_data['users'].keys(): user = User(user_name) yaml_obj = yaml_data['users'][user_name] if 'roles' in yaml_obj: roles_list = yaml_obj['roles'] splits = roles_list.split(",") for role_name in splits: role_name = role_name.strip() if role_name not in user.roles: user.roles.append(role_name) else: YLogger.debug(self, "Role [%s] already exists in user [%s]", role_name, user_name) if 'groups' in yaml_obj: groups_list = yaml_obj['groups'] splits = groups_list.split(",") for group_name in splits: group_name = group_name.strip() if group_name not in user.groups: user.groups.append(group_name) else: YLogger.debug(self, "Group [%s] already exists in user [%s]", group_name, user_name) users[user.userid] = user return users
def wait_and_answer(self): running = True try: self._client_connection = self._server_socket.accept_connection() receive_payload = self._client_connection.receive_data() question = self.extract_question(receive_payload) userid = self.extract_userid(receive_payload) client_context = self.create_client_context(userid) answer = self.process_question(client_context, question) self.render_response(client_context, answer) except KeyboardInterrupt: running = False YLogger.debug(self, "Cleaning up and exiting...") except Exception as e: if self._client_connection is not None: self._client_connection.send_error(e) finally: if self._client_connection is not None: self._client_connection.close() return running
def resolve_to_string(self, client_context): conversation = client_context.bot.get_conversation(client_context) question = conversation.current_question() sentence = question.current_sentence() resolved = sentence.matched_context.topicstar(self.index) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def check_spelling_before(self, each_sentence): # TODO Move this to spelliing base class if self.configuration.spelling.check_before is True: text = each_sentence.text() corrected = self.spell_checker.correct(text) YLogger.debug(self, "Spell Checker corrected [%s] to [%s]", text, corrected) each_sentence.replace_words(corrected)
def _parse_node_with_attribs(self, graph, expression, attribs): attribs_found = [] for attrib in attribs: attrib_name = attrib[0] if attrib_name in expression.attrib: self.set_attrib(attrib_name, expression.attrib[attrib_name]) attribs_found.append(attrib_name) self.parse_text(graph, self.get_text_from_element(expression)) for child in expression: tag_name = TextUtils.tag_from_text(child.tag) for attrib in attribs: attrib_name = attrib[0] if tag_name == attrib_name: self.set_attrib(attrib[0], self.get_text_from_element(child)) else: graph.parse_tag_expression(child, self) self.parse_text(graph, self.get_tail_from_element(child)) for attrib in attribs: attrib_name = attrib[0] if attrib_name not in attribs_found: if attrib[1] is not None: YLogger.debug(self, "Setting default value for attrib [%s]", attrib_name) self.set_attrib(attrib_name, attrib[1])
def resolve_to_string(self, client_context): srai_text = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] SRAI Text [%s]", self.to_string(), srai_text) resolved = client_context.bot.ask_question(client_context, srai_text, srai=True) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def match_sentence(self, client_context, pattern_sentence, topic_pattern, that_pattern): topic_sentence = Sentence(client_context.brain.tokenizer, topic_pattern) that_sentence = Sentence(client_context.brain.tokenizer, that_pattern) YLogger.debug(client_context, "AIML Parser matching sentence [%s], topic=[%s], that=[%s] ", pattern_sentence.text(), topic_pattern, that_pattern) sentence = Sentence(client_context.brain.tokenizer) sentence.append_sentence(pattern_sentence) sentence.append_word('__TOPIC__') sentence.append_sentence(topic_sentence) sentence.append_word('__THAT__') sentence.append_sentence(that_sentence) YLogger.debug(client_context, "Matching [%s]", sentence.words_from_current_pos(0)) context = MatchContext(max_search_depth=client_context.bot.configuration.max_search_depth, max_search_timeout=client_context.bot.configuration.max_search_timeout, tokenizer=client_context.brain.tokenizer) template = self._pattern_parser._root_node.match(client_context, context, sentence) if template is not None: context._template_node = template context.list_matches(client_context) # Save the matched context for the associated sentence pattern_sentence.matched_context = context return context return None
def schedule_as_cron(self, userid, clientid, action, text, year='*', month='*', day='*', week='*', day_of_week='*', hour='*', minute='*', second='*'): YLogger.debug(None, "Scheduler scheduling cron") job_id = self.create_job_id(userid, clientid, action, text) self.remove_existing_job(job_id) self._scheduler.add_job(scheduled, 'cron', [self.name, userid, clientid, action, text], id=job_id, year=year, month=month, day=day, week=week, day_of_week=day_of_week, hour=hour, minute=minute, second=second)
def send_response(self, userid, answer): return_payload = {"result": "OK", "answer": answer, "userid": userid} json_data = json.dumps(return_payload) YLogger.debug(self, "Sent %s:", json_data) self._clientsocket.send(json_data.encode('utf-8'))
def add_set(self, name, the_set): # Set names always stored in upper case to handle ambiquity set_name = name.upper() if set_name in self._sets: raise Exception("Set %s already exists" % set_name) YLogger.debug(self, "Adding set [%s[ to set group", set_name) self._sets[set_name] = the_set
def resolve_to_string(self, client_context): string = self.resolve_children_to_string(client_context) query = {'q': string} encoded = urlencode(query) resolved = "https://www.google.co.uk/search?" + encoded YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def _follow_new_followers(self, followers, friends): for follower in followers: YLogger.debug(self, "Checking follower [%s]", follower.screen_name) if follower.id not in friends: YLogger.debug(self, "Following %s", follower.screen_name) follower.follow() self._api.send_direct_message(follower.id, text=self._welcome_message)
def resolve_to_string(self, client_context): conversation = client_context.bot.get_conversation(client_context) if conversation.has_current_question(): current_question = conversation.current_question() current_sentence = current_question.current_sentence() matched_context = current_sentence.matched_context if matched_context is None: YLogger.error(client_context, "Star node has no matched context for clientid %s", client_context.userid) resolved = "" else: try: resolved = matched_context.star(self.index) if resolved is None: YLogger.error(client_context, "Star index not in range [%d]", self.index) resolved = "" except Exception: YLogger.error(client_context, "Star index not in range [%d]", self.index) resolved = "" else: resolved = "" YLogger.debug(client_context, "Star Node [%s] resolved to [%s]", self.to_string(), resolved) return resolved
def _get_response_as_json(self, url): YLogger.debug(self, "GoogleMaps Request = [%s]", url) response = urllib.request.urlopen(url) content = response.read() decoded = content.decode('utf8') YLogger.debug(self, "GoogleMaps Response = [%s]", decoded) return json.loads(decoded)
def _get_news_feed_articles(url, max_articles, sort, reverse): YLogger.debug(None, "News API URL: [%s]", url) response = NewsAPI._news_api_api.get_news(url) articles = [] if response.status_code == 200: header_splits = response.headers['content-type'].split(";") if header_splits[0] == 'application/json': json_data = response.json() if 'articles' in json_data: for article_data in json_data['articles']: article = NewsArticle() article.parse_json(article_data) articles.append(article) YLogger.debug(None, article.description) if sort is True: YLogger.debug(None, "Sorting articles,, reverse=%s", str(reverse)) articles.sort(key=lambda article: article.published_at, reverse=reverse) if max_articles != 0: YLogger.debug(None, "Returning max_articles %d articles", max_articles) articles = articles[:max_articles] else: YLogger.debug(None, "Returning all articles") else: YLogger.error(None, "NewAPI payload contains no articles attribute") else: YLogger.error(None, "NewsAPI request none JSON object") else: YLogger.error(None, "NewsAPI request returned error code %d", response.status_code) return articles
def resolve_to_string(self, client_context): result = self.resolve_children_to_string(client_context) first = result[:1] rest = result[1:] resolved = first.upper() + rest.lower() YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def resolve_variable(self, client_context): name = self.name.resolve(client_context) value = TemplateGetNode.get_property_value(client_context, self.local, name) if self.local: YLogger.debug(client_context, "[%s] resolved to local: [%s] <= [%s]", self.to_string(), name, value) else: YLogger.debug(client_context, "[%s] resolved to global: [%s] <= [%s]", self.to_string(), name, value) return value
def get_userid(self, request): userid = request.cookies.get(self.configuration.client_configuration.cookie_id) if userid is None: userid = str(uuid.uuid4().hex) YLogger.debug(self, "Setting userid cookie to :%s" % userid) else: YLogger.debug(self, "Found userid cookie : %s" % userid) return userid
def resolve(self, client_context): try: resolved = self.resolve_children_to_string(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved except Exception as excep: YLogger.exception(client_context, "Failed to resolve", excep) return ""
def _process_direct_message_question(self, userid, text): YLogger.debug(self, "Direct Messages: %s -> %s", userid, text) client_context = self.create_client_context(userid) response = client_context.bot.ask_question(client_context, text, responselogger=self) self._api.send_direct_message(userid, text=response)
def mark_question_start(self, question): YLogger.debug(self, "##########################################################################################") YLogger.debug(self, "Question (%s): %s", self._client.id, question) if self._question_depth == 0: self._question_start_time = datetime.datetime.now() self._question_depth += 1
def __init__(self, argument_parser=None): FlaskRestBotClient.__init__(self, 'facebook', argument_parser) YLogger.debug(self, "Facebook Client is running....") self._facebook_bot = self.create_facebook_bot() print("Facebook Client loaded")
def scheduled_event(name, userid, clientid, action, text): YLogger.debug(None, "Received Scheduled Event [%s] [%s] [%s] [%s] [%s]", name, userid, clientid, action, text) if name in ProgramyScheduler.schedulers: scheduler = ProgramyScheduler.schedulers[name] scheduler.scheduled(userid, clientid, action, text) else: YLogger.error(None, "Unknown scheduler [%s]", name)
def wait_loop(self, period=5): try: while True: time.sleep(period) except: YLogger.debug(None, "Scheduler shutting down...") finally: self.stop()
def resolve_to_string(self, client_context): resolved = "" conversation = client_context.bot.get_conversation(client_context) slotName = self._slotName.resolve(client_context) itemName = self._itemName.resolve(client_context) try: slotIndex = int(self._index.resolve(client_context)) except Exception: slotIndex = 0 slots = None try: value = conversation.current_question().property( "__SYSTEM_NLUDATA__") json_dict = json.loads(value) slots = json_dict["slots"] except Exception: YLogger.error( self, "TemplateNluSlotNode failed to load __SYSTEM_NLUDATA__") return resolved slotsKeyName = "slot" slotKeys = [slot.get(slotsKeyName) for slot in slots] if itemName == "count": if slotName == "*": resolved = str(len(slotKeys)) else: resolved = str(slotKeys.count(slotName)) YLogger.debug(client_context, "nluslot [%s] resolved to [%s]", itemName, resolved) return resolved index = None try: if slotName == "*": index = 0 if slotIndex != 0: index = slotIndex else: if slotIndex != 0: slotCounter = 0 targetCounter = 0 for name in slotKeys: if name == slotName: if targetCounter == slotIndex: index = slotCounter break targetCounter += 1 slotCounter += 1 else: index = slotKeys.index(slotName) except Exception: YLogger.debug(client_context, "nluslot non search keys:%s", slotName) if index is not None: YLogger.debug(client_context, "nluintent index[%s]", index) try: if itemName in slots[index]: resolved = str(slots[index].get(itemName)) except Exception: YLogger.debug(client_context, "nluslot non search item:%s", itemName) if resolved == '': YLogger.debug(client_context, "nluslot failed slot=[%s] item=[%s]", slotName, itemName) resolved = TemplateGetNode.get_default_value(client_context) YLogger.debug(client_context, "nluslot [%s] resolved to [%s:%s]", slotName, itemName, resolved) return resolved
def __init__(self, argument_parser=None): FlaskRestBotClient.__init__(self, 'google', argument_parser) YLogger.debug(self, "Google Client is running....") print("Google Client loaded")
def _brain_pre_process_question(self, client_context, text): pre_processed = client_context.brain.pre_process_question(client_context, text) YLogger.debug(client_context, "Pre Processed (%s): %s", client_context.userid, pre_processed) return pre_processed
def load_email(self): if self._configuration.client_configuration.email is not None: YLogger.debug(None, "Loading Email Manager") self._email = EmailSender( self._configuration.client_configuration.email)
def execute_oob_command(self, client_context): YLogger.debug(client_context, "CameraOutOfBandProcessor: Setting camera to=%s", self._command) return "CAMERA"
def aiml_response(self, response): payload = response['response']['payload'] result = payload['AbstractText'] YLogger.debug(self, result) return result
def load_initial_variables(self, variables_collection): for pair in variables_collection.pairs: YLogger.debug(self, "Setting variable [%s] = [%s]", pair[0], pair[1]) self._properties[pair[0]] = pair[1]
def resolve_to_string(self, client_context): resolved = str(client_context.brain.aiml_parser.num_categories) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def process(self, context, word_string): YLogger.debug(context, "Stemming sentence...") unstemmed_words = context.brain.tokenizer.texts_to_words(word_string) stemmed_words = [Stemmer.stem(x) for x in unstemmed_words] return context.brain.tokenizer.words_to_texts(stemmed_words)
def handle_text_message(self, client_context, message_text): YLogger.debug(client_context, "Facebook sent message: [%s]", message_text) return self.ask_question(client_context, message_text)
def consume(self, client_context, context, words, word_no, match_type, depth): tabs = self.get_tabs(client_context, depth) #TODO uncomment this section # if context.search_time_exceeded() is True: # YLogger.error(client_context, "%sMax search time [%d]secs exceeded", tabs, context.max_search_timeout) # return None if context.search_depth_exceeded(depth) is True: YLogger.error(client_context, "%sMax search depth [%d] exceeded", tabs, context.max_search_depth) return None context_match = Match(match_type, self, None) context.add_match(context_match) matches_added = 1 match = self.check_child_is_wildcard(tabs, client_context, context, words, word_no, match_type, depth) if match is not None: return match word = words.word(word_no) if self._children: for child in self._children: result = child.equals(client_context, words, word_no) if result.matched is True: word_no = result.word_no YLogger.debug(client_context, "%sWildcard child matched %s", tabs, result.matched_phrase) context_match2 = Match(Match.WORD, child, result.matched_phrase) context.add_match(context_match2) matches_added += 1 match = child.consume(client_context, context, words, word_no + 1, match_type, depth + 1) if match is not None: return match if self.invalid_topic_or_that(tabs, client_context, word, context, matches_added) is True: return None YLogger.debug(client_context, "%sWildcard %s matched %s", tabs, self._wildcard, word) context_match.add_word(word) match = super(PatternZeroOrMoreWildCardNode, self).consume(client_context, context, words, word_no + 1, match_type, depth + 1) if match is not None: return match word_no += 1 word = words.word(word_no) if self.invalid_topic_or_that(tabs, client_context, word, context, matches_added) is True: return None YLogger.debug(client_context, "%sWildcard %s matched %s", tabs, self._wildcard, word) context_match.add_word(word) match = super(PatternZeroOrMoreWildCardNode, self).consume(client_context, context, words, word_no + 1, match_type, depth + 1) if match is not None: return match word_no += 1 if word_no >= words.num_words(): context.pop_matches(matches_added) return None word = words.word(word_no) YLogger.debug(client_context, "%sNo children, consume words until next break point", tabs) while word_no < words.num_words() - 1: match = super(PatternZeroOrMoreWildCardNode, self).consume(client_context, context, words, word_no, match_type, depth + 1) if match is not None: return match if self.invalid_topic_or_that(tabs, client_context, word, context, matches_added) is True: return None YLogger.debug(client_context, "%sWildcard %s matched %s", tabs, self._wildcard, word) context_match.add_word(word) word_no += 1 word = words.word(word_no) match = super(PatternZeroOrMoreWildCardNode, self).consume(client_context, context, words, word_no, match_type, depth + 1) if match is not None: return match context.pop_matches(matches_added) return None
def resolve_to_string(self, client_context): selection = randint(0, (len(self._children) - 1)) resolved = self._children[selection - 1].resolve(client_context) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def resolve_to_string(self, client_context): string = self.resolve_children_to_string(client_context) resolved = client_context.brain.denormals.denormalise_string(string) YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
def empty(self): YLogger.debug(self, "Defaulting root to PatternRootNode") self._empty_children(self._root_node) self._root_node = self._pattern_factory.get_root_node()
def execute_oob_command(self, client_context): YLogger.debug(client_context, "EmailOutOfBandProcessor: Emailing=%s", self._to) return "EMAIL"
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 __init__(self, argument_parser=None): FlaskRestBotClient.__init__(self, "line", argument_parser) self.create_line_bot() YLogger.debug(self, "Line Client is running....")
def _load_file_contents(self, parser, filename): YLogger.debug(self, "Loading file contents from [%s]", filename) try: parser.parse_from_file(filename, userid="*") except Exception as excep: YLogger.exception(self, "Failed to load cat [%s]", excep, filename)
def load_scheduler(self): if self.configuration.client_configuration.scheduler is not None: YLogger.debug(None, "Loading Scheduler") self._scheduler = ProgramyScheduler( self, self.configuration.client_configuration.scheduler) self._scheduler.start()
def receive_data(self): json_data = self._clientsocket.recv(self._max_buffer).decode() YLogger.debug(self, "Received: %s", json_data) return json.loads(json_data, encoding="utf-8")
def load_trigger_manager(self): if self._configuration.client_configuration.triggers is not None: YLogger.debug(None, "Loading Trigger Manager") self._trigger_mgr = TriggerManager.load_trigger_manager( self._configuration.client_configuration.triggers)
def add_document(self, document): YLogger.debug(self, "Adding document to collection [%s]", self.collection_name()) collection = self.collection() document.id = self._add_to_collection(collection, document) return bool(document.id is not None)
def resolve(self, client_context): YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), client_context.client.id) if client_context.client.id is not None: return client_context.client.id return ""
def empty_named(self, name): YLogger.debug(self, "Empting set [%s]", name) collection = self.collection() collection.remove({MongoSetsStore.NAME: name})
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) return ""
def log_answer(self, client_context, text, answer, responselogger): YLogger.debug(client_context, "Processed Response (%s): %s", client_context.userid, answer) if responselogger is not None: responselogger.log_response(text, answer)
def process(self, context, word_string): YLogger.debug(context, "Removing punctuation...") return TextUtils.strip_none_terminating_punctuation(word_string)
def handle_split(self, client_context, split): YLogger.debug(client_context, "Handling split...")
def dump_request(self, request): YLogger.debug(self, str(request))
def consume(self, client_context, context, words, word_no, match_type, depth): tabs = self.get_tabs(client_context, depth) if context.search_time_exceeded() is True: if context.is_error is False: context.is_error = True raise LimitOverException("%sMax search time [%d]secs exceeded" % (tabs, context.max_search_timeout)) return None if context.search_depth_exceeded(depth) is True: if context.is_error is False: context.is_error = True raise LimitOverException("%sMax search depth [%d] exceeded" % (tabs, context.max_search_depth)) return None if word_no >= words.num_words(): if self._0ormore_hash is not None: child_template = self._0ormore_hash.template elif self._0ormore_arrow is not None: child_template = self._0ormore_arrow.template else: child_template = self._template if child_template is not None: YLogger.debug(client_context, "%sFound a template, success!", tabs) return child_template else: YLogger.debug(client_context, "%sNo more words and no template, no match found!", tabs) return None if self._topic is not None: match = self._topic.consume(client_context, context, words, word_no, Match.TOPIC, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched topic, success!", tabs) return match if words.word(word_no) == PatternNode.TOPIC: YLogger.debug(client_context, "%s Looking for a %s, none give, no match found!", tabs, PatternNode.TOPIC) return None if self._that is not None: match = self._that.consume(client_context, context, words, word_no, Match.THAT, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched that, success!", tabs) return match if words.word(word_no) == PatternNode.THAT: YLogger.debug(client_context, "%s Looking for a %s, none give, no match found!", tabs, PatternNode.THAT) return None match, word_no = self.match_children(client_context, self._priority_words, "Priority", words, word_no, context, match_type, depth) if match is not None: return match if self._0ormore_hash is not None: match = self._0ormore_hash.consume(client_context, context, words, word_no, match_type, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched 0 or more hash, success!", tabs) return match if self._1ormore_underline is not None: match = self._1ormore_underline.consume(client_context, context, words, word_no, match_type, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched 1 or more underline, success!", tabs) return match match, word_no = self.match_children(client_context, self._children, "Word", words, word_no, context, match_type, depth) if match is not None: return match if self._0ormore_arrow is not None: match = self._0ormore_arrow.consume(client_context, context, words, word_no, match_type, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched 0 or more arrow, success!", tabs) return match if self._1ormore_star is not None: match = self._1ormore_star.consume(client_context, context, words, word_no, match_type, depth+1) if match is not None: YLogger.debug(client_context, "%sMatched 1 or more star, success!", tabs) return match YLogger.debug(client_context, "%sNo match for %s, trying another path", tabs, words.word(word_no)) return None