nico 8 жил өмнө
parent
commit
f025a44be3

+ 146 - 89
core/ConfigurationManager/SettingLoader.py

@@ -1,131 +1,188 @@
 from YAMLLoader import YAMLLoader
 import logging
 
+from core.Models.Settings import Settings
+from core.Models.Stt import Stt
+from core.Models.Trigger import Trigger
+from core.Models.Tts import Tts
+
 FILE_NAME = "settings.yml"
 
 logging.basicConfig()
 logger = logging.getLogger("jarvis")
 
 
-class DefaultSpeechToTextNotFound(Exception):
-    pass
-
-
-class DefaultSpeechNull(Exception):
+class NullSettingException(Exception):
     pass
 
 
-class NoSpeechToTextConfiguration(Exception):
+class SettingNotFound(Exception):
     pass
 
 
-class SettingLoader(YAMLLoader):
+class SettingLoader(object):
 
-    def __init__(self, filename=None):
-        self.fileName = filename
-        if filename is None:
-            self.fileName = FILE_NAME
-        self.filePath = "../../" + self.fileName
-        YAMLLoader.__init__(self, self.filePath)
+    def __init__(self):
+        pass
 
-    def get_config(self):
-        return YAMLLoader.get_config(self)
+    @classmethod
+    def get_yaml_config(cls, file_name=None):
+        if file_name is None:
+            file_name = FILE_NAME
+        file_path = "../../" + file_name
+        return YAMLLoader.get_config(file_path)
 
-    def get_default_speech_to_text(self):
-        settings = self.get_config()
+    @classmethod
+    def get_settings(cls, file_name=None):
+        """
+        Return a Settings object from settings.yml file
+        :return:
+        """
+        settings = cls.get_yaml_config(file_name)
+        default_stt_name = cls._get_default_speech_to_text(settings)
+        default_tts_name = cls._get_default_text_to_speech(settings)
+        default_trigger_name = cls._get_default_trigger(settings)
+        stts = cls._get_stts(settings)
+        ttss = cls._get_ttss(settings)
+        triggers = cls._get_triggers(settings)
+        random_wake_up_answers = cls._get_random_wake_up_answers(settings)
+        # create a setting object
+        setting_object = Settings(default_stt_name=default_stt_name,
+                                  default_tts_name=default_tts_name,
+                                  default_trigger_name=default_trigger_name,
+                                  stts=stts,
+                                  ttss=ttss,
+                                  triggers=triggers,
+                                  random_wake_up_answers=random_wake_up_answers)
+        return setting_object
+
+    @staticmethod
+    def _get_default_speech_to_text(settings):
 
         try:
             default_speech_to_text = settings["default_speech_to_text"]
             if default_speech_to_text is None:
-                raise DefaultSpeechNull("Attribute default_speech_to_text is null")
+                raise NullSettingException("Attribute default_speech_to_text is null")
             logger.debug("Default STT: %s" % default_speech_to_text)
             return default_speech_to_text
         except KeyError:
-            raise DefaultSpeechToTextNotFound("Attribute default_speech_to_text not found in settings")
-
-    def get_default_text_to_speech(self):
-        settings = self.get_config()
+            raise SettingNotFound("Attribute default_speech_to_text not found in settings")
 
+    @staticmethod
+    def _get_default_text_to_speech(settings):
         try:
             default_text_to_speech = settings["default_text_to_speech"]
             if default_text_to_speech is None:
-                raise DefaultSpeechNull("Attribute default_text_to_speech is null")
+                raise NullSettingException("Attribute default_text_to_speech is null")
             logger.debug("Default TTS: %s" % default_text_to_speech)
             return default_text_to_speech
         except KeyError:
