Port Kaylee and shell plugin to new plugin API

The new shell plugin is a lot cleaner, only determining how the command
matches once and parsing numbers zero or one times.

Kaylee uses the new API, but there are still some problems.  Most
notably, Handler objects have no sorting methods yet, so behavior will
be unpredictable when multiple plugins are loaded.

kayleevc/kaylee.py

         for plugin in self.config.plugins.keys():
             pmod = importlib.import_module(plugin, 'kayleevc.plugins')
             pobj = pmod.Plugin(self.config, plugin)
-            pobj.connect('tts', self.plugin_tts)
             self.plugins.append(pobj)
 
         # Create a hasher
     def recognizer_finished(self, recognizer, text):
         confidence_heap = queue.PriorityQueue()
         min_confidence = self.options['minimum_confidence']
-        # Add plugins to the heap
+        # Add handlers 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)
-            # If the plugin meets minimum confidence
-            if ((min_confidence is not None and confidence >= min_confidence)
-                or (min_confidence is None and 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))
+            # Get a handler
+            handler = plugin.get_handler(text)
+            # If the handler meets minimum confidence
+            if ((handler is not None)
+                and ((min_confidence is None)
+                     or (min_confidence is not None
+                         and handler.confidence >= min_confidence))):
+                # Add a triple to the heap, so handlers are sorted first by
+                # their confidence, then by index to break ties
+                confidence_heap.put_nowait((handler, index, plugin))
 
         # Run valid or invalid sentence command
         if confidence_heap.empty():
         else:
             self._valid_cmd()
 
-        # Give the command to the plugins that want it
+        # Give the command to the handlers 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):
+                # Get information about the handler
+                info = confidence_heap.get_nowait()
+                handler = info[0]
+                plugin = info[2]
+                # Handle the command
+                handler(self.plugin_tts)
                 self._log_history(plugin, text)
+            except queue.Empty:
                 break
+                # If an unknown error occurs, ignore it and keep trying
+                # FIXME not a good API decision
 
         self._stop_ui(text)
 
-    def plugin_tts(self, plugin, text):
+    def plugin_tts(self, text):
         # Stop listening
         self.recognizer.pause()
         # Speak

kayleevc/plugins/shell.py

 
 import subprocess
 
-from .pluginbase import PluginBase
+from . import PluginBase, Handler
 from ..numbers import NumberParser
 
 
         for voice_cmd in self.commands.keys():
             self.corpus_strings.add(voice_cmd.strip().replace('%d', ''))
 
-    def _run_command(self, cmd):
-        """Print the command, then run it"""
-        print(cmd)
-        subprocess.call(cmd, shell=True)
-
-    def confidence(self, text):
+    def get_handler(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
+            # If there's an exact match, return a handler for it
+            return ShellHandler(1, self.commands[text])
         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
-        commands are printed immediately before they are executed.
-        """
-        numt, nums = self.number_parser.parse_all_numbers(text)
-        # Is there a matching command?
-        if text in self.commands:
-            cmd = self.commands[text]
-            self._run_command(cmd)
-            return True
-        # Is there a matching command with numbers substituted?
-        elif numt in self.commands:
-            cmd = self.commands[numt]
-            cmd = cmd.format(*nums)
-            self._run_command(cmd)
-            return True
+            # Otherwise, try substituting numbers
+            numt, nums = self.number_parser.parse_all_numbers(text)
+            if numt in self.commands:
+                # Return a handler if we have a match
+                return ShellHandler(1, self.commands[numt], nums)
+            # Return None if that fails too
+            return None
+
+
+class ShellHandler(Handler):
+    """Handle a voice command that corresponds to a shell command"""
+
+    def __init__(self, confidence, command, nums=None):
+        """Determine the exact command that will be run"""
+        super().__init__(confidence)
+        if nums is None:
+            self.command = command
         else:
-            return False
+            self.command = command.format(*nums)
+
+    def __call__(self, tts):
+        """Print the command, then run it"""
+        print(self.command)
+        subprocess.call(self.command, shell=True)