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)
