SettingLoader.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  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. # The Settings Singleton is loaded
  61. setting_object.is_loaded = True
  62. return setting_object
  63. @staticmethod
  64. def _get_default_speech_to_text(settings):
  65. try:
  66. default_speech_to_text = settings["default_speech_to_text"]
  67. if default_speech_to_text is None:
  68. raise NullSettingException("Attribute default_speech_to_text is null")
  69. logger.debug("Default STT: %s" % default_speech_to_text)
  70. return default_speech_to_text
  71. except KeyError, e:
  72. raise SettingNotFound("%s setting not found" % e)
  73. @staticmethod
  74. def _get_default_text_to_speech(settings):
  75. try:
  76. default_text_to_speech = settings["default_text_to_speech"]
  77. if default_text_to_speech is None:
  78. raise NullSettingException("Attribute default_text_to_speech is null")
  79. logger.debug("Default TTS: %s" % default_text_to_speech)
  80. return default_text_to_speech
  81. except KeyError, e:
  82. raise SettingNotFound("%s setting not found" % e)
  83. @staticmethod
  84. def _get_default_trigger(settings):
  85. try:
  86. default_trigger = settings["default_trigger"]
  87. if default_trigger is None:
  88. raise NullSettingException("Attribute default_trigger is null")
  89. logger.debug("Default Trigger name: %s" % default_trigger)
  90. return default_trigger
  91. except KeyError, e:
  92. raise SettingNotFound("%s setting not found" % e)
  93. @classmethod
  94. def _get_stts(cls, settings):
  95. """
  96. Return a list of stt object
  97. :param settings: loaded settings file
  98. :return: List of Stt
  99. """
  100. try:
  101. speechs_to_text_list = settings["speech_to_text"]
  102. except KeyError:
  103. raise NullSettingException("speech_to_text settings not found")
  104. stts = list()
  105. for speechs_to_text_el in speechs_to_text_list:
  106. if isinstance(speechs_to_text_el, dict):
  107. # print "Neurons dict ok"
  108. for stt_name in speechs_to_text_el:
  109. name = stt_name
  110. parameters = speechs_to_text_el[name]
  111. new_stt = Stt(name=name, parameters=parameters)
  112. stts.append(new_stt)
  113. else:
  114. # the neuron does not have parameter
  115. new_stt = Stt(name=speechs_to_text_el)
  116. stts.append(new_stt)
  117. return stts
  118. @classmethod
  119. def _get_ttss(cls, settings):
  120. """
  121. Return a list of Tts object
  122. :param settings: loaded settings file
  123. :return: List of Tts
  124. """
  125. try:
  126. text_to_speech_list = settings["text_to_speech"]
  127. except KeyError, e:
  128. raise SettingNotFound("%s setting not found" % e)
  129. ttss = list()
  130. for text_to_speech_el in text_to_speech_list:
  131. if isinstance(text_to_speech_el, dict):
  132. # print "Neurons dict ok"
  133. for tts_name in text_to_speech_el:
  134. name = tts_name
  135. parameters = text_to_speech_el[name]
  136. new_tts = Tts(name=name, parameters=parameters)
  137. ttss.append(new_tts)
  138. else:
  139. # the neuron does not have parameter
  140. new_tts = Tts(name=text_to_speech_el)
  141. ttss.append(new_tts)
  142. return ttss
  143. @classmethod
  144. def _get_triggers(cls, settings):
  145. """
  146. Return a list of Trigger object
  147. :param settings: loaded settings file
  148. :return: List of Trigger
  149. """
  150. try:
  151. triggers_list = settings["triggers"]
  152. except KeyError, e:
  153. raise SettingNotFound("%s setting not found" % e)
  154. triggers = list()
  155. for trigger_el in triggers_list:
  156. if isinstance(trigger_el, dict):
  157. # print "Neurons dict ok"
  158. for tts_name in trigger_el:
  159. name = tts_name
  160. parameters = trigger_el[name]
  161. new_tts = Trigger(name=name, parameters=parameters)
  162. triggers.append(new_tts)
  163. else:
  164. # the neuron does not have parameter
  165. new_tts = Trigger(name=trigger_el)
  166. triggers.append(new_tts)
  167. return triggers
  168. @classmethod
  169. def _get_random_wake_up_answers(cls, settings):
  170. """
  171. return a list of string
  172. :param settings:
  173. :return:
  174. """
  175. try:
  176. random_wake_up_answers_list = settings["random_wake_up_answers"]
  177. except KeyError:
  178. # User does not provide this settings
  179. return None
  180. # The list cannot be empty
  181. if random_wake_up_answers_list is None:
  182. raise NullSettingException("random_wake_up_answers settings is null")
  183. return random_wake_up_answers_list
  184. @classmethod
  185. def _get_random_wake_up_sounds(cls, settings):
  186. """
  187. return a list of string
  188. :param settings:
  189. :return: List of string
  190. """
  191. try:
  192. random_wake_up_sounds_list = settings["random_wake_up_sounds"]
  193. except KeyError:
  194. # User does not provide this settings
  195. return None
  196. # The the setting is present, the list cannot be empty
  197. if random_wake_up_sounds_list is None:
  198. raise NullSettingException("random_wake_up_sounds settings is empty")
  199. return random_wake_up_sounds_list
  200. @classmethod
  201. def _get_rest_api(cls, settings):
  202. try:
  203. rest_api = settings["rest_api"]
  204. except KeyError, e:
  205. raise SettingNotFound("%s setting not found" % e)
  206. if rest_api is not None:
  207. try:
  208. password_protected = rest_api["password_protected"]
  209. if password_protected is None:
  210. raise NullSettingException("password_protected setting cannot be null")
  211. login = rest_api["login"]
  212. password = rest_api["password"]
  213. if password_protected:
  214. if login is None:
  215. raise NullSettingException("login setting cannot be null if password_protected is True")
  216. if login is None:
  217. raise NullSettingException("password setting cannot be null if password_protected is True")
  218. active = rest_api["active"]
  219. if active is None:
  220. raise NullSettingException("active setting cannot be null")
  221. port = rest_api["port"]
  222. if port is None:
  223. raise NullSettingException("port setting cannot be null")
  224. # check that the port in an integer
  225. try:
  226. port = int(port)
  227. except ValueError:
  228. raise SettingInvalidException("port must be an integer")
  229. # check the port is a valid port number
  230. if not 1024 <= port <= 65535:
  231. raise SettingInvalidException("port must be in range 1024-65535")
  232. except KeyError, e:
  233. # print e
  234. raise SettingNotFound("%s settings not found" % e)
  235. # config ok, we can return the rest api object
  236. rest_api_obj = RestAPI(password_protected=password_protected, login=login, password=password, active=active, port=port)
  237. return rest_api_obj
  238. else:
  239. raise NullSettingException("rest_api settings cannot be null")
  240. @classmethod
  241. def _get_cache_path(cls, settings):
  242. try:
  243. cache_path = settings["cache_path"]
  244. except KeyError, e:
  245. raise SettingNotFound("%s setting not found" % e)
  246. if cache_path is None:
  247. raise NullSettingException("cache_path setting cannot be null")
  248. # test if that path is usable
  249. if FileManager.is_path_exists_or_creatable(cache_path):
  250. return cache_path
  251. else:
  252. raise SettingInvalidException("The cache_path seems to be invalid: %s" % cache_path)