change async_handlers default to true, and add call() method

Author: miguelgrinberg

socketio/asyncio_client.py

@@ -120,8 +120,7 @@ async def wait(self):
             if self.eio.state != 'connected':
                 break
 
-    async def emit(self, event, data=None, namespace=None, callback=None,
-                   wait=False, timeout=60):
+    async def emit(self, event, data=None, namespace=None, callback=None):
         """Emit a custom event to one or more connected clients.
 
         :param event: The event name. It can be any string. The event names
@@ -138,30 +137,11 @@ async def emit(self, event, data=None, namespace=None, callback=None,
                          that will be passed to the function are those provided
                          by the client. Callback functions can only be used
                          when addressing an individual client.
-        :param wait: If set to ``True``, this function will wait for the
-                     server to handle the event and acknowledge it via its
-                     callback function. The value(s) passed by the server to
-                     its callback will be returned. If set to ``False``,
-                     this function emits the event and returns immediately.
-        :param timeout: If ``wait`` is set to ``True``, this parameter
-                        specifies a waiting timeout. If the timeout is reached
-                        before the server acknowledges the event, then a
-                        ``TimeoutError`` exception is raised.
 
         Note: this method is a coroutine.
         """
         namespace = namespace or '/'
         self.logger.info('Emitting event "%s" [%s]', event, namespace)
-        if wait is True:
-            callback_event = self.eio.create_event()
-            callback_args = []
-
-            def event_callback(*args):
-                callback_args.append(args)
-                callback_event.set()
-
-            callback = event_callback
-
         if callback is not None:
             id = self._generate_ack_id(namespace, callback)
         else:
@@ -181,14 +161,6 @@ def event_callback(*args):
         await self._send_packet(packet.Packet(
             packet.EVENT, namespace=namespace, data=[event] + data, id=id,
             binary=binary))
-        if wait is True:
-            try:
-                await asyncio.wait_for(callback_event.wait(), timeout)
-            except asyncio.TimeoutError:
-                six.raise_from(exceptions.TimeoutError(), None)
-            return callback_args[0] if len(callback_args[0]) > 1 \
-                else callback_args[0][0] if len(callback_args[0]) == 1 \
-                    else None
 
     async def send(self, data, namespace=None, callback=None, wait=False,
                    timeout=60):
