def connect(self, event=None): if event and event.data: ssid = event.data.get("ssid") connected = self.is_connected(ssid) if connected: LOG.warn("onyx is already connected to %s" % ssid) else: self.disconnect() LOG.info("Connecting to: %s" % ssid) nid = wpa(self.iface, 'add_network') wpa(self.iface, 'set_network', nid, 'ssid', '"' + ssid + '"') if event.data.__contains__("pass"): psk = '"' + event.data.get("pass") + '"' wpa(self.iface, 'set_network', nid, 'psk', psk) else: wpa(self.iface, 'set_network', nid, 'key_mgmt', 'NONE') wpa(self.iface, 'enable', nid) connected = self.get_connected(ssid) if connected: wpa(self.iface, 'save_config') self.ws.emit(Message("onyx.wifi.connected", {'connected': connected})) LOG.info("Connection status for %s = %s" % (ssid, connected)) if connected: self.ws.emit(Message("speak", { 'utterance': "Thank you, I'm now connected to the " "internet and ready for use"}))
def onConnected(event=None): print ("Sending message...") payload = { 'utterances': [result] } ws.emit(Message('onyx_recognizer:utterance', payload)) ws.emit(Message('onyx_detect_finish')) t.close()
def cli(): while True: try: time.sleep(1.5) result = input('You: ') print ("Sending message...") payload = { 'utterances': [result] } ws.emit(Message('onyx_recognizer:utterance', payload)) ws.emit(Message('speak', result)) except (KeyboardInterrupt, EOFError, SystemExit): break
def check_connection(): if connected(): ws.emit(Message('onyx.internet.connected')) else: thread = Timer(1, check_connection) thread.daemon = True thread.start()
def load_regex_from_file(path, emitter): if path.endswith('.rx'): with open(path, 'r') as reg_file: for line in reg_file.readlines(): re.compile(line.strip()) emitter.emit(Message("register_vocab", {'regex': line.strip()}))
def speak(self, utterance, lang): logger.info("Speak: " + utterance) self.emitter.emit( Message("speak", { 'utterance': utterance, 'lang': lang })) tts.lang = lang tts.execute(utterance)
def handle_utterance(self, message): lang = message.data.get('lang', None) if not lang: lang = "en-US" user = message.data.get('user', None) url = message.data.get('url', None) utterances = message.data.get('utterances', '') best_intent = None for utterance in utterances: try: # normalize() changes "it's a boy" to "it is boy" best_intent = next( self.engine.determine_intent(normalize(utterance, lang), 100)) best_intent['utterance'] = utterance except StopIteration as e: logger.exception(e) continue if best_intent and best_intent.get('confidence', 0.0) > 0.0: best_intent['lang'] = lang best_intent['user'] = user reply = message.reply(best_intent.get('intent_type'), best_intent) self.emitter.emit(reply) elif len(utterances) == 1: self.emitter.emit( Message("intent_failure", { "utterance": utterances[0], "lang": lang })) else: self.emitter.emit( Message("multi_utterance_intent_failure", { "utterances": utterances, "lang": lang }))
def load_vocab_from_file(path, vocab_type, emitter): if path.endswith('.voc'): with open(path, 'r') as voc_file: for line in voc_file.readlines(): parts = line.strip().split("|") entity = parts[0] emitter.emit( Message("register_vocab", { 'start': entity, 'end': vocab_type })) for alias in parts[1:]: emitter.emit( Message("register_vocab", { 'start': alias, 'end': vocab_type, 'alias_of': entity }))
def on_message(self, message): logger.debug(message) try: deserialized_message = Message.deserialize(message) except: return try: self.emitter.emit(deserialized_message.type, deserialized_message) except Exception as e: logger.exception(e) traceback.print_exc(file=sys.stdout) pass for client in client_connections: client.write_message(message)
def register_intent(self, intent_parser, handler): self.emitter.emit(Message("register_intent", intent_parser.__dict__)) self.registered_intents.append(intent_parser.name) def receive_handler(message): try: handler(message) except: self.speak( "An error occurred while processing a request in " + self.name, self.lang) logger.error( "An error occurred while processing a request in " + self.name, exc_info=True) self.emitter.on(intent_parser.name, receive_handler)
def _talk(event): message = event.data['utterance'] token = event.data['token'] # Training brain brain.train() # Asking Brain for an answer answer = brain.calc_intent(message) response = { 'name': answer.name, 'sent': answer.sent, 'matches': answer.matches, 'conf': answer.conf, 'token': token } ws.emit(Message('neuron:' + answer.name, response))
def scan(self, event=None): LOG.info("Scanning wifi connections...") networks = {} status = self.get_status() for cell in Cell.all(self.iface): update = True ssid = cell.ssid quality = self.get_quality(cell.quality) # If there are duplicate network IDs (e.g. repeaters) only # report the strongest signal if networks.__contains__(ssid): update = networks.get(ssid).get("quality") < quality if update and ssid: networks[ssid] = { 'quality': quality, 'encrypted': cell.encrypted, 'connected': self.is_connected(ssid, status) } self.ws.emit(Message("onyx.wifi.scanned", {'networks': networks})) LOG.info("Wifi connections scanned!\n%s" % networks)
def onConnected(event=None): ws.emit(Message('onyx_detect')) t.close()
def speak(self, utterance, lang='en-US'): logger.info("Speak: " + utterance) self.sockyx.emit(Message("speak", {'utterance': utterance, 'lang': lang}))
def open(self): self.write_message(Message("connected").serialize()) client_connections.append(self)
def onConnected(event=None): print("Sending message...'" + messageToSend + "'") sockyx.emit(Message(messageToSend)) sockyx.close() exit()
def detach(self): for name in self.registered_intents: self.emitter.emit(Message("detach_intent", {"intent_name": name}))
def disable_intent(self, intent_name): """Disable a registered intent""" logger.debug('Disabling intent ' + intent_name) name = self.name + ':' + intent_name self.emitter.emit(Message("detach_intent", {"intent_name": name}))
def register_vocabulary(self, entity, entity_type): self.emitter.emit( Message('register_vocab', { 'start': entity, 'end': entity_type }))
def _speak_and_show(self, speak, show): ''' Communicate with the user throughout the process ''' self.ws.emit(Message("speak", {'utterance': speak})) if show is None: return
def on_message(self, ws, message): self.emitter.emit('message', message) parsed_message = Message.deserialize(message) self.pool.apply_async(self.emitter.emit, (parsed_message.type, parsed_message))
def register_regex(self, regex_str): re.compile(regex_str) # validate regex self.emitter.emit(Message('register_vocab', {'regex': regex_str}))
def finish(self): self.emitter.emit(Message("finish"))