瀏覽代碼

dynamic neuron loading from given path in settings

nico 8 年之前
父節點
當前提交
7074d2e23d

+ 14 - 11
Tests/test_launchers.py

@@ -1,6 +1,7 @@
 import unittest
 import mock
 
+from kalliope.core.Models.Resources import Resources
 from kalliope.core.NeuronLauncher import NeuronLauncher
 from kalliope.core.SynapseLauncher import SynapseLauncher, SynapseNameNotFound
 from kalliope.core.TriggerLauncher import TriggerLauncher
@@ -33,7 +34,7 @@ class TestLaunchers(unittest.TestCase):
                                         callback=None)
 
             mock_get_class_instantiation.assert_called_once_with(package_name="trigger",
-                                                                 module_name=trigger.name.capitalize(),
+                                                                 module_name=trigger.name,
                                                                  parameters=trigger.parameters)
             mock_get_class_instantiation.reset_mock()
 
@@ -70,11 +71,11 @@ class TestLaunchers(unittest.TestCase):
             SynapseLauncher.start_synapse("Synapse1", brain=br)
 
             calls = [mock.call(package_name="neurons",
-                               module_name=neuron1.name.capitalize(),
+                               module_name=neuron1.name,
                                parameters=neuron1.parameters,
                                resources_dir='/var/tmp/test/resources'),
                      mock.call(package_name="neurons",
-                               module_name=neuron2.name.capitalize(),
+                               module_name=neuron2.name,
                                parameters=neuron2.parameters,
                                resources_dir='/var/tmp/test/resources')]
             mock_get_class_instantiation.assert_has_calls(calls=calls)
@@ -94,18 +95,19 @@ class TestLaunchers(unittest.TestCase):
         synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
         synapse_empty = Synapse(name="Synapse_empty", neurons=[], signals=[signal1])
         sl = SettingLoader()
-        sl.settings.resource_dir = '/var/tmp/test/resources'
+        resources = Resources(neuron_folder='/var/tmp/test/resources')
+        sl.settings.resources = resources
         with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
             SynapseLauncher._run_synapse(synapse=synapse1)
 
             calls = [mock.call(package_name="neurons",
-                               module_name=neuron1.name.capitalize(),
+                               module_name=neuron1.name,
                                parameters=neuron1.parameters,
-                               resources_dir='/var/tmp/test/resources'),
+                               resources_dir="/var/tmp/test/resources"),
                      mock.call(package_name="neurons",
-                               module_name=neuron2.name.capitalize(),
+                               module_name=neuron2.name,
                                parameters=neuron2.parameters,
-                               resources_dir='/var/tmp/test/resources')]
+                               resources_dir="/var/tmp/test/resources")]
             mock_get_class_instantiation.assert_has_calls(calls=calls)
             mock_get_class_instantiation.reset_mock()
 
@@ -122,13 +124,14 @@ class TestLaunchers(unittest.TestCase):
         """
         neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
         sl = SettingLoader()
-        sl.settings.resource_dir = '/var/tmp/test/resources'
+        resources = Resources(neuron_folder='/var/tmp/test/resources')
+        sl.settings.resources = resources
         with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
             NeuronLauncher.start_neuron(neuron=neuron)
 
             mock_get_class_instantiation.assert_called_once_with(package_name="neurons",
-                                                                 module_name=neuron.name.capitalize(),
+                                                                 module_name=neuron.name,
                                                                  parameters=neuron.parameters,
-                                                                 resources_dir='/var/tmp/test/resources')
+                                                                 resources_dir=sl.settings.resources.neuron_folder)
             mock_get_class_instantiation.reset_mock()
 

+ 6 - 4
kalliope/core/ConfigurationManager/ConfigurationChecker.py

@@ -143,22 +143,24 @@ class ConfigurationChecker:
             """
             sl = SettingLoader()
             settings = sl.settings
-            neuron_resource_path = settings.resource_dir + '/' + "neurons" + '/' + neuron_module_name.lower()+"/" + neuron_module_name.lower()+".py"
+            neuron_resource_path = settings.resources.neuron_folder + \
+                                   os.sep + neuron_module_name.lower() + os.sep + \
+                                   neuron_module_name.lower()+".py"
             if os.path.exists(neuron_resource_path):
                 imp.load_source(neuron_module_name.capitalize(), neuron_resource_path)
                 package_name = neuron_module_name.capitalize()
             else:
-                package_name = "kalliope.neurons"+ "." + neuron_module_name.lower() + "." + neuron_module_name.lower()
+                package_name = "kalliope.neurons" + "." + neuron_module_name.lower() + "." + neuron_module_name.lower()
 
             try:
                 mod = __import__(package_name, fromlist=[neuron_module_name.capitalize()])
                 getattr(mod, neuron_module_name.capitalize())
             except AttributeError:
                 raise ModuleNotFoundError("[AttributeError] The module %s does not exist in the package %s " % (neuron_module_name.capitalize(),
-                                                                         package_name))
+                                                                                                                package_name))
             except ImportError:
                 raise ModuleNotFoundError("[ImportError] The module %s does not exist in the package %s " % (neuron_module_name.capitalize(),
-                                                                                               package_name))
+                                                                                                             package_name))
             return True
 
         if isinstance(neuron_dict, dict):

