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 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 _create_new_category(self, client_context, category, userid="*"): new_pattern = self.resolve_element_evals(client_context, category.pattern) new_topic = self.resolve_element_evals(client_context, category.topic) new_that = self.resolve_element_evals(client_context, category.that) new_template = self.evaluate_eval_nodes(client_context, category.template) client_context.brain.aiml_parser.pattern_parser.add_pattern_to_graph( new_pattern, new_topic, new_that, new_template, learn=True, userid=client_context.userid) YLogger.debug(client_context, "[%s] resolved to new pattern [[%s] [%s] [%s]", self.to_string(), ET.tostring(new_pattern, 'utf-8').decode('utf-8'), ET.tostring(new_topic, 'utf-8').decode('utf-8'), ET.tostring(new_that, 'utf-8').decode('utf-8')) return LearnCategory(new_pattern, new_topic, new_that, new_template)
def ask_question(self, client_context, question: str): try: words = question.split() question = " ".join(words[1:]) if words[0] == 'TEMPERATURE': observation = self._api.weather(question) search = self.get_temp_info(observation) search += ' degrees fahrenheit' YLogger.debug(client_context, f"weather report: {search}") elif words[0] == "STATUS": observation = self._api.weather(question) search = self.get_status_info(observation) # NOTE: This API call doesn't work with free API subscriptions # elif words[0] == 'FORECAST': # forecaster = self._api.todays_forecast(question) # search = self.get_forecast_info(observation) else: YLogger.error(client_context, "Unknown Open Weather Map command [%s]", words[0]) search = "" return search except Exception as ex: YLogger.error( client_context, "General error querying Open Weather Map for question [%s]", question) YLogger.error(client_context, f"Exception message: {ex}") return ""
def load_conversation(self, conversation, clientid, restore_last_topic=False): YLogger.debug(self, "Loading Conversation from file for %s" % clientid) h_key = "{prefix}:{clientid}:props".format(prefix=self._prefix, clientid=clientid) try: # Check if clientid in sessions set if not self._redis.is_member(self._sessions_set_key, clientid): return # Fetch properties props = self._redis.get(h_key) props = { k.decode('utf-8'): v.decode('utf-8') for k, v in props.items() } last_topic = props["topic"] # Update conversation conversation._properties.update(props) # Load last topic if required if restore_last_topic and last_topic: conversation._properties["topic"] = last_topic except Exception as e: YLogger.exception( self, "Failed to load conversation from redis for clientid [%s]" % clientid, e)
def send_error(self, error): if hasattr(error, 'message') is True: return_payload = { "result": { "status": "ERROR", "message": error.message } } elif hasattr(error, 'msg') is True: return_payload = { "result": { "status": "ERROR", "message": error.msg } } else: return_payload = { "result": { "status": "ERROR", "message": str(error) } } json_data = json.dumps(return_payload) YLogger.debug(self, "Sent: %s", json_data) self._clientsocket.send(json_data.encode('utf-8'))
def execute(self, client_context, data): YLogger.debug(client_context, "Scheduler - [%s]", data) # SCHEDULE IN|EVERY X SECONDS|MINUTES|HOURS|DAYS|WEEKS TEXT|SRAI ........... try: words = data.split() if words[0].upper() == 'SCHEDULE': action = words[1].upper() if action in ['IN', 'EVERY']: return self.execute_schedule(client_context, words) elif action == 'PAUSE': return self.execute_pause(client_context, words) elif action == 'RESUME': return self.execute_resume(client_context, words) elif action == 'STOP': return self.execute_stop(client_context, words) elif action == 'LIST': return self.execute_lists(client_context, words) else: raise Exception ("Scheduler invalid action %s"% action) else: raise Exception ("Scheduler invalid command, must start with SCHEDULE") except Exception as excep: YLogger.exception(client_context, "Failed to parse Scheduler command", excep) return 'ERR'
def resolve_to_string(self, client_context): YLogger.debug(client_context, "Removing all learn nodes created by [%s]", client_context.userid) root = client_context.brain.aiml_parser.pattern_parser.root root.remove_children_with_userid(client_context.userid) return ""
def resolve_to_string(self, client_context): conversation = client_context.bot.get_conversation(client_context) question = conversation.previous_nth_question(self.index) resolved = question.combine_answers() YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved) return resolved
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 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 resolve_to_string(self, client_context): name = self.name.resolve(client_context).upper() var = self.resolve_children(client_context).upper() if client_context.brain.dynamics.is_dynamic_map(name) is True: value = client_context.brain.dynamics.dynamic_map( client_context, name, var) else: if client_context.brain.maps.contains(name) is False: YLogger.error( client_context, "No map defined for [%s], using default-map as value", var) value = self.get_default_value(client_context) else: the_map = client_context.brain.maps.map(name) if var in the_map: value = the_map[var] else: YLogger.error( client_context, "No value defined for [%s], using default-map as value", var) value = self.get_default_value(client_context) YLogger.debug(client_context, "MAP [%s] resolved to [%s] = [%s]", self.to_string(), name, value) return value
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 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, "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 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 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 client_context.brain.dynamics.is_dynamic_set( self._set_name) is True: result = client_context.brain.dynamics.dynamic_set( client_context, self._set_name, word) return EqualsMatch(result, word_no, word) else: if self.set_is_known(client_context): match = self.words_in_set(client_context, words, word_no) if match.matched is True: YLogger.debug(client_context, "Found word [%s] in set [%s]", word, self.set_name) return match else: YLogger.error(client_context, "No word [%s] found in set [%s]", word, self.set_name) return EqualsMatch(False, word_no) else: YLogger.error(client_context, "No set named [%s] in sets collection", self.set_name) return EqualsMatch(False, word_no)
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.nlp.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.nlp.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 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) service_name = self.extract_servicename(receive_payload) client_context = self.create_client_context(userid) answer = self.ask_question_from_service(service_name, 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 _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_question(self, client_context, input_func=input): try: ask = "%s " % self.get_client_configuration().prompt return input_func(ask) except Exception as excep: YLogger.debug(client_context, "Exception caught in get_question !", excep)
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 _get_json_attribute(self, data, name, def_value=None): if name in data: return data[name] else: YLogger.debug(self, "Attribute [%s] missing from New API Article data", name) return def_value
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_to_string(self, client_context): set_words = client_context.brain.sets.count_words_in_sets() pattern_words = client_context.brain.aiml_parser.pattern_parser.count_words_in_patterns( ) resolved = "%d" % (set_words + pattern_words) 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 __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 execute(self, context, data): YLogger.debug(context, "Survey Storage - Storing data [%s]", data) # Data is bar delimited, so you could write to a file, add to a database, or send to another REST service for answer in data.split("|"): YLogger.debug(context, "Answer = %s", answer.strip()) return "OK"
def connect(self): YLogger.debug(self, "XMPPBotClient Connecting as %s to %s %s", self._username, self._server, self._port) self._xmpp_client = self.create_client(self._username, self._password) if self._xmpp_client is not None: self._xmpp_client.connect((self._server, self._port)) self._xmpp_client.register_xep_plugins(self.configuration.client_configuration) return True return False
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)