SettingLoader.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292
  1. import logging
  2. from YAMLLoader import YAMLLoader
  3. from core.FileManager import FileManager
  4. from core.Models import Singleton
  5. from core.Models.RestAPI import RestAPI
  6. from core.Models.Settings import Settings
  7. from core.Models.Stt import Stt
  8. from core.Models.Trigger import Trigger
  9. from core.Models.Tts import Tts
  10. FILE_NAME = "settings.yml"
  11. logging.basicConfig()
  12. logger = logging.getLogger("kalliope")
  13. class SettingInvalidException(Exception):
  14. pass
  15. class NullSettingException(Exception):
  16. pass
  17. class SettingNotFound(Exception):
  18. pass
  19. class SettingLoader(object):
  20. def __init__(self):
  21. pass
  22. @classmethod
  23. def get_yaml_config(cls, file_path=None):
  24. if file_path is None:
  25. file_path = FILE_NAME
  26. return YAMLLoader.get_config(file_path)
  27. @classmethod
  28. def get_settings(cls, file_path=None):
  29. """
  30. Return a Settings object from settings.yml file
  31. :return:
  32. """
  33. # create a new setting
  34. setting_object = Settings.Instance()
  35. logger.debug("Is Settings already loaded ? %r" % setting_object.is_loaded)
  36. if setting_object.is_loaded is False:
  37. # Get the setting parameters
  38. settings = cls.get_yaml_config(file_path)
  39. default_stt_name = cls._get_default_speech_to_text(settings)
  40. default_tts_name = cls._get_default_text_to_speech(settings)
  41. default_trigger_name = cls._get_default_trigger(settings)
  42. stts = cls._get_stts(settings)
  43. ttss = cls._get_ttss(settings)
  44. triggers = cls._get_triggers(settings)
  45. random_wake_up_answers = cls._get_random_wake_up_answers(settings)
  46. random_wake_up_sounds = cls._get_random_wake_up_sounds(settings)
  47. rest_api = cls._get_rest_api(settings)
  48. cache_path = cls._get_cache_path(settings)
  49. # Load the setting singleton with the parameters
  50. setting_object.default_tts_name=default_tts_name
  51. setting_object.default_stt_name=default_stt_name
  52. setting_object.default_trigger_name=default_trigger_name
  53. setting_object.stts=stts
  54. setting_object.ttss=ttss
  55. setting_object.triggers=triggers
  56. setting_object.random_wake_up_answers=random_wake_up_answers
  57. setting_object.random_wake_up_sounds=random_wake_up_sounds
  58. setting_object.rest_api=rest_api
  59. setting_object.cache_path=cache_path
  60. setting_object.is_loaded = True
  61. return setting_object
  62. @staticmethod
  63. def _get_default_speech_to_text(settings):
  64. try:
  65. default_speech_to_text = settings["default_speech_to_text"]
  66. if default_speech_to_text is None:
  67. raise NullSettingException("Attribute default_speech_to_text is null")
  68. logger.debug("Default STT: %s" % default_speech_to_text)
  69. return default_speech_to_text
  70. except KeyError, e:
  71. raise SettingNotFound("%s setting not found" % e)
  72. @staticmethod
  73. def _get_default_text_to_speech(settings):
  74. try:
  75. default_text_to_speech = settings["default_text_to_speech"]
  76. if default_text_to_speech is None:
  77. raise NullSettingException("Attribute default_text_to_speech is null")
  78. logger.debug("Default TTS: %s" % default_text_to_speech)
  79. return default_text_to_speech
  80. except KeyError, e:
  81. raise SettingNotFound("%s setting not found" % e)
  82. @staticmethod
  83. def _get_default_trigger(settings):
  84. try:
  85. default_trigger = settings["default_trigger"]
  86. if default_trigger is None:
  87. raise NullSettingException("Attribute default_trigger is null")
  88. logger.debug("Default Trigger name: %s" % default_trigger)
  89. return default_trigger
  90. except KeyError, e:
  91. raise SettingNotFound("%s setting not found" % e)
  92. @classmethod
  93. def _get_stts(cls, settings):
  94. """
  95. Return a list of stt object
  96. :param settings: loaded settings file
  97. :return: List of Stt
  98. """
  99. try:
  100. speechs_to_text_list = settings["speech_to_text"]
  101. except KeyError:
  102. raise NullSettingException("speech_to_text settings not found")
  103. stts = list()
  104. for speechs_to_text_el in speechs_to_text_list:
  105. if isinstance(speechs_to_text_el, dict):
  106. # print "Neurons dict ok"
  107. for stt_name in speechs_to_text_el:
  108. name = stt_name
  109. parameters = speechs_to_text_el[name]
  110. new_stt = Stt(name=name, parameters=parameters)
  111. stts.append(new_stt)
  112. else:
  113. # the neuron does not have parameter
  114. new_stt = Stt(name=speechs_to_text_el)
  115. stts.append(new_stt)
  116. return stts
  117. @classmethod
  118. def _get_ttss(cls, settings):
  119. """
  120. Return a list of Tts object
  121. :param settings: loaded settings file
  122. :return: List of Tts
  123. """
  124. try:
  125. text_to_speech_list = settings["text_to_speech"]
  126. except KeyError, e:
  127. raise SettingNotFound("%s setting not found" % e)
  128. ttss = list()
  129. for text_to_speech_el in text_to_speech_list:
  130. if isinstance(text_to_speech_el, dict):
  131. # print "Neurons dict ok"
  132. for tts_name in text_to_speech_el:
  133. name = tts_name
  134. parameters = text_to_speech_el[name]
  135. new_tts = Tts(name=name, parameters=parameters)
  136. ttss.append(new_tts)
  137. else:
  138. # the neuron does not have parameter
  139. new_tts = Tts(name=text_to_speech_el)
  140. ttss.append(new_tts)
  141. return ttss
  142. @classmethod
  143. def _get_triggers(cls, settings):
  144. """
  145. Return a list of Trigger object
  146. :param settings: loaded settings file
  147. :return: List of Trigger
  148. """
  149. try:
  150. triggers_list = settings["triggers"]
  151. except KeyError, e:
  152. raise SettingNotFound("%s setting not found" % e)
  153. triggers = list()
  154. for trigger_el in triggers_list:
  155. if isinstance(trigger_el, dict):
  156. # print "Neurons dict ok"
  157. for tts_name in trigger_el:
  158. name = tts_name
  159. parameters = trigger_el[name]
  160. new_tts = Trigger(name=name, parameters=parameters)
  161. triggers.append(new_tts)
  162. else:
  163. # the neuron does not have parameter
  164. new_tts = Trigger(name=trigger_el)
  165. triggers.append(new_tts)
  166. return triggers
  167. @classmethod
  168. def _get_random_wake_up_answers(cls, settings):
  169. """
  170. return a list of string
  171. :param settings:
  172. :return:
  173. """
  174. try:
  175. random_wake_up_answers_list = settings["random_wake_up_answers"]
  176. except KeyError:
  177. # User does not provide this settings
  178. return None
  179. # The list cannot be empty
  180. if random_wake_up_answers_list is None:
  181. raise NullSettingException("random_wake_up_answers settings is null")
  182. return random_wake_up_answers_list
  183. @classmethod
  184. def _get_random_wake_up_sounds(cls, settings):
  185. """
  186. return a list of string
  187. :param settings:
  188. :return: List of string
  189. """
  190. try:
  191. random_wake_up_sounds_list = settings["random_wake_up_sounds"]
  192. except KeyError:
  193. # User does not provide this settings
  194. return None
  195. # The the setting is present, the list cannot be empty
  196. if random_wake_up_sounds_list is None:
  197. raise NullSettingException("random_wake_up_sounds settings is empty")
  198. return random_wake_up_sounds_list
  199. @classmethod
  200. def _get_rest_api(cls, settings):
  201. try:
  202. rest_api = settings["rest_api"]
  203. except KeyError, e:
  204. raise SettingNotFound("%s setting not found" % e)
  205. if rest_api is not None:
  206. try:
  207. password_protected = rest_api["password_protected"]
  208. if password_protected is None:
  209. raise NullSettingException("password_protected setting cannot be null")
  210. login = rest_api["login"]
  211. password = rest_api["password"]
  212. if password_protected:
  213. if login is None:
  214. raise NullSettingException("login setting cannot be null if password_protected is True")
  215. if login is None:
  216. raise NullSettingException("password setting cannot be null if password_protected is True")
  217. active = rest_api["active"]
  218. if active is None:
  219. raise NullSettingException("active setting cannot be null")
  220. port = rest_api["port"]
  221. if port is None:
  222. raise NullSettingException("port setting cannot be null")
  223. # check that the port in an integer
  224. try:
  225. port = int(port)
  226. except ValueError:
  227. raise SettingInvalidException("port must be an integer")
  228. # check the port is a valid port number
  229. if not 1024 <= port <= 65535:
  230. raise SettingInvalidException("port must be in range 1024-65535")
  231. except KeyError, e:
  232. # print e
  233. raise SettingNotFound("%s settings not found" % e)
  234. # config ok, we can return the rest api object
  235. rest_api_obj = RestAPI(password_protected=password_protected, login=login, password=password, active=active, port=port)
  236. return rest_api_obj
  237. else:
  238. raise NullSettingException("rest_api settings cannot be null")
  239. @classmethod
  240. def _get_cache_path(cls, settings):
  241. try:
  242. cache_path = settings["cache_path"]
  243. except KeyError, e:
  244. raise SettingNotFound("%s setting not found" % e)
  245. if cache_path is None:
  246. raise NullSettingException("cache_path setting cannot be null")
  247. # test if that path is usable
  248. if FileManager.is_path_exists_or_creatable(cache_path):
  249. return cache_path
  250. else:
  251. raise SettingInvalidException("The cache_path seems to be invalid: %s" % cache_path)