+ 39 - 8
kalliope/core/ConfigurationManager/SettingLoader.py

@@ -1,6 +1,8 @@
 import logging
+import os
 
 from YAMLLoader import YAMLLoader
+from kalliope.core.Models.Resources import Resources
 from kalliope.core.Utils.Utils import Utils
 from kalliope.core.Models import Singleton
 from kalliope.core.Models.RestAPI import RestAPI
@@ -106,7 +108,7 @@ class SettingLoader(object):
         rest_api = self._get_rest_api(settings)
         cache_path = self._get_cache_path(settings)
         default_synapse = self._get_default_synapse(settings)
-        resource_dir = self._get_resource_dir(settings)
+        resources = self._get_resources(settings)
 
         # Load the setting singleton with the parameters
         setting_object.default_tts_name = default_tts_name
@@ -120,7 +122,7 @@ class SettingLoader(object):
         setting_object.rest_api = rest_api
         setting_object.cache_path = cache_path
         setting_object.default_synapse = default_synapse
-        setting_object.resource_dir = resource_dir
+        setting_object.resources = resources
 
         return setting_object
 
@@ -510,14 +512,14 @@ class SettingLoader(object):
         return default_synapse
 
     @staticmethod
-    def _get_resource_dir(settings):
+    def _get_resources(settings):
         """
-        Return the name of the resource directory
+        Return a resources object that contains path of third party modules
 
         :param settings: The YAML settings file
         :type settings: dict
-        :return: the resource directory
-        :rtype: String
+        :return: the resource object
+        :rtype: Resources
 
         :Example:
 
@@ -530,9 +532,38 @@ class SettingLoader(object):
         try:
             resource_dir = settings["resource_directory"]
             logger.debug("Resource directory synapse: %s" % resource_dir)
+
+            neuron_folder = None
+            stt_folder = None
+            tts_folder = None
+            trigger_folder = None
+            if "neuron" in resource_dir:
+                neuron_folder = resource_dir["neuron"]
+                if not os.path.exists(neuron_folder):
+                    raise SettingInvalidException("The path %s does not exist on the system" % neuron_folder)
+
+            if "stt" in resource_dir:
+                stt_folder = resource_dir["stt"]
+                if not os.path.exists(stt_folder):
+                    raise SettingInvalidException("The path %s does not exist on the system" % stt_folder)
+
+            if "tts" in resource_dir:
+                tts_folder = resource_dir["tts"]
+                if not os.path.exists(tts_folder):
+                    raise SettingInvalidException("The path %s does not exist on the system" % tts_folder)
+
+            if "trigger" in resource_dir:
+                trigger_folder = resource_dir["trigger"]
+                if not os.path.exists(trigger_folder):
+                    raise SettingInvalidException("The path %s does not exist on the system" % trigger_folder)
+
+            resource_object = Resources(neuron_folder=neuron_folder,
+                                        stt_folder=stt_folder,
+                                        tts_folder=tts_folder,
+                                        trigger_folder=trigger_folder)
         except KeyError:
-            resource_dir = None
+            resource_object = None
 
-        return resource_dir
+        return resource_object
 
 

+ 41 - 0
kalliope/core/Models/Resources.py

@@ -0,0 +1,41 @@
+
+
+class Resources(object):
+    """
+
+    """
+    def __init__(self, neuron_folder=None, stt_folder=None, tts_folder=None, trigger_folder=None):
+        self.neuron_folder = neuron_folder
+        self.stt_folder = stt_folder
+        self.tts_folder = tts_folder
+        self.trigger_folder = trigger_folder
+
+    def __str__(self):
+        return "%s: neuron_folder: %s, stt_folder: %s, tts_folder: %s, trigger_folder: %s" % (self.__class__.__name__,
+                                                                                              self.neuron_folder,
+                                                                                              self.stt_folder,
+                                                                                              self.tts_folder,
+                                                                                              self.trigger_folder)
+
+    def serialize(self):
+        """
+        This method allows to serialize in a proper way this object
+
+        :return: A dict of order
+        :rtype: Dict
+        """
+
+        return {
+            'neuron_folder': self.neuron_folder,
+            'stt_folder': self.stt_folder,
+            'tts_folder': self.tts_folder,
+            'trigger_folder': self.trigger_folder
+        }
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 2 - 2
kalliope/core/Models/Settings.py

@@ -19,7 +19,7 @@ class Settings(object):
                  rest_api=None,
                  cache_path=None,
                  default_synapse=None,
-                 resource_dir=None,
+                 resources=None,
                  machine=None):
 
         self.default_tts_name = default_tts_name
@@ -33,7 +33,7 @@ class Settings(object):
         self.rest_api = rest_api
         self.cache_path = cache_path
         self.default_synapse = default_synapse
-        self.resource_dir = resource_dir
+        self.resources = resources
         self.machine = platform.machine()   # can be x86_64 or armv7l
 
     def __eq__(self, other):

+ 2 - 2
kalliope/core/NeuronLauncher.py

@@ -24,6 +24,6 @@ class NeuronLauncher:
         sl = SettingLoader()
         settings = sl.settings
         return Utils.get_dynamic_class_instantiation(package_name="neurons",
-                                                     module_name=neuron.name.capitalize(),
+                                                     module_name=neuron.name,
                                                      parameters=neuron.parameters,
-                                                     resources_dir= settings.resource_dir)
+                                                     resources_dir=settings.resources.neuron_folder)

+ 1 - 1
kalliope/core/NeuronModule.py

@@ -130,7 +130,7 @@ class NeuronModule(object):
 
             # get the instance of the TTS module
             tts_module_instance = Utils.get_dynamic_class_instantiation(package_name="tts",
-                                                                        module_name=tts_object.name.capitalize(),
+                                                                        module_name=tts_object.name,
                                                                         parameters=tts_object.parameters)
             # generate the audio file and play it
             tts_module_instance.say(tts_message)

+ 1 - 1
kalliope/core/OrderAnalyser.py

@@ -93,7 +93,7 @@ class OrderAnalyser:
         for signal in synapse.signals:
             if cls._is_containing_bracket(signal.sentence):
                 params = cls._associate_order_params_to_values(order_to_check, signal.sentence)
-                logger.debug("Parameters for order: %s" % params)
+                logger.debug("[OrderAnalyser]: Parameters for order: %s" % params)
         return params
 
     @classmethod

+ 1 - 1
kalliope/core/TTS/TTSLauncher.py

@@ -23,5 +23,5 @@ class TTSLauncher(object):
         """
         logger.debug("get TTS module \"%s\" with parameters %s" % (tts.name, tts.parameters))
         return Utils.get_dynamic_class_instantiation(package_name="tts",
-                                                     module_name=tts.name.capitalize(),
+                                                     module_name=tts.name,
                                                      parameters=tts.parameters)

