def __init__(self):
self.bus = WebsocketClient()
Configuration.init(self.bus)
global_config = Configuration.get()
self.lang = global_config['lang']
self.config = global_config.get("enclosure")
self.__init_serial()
self.reader = EnclosureReader(self.serial, self.bus, self.lang)
self.writer = EnclosureWriter(self.serial, self.bus)
# Prepare to receive message when the Arduino responds to the
# following "system.version"
self.bus.on("enclosure.started", self.on_arduino_responded)
self.arduino_responded = False
# Send a message to the Arduino across the serial line asking
# for a reply with version info.
self.writer.write("system.version")
# Start a 5 second timer. If the serial port hasn't received
# any acknowledgement of the "system.version" within those
# 5 seconds, assume there is nothing on the other end (e.g.
# we aren't running a Mark 1 with an Arduino)
Timer(5, self.check_for_response).start()
# Notifications from OwO-core
self.bus.on("enclosure.notify.no_internet", self.on_no_internet)
# initiates the web sockets on display manager
# NOTE: this is a temporary place to connect the display manager
init_display_manager_bus_connection()
def __init__(self, key_phrase="hey OwO", config=None, lang="en-us"):
self.key_phrase = str(key_phrase).lower()
# rough estimate 1 phoneme per 2 chars
self.num_phonemes = len(key_phrase) / 2 + 1
if config is None:
config = Configuration.get().get("hot_words", {})
config = config.get(self.key_phrase, {})
self.config = config
self.listener_config = Configuration.get().get("listener", {})
self.lang = str(self.config.get("lang", lang)).lower()
def handle_speak(event):
"""
Handle "speak" message
"""
config = Configuration.get()
Configuration.init(bus)
global _last_stop_signal
# Get conversation ID
if event.context and 'ident' in event.context:
ident = event.context['ident']
else:
ident = 'unknown'
with lock:
stopwatch = Stopwatch()
stopwatch.start()
utterance = event.data['utterance']
if event.data.get('expect_response', False):
# When expect_response is requested, the listener will be restarted
# at the end of the next bit of spoken audio.
bus.once('recognizer_loop:audio_output_end', _start_listener)
# This is a bit of a hack for Picroft. The analog audio on a Pi blocks
# for 30 seconds fairly often, so we don't want to break on periods
# (decreasing the chance of encountering the block). But we will
# keep the split for non-Picroft installs since it give user feedback
# faster on longer phrases.
#
# TODO: Remove or make an option? This is really a hack, anyway,
# so we likely will want to get rid of this when not running on Mimic
if (config.get('enclosure', {}).get('platform') != "picroft"
and len(re.findall('<[^>]*>', utterance)) == 0):
start = time.time()
chunks = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s',
utterance)
for chunk in chunks:
try:
mute_and_speak(chunk, ident)
except KeyboardInterrupt:
raise
except Exception:
LOG.error('Error in mute_and_speak', exc_info=True)
if (_last_stop_signal > start
or check_for_signal('buttonPress')):
break
else:
mute_and_speak(utterance, ident)
stopwatch.stop()
report_timing(ident, 'speech', stopwatch, {
'utterance': utterance,
'tts': tts.__class__.__name__
})
def get(phrase, lang=None, context=None):
"""
Looks up a resource file for the given phrase. If no file
is found, the requested phrase is returned as the string.
This will use the default language for translations.
Args:
phrase (str): resource phrase to retrieve/translate
lang (str): the language to use
context (dict): values to be inserted into the string
Returns:
str: a randomized and/or translated version of the phrase
"""
if not lang:
from owo.configuration import Configuration
lang = Configuration.get().get("lang")
filename = "text/" + lang.lower() + "/" + phrase + ".dialog"
template = resolve_resource_file(filename)
if not template:
LOG.debug("Resource file not found: " + filename)
return phrase
stache = MustacheDialogRenderer()
stache.load_template_file("template", template)
if not context:
context = {}
return stache.render("template", context)
def __init__(self, wake_word_recognizer):
self.config = Configuration.get()
listener_config = self.config.get('listener')
self.upload_url = listener_config['wake_word_upload']['url']
self.upload_disabled = listener_config['wake_word_upload']['disable']
self.wake_word_name = wake_word_recognizer.key_phrase
self.overflow_exc = listener_config.get('overflow_exception', False)
speech_recognition.Recognizer.__init__(self)
self.wake_word_recognizer = wake_word_recognizer
self.audio = pyaudio.PyAudio()
self.multiplier = listener_config.get('multiplier')
self.energy_ratio = listener_config.get('energy_ratio')
# check the config for the flag to save wake words.
self.save_utterances = listener_config.get('record_utterances', False)
self.upload_lock = Lock()
self.filenames_to_upload = []
self.mic_level_file = os.path.join(get_ipc_directory(), "mic_level")
self._stop_signaled = False
# The maximum audio in seconds to keep for transcribing a phrase
# The wake word must fit in this time
num_phonemes = wake_word_recognizer.num_phonemes
len_phoneme = listener_config.get('phoneme_duration', 120) / 1000.0
self.TEST_WW_SEC = num_phonemes * len_phoneme
self.SAVED_WW_SEC = max(3, self.TEST_WW_SEC)
try:
self.account_id = DeviceApi().get()['user']['uuid']
except (requests.RequestException, AttributeError):
self.account_id = '0'
def main():
import tornado.options
reset_sigint_handler()
lock = Lock("service")
tornado.options.parse_command_line()
def reload_hook():
""" Hook to release lock when autoreload is triggered. """
lock.delete()
autoreload.add_reload_hook(reload_hook)
config = Configuration.get().get("websocket")
host = config.get("host")
port = config.get("port")
route = config.get("route")
validate_param(host, "websocket.host")
validate_param(port, "websocket.port")
validate_param(route, "websocket.route")
routes = [(route, WebsocketEventHandler)]
application = web.Application(routes, **settings)
application.listen(port, host)
create_daemon(ioloop.IOLoop.instance().start)
wait_for_exit_signal()
def run(self):
""" Load skills and update periodically from disk and internet """
self.remove_git_locks()
self._connected_event.wait()
has_loaded = False
# check if skill updates are enabled
update = Configuration.get()["skills"]["auto_update"]
# Scan the file folder that contains Skills. If a Skill is updated,
# unload the existing version from memory and reload from the disk.
while not self._stop_event.is_set():
# Update skills once an hour if update is enabled
if time.time() >= self.next_download and update:
self.download_skills()
# Look for recently changed skill(s) needing a reload
# checking skills dir and getting all skills there
skill_paths = glob(join(self.msm.skills_dir, '*/'))
still_loading = False
for skill_path in skill_paths:
still_loading = (self._load_or_reload_skill(skill_path)
or still_loading)
if not has_loaded and not still_loading and len(skill_paths) > 0:
has_loaded = True
self.bus.emit(Message('owo.skills.initialized'))
self._unload_removed(skill_paths)
# Pause briefly before beginning next scan
time.sleep(2)
def main():
global bus
reset_sigint_handler()
# Create PID file, prevent multiple instancesof this service
owo.lock.Lock('skills')
# Connect this Skill management process to the OwO Messagebus
bus = WebsocketClient()
Configuration.init(bus)
bus.on('message', create_echo_function('SKILLS'))
# Startup will be called after the connection with the Messagebus is done
bus.once('open', _starting_up)
create_daemon(bus.run_forever)
wait_for_exit_signal()
shutdown()
def __init__(self, bus):
super(SkillManager, self).__init__()
self._stop_event = Event()
self._connected_event = Event()
self.loaded_skills = {}
self.bus = bus
self.enclosure = EnclosureAPI(bus)
# Schedule install/update of default skill
self.msm = self.create_msm()
self.num_install_retries = 0
self.update_interval = Configuration.get()['skills']['update_interval']
self.update_interval = int(self.update_interval * 60 * MINUTES)
self.dot_msm = join(self.msm.skills_dir, '.msm')
if exists(self.dot_msm):
self.next_download = os.path.getmtime(self.dot_msm) + \
self.update_interval
else:
self.next_download = time.time() - 1
# Conversation management
bus.on('skill.converse.request', self.handle_converse_request)
# Update on initial connection
bus.on('owo.internet.connected', lambda x: self._connected_event.set())
# Update upon request
bus.on('skillmanager.update', self.schedule_now)
bus.on('skillmanager.list', self.send_skill_list)
bus.on('skillmanager.deactivate', self.deactivate_skill)
bus.on('skillmanager.keep', self.deactivate_except)
bus.on('skillmanager.activate', self.activate_skill)
def __init__(self):
config_core = Configuration.get()
self.lang = str(self.init_language(config_core))
config_stt = config_core.get("stt", {})
self.config = config_stt.get(config_stt.get("module"), {})
self.credential = self.config.get("credential", {})
self.recognizer = Recognizer()
def __init__(self, bus):
self.config = Configuration.get().get('context', {})
self.engine = IntentDeterminationEngine()
# Dictionary for translating a skill id to a name
self.skill_names = {}
# Context related intializations
self.context_keywords = self.config.get('keywords', [])
self.context_max_frames = self.config.get('max_frames', 3)
self.context_timeout = self.config.get('timeout', 2)
self.context_greedy = self.config.get('greedy', False)
self.context_manager = ContextManager(self.context_timeout)
self.bus = bus
self.bus.on('register_vocab', self.handle_register_vocab)
self.bus.on('register_intent', self.handle_register_intent)
self.bus.on('recognizer_loop:utterance', self.handle_utterance)
self.bus.on('detach_intent', self.handle_detach_intent)
self.bus.on('detach_skill', self.handle_detach_skill)
# Context related handlers
self.bus.on('add_context', self.handle_add_context)
self.bus.on('remove_context', self.handle_remove_context)
self.bus.on('clear_context', self.handle_clear_context)
# Converse method
self.bus.on('skill.converse.response', self.handle_converse_response)
self.bus.on('owo.speech.recognition.unknown', self.reset_converse)
self.bus.on('owo.skills.loaded', self.update_skill_name_dict)
def add_active_skill_handler(message):
self.add_active_skill(message.data['skill_id'])
self.bus.on('active_skill_request', add_active_skill_handler)
self.active_skills = [] # [skill_id , timestamp]
self.converse_timeout = 5 # minutes to prune active_skills
def __init__(self, bus, schedule_file='schedule.json'):
"""
Create an event scheduler thread. Will send messages at a
predetermined time to the registered targets.
Args:
bus: OwO messagebus (owo.messagebus)
schedule_file: File to store pending events to on shutdown
"""
super(EventScheduler, self).__init__()
data_dir = expanduser(Configuration.get()['data_dir'])
self.events = {}
self.event_lock = Lock()
self.bus = bus
self.isRunning = True
self.schedule_file = join(data_dir, schedule_file)
if self.schedule_file:
self.load()
self.bus.on('owo.scheduler.schedule_event',
self.schedule_event_handler)
self.bus.on('owo.scheduler.remove_event', self.remove_event_handler)
self.bus.on('owo.scheduler.update_event', self.update_event_handler)
self.bus.on('owo.scheduler.get_event', self.get_event_handler)
self.start()
def __init__(self, bus, service):
FallbackSkill.__init__(self)
if not PadatiousService.instance:
PadatiousService.instance = self
self.config = Configuration.get()['padatious']
self.service = service
intent_cache = expanduser(self.config['intent_cache'])
try:
from padatious import IntentContainer
except ImportError:
LOG.error('Padatious not installed. Please re-run dev_setup.sh')
try:
call([
'notify-send', 'Padatious not installed',
'Please run build_host_setup and dev_setup again'
])
except OSError:
pass
return
self.container = IntentContainer(intent_cache)
self.bus = bus
self.bus.on('padatious:register_intent', self.register_intent)
self.bus.on('padatious:register_entity', self.register_entity)
self.bus.on('detach_intent', self.handle_detach_intent)
self.bus.on('owo.skills.initialized', self.train)
self.register_fallback(self.handle_fallback, 5)
self.finished_training_event = Event()
self.finished_initial_train = False
self.train_delay = self.config['train_delay']
self.train_time = get_time() + self.train_delay
def main():
""" Main function. Run when file is invoked. """
reset_sigint_handler()
check_for_signal("isSpeaking")
bus = WebsocketClient() # Connect to the OwO Messagebus
Configuration.init(bus)
speech.init(bus)
LOG.info("Starting Audio Services")
bus.on('message', create_echo_function('AUDIO', ['owo.audio.service']))
audio = AudioService(bus) # Connect audio service instance to message bus
create_daemon(bus.run_forever)
wait_for_exit_signal()
speech.shutdown()
audio.shutdown()
def validate_connection(self):
config = Configuration.get().get("tts", {}).get("watson", {})
user = config.get("user") or config.get("username")
password = config.get("password")
if user and password:
return
else:
raise ValueError('user and/or password for IBM tts is not defined')
def __init__(self, lang, config):
super(BingTTS, self).__init__(lang, config, BingTTSValidator(self))
self.type = 'wav'
from bingtts import Translator
self.config = Configuration.get().get("tts", {}).get("bing", {})
api = self.config.get("api_key")
self.bing = Translator(api)
self.gender = self.config.get("gender", "Male")
self.format = self.config.get("format", "riff-16khz-16bit-mono-pcm")
def get():
data_dir = expanduser(Configuration.get()['data_dir'])
version_file = join(data_dir, 'version.json')
if exists(version_file) and isfile(version_file):
try:
with open(version_file) as f:
return json.load(f)
except Exception:
LOG.error("Failed to load version from '%s'" % version_file)
return {"coreVersion": None, "enclosureVersion": None}
def __init__(self, path):
self.path = path
# Load the config, skipping the REMOTE_CONFIG since we are
# getting the info needed to get to it!
config = Configuration.get(
[DEFAULT_CONFIG, SYSTEM_CONFIG, USER_CONFIG], cache=False)
config_server = config.get("server")
self.url = config_server.get("url")
self.version = config_server.get("version")
self.identity = IdentityManager.get()
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
if self._config_hash != hash(str(Configuration().get())):
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
raise # Re-raise KeyboardInterrupt
def create_msm():
config = Configuration.get()
msm_config = config['skills']['msm']
repo_config = msm_config['repo']
data_dir = expanduser(config['data_dir'])
skills_dir = join(data_dir, msm_config['directory'])
repo_cache = join(data_dir, repo_config['cache'])
platform = config['enclosure'].get('platform', 'default')
return OwOSkillsManager(platform=platform,
skills_dir=skills_dir,
repo=SkillRepo(repo_cache, repo_config['url'],
repo_config['branch']),
versioned=msm_config['versioned'])
def create_hotword(cls,
hotword="hey OwO",
config=None,
lang="en-us",
loop=None):
if not config:
config = Configuration.get()['hotwords']
config = config[hotword]
module = config.get("module", "pocketsphinx")
return cls.load_module(module, hotword, config, lang, loop) or \
cls.load_module('pocketsphinx', hotword, config, lang, loop) or \
cls.CLASSES['pocketsphinx']()
def init(messagebus):
""" Start speech related handlers.
Arguments:
messagebus: Connection to the OwO messagebus
"""
global bus
global tts
global tts_hash
global config
bus = messagebus
Configuration.init(bus)
config = Configuration.get()
bus.on('owo.stop', handle_stop)
bus.on('owo.audio.speech.stop', handle_stop)
bus.on('speak', handle_speak)
bus.on('owo.mic.listen', _start_listener)
tts = TTSFactory.create()
tts.init(bus)
tts_hash = config.get('tts')
def report_metric(name, data):
"""
Report a general metric to the OwO servers
Args:
name (str): Name of metric. Must use only letters and hyphens
data (dict): JSON dictionary to report. Must be valid JSON
"""
try:
if is_paired() and Configuration().get()['opt_in']:
DeviceApi().report_metric(name, data)
except requests.RequestException as e:
LOG.error(
'Metric couldn\'t be uploaded, due to a network error ({})'.format(
e))
def main():
global bus
global loop
reset_sigint_handler()
PIDLock("voice")
bus = WebsocketClient() # OwO messagebus, see owo.messagebus
Configuration.init(bus)
# Register handlers on internal RecognizerLoop bus
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:speech.recognition.unknown', handle_unknown)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:awoken', handle_awoken)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('recognizer_loop:no_internet', handle_no_internet)
# Register handlers for events on main OwO messagebus
bus.on('open', handle_open)
bus.on('complete_intent_failure', handle_complete_intent_failure)
bus.on('recognizer_loop:sleep', handle_sleep)
bus.on('recognizer_loop:wake_up', handle_wake_up)
bus.on('owo.mic.mute', handle_mic_mute)
bus.on('owo.mic.unmute', handle_mic_unmute)
bus.on('owo.mic.get_status', handle_mic_get_status)
bus.on("owo.paired", handle_paired)
bus.on('recognizer_loop:audio_output_start', handle_audio_start)
bus.on('recognizer_loop:audio_output_end', handle_audio_end)
bus.on('owo.stop', handle_stop)
create_daemon(bus.run_forever)
create_daemon(loop.run)
wait_for_exit_signal()
def __init__(self, key_phrase="hey OwO", config=None, lang="en-us"):
super(PreciseHotword, self).__init__(key_phrase, config, lang)
from precise_runner import (PreciseRunner, PreciseEngine,
ReadWriteStream)
local_conf = LocalConf(USER_CONFIG)
if local_conf.get('precise', {}).get('dist_url') == \
'http://bootstrap.owo.ai/artifacts/static/daily/':
del local_conf['precise']['dist_url']
local_conf.store()
Configuration.updated(None)
self.download_complete = True
self.show_download_progress = Timer(0, lambda: None)
precise_config = Configuration.get()['precise']
precise_exe = self.install_exe(precise_config['dist_url'])
local_model = self.config.get('local_model_file')
if local_model:
self.precise_model = expanduser(local_model)
else:
self.precise_model = self.install_model(
precise_config['model_url'],
key_phrase.replace(' ', '-')).replace('.tar.gz', '.pb')
self.has_found = False
self.stream = ReadWriteStream()
def on_activation():
self.has_found = True
self.runner = PreciseRunner(PreciseEngine(precise_exe,
self.precise_model),
stream=self.stream,
on_activation=on_activation)
self.runner.start()
def get():
"""
get the active session.
:return: An active session
"""
config = Configuration.get().get('session')
with SessionManager.__lock:
if (not SessionManager.__current_session
or SessionManager.__current_session.expired()):
SessionManager.__current_session = Session(
str(uuid4()), expiration_seconds=config.get('ttl', 180))
LOG.info("New Session Start: " +
SessionManager.__current_session.session_id)
return SessionManager.__current_session
def __init__(self, host=None, port=None, route=None, ssl=None):
config = Configuration.get().get("websocket")
host = host or config.get("host")
port = port or config.get("port")
route = route or config.get("route")
ssl = ssl or config.get("ssl")
validate_param(host, "websocket.host")
validate_param(port, "websocket.port")
validate_param(route, "websocket.route")
self.url = WebsocketClient.build_url(host, port, route, ssl)
self.emitter = EventEmitter()
self.client = self.create_client()
self.pool = ThreadPool(10)
self.retry = 5
self.connected_event = Event()
self.started_running = False
def __init__(self, name=None, bus=None):
self.name = name or self.__class__.__name__
# Get directory of skill
self._dir = dirname(abspath(sys.modules[self.__module__].__file__))
self.settings = SkillSettings(self._dir, self.name)
self.bus = None
self.bind(bus)
self.config_core = Configuration.get()
self.config = self.config_core.get(self.name) or {}
self.dialog_renderer = None
self.root_dir = None
self.file_system = FileSystemAccess(join('skills', self.name))
self.registered_intents = []
self.log = LOG.create_logger(self.name)
self.reload_skill = True # allow reloading
self.events = []
self.scheduled_repeats = []
self.skill_id = '' # will be set from the path, so guaranteed unique
self.voc_match_cache = {}
def create():
"""
Factory method to create a TTS engine based on configuration.
The configuration file ``owo.conf`` contains a ``tts`` section with
the name of a TTS module to be read by this method.
"tts": {
"module": <engine_name>
}
"""
config = Configuration.get()
lang = config.get("lang", "en-us")
tts_module = config.get('tts', {}).get('module', 'mimic')
tts_config = config.get('tts', {}).get(tts_module, {})
tts_lang = tts_config.get('lang', lang)
clazz = TTSFactory.CLASSES.get(tts_module)
tts = clazz(tts_lang, tts_config)
tts.validator.validate()
return tts
def __init__(self, bus):
"""
Args:
bus: OwO messagebus
"""
self.bus = bus
self.config = Configuration.get().get("Audio")
self.service_lock = Lock()
self.default = None
self.service = []
self.current = None
self.volume_is_low = False
self.pulse = None
self.pulse_quiet = None
self.pulse_restore = None
self.muted_sinks = []
# Setup control of pulse audio
self.setup_pulseaudio_handlers(self.config.get('pulseaudio'))
bus.once('open', self.load_services_callback)
