def test_singleton(self):
s1 = SettingLoader.Instance(file_path=self.settings_file_to_test)
s2 = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertTrue(s1.settings is s2.settings)
del s1
del s2
def __init__(self, **kwargs):
"""
Class used by neuron for talking
:param kwargs: Same parameter as the Child. Can contain info about the tts to use instead of the
default one
"""
# get the child who called the class
child_name = self.__class__.__name__
logger.debug("NeuronModule called from class %s with parameters: %s" %
(child_name, str(kwargs)))
sl = SettingLoader.Instance()
self.settings = sl.settings
brain_loader = BrainLoader.Instance()
self.brain = brain_loader.brain
# check if the user has overrider the TTS
tts = kwargs.get('tts', None)
if tts is None:
# No tts provided, we load the default one
self.tts = self.settings.default_tts_name
else:
self.tts = tts
# get if the cache settings is present
self.override_cache = kwargs.get('cache', None)
# get templates if provided
# Check if there is a template associate to the output message
self.say_template = kwargs.get('say_template', None)
# check if there is a template file associate to the output message
self.file_template = kwargs.get('file_template', None)
def __init__(self, **kwargs):
# set parameter from what we receive from the settings
self.cache = kwargs.get('cache', False)
self.language = kwargs.get('language', None)
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
self.settings = SettingLoader.get_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 test_get_default_speech_to_text(self):
expected_default_speech_to_text = "google"
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_default_speech_to_text,
sl._get_default_speech_to_text(self.settings_dict))
del sl
def decorated(*args, **kwargs):
settings = SettingLoader.get_settings()
if settings.rest_api.password_protected:
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
return authenticate()
return f(*args, **kwargs)
def check_auth(username, password):
"""This function is called to check if a username /
password combination is valid.
"""
sl = SettingLoader.Instance()
settings = sl.settings
return username == settings.rest_api.login and password == settings.rest_api.password
def test_get_triggers(self):
trigger1 = Trigger(
name="snowboy",
parameters={
'pmdl_file':
'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'
})
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual([trigger1], sl._get_triggers(self.settings_dict))
del sl
def test_get_rest_api(self):
expected_rest_api = RestAPI(password_protected=True,
active=True,
login="******",
password="******",
port=5000)
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_rest_api,
sl._get_rest_api(self.settings_dict))
del sl
def __init__(self, brain_file=None):
# override brain
self.brain_file = brain_file
# get settings
self.settings = SettingLoader.get_settings()
locale.setlocale(locale.LC_ALL, '')
self.d = Dialog(dialog="dialog")
self.d.set_background_title("Kalliope shell UI")
self.show_main_menu()
def test_get_ttss(self):
tts1 = Tts(name="pico2wave",
parameters={
'cache': True,
'language': 'fr-FR'
})
tts2 = Tts(name="voxygen",
parameters={
'voice': 'Agnes',
'cache': True
})
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual([tts1, tts2], sl._get_ttss(self.settings_dict))
del sl
def __init__(self, callback=None, stt=None):
"""
This class is called after we catch the hotword that have woke up Kalliope.
We now wait for an order spoken out loud by the user, translate the order into a text and run the action
attached to this order from settings
:param callback: callback function to call
:param stt: Speech to text plugin name to load. If not provided,
we will load the default one set in settings
"""
# this is a trick to ignore ALSA output error
# see http://stackoverflow.com/questions/7088672/pyaudio-working-but-spits-out-error-messages-each-time
super(OrderListener, self).__init__()
self.stt = stt
self._ignore_stderr()
self.stt_module_name = stt
self.callback = callback
self.settings = SettingLoader.get_settings()
def __init__(self, brain_file=None):
self.brain_file = brain_file
# get global configuration
self.settings = SettingLoader.get_settings()
# run the api if the user want it
if self.settings.rest_api.active:
Utils.print_info("Starting REST API Listening port: %s" % self.settings.rest_api.port)
app = Flask(__name__)
flask_api = FlaskAPI(app, port=self.settings.rest_api.port, brain_file=brain_file)
flask_api.start()
# create an order listener object. This last will the trigger callback before starting
self.order_listener = OrderListener(self.analyse_order)
# Wait that the kalliope trigger is pronounced by the user
self.trigger_instance = self._get_default_trigger()
self.trigger_instance.start()
Utils.print_info("Waiting for trigger detection")
def __init__(self, brain=None):
"""
Load a GUI in a shell console for testing TTS, STT and brain configuration
:param brain: The Brain object provided by the brain.yml
:type brain: Brain
.. seealso:: Brain
"""
# override brain
self.brain = brain
# get settings
self.settings = SettingLoader.get_settings()
locale.setlocale(locale.LC_ALL, '')
self.d = Dialog(dialog="dialog")
self.d.set_background_title("Kalliope shell UI")
self.show_main_menu()
def check_auth(username, password):
"""This function is called to check if a username /
password combination is valid.
"""
settings = SettingLoader.get_settings()
return username == settings.rest_api.login and password == settings.rest_api.password
# coding: utf8
import logging
import re
from collections import Counter
from flask import Flask
from core.RestAPI.FlaskAPI import FlaskAPI
from core import OrderAnalyser
from core.ConfigurationManager import SettingLoader
from core.ConfigurationManager import YAMLLoader
from core.ConfigurationManager.BrainLoader import BrainLoader
from neurons import Systemdate
from neurons.tasker_autoremote.tasker_autoremote import Tasker_autoremote
logging.basicConfig()
logger = logging.getLogger("kalliope")
logger.setLevel(logging.DEBUG)
# order = "quelle heure est-il"
# oa = OrderAnalyser(order=order)
# oa.start()
SettingLoader.get_settings()
# app = Flask(__name__)
# flask_api = FlaskAPI(app)
# flask_api.start()
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from core.ConfigurationManager import SettingLoader
from sys import version_info
sl = SettingLoader.Instance()
settings = sl.settings
module_file_path = "%s/_snowboydetect" % settings.machine
if version_info >= (2, 6, 0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(module_file_path, [dirname(__file__)])
except ImportError:
import _snowboydetect
return _snowboydetect
if fp is not None:
try:
_mod = imp.load_module('_snowboydetect', fp, pathname, description)
finally:
fp.close()
return _mod
_snowboydetect = swig_import_helper()
del swig_import_helper
def test_get_default_text_to_speech(self):
expected_default_text_to_speech = "pico2wave"
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_default_text_to_speech,
sl._get_default_text_to_speech(self.settings_dict))
del sl
def test_get_cache_path(self):
expected_cache_path = '/tmp/kalliope_tts_cache'
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_cache_path,
sl._get_cache_path(self.settings_dict))
del sl
def test_get_random_wake_up_answers(self):
expected_random_wake_up_answers = ['Oui monsieur?']
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_random_wake_up_answers,
sl._get_random_wake_up_answers(self.settings_dict))
del sl
def test_get_stts(self):
stt = Stt(name="google", parameters={'language': 'fr-FR'})
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual([stt], sl._get_stts(self.settings_dict))
del sl
def test_get_default_trigger(self):
expected_default_trigger = "snowboy"
sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
self.assertEqual(expected_default_trigger,
sl._get_default_trigger(self.settings_dict))
del sl