+ 1 - 1
kalliope/core/TriggerLauncher.py

@@ -24,5 +24,5 @@ class TriggerLauncher(object):
         trigger.parameters["callback"] = callback
         logger.debug("TriggerLauncher: Start trigger %s with parameters: %s" % (trigger.name, trigger.parameters))
         return Utils.get_dynamic_class_instantiation(package_name="trigger",
-                                                     module_name=trigger.name.capitalize(),
+                                                     module_name=trigger.name,
                                                      parameters=trigger.parameters)

+ 5 - 4
kalliope/core/Utils/Utils.py

@@ -103,7 +103,8 @@ class Utils(object):
         logger.debug("Run plugin %s with parameter %s" % (module_name, parameters))
         package_path = "kalliope." + package_name + "." + module_name.lower() + "." + module_name.lower()
         if resources_dir is not None:
-            neuron_resource_path = resources_dir + '/' + package_name + '/' + module_name.lower() + "/" + module_name.lower() + ".py"
+            neuron_resource_path = resources_dir + os.sep + module_name.lower() \
+                                   + os.sep + module_name.lower() + ".py"
             if os.path.exists(neuron_resource_path):
                 imp.load_source(module_name.capitalize(), neuron_resource_path)
                 package_path = module_name.capitalize()
@@ -113,10 +114,10 @@ class Utils(object):
         mod = __import__(package_path, fromlist=[module_name.capitalize()])
 
         try:
-            klass = getattr(mod, module_name)
+            klass = getattr(mod, module_name.capitalize())
         except AttributeError:
-            logger.debug("Error: No module named %s " % module_name)
-            raise ModuleNotFoundError("The module %s does not exist in package %s" % (module_name, package_name))
+            logger.debug("Error: No module named %s " % module_name.capitalize())
+            raise ModuleNotFoundError("The module %s does not exist in package %s" % (module_name.capitalize(), package_name))
 
         if klass is not None:
             # run the plugin

+ 5 - 1
kalliope/settings.yml

@@ -117,4 +117,8 @@ default_synapse: "Default-synapse"
 # ---------------------------
 # resource directory path
 # ---------------------------
-resource_directory: "/var/tmp/resources"
+#resource_directory:
+#  neuron: "/home/me/kalliope_resources_dir/neurons"
+#  stt: "/home/me/kalliope_resources_dir/stt"
+#  tts: "/home/me/kalliope_resources_dir/tts"
+#  trigger: "/home/me/kalliope_resources_dir/trigger"