Cortex.py 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120
  1. import logging
  2. import jinja2
  3. from kalliope.core.Utils.Utils import Utils
  4. from kalliope.core.Models import Singleton
  5. from six import with_metaclass
  6. logging.basicConfig()
  7. logger = logging.getLogger("kalliope")
  8. class Cortex(with_metaclass(Singleton, object)):
  9. """
  10. short-term memories of kalliope. Used to store object with a "key" "value"
  11. """
  12. # this dict contains the short term memory of kalliope.
  13. # all keys present in this dict has been saved from a user demand
  14. memory = dict()
  15. # this is a temp dict that allow us to store temporary parameters that as been loaded from the user order
  16. # if the user want to a key from this dict, the key and its value will be added o the memory dict
  17. temp = dict()
  18. def __init__(self):
  19. logger.debug("[Cortex] New memory created")
  20. @classmethod
  21. def get_memory(cls):
  22. """
  23. Get the current dict of parameters saved in memory
  24. :return: dict memory
  25. """
  26. return cls.memory
  27. @classmethod
  28. def save(cls, key, value):
  29. """
  30. Save a new value in the memory
  31. :param key: key to save
  32. :param value: value to save into the key
  33. """
  34. if key in cls.memory:
  35. logger.debug("[Cortex] key %s already present in memory with value %s. Will be overridden"
  36. % (key, cls.memory[key]))
  37. logger.debug("[Cortex] key saved in memory. key: %s, value: %s" % (key, value))
  38. cls.memory[key] = value
  39. @classmethod
  40. def get_from_key(cls, key):
  41. try:
  42. return cls.memory[key]
  43. except KeyError:
  44. logger.debug("[Cortex] key %s does not exist in memory" % key)
  45. return None
  46. @classmethod
  47. def add_parameters_from_order(cls, dict_parameter):
  48. logger.debug("[Cortex] place parameters in temp list: %s" % dict_parameter)
  49. cls.temp.update(dict_parameter)
  50. @classmethod
  51. def clean_parameter_from_order(cls):
  52. """
  53. Clean the temps memory that store parameters loaded from vocal order
  54. """
  55. logger.debug("[Cortex] Clean temp memory")
  56. cls.temp = dict()
  57. @classmethod
  58. def save_neuron_parameter_in_memory(cls, kalliope_memory_dict, neuron_parameters):
  59. """
  60. receive a dict of value send by the child neuron
  61. save in kalliope memory all value
  62. E.g
  63. dict_parameter_to_save = {"my_key_to_save_in_memory": "{{ output_val_from_neuron }}"}
  64. neuron_parameter = {"output_val_from_neuron": "this_is_a_value" }
  65. then the cortex will save in memory the key "my_key_to_save_in_memory" and attach the value "this_is_a_value"
  66. :param neuron_parameters: dict of parameter the neuron has processed and send to the neurone module to
  67. be processed by the TTS engine
  68. :param kalliope_memory_dict: a dict of key value the user want to save from the dict_neuron_parameter
  69. """
  70. if kalliope_memory_dict is not None:
  71. logger.debug("[Cortex] save_memory - User want to save: %s" % kalliope_memory_dict)
  72. logger.debug("[Cortex] save_memory - Available parameters in the neuron: %s" % neuron_parameters)
  73. for key, value in kalliope_memory_dict.items():
  74. # ask the cortex to save in memory the target "key" if it was in parameters of the neuron
  75. if isinstance(neuron_parameters, dict):
  76. if Utils.is_containing_bracket(value):
  77. value = jinja2.Template(value).render(neuron_parameters)
  78. Cortex.save(key, value)
  79. @classmethod
  80. def save_parameter_from_order_in_memory(cls, order_parameters):
  81. """
  82. Save key from the temp dict (where parameters loaded from the voice order where placed temporary)
  83. into the memory dict
  84. :param order_parameters: dict of key to save. {'key_name_in_memory': 'key_name_in_temp_dict'}
  85. :return True if a value has been saved in the kalliope memory
  86. """
  87. order_saved = False
  88. if order_parameters is not None:
  89. logger.debug("[Cortex] save_parameter_from_order_in_memory - User want to save: %s" % order_parameters)
  90. logger.debug("[Cortex] save_parameter_from_order_in_memory - Available parameters in orders: %s"
  91. % cls.temp)
  92. for key, value in order_parameters.items():
  93. # ask the cortex to save in memory the target "key" if it was in the order
  94. if Utils.is_containing_bracket(value):
  95. # if the key exist in the temp dict we can load it with jinja
  96. value = jinja2.Template(value).render(Cortex.temp)
  97. if value:
  98. Cortex.save(key, value)
  99. order_saved = True
  100. return order_saved