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()
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(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. 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): 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) # # 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(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(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 """ 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()
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(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): # 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()