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"))
