XSocket 2.1.0__py3-none-any.whl

xsocket/__init__.py

@@ -0,0 +1,7 @@
+from .helpers import VERSION, EventEmitter, XSocketError
+from .data import Data
+from .socket_object import SocketObject
+from .client import Client
+from .server import Server
+
+__version__ = VERSION

xsocket/client.py

@@ -0,0 +1,197 @@
+import asyncio
+from urllib.parse import quote, urlencode
+
+from websockets.asyncio.client import connect
+from websockets.exceptions import ConnectionClosed
+
+from . import helpers
+from .helpers import Connection, EventEmitter, XSocketError, logger
+from .socket_object import SocketObject
+
+
+class Client(EventEmitter):
+
+    def __init__(self, serverUrl, query=None, settings=None):
+        super().__init__()
+        self.setMaxListeners(0)
+
+        if isinstance(serverUrl, str):
+            self._urlList = [serverUrl]
+        elif isinstance(serverUrl, (list, tuple)):
+            self._urlList = list(serverUrl)
+        else:
+            self._urlList = []
+        if not self._urlList:
+            raise XSocketError('Invalid urlList')
+        self._query           = dict(query) if isinstance(query, dict) else {}
+        self._settings        = dict(settings) if isinstance(settings, dict) else {}
+        self._ws              = None
+        self._socketObject    = None
+        self._isVersionWarned = False
+        self._isClose         = False
+
+        self.on('connect', self.__onConnect)
+        self._runTask = helpers.promise(self.__run())
+
+    def getSettings(self):
+        return self._settings
+
+    def getSettingsVal(self, key, default=None):
+        return self.getSettings().get(key) or default
+
+    def getSocketObject(self):
+        return self._socketObject or False
+
+    async def getSocketObjectReady(self):
+        if self.getSocketObject():
+            return self.getSocketObject()
+        future = asyncio.get_running_loop().create_future()
+        self.once('connect', lambda socketObject: future.done() or future.set_result(socketObject))
+        return await future
+
+    def send(self, type, data=None, ttl=None):
+        return helpers.promise(self.__send(type, data, ttl))
+
+    async def __send(self, type, data, ttl):
+        socketObject = await self.getSocketObjectReady()
+        return await socketObject.send(type, data, ttl)
+
+    def sendReady(self, type, data=None, ttl=None):
+        return helpers.promise(self.__sendReady(type, data, ttl))
+
+    sendReadyResponse = sendReady
+
+    async def __sendReady(self, type, data, ttl):
+        socketObject = await self.getSocketObjectReady()
+        return await socketObject.sendReady(type, data, ttl)
+
+    def disconnect(self, msg=None):
+        socketObject = self.getSocketObject()
+        if not socketObject:
+            return False
+        return socketObject.disconnect(msg)
+
+    async def close(self, msg='end'):
+        self._isClose = True
+        if not self._ws or not self._ws.closeConnection(msg):
+            self._runTask.cancel()
+        await asyncio.gather(self._runTask, return_exceptions=True)
+        if self._socketObject:
+            self._socketObject.destroy(msg)
+
+    def __getUrl(self):
+        url = self._urlList[helpers.getRandInt(0, len(self._urlList) - 1)]
+        query = dict(self._query)
+        query['xV'] = helpers.VERSION
+        if self._socketObject and self._socketObject.getID() and self._socketObject.getSign():
+            query['xSOId']   = self._socketObject.getID()
+            query['xSOSign'] = self._socketObject.getSign()
+        return url + ('&' if '?' in url else '?') + urlencode({str(key): str(val) for key, val in query.items()}, quote_via=quote)
+
+    async def __run(self):
+        while not self._isClose:
+            try:
+                websocket = await connect(self.__getUrl(), ssl=self.getSettingsVal('ssl'), max_size=helpers.MAX_MESSAGE_SIZE)
+            except Exception as e:
+                self.emit('ws|error', str(e))
+                await asyncio.sleep(1)
+                continue
+            await self.__handleConnection(websocket)
+            if not self._isClose:
+                await asyncio.sleep(1)
+
+    async def __handleConnection(self, websocket):
+        ws = Connection(websocket)
+        self._ws = ws
+        if self._isClose:
+            ws.closeConnection('end')
+        self.emit('ws|connect', ws)
+        msgInc = 0
+
+        async def pongCheck():
+            nonlocal msgInc
+            while True:
+                await asyncio.sleep(21)
+                if not msgInc:
+                    ws.closeConnection('pingTimeout')
+                msgInc = 0
+
+        pongTask = helpers.promise(pongCheck())
+        try:
+            async for message in websocket:
+                msgInc += 1
+                if message == 'ping':
+                    ws.sendMessage('pong')
+                    continue
+                try:
+                    self.__onMessage(ws, message)
+                except Exception:
+                    logger.exception('Message handler error')
+        except ConnectionClosed:
+            pass
+        finally:
+            pongTask.cancel()
+            await websocket.wait_closed()
+            ws.stop()
+            self._ws = None
+            msg = websocket.close_reason or 'close'
+            self.emit('ws|disconnect', msg)
+            if self._socketObject:
+                self._socketObject.emit('ws|disconnect', msg)
+
+    def __onMessage(self, ws, message):
+        body = helpers.decodeMessage(message)
+        if not body:
+            return
+        if body[0] != helpers.MSG_SO_UPDATE:
+            if self._socketObject:
+                self._socketObject.emit('ws|message', body)
+            return
+        body = body + [None] * (6 - len(body))
+        if body[4] != helpers.VERSION and not self._isVersionWarned:
+            self._isVersionWarned = True
+            logger.warning('Version mismatch client %s, server %s', helpers.VERSION, body[4] or 'unknown')
+        ws.setTimeOffset(body[5] - helpers.getTime() if helpers.isNumber(body[5]) else 0)
+        ws.setQuery({
+            'xSOId'     : str(body[1]),
+            'xSOSign'   : str(body[2]),
+            'configure' : body[3] if isinstance(body[3], dict) else {}
+        })
+        if self._socketObject:
+            query = ws.getQuery()
+            if query['xSOId'] == self._socketObject.getID() and query['xSOSign'] == self._socketObject.getSign() and self._socketObject.update(ws):
+                return
+            self._socketObject.destroy('update')
+            self._socketObject = None
+        socketObject = self._socketObject = SocketObject()
+        socketObject.once('connect', lambda socketObject: self.emit('connect', socketObject))
+        socketObject.on('destroy', self.__onSocketObjectDestroy)
+        socketObject.on('disconnect', lambda socketObject, msg: self.emit('disconnect', socketObject, msg))
+        socketObject.on('reconnect', lambda socketObject: self.emit('reconnect', socketObject))
+        socketObject.on('data', lambda socketData: self.emit('data', socketData))
+        if not socketObject.update(ws):
+            ws.closeConnection('update')
+
+    def __onSocketObjectDestroy(self, socketObject, msg):
+        if self._socketObject is socketObject:
+            self._socketObject = None
+        self.emit('destroy', socketObject, msg)
+
+    def __onConnect(self, socketObject):
+        loop = asyncio.get_running_loop()
+        timerMap = {'destroy' : None}
+
+        def setDestroyTimeout(action, ttl=0):
+            if timerMap['destroy']:
+                timerMap['destroy'].cancel()
+                timerMap['destroy'] = None
+            if action:
+                timerMap['destroy'] = loop.call_later(max(ttl, 0) / 1000, socketObject.destroy, 'socketObjectTimeout')
+
+        def disconnectHandler(socketObject, msg):
+            configure = socketObject.getQueryVal('configure', {})
+            setDestroyTimeout(True, helpers.toInt(configure.get('socketObjectTimeout') if isinstance(configure, dict) else 0))
+
+        socketObject.on('reconnect', lambda socketObject: setDestroyTimeout(False))
+        socketObject.on('disconnect', disconnectHandler)
+        socketObject.once('destroy', lambda socketObject, msg: setDestroyTimeout(False))

