def _build_resp(msg: aiohttp.WSMessage) -> WSResponse:
if msg.type == aiohttp.WSMsgType.BINARY:
data = msg.data
else:
data = msg.json()
response = WSResponse(data)
return response
async def handle_message(self, message: aiohttp.WSMessage):
if message.type == aiohttp.WSMsgType.TEXT:
data = message.json()
self.logger.debug(f"handling:{repr(hide_secret(data))}")
if "method" in data:
await self.handle_method_message(data)
else:
if "id" in data:
if "error" in data:
if self.on_response_error:
await self.on_response_error()
else:
self.logger.error(f"Receive error {repr(data)}")
else:
request_id = data["id"]
request = self.requests.get(request_id)
if request:
await self.handle_response(request=request,
response=data)
del self.requests[request_id]
else:
if self.on_handle_response:
await self.on_handle_response(data)
else:
self.logger.warning(
f"Unknown id:{request_id}, the on_handle_response event must be defined."
f" Unhandled message {data}")
else:
self.logger.warning(f"Unsupported message {message.data}")
else:
self.logger.warning(f"Unknown type of message {repr(message)}")
async def on_message(self, route: str, ws: web.WebSocketResponse, ws_msg_from_client: aiohttp.WSMessage):
if ws_msg_from_client.type == WSMsgType.TEXT:
msg = ws_msg_from_client.json()
self.parent.tk(self.parent.detail_var.set, msg.get("detail")) # Schedule on gui thread
elif ws_msg_from_client.type == WSMsgType.CLOSE:
# Two ways two detect a closing
txt = self.parent.detail_var.get() + "\nDisconnected."
self.parent.tk(self.parent.detail_var.set, txt)
async def on_message(self, message: aiohttp.WSMessage):
# deserialize message
data = message.json(loads=json.loads)
serial = data.get('serial', -1)
msg_type = data.get('type', 'call')
assert serial >= 0
log.debug("Acquiring lock for %s serial %s", self, serial)
async with self._locks[serial]:
try:
if msg_type == 'call':
args, kwargs = self._prepare_args(
data.get('arguments', None))
callback = data.get('call', None)
if callback is None:
raise ValueError(
'Require argument "call" does\'t exist.')
callee = self.resolver(callback)
calee_is_route = hasattr(
callee, '__self__') and isinstance(
callee.__self__, WebSocketRoute)
if not calee_is_route:
a = [self]
a.extend(args)
args = a
result = await self._executor(
partial(callee, *args, **kwargs))
self._send(data=result, serial=serial, type='callback')
elif msg_type == 'callback':
cb = self._futures.pop(serial, None)
cb.set_result(data.get('data', None))
elif msg_type == 'error':
self._reject(data.get('serial', -1),
data.get('data', None))
log.error('Client return error: \n\t{0}'.format(
data.get('data', None)))
except Exception as e:
log.exception(e)
self._send(data=self._format_error(e),
serial=serial,
type='error')
finally:
def clean_lock():
log.debug("Release and delete lock for %s serial %s", self,
serial)
if serial in self._locks:
self._locks.pop(serial)
self._call_later(self._CLEAN_LOCK_TIMEOUT, clean_lock)
def _build_resp(msg: aiohttp.WSMessage) -> WSResponse:
if msg.type == aiohttp.WSMsgType.BINARY:
data = msg.data
else:
try:
data = msg.json()
except JSONDecodeError:
data = msg.data
response = WSResponse(data)
return response
async def __handle_text_message(
_websocket: ClientWebSocketResponse, msg: WSMessage,
event_handler: Callable[[MessageDTO], None]) -> None:
_LOG.debug('%s: Server sent "%s"', datetime.now(), msg.data)
json_response = msg.json()
if 'access_id' not in json_response:
message = MessageDTO(**json_response)
event_handler(message)
elif isinstance(json_response, dict):
_LOG.info(f'Got id {json_response.get("access_id")}')
async def handle_message(self, message: aiohttp.WSMessage):
# noinspection PyTypeChecker, PyNoneFunctionAssignment
data = message.json(loads=loads) # type: dict
log.debug("Got message: %r", data)
serial = data.get("id")
if serial is None:
return await self.handle_event(data)
call_item = self._parse_message(data)
await self._call_method(call_item)
async def on_message(self, route: str, ws: web.WebSocketResponse,
ws_msg_from_client: aiohttp.WSMessage):
if ws_msg_from_client.type == WSMsgType.TEXT:
try:
msg = ws_msg_from_client.json()
except Exception as ex:
print("Error trying to make json", ex, ws_msg_from_client)
else:
if OAUTH2_TOKEN_KEY in msg:
token = msg.get(OAUTH2_TOKEN_KEY)
await self.queue.put(token)
else:
err = msg.get("error")
await self.queue.put(PushbulletError(err))
await self.queue.put(ws)
def process_ws_response(response: aiohttp.WSMessage) -> Union[dict, list]:
"""A utility function to process the response from the Synse Server WebSocket API.
Args:
response: The WebSocket response message.
Returns:
The JSON response edata marshaled into its Python type (e.g., dict or list).
Raises:
errors.SynseError: An instance of a SynseError, wrapping any other error
which may have occurred.
"""
if response.type == aiohttp.WSMsgType.text:
msg = response.json()
if msg['event'] == 'response/error':
log.debug(f'error response from Synse Server: {msg}')
status = msg['data']['http_code']
desc = msg['data'].get('description', '')
ctx = msg['data'].get('context', 'no context available')
err = f'{desc} [{status}]: {ctx}'
if status == 404:
raise errors.NotFound(err)
elif status == 400:
raise errors.InvalidInput(err)
else:
raise errors.SynseError(err)
else:
return msg
elif response.type == aiohttp.WSMsgType.closed:
raise errors.SynseError('WebSocket connection closed: {}'.format(
response.extra))
elif response.type == aiohttp.WSMsgType.error:
raise errors.SynseError('WebSocket error: {} : {}'.format(
response.data, response.extra))
else:
raise errors.SynseError(f'Unexpected WebSocket response: {response}')
async def handle_message(self, message: aiohttp.WSMessage):
if message.type == aiohttp.WSMsgType.TEXT:
data = message.json()
if isinstance(data, list):
channel_id = data[0]
handler = self.channel_handlers.get(channel_id)
if handler:
await handler(data, self)
else:
self.logger.warning(
f"Can't find handler for channel_id{channel_id}, {data}"
)
elif isinstance(data, dict):
if "event" in data:
await self.handle_event(data)
else:
self.logger.warning(f"Unknown message {message.data}")
else:
self.logger.warning(f"Unknown message {message.data}")
else:
self.logger.warning(f"Unknown type of message {repr(message)}")
async def handle_message(self, message: aiohttp.WSMessage):
# deserialize message
# noinspection PyNoneFunctionAssignment, PyTypeChecker
data = message.json(loads=loads) # type: dict
log.debug("Response: %r", data)
serial = data.get('id')
if serial is None:
return await self.handle_event(data)
method = data.get('method')
result = data.get('result')
error = data.get('error')
log.debug("Acquiring lock for %s serial %s", self, serial)
async with self._locks[serial]:
try:
if 'method' in data:
args, kwargs = self.prepare_args(data.get('params', None))
return await self.handle_method(method, serial, *args,
**kwargs)
elif 'result' in data:
return await self.handle_result(serial, result)
elif 'error' in data:
return await self.handle_error(serial, error)
else:
return await self.handle_result(serial, None)
except Exception as e:
log.exception(e)
if serial:
await self._send(error=self._format_error(e), id=serial)
finally:
self._call_later(self._CLEAN_LOCK_TIMEOUT, self.__clean_lock,
serial)
async def on_message(ws, message: aiohttp.WSMessage):
"""
{
"message": {
"data": "hello",
"extended_data": [],
"captions": [],
"type": "PLAIN"
},
"topic": "global",
"type": "MESSAGE"
}
"""
from main import bot
hub_log.info(message)
msg = message.json()
type = msg['type']
if type == 'MESSAGE':
topic = msg['topic']
if topic:
# ignore topic global
if topic == 'global':
return
# render message
innter_type = msg['message']['type']
innter_data = msg['message']['data']
extended_data = msg['message']['extended_data'] or []
caption = msg['message']['caption']
preview = msg['message']['preview']
group = False
body = ''
parse_mode = None
disable_preview = not preview
disable_notification = False
# parse message type
if innter_type == MESSAGE_TYPE.PLAIN.name:
body = innter_data
elif innter_type == MESSAGE_TYPE.MARKDOWN.name:
body = innter_data
parse_mode = "Markdown"
elif innter_type == MESSAGE_TYPE.HTML.name:
body = innter_data
parse_mode = "HTML"
elif innter_type == MESSAGE_TYPE.JSON.name:
body = innter_data
elif is_media(innter_type) or extended_data:
body = [{
'type': innter_type,
'data': innter_data,
'caption': caption
}] + extended_data # type: list
print(body)
# check: all types must be photo or video
if not all(is_media(x['type']) for x in body):
hub_log.warning(f"not all types are media")
return
else:
hub_log.warning(f"unprocessed type {innter_type}")
if body:
all_topics = DB.get_key_topics_map()
for key, topics in all_topics.items():
user_id, username, chat_id = Event.parse_key(key)
if topic in topics:
try:
if is_media(innter_type) or extended_data:
# string in hub message maybe a base64 encoded bytes
# or http url of a image
media_group = [{
'type':
x['type'].lower(),
'media':
x['data'] if x['data'].startswith('http')
else BytesIO(base64.b64decode(x['data'])),
'caption':
x['caption'],
} for x in body]
if len(media_group) > 1:
await bot.send_media_group(
chat_id,
media_group,
disable_notification=
disable_notification,
)
else:
if user_id != chat_id:
caption_default = f"# {topic} by {username}"
else:
caption_default = f'# {topic}'
if caption:
caption_default = (
f'{caption.rstrip()}\n\n{caption_default}'
)
x = media_group[0]
if x['type'] == 'photo':
await bot.send_photo(
chat_id,
x['media'],
caption=caption_default,
parse_mode=parse_mode,
disable_notification=
disable_notification,
)
else:
await bot.send_video(
chat_id,
x['media'],
caption=caption_default,
parse_mode=parse_mode,
disable_notification=
disable_notification,
)
else:
body_with_topic = f"{body.rstrip()}\n\n# {topic}"
# reply in group or private chat
if user_id != chat_id:
real_body = (
f"{body_with_topic} by {username}")
disable_notification = True
else:
real_body = body_with_topic
await bot.send_message(
chat_id,
real_body,
parse_mode=parse_mode,
disable_web_page_preview=disable_preview,
disable_notification=disable_notification,
)
except Exception as e:
traceback.print_exc()
async def on_message(self, message: WSMessage):
async with self.semaphore:
log.debug('Client %s send message: "%s"', self.id, message)
start = self._loop.time()
# deserialize message
data = message.json(loads=json.loads)
serial = data.get('serial', -1)
msg_type = data.get('type', 'call')
message_repr = ''
assert serial >= 0
log.debug("Acquiring lock for %s serial %s", self, serial)
async with self._locks[serial]:
try:
if msg_type == 'call':
args, kwargs = self._prepare_args(
data.get('arguments', None))
callback = data.get('call', None)
message_repr = "call[%s]" % callback
if callback is None:
raise ValueError(
'Require argument "call" does\'t exist.')
callee = self.resolver(callback)
callee_is_route = hasattr(
callee, '__self__') and isinstance(
callee.__self__, WebSocketRoute)
if not callee_is_route:
a = [self]
a.extend(args)
args = a
result = await self._executor(
partial(callee, *args, **kwargs))
self._send(data=result, serial=serial, type='callback')
elif msg_type == 'callback':
cb = self._futures.pop(serial, None)
payload = data.get('data', None)
cb.set_result(payload)
message_repr = "callback[%r]" % payload
elif msg_type == 'error':
self._reject(data.get('serial', -1),
data.get('data', None))
log.error('Client return error: \n\t{0}'.format(
data.get('data', None)))
message_repr = "error[%r]" % data
except Exception as e:
log.exception(e)
self._send(data=self._format_error(e),
serial=serial,
type='error')
finally:
def clean_lock():
log.debug("Release and delete lock for %s serial %s",
self, serial)
if serial in self._locks:
self._locks.pop(serial)
self._call_later(self._CLIENT_TIMEOUT, clean_lock)
response_time = self._loop.time() - start
if response_time > 0.001:
response_time = "%.3f" % response_time
else:
# loop.time() resolution is 1 ms.
response_time = "less then 1ms"
log.info("Response for client \"%s\" #%d finished %s",
message_repr, serial, response_time)
