def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = Configuration.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
device_name = self.config.get('device_name')
if not device_index and device_name:
device_index = find_input_device(device_name)
LOG.debug('Using microphone (None = default): ' + str(device_index))
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer)
self.state = RecognizerLoopState()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
LOG.info("*********loading configuration")
config = ConfigurationManager.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.wakeword_recognizer = self.create_wake_word_recognizer(
rate, self.lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, self.lang)
self.hot_word_engines = {}
self.create_hot_word_engines()
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, self.lang)
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer, self.hot_word_engines)
self.state = RecognizerLoopState()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self,
channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
self.microphone.CHANNELS = channels
self.ww_recognizer = wakeword_recognizer.create_recognizer(
samprate=sample_rate, lang=lang)
self.wakeup_recognizer = wakeword_recognizer.create_recognizer(
samprate=sample_rate, lang=lang,
keyphrase="wake up mycroft") # TODO - localization
self.remote_recognizer = Recognizer()
basedir = os.path.dirname(__file__)
self.wakeup_words = read_stripped_lines(
os.path.join(basedir, 'model', lang, 'WakeUpWord.voc'))
self.wakeup_prefixes = read_stripped_lines(
os.path.join(basedir, 'model', lang, 'PrefixWakeUp.voc'))
self.state = RecognizerLoopState()
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(
self.state, queue, self, self.wakeup_recognizer,
self.ww_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(
self.remote_recognizer), self.wakeup_prefixes,
self.wakeup_words).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
self.stop()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self, channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = LocalRecognizer(sample_rate, lang)
# TODO - localization
self.wakeup_recognizer = LocalRecognizer(sample_rate, lang, "wake up")
self.remote_recognizer = Recognizer()
self.state = RecognizerLoopState()
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state,
queue,
self.microphone,
self.remote_recognizer,
self).start()
AudioConsumer(self.state,
queue,
self,
self.wakeup_recognizer,
self.mycroft_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(
self.remote_recognizer)).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
logger.error(e)
self.stop()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self, channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate, device_index=device_index)
self.microphone.CHANNELS = channels
self.ww_recognizer = wakeword_recognizer.create_recognizer(samprate=sample_rate, lang=lang)
self.wakeup_recognizer = wakeword_recognizer.create_recognizer(samprate=sample_rate, lang=lang,
keyphrase="wake up mycroft") # TODO - localization
self.remote_recognizer = Recognizer()
basedir = os.path.dirname(__file__)
self.wakeup_words = read_stripped_lines(os.path.join(basedir, 'model', lang, 'WakeUpWord.voc'))
self.wakeup_prefixes = read_stripped_lines(os.path.join(basedir, 'model', lang, 'PrefixWakeUp.voc'))
self.state = RecognizerLoopState()
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state,
queue,
self.microphone,
self.remote_recognizer,
self).start()
AudioConsumer(self.state,
queue,
self,
self.wakeup_recognizer,
self.ww_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(self.remote_recognizer),
self.wakeup_prefixes,
self.wakeup_words).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
self.stop()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self,
channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = LocalRecognizer(sample_rate, lang)
# TODO - localization
self.wakeup_recognizer = LocalRecognizer(sample_rate, lang, "wake up")
self.remote_recognizer = Recognizer()
self.state = RecognizerLoopState()
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(
self.state, queue, self, self.wakeup_recognizer,
self.mycroft_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(
self.remote_recognizer)).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
logger.error(e)
self.stop()
def _load_config(self):
"""
Load configuration parameters from configuration and initialize
self.microphone, self.responsive_recognizer
"""
# self.config_core = self._init_config_core or Configuration.get()
self.config_core = Configuration.get()
self.config = self.config_core.get('listener')
self._config_hash = recognizer_conf_hash(self.config_core)
self.lang = self.config_core.get('lang')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index') or \
self.config.get("dev_index")
device_name = self.config.get('device_name')
if not device_index and device_name:
device_index = find_input_device(device_name)
LOG.debug('Using microphone (None = default): ' + str(device_index))
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
self.create_hotword_engines()
self.state = RecognizerLoopState()
self.responsive_recognizer = NeonResponsiveRecognizer(self)
def record(filename, duration):
mic = MutableMicrophone()
recognizer = Recognizer()
with mic as source:
audio = recognizer.record(source, duration=duration)
with open(filename, 'wb') as f:
f.write(audio.get_wav_data())
def __init__(self):
super(RecognizerLoop, self).__init__()
config = ConfigurationManager.get()
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def __init__(self,
channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = LocalRecognizer(sample_rate, lang)
# TODO - localization
self.wakeup_recognizer = LocalRecognizer(sample_rate, lang, "wake up")
self.remote_recognizer = Recognizer()
self.state = RecognizerLoopState()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = Configuration.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
device_name = self.config.get('device_name')
if not device_index and device_name:
device_index = find_input_device(device_name)
LOG.debug('Using microphone (None = default): '+str(device_index))
self.microphone = MutableMicrophone(device_index, rate,
mute=self.mute_calls > 0)
# TODO:19.02 - channels are not been used, remove from mycroft.conf
# and from code.
self.microphone.CHANNELS = self.config.get('channels')
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer)
self.state = RecognizerLoopState()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = ConfigurationManager.get()
self._config_hash = hash(str(config))
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def __init__(self,
channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
self.microphone.CHANNELS = channels
self.ww_recognizer = wakeword_recognizer.create_recognizer(
samprate=sample_rate, lang=lang)
self.wakeup_recognizer = wakeword_recognizer.create_recognizer(
samprate=sample_rate, lang=lang,
keyphrase="wake up mycroft") # TODO - localization
self.remote_recognizer = Recognizer()
basedir = os.path.dirname(__file__)
self.wakeup_words = read_stripped_lines(
os.path.join(basedir, 'model', lang, 'WakeUpWord.voc'))
self.wakeup_prefixes = read_stripped_lines(
os.path.join(basedir, 'model', lang, 'PrefixWakeUp.voc'))
self.state = RecognizerLoopState()
def __init__(self, channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = LocalRecognizer(sample_rate, lang)
# TODO - localization
self.wakeup_recognizer = LocalRecognizer(sample_rate, lang, "wake up")
self.remote_recognizer = Recognizer()
self.state = RecognizerLoopState()
def __init__(self, channels=int(speech_config.get('channels')),
sample_rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=sample_rate, device_index=device_index)
self.microphone.CHANNELS = channels
self.ww_recognizer = wakeword_recognizer.create_recognizer(samprate=sample_rate, lang=lang)
self.wakeup_recognizer = wakeword_recognizer.create_recognizer(samprate=sample_rate, lang=lang,
keyphrase="wake up mycroft") # TODO - localization
self.remote_recognizer = Recognizer()
basedir = os.path.dirname(__file__)
self.wakeup_words = read_stripped_lines(os.path.join(basedir, 'model', lang, 'WakeUpWord.voc'))
self.wakeup_prefixes = read_stripped_lines(os.path.join(basedir, 'model', lang, 'PrefixWakeUp.voc'))
self.state = RecognizerLoopState()
def __init__(self):
super(RecognizerLoop, self).__init__()
config = ConfigurationManager.get()
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = ConfigurationManager.get()
self._config_hash = hash(str(config))
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = ConfigurationManager.get()
self._config_hash = hash(str(config))
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def create_mycroft_recognizer(self, rate, lang):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
wake_word = self.config.get('wake_word')
phonemes = self.config.get('phonemes')
threshold = self.config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def create_wakeup_recognizer(self, rate, lang):
wake_word = self.config.get('standup_word', "wake up")
phonemes = self.config.get('standup_phonemes', "W EY K . AH P")
threshold = self.config.get('standup_threshold', 1e-10)
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
queue = Queue()
self.producer = AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self,
STTFactory.create(),
self.wakeup_recognizer,
self.mycroft_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
if self._config_hash != hash(str(
ConfigurationManager().get())):
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
def reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(EventEmitter):
""" EventEmitter loop running speech recognition.
Local wake word recognizer and remote general speech recognition.
Args:
watchdog: (callable) function to call periodically indicating
operational status.
"""
def __init__(self, watchdog=None):
super(RecognizerLoop, self).__init__()
self._watchdog = watchdog
self.mute_calls = 0
self._load_config()
def _load_config(self):
"""Load configuration parameters from configuration."""
config = Configuration.get()
self.config_core = config
self._config_hash = recognizer_conf_hash(config)
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
device_name = self.config.get('device_name')
if not device_index and device_name:
device_index = find_input_device(device_name)
LOG.debug('Using microphone (None = default): ' + str(device_index))
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer, self._watchdog)
self.state = RecognizerLoopState()
def create_wake_word_recognizer(self):
"""Create a local recognizer to hear the wakeup word
For example 'Hey Mycroft'.
The method uses the hotword entry for the selected wakeword, if
one is missing it will fall back to the old phoneme and threshold in
the listener entry in the config.
If the hotword entry doesn't include phoneme and threshold values these
will be patched in using the defaults from the config listnere entry.
"""
LOG.info('Creating wake word engine')
word = self.config.get('wake_word', 'hey mycroft')
# TODO remove this, only for server settings compatibility
phonemes = self.config.get('phonemes')
thresh = self.config.get('threshold')
# Since we're editing it for server backwards compatibility
# use a copy so we don't alter the hash of the config and
# trigger a reload.
config = deepcopy(self.config_core.get('hotwords', {}))
if word not in config:
# Fallback to using config from "listener" block
LOG.warning('Wakeword doesn\'t have an entry falling back'
'to old listener config')
config[word] = {'module': 'precise'}
if phonemes:
config[word]['phonemes'] = phonemes
if thresh:
config[word]['threshold'] = thresh
if phonemes is None or thresh is None:
config = None
else:
LOG.info('Using hotword entry for {}'.format(word))
if 'phonemes' not in config[word]:
LOG.warning('Phonemes are missing falling back to listeners '
'configuration')
config[word]['phonemes'] = phonemes
if 'threshold' not in config[word]:
LOG.warning('Threshold is missing falling back to listeners '
'configuration')
config[word]['threshold'] = thresh
return HotWordFactory.create_hotword(word,
config,
self.lang,
loop=self)
def create_wakeup_recognizer(self):
LOG.info("creating stand up word engine")
word = self.config.get("stand_up_word", "wake up")
return HotWordFactory.create_hotword(word, lang=self.lang, loop=self)
def start_async(self):
"""Start consumer and producer threads."""
self.state.running = True
stt = STTFactory.create()
queue = Queue()
stream_handler = None
if stt.can_stream:
stream_handler = AudioStreamHandler(queue)
self.producer = AudioProducer(self.state, queue, self.microphone,
self.responsive_recognizer, self,
stream_handler)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self, stt,
self.wakeup_recognizer,
self.wakeword_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
"""Mute microphone and increase number of requests to mute."""
self.mute_calls += 1
if self.microphone:
self.microphone.mute()
def unmute(self):
"""Unmute mic if as many unmute calls as mute calls have been received.
"""
if self.mute_calls > 0:
self.mute_calls -= 1
if self.mute_calls <= 0 and self.microphone:
self.microphone.unmute()
self.mute_calls = 0
def force_unmute(self):
"""Completely unmute mic regardless of the number of calls to mute."""
self.mute_calls = 0
self.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
"""Start and reload mic and STT handling threads as needed.
Wait for KeyboardInterrupt and shutdown cleanly.
"""
try:
self.start_async()
except Exception:
LOG.exception('Starting producer/consumer threads for listener '
'failed.')
return
# Handle reload of consumer / producer if config changes
while self.state.running:
try:
time.sleep(1)
current_hash = recognizer_conf_hash(Configuration().get())
if current_hash != self._config_hash:
self._config_hash = current_hash
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
raise # Re-raise KeyboardInterrupt
except Exception:
LOG.exception('Exception in RecognizerLoop')
raise
def reload(self):
"""Reload configuration and restart consumer and producer."""
self.stop()
self.wakeword_recognizer.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self.mute_calls = 0
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = Configuration.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer)
self.state = RecognizerLoopState()
def create_wake_word_recognizer(self):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
LOG.info("creating wake word engine")
word = self.config.get("wake_word", "hey mycroft")
# TODO remove this, only for server settings compatibility
phonemes = self.config.get("phonemes")
thresh = self.config.get("threshold")
config = self.config_core.get("hotwords", {word: {}})
if word not in config:
config[word] = {'module': 'pocketsphinx'}
if phonemes:
config[word]["phonemes"] = phonemes
if thresh:
config[word]["threshold"] = thresh
if phonemes is None or thresh is None:
config = None
return HotWordFactory.create_hotword(word, config, self.lang)
def create_wakeup_recognizer(self):
LOG.info("creating stand up word engine")
word = self.config.get("stand_up_word", "wake up")
return HotWordFactory.create_hotword(word, lang=self.lang)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
queue = Queue()
self.producer = AudioProducer(self.state, queue, self.microphone,
self.responsive_recognizer, self)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self,
STTFactory.create(),
self.wakeup_recognizer,
self.wakeword_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
"""
Mute microphone and increase number of requests to mute
"""
self.mute_calls += 1
if self.microphone:
self.microphone.mute()
def unmute(self):
"""
Unmute mic if as many unmute calls as mute calls have been
received.
"""
if self.mute_calls > 0:
self.mute_calls -= 1
if self.mute_calls <= 0 and self.microphone:
self.microphone.unmute()
self.mute_calls = 0
def force_unmute(self):
"""
Completely unmute mic dispite the number of calls to mute
"""
self.mute_calls = 0
self.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
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 reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self,
channels=int(speech_config.get('channels')),
rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
@staticmethod
def create_mycroft_recognizer(rate, lang):
wake_word = listener_config.get('wake_word')
phonemes = listener_config.get('phonemes')
threshold = listener_config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
@staticmethod
def create_wakeup_recognizer(rate, lang):
return LocalRecognizer("wake up", "W EY K . AH P", "1e-10", rate, lang)
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(
self.state, queue, self, self.wakeup_recognizer,
self.mycroft_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(
self.remote_recognizer)).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
logger.error(e)
self.stop()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = ConfigurationManager.get()
self._config_hash = hash(str(config))
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def create_mycroft_recognizer(self, rate, lang):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
wake_word = self.config.get('wake_word')
phonemes = self.config.get('phonemes')
threshold = self.config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def create_wakeup_recognizer(self, rate, lang):
wake_word = self.config.get('standup_word', "wake up")
phonemes = self.config.get('standup_phonemes', "W EY K . AH P")
threshold = self.config.get('standup_threshold', 1e-10)
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
queue = Queue()
self.producer = AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self,
STTFactory.create(),
self.wakeup_recognizer,
self.mycroft_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
if self._config_hash != hash(str(ConfigurationManager()
.get())):
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
def reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self.mute_calls = 0
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = Configuration.get()
self.config_core = config
self._config_hash = recognizer_conf_hash(config)
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
device_name = self.config.get('device_name')
if not device_index and device_name:
device_index = find_input_device(device_name)
LOG.debug('Using microphone (None = default): ' + str(device_index))
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer)
self.state = RecognizerLoopState()
def create_wake_word_recognizer(self):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
LOG.info("creating wake word engine")
word = self.config.get("wake_word", "hey mycroft")
# TODO remove this, only for server settings compatibility
phonemes = self.config.get("phonemes")
thresh = self.config.get("threshold")
# Since we're editing it for server backwards compatibility
# use a copy so we don't alter the hash of the config and
# trigger a reload.
config = deepcopy(self.config_core.get("hotwords", {word: {}}))
if word not in config:
config[word] = {'module': 'precise'}
if phonemes:
config[word]["phonemes"] = phonemes
if thresh:
config[word]["threshold"] = thresh
if phonemes is None or thresh is None:
config = None
return HotWordFactory.create_hotword(word,
config,
self.lang,
loop=self)
def create_wakeup_recognizer(self):
LOG.info("creating stand up word engine")
word = self.config.get("stand_up_word", "wake up")
return HotWordFactory.create_hotword(word, lang=self.lang, loop=self)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
stt = STTFactory.create()
queue = Queue()
stream_handler = None
if stt.can_stream:
stream_handler = AudioStreamHandler(queue)
self.producer = AudioProducer(self.state, queue, self.microphone,
self.responsive_recognizer, self,
stream_handler)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self, stt,
self.wakeup_recognizer,
self.wakeword_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
"""
Mute microphone and increase number of requests to mute
"""
self.mute_calls += 1
if self.microphone:
self.microphone.mute()
def unmute(self):
"""
Unmute mic if as many unmute calls as mute calls have been
received.
"""
if self.mute_calls > 0:
self.mute_calls -= 1
if self.mute_calls <= 0 and self.microphone:
self.microphone.unmute()
self.mute_calls = 0
def force_unmute(self):
"""
Completely unmute mic regardless of the number of calls to mute
"""
self.mute_calls = 0
self.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
current_hash = recognizer_conf_hash(Configuration().get())
if current_hash != self._config_hash:
self._config_hash = current_hash
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
raise # Re-raise KeyboardInterrupt
def reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
self.wakeword_recognizer.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self.mute_calls = 0
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
config = ConfigurationManager.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate,
mute=self.mute_calls > 0)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.wakeword_recognizer = self.create_wake_word_recognizer()
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer()
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer)
self.state = RecognizerLoopState()
def create_wake_word_recognizer(self):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
LOG.info("creating wake word engine")
word = self.config.get("wake_word", "hey mycroft")
# TODO remove this, only for server settings compatibility
phonemes = self.config.get("phonemes")
thresh = self.config.get("threshold")
config = self.config_core.get("hotwords", {word: {}})
if word not in config:
config[word] = {}
if phonemes:
config[word]["phonemes"] = phonemes
if thresh:
config[word]["threshold"] = thresh
if phonemes is None or thresh is None:
config = None
return HotWordFactory.create_hotword(word, config, self.lang)
def create_wakeup_recognizer(self):
LOG.info("creating stand up word engine")
word = self.config.get("stand_up_word", "wake up")
return HotWordFactory.create_hotword(word, lang=self.lang)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
queue = Queue()
self.producer = AudioProducer(self.state, queue, self.microphone,
self.responsive_recognizer, self)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self,
STTFactory.create(),
self.wakeup_recognizer,
self.wakeword_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
"""
Mute microphone and increase number of requests to mute
"""
self.mute_calls += 1
if self.microphone:
self.microphone.mute()
def unmute(self):
"""
Unmute mic if as many unmute calls as mute calls have been
received.
"""
if self.mute_calls > 0:
self.mute_calls -= 1
if self.mute_calls <= 0 and self.microphone:
self.microphone.unmute()
self.mute_calls = 0
def force_unmute(self):
"""
Completely unmute mic dispite the number of calls to mute
"""
self.mute_calls = 0
self.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
if self._config_hash != hash(
str(ConfigurationManager().get())):
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
raise # Re-raise KeyboardInterrupt
def reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
# load config
self._load_config()
# restart
self.start_async()
class RecognizerLoop(EventEmitter):
def __init__(self):
super(RecognizerLoop, self).__init__()
config = ConfigurationManager.get()
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
#
# TODO:SSP On config change we need to rebuild these objects
#
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def create_mycroft_recognizer(self, rate, lang):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
wake_word = self.config.get('wake_word')
phonemes = self.config.get('phonemes')
threshold = self.config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def create_wakeup_recognizer(self, rate, lang):
wake_word = self.config.get('standup_word', "wake up")
phonemes = self.config.get('standup_phonemes', "W EY K . AH P")
threshold = self.config.get('standup_threshold', 1e-10)
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(self.state, queue, self, STTFactory.create(),
self.wakeup_recognizer, self.mycroft_recognizer).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
class RecognizerLoop(pyee.EventEmitter):
def __init__(self, channels=int(speech_config.get('channels')),
rate=int(speech_config.get('sample_rate')),
device_index=None,
lang=core_config.get('lang')):
pyee.EventEmitter.__init__(self)
self.microphone = MutableMicrophone(sample_rate=rate,
device_index=device_index)
# FIXME - channels are not been used
self.microphone.CHANNELS = channels
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
@staticmethod
def create_mycroft_recognizer(rate, lang):
wake_word = listener_config.get('wake_word')
phonemes = listener_config.get('phonemes')
threshold = listener_config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
@staticmethod
def create_wakeup_recognizer(rate, lang):
return LocalRecognizer("wake up", "W EY K . AH P", "1e-10", rate, lang)
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state,
queue,
self.microphone,
self.remote_recognizer,
self).start()
AudioConsumer(self.state,
queue,
self,
self.wakeup_recognizer,
self.mycroft_recognizer,
RemoteRecognizerWrapperFactory.wrap_recognizer(
self.remote_recognizer)).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
logger.error(e)
self.stop()
class RecognizerLoop(EventEmitter):
def __init__(self):
super(RecognizerLoop, self).__init__()
config = ConfigurationManager.get()
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def create_mycroft_recognizer(self, rate, lang):
wake_word = self.config.get('wake_word')
LOG.debug("Using wake word %s" % wake_word)
phonemes = self.config.get('phonemes')
threshold = self.config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
@staticmethod
def create_wakeup_recognizer(rate, lang):
return LocalRecognizer("wake up", "W EY K . AH P", 1e-10, rate, lang)
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(self.state, queue, self, STTFactory.create(),
self.wakeup_recognizer, self.mycroft_recognizer).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def muteListen(self):
self.remote_recognizer.is_wakeword_enabled = False
def unmuteListen(self):
self.remote_recognizer.is_wakeword_enabled = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
class RecognizerLoop(EventEmitter):
def __init__(self):
super(RecognizerLoop, self).__init__()
config = ConfigurationManager.get()
lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index, rate)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.mycroft_recognizer = self.create_mycroft_recognizer(rate, lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, lang)
self.remote_recognizer = ResponsiveRecognizer(self.mycroft_recognizer)
self.state = RecognizerLoopState()
def create_mycroft_recognizer(self, rate, lang):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
wake_word = self.config.get('wake_word')
phonemes = self.config.get('phonemes')
threshold = self.config.get('threshold')
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def create_wakeup_recognizer(self, rate, lang):
wake_word = self.config.get('standup_word', "wake up")
phonemes = self.config.get('standup_phonemes', "W EY K . AH P")
threshold = self.config.get('standup_threshold', 1e-10)
return LocalRecognizer(wake_word, phonemes, threshold, rate, lang)
def start_async(self):
self.state.running = True
queue = Queue()
AudioProducer(self.state, queue, self.microphone,
self.remote_recognizer, self).start()
AudioConsumer(self.state, queue, self, STTFactory.create(),
self.wakeup_recognizer, self.mycroft_recognizer).start()
def stop(self):
self.state.running = False
def mute(self):
if self.microphone:
self.microphone.mute()
def unmute(self):
if self.microphone:
self.microphone.unmute()
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
class RecognizerLoop(EventEmitter):
"""
EventEmitter loop running speech recognition. Local wake word
recognizer and remote general speech recognition.
"""
def __init__(self):
super(RecognizerLoop, self).__init__()
self.mute_calls = 0
self._load_config()
def _load_config(self):
"""
Load configuration parameters from configuration
"""
LOG.info("*********loading configuration")
config = ConfigurationManager.get()
self.config_core = config
self._config_hash = hash(str(config))
self.lang = config.get('lang')
self.config = config.get('listener')
rate = self.config.get('sample_rate')
device_index = self.config.get('device_index')
self.microphone = MutableMicrophone(device_index,
rate,
mute=self.mute_calls > 0)
# FIXME - channels are not been used
self.microphone.CHANNELS = self.config.get('channels')
self.wakeword_recognizer = self.create_wake_word_recognizer(
rate, self.lang)
# TODO - localization
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, self.lang)
self.hot_word_engines = {}
self.create_hot_word_engines()
self.wakeup_recognizer = self.create_wakeup_recognizer(rate, self.lang)
self.responsive_recognizer = ResponsiveRecognizer(
self.wakeword_recognizer, self.hot_word_engines)
self.state = RecognizerLoopState()
def create_hot_word_engines(self):
LOG.info(
"###############********creating hotword engines************************************************************************"
)
hot_words = self.config_core.get("hotwords", {})
for word in hot_words:
print("wake word creation for one word started:-" +
str(datetime.datetime.now()))
data = hot_words[word]
print(
"#######################xx***********************************found wake word************************************************************************"
)
#if not data.get("active", True):
#continue
engine_type = data["module"]
ding = data.get("sound")
utterance = data.get("utterance")
listen = data.get("listen", True)
# data = data["data"]
LOG.info("Creating hotword engine for " + word)
lang = self.config_core.get("lang", "en-us")
print("@@@@@@@@@@@ lang @@@@@@@@@@@@@@@@@@@@@", lang)
# rate = self.config.get("rate")
hot_word = data.get("hot_word")
print("@@@@@@@@@@@ hot_word @@@@@@@@@@@@@@@@@@@@@", hot_word)
phonemes = data.get('phonemes')
print("@@@@@@@@@@@ phonemes @@@@@@@@@@@@@@@@@@@@@", phonemes)
threshold = data.get('threshold')
engine = PocketsphinxRecognizer(hot_word, phonemes, threshold,
16000, lang)
print("wake word for one word finished:-" +
str(datetime.datetime.now()))
if engine is None:
print("engine is null!!!!!!")
self.hot_word_engines[word] = [
engine, ding, utterance, engine_type
]
def create_wake_word_recognizer(self, rate, lang):
# Create a local recognizer to hear the wakeup word, e.g. 'Hey Mycroft'
LOG.info("creating wake word engine")
word = self.config.get("wake_word", "hey mycroft")
# TODO remove this, only for server settings compatibility
phonemes = self.config.get("phonemes")
thresh = self.config.get("threshold")
config = self.config_core.get("hotwords", {word: {}})
if word not in config:
config[word] = {}
if phonemes:
config[word]["phonemes"] = phonemes
if thresh:
config[word]["threshold"] = thresh
if phonemes is None or thresh is None:
config = None
return HotWordFactory.create_hotword(word, config, self.lang)
def create_wakeup_recognizer(self, rate, lang):
LOG.info("creating stand up word engine")
word = self.config.get("stand_up_word", "wake up")
return HotWordFactory.create_hotword(word, lang=self.lang)
def start_async(self):
"""
Start consumer and producer threads
"""
self.state.running = True
queue = Queue()
self.producer = AudioProducer(self.state, queue, self.microphone,
self.responsive_recognizer, self)
self.producer.start()
self.consumer = AudioConsumer(self.state, queue, self,
STTFactory.create(),
self.wakeup_recognizer,
self.wakeword_recognizer)
self.consumer.start()
def stop(self):
self.state.running = False
self.producer.stop()
# wait for threads to shutdown
self.producer.join()
self.consumer.join()
def mute(self):
"""
Mute microphone and increase number of requests to mute
"""
self.mute_calls += 1
if self.microphone:
self.microphone.mute()
def unmute(self):
"""
Unmute mic if as many unmute calls as mute calls have been
received.
"""
if self.mute_calls > 0:
self.mute_calls -= 1
if self.mute_calls <= 0 and self.microphone:
self.microphone.unmute()
self.mute_calls = 0
def force_unmute(self):
"""
Completely unmute mic dispite the number of calls to mute
"""
self.mute_calls = 0
self.unmute()
def is_muted(self):
if self.microphone:
return self.microphone.is_muted()
else:
return True # consider 'no mic' muted
def sleep(self):
self.state.sleeping = True
def awaken(self):
self.state.sleeping = False
def run(self):
self.start_async()
while self.state.running:
try:
time.sleep(1)
if self._config_hash != hash(str(
ConfigurationManager().get())):
LOG.debug('Config has changed, reloading...')
self.reload()
except KeyboardInterrupt as e:
LOG.error(e)
self.stop()
raise # Re-raise KeyboardInterrupt
def reload(self):
"""
Reload configuration and restart consumer and producer
"""
self.stop()
# load config
self._load_config()
# restart
self.start_async()
