python-engineio 4.7.1__py3-none-any.whl → 4.8.1__py3-none-any.whl

engineio/__init__.py

@@ -1,23 +1,13 @@
-import sys
-
 from .client import Client
 from .middleware import WSGIApp, Middleware
 from .server import Server
-if sys.version_info >= (3, 5):  # pragma: no cover
-    from .asyncio_server import AsyncServer
-    from .asyncio_client import AsyncClient
-    from .async_drivers.asgi import ASGIApp
-    try:
-        from .async_drivers.tornado import get_tornado_handler
-    except ImportError:
-        get_tornado_handler = None
-else:  # pragma: no cover
-    AsyncServer = None
-    AsyncClient = None
+from .async_server import AsyncServer
+from .async_client import AsyncClient
+from .async_drivers.asgi import ASGIApp
+try:
+    from .async_drivers.tornado import get_tornado_handler
+except ImportError:  # pragma: no cover
     get_tornado_handler = None
-    ASGIApp = None
 
-__all__ = ['Server', 'WSGIApp', 'Middleware', 'Client']
-if AsyncServer is not None:  # pragma: no cover
-    __all__ += ['AsyncServer', 'ASGIApp', 'get_tornado_handler',
-                'AsyncClient']
+__all__ = ['Server', 'WSGIApp', 'Middleware', 'Client',
+           'AsyncServer', 'ASGIApp', 'get_tornado_handler', 'AsyncClient']

engineio/{asyncio_client.py → async_client.py}

@@ -8,7 +8,7 @@ try:
 except ImportError:  # pragma: no cover
     aiohttp = None
 
-from . import client
+from . import base_client
 from . import exceptions
 from . import packet
 from . import payload
@@ -22,7 +22,7 @@ def async_signal_handler():
     Disconnect all active async clients.
     """
     async def _handler():  # pragma: no cover
-        for c in client.connected_clients[:]:
+        for c in base_client.connected_clients[:]:
             if c.is_asyncio_based():
                 await c.disconnect()
 
@@ -37,7 +37,7 @@ def async_signal_handler():
     asyncio.ensure_future(_handler())
 
 
-class AsyncClient(client.Client):
+class AsyncClient(base_client.BaseClient):
     """An Engine.IO client for asyncio.
 
     This class implements a fully compliant Engine.IO web client with support
@@ -71,7 +71,6 @@ class AsyncClient(client.Client):
                                     arguments passed to
                                     ``aiohttp.ws_connect()``.
     """
-
     def is_asyncio_based(self):
         return True
 
@@ -164,7 +163,7 @@ class AsyncClient(client.Client):
                 await self.read_loop_task
             self.state = 'disconnected'
             try:
-                client.connected_clients.remove(self)
+                base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
                 pass
         await self._reset()
@@ -262,7 +261,7 @@ class AsyncClient(client.Client):
         self.base_url += '&sid=' + self.sid
 
         self.state = 'connected'
-        client.connected_clients.append(self)
+        base_client.connected_clients.append(self)
         await self._trigger_event('connect', run_async=False)
 
         for pkt in p.packets[1:]:
@@ -384,7 +383,7 @@ class AsyncClient(client.Client):
             self.current_transport = 'websocket'
 
             self.state = 'connected'
-            client.connected_clients.append(self)
+            base_client.connected_clients.append(self)
             await self._trigger_event('connect', run_async=False)
 
         self.ws = ws
@@ -515,7 +514,7 @@ class AsyncClient(client.Client):
         if self.state == 'connected':
             await self._trigger_event('disconnect', run_async=False)
             try:
-                client.connected_clients.remove(self)
+                base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
                 pass
             await self._reset()
@@ -566,7 +565,7 @@ class AsyncClient(client.Client):
         if self.state == 'connected':
             await self._trigger_event('disconnect', run_async=False)
             try:
-                client.connected_clients.remove(self)
+                base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
                 pass
             await self._reset()

engineio/async_drivers/asgi.py

@@ -233,9 +233,14 @@ class WebSocket(object):  # pragma: no cover
         self.asgi_send = environ['asgi.send']
         await self.asgi_send({'type': 'websocket.accept'})
         await self.handler(self)
+        return ''  # send nothing as response
 
     async def close(self):
-        pass
+        try:
+            await self.asgi_send({'type': 'websocket.close'})
+        except Exception:
+            # if the socket is already close we don't care
+            pass
 
     async def send(self, message):
         msg_bytes = None

engineio/async_drivers/gevent_uwsgi.py

@@ -61,6 +61,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
 
         self.app(self)
         uwsgi.disconnect()
+        return ''  # send nothing as response
 
     def close(self):
         """Disconnects uWSGI from the client."""

engineio/async_drivers/sanic.py

@@ -114,6 +114,7 @@ class WebSocket(object):  # pragma: no cover
     """
     def __init__(self, handler, server):
         self.handler = handler
