def test_load_stt_plugin(self):
# Test getting default stt
ol = OrderListener()
stt1 = Stt(name="default-stt", parameters=dict())
stt2 = Stt(name="second-stt", parameters=dict())
stt3 = Stt(name="third-stt", parameters=dict())
resources = Resources(stt_folder="/tmp")
ol.settings = mock.MagicMock(default_stt_name="default-stt",
stts=[stt1, stt2, stt3],
resources=resources)
callback = mock.MagicMock()
ol.callback = callback
with mock.patch("brain.core.Utils.get_dynamic_class_instantiation"
) as mock_get_dynamic_class_instantiation:
mock_get_dynamic_class_instantiation.return_value = 'class_instance'
self.assertEqual(ol.load_stt_plugin(), "class_instance",
"Fail getting the proper value")
mock_get_dynamic_class_instantiation.assert_called_once_with(
package_name="stt",
module_name="Default-stt",
parameters={'callback': callback},
resources_dir="/tmp")
def test_set_stts(self):
new_stt = Stt(name="totoStt", parameters={})
with mock.patch("brain.core.ConfigurationManager.SettingLoader"
) as mock_setting_loader:
mock_setting_loader.return_value(self.sl)
SettingEditor.set_stts(new_stt)
self.assertIn(new_stt, self.sl.settings.stts)
def _get_stts(settings):
"""
Return a list of stt object
:param settings: The YAML settings file
:type settings: dict
:return: List of Stt
:rtype: list
:Example:
stts = cls._get_stts(settings)
.. seealso:: Stt
.. raises:: SettingNotFound
.. warnings:: Static Method and Private
"""
try:
speechs_to_text_list = settings["speech_to_text"]
except KeyError:
raise SettingNotFound("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):
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 stt does not have parameter
new_stt = Stt(name=speechs_to_text_el, parameters=dict())
stts.append(new_stt)
return stts
def test_Stt(self):
stt1 = Stt(name="stt1", parameters={"key1": "val1"})
stt2 = Stt(name="stt2", parameters={"key2": "val2"})
stt3 = Stt(name="stt1", parameters={"key1": "val1"})
expected_result_serialize = {
'name': 'stt1',
'parameters': {
'key1': 'val1'
}
}
self.assertDictEqual(expected_result_serialize, stt1.serialize())
self.assertTrue(stt1.__eq__(stt3))
self.assertFalse(stt1.__eq__(stt2))
def test_get_stts(self):
stt = Stt(name="google", parameters={'language': 'fr-FR'})
sl = SettingLoader(file_path=self.settings_file_to_test)
self.assertEqual([stt], sl._get_stts(self.settings_dict))
def test_get_settings(self):
settings_object = Settings()
settings_object.default_tts_name = "pico2wave"
settings_object.default_stt_name = "google"
settings_object.default_trigger_name = "snowboy"
settings_object.default_player_name = "mplayer"
tts1 = Tts(name="pico2wave",
parameters={
'cache': True,
'language': 'fr-FR'
})
tts2 = Tts(name="googletts",
parameters={
'language': 'fr',
'cache': True
})
settings_object.ttss = [tts1, tts2]
stt = Stt(name="google", parameters={'language': 'fr-FR'})
settings_object.stts = [stt]
trigger1 = Trigger(
name="snowboy",
parameters={
'pmdl_file': 'trigger/snowboy/resources/brain-FR-6samples.pmdl'
})
settings_object.triggers = [trigger1]
player1 = Player(name="mplayer", parameters={})
player2 = Player(name="pyalsaaudio", parameters={"device": "default"})
settings_object.players = [player1, player2]
settings_object.rest_api = RestAPI(password_protected=True,
active=True,
login="******",
password="******",
port=5000,
allowed_cors_origin=False)
settings_object.cache_path = '/tmp/brain_tts_cache'
resources = Resources(
neuron_folder="/tmp/brain/tests/brain_resources_dir/neurons",
stt_folder="/tmp/brain/tests/brain_resources_dir/stt",
tts_folder="/tmp/brain/tests/brain_resources_dir/tts",
trigger_folder="/tmp/brain/tests/brain_resources_dir/trigger")
settings_object.resources = resources
settings_object.variables = {
"author": "Lamonf",
"test_number": 60,
"test": "brain"
}
settings_object.options = Options(energy_threshold=3000,
deaf=True,
mute=False)
settings_object.machine = platform.machine()
settings_object.hooks = {
'on_waiting_for_trigger': 'test',
'on_stop_listening': None,
'on_start_listening': None,
'on_order_found': None,
'on_start': ['on-start-synapse', 'bring-led-on'],
'on_undeaf': [],
'on_triggered': ['on-triggered-synapse'],
'on_deaf': [],
'on_mute': [],
'on_unmute': [],
'on_order_not_found': ['order-not-found-synapse'],
'on_processed_synapses': None,
'on_start_speaking': None,
'on_stop_speaking': None,
}
sl = SettingLoader(file_path=self.settings_file_to_test)
self.assertEqual(settings_object, sl.settings)
def _set_settings(self):
# PLAYERS
if self.default_player:
SettingEditor.set_default_player(self.default_player)
if self.players:
for player_el in self.players:
if isinstance(player_el, dict):
for player_name in player_el:
name = player_name
parameters = player_el[name]
new_player = Player(name=name, parameters=parameters)
SettingEditor.set_players(new_player)
# STT
if self.default_stt:
SettingEditor.set_default_stt(self.default_stt)
if self.speech_to_text:
for stt_el in self.speech_to_text:
if isinstance(stt_el, dict):
for stt_name in stt_el:
name = stt_name
parameters = stt_el[name]
new_stt = Stt(name=name, parameters=parameters)
SettingEditor.set_stts(new_stt)
# TRIGGER
if self.default_trigger:
SettingEditor.set_default_trigger(self.default_trigger)
if self.triggers:
for trigger_el in self.triggers:
if isinstance(trigger_el, dict):
for trigger_name in trigger_el:
name = trigger_name
parameters = trigger_el[name]
new_trigger = Trigger(name=name, parameters=parameters)
SettingEditor.set_trigger(new_trigger)
# TTS
if self.default_tts:
SettingEditor.set_default_tts(self.default_tts)
if self.text_to_speech:
for tts_el in self.text_to_speech:
if isinstance(tts_el, dict):
for tts_name in tts_el:
name = tts_name
parameters = tts_el[name]
new_tts = Tts(name=name, parameters=parameters)
SettingEditor.set_ttss(new_tts)
# Options
if self.deaf is not None:
signal_order = SignalLauncher.get_order_instance()
if signal_order is not None:
SettingEditor.set_deaf_status(signal_order.trigger_instance,
self.deaf)
if self.mute is not None:
SettingEditor.set_mute_status(self.mute)
if self.energy_threshold is not None:
SettingEditor.set_energy_threshold(self.energy_threshold)
if self.adjust_for_ambient_noise_second is not None:
SettingEditor.set_adjust_for_ambient_noise_second(
self.adjust_for_ambient_noise_second)
# Hooks
if self.hooks:
SettingEditor.set_hooks(self.hooks)
# Variables
if self.var_files:
variables = dict()
for files in self.var_files:
var = Utils.get_real_file_path(files)
# var is None has been checked previously in _is_parameters_ok() method
variables.update(YAMLLoader.get_config(var))
SettingEditor.set_variables(variables)
if self.variable is not None:
SettingEditor.set_variables(self.variable)
def test_set_settings(self):
# tts
self.neuron_settings.default_tts = "randomtts"
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_default_tts"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
self.neuron_settings.default_tts)
self.neuron_settings.text_to_speech = [{
"randomTTS": {
"language": "fr-FR"
}
}]
tts = Tts(name="randomTTS", parameters={"language": "fr-FR"})
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_ttss"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(tts)
# stt
self.neuron_settings.default_stt = "randomstt"
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_default_stt"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
self.neuron_settings.default_stt)
self.neuron_settings.speech_to_text = [{
"randomStt": {
"language": "fr-FR"
}
}]
stt = Stt(name="randomStt", parameters={"language": "fr-FR"})
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_stts"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(stt)
# players
self.neuron_settings.default_player = "randomPlayer"
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_default_player"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
self.neuron_settings.default_player)
self.neuron_settings.players = [{"randomPlayer": {}}]
player = Player(name="randomPlayer", parameters={})
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_players"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(player)
# triggers
self.neuron_settings.default_trigger = "randomTrigger"
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_default_trigger"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
self.neuron_settings.default_trigger)
self.neuron_settings.triggers = [{"randomTrigger": {}}]
trigger = Trigger(name="randomTrigger", parameters={})
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_trigger"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(trigger)
# Hooks
self.neuron_settings.hooks = {"randomHook": "randomSynapse"}
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_hooks"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
self.neuron_settings.hooks)
# Variables
with tempfile.NamedTemporaryFile() as tmpfile:
tmpfile.write(
"coucou: 'hello'".encode()) # encode to get the binary format
tmpfile.flush() # To refresh the file with the data
self.neuron_settings.var_files = [tmpfile.name]
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_variables"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(
{'coucou': 'hello'})
self.neuron_settings.var_files = [] # reset var_file
# Deaf
self.neuron_settings.deaf = True
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_deaf_status"
) as mock_setting_editor:
with mock.patch(
"brain.core.SignalLauncher.SignalLauncher.get_order_instance"
):
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once()
# Mute
self.neuron_settings.mute = True
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_mute_status"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(True)
# set_energy_threshold
self.neuron_settings.energy_threshold = 50
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_energy_threshold"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(50)
# set_adjust_for_ambient_noise_second
self.neuron_settings.adjust_for_ambient_noise_second = 3000
with mock.patch(
"brain.core.ConfigurationManager.SettingEditor.set_adjust_for_ambient_noise_second"
) as mock_setting_editor:
self.neuron_settings._set_settings()
mock_setting_editor.assert_called_once_with(3000)
def test_Settings(self):
with mock.patch('platform.machine', return_value='pumpkins'):
rest_api1 = RestAPI(password_protected=True,
login="******",
password="******",
active=True,
port=5000,
allowed_cors_origin="*")
tts1 = Tts(name="tts1", parameters=dict())
tts2 = Tts(name="tts2", parameters=dict())
stt1 = Stt(name="stt1", parameters=dict())
stt2 = Stt(name="stt2", parameters=dict())
trigger1 = Trigger(name="snowboy", parameters=dict())
player = Player(name="player1")
resources = Resources()
options = Options()
setting1 = Settings(default_tts_name="pico2wav",
default_stt_name="google",
default_trigger_name="swoyboy",
default_player_name="mplayer",
ttss=[tts1],
stts=[stt1],
triggers=[trigger1],
players=[player],
rest_api=rest_api1,
cache_path="/tmp/brain",
resources=resources,
variables={"key1": "val1"},
options=options)
setting1.brain_version = "0.1.5"
setting2 = Settings(default_tts_name="pico2wav",
default_stt_name="google",
default_trigger_name="swoyboy",
default_player_name="mplayer",
ttss=[tts2],
stts=[stt2],
triggers=[trigger1],
players=[player],
rest_api=rest_api1,
cache_path="/tmp/brain",
resources=resources,
variables={"key1": "val1"},
options=options)
setting3 = Settings(default_tts_name="pico2wav",
default_stt_name="google",
default_trigger_name="swoyboy",
default_player_name="mplayer",
ttss=[tts1],
stts=[stt1],
triggers=[trigger1],
players=[player],
rest_api=rest_api1,
cache_path="/tmp/brain",
resources=resources,
variables={"key1": "val1"},
options=options)
setting3.brain_version = "0.1.5"
expected_result_serialize = {
'default_tts_name': 'pico2wav',
'default_stt_name': 'google',
'default_trigger_name': 'swoyboy',
'default_player_name': 'mplayer',
'ttss': [{
'name': 'tts1',
'parameters': {}
}],
'stts': [{
'name': 'stt1',
'parameters': {}
}],
'triggers': [{
'name': 'snowboy',
'parameters': {}
}],
'players': [{
'name': 'player1',
'parameters': None
}],
'rest_api': {
'password_protected': True,
'login': '******',
'password': '******',
'active': True,
'port': 5000,
'allowed_cors_origin': '*'
},
'cache_path': '/tmp/brain',
'resources': {
'neuron_folder': None,
'stt_folder': None,
'tts_folder': None,
'trigger_folder': None,
'signal_folder': None
},
'variables': {
'key1': 'val1'
},
'machine': 'pumpkins',
'brain_version': '0.1.1',
'options': {
'name': 'Options',
'energy_threshold': 4000,
'adjust_for_ambient_noise_second': 0,
'deaf': None,
'mute': None,
'stt_timeout': 0
},
'hooks': None
}
self.maxDiff = None
self.assertDictEqual(expected_result_serialize,
setting1.serialize())
self.assertTrue(setting1.__eq__(setting3))
self.assertFalse(setting1.__eq__(setting2))