From aee4345020957ebe7f360b30a4bb8a00f87e5fa8 Mon Sep 17 00:00:00 2001 From: Ask Solem Date: Tue, 24 Sep 2013 14:31:28 +0100 Subject: [PATCH] Renamed serialization.encode/decode -> .dumps, .loads --- kombu/messaging.py | 4 +- kombu/serialization.py | 40 ++++----- kombu/tests/test_serialization.py | 132 ++++++++++++++---------------- 3 files changed, 84 insertions(+), 92 deletions(-) diff --git a/kombu/messaging.py b/kombu/messaging.py index 753d8f36..87f6b224 100644 --- a/kombu/messaging.py +++ b/kombu/messaging.py @@ -14,7 +14,7 @@ from .connection import maybe_channel, is_connection from .entity import Exchange, Queue, DELIVERY_MODES from .exceptions import ContentDisallowed from .five import int_types, text_t, values -from .serialization import encode, prepare_accept_content +from .serialization import dumps, prepare_accept_content from .utils import ChannelPromise, maybe_list __all__ = ['Exchange', 'Queue', 'Producer', 'Consumer'] @@ -235,7 +235,7 @@ class Producer(object): if not content_type: serializer = serializer or self.serializer (content_type, content_encoding, - body) = encode(body, serializer=serializer) + body) = dumps(body, serializer=serializer) else: # If the programmer doesn't want us to serialize, # make sure content_encoding is set. diff --git a/kombu/serialization.py b/kombu/serialization.py index 489f97e3..dd2f6f34 100644 --- a/kombu/serialization.py +++ b/kombu/serialization.py @@ -24,7 +24,7 @@ from .five import BytesIO, text_t from .utils import entrypoints from .utils.encoding import str_to_bytes, bytes_t -__all__ = ['pickle', 'encode', 'decode', 'register', 'unregister'] +__all__ = ['pickle', 'loads', 'dumps', 'register', 'unregister'] SKIP_DECODE = frozenset(['binary', 'ascii-8bit']) if sys.platform.startswith('java'): # pragma: no cover @@ -116,7 +116,7 @@ class SerializerRegistry(object): raise SerializerNotInstalled( 'No encoder installed for {0}'.format(name)) - def encode(self, data, serializer=None): + def dumps(self, data, serializer=None): if serializer == 'raw': return raw_encode(data) if serializer and not self._encoders.get(serializer): @@ -146,9 +146,10 @@ class SerializerRegistry(object): payload = encoder(data) return content_type, content_encoding, payload + encode = dumps # XXX compat - def decode(self, data, content_type, content_encoding, - accept=None, force=False): + def loads(self, data, content_type, content_encoding, + accept=None, force=False): if accept is not None: if content_type not in accept: raise self._for_untrusted_content(content_type, 'untrusted') @@ -166,10 +167,11 @@ class SerializerRegistry(object): not isinstance(data, text_t): return _decode(data, content_encoding) return data + decode = loads # XXX compat def _for_untrusted_content(self, ctype, why): return ContentDisallowed( - 'Refusing to decode {0} content of type {1}'.format( + 'Refusing to deserialize {0} content of type {1}'.format( why, parenthesize_alias(self.type_to_name.get(ctype, ctype), ctype), ), @@ -181,7 +183,7 @@ registry = SerializerRegistry() """ -.. function:: encode(data, serializer=default_serializer) +.. function:: dumps(data, serializer=default_serializer) Serialize a data structure into a string suitable for sending as an AMQP message body. @@ -210,12 +212,12 @@ registry = SerializerRegistry() :raises SerializerNotInstalled: If the serialization method requested is not available. """ -encode = registry.encode +dumps = encode = registry.encode # XXX encode is a compat alias """ -.. function:: decode(data, content_type, content_encoding): +.. function:: loads(data, content_type, content_encoding): - Deserialize a data stream as serialized using `encode` + Deserialize a data stream as serialized using `dumps` based on `content_type`. :param data: The message data to deserialize. @@ -229,7 +231,7 @@ encode = registry.encode :returns: The unserialized data. """ -decode = registry.decode +loads = decode = registry.decode # XXX decode is a compat alias """ @@ -284,14 +286,14 @@ def raw_encode(data): def register_json(): """Register a encoder/decoder for JSON serialization.""" - from anyjson import loads, dumps + from anyjson import loads as json_loads, dumps as json_dumps def _loads(obj): if isinstance(obj, bytes_t): obj = obj.decode() - return loads(obj) + return json_loads(obj) - registry.register('json', dumps, _loads, + registry.register('json', json_dumps, _loads, content_type='application/json', content_encoding='utf-8') @@ -329,10 +331,10 @@ def register_pickle(): """The fastest serialization method, but restricts you to python clients.""" - def dumps(obj, dumper=pickle.dumps): + def pickle_dumps(obj, dumper=pickle.dumps): return dumper(obj, protocol=pickle_protocol) - registry.register('pickle', dumps, unpickle, + registry.register('pickle', pickle_dumps, unpickle, content_type='application/x-python-serialize', content_encoding='binary') @@ -341,13 +343,13 @@ def register_msgpack(): """See http://msgpack.sourceforge.net/""" try: try: - from msgpack import packb as dumps, unpackb - loads = lambda s: unpackb(s, encoding='utf-8') + from msgpack import packb as pack, unpackb + unpack = lambda s: unpackb(s, encoding='utf-8') except ImportError: # msgpack < 0.2.0 and Python 2.5 - from msgpack import packs as dumps, unpacks as loads # noqa + from msgpack import packs as pack, unpacks as unpack # noqa registry.register( - 'msgpack', dumps, loads, + 'msgpack', pack, unpack, content_type='application/x-msgpack', content_encoding='binary') except (ImportError, ValueError): diff --git a/kombu/tests/test_serialization.py b/kombu/tests/test_serialization.py index 6500a890..8ce1a425 100644 --- a/kombu/tests/test_serialization.py +++ b/kombu/tests/test_serialization.py @@ -12,7 +12,7 @@ from kombu.five import text_t, bytes_t from kombu.serialization import ( registry, register, SerializerNotInstalled, raw_encode, register_yaml, register_msgpack, - decode, pickle, pickle_protocol, + dumps, loads, pickle, pickle_protocol, unregister, register_pickle, enable_insecure_serializers, disable_insecure_serializers, ) @@ -99,74 +99,66 @@ class test_Serialization(Case): registry.enable('application/json') self.assertNotIn('application/json', registry._disabled_content_types) - def test_decode_when_disabled(self): + def test_loads_when_disabled(self): disabled = registry._disabled_content_types try: registry.disable('testS') with self.assertRaises(SerializerNotInstalled): - registry.decode( - 'xxd', 'application/testS', 'utf-8', force=False, - ) + loads('xxd', 'application/testS', 'utf-8', force=False) - ret = registry.decode( - 'xxd', 'application/testS', 'utf-8', force=True, - ) + ret = loads('xxd', 'application/testS', 'utf-8', force=True) self.assertEqual(ret, 'decoded') finally: disabled.clear() - def test_decode_when_data_is_None(self): - registry.decode(None, 'application/testS', 'utf-8') + def test_loads_when_data_is_None(self): + loads(None, 'application/testS', 'utf-8') def test_content_type_decoding(self): self.assertEqual( unicode_string, - registry.decode(unicode_string_as_utf8, - content_type='plain/text', - content_encoding='utf-8'), + loads(unicode_string_as_utf8, + content_type='plain/text', content_encoding='utf-8'), ) self.assertEqual( latin_string, - registry.decode(latin_string_as_latin1, - content_type='application/data', - content_encoding='latin-1'), + loads(latin_string_as_latin1, + content_type='application/data', content_encoding='latin-1'), ) def test_content_type_binary(self): self.assertIsInstance( - registry.decode(unicode_string_as_utf8, - content_type='application/data', - content_encoding='binary'), + loads(unicode_string_as_utf8, + content_type='application/data', content_encoding='binary'), bytes_t, ) self.assertEqual( unicode_string_as_utf8, - registry.decode(unicode_string_as_utf8, - content_type='application/data', - content_encoding='binary'), + loads(unicode_string_as_utf8, + content_type='application/data', content_encoding='binary'), ) def test_content_type_encoding(self): # Using the 'raw' serializer self.assertEqual( unicode_string_as_utf8, - registry.encode(unicode_string, serializer='raw')[-1], + dumps(unicode_string, serializer='raw')[-1], ) self.assertEqual( latin_string_as_utf8, - registry.encode(latin_string, serializer='raw')[-1], + dumps(latin_string, serializer='raw')[-1], ) # And again w/o a specific serializer to check the # code where we force unicode objects into a string. self.assertEqual( unicode_string_as_utf8, - registry.encode(unicode_string)[-1], + dumps(unicode_string)[-1], ) self.assertEqual( latin_string_as_utf8, - registry.encode(latin_string)[-1], + dumps(latin_string)[-1], ) def test_enable_insecure_serializers(self): @@ -194,22 +186,21 @@ class test_Serialization(Case): call('pickle'), call('yaml'), call('doomsday') ]) - def test_json_decode(self): + def test_json_loads(self): self.assertEqual( py_data, - registry.decode(json_data, - content_type='application/json', - content_encoding='utf-8'), + loads(json_data, + content_type='application/json', content_encoding='utf-8'), ) - def test_json_encode(self): + def test_json_dumps(self): self.assertEqual( - registry.decode( - registry.encode(py_data, serializer='json')[-1], + loads( + dumps(py_data, serializer='json')[-1], content_type='application/json', content_encoding='utf-8', ), - registry.decode( + loads( json_data, content_type='application/json', content_encoding='utf-8', @@ -217,11 +208,11 @@ class test_Serialization(Case): ) @skip_if_not_module('msgpack', (ImportError, ValueError)) - def test_msgpack_decode(self): + def test_msgpack_loads(self): register_msgpack() - res = registry.decode(msgpack_data, - content_type='application/x-msgpack', - content_encoding='binary') + res = loads(msgpack_data, + content_type='application/x-msgpack', + content_encoding='binary') if sys.version_info[0] < 3: for k, v in res.items(): if isinstance(v, text_t): @@ -234,15 +225,15 @@ class test_Serialization(Case): ) @skip_if_not_module('msgpack', (ImportError, ValueError)) - def test_msgpack_encode(self): + def test_msgpack_dumps(self): register_msgpack() self.assertEqual( - registry.decode( - registry.encode(msgpack_py_data, serializer='msgpack')[-1], + loads( + dumps(msgpack_py_data, serializer='msgpack')[-1], content_type='application/x-msgpack', content_encoding='binary', ), - registry.decode( + loads( msgpack_data, content_type='application/x-msgpack', content_encoding='binary', @@ -250,43 +241,43 @@ class test_Serialization(Case): ) @skip_if_not_module('yaml') - def test_yaml_decode(self): + def test_yaml_loads(self): register_yaml() self.assertEqual( py_data, - registry.decode(yaml_data, - content_type='application/x-yaml', - content_encoding='utf-8'), + loads(yaml_data, + content_type='application/x-yaml', + content_encoding='utf-8'), ) @skip_if_not_module('yaml') - def test_yaml_encode(self): + def test_yaml_dumps(self): register_yaml() self.assertEqual( - registry.decode( - registry.encode(py_data, serializer='yaml')[-1], + loads( + dumps(py_data, serializer='yaml')[-1], content_type='application/x-yaml', content_encoding='utf-8', ), - registry.decode( + loads( yaml_data, content_type='application/x-yaml', content_encoding='utf-8', ), ) - def test_pickle_decode(self): + def test_pickle_loads(self): self.assertEqual( py_data, - registry.decode(pickle_data, - content_type='application/x-python-serialize', - content_encoding='binary'), + loads(pickle_data, + content_type='application/x-python-serialize', + content_encoding='binary'), ) - def test_pickle_encode(self): + def test_pickle_dumps(self): self.assertEqual( pickle.loads(pickle_data), - pickle.loads(registry.encode(py_data, serializer='pickle')[-1]), + pickle.loads(dumps(py_data, serializer='pickle')[-1]), ) def test_register(self): @@ -295,35 +286,34 @@ class test_Serialization(Case): def test_unregister(self): with self.assertRaises(SerializerNotInstalled): unregister('nonexisting') - registry.encode('foo', serializer='pickle') + dumps('foo', serializer='pickle') unregister('pickle') with self.assertRaises(SerializerNotInstalled): - registry.encode('foo', serializer='pickle') + dumps('foo', serializer='pickle') register_pickle() def test_set_default_serializer_missing(self): with self.assertRaises(SerializerNotInstalled): registry._set_default_serializer('nonexisting') - def test_encode_missing(self): + def test_dumps_missing(self): with self.assertRaises(SerializerNotInstalled): - registry.encode('foo', serializer='nonexisting') + dumps('foo', serializer='nonexisting') - def test_encode__no_serializer(self): - ctyp, cenc, data = registry.encode(str_to_bytes('foo')) + def test_dumps__no_serializer(self): + ctyp, cenc, data = dumps(str_to_bytes('foo')) self.assertEqual(ctyp, 'application/data') self.assertEqual(cenc, 'binary') - def test_decode__not_accepted(self): + def test_loads__not_accepted(self): with self.assertRaises(ContentDisallowed): - registry.decode('tainted', 'application/x-evil', - 'binary', accept=[]) + loads('tainted', 'application/x-evil', 'binary', accept=[]) with self.assertRaises(ContentDisallowed): - registry.decode('tainted', 'application/x-evil', 'binary', - accept=['application/x-json']) + loads('tainted', 'application/x-evil', 'binary', + accept=['application/x-json']) self.assertTrue( - registry.decode('tainted', 'application/x-doomsday', 'binary', - accept=['application/x-doomsday']) + loads('tainted', 'application/x-doomsday', 'binary', + accept=['application/x-doomsday']) ) def test_raw_encode(self): @@ -336,10 +326,10 @@ class test_Serialization(Case): def test_register_yaml__no_yaml(self): register_yaml() with self.assertRaises(SerializerNotInstalled): - decode('foo', 'application/x-yaml', 'utf-8') + loads('foo', 'application/x-yaml', 'utf-8') @mask_modules('msgpack') def test_register_msgpack__no_msgpack(self): register_msgpack() with self.assertRaises(SerializerNotInstalled): - decode('foo', 'application/x-msgpack', 'utf-8') + loads('foo', 'application/x-msgpack', 'utf-8')