def test_deserialize(self):
"""This test's the deserialize method
"""
messages = []
# create the messages from the serialized strings above
messages.append(Message.deserialize(self.serialized[0]))
messages.append(Message.deserialize(self.serialized[1]))
messages.append(Message.deserialize(self.serialized[2]))
# check the created messages match the strings
self.assertEqual(messages[0].serialize(), self.serialized[0])
self.assertEqual(messages[1].serialize(), self.serialized[1])
self.assertEqual(messages[2].serialize(), self.serialized[2])
def test_deserialize(self):
"""This test's the deserialize method
"""
messages = []
# create the messages from the serialized strings above
messages.append(Message.deserialize(self.serialized[0]))
messages.append(Message.deserialize(self.serialized[1]))
messages.append(Message.deserialize(self.serialized[2]))
# check the created messages match the strings
self.assertEqual(messages[0].serialize(), self.serialized[0])
self.assertEqual(messages[1].serialize(), self.serialized[1])
self.assertEqual(messages[2].serialize(), self.serialized[2])
def __init__(self):
super(MySkill, self).__init__(name="MySkill")
self.MessageQueueFileName = 'MessageQueue.json' # file_system object handles the full path
# GPIO variables created to make system changes much easier
self.GPIO_Pin = 27
self.pull_up_down = GPIO.PUD_UP
self.falling_rising = GPIO.FALLING
self.testMessage = Message.deserialize(json.dumps({"type":"NULL", "data":{"messageData":{"data":"hi, how are you doing?", "sender":"bob","response-needed":"True"}}}))
def process_message(self, client, payload, isBinary):
"""
Process message from node, decide what to do internally here
"""
LOG.info("processing message from client: " + str(client.peer))
client_data = self.clients[client.peer]
client_protocol, ip, sock_num = client.peer.split(":")
# TODO update any client data you may want to store, ip, timestamp
# etc.
if isBinary:
# TODO receive files ?
pass
else:
message = Message.deserialize(payload.decode('utf8'))
# add context for this message
message.context["source"] = client.peer
message.context["platform"] = "node_red"
message.context["ident"] = client.name + ":" + client.peer
# This would be the place to check for blacklisted
# messages/skills/intents per node instance
# we can accept any kind of message for other purposes
message.context["client_name"] = "node_red"
message.context["destinatary"] = client.peer
if message.type == "node_red.answer":
# node is answering us, do not use target, we want tts to
# execute
message.type = "speak"
message.context["destinatary"] = "node_fallback"
# node is answering its own question in a fallback
if self.query:
message.context["target"] = "node_red"
self.query = False
# forward back to node
self.broadcast_message(message)
elif message.type == "node_red.query":
# node is asking us something
self.query = True
message.type = "recognizer_loop:utterance"
# we do not want tts to execute, unless explicitly requested
if "target" not in message.context:
message.context["target"] = "node_red"
elif message.type == "node_red.intent_failure":
# node red failed
LOG.info("node red intent failure")
elif message.type == "node_red.converse.deactivate":
LOG.info("node red converse deactivate")
elif message.type == "node_red.converse.activate":
LOG.info("node red converse activate")
elif self.settings["safe_mode"] and message.type not in \
self.settings["message_whitelist"]:
LOG.warning("node red sent an unexpected message type, "
"it was suppressed: " + message.type)
return
# send client message to internal mycroft bus
self.emitter.emit(message)
def handle_receive_server_message(self, message):
server_msg = message.data.get("payload")
is_file = message.data.get("isBinary")
if is_file:
# TODO received file
pass
else:
# forward server message to internal bus
message = Message.deserialize(server_msg)
self.emitter.emit(message)
def handle_message(self, message):
# forward internal messages to clients if they are the target
message = Message.deserialize(message)
if message.type == "complete_intent_failure":
message.type = "hivemind.complete_intent_failure"
message.context = message.context or {}
peer = message.context.get("destinatary")
if peer and peer in self.clients:
client_data = self.clients[peer] or {}
client = client_data.get("object")
client.sendMessage(message.serialize(), False)
def handle_send_server_message(self, message):
server_msg = message.data.get("payload")
is_file = message.data.get("isBinary")
if is_file:
# TODO send file
pass
else:
# send message to server
server_msg = Message.deserialize(server_msg)
server_msg.context["platform"] = platform
self.sendMessage(server_msg.type, server_msg.data,
server_msg.context)
def on_message(self, message):
logger.debug(message)
try:
deserialized_message = Message.deserialize(message)
except:
return
try:
self.emitter.emit(deserialized_message.message_type,
deserialized_message)
except Exception, e:
traceback.print_exc(file=sys.stdout)
pass
def on_message(self, message):
LOG.debug(message)
try:
deserialized_message = Message.deserialize(message)
except:
return
try:
self.emitter.emit(deserialized_message.type, deserialized_message)
except Exception, e:
LOG.exception(e)
traceback.print_exc(file=sys.stdout)
pass
def on_message(self, message):
# LOG.debug(message)
try:
deserialized_message = Message.deserialize(message)
except:
return
try:
self.emitter.emit(deserialized_message.type, deserialized_message)
except Exception as e:
LOG.exception(e)
traceback.print_exc(file=sys.stdout)
pass
for client in client_connections:
client.write_message(message)
def on_message(self, message):
# LOG.debug(message)
try:
deserialized_message = Message.deserialize(message)
except Exception:
return
try:
self.emitter.emit(deserialized_message.type, deserialized_message)
except Exception as e:
LOG.exception(e)
traceback.print_exc(file=sys.stdout)
pass
for client in client_connections:
client.write_message(message)
def process_message(self, client, payload, isBinary):
"""
Process message from client, decide what to do internally here
"""
logger.info("processing message from client: " + str(client.peer))
client_data = self.clients[client.peer]
# client_protocol, ip, sock_num = client.peer.split(":")
# TODO this would be the place to check for blacklisted
# messages/skills/intents per user
if isBinary:
# TODO receive files
pass
else:
# add context for this message
message = Message.deserialize(payload)
message.context["source"] = client.peer
message.context["destinatary"] = "skills"
if "platform" not in message.context:
message.context["platform"] = client_data.get(
"platform", "unknown")
# send client message to internal mycroft bus
self.emitter.emit(message)
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 on_message(self, message):
parsed_message = Message.deserialize(message)
self.emitter.emit('message', message)
self.emitter.emit(parsed_message.type, parsed_message)
def on_message(self, message):
parsed_message = Message.deserialize(message)
# LOG.info("RECEIVED MESSAGE", message)
#print("RECEIVED MESSAGE: ", message)
self.emitter.emit('message', message)
self.emitter.emit(parsed_message.type, parsed_message)
def read_messages(self, f, passive):
"""
# read_messages : function to make changing the core mechanics/ui of reading through messages
# easier while still maintaing a differance between use cases
# args :
# f : (.json file) the file where the message queue is stored
# passive : (bool) : handles the different use case of a passive activation (ie by a motion tracker)
# no return
"""
messageData = json.load(f) # Message Data stored in a list in a json object
yes_words = set(self.translate_list('confirm'))
if len(messageData["messages"]) > 0: # checks if there are any messages
if len(messageData["messages"]) == 1: # 1 message plural fix
self.speak(str(len(messageData["messages"])) + " new message.")
else:
self.speak(str(len(messageData["messages"])) + " new messages.")
wait_while_speaking()
if passive: # asks the user to confirm a read if it is passive activation
confirmedIntent = self.ask_yesno("ask.confirm_message_view")
confirmedBool = True if confirmedIntent == 'yes' else False
else:
confirmedBool = True
fullData = messageData # this is nessasary to maintain a copy of the full data to make looping more consistant
if confirmedBool:
for i in range(len(fullData["messages"])):
poppedData = messageData["messages"].pop() # pop works well here because we want it to work like a voicemail
self.speak("Message "+ str(i+1) +" from " + poppedData["sender"] + ". " + poppedData["sender"] +" says") #actual reading of the message
wait_while_speaking()
self.speak(poppedData["data"])
wait_while_speaking()
if poppedData["response-needed"] == "True":
outMessageConfirm = self.get_response('ask.confirm_message_response')
if any(word in outMessageConfirm for word in yes_words):
self.speak_dialog('ask.for_message')
wait_while_speaking()
#record(self.file_system.path+'/test.wav', 600, 44100, 1)
self.log.info("Audio Request Sending")
self.emitTest.wait_for_response(Message.deserialize(json.dumps({"type":"skill-audio-record:AudioRecordSkillIntent", "data":{"utterance":"record audio 10 seconds"}})), 'mycroft.skill.handler.complete', 10)
self.emitTest.wait_for_response(Message.deserialize(json.dumps({"type":"NULL"})), 'mycroft.skill.handler.complete', 15)
self.speak('Done')
wait_while_speaking()
#the following lines write the poped data to the json file
f.seek(0)
f.write(json.dumps(messageData, sort_keys=True, indent=4, separators=(',', ': ')))
f.truncate()
if len(messageData["messages"]) > 0:
self.speak("Next Message")
wait_while_speaking()
else:
self.speak("End Of messages")
f.close()
wait_while_speaking()
else:
self.speak("I'll read them another time")
if passive: # GPIO events need to be reset
self.resetGPIO()
wait_while_speaking()
self.stop()
elif not passive:
self.speak("No new messages")
wait_while_speaking()
self.stop()
else: # GPIO events need to be reset
self.resetGPIO()
self.stop()
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 on_message(self, message):
parsed_message = Message.deserialize(message)
self.emitter.emit('message', message)
self.emitter.emit(parsed_message.msg_type, parsed_message)
