Initial support for plugins

As part of the effort for resolving #12, I've started work on a plugin
API for Kaylee.  While very much a work in progress, it will allow
Python plugins to be written, loaded from user configuration, and
hooked in to events from necessary portions of Kaylee to handle voice
commands.

Currently there is only one plugin, a partial implementation of shell
command support as existed previously.  It works in that it executes
commands, but several old features are missing.  Also, the GUIs are
probably broken, but I'm not worried about that at the moment.

kayleevc/kaylee.py

 # Copyright 2015-2016 Clayton G. Hobbs
 # Portions Copyright 2013 Jezra
 
+import importlib
 import sys
 import signal
 import os.path
-import subprocess
 from gi.repository import GObject, GLib
 
 from kayleevc.recognizer import Recognizer
 from kayleevc.util import *
 from kayleevc.numbers import NumberParser
+import kayleevc.plugins
 
 
 class Kaylee:
         # Load configuration
         self.config = Config()
         self.options = vars(self.config.options)
-        self.commands = self.options['commands']
+        self.commands = self.options['plugins']['.shell']
 
-        # Create number parser for later use
-        self.number_parser = NumberParser()
+        # Load plugins
+        self.plugins = []
+        for plugin in self.options['plugins'].keys():
+            pmod = importlib.import_module(plugin, 'kayleevc.plugins')
+            self.plugins.append(pmod.Plugin(self.config))
 
         # Create a hasher
         self.hasher = Hasher(self.config)
 
         # Create the recognizer
         self.recognizer = Recognizer(self.config)
-        self.recognizer.connect('finished', self.recognizer_finished)
+
+        # Connect the recognizer's finished signal to all the plugins
+        for plugin in self.plugins:
+            self.recognizer.connect('finished', plugin.recognizer_finished)
 
     def update_voice_commands_if_changed(self):
         """Use hashes to test if the voice commands have changed"""
 
         # Calculate the hash the voice commands have right now
         hasher = self.hasher.get_hash_object()
-        for voice_cmd in self.commands.keys():
-            hasher.update(voice_cmd.encode('utf-8'))
-            # Add a separator to avoid odd behavior
-            hasher.update('\n'.encode('utf-8'))
+        for plugin in self.plugins:
+            for string in sorted(plugin.corpus_strings):
+                hasher.update(string.encode('utf-8'))
+                # Add a separator to avoid odd behavior
+                hasher.update('\n'.encode('utf-8'))
         new_hash = hasher.hexdigest()
 
         if new_hash != stored_hash:
         # Open the strings file
         with open(self.config.strings_file, 'w') as strings:
             # Add command words to the corpus
-            for voice_cmd in sorted(self.commands.keys()):
-                strings.write(voice_cmd.strip().replace('%d', '') + "\n")
+            # FIXME: Doing this twice is a silly thing
+            for plugin in self.plugins:
+                for string in sorted(plugin.corpus_strings):
+                    strings.write(string + "\n")
             # Add number words to the corpus
-            for word in self.number_parser.number_words:
-                strings.write(word + " ")
+            if NumberParser.number_words is not None:
+                for word in NumberParser.number_words:
+                    strings.write(word + " ")
             strings.write("\n")
 
     def log_history(self, text):
                 for line in self.history:
                     hfile.write(line + '\n')
 
-    def run_command(self, cmd):
-        """Print the command, then run it"""
-        print(cmd)
-        subprocess.call(cmd, shell=True)
-
     def recognizer_finished(self, recognizer, text):
-        t = text.lower()
-        numt, nums = self.number_parser.parse_all_numbers(t)
-        # Is there a matching command?
-        if t in self.commands:
-            # Run the valid_sentence_command if it's set
-            if self.options['valid_sentence_command']:
-                subprocess.call(self.options['valid_sentence_command'],
-                                shell=True)
-            cmd = self.commands[t]
-            # Should we be passing words?
-            if self.options['pass_words']:
-                cmd += " " + t
-            self.run_command(cmd)
-            self.log_history(text)
-        elif numt in self.commands:
-            # Run the valid_sentence_command if it's set
-            if self.options['valid_sentence_command']:
-                subprocess.call(self.options['valid_sentence_command'],
-                                shell=True)
-            cmd = self.commands[numt]
-            cmd = cmd.format(*nums)
-            # Should we be passing words?
-            if self.options['pass_words']:
-                cmd += " " + t
-            self.run_command(cmd)
-            self.log_history(text)
-        else:
-            # 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(t))
-        # If there is a UI and we are not continuous listen
-        if self.ui:
-            if not self.continuous_listen:
-                # Stop listening
-                self.recognizer.pause()
-            # Let the UI know that there is a finish
-            self.ui.finished(t)
+        pass
 
     def run(self):
         if self.ui:

kayleevc/numbers.py

         'and'
     ]
 
+    number_words = None
+    mandatory_number_words = None
+
     def __init__(self):
