Add conversational support to skill system

The most recently used skills now have an opportunity to preview all
utterances before they hit the intent system.

==== Tech Notes ====
Skills get a preview in the order of activation -- most recent first --
and if they can consume the utterance or ignore it. If consumed,
processing stops. If ignored, the next most recent skill gets a shot
at it. Finally, if no skill consumes it the intent system takes over,
running as it always has.

Skills remain "active" for 5 minutes after last use.

A skill achieves this by implementing the converse() method, e.g.

def def converse(self, utterances, lang="en-us"):
    if .... :
        return True  # handled, consume utterance
    else:
        return False  # not for this skill, pass it along

Author: JarbasAl

mycroft/skills/core.py

@@ -95,9 +95,10 @@ def open_intent_envelope(message):
                   intent_dict.get('optional'))
 
 
-def load_skill(skill_descriptor, emitter):
+def load_skill(skill_descriptor, emitter, skill_id):
     try:
-        logger.info("ATTEMPTING TO LOAD SKILL: " + skill_descriptor["name"])
+        logger.info("ATTEMPTING TO LOAD SKILL: " + skill_descriptor["name"] +
+                    " with ID " + str(skill_id))
         if skill_descriptor['name'] in BLACKLISTED_SKILLS:
             logger.info("SKILL IS BLACKLISTED " + skill_descriptor["name"])
             return None
@@ -108,6 +109,7 @@ def load_skill(skill_descriptor, emitter):
             # v2 skills framework
             skill = skill_module.create_skill()
             skill.bind(emitter)
+            skill.skill_id = skill_id
             skill._dir = dirname(skill_descriptor['info'][1])
             skill.load_data_files(dirname(skill_descriptor['info'][1]))
             # Set up intent handlers
@@ -172,12 +174,15 @@ def unload_skills(skills):
 
 def intent_handler(intent_parser):
     """ Decorator for adding a method as an intent handler. """
+
     def real_decorator(func):
         @wraps(func)
         def handler_method(*args, **kwargs):
             return func(*args, **kwargs)
+
         _intent_list.append((intent_parser, func))
         return handler_method
+
     return real_decorator
 
 
@@ -198,6 +203,7 @@ def __init__(self, name=None, emitter=None):
         self.log = getLogger(self.name)
         self.reload_skill = True
         self.events = []
+        self.skill_id = 0
 
     @property
     def location(self):
@@ -249,7 +255,7 @@ def __register_stop(self):
 
     def detach(self):
         for (name, intent) in self.registered_intents:
-            name = self.name + ':' + name
+            name = str(self.skill_id) + ':' + name
             self.emitter.emit(Message("detach_intent", {"intent_name": name}))
 
     def initialize(self):
@@ -260,6 +266,16 @@ def initialize(self):
         """
         logger.debug("No initialize function implemented")
 
+    def converse(self, utterances, lang="en-us"):
+        return False
+
+    def make_active(self):
+        # bump skill to active_skill list in intent_service
+        # this enables converse method to be called even without skill being
+        # used in last 5 minutes
+        self.emitter.emit(Message('active_skill_request',
+                                  {"skill_id": self.skill_id}))
+
     def _register_decorated(self):
         """
         Register all intent handlers that has been decorated with an intent.
@@ -287,7 +303,7 @@ def register_intent(self, intent_parser, handler, need_self=False):
             raise ValueError('intent_parser is not an Intent')
 
         name = intent_parser.name
-        intent_parser.name = self.name + ':' + intent_parser.name
+        intent_parser.name = str(self.skill_id) + ':' + intent_parser.name
         self.emitter.emit(Message("register_intent", intent_parser.__dict__))
         self.registered_intents.append((name, intent_parser))
 
@@ -314,7 +330,7 @@ def receive_handler(message):
     def disable_intent(self, intent_name):
         """Disable a registered intent"""
         logger.debug('Disabling intent ' + intent_name)
-        name = self.name + ':' + intent_name
+        name = str(self.skill_id) + ':' + intent_name
         self.emitter.emit(Message("detach_intent", {"intent_name": name}))
 
     def enable_intent(self, intent_name):
