From c7b872915c24e06a0a15b37497d877605826bc58 Mon Sep 17 00:00:00 2001 From: Miguel Grinberg Date: Thu, 6 Nov 2025 19:33:24 +0000 Subject: [PATCH] MsgPackPacket.configure method --- src/socketio/async_client.py | 13 ++++------- src/socketio/async_server.py | 19 +++++++-------- src/socketio/base_client.py | 7 +----- src/socketio/base_server.py | 7 +----- src/socketio/client.py | 16 +++++-------- src/socketio/msgpack_packet.py | 36 ++++++++++++----------------- src/socketio/server.py | 19 +++++++-------- tests/async/test_client.py | 23 +++++------------- tests/async/test_server.py | 23 +++++------------- tests/common/test_client.py | 21 +++++------------ tests/common/test_msgpack_packet.py | 19 +++++++-------- tests/common/test_server.py | 21 +++++------------ 12 files changed, 78 insertions(+), 146 deletions(-) diff --git a/src/socketio/async_client.py b/src/socketio/async_client.py index c19c845..678743a 100644 --- a/src/socketio/async_client.py +++ b/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 @@ class AsyncClient(base_client.BaseClient): 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 @@ class AsyncClient(base_client.BaseClient): # 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 @@ class AsyncClient(base_client.BaseClient): 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 @@ class AsyncClient(base_client.BaseClient): 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 @@ class AsyncClient(base_client.BaseClient): 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: diff --git a/src/socketio/async_server.py b/src/socketio/async_server.py index fa22393..6c9e3ca 100644 --- a/src/socketio/async_server.py +++ b/src/socketio/async_server.py @@ -50,9 +50,6 @@ class AsyncServer(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: @@ -428,7 +425,7 @@ class AsyncServer(base_server.BaseServer): 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 +538,13 @@ class AsyncServer(base_server.BaseServer): 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 +568,15 @@ class AsyncServer(base_server.BaseServer): 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 +622,7 @@ class AsyncServer(base_server.BaseServer): 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 +686,7 @@ class AsyncServer(base_server.BaseServer): 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: diff --git a/src/socketio/base_client.py b/src/socketio/base_client.py index 2bcaafc..0232dca 100644 --- a/src/socketio/base_client.py +++ b/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 @@ class BaseClient: 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 @@ class BaseClient: 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() diff --git a/src/socketio/base_server.py b/src/socketio/base_server.py index 488ffe1..d134eba 100644 --- a/src/socketio/base_server.py +++ b/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 @@ class BaseServer: 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 @@ class BaseServer: 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() diff --git a/src/socketio/client.py b/src/socketio/client.py index 29c1f25..5282e0a 100644 --- a/src/socketio/client.py +++ b/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: @@ -237,9 +234,8 @@ class Client(base_client.BaseClient): data = [data] else: data = [] - self._send_packet( - self._create_packet(packet.EVENT, namespace=namespace, - data=[event] + data, id=id)) + self._send_packet(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 +307,7 @@ class Client(base_client.BaseClient): # 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 +402,7 @@ class Client(base_client.BaseClient): 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 +506,7 @@ class Client(base_client.BaseClient): 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 +520,7 @@ class Client(base_client.BaseClient): 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: diff --git a/src/socketio/msgpack_packet.py b/src/socketio/msgpack_packet.py index 846db2f..9622dd2 100644 --- a/src/socketio/msgpack_packet.py +++ b/src/socketio/msgpack_packet.py @@ -4,34 +4,28 @@ from . import packet class MsgPackPacket(packet.Packet): uses_binary_events = False + dumps_default = None + ext_hook = msgpack.ExtType - def __init__( - self, - packet_type=packet.EVENT, - data=None, - namespace=None, - 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 - ) + @classmethod + def configure(cls, dumps_default=None, ext_hook=msgpack.ExtType): + class CustomMsgPackPacket(MsgPackPacket): + dumps_default = None + ext_hook = None + + CustomMsgPackPacket.dumps_default = dumps_default + CustomMsgPackPacket.ext_hook = ext_hook + return CustomMsgPackPacket 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') diff --git a/src/socketio/server.py b/src/socketio/server.py index 7312506..f325708 100644 --- a/src/socketio/server.py +++ b/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 @@ class Server(base_server.BaseServer): 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 @@ class Server(base_server.BaseServer): 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 @@ class Server(base_server.BaseServer): 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 @@ class Server(base_server.BaseServer): 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 @@ class Server(base_server.BaseServer): 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: diff --git a/tests/async/test_client.py b/tests/async/test_client.py index 58e2ac7..7a7bfa7 100644 --- a/tests/async/test_client.py +++ b/tests/async/test_client.py @@ -9,6 +9,7 @@ from socketio import async_namespace 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 @@ class TestAsyncClient: 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() diff --git a/tests/async/test_server.py b/tests/async/test_server.py index 793192f..10d7ba1 100644 --- a/tests/async/test_server.py +++ b/tests/async/test_server.py @@ -12,6 +12,7 @@ from socketio import async_namespace from socketio import exceptions from socketio import namespace from socketio import packet +from socketio.msgpack_packet import MsgPackPacket @mock.patch('socketio.server.engineio.AsyncServer', **{ @@ -1091,32 +1092,20 @@ class TestAsyncServer: await s.sleep(1.23) s.eio.sleep.assert_awaited_once_with(1.23) - def test_serializer_args(self, eio): - args = {"foo": "bar"} - s = async_server.AsyncServer(serializer_args=args) - assert s.packet_class_args == args - def test_serializer_args_with_msgpack(self, eio): 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)))} - s = async_server.AsyncServer(serializer='msgpack', - serializer_args=args) - p = s._create_packet(data=data) - p2 = s._create_packet(encoded_packet=p.encode()) + s = async_server.AsyncServer( + serializer=MsgPackPacket.configure(dumps_default=default)) + p = s.packet_class(data=data) + p2 = s.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, eio): - args = {"invalid_arg": 123} - s = async_server.AsyncServer(serializer='msgpack', - serializer_args=args) - with pytest.raises(TypeError): - s._create_packet(data={"foo": "bar"}).encode() diff --git a/tests/common/test_client.py b/tests/common/test_client.py index 90ab5df..d386a9c 100644 --- a/tests/common/test_client.py +++ b/tests/common/test_client.py @@ -14,6 +14,7 @@ from socketio import exceptions from socketio import msgpack_packet from socketio import namespace from socketio import packet +from socketio.msgpack_packet import MsgPackPacket class TestClient: @@ -1388,30 +1389,20 @@ class TestClient: assert not c.connected c.start_background_task.assert_not_called() - def test_serializer_args(self): - args = {"foo": "bar"} - c = client.Client(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 = client.Client(serializer='msgpack', serializer_args=args) - p = c._create_packet(data=data) - p2 = c._create_packet(encoded_packet=p.encode()) + c = client.Client( + 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 = client.Client(serializer='msgpack', serializer_args=args) - with pytest.raises(TypeError): - c._create_packet(data={"foo": "bar"}).encode() diff --git a/tests/common/test_msgpack_packet.py b/tests/common/test_msgpack_packet.py index 8a3befd..0fad029 100644 --- a/tests/common/test_msgpack_packet.py +++ b/tests/common/test_msgpack_packet.py @@ -10,8 +10,7 @@ from socketio import packet class TestMsgPackPacket: def test_encode_decode(self): p = msgpack_packet.MsgPackPacket( - packet.CONNECT, data={'auth': {'token': '123'}}, namespace='/foo' - ) + packet.CONNECT, data={'auth': {'token': '123'}}, namespace='/foo') p2 = msgpack_packet.MsgPackPacket(encoded_packet=p.encode()) assert p.packet_type == p2.packet_type assert p.data == p2.data @@ -20,8 +19,7 @@ class TestMsgPackPacket: def test_encode_decode_with_id(self): p = msgpack_packet.MsgPackPacket( - packet.EVENT, data=['ev', 42], id=123, namespace='/foo' - ) + packet.EVENT, data=['ev', 42], id=123, namespace='/foo') p2 = msgpack_packet.MsgPackPacket(encoded_packet=p.encode()) assert p.packet_type == p2.packet_type assert p.data == p2.data @@ -50,7 +48,8 @@ class TestMsgPackPacket: 'current': datetime.now(tz=timezone(timedelta(0))), 'key': 'value', } - p = msgpack_packet.MsgPackPacket(data=data, dumps_default=default) + p = msgpack_packet.MsgPackPacket.configure(dumps_default=default)( + data=data) p2 = msgpack_packet.MsgPackPacket(encoded_packet=p.encode()) assert p.packet_type == p2.packet_type assert p.id == p2.id @@ -95,9 +94,10 @@ class TestMsgPackPacket: raise TypeError('Unknown ext type') data = {'custom': Custom(b'custom_data'), 'key': 'value'} - p = msgpack_packet.MsgPackPacket(data=data, dumps_default=default) - p2 = msgpack_packet.MsgPackPacket( - encoded_packet=p.encode(), ext_hook=ext_hook + p = msgpack_packet.MsgPackPacket.configure(dumps_default=default)( + data=data) + p2 = msgpack_packet.MsgPackPacket.configure(ext_hook=ext_hook)( + encoded_packet=p.encode() ) assert p.packet_type == p2.packet_type assert p.id == p2.id @@ -118,7 +118,8 @@ class TestMsgPackPacket: raise TypeError('Unknown type') data = {'custom': Custom(b'custom_data'), 'key': 'value'} - p = msgpack_packet.MsgPackPacket(data=data, dumps_default=default) + p = msgpack_packet.MsgPackPacket.configure(dumps_default=default)( + data=data) p2 = msgpack_packet.MsgPackPacket(encoded_packet=p.encode()) assert p.packet_type == p2.packet_type assert p.id == p2.id diff --git a/tests/common/test_server.py b/tests/common/test_server.py index 6bbe7c4..4c2c807 100644 --- a/tests/common/test_server.py +++ b/tests/common/test_server.py @@ -11,6 +11,7 @@ from socketio import msgpack_packet from socketio import namespace from socketio import packet from socketio import server +from socketio.msgpack_packet import MsgPackPacket @mock.patch('socketio.server.engineio.Server', **{ @@ -1034,30 +1035,20 @@ class TestServer: s.sleep(1.23) s.eio.sleep.assert_called_once_with(1.23) - def test_serializer_args(self, eio): - args = {"foo": "bar"} - s = server.Server(serializer_args=args) - assert s.packet_class_args == args - def test_serializer_args_with_msgpack(self, eio): 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)))} - s = server.Server(serializer='msgpack', serializer_args=args) - p = s._create_packet(data=data) - p2 = s._create_packet(encoded_packet=p.encode()) + s = server.Server( + serializer=MsgPackPacket.configure(dumps_default=default)) + p = s.packet_class(data=data) + p2 = s.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, eio): - args = {"invalid_arg": 123} - s = server.Server(serializer='msgpack', serializer_args=args) - with pytest.raises(TypeError): - s._create_packet(data={"foo": "bar"}).encode()