-        self.number_words = []
-        for word in sorted(self.zero.keys()):
-            self.number_words.append(word)
-        for word in sorted(self.ones.keys()):
-            self.number_words.append(word)
-        for word in sorted(self.special_ones.keys()):
-            self.number_words.append(word)
-        for word in sorted(self.tens.keys()):
-            self.number_words.append(word)
-        for word in sorted(self.hundred.keys()):
-            self.number_words.append(word)
-        for word in sorted(self.exp.keys()):
-            self.number_words.append(word)
-        self.mandatory_number_words = self.number_words.copy()
-        for word in sorted(self.allowed):
-            self.number_words.append(word)
+        if NumberParser.number_words is None:
+            NumberParser.number_words = []
+            for word in sorted(self.zero.keys()):
+                NumberParser.number_words.append(word)
+            for word in sorted(self.ones.keys()):
+                NumberParser.number_words.append(word)
+            for word in sorted(self.special_ones.keys()):
+                NumberParser.number_words.append(word)
+            for word in sorted(self.tens.keys()):
+                NumberParser.number_words.append(word)
+            for word in sorted(self.hundred.keys()):
+                NumberParser.number_words.append(word)
+            for word in sorted(self.exp.keys()):
+                NumberParser.number_words.append(word)
+            NumberParser.mandatory_number_words = self.number_words.copy()
+            for word in sorted(self.allowed):
+                NumberParser.number_words.append(word)
 
     def parse_number(self, text_line):
         """Parse a number from English into an int"""

kayleevc/plugins/pluginbase.py

+# This is part of Kaylee
+# -- this code is licensed GPLv3
+# Copyright 2015-2016 Clayton G. Hobbs
+# Portions Copyright 2013 Jezra
+
+from abc import ABCMeta, abstractmethod
+
+
+class PluginBase(metaclass=ABCMeta):
+    """Base class for Kaylee plugins
+
+    Each Kaylee plugin module must define a subclass of this class, named
+    ``Plugin``.  These obviously must provide concrete implementations of all
+    abstract methods defined here.
+    """
+
+    def __init__(self, config):
+        """Initialize the plugin
+
+        All strings to be included in the corpus should be elements of
+        ``corpus_strings`` by the end of __init__'s execution.  Note however
+        that the words required for number support are automatically included,
+        so they need not be listed explicitly on a per-plugin basis.
+        """
+        self.config = config
+        self.corpus_strings = set()
+
+    @abstractmethod
+    def recognizer_finished(self, recognizer, text):
+        """Process a recognized voice command
+
+        This method must return True if the command was handled by the plugin,
+        and False otherwise.
+        """
+        pass

kayleevc/plugins/shell.py

+# This is part of Kaylee
+# -- this code is licensed GPLv3
+# Copyright 2015-2016 Clayton G. Hobbs
+# Portions Copyright 2013 Jezra
+
+import subprocess
+
+from .pluginbase import PluginBase
+from ..numbers import NumberParser
+
+
+class Plugin(PluginBase):
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.options = vars(self.config.options)
+        self.number_parser = NumberParser()
+        self.commands = self.options['plugins']['.shell']
+
+        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 recognizer_finished(self, recognizer, text):
+        """Process a recognized voice command
+
+        Recognized commands have the corresponding shell commands executed,
+        possibly with number(s) substituted.
+        """
+        numt, nums = self.number_parser.parse_all_numbers(text)
+        # Is there a matching command?
+        if text in self.commands:
+            # Run the valid_sentence_command if it's set
+            # TODO: determine how to support this with plugins
+            if self.options['valid_sentence_command']:
+                subprocess.call(self.options['valid_sentence_command'],
+                                shell=True)
+            cmd = self.commands[text]
+            # Should we be passing words?
+            # TODO: configuration changes to make this not ridiculous
+            if self.options['pass_words']:
+                cmd += " " + text
+            self._run_command(cmd)
+            # TODO: Logging can be handled along with valid_sentence_command
+            #self.log_history(text)
+            return True
+        elif numt in self.commands:
+            # Run the valid_sentence_command if it's set
+            if self.options['valid_sentence_command']:
+                subprocess.call(self.options['valid_sentence_command'],
+                                shell=True)
+            cmd = self.commands[numt]
+            cmd = cmd.format(*nums)
+            # Should we be passing words?
+            if self.options['pass_words']:
+                cmd += " " + text
+            self._run_command(cmd)
+            #self.log_history(text)
+            return True
+        else:
+            # TODO: This could be implemented as a plugin, implicitly loaded
+            # last
+            # 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))
+            return False
+        # TODO: Make the D-Bus interface so this can leave the main process
+        ## If there is a UI and we are not continuous listen
+        #if self.ui:
+        #    if not self.continuous_listen:
+        #        # Stop listening
+        #        self.recognizer.pause()
+        #    # Let the UI know that there is a finish
+        #    self.ui.finished(text)

kayleevc/recognizer.py

 
 class Recognizer(GObject.GObject):
     __gsignals__ = {
-        'finished' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-                      (GObject.TYPE_STRING,))
+        'finished' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN,
+                      (GObject.TYPE_STRING,),
+                      GObject.signal_accumulator_true_handled)
     }
 
     def __init__(self, config):
         # If we have a final command, send it for processing
         command = msg_struct.get_string('hypothesis')
         if command != '' and msg_struct.get_boolean('final')[1]:
-            self.emit("finished", command)
+            self.emit("finished", command.lower())

options.json.tmp

 {
-    "commands": {
-        "hello world": "echo \"hello world\"",
-        "start a %d minute timer": "(echo {0} minute timer started && sleep {0}m && echo {0} minute timer ended) &"
+    "plugins": {
+        ".shell": {
+            "hello world": "echo \"hello world\"",
+            "start a %d minute timer": "(echo {0} minute timer started && sleep {0}m && echo {0} minute timer ended) &"
+        }
     },
     "continuous": false,
     "history": null,