def mute_and_speak(utterance):
"""
Mute mic and start speaking the utterance using selected tts backend.
Args:
utterance: The sentence to be spoken
"""
global tts_hash
lock.acquire()
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
LOG.info("Speak: " + utterance)
try:
tts.execute(utterance)
finally:
lock.release()
def mute_and_speak(utterance):
"""
Mute mic and start speaking the utterance using selected tts backend.
Args:
utterance: The sentence to be spoken
"""
global tts_hash
lock.acquire()
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
logger.info("Speak: " + utterance)
try:
tts.execute(utterance)
finally:
lock.release()
def mute_and_speak(utterance, ident):
"""
Mute mic and start speaking the utterance using selected tts backend.
Args:
utterance: The sentence to be spoken
ident: Ident tying the utterance to the source query
"""
global tts_hash
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(bus)
tts_hash = hash(str(config.get('tts', '')))
LOG.info("Speak: " + utterance)
try:
tts.execute(utterance, ident)
except RemoteTTSTimeoutException as e:
LOG.error(e)
mimic_fallback_tts(utterance, ident)
except Exception as e:
LOG.error('TTS execution failed ({})'.format(repr(e)))
def mute_and_speak(utterance, ident, listen=False):
"""Mute mic and start speaking the utterance using selected tts backend.
Arguments:
utterance: The sentence to be spoken
ident: Ident tying the utterance to the source query
"""
global tts_hash
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(bus)
tts_hash = hash(str(config.get('tts', '')))
LOG.info("Speak: " + utterance)
try:
tts.execute(utterance, ident, listen)
except RemoteTTSException as e:
LOG.error(e)
mimic_fallback_tts(utterance, ident, listen)
except Exception:
LOG.exception('TTS execution failed.')
def main():
global ws
global loop
global config
global tts
global tts_hash
lock = PIDLock("voice")
ws = WebsocketClient()
config = ConfigurationManager.get()
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
ConfigurationManager.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:no_internet', handle_no_internet)
ws.on('open', handle_open)
ws.on('speak', handle_speak)
ws.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.mic.mute', handle_mic_mute)
ws.on('mycroft.mic.unmute', handle_mic_unmute)
ws.on('mycroft.stop', handle_stop)
ws.on("mycroft.paired", handle_paired)
ws.on('recognizer_loop:audio_output_start', handle_audio_start)
ws.on('recognizer_loop:audio_output_end', handle_audio_end)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
loop.run()
except KeyboardInterrupt, e:
tts.playback.stop()
tts.playback.join()
logger.exception(e)
sys.exit()
def main():
global ws
global loop
global config
global tts
global tts_hash
lock = PIDLock("voice")
ws = WebsocketClient()
config = ConfigurationManager.get()
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
ConfigurationManager.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:no_internet', handle_no_internet)
ws.on('open', handle_open)
ws.on('speak', handle_speak)
ws.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.mic.mute', handle_mic_mute)
ws.on('mycroft.mic.unmute', handle_mic_unmute)
ws.on('mycroft.stop', handle_stop)
ws.on("mycroft.paired", handle_paired)
ws.on('recognizer_loop:audio_output_start', handle_audio_start)
ws.on('recognizer_loop:audio_output_end', handle_audio_end)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
loop.run()
except KeyboardInterrupt, e:
tts.playback.stop()
tts.playback.join()
logger.exception(e)
sys.exit()
def init(websocket):
"""
Start speach related handlers
"""
global ws
global tts
global tts_hash
global config
ws = websocket
ConfigurationManager.init(ws)
config = ConfigurationManager.get()
ws.on('mycroft.stop', handle_stop)
ws.on('speak', handle_speak)
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
def start_tts(utterance):
"""
Begin speaking in another thread to redirect output
Otherwise, the CLI get's polluted with text to speech debug
"""
global tts
mutex.acquire()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_start"))
try:
if not tts:
tts = TTSFactory.create()
tts.init(ws)
tts.execute(utterance)
finally:
mutex.release()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_end"))
def init(websocket):
"""
Start speach related handlers
"""
global ws
global tts
global tts_hash
global config
ws = websocket
ConfigurationManager.init(ws)
config = ConfigurationManager.get()
ws.on('mycroft.stop', handle_stop)
ws.on('mycroft.audio.speech.stop', handle_stop)
ws.on('speak', handle_speak)
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
def mute_and_speak(utterance):
global tts_hash
lock.acquire()
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
logger.info("Speak: " + utterance)
try:
tts.execute(utterance)
finally:
lock.release()
def mute_and_speak(utterance):
global tts_hash
lock.acquire()
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
logger.info("Speak: " + utterance)
try:
tts.execute(utterance)
finally:
lock.release()
def init(websocket):
"""
Start speach related handlers
"""
global ws
global tts
global tts_hash
global config
ws = websocket
Configuration.init(ws)
config = Configuration.get()
ws.on('mycroft.stop', handle_stop)
ws.on('mycroft.audio.speech.stop', handle_stop)
ws.on('speak', handle_speak)
ws.on('mycroft.mic.listen', _start_listener)
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
def init(messagebus):
"""Start speech related handlers.
Arguments:
messagebus: Connection to the Mycroft messagebus
"""
global bus
global tts
global tts_hash
global config
bus = messagebus
Configuration.set_config_update_handlers(bus)
config = Configuration.get()
bus.on('mycroft.stop', handle_stop)
bus.on('mycroft.audio.speech.stop', handle_stop)
bus.on('speak', handle_speak)
tts = TTSFactory.create()
tts.init(bus)
tts_hash = hash(str(config.get('tts', '')))
def handle_speak(event):
global chat
global tts
mutex.acquire()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_start"))
try:
utterance = event.data.get('utterance')
if bSimple:
print(">> " + utterance)
else:
chat.append(">> " + utterance)
draw_screen()
if not bQuiet:
if not tts:
tts = TTSFactory.create()
tts.init(ws)
tts.execute(utterance)
finally:
mutex.release()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_end"))
def handle_speak(event):
global chat
global tts
mutex.acquire()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_start"))
try:
utterance = event.data.get('utterance')
if bSimple:
print(">> " + utterance)
else:
chat.append(">> " + utterance)
draw_screen()
if not bQuiet:
if not tts:
tts = TTSFactory.create()
tts.init(ws)
tts.execute(utterance)
finally:
mutex.release()
if not bQuiet:
ws.emit(Message("recognizer_loop:audio_output_end"))
def mute_and_speak(utterance):
global tts_hash
global tts
lock.acquire()
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
ws.emit(Message("recognizer_loop:audio_output_start"))
already_muted = loop.is_muted()
try:
logger.info("Speak: " + utterance)
if not already_muted:
loop.mute() # only mute if necessary
tts.execute(utterance)
finally:
if not already_muted:
loop.unmute() # restore
lock.release()
ws.emit(Message("recognizer_loop:audio_output_end"))
def init(messagebus):
""" Start speech related handlers.
Arguments:
messagebus: Connection to the Mycroft messagebus
"""
global bus
global tts
global tts_hash
global config
bus = messagebus
Configuration.init(bus)
config = Configuration.get()
bus.on('mycroft.stop', handle_stop)
bus.on('mycroft.audio.speech.stop', handle_stop)
bus.on('speak', handle_speak)
bus.on('mycroft.mic.listen', _start_listener)
tts = TTSFactory.create()
tts.init(bus)
tts_hash = config.get('tts')
def init(messagebus):
""" Start speech related handlers.
Arguments:
messagebus: Connection to the Mycroft messagebus
"""
global bus
global tts
global tts_hash
global config
bus = messagebus
Configuration.init(bus)
config = Configuration.get()
bus.on('mycroft.stop', handle_stop)
bus.on('mycroft.audio.speech.stop', handle_stop)
bus.on('speak', handle_speak)
bus.on('mycroft.mic.listen', _start_listener)
tts = TTSFactory.create()
tts.init(bus)
tts_hash = config.get('tts')
def mute_and_speak(utterance, ident):
"""
Mute mic and start speaking the utterance using selected tts backend.
Args:
utterance: The sentence to be spoken
ident: Ident tying the utterance to the source query
"""
global tts_hash
# update TTS object if configuration has changed
if tts_hash != hash(str(config.get('tts', ''))):
global tts
# Stop tts playback thread
tts.playback.stop()
tts.playback.join()
# Create new tts instance
tts = TTSFactory.create()
tts.init(ws)
tts_hash = hash(str(config.get('tts', '')))
LOG.info("Speak: " + utterance)
tts.execute(utterance, ident)
import sys
from threading import Thread, Lock
from mycroft.client.enclosure.api import EnclosureAPI
from mycroft.client.speech.listener import RecognizerLoop
from mycroft.configuration import ConfigurationManager
from mycroft.identity import IdentityManager
from mycroft.messagebus.client.ws import WebsocketClient
from mycroft.messagebus.message import Message
from mycroft.tts import TTSFactory
from mycroft.util import kill
from mycroft.util.log import getLogger
logger = getLogger("SpeechClient")
ws = None
tts = TTSFactory.create()
lock = Lock()
loop = None
config = ConfigurationManager.get()
def handle_record_begin():
logger.info("Begin Recording...")
ws.emit(Message('recognizer_loop:record_begin'))
def handle_record_end():
logger.info("End Recording...")
ws.emit(Message('recognizer_loop:record_end'))
import sys
from threading import Thread, Lock
from mycroft.client.enclosure.api import EnclosureAPI
from mycroft.client.speech.listener import RecognizerLoop
from mycroft.configuration import ConfigurationManager
from mycroft.identity import IdentityManager
from mycroft.messagebus.client.ws import WebsocketClient
from mycroft.messagebus.message import Message
from mycroft.tts import TTSFactory
from mycroft.util import kill
from mycroft.util.log import getLogger
logger = getLogger("SpeechClient")
ws = None
tts = TTSFactory.create()
lock = Lock()
loop = None
config = ConfigurationManager.get()
def handle_record_begin():
logger.info("Begin Recording...")
ws.emit(Message('recognizer_loop:record_begin'))
def handle_record_end():
logger.info("End Recording...")
ws.emit(Message('recognizer_loop:record_end'))
def get_tts():
return TTSFactory.create()