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