@@ -342,8 +358,8 @@ def set_context(self, context, word=''):
             raise ValueError('context should be a string')
         if not isinstance(word, basestring):
             raise ValueError('word should be a string')
-        self.emitter.emit(Message('add_context', {'context': context, 'word':
-                          word}))
+        self.emitter.emit(Message('add_context',
+                                  {'context': context, 'word': word}))
 
     def remove_context(self, context):
         """
@@ -430,7 +446,7 @@ def shutdown(self):
             self.emitter.remove(e, f)
 
         self.emitter.emit(
-            Message("detach_skill", {"skill_name": self.name + ":"}))
+            Message("detach_skill", {"skill_id": self.skill_id + ":"}))
         try:
             self.stop()
         except:

mycroft/skills/intent_service.py

@@ -26,6 +26,7 @@
 
 from adapt.context import ContextManagerFrame
 import time
+
 __author__ = 'seanfitz'
 
 logger = getLogger(__name__)
@@ -37,6 +38,7 @@ class ContextManager(object):
     Use to track context throughout the course of a conversational session.
     How to manage a session's lifecycle is not captured here.
     """
+
     def __init__(self, timeout):
         self.frame_stack = []
         self.timeout = timeout * 60  # minutes to seconds
@@ -91,7 +93,7 @@ def get_context(self, max_frames=None, missing_entities=[]):
                               relevant_frames[i].entities]
             for entity in frame_entities:
                 entity['confidence'] = entity.get('confidence', 1.0) \
-                    / (2.0 + i)
+                                       / (2.0 + i)
             context += frame_entities
 
         result = []
@@ -138,6 +140,44 @@ def __init__(self, emitter):
         self.emitter.on('add_context', self.handle_add_context)
         self.emitter.on('remove_context', self.handle_remove_context)
         self.emitter.on('clear_context', self.handle_clear_context)
+        # Converse method
+        self.emitter.on('skill.converse.response',
+                        self.handle_converse_response)
+        self.active_skills = []  # [skill_id , timestamp]
+        self.converse_timeout = 5  # minutes to prune active_skills
+
+    def do_converse(self, utterances, skill_id, lang):
+        self.emitter.emit(Message("skill.converse.request", {
+            "skill_id": skill_id, "utterances": utterances, "lang": lang}))
+        self.waiting = True
+        self.result = False
+        start_time = time.time()
+        t = 0
+        while self.waiting and t < 5:
+            t = time.time() - start_time
+            time.sleep(0.1)
+        self.waiting = False
+        return self.result
+
+    def handle_converse_response(self, message):
+        # id = message.data["skill_id"]
+        # no need to crosscheck id because waiting before new request is made
+        # no other skill will make this request is safe assumption
+        result = message.data["result"]
+        self.result = result
+        self.waiting = False
+
+    def remove_active_skill(self, skill_id):
+        for skill in self.active_skills:
+            if skill[0] == skill_id:
+                self.active_skills.remove(skill)
+
+    def add_active_skill(self, skill_id):
+        # search the list for an existing entry that already contains it
+        # and remove that reference
+        self.remove_active_skill(skill_id)
+        # add skill with timestamp to start of skill_list
+        self.active_skills.insert(0, [skill_id, time()])
 
     def update_context(self, intent):
         for tag in intent['__tags__']:
@@ -155,14 +195,28 @@ def handle_utterance(self, message):
 
         utterances = message.data.get('utterances', '')
 
+        # check for conversation time-out
+        self.active_skills = [skill for skill in self.active_skills
+                              if time.time() - skill[
+                                  1] <= self.converse_timeout * 60]
+
+        # check if any skill wants to handle utterance
+        for skill in self.active_skills:
+            if self.do_converse(utterances, skill[0], lang):
+                # update timestamp, or there will be a timeout where
+                # intent stops conversing whether its being used or not
+                self.add_active_skill(skill[0])
+                return
+
+        # no skill wants to handle utterance
         best_intent = None
         for utterance in utterances:
             try:
                 # normalize() changes "it's a boy" to "it is boy", etc.
                 best_intent = next(self.engine.determine_intent(
-                                   normalize(utterance, lang), 100,
-                                   include_tags=True,
-                                   context_manager=self.context_manager))
+                    normalize(utterance, lang), 100,
+                    include_tags=True,
+                    context_manager=self.context_manager))
                 # TODO - Should Adapt handle this?
                 best_intent['utterance'] = utterance
             except StopIteration, e:
