def test_odict():
seq = [(b'one', 1), (b'two', 2), (b'three', 3), (b'four', 4)]
od = OrderedDict(seq)
assert unpackb(packb(od), use_list=1) == dict(seq)
def pair_hook(seq):
return list(seq)
assert unpackb(packb(od), object_pairs_hook=pair_hook, use_list=1) == seq
def test_integer():
x = -(2 ** 63)
assert unpackb(packb(x)) == x
with pytest.raises(PackOverflowError):
packb(x-1)
x = 2 ** 64 - 1
assert unpackb(packb(x)) == x
with pytest.raises(PackOverflowError):
packb(x+1)
def decode(rlp,
sedes=None,
strict=True,
recursive_cache=False,
use_list=False,
**kwargs):
"""Decode an RLP encoded object.
If the deserialized result `obj` has an attribute :attr:`_cached_rlp` (e.g. if `sedes` is a
subclass of :class:`rlp.Serializable`) it will be set to `rlp`, which will improve performance
on subsequent :func:`rlp.encode` calls. Bear in mind however that `obj` needs to make sure that
this value is updated whenever one of its fields changes or prevent such changes entirely
(:class:`rlp.sedes.Serializable` does the latter).
:param sedes: an object implementing a function ``deserialize(code)`` which will be applied
after decoding, or ``None`` if no deserialization should be performed
:param \*\*kwargs: additional keyword arguments that will be passed to the deserializer
:param strict: if false inputs that are longer than necessary don't cause an exception
:returns: the decoded and maybe deserialized Python object
:raises: :exc:`rlp.DecodingError` if the input string does not end after the root item and
`strict` is true
:raises: :exc:`rlp.DeserializationError` if the deserialization fails
"""
if sedes:
try:
fast_sedes = sedes.get_sede_identifier()
except AttributeError:
# Default an identifier of 0, which is binary. This can be used in the case where the python sede converts to binary.
fast_sedes = 0
item = unpackb(rlp, sedes=fast_sedes, use_list=use_list)
else:
item = unpackb(
rlp, use_list=True
) #For some f*****g reason, if there are no sedes we the specifications say to return a list
# if not is_bytes(rlp):
# raise DecodingError('Can only decode RLP bytes, got type %s' % type(rlp).__name__, rlp)
# try:
# item, per_item_rlp, end = consume_item(rlp, 0)
# except IndexError:
# raise DecodingError('RLP string too short', rlp)
#this is checked withing msgpack
# if end != len(rlp) and strict:
# msg = 'RLP string ends with {} superfluous bytes'.format(len(rlp) - end)
# raise DecodingError(msg, rlp)
if sedes:
obj = sedes.deserialize(item, to_list=use_list, **kwargs)
# if is_sequence(obj) or hasattr(obj, '_cached_rlp'):
# _apply_rlp_cache(obj, per_item_rlp, recursive_cache)
return obj
else:
return item
def test_str8():
header = b'\xd9'
data = b'x' * 32
b = packb(data.decode(), use_bin_type=True)
assert len(b) == len(data) + 2
assert b[0:2] == header + b'\x20'
assert b[2:] == data
assert unpackb(b) == data
data = b'x' * 255
b = packb(data.decode(), use_bin_type=True)
assert len(b) == len(data) + 2
assert b[0:2] == header + b'\xff'
assert b[2:] == data
assert unpackb(b) == data
def test_bin8():
header = b'\xc4'
data = b''
b = packb(data, use_bin_type=True)
assert len(b) == len(data) + 2
assert b[0:2] == header + b'\x00'
assert b[2:] == data
assert unpackb(b) == data
data = b'x' * 255
b = packb(data, use_bin_type=True)
assert len(b) == len(data) + 2
assert b[0:2] == header + b'\xff'
assert b[2:] == data
assert unpackb(b) == data
def test_unpack_memoryview():
buf = bytearray(packb(('foo', 'bar')))
view = memoryview(buf)
obj = unpackb(view, use_list=1)
assert [b'foo', b'bar'] == obj
expected_type = bytes
assert all(type(s) == expected_type for s in obj)
def test_decode_pairs_hook():
packed = packb([3, {1: 2, 3: 4}])
prod_sum = 1 * 2 + 3 * 4
unpacked = unpackb(packed,
object_pairs_hook=lambda l: sum(k * v for k, v in l),
use_list=1)
assert unpacked[1] == prod_sum
def test_tuple_ext():
t = ('one', 2, b'three', (4, ))
MSGPACK_EXT_TYPE_TUPLE = 0
def default(o):
if isinstance(o, tuple):
# Convert to list and pack
payload = packb(list(o),
strict_types=True,
use_bin_type=True,
default=default)
return ExtType(MSGPACK_EXT_TYPE_TUPLE, payload)
raise TypeError(repr(o))
def convert(code, payload):
if code == MSGPACK_EXT_TYPE_TUPLE:
# Unpack and convert to tuple
return tuple(unpackb(payload, raw=False, ext_hook=convert))
raise ValueError('Unknown Ext code {}'.format(code))
data = packb(t, strict_types=True, use_bin_type=True, default=default)
expected = unpackb(data, raw=False, ext_hook=convert)
assert expected == t
def test_bin16():
header = b'\xc5'
data = b'x' * 256
b = packb(data, use_bin_type=True)
assert len(b) == len(data) + 3
assert b[0:1] == header
assert b[1:3] == b'\x01\x00'
assert b[3:] == data
assert unpackb(b) == data
data = b'x' * 65535
b = packb(data, use_bin_type=True)
assert len(b) == len(data) + 3
assert b[0:1] == header
assert b[1:3] == b'\xff\xff'
assert b[3:] == data
assert unpackb(b) == data
def testPackUnicode():
test_data = ["", "abcd", ["defgh"], "Русский текст"]
for td in test_data:
re = unpackb(packb(td), use_list=1, raw=False)
assert re == td
packer = Packer()
data = packer.pack(td)
re = Unpacker(BytesIO(data), raw=False, use_list=1).unpack()
assert re == td
def test_bin32():
header = b'\xc6'
data = b'x' * 65536
b = packb(data, use_bin_type=True)
assert len(b) == len(data) + 5
assert b[0:1] == header
assert b[1:5] == b'\x00\x01\x00\x00'
assert b[5:] == data
assert unpackb(b) == data
def test_namedtuple():
T = namedtuple('T', "foo bar")
def default(o):
if isinstance(o, T):
return dict(o._asdict())
raise TypeError('Unsupported type %s' % (type(o), ))
packed = packb(T(1, 42),
strict_types=True,
use_bin_type=True,
default=default)
unpacked = unpackb(packed, raw=False)
assert unpacked == {'foo': 1, 'bar': 42}
def testPackUTF32(): # deprecated
try:
test_data = [
"",
"abcd",
["defgh"],
"Русский текст",
]
for td in test_data:
re = unpackb(packb(td, encoding='utf-32'),
use_list=1,
encoding='utf-32')
assert re == td
except LookupError as e:
xfail(e)
def test_tuple():
t = ('one', 2, b'three', (4, ))
def default(o):
if isinstance(o, tuple):
return {
'__type__': 'tuple',
'value': list(o),
}
raise TypeError('Unsupported type %s' % (type(o), ))
def convert(o):
if o.get('__type__') == 'tuple':
return tuple(o['value'])
return o
data = packb(t, strict_types=True, use_bin_type=True, default=default)
expected = unpackb(data, raw=False, object_hook=convert)
assert expected == t
def test_extension_type():
def default(obj):
print('default called', obj)
if isinstance(obj, array.array):
typecode = 123 # application specific typecode
data = obj.tostring()
return ExtType(typecode, data)
raise TypeError("Unknown type object %r" % (obj, ))
def ext_hook(code, data):
print('ext_hook called', code, data)
assert code == 123
obj = array.array('d')
obj.fromstring(data)
return obj
obj = [42, b'hello', array.array('d', [1.1, 2.2, 3.3])]
s = msgpack.packb(obj, default=default)
obj2 = msgpack.unpackb(s, ext_hook=ext_hook)
assert obj == obj2
def _runtest(format, nbytes, expected_header, expected_prefix, use_bin_type):
# create a new array
original_array = array(format)
original_array.fromlist([255] * (nbytes // original_array.itemsize))
original_data = get_data(original_array)
view = make_memoryview(original_array)
# pack, unpack, and reconstruct array
packed = packb(view, use_bin_type=use_bin_type)
unpacked = unpackb(packed)
reconstructed_array = make_array(format, unpacked)
# check that we got the right amount of data
assert len(original_data) == nbytes
# check packed header
assert packed[:1] == expected_header
# check packed length prefix, if any
assert packed[1:1+len(expected_prefix)] == expected_prefix
# check packed data
assert packed[1+len(expected_prefix):] == original_data
# check array unpacked correctly
assert original_array == reconstructed_array
def test_pairlist():
pairlist = [(b'a', 1), (2, b'b'), (b'foo', b'bar')]
packer = Packer()
packed = packer.pack_map_pairs(pairlist)
unpacked = unpackb(packed, object_pairs_hook=list)
assert pairlist == unpacked
def testDecodeBinary():
re = unpackb(packb(b"abc"), encoding=None, use_list=1)
assert re == b"abc"
def check(data, use_list=False):
re = unpackb(packb(data), use_list=use_list)
assert re == data
def testIgnoreErrorsPack(): # deprecated
re = unpackb(packb("abcФФФdef", encoding='ascii', unicode_errors='ignore'),
raw=False,
use_list=1)
assert re == "abcdef"
def testStrictUnicodeUnpack():
with raises(UnicodeDecodeError):
unpackb(packb(b'abc\xeddef'), raw=False, use_list=1)
def match(obj, buf):
assert packb(obj) == buf
assert unpackb(buf, use_list=0) == obj
def check(b, expected):
assert msgpack.unpackb(b) == expected
def check(src, should, use_list=0):
assert unpackb(src, use_list=use_list) == should
def testIgnoreUnicodeErrors(): # deprecated
re = unpackb(packb(b'abc\xeddef'),
encoding='utf-8',
unicode_errors='ignore',
use_list=1)
assert re == "abcdef"
def check(length, obj):
v = packb(obj)
assert len(v) == length, \
"%r length should be %r but get %r" % (obj, length, len(v))
assert unpackb(v, use_list=0) == obj
def test_unpack_bytearray():
buf = bytearray(packb(('foo', 'bar')))
obj = unpackb(buf, use_list=1)
assert [b'foo', b'bar'] == obj
expected_type = bytes
assert all(type(s) == expected_type for s in obj)
def test_invalidvalue():
with raises(ValueError):
unpackb(b'\xd9\x97#DL_')
def test_unpack_buffer():
from array import array
buf = array('b')
buf.fromstring(packb((b'foo', b'bar')))
obj = unpackb(buf, use_list=1)
assert [b'foo', b'bar'] == obj
import sys
import msgpack_rlp as msgpack
encoded = msgpack.packb([[]])
print(encoded)
decoded = msgpack.unpackb(encoded)
print(decoded)
sys.exit()
#Didn't do tests beyond a length of 2**26 because it can cause system instability. The variables just get too large.
for i in range(1, 26):
print("trying list with byte length = {} bytes".format(i))
to_encode = [(2**i) * b'0']
rlp_encoded = rlp.encode(to_encode)
msg_encoded = msgpack.packb(to_encode)
#print(rlp_encoded)
#print(msg_encoded)
if rlp_encoded != msg_encoded:
print('encoding error found')
print(rlp_encoded[:100])
print(msg_encoded[:100])
sys.exit()
msg_decoded = msgpack.unpackb(msg_encoded)
if to_encode != msg_decoded:
