Two stage command processing

As described in issue #16, commands are now processed in two stages.
First, all plugins get to give a confidence with which they are the
right plugin to handle the command.  Then, the one with the highest
confidence gets to run first, and if for some reason it can't handle the
command, other plugins try in turn.

kayleevc/kaylee.py

@@ -4,6 +4,7 @@
 # Portions Copyright 2013 Jezra
 
 import importlib
+import queue
 import sys
 import subprocess
 import signal
@@ -36,7 +37,9 @@ class Kaylee:
         self.plugins = []
         for plugin in self.config.plugins.keys():
             pmod = importlib.import_module(plugin, 'kayleevc.plugins')
-            self.plugins.append(pmod.Plugin(self.config, plugin))
+            pobj = pmod.Plugin(self.config, plugin)
+            pobj.connect('tts', self.plugin_tts)
+            self.plugins.append(pobj)
 
         # Create a hasher
         self.hasher = Hasher(self.config)
@@ -74,11 +77,7 @@ class Kaylee:
         # Create the recognizer
         self.recognizer = Recognizer(self.config)
 
-        # Connect the recognizer's finished signal to all the plugins
-        for plugin in self.plugins:
-            self.recognizer.connect('finished', plugin.recognizer_finished)
-            plugin.connect('processed', self.plugin_processed)
-            plugin.connect('tts', self.plugin_tts)
+        # Connect the recognizer's finished signal to the appropriate method
         self.recognizer.connect('finished', self.recognizer_finished)
 
     def update_voice_commands_if_changed(self):
@@ -113,17 +112,8 @@ class Kaylee:
                     strings.write(word + " ")
             strings.write("\n")
 
-    def plugin_processed(self, plugin, text):
-        """Callback for ``processed`` signal from plugins
-
-        Runs the valid_sentence_command and logs the recognized sentence to the
-        history file.
-        """
-        # Run the valid_sentence_command if it's set
-        if self.options['valid_sentence_command']:
-            subprocess.call(self.options['valid_sentence_command'], shell=True)
-
-        # Log the command to the history file
+    def _log_history(self, plugin, text):
+        """Log the recognized sentence to the history file"""
         if self.options['history']:
             self.history.append("{}: {}".format(plugin.name, text))
             if len(self.history) > self.options['history']:
@@ -136,13 +126,49 @@ class Kaylee:
                     hfile.write(line + '\n')
         self._stop_ui(text)
 
-    def recognizer_finished(self, recognizer, text):
-        # No loaded plugin wanted the text, so run the invalid_sentence_command
-        # if it's set
+    def _valid_cmd(self):
+        """Run the valid_sentence_command if it's set"""
+        if self.options['valid_sentence_command']:
+            subprocess.call(self.options['valid_sentence_command'], shell=True)
+
+    def _invalid_cmd(self, text):
+        """Run the invalid_sentence_command if it's set"""
         if self.options['invalid_sentence_command']:
             subprocess.call(self.options['invalid_sentence_command'],
                             shell=True)
         print("no matching command {0}".format(text))
+
+    def recognizer_finished(self, recognizer, text):
+        confidence_heap = queue.PriorityQueue()
+        # Add plugins to the heap
+        for index, plugin in enumerate(self.plugins):
+            # Get plugin confidence
+            confidence = plugin.confidence(text)
+            # Clamp confidence to [0, 1]
+            confidence = min(max(confidence, 0), 1)
+            # TODO: Only add items if they meet minimum confidence
+            if confidence > 0:
+                # Add a triple to the heap, so plugins are sorted first by
+                # confidence, then by index to break ties
+                confidence_heap.put_nowait((1 - confidence, index, plugin))
+
+        # Run valid or invalid sentence command
+        if confidence_heap.empty():
+            self._invalid_cmd(text)
+        else:
+            self._valid_cmd()
+
+        # Give the command to the plugins that want it
+        while True:
+            try:
+                plugin = confidence_heap.get_nowait()[2]
+            except queue.Empty:
+                break
+            # If the plugin successfully handled the command
+            if plugin.handle(text):
+                self._log_history(plugin, text)
+                break
+
         self._stop_ui(text)
 
     def plugin_tts(self, plugin, text):

kayleevc/plugins/darksky.py

@@ -137,11 +137,14 @@ class Plugin(PluginBase):
         with open(self._cache_filename, 'r') as f:
             return json.load(f)
 
-    def recognizer_finished(self, recognizer, text):
+    def confidence(self, text):
+        """Return whether or not the command can be handled"""
+        return 1 if text in self.corpus_strings else 0
+
+    def handle(self, text):
         """Speak reasonably up-to-date weather information"""
         # Is there a matching command?
-        if text in self.corpus_strings:
-            self.emit('processed', text)
+        if self.confidence(text):
             self._update_cache_if_stale()
             self.cache = self._read_cache()
             self.emit('tts', self.commands[text]())