@@ -174,6 +228,10 @@ def handle_utterance(self, message):
             reply = message.reply(
                 best_intent.get('intent_type'), best_intent)
             self.emitter.emit(reply)
+            # update active skills
+            skill_id = int(best_intent['intent_type'].split(":")[0])
+            self.add_active_skill(skill_id)
+
         else:
             self.emitter.emit(Message("intent_failure", {
                 "utterance": utterances[0],
@@ -202,10 +260,10 @@ def handle_detach_intent(self, message):
         self.engine.intent_parsers = new_parsers
 
     def handle_detach_skill(self, message):
-        skill_name = message.data.get('skill_name')
+        skill_id = message.data.get('skill_id')
         new_parsers = [
             p for p in self.engine.intent_parsers if
-            not p.name.startswith(skill_name)]
+            not p.name.startswith(skill_id)]
         self.engine.intent_parsers = new_parsers
 
     def handle_add_context(self, message):

mycroft/skills/main.py

@@ -47,6 +47,7 @@
 skills_directories = []
 skill_reload_thread = None
 skills_manager_timer = None
+id_counter = 0
 
 installer_config = ConfigurationManager.instance().get("SkillInstallerSkill")
 MSM_BIN = installer_config.get("path", join(MYCROFT_ROOT_PATH, 'msm', 'msm'))
@@ -81,7 +82,7 @@ def install_default_skills(speak=True):
             logger.error('msm failed with error {}: {}'.format(res, output))
             ws.emit(Message("speak", {
                 'utterance': mycroft.dialog.get(
-                             "sorry I couldn't install default skills")}))
+                    "sorry I couldn't install default skills")}))
 
     else:
         logger.error("Unable to invoke Mycroft Skill Manager: " + MSM_BIN)
@@ -177,7 +178,8 @@ def _watch_skills():
 
             for skill_folder in list:
                 if skill_folder not in loaded_skills:
-                    loaded_skills[skill_folder] = {}
+                    id_counter += 1
+                    loaded_skills[skill_folder] = {"id": id_counter}
                 skill = loaded_skills.get(skill_folder)
                 skill["path"] = os.path.join(SKILLS_DIR, skill_folder)
                 # checking if is a skill
@@ -202,7 +204,7 @@ def _watch_skills():
                     del skill["instance"]
                 skill["loaded"] = True
                 skill["instance"] = load_skill(
-                    create_skill_descriptor(skill["path"]), ws)
+                    create_skill_descriptor(skill["path"]), ws, skill["id"])
         # get the last modified skill
         modified_dates = map(lambda x: x.get("last_modified"),
                              loaded_skills.values())
@@ -218,6 +220,33 @@ def _starting_up():
     _load_skills()
 
 
+def handle_converse_request(message):
+    skill_id = int(message.data["skill_id"])
+    utterances = message.data["utterances"]
+    lang = message.data["lang"]
+    global ws, loaded_skills
+    # loop trough skills list and call converse for skill with skill_id
+    for skill in loaded_skills:
+        if loaded_skills[skill]["id"] == skill_id:
+            try:
+                instance = loaded_skills[skill]["instance"]
+            except:
+                logger.error("converse requested but skill not loaded")
+                ws.emit(Message("skill.converse.response", {
+                    "skill_id": 0, "result": False}))
+                return
+            try:
+                result = instance.converse(utterances, lang)
+                ws.emit(Message("skill.converse.response", {
+                    "skill_id": skill_id, "result": result}))
+                return
+            except:
+                logger.error(
+                    "Converse method malformed for skill " + str(skill_id))
+    ws.emit(Message("skill.converse.response", {
+        "skill_id": 0, "result": False}))
+
+
 def main():
     global ws
     lock = Lock('skills')  # prevent multiple instances of this service
@@ -245,7 +274,7 @@ def _echo(message):
         logger.debug(message)
 
     ws.on('message', _echo)
-
+    ws.on('skill.converse.request', handle_converse_request)
     # Startup will be called after websocket is full live
     ws.once('open', _starting_up)
     ws.run_forever()