@@ -223,6 +195,41 @@ async def send(self, data, namespace=None, callback=None, wait=False,
         await self.emit('message', data=data, namespace=namespace,
                         callback=callback, wait=wait, timeout=timeout)
 
+    async def call(self, event, data=None, namespace=None, timeout=60):
+        """Emit a custom event to a client and wait for the response.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. If a
+                     ``list`` or ``dict``, the data will be serialized as JSON.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+
+        Note: this method is a coroutine.
+        """
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+
+        await self.emit(event, data=data, namespace=namespace,
+                        callback=event_callback)
+        try:
+            await asyncio.wait_for(callback_event.wait(), timeout)
+        except asyncio.TimeoutError:
+            six.raise_from(exceptions.TimeoutError(), None)
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+                else None
+
     async def disconnect(self):
         """Disconnect from the server.
 

socketio/asyncio_server.py

@@ -1,8 +1,10 @@
 import asyncio
 
 import engineio
+import six
 
 from . import asyncio_manager
+from . import exceptions
 from . import packet
 from . import server
 
@@ -26,7 +28,7 @@ class AsyncServer(server.Server):
                  versions.
     :param async_handlers: If set to ``True``, event handlers are executed in
                            separate threads. To run handlers synchronously,
-                           set to ``False``. The default is ``False``.
+                           set to ``False``. The default is ``True``.
     :param kwargs: Connection parameters for the underlying Engine.IO server.
 
     The Engine.IO configuration supports the following settings:
@@ -59,7 +61,7 @@ class AsyncServer(server.Server):
                             ``False``.
     """
     def __init__(self, client_manager=None, logger=False, json=None,
-                 async_handlers=False, **kwargs):
+                 async_handlers=True, **kwargs):
         if client_manager is None:
             client_manager = asyncio_manager.AsyncManager()
         super().__init__(client_manager=client_manager, logger=logger,
@@ -112,8 +114,9 @@ async def emit(self, event, data=None, room=None, skip_sid=None,
         namespace = namespace or '/'
         self.logger.info('emitting event "%s" to %s [%s]', event,
                          room or 'all', namespace)
-        await self.manager.emit(event, data, namespace, room, skip_sid,
-                                callback, **kwargs)
+        await self.manager.emit(event, data, namespace, room=room,
+                                skip_sid=skip_sid, callback=callback,
+                                **kwargs)
 
     async def send(self, data, room=None, skip_sid=None, namespace=None,
                    callback=None, **kwargs):
@@ -151,9 +154,54 @@ async def send(self, data, room=None, skip_sid=None, namespace=None,
 
         Note: this method is a coroutine.
         """
-        await self.emit('message', data, room, skip_sid, namespace, callback,
-                        **kwargs)
+        await self.emit('message', data=data, room=room, skip_sid=skip_sid,
+                        namespace=namespace, callback=callback, **kwargs)
 
+    async def call(self, event, data=None, sid=None, namespace=None,
+                   timeout=60, **kwargs):
+        """Emit a custom event to a client and wait for the response.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. If a
+                     ``list`` or ``dict``, the data will be serialized as JSON.
+        :param sid: The session ID of the recipient client.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             client directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+        """
+        if not self.async_handlers:
+            raise RuntimeError(
+                'Cannot use call() when async_handlers is False.')
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+        
+        await self.emit(event, data=data, room=sid, namespace=namespace,
+                        callback=event_callback, **kwargs)
+        try:
+            await asyncio.wait_for(callback_event.wait(), timeout)
+        except asyncio.TimeoutError:
+            six.raise_from(exceptions.TimeoutError(), None)
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+                else None
+    
     async def close_room(self, room, namespace=None):
         """Close a room.
 

socketio/client.py

@@ -224,8 +224,7 @@ def wait(self):
             if self.eio.state != 'connected':
                 break
 
-    def emit(self, event, data=None, namespace=None, callback=None,
-             wait=False, timeout=60):
+    def emit(self, event, data=None, namespace=None, callback=None):
         """Emit a custom event to one or more connected clients.
 
         :param event: The event name. It can be any string. The event names
@@ -242,28 +241,9 @@ def emit(self, event, data=None, namespace=None, callback=None,
                          that will be passed to the function are those provided
                          by the client. Callback functions can only be used
                          when addressing an individual client.
-        :param wait: If set to ``True``, this function will wait for the
-                     server to handle the event and acknowledge it via its
-                     callback function. The value(s) passed by the server to
-                     its callback will be returned. If set to ``False``,
-                     this function emits the event and returns immediately.
-        :param timeout: If ``wait`` is set to ``True``, this parameter
-                        specifies a waiting timeout. If the timeout is reached
-                        before the server acknowledges the event, then a
-                        ``TimeoutError`` exception is raised.
         """
         namespace = namespace or '/'
         self.logger.info('Emitting event "%s" [%s]', event, namespace)
-        if wait is True:
-            callback_event = self.eio.create_event()
-            callback_args = []
-
-            def event_callback(*args):
-                callback_args.append(args)
-                callback_event.set()
-
-            callback = event_callback
-
         if callback is not None:
             id = self._generate_ack_id(namespace, callback)
         else:
@@ -283,12 +263,6 @@ def event_callback(*args):
         self._send_packet(packet.Packet(packet.EVENT, namespace=namespace,
                                         data=[event] + data, id=id,
                                         binary=binary))
-        if wait is True:
-            if not callback_event.wait(timeout=timeout):
-                raise exceptions.TimeoutError()
-            return callback_args[0] if len(callback_args[0]) > 1 \
-                else callback_args[0][0] if len(callback_args[0]) == 1 \
-                    else None
 
     def send(self, data, namespace=None, callback=None, wait=False,
              timeout=60):
@@ -321,6 +295,37 @@ def send(self, data, namespace=None, callback=None, wait=False,
         self.emit('message', data=data, namespace=namespace,
                   callback=callback, wait=wait, timeout=timeout)
 
+    def call(self, event, data=None, namespace=None, timeout=60):
+        """Emit a custom event to a client and wait for the response.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. If a
+                     ``list`` or ``dict``, the data will be serialized as JSON.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+        """
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+        
+        self.emit(event, data=data, namespace=namespace,
+                  callback=event_callback)
+        if not callback_event.wait(timeout=timeout):
+            raise exceptions.TimeoutError()
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+                else None
+
     def disconnect(self):
         """Disconnect from the server."""
         for n in self.namespaces:

socketio/server.py

@@ -4,8 +4,9 @@
 import six
 
 from . import base_manager
-from . import packet
+from . import exceptions
 from . import namespace
+from . import packet
 
 default_logger = logging.getLogger('socketio.server')
 
@@ -33,9 +34,10 @@ class Server(object):
                  packets. Custom json modules must have ``dumps`` and ``loads``
                  functions that are compatible with the standard library
                  versions.
-    :param async_handlers: If set to ``True``, event handlers are executed in
-                           separate threads. To run handlers synchronously,
-                           set to ``False``. The default is ``False``.
+    :param async_handlers: If set to ``True``, event handlers for a client are
+                           executed in separate threads. To run handlers for a
+                           client synchronously, set to ``False``. The default
+                           is ``True``.
     :param kwargs: Connection parameters for the underlying Engine.IO server.
 
     The Engine.IO configuration supports the following settings:
@@ -77,7 +79,7 @@ class Server(object):
                             ``False``. The default is ``False``.
     """
     def __init__(self, client_manager=None, logger=False, binary=False,
-                 json=None, async_handlers=False, **kwargs):
+                 json=None, async_handlers=True, **kwargs):
         engineio_options = kwargs
         engineio_logger = engineio_options.pop('engineio_logger', None)
         if engineio_logger is not None:
@@ -224,11 +226,11 @@ def emit(self, event, data=None, room=None, skip_sid=None, namespace=None,
         namespace = namespace or '/'
         self.logger.info('emitting event "%s" to %s [%s]', event,
                          room or 'all', namespace)
-        self.manager.emit(event, data, namespace, room, skip_sid, callback,
-                          **kwargs)
+        self.manager.emit(event, data, namespace, room=room,
+                          skip_sid=skip_sid, callback=callback, **kwargs)
 
     def send(self, data, room=None, skip_sid=None, namespace=None,
-             callback=None, **kwargs):
+             callback=None, wait=False, timeout=60, **kwargs):
         """Send a message to one or more connected clients.
 
         This function emits an event with the name ``'message'``. Use
@@ -261,8 +263,51 @@ def send(self, data, room=None, skip_sid=None, namespace=None,
                              to always leave this parameter with its default
                              value of ``False``.
         """
-        self.emit('message', data, room, skip_sid, namespace, callback,
-                  **kwargs)
+        self.emit('message', data=data, room=room, skip_sid=skip_sid,
+                  namespace=namespace, callback=callback, **kwargs)
+
+    def call(self, event, data=None, sid=None, namespace=None, timeout=60,
+             **kwargs):
+        """Emit a custom event to a client and wait for the response.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. If a
+                     ``list`` or ``dict``, the data will be serialized as JSON.
+        :param sid: The session ID of the recipient client.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             client directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+        """
+        if not self.async_handlers:
+            raise RuntimeError(
+                'Cannot use call() when async_handlers is False.')
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+        
+        self.emit(event, data=data, room=sid, namespace=namespace,
+                  callback=event_callback, **kwargs)
+        if not callback_event.wait(timeout=timeout):
+            raise exceptions.TimeoutError()
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+                else None
 
     def enter_room(self, sid, room, namespace=None):
         """Enter a room.