def sendMessage(self, type, data, context=None): if self.client is None: logger.error("Client is none") return if context is None: context = {} msg = self.client.serialize_message(Message(type, data, context)) self.client.sendMessage(msg, isBinary=False) self.bus.emit( Message("hive.mind.message.sent", { "type": type, "data": data, "context": context, "raw": msg }))
def process_message(self, client, payload, isBinary): """ Process message from client, 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(":") if isBinary: # TODO receive files pass else: # add context for this message payload = payload.decode("utf-8") message = Message.deserialize(payload) message.context["source"] = client.peer message.context["destination"] = "skills" if "platform" not in message.context: message.context["platform"] = client_data.get( "platform", "unknown") # messages/skills/intents per user if message.type in client.blacklist.get("messages", []): LOG.warning(client.peer + " sent a blacklisted message " \ "type: " + message.type) return # TODO check intent / skill that will trigger # send client message to internal mycroft bus self.mycroft_send(message.type, message.data, message.context)
def get_entities_manifest(self): start = time.time() self._response = None self.waiting = True self.bus.emit( Message("intent.service.padatious.entities.manifest.get", context={ "destination": "intent_service", "source": "intent_api" })) while self.waiting and time.time() - start <= self.timeout: time.sleep(0.3) if time.time() - start > self.timeout: LOG.error("Intent Service timed out!") return None entities = [] # read files for ent in self._response["entities"]: if isfile(ent["file_name"]): with open(ent["file_name"]) as f: lines = f.read().replace("(", "").replace(")", "").split("\n") samples = [] for l in lines: samples += [a.strip() for a in l.split("|") if a.strip()] entities.append({"name": ent["name"], "samples": samples}) return entities
def get_regex_manifest(self): start = time.time() self._response = None self.waiting = True self.bus.emit( Message("intent.service.adapt.vocab.manifest.get", context={ "destination": "intent_service", "source": "intent_api" })) while self.waiting and time.time() - start <= self.timeout: time.sleep(0.3) if time.time() - start > self.timeout: LOG.error("Intent Service timed out!") return None vocab = {} for voc in self._response["vocab"]: if not voc.get("regex"): continue name = voc["regex"].split("(?P<")[-1].split(">")[0] if name not in vocab: vocab[name] = {"samples": []} vocab[name]["samples"].append(voc["regex"]) return [{ "name": voc, "regexes": vocab[voc]["samples"] } for voc in vocab]
def onConnect(self, response): logger.info("Server connected: {0}".format(response.peer)) self.factory.bus.emit( Message("hive.mind.connected", {"server_id": response.headers["server"]})) self.factory.client = self self.factory.status = "connected"
def onMessage(self, payload, isBinary): logger.info("status: " + self.factory.status) if not isBinary: payload = payload.decode("utf-8") data = {"payload": payload, "isBinary": isBinary} else: data = {"payload": None, "isBinary": isBinary} self.factory.bus.emit(Message("hive.mind.message.received", data))
def display(self, invert=True, clear=True, x_offset=0, y_offset=0): if self.bus is None: self.bus = get_mycroft_bus() data = {"img_code": self.encode(invert), "clearPrev": clear, "xOffset": x_offset, "yOffset": y_offset} self.bus.emit(Message('enclosure.mouth.display', data))
def onClose(self, wasClean, code, reason): logger.info("WebSocket connection closed: {0}".format(reason)) self.factory.bus.emit( Message("hive.mind.connection.closed", { "wasClean": wasClean, "reason": reason, "code": code })) self.factory.client = None self.factory.status = "disconnected"
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.bus.emit(message)
def handle_broadcast(self, message): # send message to all clients msg = message.data.get("payload") is_file = message.data.get("isBinary") if is_file: # TODO send file pass else: # send message to all clients server_msg = Message.serialize(msg) self.broadcast(server_msg)
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 handle_message(self, message=None): # forward internal messages to clients if they are the target message = Message.deserialize(message) if message.type == "complete_intent_failure": message.type = "hive.complete_intent_failure" message.context = message.context or {} peer = message.context.get("destination") if peer and peer in self.clients: client_data = self.clients[peer] or {} client = client_data.get("object") message = message.serialize() client.sendMessage(bytes(message, encoding="utf-8"), False)
def get_skills(self): start = time.time() self._response = None self.waiting = True self.bus.emit( Message("intent.service.skills.get", context={ "destination": "intent_service", "source": "intent_api" })) while self.waiting and time.time() - start <= self.timeout: time.sleep(0.3) if time.time() - start > self.timeout: LOG.error("Intent Service timed out!") return None return self._response["skills"]
def get_intent(self, utterance): """ get best intent for utterance """ start = time.time() self._response = None self.waiting = True self.bus.emit( Message("intent.service.intent.get", {"utterance": utterance}, context={ "destination": "intent_service", "source": "intent_api" })) while self.waiting and time.time() - start <= self.timeout: time.sleep(0.3) if time.time() - start > self.timeout: LOG.error("Intent Service timed out!") return None return self._response["intent"]
def handle_send(self, message): # send message to client msg = message.data.get("payload") is_file = message.data.get("isBinary") peer = message.data.get("peer") if is_file: # TODO send file pass elif peer in self.clients: # send message to client client = self.clients[peer] payload = Message.serialize(msg) client.sendMessage(payload, False) else: LOG.error("That client is not connected") self.mycroft_send("hive.client.send.error", { "error": "That client is not connected", "peer": peer }, message.context)
def unregister_client(self, client, code=3078, reason=u"unregister client request"): """ Remove client from list of managed connections. """ LOG.info("deregistering client: " + str(client.peer)) if client.peer in self.clients.keys(): client_data = self.clients[client.peer] or {} j, ip, sock_num = client.peer.split(":") context = { "user": client_data.get("names", ["unknown_user"])[0], "source": client.peer } self.bus.emit( Message("hive.client.disconnect", { "reason": reason, "ip": ip, "sock": sock_num }, context)) client.sendClose(code, reason) self.clients.pop(client.peer)
def register_entity(self, name, samples): data = {"name": name, "samples": samples} self._register_entity(Message(name, data))
def mycroft_send(self, type, data=None, context=None): data = data or {} context = context or {} if "client_name" not in context: context["client_name"] = NAME self.bus.emit(Message(type, data, context))
def wrapper(cl, message): message = Message.deserialize(message) self.handle_message(message)
def connect(self): LOG.debug("Announcing GUI") self.bus.on('mycroft.gui.port', self._connect_to_gui) self.bus.emit(Message("mycroft.gui.connected", {"gui_id": self.gui_id})) self.connected = True
def disable_intent(self, intent_name): """Disable a registered intent""" self.bus.emit( Message("mycroft.skill.disable_intent", {"intent_name": intent_name}))
def enable_intent(self, intent_name): """Reenable a registered self intent""" self.bus.emit( Message("mycroft.skill.enable_intent", {"intent_name": intent_name}))
def onOpen(self): logger.info("WebSocket connection open. ") self.factory.bus.emit(Message("hive.mind.websocket.open"))
def register_regex(self, name, pattern): data = {"name": name, "pattern": pattern} self._register_regex(Message(name, data))