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)