xsocket/data.py

@@ -0,0 +1,169 @@
+import asyncio
+
+from . import helpers
+from .helpers import EventEmitter, XSocketError
+
+
+class Data(EventEmitter):
+
+    STATUS_NEW      = 0
+    STATUS_SEND     = 1
+    STATUS_RESPONSE = 2
+    DEFAULT_TTL     = 3000
+
+    def __init__(self, isOutput, dataObject=None, socketObject=None):
+        super().__init__()
+        self.setMaxListeners(0)
+        dataObject = dataObject if isinstance(dataObject, dict) else {}
+
+        ID   = dataObject.get('ID')
+        type = dataObject.get('type')
+        data = dataObject.get('data')
+        ttl  = dataObject.get('ttl')
+        time = dataObject.get('time')
+
+        self._isOutput     = bool(isOutput)
+        self._socketObject = socketObject
+        self._ID           = ID if isinstance(ID, str) else ''
+        self._type         = type if isinstance(type, str) else ''
+        self._data         = data if helpers.isObject(data) else {}
+        self._ttl          = ttl if helpers.isInt(ttl) and ttl >= 0 else Data.DEFAULT_TTL
+        now                = socketObject.getTime() if socketObject else helpers.getTime()
+        self._time         = time if helpers.isNumber(time) and time > 0 else now
+        self._resData      = {}
+        self._error        = False
+        self._status       = Data.STATUS_NEW
+        self._destroy      = False
+        self._ttlTimeout   = asyncio.get_running_loop().call_later(
+            max(0, min(self._ttl, self._ttl - (now - self._time))) / 1000,
+            self.destroy, 'ttl', True
+        )
+
+    def getID(self):
+        return str(self._ID)
+
+    def getType(self):
+        return str(self._type)
+
+    def getTTL(self):
+        return self._ttl
+
+    def getTime(self):
+        return self._time
+
+    def getData(self):
+        return self._data
+
+    def getDataVal(self, key, default=None):
+        try:
+            return self.getData()[key] or default
+        except (KeyError, IndexError, TypeError):
+            return default
+
+    def getResData(self):
+        return self._resData
+
+    def getResDataVal(self, key, default=None):
+        try:
+            return self.getResData()[key] or default
+        except (KeyError, IndexError, TypeError):
+            return default
+
+    def getStatus(self):
+        return self._status
+
+    def getDestroy(self):
+        return self._destroy or False
+
+    def getSocketObject(self):
+        return self._socketObject
+
+    def getError(self):
+        return self._error or False
+
+    def isNew(self):
+        return self._status == Data.STATUS_NEW
+
+    def isSend(self):
+        return self._status == Data.STATUS_SEND
+
+    def isResponse(self):
+        return self._status == Data.STATUS_RESPONSE
+
+    def response(self, data=None, error=None):
+        return helpers.promise(self.__response(data, error))
+
+    async def __response(self, data, error):
+        if self._isOutput:
+            raise XSocketError('Output data')
+        if self._destroy or self.isResponse() or not self._ttl:
+            raise XSocketError('destroy')
+        self.setResData(data)
+        self.setError(error)
+        future = asyncio.get_running_loop().create_future()
+
+        def responseHandler(resData, error):
+            if not future.done():
+                future.set_result(self)
+
+        def destroyHandler(msg):
+            if not future.done():
+                future.set_exception(XSocketError(msg))
+
+        self.once('response', responseHandler)
+        self.once('destroy', destroyHandler)
+        try:
+            ws = await self._socketObject.getWsReady()
+            if ws.sendObject([
+                helpers.MSG_SD_UPDATE,
+                int(self._ID),
+                self.getResData(),
+                self.getError()
+            ]):
+                self.setStatus(Data.STATUS_RESPONSE)
+            else:
+                self.destroy('Send failed')
+        except Exception as e:
+            self.destroy(str(e) or 'Send failed')
+        return await future
+
+    def setStatus(self, status):
+        if (
+            status not in (Data.STATUS_SEND, Data.STATUS_RESPONSE) or
+            self._status == Data.STATUS_RESPONSE or
+            self._status == status
+        ):
+            return False
+        self._status = status
+        self.emit('setStatus', status)
+        if status == Data.STATUS_RESPONSE:
+            self.emit('response', self.getResData(), self.getError())
+            self.destroy('response')
+        return True
+
+    def setError(self, errorMsg):
+        if not isinstance(errorMsg, str):
+            return False
+        self._error = errorMsg
+        return True
+
+    def setResData(self, data):
+        if data is None:
+            data = {}
+        if not helpers.isObject(data):
+            return False
+        self._resData = data
+        return True
+
+    def destroy(self, msg=None, isSetError=False):
+        if self._destroy:
+            return False
+        self._destroy = msg if isinstance(msg, str) and msg else 'destroy'
+        self._ttlTimeout.cancel()
+        if isSetError and not self._error:
+            self.setError(self._destroy)
+        if self._status != Data.STATUS_RESPONSE:
+            self.setStatus(Data.STATUS_RESPONSE)
+        self.emit('destroy', self._destroy)
+        self.clearAllListeners()
+        return True