-            raise DefaultSpeechToTextNotFound("Attribute default_text_to_speech not found in settings")
+            raise SettingNotFound("Attribute default_text_to_speech not found in settings")
+
+    @staticmethod
+    def _get_default_trigger(settings):
+        try:
+            default_trigger = settings["default_trigger"]
+            if default_trigger is None:
+                raise NullSettingException("Attribute default_trigger is null")
+            logger.debug("Default Trigger name: %s" % default_trigger)
+            return default_trigger
+        except KeyError:
+            raise SettingNotFound("Attribute default_trigger not found in settings")
 
-    def get_stt_args(self, default_stt_plugin_name):
+    @classmethod
+    def _get_stts(cls, settings):
         """
-        Return argument set for the current STT engine
-        :param default_stt_plugin_name: Name of the STT engine
-        :return:
+        Return a list of stt object
+        :param settings: loaded settings file
+        :return: List of Stt
         """
-
-        def find(lst, key):
-            """
-            Find a key name in a list
-            :param lst: list()
-            :param key: key name to find i the list
-            :return: Return the dict
-            """
-            for el in lst:
-                try:
-                    if el[key]:
-                        return el[key]
-                except TypeError:
-                    pass
-                except KeyError:
-                    pass
-            return None
-
-        settings = self.get_config()
         try:
-            speechs_to_text = settings["speech_to_text"]
+            speechs_to_text_list = settings["speech_to_text"]
         except KeyError:
-            raise NoSpeechToTextConfiguration("No speech_to_text in settings")
-
-        logger.debug("Settings file content: %s" % speechs_to_text)
-        # get args
-        args = find(speechs_to_text, default_stt_plugin_name)
-
-        logger.debug("Args for %s STT: %s" % (default_stt_plugin_name, args))
-
-        return args
-
-    def get_tts_args(self, tts_name):
+            raise NullSettingException("speech_to_text settings not found")
+
+        stts = list()
+        for speechs_to_text_el in speechs_to_text_list:
+            if isinstance(speechs_to_text_el, dict):
+                # print "Neurons dict ok"
+                for stt_name in speechs_to_text_el:
+                    name = stt_name
+                    parameters = speechs_to_text_el[name]
+                    new_stt = Stt(name=name, parameters=parameters)
+                    stts.append(new_stt)
+            else:
+                # the neuron does not have parameter
+                new_stt = Stt(name=speechs_to_text_el)
+                stts.append(new_stt)
+        return stts
+
+    @classmethod
+    def _get_ttss(cls, settings):
+        """
+        Return a list of Tts object
+        :param settings: loaded settings file
+        :return: List of Tts
+        """
+        try:
+            text_to_speech_list = settings["text_to_speech"]
+        except KeyError:
+            raise SettingNotFound("text_to_speech settings not found")
+
+        ttss = list()
+        for text_to_speech_el in text_to_speech_list:
+            if isinstance(text_to_speech_el, dict):
+                # print "Neurons dict ok"
+                for tts_name in text_to_speech_el:
+                    name = tts_name
+                    parameters = text_to_speech_el[name]
+                    new_tts = Tts(name=name, parameters=parameters)
+                    ttss.append(new_tts)
+            else:
+                # the neuron does not have parameter
+                new_tts = Tts(name=text_to_speech_el)
+                ttss.append(new_tts)
+        return ttss
+
+    @classmethod
+    def _get_triggers(cls, settings):
         """
-        Return argument set for the current STT engine
-        :param tts_name: Name of the TTS engine
+        Return a list of Trigger object
+        :param settings: loaded settings file
+        :return: List of Trigger
+        """
+        try:
+            triggers_list = settings["triggers"]
+        except KeyError:
+            raise SettingNotFound("text_to_speech settings not found")
+
+        triggers = list()
+        for trigger_el in triggers_list:
+            if isinstance(trigger_el, dict):
+                # print "Neurons dict ok"
+                for tts_name in trigger_el:
+                    name = tts_name
+                    parameters = trigger_el[name]
+                    new_tts = Trigger(name=name, parameters=parameters)
+                    triggers.append(new_tts)
+            else:
+                # the neuron does not have parameter
+                new_tts = Trigger(name=trigger_el)
+                triggers.append(new_tts)
+        return triggers
+
+    @classmethod
+    def _get_random_wake_up_answers(cls, settings):
+        """
+        return a list of string
+        :param settings:
         :return:
         """