kayleevc/plugins/mpris.py

@@ -57,7 +57,6 @@ class Plugin(PluginBase):
             # Get the proxy
             return self._bus.get(bus_name, '/org/mpris/MediaPlayer2')
         except IndexError:
-            print('No media player found')
             return None
 
     def _next(self):
@@ -80,11 +79,18 @@ class Plugin(PluginBase):
         if p is not None:
             p.Previous()
 
-    def recognizer_finished(self, recognizer, text):
+    def confidence(self, text):
+        """Return whether or not the command can be handled"""
+        if text not in self.corpus_strings:
+            return 0
+        if self._mpris_proxy() is None:
+            return 0
+        return 1
+
+    def handle(self, text):
         """Print and speak the phrase when it is heard"""
         # Is there a matching command?
-        if text in self.corpus_strings:
-            self.emit('processed', text)
+        if self.confidence(text):
             self.commands[text]()
             return True
         else:

kayleevc/plugins/pluginbase.py

@@ -14,8 +14,6 @@ class PluginBase(GObject.Object):
     """
 
     __gsignals__ = {
-        'processed' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-                      (GObject.TYPE_STRING,)),
         'tts' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                 (GObject.TYPE_STRING,))
     }
@@ -34,14 +32,26 @@ class PluginBase(GObject.Object):
         self.options = config.plugins[name]
         self.corpus_strings = set()
 
-    def recognizer_finished(self, recognizer, text):
+    def confidence(self, text):
+        """Return the confidence (0-1) with which this plugin can handle text
+
+        This method must return 1 if the command is definitely supposed to be
+        handled by this plugin (text is exactly a sentence configured to
+        perform some action) and must return 0 if the command is not recognized
+        at all.  The method must also return 0 if the command is recognized,
+        but for some reason would not perform any action currently, e.g. "pause
+        music" when no music player is running.  Intermediate values may be
+        used to indicate that text may be a command this plugin should handle,
+        but was misunderstood by the speech recognition system.
+        """
+        return 0
+
+    def handle(self, text):
         """Process a recognized voice command
 
         This method must return True if the command was handled by the plugin,
-        and False otherwise.  As soon as it has been determined that the
-        command will be handled, this method must emit a ``processed`` signal
-        with ``text`` as its parameter.  If the plugin wants to speak some
-        words to the user, it can do so by emitting a ``tts`` signal with the
-        words to be spoken as its parameter.
+        and False otherwise.  If the plugin wants to speak some words to the
+        user, it can do so by emitting a ``tts`` signal with the words to be
+        spoken as its parameter.
         """
         return False

kayleevc/plugins/shell.py

@@ -49,7 +49,17 @@ class Plugin(PluginBase):
         print(cmd)
         subprocess.call(cmd, shell=True)
 
-    def recognizer_finished(self, recognizer, text):
+    def confidence(self, text):
+        """Return whether or not the command can be handled"""
+        numt, nums = self.number_parser.parse_all_numbers(text)
+        if text in self.commands:
+            return 1
+        elif numt in self.commands:
+            return 1
+        else:
+            return 0
+
+    def handle(self, text):
         """Run the shell command corresponding to a recognized voice command
 
         Spoken number(s) may be substituted in the shell command.  The shell
@@ -58,13 +68,11 @@ class Plugin(PluginBase):
         numt, nums = self.number_parser.parse_all_numbers(text)
         # Is there a matching command?
         if text in self.commands:
-            self.emit('processed', text)
             cmd = self.commands[text]
             self._run_command(cmd)
             return True
         # Is there a matching command with numbers substituted?
         elif numt in self.commands:
-            self.emit('processed', text)
             cmd = self.commands[numt]
             cmd = cmd.format(*nums)
             self._run_command(cmd)

kayleevc/plugins/simple.py

@@ -23,11 +23,14 @@ class Plugin(PluginBase):
 
         self.corpus_strings.add(self.options['phrase'])
 
-    def recognizer_finished(self, recognizer, text):
-        """Print and speak the phrase when it is heard"""
+    def confidence(self, text):
+        """Return 0 if text is not the phrase, 1 if it is"""
+        return 1 if text == self.options['phrase'] else 0
+
+    def handle(self, text):
+        """Print and speak the phrase"""
         # Is there a matching command?
-        if text == self.options['phrase']:
-            self.emit('processed', text)
+        if self.confidence(text):
             print("Simple plugin says:", text)
             self.emit('tts', text)
             return True

kayleevc/recognizer.py

@@ -16,8 +16,7 @@ Gst.init(None)
 class Recognizer(GObject.GObject):
     __gsignals__ = {
         'finished' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN,
-                      (GObject.TYPE_STRING,),
-                      GObject.signal_accumulator_true_handled)
+                      (GObject.TYPE_STRING,))
     }
 
     def __init__(self, config):