xsocket/helpers.py

@@ -0,0 +1,250 @@
+import asyncio
+import inspect
+import json
+import logging
+import random
+import struct
+import time
+
+from websockets.protocol import State
+
+VERSION = '2.1.0'
+
+MSG_SO_UPDATE = 0
+MSG_SD_CREATE = 1
+MSG_SD_UPDATE = 2
+MSG_SO_TIME   = 3
+
+MAX_MESSAGE_SIZE = 100 * 1024 * 1024
+
+logger = logging.getLogger('xsocket')
+
+_taskSet = set()
+
+
+class XSocketError(Exception):
+    pass
+
+
+def getTime():
+    return int(time.time() * 1000)
+
+
+def getRandInt(min, max):
+    return random.randint(min, max)
+
+
+def isNumber(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and value == value
+
+
+def isInt(value):
+    return isNumber(value) and value % 1 == 0
+
+
+def isBinary(data):
+    return isinstance(data, (bytes, bytearray, memoryview))
+
+
+def isObject(data):
+    return isinstance(data, (dict, list)) or isBinary(data)
+
+
+def toInt(value, default=0):
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        return default
+
+
+def promise(awaitable):
+    task = asyncio.ensure_future(awaitable)
+    _taskSet.add(task)
+    task.add_done_callback(_onTaskDone)
+    return task
+
+
+def resolve(value):
+    future = asyncio.get_running_loop().create_future()
+    future.set_result(value)
+    return future
+
+
+def _onTaskDone(task):
+    _taskSet.discard(task)
+    if not task.cancelled():
+        task.exception()
+
+
+def getMessageDataIndex(msgType):
+    return 4 if msgType == MSG_SD_CREATE else 2
+
+
+def _dumps(body):
+    return json.dumps(body, separators=(',', ':'), ensure_ascii=False)
+
+
+def encodeMessage(body):
+    dataIndex = getMessageDataIndex(body[0])
+    data = body[dataIndex] if len(body) > dataIndex else None
+    if not isBinary(data):
+        return _dumps(body)
+    body = list(body)
+    body[dataIndex] = None
+    headerBytes = _dumps(body).encode()
+    return struct.pack('>I', len(headerBytes)) + headerBytes + bytes(data)
+
+
+def decodeMessage(raw):
+    try:
+        if isinstance(raw, str):
+            body = json.loads(raw)
+        else:
+            headerLength = struct.unpack_from('>I', raw)[0]
+            body = json.loads(bytes(raw[4:4 + headerLength]).decode())
+            if isinstance(body, list) and body:
+                dataIndex = getMessageDataIndex(body[0])
+                body.extend([None] * (dataIndex + 1 - len(body)))
+                body[dataIndex] = bytes(raw[4 + headerLength:])
+    except Exception:
+        return False
+    return body if isinstance(body, list) and body and isNumber(body[0]) else False
+
+
+class Listener:
+
+    def __init__(self, callback, once):
+        self.callback = callback
+        self.once = once
+
+
+class EventEmitter:
+
+    def __init__(self):
+        self._listenerMap = {}
+        self._maxListeners = 10
+
+    def on(self, name, callback, once=False):
+        if not isinstance(name, str) or not callable(callback):
+            return self
+        listenerList = self._listenerMap.setdefault(name, [])
+        listenerList.append(Listener(callback, once is True))
+        if self._maxListeners > 0 and len(listenerList) > self._maxListeners:
+            logger.warning('EventEmitter %s, exceeded maxListeners: %s/%s. Use setMaxListeners(n)', name, self._maxListeners, len(listenerList))
+        return self
+
+    def once(self, name, callback):
+        return self.on(name, callback, True)
+
+    def getListenerNameList(self):
+        return list(self._listenerMap.keys())
+
+    def clearAllListeners(self):
+        self._listenerMap = {}
+        return self._listenerMap
+
+    def listenerCount(self, name):
+        return len(self._listenerMap.get(name, []))
+
+    def setMaxListeners(self, count):
+        if not isNumber(count):
+            return False
+        self._maxListeners = int(count)
+        return True
+
+    def off(self, name, callback):
+        listenerList = self._listenerMap.get(name)
+        if not listenerList or not callable(callback):
+            return self
+        listenerList[:] = [listener for listener in listenerList if listener.callback != callback]
+        if not listenerList:
+            del self._listenerMap[name]
+        return self
+
+    def offAll(self, name):
+        self._listenerMap.pop(name, None)
+        return self
+
+    def emit(self, name, *args):
+        listenerList = self._listenerMap.get(name)
+        if not listenerList:
+            return self
+        for listener in list(listenerList):
+            currentList = self._listenerMap.get(name)
+            if not currentList or not any(item is listener for item in currentList):
+                continue
+            if listener.once:
+                currentList.remove(listener)
+                if not currentList:
+                    del self._listenerMap[name]
+            result = listener.callback(*args)
+            if inspect.isawaitable(result):
+                promise(result)
+        return self
+
+
+class Connection:
+
+    def __init__(self, websocket, query=None):
+        self._websocket   = websocket
+        self._query       = query if isinstance(query, dict) else {}
+        self._timeOffset  = 0
+        self._isClose     = False
+        self._outputQueue = asyncio.Queue()
+        self._writerTask  = promise(self.__writer())
+
+    def getWebsocket(self):
+        return self._websocket
+
+    def getQuery(self):
+        return self._query
+
+    def setQuery(self, query):
+        self._query = query if isinstance(query, dict) else {}
+
+    def getTimeOffset(self):
+        return self._timeOffset
+
+    def setTimeOffset(self, timeOffset):
+        self._timeOffset = timeOffset
+
+    def isConnection(self):
+        return not self._isClose and self._websocket.state is State.OPEN
+
+    def sendMessage(self, msg):
+        if not self.isConnection():
+            return False
+        self._outputQueue.put_nowait(('send', str(msg)))
+        return True
+
+    def sendObject(self, body):
+        if not self.isConnection():
+            return False
+        try:
+            message = encodeMessage(body)
+        except Exception:
+            return False
+        self._outputQueue.put_nowait(('send', message))
+        return True
+
+    def closeConnection(self, msg='close'):
+        if not self.isConnection():
+            return False
+        self._isClose = True
+        reason = str(msg or 'close').encode()[:123].decode(errors='ignore')
+        self._outputQueue.put_nowait(('close', reason))
+        return True
+
+    def stop(self):
+        self._isClose = True
+        self._writerTask.cancel()
+
+    async def __writer(self):
+        while True:
+            action, payload = await self._outputQueue.get()
+            try:
+                if action == 'close':
+                    return await self._websocket.close(1000, payload)
+                await self._websocket.send(payload)
+            except Exception:
+                return

xsocket/server.py

@@ -0,0 +1,227 @@
+import asyncio
+import inspect
+import ssl
+import uuid
+from urllib.parse import parse_qsl
+
+from websockets.asyncio.server import serve
+from websockets.exceptions import ConnectionClosed
+
+from . import helpers
+from .helpers import Connection, EventEmitter, XSocketError, logger
+from .socket_object import SocketObject
+
+
+class Server(EventEmitter):
+
+    def __init__(self, settings=None):
+        super().__init__()
+        self.setMaxListeners(0)
+        self._settings          = dict(settings or {})
+        self._server            = None
+        self._isListen          = False
+        self._useCallbackMap    = {}
+        self._socketObjectMap   = {}
+        self._versionWarnMap    = {}
+        self._sslContext        = None
+
+        options = self.getSettingsVal('https', {})
+        if options.get('cert'):
+            self._sslContext = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            self._sslContext.load_cert_chain(options['cert'], options.get('key'))
+
+        self._socketObjectTimeout = helpers.toInt(self.getSettingsVal('socketObjectTimeout', 0), -1)
+        if self._socketObjectTimeout < 0:
+            self._socketObjectTimeout = 0
+            logger.warning('socketObjectTimeout invalid value, set default is 0')
+
+    def getSocketObjectList(self):
+        return self._socketObjectMap
+
+    def getSocketObject(self, ID):
+        return self._socketObjectMap.get(ID, False)
+
+    def getPort(self):
+        return self.getSettings().get('port') or (443 if self._sslContext else 80)
+
+    def getSettings(self):
+        return self._settings
+
+    def getSettingsVal(self, key, default=None):
+        return self.getSettings().get(key) or default
+
+    async def useEmit(self, target, data):
+        callback = self._useCallbackMap.get(target)
+        if not callable(callback):
+            raise XSocketError('callbackNotFound')
+        future = asyncio.get_running_loop().create_future()
+
+        def successCallback(*args):
+            if not future.done():
+                future.set_result(args[0] if args else None)
+
+        def failedCallback(message=None):
+            if not future.done():
+                future.set_exception(XSocketError(message if isinstance(message, str) else ''))
+
+        def onCallbackDone(task):
+            if not task.cancelled() and task.exception():
+                failedCallback(str(task.exception()))
+
+        try:
+            result = callback(data, successCallback, failedCallback)
+            if inspect.isawaitable(result):
+                helpers.promise(result).add_done_callback(onCallbackDone)
+        except Exception as e:
+            failedCallback(str(e))
+        try:
+            return await asyncio.wait_for(future, 10)
+        except asyncio.TimeoutError:
+            raise XSocketError('timeout')
+
+    def use(self, target, callback):
+        if not isinstance(target, str) or not target:
+            raise XSocketError('Invalid target')
+        if not callable(callback):
+            raise XSocketError('Invalid callback')
+        self._useCallbackMap[target] = callback
+        self.emit('use|append', target, callback)
+        return self
+
+    async def listen(self):
+        if self._isListen:
+            raise XSocketError('repeat')
+        if self._isListen is None:
+            future = asyncio.get_running_loop().create_future()
+            self.once('listen', lambda: future.done() or future.set_result(None))
+            self.once('error', lambda e: future.done() or future.set_exception(e))
+            return await future
+        self._isListen = None
+        perMessageDeflate = self.getSettingsVal('perMessageDeflate', False)
+        try:
+            self._server = await serve(
+                self.__onConnection,
+                None,
+                self.getPort(),
+                ssl=self._sslContext,
+                compression='deflate' if perMessageDeflate else None,
+                max_size=helpers.MAX_MESSAGE_SIZE
+            )
+        except Exception as e:
+            self._isListen = False
+            self.emit('error', e)
+            raise
+        self._isListen = True
+        self.emit('listen')
+
+    async def close(self):
+        for socketObject in list(self._socketObjectMap.values()):
+            socketObject.destroy('close')
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None
+        self._isListen = False
+
+    async def __onConnection(self, websocket):
+        request = websocket.request
+        query = dict(parse_qsl(request.path.partition('?')[2], keep_blank_values=True))
+        ws = Connection(websocket, query)
+        remoteAddress = websocket.remote_address
+        req = {
+            'path'          : request.path,
+            'headers'       : {key.lower(): val for key, val in request.headers.raw_items()},
+            'remoteAddress' : remoteAddress[0] if isinstance(remoteAddress, tuple) else remoteAddress
+        }
+
+        clientVersion = str(query.get('xV') or 'unknown')
+        if clientVersion != helpers.VERSION and clientVersion not in self._versionWarnMap:
+            self._versionWarnMap[clientVersion] = True
+            logger.warning('Version mismatch server %s, client %s', helpers.VERSION, clientVersion)
+
+        socketObject = None
+        query['xSOId']   = str(query.get('xSOId') or '')
+        query['xSOSign'] = str(query.get('xSOSign') or '')
+        if query['xSOId'] and query['xSOSign']:
+            s = self.getSocketObject(query['xSOId'])
+            if s and s.getSign() == query['xSOSign'] and s.update(ws):
+                socketObject = s
+        if not socketObject:
+            query['xSOId']   = str(uuid.uuid4())
+            query['xSOSign'] = str(uuid.uuid4())
+            socketObject = SocketObject({'socketObjectTimeout' : self._socketObjectTimeout}, req)
+            if not self.getSettingsVal('auth', False) and not callable(self._useCallbackMap.get('auth')):
+                self.use('auth', lambda socketObject, successCallback, failedCallback: successCallback())
+            if socketObject.update(ws):
+                helpers.promise(self.__auth(socketObject))
+            else:
+                ws.closeConnection('update')
+
+        msgInc = 0
+
+        async def ping():
+            nonlocal msgInc
+            countPing = 0
+            while True:
+                await asyncio.sleep(5)
+                if countPing > 4:
+                    if not msgInc:
+                        ws.closeConnection('pingTimeout')
+                        return
+                    msgInc = 0
+                    countPing = 0
+                ws.sendMessage('ping')
+                countPing += 1
+
+        pingTask = helpers.promise(ping())
+        self.emit('ws|connect', ws)
+        try:
+            async for message in websocket:
+                msgInc += 1
+                if message == 'pong' or not socketObject:
+                    continue
+                try:
+                    body = helpers.decodeMessage(message)
+                    if body:
+                        socketObject.emit('ws|message', body)
+                except Exception:
+                    logger.exception('Message handler error')
+        except ConnectionClosed:
+            pass
+        finally:
+            pingTask.cancel()
+            await websocket.wait_closed()
+            ws.stop()
+            msg = websocket.close_reason or 'close'
+            socketObject.emit('ws|disconnect', msg)
+            self.emit('ws|disconnect', msg)
+
+    async def __auth(self, socketObject):
+        try:
+            await self.useEmit('auth', socketObject)
+        except Exception as e:
+            socketObject.destroy(str(e) or 'deniedAuth')
+            return
+        if socketObject.isDestroy():
+            return
+        self._socketObjectMap[socketObject.getID()] = socketObject
+        self.emit('connect', socketObject)
+        loop = asyncio.get_running_loop()
+        timerMap = {'destroy' : None}
+
+        def cancelTimeout(*args):
+            if timerMap['destroy']:
+                timerMap['destroy'].cancel()
+                timerMap['destroy'] = None
+
+        def disconnectHandler(socketObject, msg):
+            cancelTimeout()
+            timerMap['destroy'] = loop.call_later(self._socketObjectTimeout / 1000, socketObject.destroy, 'socketObjectTimeout')
+            socketObject.once('connect', cancelTimeout)
+
+        def destroyHandler(socketObject, msg):
+            self._socketObjectMap.pop(socketObject.getID(), None)
+            cancelTimeout()
+
+        socketObject.on('disconnect', disconnectHandler)
+        socketObject.once('destroy', destroyHandler)

xsocket/socket_object.py

@@ -0,0 +1,255 @@
+import asyncio
+
+from . import helpers
+from .data import Data
+from .helpers import EventEmitter, XSocketError
+
+
+class SocketObject(EventEmitter):
+
+    def __init__(self, serverConfigure=None, req=None):
+        super().__init__()
+        self.setMaxListeners(0)
+
+        self._serverConfigure = serverConfigure
+        self._req             = req if isinstance(req, dict) else {}
+        self._ws              = None
+        self._ID              = ''
+        self._sign            = ''
+        self._destroy         = None
+        self._isNewConnection = True
+        self._socketDataMap   = {}
+        self._socketDataInc   = 0
+        self._query           = {}
+        self._timeOffset      = 0
+
+        self.on('destroy', self.__onDestroy)
+        self.on('ws|disconnect', self.__onWsDisconnect)
+        self.on('ws|connect', self.__onWsConnect)
+        self.on('ws|message', self.__onWsMessage)
+
+    def getID(self):
+        return self._ID or ''
+
+    def getSign(self):
+        return self._sign or ''
+
+    def getTime(self):
+        return helpers.getTime() + self._timeOffset
+
+    def getTimeOffset(self):
+        return self._timeOffset
+
+    def setTimeOffset(self, timeOffset):
+        if not helpers.isNumber(timeOffset):
+            return False
+        self._timeOffset = round(timeOffset)
+        return True
+
+    def getReq(self):
+        return self._req
+
+    def getQuery(self):
+        return self._query
+
+    def getQueryVal(self, key, default=None):
+        return self.getQuery().get(key) or default
+
+    def getReqHeaders(self):
+        return self.getReq().get('headers') or {}
+
+    def getOrigin(self):
+        return self.getReqHeaders().get('origin') or 'unknown'
+
+    def getIP(self):
+        return str(self.getReq().get('remoteAddress') or 'unknown')
+
+    def getSocketDataList(self):
+        return self._socketDataMap
+
+    def getSocketData(self, ID):
+        return self._socketDataMap.get(ID, False)
+
+    def isConnection(self):
+        return self._ws.isConnection() if self._ws else False
+
+    def getConnection(self):
+        return self._ws if self.isConnection() else False
+
+    def getDestroy(self):
+        return self._destroy or False
+
+    def isDestroy(self):
+        return bool(self.getDestroy())
+
+    def isServer(self):
+        return self._serverConfigure is not None
+
+    async def getWsReady(self):
+        if self.getConnection():
+            return self.getConnection()
+        future = asyncio.get_running_loop().create_future()
+
+        def destroyHandler(socketObject, msg):
+            self.off('connect', connectHandler)
+            if not future.done():
+                future.set_exception(XSocketError('destroy'))
+
+        def connectHandler(socketObject):
+            self.off('destroy', destroyHandler)
+            if future.done():
+                return
+            if self.getConnection():
+                future.set_result(self.getConnection())
+            else:
+                future.set_exception(XSocketError('Connection failed'))
+
+        self.once('connect', connectHandler)
+        self.once('destroy', destroyHandler)
+        return await future
+
+    def send(self, type, data=None, ttl=None):
+        self._socketDataInc += 1
+        socketData = Data(True, {
+            'ID'   : str(self._socketDataInc),
+            'type' : type,
+            'data' : data,
+            'ttl'  : ttl,
+            'time' : self.getTime()
+        }, self)
+        if socketData.getTTL():
+            self._socketDataMap[socketData.getID()] = socketData
+            socketData.once('destroy', lambda msg: self._socketDataMap.pop(socketData.getID(), None))
+        helpers.promise(self.__sendData(socketData))
+        return helpers.resolve(socketData)
+
+    async def __sendData(self, socketData):
+        try:
+            ws = await self.getWsReady()
+        except Exception as e:
+            socketData.destroy(str(e) or 'Send failed')
+            return
+        if not ws.sendObject([
+            helpers.MSG_SD_CREATE,
+            int(socketData.getID()),
+            socketData.getType(),
+            socketData.getTTL(),
+            socketData.getData(),
+            socketData.getTime()
+        ]):
+            socketData.destroy('Send failed')
+            return
+        socketData.setStatus(Data.STATUS_SEND if socketData.getTTL() else Data.STATUS_RESPONSE)
+
+    def sendReadyResponse(self, type, data=None, ttl=None):
+        return helpers.promise(self.__sendReady(type, data, ttl))
+
+    sendReady = sendReadyResponse
+
+    async def __sendReady(self, type, data, ttl):
+        socketData = await self.send(type, data, ttl)
+        if not socketData.isResponse() and not socketData.getDestroy():
+            future = asyncio.get_running_loop().create_future()
+            socketData.once('response', lambda resData, error: future.done() or future.set_result(None))
+            await future
+        if socketData.getError():
+            raise XSocketError(socketData.getError())
+        return socketData
+
+    def destroy(self, msg=None):
+        if self.isDestroy():
+            return False
+        self._destroy = str(msg or 'destroy')
+        self.disconnect(self._destroy)
+        self.emit('destroy', self, self._destroy)
+        self.clearAllListeners()
+        return True
+
+    def disconnect(self, msg=None):
+        ws = self.getConnection()
+        if not ws:
+            return False
+        return ws.closeConnection(msg)
+
+    def update(self, ws):
+        if not isinstance(ws, helpers.Connection):
+            return False
+        if not ws.isConnection() or self._destroy:
+            return False
+        query = ws.getQuery()
+        if self._ID != query.get('xSOId') or self._sign != query.get('xSOSign'):
+            self._ID    = query.get('xSOId')
+            self._sign  = query.get('xSOSign')
+            self._query = {key: val for key, val in query.items() if key not in ('xSOId', 'xSOSign', 'xV')}
+            self.emit('update', self)
+        if self.isServer():
+            ws.sendObject([
+                helpers.MSG_SO_UPDATE,
+                self.getID(),
+                self.getSign(),
+                self._serverConfigure if isinstance(self._serverConfigure, dict) else {},
+                helpers.VERSION,
+                helpers.getTime()
+            ])
+        else:
+            self.setTimeOffset(ws.getTimeOffset())
+            ws.sendObject([helpers.MSG_SO_TIME, helpers.getTime()])
+        self._ws = ws
+        self.emit('ws|connect', ws)
+        return True
+
+    def __onDestroy(self, socketObject, msg):
+        for socketData in list(self._socketDataMap.values()):
+            socketData.destroy('SocketObject|destroy')
+
+    def __onWsDisconnect(self, msg):
+        msg = msg if isinstance(msg, str) else 'unknown'
+        self.emit('disconnect', self, msg)
+        if msg == 'end':
+            self.destroy('end')
+
+    def __onWsConnect(self, ws):
+        self.emit('connect', self)
+        if not self._isNewConnection:
+            self.emit('reconnect', self)
+        else:
+            self._isNewConnection = False
+
+    def __onWsMessage(self, body):
+        body = list(body) + [None] * (6 - len(body))
+        if body[0] == helpers.MSG_SO_TIME:
+            return self.__onWsTime(body)
+        ID = body[1]
+        if not helpers.isInt(ID) or ID < 1:
+            return
+        ID = int(ID)
+        if body[0] == helpers.MSG_SD_CREATE:
+            if not isinstance(body[2], str) or not body[2] or not (body[4] is None or helpers.isObject(body[4])):
+                return
+            socketData = Data(False, {
+                'ID'   : str(ID),
+                'type' : body[2],
+                'ttl'  : body[3],
+                'data' : body[4],
+                'time' : body[5]
+            }, self)
+            self.emit('data', socketData)
+            self.emit('data|' + socketData.getType(), socketData)
+            if not socketData.getTTL():
+                socketData.setStatus(Data.STATUS_RESPONSE)
+        elif body[0] == helpers.MSG_SD_UPDATE:
+            socketData = self.getSocketData(str(ID))
+            if socketData:
+                socketData.setResData(body[2])
+                socketData.setError(body[3] or False)
+                socketData.setStatus(Data.STATUS_RESPONSE)
+
+    def __onWsTime(self, body):
+        ws = self.getConnection()
+        if not ws or not helpers.isNumber(body[1]):
+            return
+        if self.isServer():
+            ws.sendObject([helpers.MSG_SO_TIME, body[1], helpers.getTime()])
+        elif helpers.isNumber(body[2]):
+            now = helpers.getTime()
+            self.setTimeOffset(body[2] + (now - body[1]) / 2 - now)

xsocket-2.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: xsocket
+Version: 2.1.0
+Summary: WebSocket client and server for Python (asyncio), compatible with xSocket for Node.js and the browser
+Author: pr!de
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pride-oO/xsocket
+Keywords: socket,ws,wss,websocket,message,client,server,asyncio
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websockets>=13
+Dynamic: license-file
+
+rfr# xSocket for Python
+
+WebSocket client and server for Python (asyncio). Same protocol as [xSocket](https://github.com/pride-oO/xsocket) for Node.js and the browser: a Python server works with JS clients, a Python client works with a Node.js server.
+
+- Request-response with TTL (`sendReady`), clock synchronization with the server
+- Automatic reconnect and session recovery within `socketObjectTimeout`
+- Auth hook on the server (`use('auth')`)
+- `ws://` or `wss://` depending on certificate, optional `perMessageDeflate` compression
+- Binary messages: `bytes`, `bytearray` or `memoryview` as data, received as `bytes`
+- Python 3.9+, depends on [websockets](https://pypi.org/project/websockets/)
+
+```
+pip install xsocket
+```
+
+The API mirrors the JS version. Methods that return a `Promise` in JS (`send`, `sendReady`, `response`) return an awaitable task here: the message is sent even without `await`. Event handlers can be regular functions or coroutines and receive the same arguments as in JS. `Client` and `Server` must be created inside a running event loop.
+
+## Server:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xServer = xsocket.Server({
+        'port' : 8752, # (Not necessary) Port listen (Default: 443 with certificate, 80 without)
+        'socketObjectTimeout' : 30000, # (Not necessary) Allows the user to reconnect within 30 seconds (Default: 0)
+        'perMessageDeflate' : True, # (Not necessary) Compress messages (Default: False)
+        'https' : { # (Not necessary) Without certificate server uses ws:// instead of wss://
+            'cert' : '<path>/cert.pem',
+            'key' : '<path>/private.key'
+        }
+    })
+
+    # (Not necessary) Auth, by default all connections are allowed. Can be async
+    def auth(xSocketObject, success, failed):
+        if xSocketObject.getQueryVal('name'):
+            return success()
+        failed('Access denied')
+
+    xServer.use('auth', auth)
+
+    def onConnect(xSocketObject):
+        print('Connect event:', xSocketObject.getID(), xSocketObject.getIP(), xSocketObject.getOrigin(), xSocketObject.getQuery(), xSocketObject.getReqHeaders())
+
+        async def onData(xSocketData):
+            print('Data event', xSocketData.getID(), xSocketData.getType(), xSocketData.getData())
+            await asyncio.sleep(1)
+            try:
+                await xSocketData.response({'welcome' : 'Hello ' + xSocketObject.getQueryVal('name')})
+                # OR
+                # await xSocketData.response({}, 'Permision denied')
+            except xsocket.XSocketError as e:
+                print('Response send failed', xSocketData.getID(), e)
+
+        xSocketObject.on('data', onData)
+        xSocketObject.on('disconnect', lambda xSocketObject, msg: print('Disconnect event:', xSocketObject.getID(), msg))
+        xSocketObject.on('reconnect', lambda xSocketObject: print('Reconnect event:', xSocketObject.getID()))
+        xSocketObject.on('destroy', lambda xSocketObject, msg: print('Destroy event:', xSocketObject.getID(), msg))
+
+    xServer.on('connect', onConnect)
+    xServer.on('listen', lambda: print('Listen event', xServer.getPort()))
+
+    await xServer.listen()
+    await asyncio.Future()
+
+asyncio.run(main())
+```
+
+## Client:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xClient = xsocket.Client(['wss://server_domain.com:8752'], {'name' : 'Bob'}) # ws:// if server without certificate
+    # Self-signed certificate: xsocket.Client(url, query, {'ssl' : ssl.SSLContext})
+
+    xClient.on('reconnect', lambda xSocketObject: print('reconnect event', xSocketObject.getID()))
+    xClient.on('disconnect', lambda xSocketObject, msg: print('disconnect', xSocketObject.getID(), msg))
+    xClient.on('destroy', lambda xSocketObject, msg: print('destroy', xSocketObject.getID(), msg))
+
+    # Messages from server
+    xClient.on('data', lambda xSocketData: xSocketData.response({'ok' : True}))
+
+    xSocketObject = await xClient.getSocketObjectReady()
+    print('connect event:', xSocketObject.getID())
+
+    try:
+        xSocketData = await xClient.sendReady(
+            'helloServer', # Name message
+            {'message' : 'Hello server'}, # Data message
+            2000 # TTL ready response (Default: 3s)
+        )
+        print('Server responsed #' + xSocketData.getID(), xSocketData.getType(), xSocketData.getResData())
+    except xsocket.XSocketError as e:
+        print('Server responsed error', e)
+
+    # Binary message, response can be binary too
+    # xSocketData = await xClient.sendReady('file', b'\x01\x02\x03')
+
+    # Without waiting for response
+    # await xClient.send('log', {'message' : 'Hello'}, 0)
+
+    # Close connection and destroy session on server
+    await xClient.close()
+
+asyncio.run(main())
+```

xsocket-2.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+xsocket/__init__.py,sha256=UMeD4__Z7tKEqY7w3f6HVpQC7ECgKUWdVLaX-70G0Ko,197
+xsocket/client.py,sha256=dLbvVwSD9QKlaDUel7ujbgp0MHCBze5JpoZC7ld7W_w,7859
+xsocket/data.py,sha256=WBJfCWR5x6UmLptufXmw1aTJ5wUsy1JG7qHDW4mhj4o,5225
+xsocket/helpers.py,sha256=pPQ5CC7BArZfnpJK2f3R6wQWon4FIp1cTiKJOqEStd0,6751
+xsocket/server.py,sha256=2_mATDSgvCvrjByFU2oeQSnpeZcmyoY2Q5OZamv7oKk,8625
+xsocket/socket_object.py,sha256=9MKLdRjrvWQM2SjagaHW8UTFFL7x9EmObJybJ13qgJA,8603
+xsocket-2.1.0.dist-info/licenses/LICENSE,sha256=9ynRS34b-K3KDcw4uTuSnRTVP81dtWw9HJstqnqmk5Y,1169
+xsocket-2.1.0.dist-info/METADATA,sha256=93DmkMTiQivn4NnckvbrRQ1fSavZfZtq6sVaSBpI2dU,5191
+xsocket-2.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+xsocket-2.1.0.dist-info/top_level.txt,sha256=j4AoRIuXoYD9KDZmDGVT74dUZ704pp5EyH1InIw_q2M,8
+xsocket-2.1.0.dist-info/RECORD,,

xsocket-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xsocket-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+# License
+
+[The MIT License (MIT)](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2009-2013 Jeff Mott  
+Copyright (c) 2013-2016 Evan Vosberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

xsocket-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xsocket