def test_get_player(self):
"""
Test the PlayerLauncher trying to run the Player
"""
player1 = Player("Player", {})
player2 = Player("Player2", {'test': "hitheparamtest"})
settings = Settings()
settings.players = [player1, player2]
with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
# Get the player1
settings.default_player_name = "Player"
PlayerLauncher.get_player(settings=settings)
mock_get_class_instantiation.assert_called_once_with(package_name="players",
module_name=player1.name,
parameters=player1.parameters)
mock_get_class_instantiation.reset_mock()
# Get the player 2
settings.default_player_name = "Player2"
PlayerLauncher.get_player(settings=settings)
mock_get_class_instantiation.assert_called_once_with(package_name="players",
module_name=player2.name,
parameters=player2.parameters)
mock_get_class_instantiation.reset_mock()
def test_get_player(self):
"""
Test the PlayerLauncher trying to run the Player
"""
player1 = Player("Player", {})
player2 = Player("Player2", {'test': "hitheparamtest"})
settings = Settings()
settings.players = [player1, player2]
with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation"
) as mock_get_class_instantiation:
# Get the player1
settings.default_player_name = "Player"
PlayerLauncher.get_player(settings=settings)
mock_get_class_instantiation.assert_called_once_with(
package_name="players",
module_name=player1.name,
parameters=player1.parameters)
mock_get_class_instantiation.reset_mock()
# Get the player 2
settings.default_player_name = "Player2"
PlayerLauncher.get_player(settings=settings)
mock_get_class_instantiation.assert_called_once_with(
package_name="players",
module_name=player2.name,
parameters=player2.parameters)
mock_get_class_instantiation.reset_mock()
def __init__(self, **kwargs):
# set parameter from what we receive from the settings
self.cache = kwargs.get('cache', False)
self.language = kwargs.get('language', "default")
self.voice = kwargs.get('voice', "default")
# the name of the TSS is the name of the Tss module that have instantiated TTSModule
self.tts_caller_name = self.__class__.__name__
# we don't know yet the words that will be converted to an audio and so we don't have the audio path yet too
self.words = None
self.file_path = None
self.base_cache_path = None
# load settings
sl = SettingLoader()
self.settings = sl.settings
self.player = PlayerLauncher.get_player(settings=self.settings)
# create the path in the tmp folder
base_path = os.path.join(self.settings.cache_path, self.tts_caller_name, self.language, self.voice)
FileManager.create_directory(base_path)
logger.debug("Class TTSModule called from module %s, cache: %s, language: %s, voice: %s" % (self.tts_caller_name,
self.cache,
self.language,
self.voice))
def __init__(self, **kwargs):
super(Play, self).__init__(**kwargs)
self.filename = kwargs.get('filename', None)
self.player = PlayerLauncher.get_player(settings=self.settings)
# check if parameters have been provided
if self._is_parameters_ok():
self.player.play(self.filename)
def __init__(self):
super(Order, self).__init__()
Utils.print_info('Starting voice order manager')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().get_brain()
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.is_trigger_muted = False
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# boolean used to know id we played the on ready notification at least one time
self.on_ready_notification_played_once = False
# rpi setting for led and mute button
self.init_rpi_utils()
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', ['init', 'analysing_order'], 'starting_trigger')
self.machine.add_transition('play_ready_sound', 'starting_trigger', 'playing_ready_sound')
self.machine.add_transition('wait_trigger_callback', 'playing_ready_sound', 'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger', 'waiting_for_trigger_callback', 'stopping_trigger')
self.machine.add_transition('play_wake_up_answer', 'stopping_trigger', 'playing_wake_up_answer')
self.machine.add_transition('wait_for_order', 'playing_wake_up_answer', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'playing_wake_up_answer', 'analysing_order')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_playing_ready_sound('play_ready_sound_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_playing_wake_up_answer('play_wake_up_answer_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def __init__(self):
super(SignalModule, self).__init__()
Thread.__init__(self, name=Order)
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
# variable from notifications
self.skip_trigger = False # keep the status of the trigger, if true we can skip it in the statue machine
self.counter_max_retry = 0 # 0 means disabled
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', 'init', 'starting_trigger')
self.machine.add_transition('unpause_trigger', 'analysing_order', 'unpausing_trigger')
self.machine.add_transition('wait_trigger_callback', 'unpausing_trigger', 'waiting_for_trigger_callback')
self.machine.add_transition('pause_trigger', 'waiting_for_trigger_callback', 'pausing_trigger')
self.machine.add_transition('wait_for_order', 'pausing_trigger', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'waiting_for_order_listener_callback', 'analysing_order')
self.machine.add_transition('start_order_listener', 'analysing_order', 'start_order_listener')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_unpausing_trigger('unpausing_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_pausing_trigger('pause_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def __init__(self):
super(SignalModule, self).__init__()
Thread.__init__(self, name=Order)
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.skip_trigger = False # keep the status of the trigger, if true we can skip it in the statue machine
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self, states=Order.states, initial='init', queued=True)
# define transitions
self.machine.add_transition('start_trigger', ['init', 'analysing_order'], 'starting_trigger')
self.machine.add_transition('wait_trigger_callback', 'starting_trigger', 'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger', 'waiting_for_trigger_callback', 'stopping_trigger')
self.machine.add_transition('wait_for_order', 'stopping_trigger', 'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order', 'waiting_for_order_listener_callback', 'analysing_order')
self.machine.add_transition('start_order_listener', 'analysing_order', 'start_order_listener')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback('waiting_for_trigger_callback_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener('start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback('waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
def __init__(self, **kwargs):
super(Recorder, self).__init__(**kwargs)
# the args from the neuron configuration
self.rate = kwargs.get('rate', 44100)
self.chunk = kwargs.get('chunk', 1024)
self.channels = kwargs.get('channels', 2)
self.seconds = kwargs.get('seconds', None)
self.file_name = kwargs.get('file_name', 'default.wav')
self.playback = kwargs.get('playback', False)
self.format = kwargs.get('format', None)
# check if parameters have been provided
if self._is_parameters_ok():
self.output = os.path.dirname(
__file__) + "/output/" + self.file_name
if self.playback:
sl = SettingLoader()
self.settings = sl.settings
self.player = PlayerLauncher.get_player(settings=self.settings)
if self.seconds:
self.start_recording()
if self.playback and not self.seconds:
self.playback_file(self.output)
def __init__(self, brain=None):
self.brain = brain
# get global configuration
sl = SettingLoader()
self.settings = sl.settings
# keep in memory the order to process
self.order_to_process = None
# Starting the rest API
self._start_rest_api()
# rpi setting for led and mute button
self.rpi_utils = None
if self.settings.rpi_settings:
# the useer set GPIO pin, we need to instantiate the RpiUtils class in order to setup GPIO
self.rpi_utils = RpiUtils(self.settings.rpi_settings,
self.muted_button_pressed)
if self.settings.rpi_settings.pin_mute_button:
# start the listening for button pressed thread only if the user set a pin
self.rpi_utils.daemon = True
self.rpi_utils.start()
# switch high the start led, as kalliope is started. Only if the setting exist
if self.settings.rpi_settings:
if self.settings.rpi_settings.pin_led_started:
logger.debug(
"[MainController] Switching pin_led_started to ON")
RpiUtils.switch_pin_to_on(
self.settings.rpi_settings.pin_led_started)
# get the player instance
self.player_instance = PlayerLauncher.get_player(
settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# boolean used to know id we played the on ready notification at least one time
self.on_ready_notification_played_once = False
# Initialize the state machine
self.machine = Machine(model=self,
states=MainController.states,
initial='init',
queued=True)
# define transitions
self.machine.add_transition('start_trigger',
['init', 'analysing_order'],
'starting_trigger')
self.machine.add_transition('play_ready_sound', 'starting_trigger',
'playing_ready_sound')
self.machine.add_transition('wait_trigger_callback',
'playing_ready_sound',
'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger',
'waiting_for_trigger_callback',
'stopping_trigger')
self.machine.add_transition('play_wake_up_answer',
'waiting_for_trigger_callback',
'playing_wake_up_answer')
self.machine.add_transition('wait_for_order', 'playing_wake_up_answer',
'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order',
'waiting_for_order_listener_callback',
'analysing_order')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_playing_ready_sound('play_ready_sound_process')
self.machine.on_enter_waiting_for_trigger_callback(
'waiting_for_trigger_callback_thread')
self.machine.on_enter_playing_wake_up_answer(
'play_wake_up_answer_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener(
'start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback(
'waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')
self.start_trigger()
def __init__(self):
super(Order, self).__init__()
Utils.print_info('Starting order signal')
# load settings and brain from singleton
sl = SettingLoader()
self.settings = sl.settings
self.brain = BrainLoader().brain
# keep in memory the order to process
self.order_to_process = None
# get the player instance
self.player_instance = PlayerLauncher.get_player(
settings=self.settings)
# save an instance of the trigger
self.trigger_instance = None
self.trigger_callback_called = False
self.is_trigger_muted = False
# If kalliope is asked to start muted
if self.settings.start_options['muted'] is True:
self.is_trigger_muted = True
# save the current order listener
self.order_listener = None
self.order_listener_callback_called = False
# Initialize the state machine
self.machine = Machine(model=self,
states=Order.states,
initial='init',
queued=True)
# define transitions
self.machine.add_transition('start_trigger',
['init', 'analysing_order'],
'starting_trigger')
self.machine.add_transition('wait_trigger_callback',
'starting_trigger',
'waiting_for_trigger_callback')
self.machine.add_transition('stop_trigger',
'waiting_for_trigger_callback',
'stopping_trigger')
self.machine.add_transition('wait_for_order', 'stopping_trigger',
'waiting_for_order_listener_callback')
self.machine.add_transition('analyse_order',
'waiting_for_order_listener_callback',
'analysing_order')
self.machine.add_ordered_transitions()
# add method which are called when changing state
self.machine.on_enter_starting_trigger('start_trigger_process')
self.machine.on_enter_waiting_for_trigger_callback(
'waiting_for_trigger_callback_thread')
self.machine.on_enter_stopping_trigger('stop_trigger_process')
self.machine.on_enter_start_order_listener(
'start_order_listener_thread')
self.machine.on_enter_waiting_for_order_listener_callback(
'waiting_for_order_listener_callback_thread')
self.machine.on_enter_analysing_order('analysing_order_thread')