MsgPackPacket.configure method

Author: miguelgrinberg

src/socketio/async_client.py

@@ -45,9 +45,6 @@ class AsyncClient(base_client.BaseClient):
                           leave interrupt handling to the calling application.
                           Interrupt handling can only be enabled when the
                           client instance is created in the main thread.
-    :param serializer_args: A mapping of additional parameters to pass to
-                            the serializer. The content of this dictionary
-                            depends on the selected serialization method.
 
     The Engine.IO configuration supports the following settings:
 
@@ -246,7 +243,7 @@ async def emit(self, event, data=None, namespace=None, callback=None):
             data = [data]
         else:
             data = []
-        await self._send_packet(self._create_packet(
+        await self._send_packet(self.packet_class(
             packet.EVENT, namespace=namespace, data=[event] + data, id=id))
 
     async def send(self, data, namespace=None, callback=None):
@@ -328,7 +325,7 @@ async def disconnect(self):
         # here we just request the disconnection
         # later in _handle_eio_disconnect we invoke the disconnect handler
         for n in self.namespaces:
-            await self._send_packet(self._create_packet(packet.DISCONNECT,
+            await self._send_packet(self.packet_class(packet.DISCONNECT,
                                     namespace=n))
         await self.eio.disconnect()
 
@@ -425,7 +422,7 @@ async def _handle_event(self, namespace, id, data):
                 data = list(r)
             else:
                 data = [r]
-            await self._send_packet(self._create_packet(
+            await self._send_packet(self.packet_class(
                 packet.ACK, namespace=namespace, id=id, data=data))
 
     async def _handle_ack(self, namespace, id, data):
@@ -558,7 +555,7 @@ async def _handle_eio_connect(self):
         self.sid = self.eio.sid
         real_auth = await self._get_real_value(self.connection_auth) or {}
         for n in self.connection_namespaces:
-            await self._send_packet(self._create_packet(
+            await self._send_packet(self.packet_class(
                 packet.CONNECT, data=real_auth, namespace=n))
 
     async def _handle_eio_message(self, data):
@@ -572,7 +569,7 @@ async def _handle_eio_message(self, data):
                 else:
                     await self._handle_ack(pkt.namespace, pkt.id, pkt.data)
         else:
-            pkt = self._create_packet(encoded_packet=data)
+            pkt = self.packet_class(encoded_packet=data)
             if pkt.packet_type == packet.CONNECT:
                 await self._handle_connect(pkt.namespace, pkt.data)
             elif pkt.packet_type == packet.DISCONNECT:

src/socketio/async_server.py

@@ -428,7 +428,7 @@ async def disconnect(self, sid, namespace=None, ignore_queue=False):
         if delete_it:
             self.logger.info('Disconnecting %s [%s]', sid, namespace)
             eio_sid = self.manager.pre_disconnect(sid, namespace=namespace)
-            await self._send_packet(eio_sid, self._create_packet(
+            await self._send_packet(eio_sid, self.packet_class(
                 packet.DISCONNECT, namespace=namespace))
             await self._trigger_event('disconnect', namespace, sid,
                                       self.reason.SERVER_DISCONNECT)
@@ -541,13 +541,13 @@ async def _handle_connect(self, eio_sid, namespace, data):
                 or self.namespaces == '*' or namespace in self.namespaces:
             sid = await self.manager.connect(eio_sid, namespace)
         if sid is None:
-            await self._send_packet(eio_sid, self._create_packet(
+            await self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT_ERROR, data='Unable to connect',
                 namespace=namespace))
             return
 
         if self.always_connect:
-            await self._send_packet(eio_sid, self._create_packet(
+            await self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT, {'sid': sid}, namespace=namespace))
         fail_reason = exceptions.ConnectionRefusedError().error_args
         try:
@@ -571,15 +571,15 @@ async def _handle_connect(self, eio_sid, namespace, data):
         if success is False:
             if self.always_connect:
                 self.manager.pre_disconnect(sid, namespace)
-                await self._send_packet(eio_sid, self._create_packet(
+                await self._send_packet(eio_sid, self.packet_class(
                     packet.DISCONNECT, data=fail_reason, namespace=namespace))
             else:
-                await self._send_packet(eio_sid, self._create_packet(
+                await self._send_packet(eio_sid, self.packet_class(
                     packet.CONNECT_ERROR, data=fail_reason,
                     namespace=namespace))
             await self.manager.disconnect(sid, namespace, ignore_queue=True)
         elif not self.always_connect:
-            await self._send_packet(eio_sid, self._create_packet(
+            await self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT, {'sid': sid}, namespace=namespace))
 
     async def _handle_disconnect(self, eio_sid, namespace, reason=None):
@@ -625,7 +625,7 @@ async def _handle_event_internal(self, server, sid, eio_sid, data,
                 data = list(r)
             else:
                 data = [r]
-            await server._send_packet(eio_sid, self._create_packet(
+            await server._send_packet(eio_sid, self.packet_class(
                 packet.ACK, namespace=namespace, id=id, data=data))
 
     async def _handle_ack(self, eio_sid, namespace, id, data):
@@ -689,7 +689,7 @@ async def _handle_eio_message(self, eio_sid, data):
                     await self._handle_ack(eio_sid, pkt.namespace, pkt.id,
                                            pkt.data)
         else:
-            pkt = self._create_packet(encoded_packet=data)
+            pkt = self.packet_class(encoded_packet=data)
             if pkt.packet_type == packet.CONNECT:
                 await self._handle_connect(eio_sid, pkt.namespace, pkt.data)
             elif pkt.packet_type == packet.DISCONNECT:

src/socketio/base_client.py

@@ -38,8 +38,7 @@ class BaseClient:
     def __init__(self, reconnection=True, reconnection_attempts=0,
                  reconnection_delay=1, reconnection_delay_max=5,
                  randomization_factor=0.5, logger=False, serializer='default',
-                 json=None, handle_sigint=True, serializer_args=None,
-                 **kwargs):
+                 json=None, handle_sigint=True, **kwargs):
         global original_signal_handler
         if handle_sigint and original_signal_handler is None and \
                 threading.current_thread() == threading.main_thread():
@@ -64,7 +63,6 @@ def __init__(self, reconnection=True, reconnection_attempts=0,
             self.packet_class = msgpack_packet.MsgPackPacket
         else:
             self.packet_class = serializer
-        self.packet_class_args = serializer_args or {}
         if json is not None:
             self.packet_class.json = json
             engineio_options['json'] = json
@@ -285,9 +283,6 @@ def _generate_ack_id(self, namespace, callback):
         self.callbacks[namespace][id] = callback
         return id
 
-    def _create_packet(self, *args, **kwargs):
-        return self.packet_class(*args, **kwargs, **self.packet_class_args)
-
     def _handle_eio_connect(self):  # pragma: no cover
         raise NotImplementedError()
 

src/socketio/base_server.py

@@ -15,7 +15,7 @@ class BaseServer:
 
     def __init__(self, client_manager=None, logger=False, serializer='default',
                  json=None, async_handlers=True, always_connect=False,
-                 namespaces=None, serializer_args=None, **kwargs):
+                 namespaces=None, **kwargs):
         engineio_options = kwargs
         engineio_logger = engineio_options.pop('engineio_logger', None)
         if engineio_logger is not None:
@@ -27,7 +27,6 @@ def __init__(self, client_manager=None, logger=False, serializer='default',
             self.packet_class = msgpack_packet.MsgPackPacket
         else:
             self.packet_class = serializer
-        self.packet_class_args = serializer_args or {}
         if json is not None:
             self.packet_class.json = json
             engineio_options['json'] = json
@@ -254,10 +253,6 @@ def _get_namespace_handler(self, namespace, args):
             args = (namespace, *args)
         return handler, args
 
-    def _create_packet(self, *args, **kwargs):
-        return self.packet_class(*args, **kwargs,
-                                 **self.packet_class_args)
-
     def _handle_eio_connect(self):  # pragma: no cover
         raise NotImplementedError()
 

src/socketio/client.py

@@ -48,9 +48,6 @@ class Client(base_client.BaseClient):
                           leave interrupt handling to the calling application.
                           Interrupt handling can only be enabled when the
                           client instance is created in the main thread.
-    :param serializer_args: A mapping of additional parameters to pass to
-                            the serializer. The content of this dictionary
-                            depends on the selected serialization method.
 
     The Engine.IO configuration supports the following settings:
 
@@ -238,8 +235,8 @@ def emit(self, event, data=None, namespace=None, callback=None):
         else:
             data = []
         self._send_packet(
-            self._create_packet(packet.EVENT, namespace=namespace,
-                                data=[event] + data, id=id))
+            self.packet_class(packet.EVENT, namespace=namespace,
+                              data=[event] + data, id=id))
 
     def send(self, data, namespace=None, callback=None):
         """Send a message to the server.
@@ -311,7 +308,7 @@ def disconnect(self):
         # here we just request the disconnection
         # later in _handle_eio_disconnect we invoke the disconnect handler
         for n in self.namespaces:
-            self._send_packet(self._create_packet(
+            self._send_packet(self.packet_class(
                 packet.DISCONNECT, namespace=n))
         self.eio.disconnect()
 
@@ -406,7 +403,7 @@ def _handle_event(self, namespace, id, data):
                 data = list(r)
             else:
                 data = [r]
-            self._send_packet(self._create_packet(
+            self._send_packet(self.packet_class(
                 packet.ACK, namespace=namespace, id=id, data=data))
 
     def _handle_ack(self, namespace, id, data):
@@ -510,7 +507,7 @@ def _handle_eio_connect(self):
         self.sid = self.eio.sid
         real_auth = self._get_real_value(self.connection_auth) or {}
         for n in self.connection_namespaces:
-            self._send_packet(self._create_packet(
+            self._send_packet(self.packet_class(
                 packet.CONNECT, data=real_auth, namespace=n))
 
     def _handle_eio_message(self, data):
@@ -524,7 +521,7 @@ def _handle_eio_message(self, data):
                 else:
                     self._handle_ack(pkt.namespace, pkt.id, pkt.data)
         else:
-            pkt = self._create_packet(encoded_packet=data)
+            pkt = self.packet_class(encoded_packet=data)
             if pkt.packet_type == packet.CONNECT:
                 self._handle_connect(pkt.namespace, pkt.data)
             elif pkt.packet_type == packet.DISCONNECT:

src/socketio/msgpack_packet.py

@@ -4,6 +4,18 @@
 
 class MsgPackPacket(packet.Packet):
     uses_binary_events = False
+    dumps_default = None
+    ext_hook = None
+
+    @classmethod
+    def configure(cls, dumps_default=None, ext_hook=None):
+        class CustomMsgPackPacket(MsgPackPacket):
+            dumps_default = None
+            ext_hook = None
+
+        CustomMsgPackPacket.dumps_default = dumps_default
+        CustomMsgPackPacket.ext_hook = ext_hook
+        return CustomMsgPackPacket
 
     def __init__(
         self,
@@ -13,25 +25,23 @@ def __init__(
         id=None,
         binary=None,
         encoded_packet=None,
-        dumps_default=None,
-        ext_hook=None,
     ):
-        self.dumps_default = dumps_default
-        self.ext_hook = ext_hook
         super().__init__(
             packet_type, data, namespace, id, binary, encoded_packet
         )
 
     def encode(self):
         """Encode the packet for transmission."""
-        return msgpack.dumps(self._to_dict(), default=self.dumps_default)
+        return msgpack.dumps(self._to_dict(),
+                             default=self.__class__.dumps_default)
 
     def decode(self, encoded_packet):
         """Decode a transmitted package."""
         if self.ext_hook is None:
             decoded = msgpack.loads(encoded_packet)
         else:
-            decoded = msgpack.loads(encoded_packet, ext_hook=self.ext_hook)
+            decoded = msgpack.loads(encoded_packet,
+                                    ext_hook=self.__class__.ext_hook)
         self.packet_type = decoded['type']
         self.data = decoded.get('data')
         self.id = decoded.get('id')

src/socketio/server.py

@@ -53,9 +53,6 @@ class Server(base_server.BaseServer):
                        default is `['/']`, which always accepts connections to
                        the default namespace. Set to `'*'` to accept all
                        namespaces.
-    :param serializer_args: A mapping of additional parameters to pass to
-                            the serializer. The content of this dictionary
-                            depends on the selected serialization method.
     :param kwargs: Connection parameters for the underlying Engine.IO server.
 
     The Engine.IO configuration supports the following settings:
@@ -404,7 +401,7 @@ def disconnect(self, sid, namespace=None, ignore_queue=False):
         if delete_it:
             self.logger.info('Disconnecting %s [%s]', sid, namespace)
             eio_sid = self.manager.pre_disconnect(sid, namespace=namespace)
-            self._send_packet(eio_sid, self._create_packet(
+            self._send_packet(eio_sid, self.packet_class(
                 packet.DISCONNECT, namespace=namespace))
             self._trigger_event('disconnect', namespace, sid,
                                 self.reason.SERVER_DISCONNECT)
@@ -523,13 +520,13 @@ def _handle_connect(self, eio_sid, namespace, data):
                 or self.namespaces == '*' or namespace in self.namespaces:
             sid = self.manager.connect(eio_sid, namespace)
         if sid is None:
-            self._send_packet(eio_sid, self._create_packet(
+            self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT_ERROR, data='Unable to connect',
                 namespace=namespace))
             return
 
         if self.always_connect:
-            self._send_packet(eio_sid, self._create_packet(
+            self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT, {'sid': sid}, namespace=namespace))
         fail_reason = exceptions.ConnectionRefusedError().error_args
         try:
@@ -553,15 +550,15 @@ def _handle_connect(self, eio_sid, namespace, data):
         if success is False:
             if self.always_connect:
                 self.manager.pre_disconnect(sid, namespace)
-                self._send_packet(eio_sid, self._create_packet(
+                self._send_packet(eio_sid, self.packet_class(
                     packet.DISCONNECT, data=fail_reason, namespace=namespace))
             else:
-                self._send_packet(eio_sid, self._create_packet(
+                self._send_packet(eio_sid, self.packet_class(
                     packet.CONNECT_ERROR, data=fail_reason,
                     namespace=namespace))
             self.manager.disconnect(sid, namespace, ignore_queue=True)
         elif not self.always_connect:
-            self._send_packet(eio_sid, self._create_packet(
+            self._send_packet(eio_sid, self.packet_class(
                 packet.CONNECT, {'sid': sid}, namespace=namespace))
 
     def _handle_disconnect(self, eio_sid, namespace, reason=None):
@@ -604,7 +601,7 @@ def _handle_event_internal(self, server, sid, eio_sid, data, namespace,
                 data = list(r)
             else:
                 data = [r]
-            server._send_packet(eio_sid, self._create_packet(
+            server._send_packet(eio_sid, self.packet_class(
                 packet.ACK, namespace=namespace, id=id, data=data))
 
     def _handle_ack(self, eio_sid, namespace, id, data):
@@ -653,7 +650,7 @@ def _handle_eio_message(self, eio_sid, data):
                 else:
                     self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data)
         else:
-            pkt = self._create_packet(encoded_packet=data)
+            pkt = self.packet_class(encoded_packet=data)
             if pkt.packet_type == packet.CONNECT:
                 self._handle_connect(eio_sid, pkt.namespace, pkt.data)
             elif pkt.packet_type == packet.DISCONNECT:

tests/async/test_client.py

@@ -9,6 +9,7 @@
 from engineio import exceptions as engineio_exceptions
 from socketio import exceptions
 from socketio import packet
+from socketio.msgpack_packet import MsgPackPacket
 
 
 class TestAsyncClient:
@@ -1244,32 +1245,20 @@ async def test_eio_disconnect_no_reconnect(self):
         assert not c.connected
         c.start_background_task.assert_not_called()
 
-    def test_serializer_args(self):
-        args = {"foo": "bar"}
-        c = async_client.AsyncClient(serializer_args=args)
-        assert c.packet_class_args == args
-
     def test_serializer_args_with_msgpack(self):
         def default(o):
             if isinstance(o, datetime):
                 return o.isoformat()
             raise TypeError("Unknown type")
-        args = {"dumps_default": default}
+
         data = {"current": datetime.now(timezone(timedelta(0)))}
-        c = async_client.AsyncClient(serializer='msgpack',
-                                     serializer_args=args)
-        p = c._create_packet(data=data)
-        p2 = c._create_packet(encoded_packet=p.encode())
+        c = async_client.AsyncClient(
+            serializer=MsgPackPacket.configure(dumps_default=default))
+        p = c.packet_class(data=data)
+        p2 = c.packet_class(encoded_packet=p.encode())
 
         assert p.data != p2.data
         assert isinstance(p2.data, dict)
         assert "current" in p2.data
         assert isinstance(p2.data["current"], str)
         assert default(data["current"]) == p2.data["current"]
-
-    def test_invalid_serializer_args(self):
-        args = {"invalid_arg": 123}
-        c = async_client.AsyncClient(serializer='msgpack',
-                                     serializer_args=args)
-        with pytest.raises(TypeError):
-            c._create_packet(data={"foo": "bar"}).encode()