-
-        def find(lst, key):
-            """
-            Find a key name in a list
-            :param lst: list()
-            :param key: key name to find i the list
-            :return: Return the dict
-            """
-            for el in lst:
-                try:
-                    if el[key]:
-                        return el[key]
-                except TypeError:
-                    pass
-                except KeyError:
-                    pass
-            return None
-
-        settings = self.get_config()
         try:
-            texts_to_speech = settings["text_to_speech"]
+            random_wake_up_answers_list = settings["random_wake_up_answers"]
         except KeyError:
-            raise NoSpeechToTextConfiguration("No text_to_speech in settings")
-
-        logger.debug("Settings file content: %s" % texts_to_speech)
-        # get args
-        args = find(texts_to_speech, tts_name)
-        logger.debug("Args for %s TTS: %s" % (tts_name, args))
-        # print args
-        return args
+            raise SettingNotFound("text_to_speech settings not found")
+
+        # The list cannot be empty
+        if random_wake_up_answers_list is None:
+            raise NullSettingException("random_wake_up_answers settings is null")

+ 6 - 5
core/ConfigurationManager/YAMLLoader.py

@@ -8,10 +8,11 @@ class YAMLFileNotFound(Exception):
 
 class YAMLLoader:
 
-    def __init__(self, yaml_file):
-        self.file = yaml_file
+    def __init__(self):
+        pass
 
-    def get_config(self):
+    @classmethod
+    def get_config(cls, yaml_file):
         """
         Load settings file
         :return: cfg : the configuration file
@@ -19,8 +20,8 @@ class YAMLLoader:
         # Load settings.
         __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
         try:
-            with open(os.path.join(__location__, self.file)) as ymlfile:
+            with open(os.path.join(__location__, yaml_file)) as ymlfile:
                 cfg = yaml.load(ymlfile)
             return cfg
         except IOError:
-            raise YAMLFileNotFound("The file path %s does not exist" % self.file)
+            raise YAMLFileNotFound("The file path %s does not exist" % yaml_file)

+ 12 - 0
core/Models/Settings.py

@@ -0,0 +1,12 @@
+
+
+class Settings(object):
+    def __init__(self, default_tts_name=None, default_stt_name=None,
+                 default_trigger_name=None, ttss=None, stts=None, random_wake_up_answers=None, triggers=None):
+        self.default_tts_name = default_tts_name
+        self.default_stt_name = default_stt_name
+        self.default_trigger_name = default_trigger_name
+        self.ttss = ttss
+        self.stts = stts
+        self.random_wake_up_answers = random_wake_up_answers
+        self.triggers = triggers

+ 9 - 0
core/Models/Stt.py

@@ -0,0 +1,9 @@
+
+
+class Stt(object):
+    def __init__(self, name=None, parameters=None):
+        self.name = name
+        self.parameters = parameters
+
+    def __str__(self):
+        return "Stt name: %s, parameters: %s" % (str(self.name), str(self.parameters))

+ 10 - 0
core/Models/Trigger.py

@@ -0,0 +1,10 @@
+
+
+class Trigger(object):
+    def __init__(self, name=None, parameters=None):
+        self.name = name
+        self.parameters = parameters
+
+    def __str__(self):
+        return "Trigger name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+

+ 10 - 0
core/Models/Tts.py

@@ -0,0 +1,10 @@
+
+
+class Tts(object):
+    def __init__(self, name=None, parameters=None):
+        self.name = name
+        self.parameters = parameters
+
+    def __str__(self):
+        return "Tts name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+

+ 0 - 0
core/TriggerLauncher.py