+        self.server = server
         self._sock = None
 
     async def __call__(self, environ):
@@ -123,6 +124,7 @@ class WebSocket(object):  # pragma: no cover
 
         self.environ = environ
         await self.handler(self)
+        return self.server._ok()
 
     async def close(self):
         await self._sock.close()

engineio/{asyncio_server.py → async_server.py}

@@ -1,13 +1,13 @@
 import asyncio
 import urllib
 
+from . import base_server
 from . import exceptions
 from . import packet
-from . import server
-from . import asyncio_socket
+from . import async_socket
 
 
-class AsyncServer(server.Server):
+class AsyncServer(base_server.BaseServer):
     """An Engine.IO server for asyncio.
 
     This class implements a fully compliant Engine.IO web server with support
@@ -418,7 +418,7 @@ class AsyncServer(server.Server):
                 self._service_task)
 
         sid = self.generate_id()
-        s = asyncio_socket.AsyncSocket(self, sid)
+        s = async_socket.AsyncSocket(self, sid)
         self.sockets[sid] = s
 
         pkt = packet.Packet(

engineio/{asyncio_socket.py → async_socket.py}

@@ -2,13 +2,13 @@ import asyncio
 import sys
 import time
 
+from . import base_socket
 from . import exceptions
 from . import packet
 from . import payload
-from . import socket
 
 
-class AsyncSocket(socket.Socket):
+class AsyncSocket(base_socket.BaseSocket):
     async def poll(self):
         """Wait for packets to send to the client."""
         try:
@@ -122,14 +122,14 @@ class AsyncSocket(socket.Socket):
                 await self.queue.join()
 
     def schedule_ping(self):
-        async def send_ping():
-            self.last_ping = None
-            await asyncio.sleep(self.server.ping_interval)
-            if not self.closing and not self.closed:
-                self.last_ping = time.time()
-                await self.send(packet.Packet(packet.PING))
-
-        self.server.start_background_task(send_ping)
+        self.server.start_background_task(self._send_ping)
+
+    async def _send_ping(self):
+        self.last_ping = None
+        await asyncio.sleep(self.server.ping_interval)
+        if not self.closing and not self.closed:
+            self.last_ping = time.time()
+            await self.send(packet.Packet(packet.PING))
 
     async def _upgrade_websocket(self, environ):
         """Upgrade the connection from polling to websocket."""

engineio/base_client.py

@@ -0,0 +1,146 @@
+import logging
+import signal
+import threading
+import time
+import urllib
+from . import packet
+
+default_logger = logging.getLogger('engineio.client')
+connected_clients = []
+
+
+def signal_handler(sig, frame):
+    """SIGINT handler.
+
+    Disconnect all active clients and then invoke the original signal handler.
+    """
+    for client in connected_clients[:]:
+        if not client.is_asyncio_based():
+            client.disconnect()
+    if callable(original_signal_handler):
+        return original_signal_handler(sig, frame)
+    else:  # pragma: no cover
+        # Handle case where no original SIGINT handler was present.
+        return signal.default_int_handler(sig, frame)
+
+
+original_signal_handler = None
+
+
+class BaseClient:
+    event_names = ['connect', 'disconnect', 'message']
+
+    def __init__(self, logger=False, json=None, request_timeout=5,
+                 http_session=None, ssl_verify=True, handle_sigint=True,
+                 websocket_extra_options=None):
+        global original_signal_handler
+        if handle_sigint and original_signal_handler is None and \
+                threading.current_thread() == threading.main_thread():
+            original_signal_handler = signal.signal(signal.SIGINT,
+                                                    signal_handler)
+        self.handlers = {}
+        self.base_url = None
+        self.transports = None
+        self.current_transport = None
+        self.sid = None
+        self.upgrades = None
+        self.ping_interval = None
+        self.ping_timeout = None
+        self.http = http_session
+        self.external_http = http_session is not None
+        self.handle_sigint = handle_sigint
+        self.ws = None
+        self.read_loop_task = None
+        self.write_loop_task = None
+        self.queue = None
+        self.state = 'disconnected'
+        self.ssl_verify = ssl_verify
+        self.websocket_extra_options = websocket_extra_options or {}
+
+        if json is not None:
+            packet.Packet.json = json
+        if not isinstance(logger, bool):
+            self.logger = logger
+        else:
+            self.logger = default_logger
+            if self.logger.level == logging.NOTSET:
+                if logger:
+                    self.logger.setLevel(logging.INFO)
+                else:
+                    self.logger.setLevel(logging.ERROR)
+                self.logger.addHandler(logging.StreamHandler())
+
+        self.request_timeout = request_timeout
+
+    def is_asyncio_based(self):
+        return False
+
+    def on(self, event, handler=None):
+        """Register an event handler.
+
+        :param event: The event name. Can be ``'connect'``, ``'message'`` or
+                      ``'disconnect'``.
+        :param handler: The function that should be invoked to handle the
+                        event. When this parameter is not given, the method
+                        acts as a decorator for the handler function.
+
+        Example usage::
+
+            # as a decorator:
+            @eio.on('connect')
+            def connect_handler():
+                print('Connection request')
+
+            # as a method:
+            def message_handler(msg):
+                print('Received message: ', msg)
+                eio.send('response')
+            eio.on('message', message_handler)
+        """
+        if event not in self.event_names:
+            raise ValueError('Invalid event')
+
+        def set_handler(handler):
+            self.handlers[event] = handler
+            return handler
+
+        if handler is None:
+            return set_handler
+        set_handler(handler)
+
+    def transport(self):
+        """Return the name of the transport currently in use.
+
+        The possible values returned by this function are ``'polling'`` and
+        ``'websocket'``.
+        """
+        return self.current_transport
+
+    def _reset(self):
+        self.state = 'disconnected'
+        self.sid = None
+
+    def _get_engineio_url(self, url, engineio_path, transport):
+        """Generate the Engine.IO connection URL."""
+        engineio_path = engineio_path.strip('/')
+        parsed_url = urllib.parse.urlparse(url)
+
+        if transport == 'polling':
+            scheme = 'http'
+        elif transport == 'websocket':
+            scheme = 'ws'
+        else:  # pragma: no cover
+            raise ValueError('invalid transport')
+        if parsed_url.scheme in ['https', 'wss']:
+            scheme += 's'
+
+        return ('{scheme}://{netloc}/{path}/?{query}'
+                '{sep}transport={transport}&EIO=4').format(
+                    scheme=scheme, netloc=parsed_url.netloc,
+                    path=engineio_path, query=parsed_url.query,
+                    sep='&' if parsed_url.query else '',
+                    transport=transport)
+
+    def _get_url_timestamp(self):
+        """Generate the Engine.IO query string timestamp."""
+        return '&t=' + str(time.time())