Stowage/msgpack-python
2
0
Fork 0
mirror of https://github.com/msgpack/msgpack-python.git synced 2025-10-21 12:53:17 +00:00
Code Issues Projects Releases Packages Wiki Activity

blacken

Browse source
This commit is contained in:
Inada Naoki 2019-12-05 18:50:13 +09:00
parent 641406902e
commit e557e17cbd
3 changed files with 245 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

2
msgpack/__init__.py
View file

@ -7,7 +7,7 @@ import os
import sys import sys
if os.environ.get('MSGPACK_PUREPYTHON') or sys.version_info[0] == 2: if os.environ.get("MSGPACK_PUREPYTHON") or sys.version_info[0] == 2:
from .fallback import Packer, unpackb, Unpacker from .fallback import Packer, unpackb, Unpacker
else: else:
try: try:

28
msgpack/ext.py
View file

@ -9,8 +9,9 @@ if not PY2:
long = int long = int
class ExtType(namedtuple('ExtType', 'code data')): class ExtType(namedtuple("ExtType", "code data")):
"""ExtType represents ext type in msgpack.""" """ExtType represents ext type in msgpack."""
def __new__(cls, code, data): def __new__(cls, code, data):
if not isinstance(code, int): if not isinstance(code, int):
raise TypeError("code must be int") raise TypeError("code must be int")
@ -29,6 +30,7 @@ class Timestamp(object):
When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`. When using pure-Python When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`. When using pure-Python
msgpack, :func:`to_bytes` and :func:`from_bytes` are used to pack and unpack `Timestamp`. msgpack, :func:`to_bytes` and :func:`from_bytes` are used to pack and unpack `Timestamp`.
""" """
__slots__ = ["seconds", "nanoseconds"] __slots__ = ["seconds", "nanoseconds"]
def __init__(self, seconds, nanoseconds=0): def __init__(self, seconds, nanoseconds=0):
@ -50,9 +52,13 @@ class Timestamp(object):
raise TypeError("nanoseconds must be an integer") raise TypeError("nanoseconds must be an integer")
if nanoseconds: if nanoseconds:
if nanoseconds < 0 or nanoseconds % 1 != 0 or nanoseconds > (1e9 - 1): if nanoseconds < 0 or nanoseconds % 1 != 0 or nanoseconds > (1e9 - 1):
raise ValueError("nanoseconds must be a non-negative integer less than 999999999.") raise ValueError(
"nanoseconds must be a non-negative integer less than 999999999."
)
if not isinstance(seconds, (int, long)): if not isinstance(seconds, (int, long)):
raise ValueError("seconds must be an integer if also providing nanoseconds.") raise ValueError(
"seconds must be an integer if also providing nanoseconds."
)
self.nanoseconds = nanoseconds self.nanoseconds = nanoseconds
else: else:
# round helps with floating point issues # round helps with floating point issues
@ -61,12 +67,16 @@ class Timestamp(object):
def __repr__(self): def __repr__(self):
"""String representation of Timestamp.""" """String representation of Timestamp."""
return "Timestamp(seconds={0}, nanoseconds={1})".format(self.seconds, self.nanoseconds) return "Timestamp(seconds={0}, nanoseconds={1})".format(
self.seconds, self.nanoseconds
)
def __eq__(self, other): def __eq__(self, other):
"""Check for equality with another Timestamp object""" """Check for equality with another Timestamp object"""
if type(other) is self.__class__: if type(other) is self.__class__:
return self.seconds == other.seconds and self.nanoseconds == other.nanoseconds return (
self.seconds == other.seconds and self.nanoseconds == other.nanoseconds
)
return False return False
def __ne__(self, other): def __ne__(self, other):
@ -90,12 +100,14 @@ class Timestamp(object):
nanoseconds = 0 nanoseconds = 0
elif len(b) == 8: elif len(b) == 8:
data64 = struct.unpack("!Q", b)[0] data64 = struct.unpack("!Q", b)[0]
seconds = data64 & 0x00000003ffffffff seconds = data64 & 0x00000003FFFFFFFF
nanoseconds = data64 >> 34 nanoseconds = data64 >> 34
elif len(b) == 12: elif len(b) == 12:
nanoseconds, seconds = struct.unpack("!Iq", b) nanoseconds, seconds = struct.unpack("!Iq", b)
else: else:
raise ValueError("Timestamp type can only be created from 32, 64, or 96-bit byte objects") raise ValueError(
"Timestamp type can only be created from 32, 64, or 96-bit byte objects"
)
return Timestamp(seconds, nanoseconds) return Timestamp(seconds, nanoseconds)
def to_bytes(self): def to_bytes(self):
@ -108,7 +120,7 @@ class Timestamp(object):
""" """
if (self.seconds >> 34) == 0: # seconds is non-negative and fits in 34 bits if (self.seconds >> 34) == 0: # seconds is non-negative and fits in 34 bits
data64 = self.nanoseconds << 34 | self.seconds data64 = self.nanoseconds << 34 | self.seconds
if data64 & 0xffffffff00000000 == 0: if data64 & 0xFFFFFFFF00000000 == 0:
# nanoseconds is zero and seconds < 2**32, so timestamp 32 # nanoseconds is zero and seconds < 2**32, so timestamp 32
data = struct.pack("!L", data64) data = struct.pack("!L", data64)
else: else:

323
msgpack/fallback.py
View file

@ -8,53 +8,72 @@ import warnings
PY2 = sys.version_info[0] == 2 PY2 = sys.version_info[0] == 2
if PY2: if PY2:
int_types = (int, long) int_types = (int, long)
def dict_iteritems(d): def dict_iteritems(d):
return d.iteritems() return d.iteritems()
else: else:
int_types = int int_types = int
unicode = str unicode = str
xrange = range xrange = range
def dict_iteritems(d): def dict_iteritems(d):
return d.items() return d.items()
if sys.version_info < (3, 5): if sys.version_info < (3, 5):
# Ugly hack... # Ugly hack...
RecursionError = RuntimeError RecursionError = RuntimeError
def _is_recursionerror(e): def _is_recursionerror(e):
return len(e.args) == 1 and isinstance(e.args[0], str) and \ return (
e.args[0].startswith('maximum recursion depth exceeded') len(e.args) == 1
and isinstance(e.args[0], str)
and e.args[0].startswith("maximum recursion depth exceeded")
)
else: else:
def _is_recursionerror(e): def _is_recursionerror(e):
return True return True
if hasattr(sys, 'pypy_version_info'):
if hasattr(sys, "pypy_version_info"):
# cStringIO is slow on PyPy, StringIO is faster. However: PyPy's own # cStringIO is slow on PyPy, StringIO is faster. However: PyPy's own
# StringBuilder is fastest. # StringBuilder is fastest.
from __pypy__ import newlist_hint from __pypy__ import newlist_hint
try: try:
from __pypy__.builders import BytesBuilder as StringBuilder from __pypy__.builders import BytesBuilder as StringBuilder
except ImportError: except ImportError:
from __pypy__.builders import StringBuilder from __pypy__.builders import StringBuilder
USING_STRINGBUILDER = True USING_STRINGBUILDER = True
class StringIO(object): class StringIO(object):
def __init__(self, s=b''): def __init__(self, s=b""):
if s: if s:
self.builder = StringBuilder(len(s)) self.builder = StringBuilder(len(s))
self.builder.append(s) self.builder.append(s)
else: else:
self.builder = StringBuilder() self.builder = StringBuilder()
def write(self, s): def write(self, s):
if isinstance(s, memoryview): if isinstance(s, memoryview):
s = s.tobytes() s = s.tobytes()
elif isinstance(s, bytearray): elif isinstance(s, bytearray):
s = bytes(s) s = bytes(s)
self.builder.append(s) self.builder.append(s)
def getvalue(self): def getvalue(self):
return self.builder.build() return self.builder.build()
else: else:
USING_STRINGBUILDER = False USING_STRINGBUILDER = False
from io import BytesIO as StringIO from io import BytesIO as StringIO
newlist_hint = lambda size: [] newlist_hint = lambda size: []
@ -98,10 +117,13 @@ def _get_data_from_buffer(obj):
# try to use legacy buffer protocol if 2.7, otherwise re-raise # try to use legacy buffer protocol if 2.7, otherwise re-raise
if PY2: if PY2:
view = memoryview(buffer(obj)) view = memoryview(buffer(obj))
warnings.warn("using old buffer interface to unpack %s; " warnings.warn(
"using old buffer interface to unpack %s; "
"this leads to unpacking errors if slicing is used and " "this leads to unpacking errors if slicing is used and "
"will be removed in a future version" % type(obj), "will be removed in a future version" % type(obj),
RuntimeWarning, stacklevel=3) RuntimeWarning,
stacklevel=3,
)
else: else:
raise raise
if view.itemsize != 1: if view.itemsize != 1:
@ -112,7 +134,9 @@ def _get_data_from_buffer(obj):
def unpack(stream, **kwargs): def unpack(stream, **kwargs):
warnings.warn( warnings.warn(
"Direct calling implementation's unpack() is deprecated, Use msgpack.unpack() or unpackb() instead.", "Direct calling implementation's unpack() is deprecated, Use msgpack.unpack() or unpackb() instead.",
DeprecationWarning, stacklevel=2) DeprecationWarning,
stacklevel=2,
)
data = stream.read() data = stream.read()
return unpackb(data, **kwargs) return unpackb(data, **kwargs)
@ -145,9 +169,12 @@ def unpackb(packed, **kwargs):
if sys.version_info < (2, 7, 6): if sys.version_info < (2, 7, 6):
def _unpack_from(f, b, o=0): def _unpack_from(f, b, o=0):
"""Explicit typcast for legacy struct.unpack_from""" """Explicit typcast for legacy struct.unpack_from"""
return struct.unpack_from(f, bytes(b), o) return struct.unpack_from(f, bytes(b), o)
else: else:
_unpack_from = struct.unpack_from _unpack_from = struct.unpack_from
@ -245,17 +272,27 @@ class Unpacker(object):
Other exceptions can be raised during unpacking. Other exceptions can be raised during unpacking.
""" """
def __init__(self, file_like=None, read_size=0, use_list=True, raw=True, strict_map_key=False, def __init__(
object_hook=None, object_pairs_hook=None, list_hook=None, self,
unicode_errors=None, max_buffer_size=0, file_like=None,
read_size=0,
use_list=True,
raw=True,
strict_map_key=False,
object_hook=None,
object_pairs_hook=None,
list_hook=None,
unicode_errors=None,
max_buffer_size=0,
ext_hook=ExtType, ext_hook=ExtType,
max_str_len=-1, max_str_len=-1,
max_bin_len=-1, max_bin_len=-1,
max_array_len=-1, max_array_len=-1,
max_map_len=-1, max_map_len=-1,
max_ext_len=-1): max_ext_len=-1,
):
if unicode_errors is None: if unicode_errors is None:
unicode_errors = 'strict' unicode_errors = "strict"
if file_like is None: if file_like is None:
self._feeding = True self._feeding = True
@ -310,21 +347,22 @@ class Unpacker(object):
self._stream_offset = 0 self._stream_offset = 0
if list_hook is not None and not callable(list_hook): if list_hook is not None and not callable(list_hook):
raise TypeError('`list_hook` is not callable') raise TypeError("`list_hook` is not callable")
if object_hook is not None and not callable(object_hook): if object_hook is not None and not callable(object_hook):
raise TypeError('`object_hook` is not callable') raise TypeError("`object_hook` is not callable")
if object_pairs_hook is not None and not callable(object_pairs_hook): if object_pairs_hook is not None and not callable(object_pairs_hook):
raise TypeError('`object_pairs_hook` is not callable') raise TypeError("`object_pairs_hook` is not callable")
if object_hook is not None and object_pairs_hook is not None: if object_hook is not None and object_pairs_hook is not None:
raise TypeError("object_pairs_hook and object_hook are mutually " raise TypeError(
"exclusive") "object_pairs_hook and object_hook are mutually " "exclusive"
)
if not callable(ext_hook): if not callable(ext_hook):
raise TypeError("`ext_hook` is not callable") raise TypeError("`ext_hook` is not callable")
def feed(self, next_bytes): def feed(self, next_bytes):
assert self._feeding assert self._feeding
view = _get_data_from_buffer(next_bytes) view = _get_data_from_buffer(next_bytes)
if (len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size): if len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size:
raise BufferFull raise BufferFull
# Strip buffer before checkpoint before reading file. # Strip buffer before checkpoint before reading file.
@ -399,7 +437,7 @@ class Unpacker(object):
if b & 0b10000000 == 0: if b & 0b10000000 == 0:
obj = b obj = b
elif b & 0b11100000 == 0b11100000: elif b & 0b11100000 == 0b11100000:
obj = -1 - (b ^ 0xff) obj = -1 - (b ^ 0xFF)
elif b & 0b11100000 == 0b10100000: elif b & 0b11100000 == 0b10100000:
n = b & 0b00011111 n = b & 0b00011111
typ = TYPE_RAW typ = TYPE_RAW
@ -416,13 +454,13 @@ class Unpacker(object):
typ = TYPE_MAP typ = TYPE_MAP
if n > self._max_map_len: if n > self._max_map_len:
raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
elif b == 0xc0: elif b == 0xC0:
obj = None obj = None
elif b == 0xc2: elif b == 0xC2:
obj = False obj = False
elif b == 0xc3: elif b == 0xC3:
obj = True obj = True
elif b == 0xc4: elif b == 0xC4:
typ = TYPE_BIN typ = TYPE_BIN
self._reserve(1) self._reserve(1)
n = self._buffer[self._buff_i] n = self._buffer[self._buff_i]
@ -430,7 +468,7 @@ class Unpacker(object):
if n > self._max_bin_len: if n > self._max_bin_len:
raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
obj = self._read(n) obj = self._read(n)
elif b == 0xc5: elif b == 0xC5:
typ = TYPE_BIN typ = TYPE_BIN
self._reserve(2) self._reserve(2)
n = _unpack_from(">H", self._buffer, self._buff_i)[0] n = _unpack_from(">H", self._buffer, self._buff_i)[0]
@ -438,7 +476,7 @@ class Unpacker(object):
if n > self._max_bin_len: if n > self._max_bin_len:
raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
obj = self._read(n) obj = self._read(n)
elif b == 0xc6: elif b == 0xC6:
typ = TYPE_BIN typ = TYPE_BIN
self._reserve(4) self._reserve(4)
n = _unpack_from(">I", self._buffer, self._buff_i)[0] n = _unpack_from(">I", self._buffer, self._buff_i)[0]
@ -446,106 +484,106 @@ class Unpacker(object):
if n > self._max_bin_len: if n > self._max_bin_len:
raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
obj = self._read(n) obj = self._read(n)
elif b == 0xc7: # ext 8 elif b == 0xC7: # ext 8
typ = TYPE_EXT typ = TYPE_EXT
self._reserve(2) self._reserve(2)
L, n = _unpack_from('Bb', self._buffer, self._buff_i) L, n = _unpack_from("Bb", self._buffer, self._buff_i)
self._buff_i += 2 self._buff_i += 2
if L > self._max_ext_len: if L > self._max_ext_len:
raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
obj = self._read(L) obj = self._read(L)
elif b == 0xc8: # ext 16 elif b == 0xC8: # ext 16
typ = TYPE_EXT typ = TYPE_EXT
self._reserve(3) self._reserve(3)
L, n = _unpack_from('>Hb', self._buffer, self._buff_i) L, n = _unpack_from(">Hb", self._buffer, self._buff_i)
self._buff_i += 3 self._buff_i += 3
if L > self._max_ext_len: if L > self._max_ext_len:
raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
obj = self._read(L) obj = self._read(L)
elif b == 0xc9: # ext 32 elif b == 0xC9: # ext 32
typ = TYPE_EXT typ = TYPE_EXT
self._reserve(5) self._reserve(5)
L, n = _unpack_from('>Ib', self._buffer, self._buff_i) L, n = _unpack_from(">Ib", self._buffer, self._buff_i)
self._buff_i += 5 self._buff_i += 5
if L > self._max_ext_len: if L > self._max_ext_len:
raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
obj = self._read(L) obj = self._read(L)
elif b == 0xca: elif b == 0xCA:
self._reserve(4) self._reserve(4)
obj = _unpack_from(">f", self._buffer, self._buff_i)[0] obj = _unpack_from(">f", self._buffer, self._buff_i)[0]
self._buff_i += 4 self._buff_i += 4
elif b == 0xcb: elif b == 0xCB:
self._reserve(8) self._reserve(8)
obj = _unpack_from(">d", self._buffer, self._buff_i)[0] obj = _unpack_from(">d", self._buffer, self._buff_i)[0]
self._buff_i += 8 self._buff_i += 8
elif b == 0xcc: elif b == 0xCC:
self._reserve(1) self._reserve(1)
obj = self._buffer[self._buff_i] obj = self._buffer[self._buff_i]
self._buff_i += 1 self._buff_i += 1
elif b == 0xcd: elif b == 0xCD:
self._reserve(2) self._reserve(2)
obj = _unpack_from(">H", self._buffer, self._buff_i)[0] obj = _unpack_from(">H", self._buffer, self._buff_i)[0]
self._buff_i += 2 self._buff_i += 2
elif b == 0xce: elif b == 0xCE:
self._reserve(4) self._reserve(4)
obj = _unpack_from(">I", self._buffer, self._buff_i)[0] obj = _unpack_from(">I", self._buffer, self._buff_i)[0]
self._buff_i += 4 self._buff_i += 4
elif b == 0xcf: elif b == 0xCF:
self._reserve(8) self._reserve(8)
obj = _unpack_from(">Q", self._buffer, self._buff_i)[0] obj = _unpack_from(">Q", self._buffer, self._buff_i)[0]
self._buff_i += 8 self._buff_i += 8
elif b == 0xd0: elif b == 0xD0:
self._reserve(1) self._reserve(1)
obj = _unpack_from("b", self._buffer, self._buff_i)[0] obj = _unpack_from("b", self._buffer, self._buff_i)[0]
self._buff_i += 1 self._buff_i += 1
elif b == 0xd1: elif b == 0xD1:
self._reserve(2) self._reserve(2)
obj = _unpack_from(">h", self._buffer, self._buff_i)[0] obj = _unpack_from(">h", self._buffer, self._buff_i)[0]
self._buff_i += 2 self._buff_i += 2
elif b == 0xd2: elif b == 0xD2:
self._reserve(4) self._reserve(4)
obj = _unpack_from(">i", self._buffer, self._buff_i)[0] obj = _unpack_from(">i", self._buffer, self._buff_i)[0]
self._buff_i += 4 self._buff_i += 4
elif b == 0xd3: elif b == 0xD3:
self._reserve(8) self._reserve(8)
obj = _unpack_from(">q", self._buffer, self._buff_i)[0] obj = _unpack_from(">q", self._buffer, self._buff_i)[0]
self._buff_i += 8 self._buff_i += 8
elif b == 0xd4: # fixext 1 elif b == 0xD4: # fixext 1
typ = TYPE_EXT typ = TYPE_EXT
if self._max_ext_len < 1: if self._max_ext_len < 1:
raise ValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len))
self._reserve(2) self._reserve(2)
n, obj = _unpack_from("b1s", self._buffer, self._buff_i) n, obj = _unpack_from("b1s", self._buffer, self._buff_i)
self._buff_i += 2 self._buff_i += 2
elif b == 0xd5: # fixext 2 elif b == 0xD5: # fixext 2
typ = TYPE_EXT typ = TYPE_EXT
if self._max_ext_len < 2: if self._max_ext_len < 2:
raise ValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len))
self._reserve(3) self._reserve(3)
n, obj = _unpack_from("b2s", self._buffer, self._buff_i) n, obj = _unpack_from("b2s", self._buffer, self._buff_i)
self._buff_i += 3 self._buff_i += 3
elif b == 0xd6: # fixext 4 elif b == 0xD6: # fixext 4
typ = TYPE_EXT typ = TYPE_EXT
if self._max_ext_len < 4: if self._max_ext_len < 4:
raise ValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len))
self._reserve(5) self._reserve(5)
n, obj = _unpack_from("b4s", self._buffer, self._buff_i) n, obj = _unpack_from("b4s", self._buffer, self._buff_i)
self._buff_i += 5 self._buff_i += 5
elif b == 0xd7: # fixext 8 elif b == 0xD7: # fixext 8
typ = TYPE_EXT typ = TYPE_EXT
if self._max_ext_len < 8: if self._max_ext_len < 8:
raise ValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len))
self._reserve(9) self._reserve(9)
n, obj = _unpack_from("b8s", self._buffer, self._buff_i) n, obj = _unpack_from("b8s", self._buffer, self._buff_i)
self._buff_i += 9 self._buff_i += 9
elif b == 0xd8: # fixext 16 elif b == 0xD8: # fixext 16
typ = TYPE_EXT typ = TYPE_EXT
if self._max_ext_len < 16: if self._max_ext_len < 16:
raise ValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len)) raise ValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len))
self._reserve(17) self._reserve(17)
n, obj = _unpack_from("b16s", self._buffer, self._buff_i) n, obj = _unpack_from("b16s", self._buffer, self._buff_i)
self._buff_i += 17 self._buff_i += 17
elif b == 0xd9: elif b == 0xD9:
typ = TYPE_RAW typ = TYPE_RAW
self._reserve(1) self._reserve(1)
n = self._buffer[self._buff_i] n = self._buffer[self._buff_i]
@ -553,46 +591,46 @@ class Unpacker(object):
if n > self._max_str_len: if n > self._max_str_len:
raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
obj = self._read(n) obj = self._read(n)
elif b == 0xda: elif b == 0xDA:
typ = TYPE_RAW typ = TYPE_RAW
self._reserve(2) self._reserve(2)
n, = _unpack_from(">H", self._buffer, self._buff_i) (n,) = _unpack_from(">H", self._buffer, self._buff_i)
self._buff_i += 2 self._buff_i += 2
if n > self._max_str_len: if n > self._max_str_len:
raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
obj = self._read(n) obj = self._read(n)
elif b == 0xdb: elif b == 0xDB:
typ = TYPE_RAW typ = TYPE_RAW
self._reserve(4) self._reserve(4)
n, = _unpack_from(">I", self._buffer, self._buff_i) (n,) = _unpack_from(">I", self._buffer, self._buff_i)
self._buff_i += 4 self._buff_i += 4
if n > self._max_str_len: if n > self._max_str_len:
raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
obj = self._read(n) obj = self._read(n)
elif b == 0xdc: elif b == 0xDC:
typ = TYPE_ARRAY typ = TYPE_ARRAY
self._reserve(2) self._reserve(2)
n, = _unpack_from(">H", self._buffer, self._buff_i) (n,) = _unpack_from(">H", self._buffer, self._buff_i)
self._buff_i += 2 self._buff_i += 2
if n > self._max_array_len: if n > self._max_array_len:
raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
elif b == 0xdd: elif b == 0xDD:
typ = TYPE_ARRAY typ = TYPE_ARRAY
self._reserve(4) self._reserve(4)
n, = _unpack_from(">I", self._buffer, self._buff_i) (n,) = _unpack_from(">I", self._buffer, self._buff_i)
self._buff_i += 4 self._buff_i += 4
if n > self._max_array_len: if n > self._max_array_len:
raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
elif b == 0xde: elif b == 0xDE:
self._reserve(2) self._reserve(2)
n, = _unpack_from(">H", self._buffer, self._buff_i) (n,) = _unpack_from(">H", self._buffer, self._buff_i)
self._buff_i += 2 self._buff_i += 2
if n > self._max_map_len: if n > self._max_map_len:
raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
typ = TYPE_MAP typ = TYPE_MAP
elif b == 0xdf: elif b == 0xDF:
self._reserve(4) self._reserve(4)
n, = _unpack_from(">I", self._buffer, self._buff_i) (n,) = _unpack_from(">I", self._buffer, self._buff_i)
self._buff_i += 4 self._buff_i += 4
if n > self._max_map_len: if n > self._max_map_len:
raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
@ -635,15 +673,17 @@ class Unpacker(object):
return return
if self._object_pairs_hook is not None: if self._object_pairs_hook is not None:
ret = self._object_pairs_hook( ret = self._object_pairs_hook(
(self._unpack(EX_CONSTRUCT), (self._unpack(EX_CONSTRUCT), self._unpack(EX_CONSTRUCT))
self._unpack(EX_CONSTRUCT)) for _ in xrange(n)
for _ in xrange(n)) )
else: else:
ret = {} ret = {}
for _ in xrange(n): for _ in xrange(n):
key = self._unpack(EX_CONSTRUCT) key = self._unpack(EX_CONSTRUCT)
if self._strict_map_key and type(key) not in (unicode, bytes): if self._strict_map_key and type(key) not in (unicode, bytes):
raise ValueError("%s is not allowed for map key" % str(type(key))) raise ValueError(
"%s is not allowed for map key" % str(type(key))
)
if not PY2 and type(key) is str: if not PY2 and type(key) is str:
key = sys.intern(key) key = sys.intern(key)
ret[key] = self._unpack(EX_CONSTRUCT) ret[key] = self._unpack(EX_CONSTRUCT)
@ -656,7 +696,7 @@ class Unpacker(object):
if self._raw: if self._raw:
obj = bytes(obj) obj = bytes(obj)
else: else:
obj = obj.decode('utf_8', self._unicode_errors) obj = obj.decode("utf_8", self._unicode_errors)
return obj return obj
if typ == TYPE_EXT: if typ == TYPE_EXT:
return self._ext_hook(n, bytes(obj)) return self._ext_hook(n, bytes(obj))
@ -746,9 +786,16 @@ class Packer(object):
The error handler for encoding unicode. (default: 'strict') The error handler for encoding unicode. (default: 'strict')
DO NOT USE THIS!! This option is kept for very specific usage. DO NOT USE THIS!! This option is kept for very specific usage.
""" """
def __init__(self, default=None, unicode_errors=None,
use_single_float=False, autoreset=True, use_bin_type=False, def __init__(
strict_types=False): self,
default=None,
unicode_errors=None,
use_single_float=False,
autoreset=True,
use_bin_type=False,
strict_types=False,
):
self._strict_types = strict_types self._strict_types = strict_types
self._use_float = use_single_float self._use_float = use_single_float
self._autoreset = autoreset self._autoreset = autoreset
@ -760,8 +807,13 @@ class Packer(object):
raise TypeError("default must be callable") raise TypeError("default must be callable")
self._default = default self._default = default
def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT, def _pack(
check=isinstance, check_type_strict=_check_type_strict): self,
obj,
nest_limit=DEFAULT_RECURSE_LIMIT,
check=isinstance,
check_type_strict=_check_type_strict,
):
default_used = False default_used = False
if self._strict_types: if self._strict_types:
check = check_type_strict check = check_type_strict
@ -782,22 +834,22 @@ class Packer(object):
return self._buffer.write(struct.pack("B", obj)) return self._buffer.write(struct.pack("B", obj))
if -0x20 <= obj < 0: if -0x20 <= obj < 0:
return self._buffer.write(struct.pack("b", obj)) return self._buffer.write(struct.pack("b", obj))
if 0x80 <= obj <= 0xff: if 0x80 <= obj <= 0xFF:
return self._buffer.write(struct.pack("BB", 0xcc, obj)) return self._buffer.write(struct.pack("BB", 0xCC, obj))
if -0x80 <= obj < 0: if -0x80 <= obj < 0:
return self._buffer.write(struct.pack(">Bb", 0xd0, obj)) return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
if 0xff < obj <= 0xffff: if 0xFF < obj <= 0xFFFF:
return self._buffer.write(struct.pack(">BH", 0xcd, obj)) return self._buffer.write(struct.pack(">BH", 0xCD, obj))
if -0x8000 <= obj < -0x80: if -0x8000 <= obj < -0x80:
return self._buffer.write(struct.pack(">Bh", 0xd1, obj)) return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
if 0xffff < obj <= 0xffffffff: if 0xFFFF < obj <= 0xFFFFFFFF:
return self._buffer.write(struct.pack(">BI", 0xce, obj)) return self._buffer.write(struct.pack(">BI", 0xCE, obj))
if -0x80000000 <= obj < -0x8000: if -0x80000000 <= obj < -0x8000:
return self._buffer.write(struct.pack(">Bi", 0xd2, obj)) return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
if 0xffffffff < obj <= 0xffffffffffffffff: if 0xFFFFFFFF < obj <= 0xFFFFFFFFFFFFFFFF:
return self._buffer.write(struct.pack(">BQ", 0xcf, obj)) return self._buffer.write(struct.pack(">BQ", 0xCF, obj))
if -0x8000000000000000 <= obj < -0x80000000: if -0x8000000000000000 <= obj < -0x80000000:
return self._buffer.write(struct.pack(">Bq", 0xd3, obj)) return self._buffer.write(struct.pack(">Bq", 0xD3, obj))
if not default_used and self._default is not None: if not default_used and self._default is not None:
obj = self._default(obj) obj = self._default(obj)
default_used = True default_used = True
@ -824,8 +876,8 @@ class Packer(object):
return self._buffer.write(obj) return self._buffer.write(obj)
if check(obj, float): if check(obj, float):
if self._use_float: if self._use_float:
return self._buffer.write(struct.pack(">Bf", 0xca, obj)) return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
return self._buffer.write(struct.pack(">Bd", 0xcb, obj)) return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
if check(obj, (ExtType, Timestamp)): if check(obj, (ExtType, Timestamp)):
if check(obj, Timestamp): if check(obj, Timestamp):
code = -1 code = -1
@ -837,21 +889,21 @@ class Packer(object):
assert isinstance(data, bytes) assert isinstance(data, bytes)
L = len(data) L = len(data)
if L == 1: if L == 1:
self._buffer.write(b'\xd4') self._buffer.write(b"\xd4")
elif L == 2: elif L == 2:
self._buffer.write(b'\xd5') self._buffer.write(b"\xd5")
elif L == 4: elif L == 4:
self._buffer.write(b'\xd6') self._buffer.write(b"\xd6")
elif L == 8: elif L == 8:
self._buffer.write(b'\xd7') self._buffer.write(b"\xd7")
elif L == 16: elif L == 16:
self._buffer.write(b'\xd8') self._buffer.write(b"\xd8")
elif L <= 0xff: elif L <= 0xFF:
self._buffer.write(struct.pack(">BB", 0xc7, L)) self._buffer.write(struct.pack(">BB", 0xC7, L))
elif L <= 0xffff: elif L <= 0xFFFF:
self._buffer.write(struct.pack(">BH", 0xc8, L)) self._buffer.write(struct.pack(">BH", 0xC8, L))
else: else:
self._buffer.write(struct.pack(">BI", 0xc9, L)) self._buffer.write(struct.pack(">BI", 0xC9, L))
self._buffer.write(struct.pack("b", code)) self._buffer.write(struct.pack("b", code))
self._buffer.write(data) self._buffer.write(data)
return return
@ -862,8 +914,9 @@ class Packer(object):
self._pack(obj[i], nest_limit - 1) self._pack(obj[i], nest_limit - 1)
return return
if check(obj, dict): if check(obj, dict):
return self._pack_map_pairs(len(obj), dict_iteritems(obj), return self._pack_map_pairs(
nest_limit - 1) len(obj), dict_iteritems(obj), nest_limit - 1
)
if not default_used and self._default is not None: if not default_used and self._default is not None:
obj = self._default(obj) obj = self._default(obj)
default_used = 1 default_used = 1
@ -914,43 +967,43 @@ class Packer(object):
if not isinstance(data, bytes): if not isinstance(data, bytes):
raise TypeError("data must have bytes type") raise TypeError("data must have bytes type")
L = len(data) L = len(data)
if L > 0xffffffff: if L > 0xFFFFFFFF:
raise ValueError("Too large data") raise ValueError("Too large data")
if L == 1: if L == 1:
self._buffer.write(b'\xd4') self._buffer.write(b"\xd4")
elif L == 2: elif L == 2:
self._buffer.write(b'\xd5') self._buffer.write(b"\xd5")
elif L == 4: elif L == 4:
self._buffer.write(b'\xd6') self._buffer.write(b"\xd6")
elif L == 8: elif L == 8:
self._buffer.write(b'\xd7') self._buffer.write(b"\xd7")
elif L == 16: elif L == 16:
self._buffer.write(b'\xd8') self._buffer.write(b"\xd8")
elif L <= 0xff: elif L <= 0xFF:
self._buffer.write(b'\xc7' + struct.pack('B', L)) self._buffer.write(b"\xc7" + struct.pack("B", L))
elif L <= 0xffff: elif L <= 0xFFFF:
self._buffer.write(b'\xc8' + struct.pack('>H', L)) self._buffer.write(b"\xc8" + struct.pack(">H", L))
else: else:
self._buffer.write(b'\xc9' + struct.pack('>I', L)) self._buffer.write(b"\xc9" + struct.pack(">I", L))
self._buffer.write(struct.pack('B', typecode)) self._buffer.write(struct.pack("B", typecode))
self._buffer.write(data) self._buffer.write(data)
def _pack_array_header(self, n): def _pack_array_header(self, n):
if n <= 0x0f: if n <= 0x0F:
return self._buffer.write(struct.pack('B', 0x90 + n)) return self._buffer.write(struct.pack("B", 0x90 + n))
if n <= 0xffff: if n <= 0xFFFF:
return self._buffer.write(struct.pack(">BH", 0xdc, n)) return self._buffer.write(struct.pack(">BH", 0xDC, n))
if n <= 0xffffffff: if n <= 0xFFFFFFFF:
return self._buffer.write(struct.pack(">BI", 0xdd, n)) return self._buffer.write(struct.pack(">BI", 0xDD, n))
raise ValueError("Array is too large") raise ValueError("Array is too large")
def _pack_map_header(self, n): def _pack_map_header(self, n):
if n <= 0x0f: if n <= 0x0F:
return self._buffer.write(struct.pack('B', 0x80 + n)) return self._buffer.write(struct.pack("B", 0x80 + n))
if n <= 0xffff: if n <= 0xFFFF:
return self._buffer.write(struct.pack(">BH", 0xde, n)) return self._buffer.write(struct.pack(">BH", 0xDE, n))
if n <= 0xffffffff: if n <= 0xFFFFFFFF:
return self._buffer.write(struct.pack(">BI", 0xdf, n)) return self._buffer.write(struct.pack(">BI", 0xDF, n))
raise ValueError("Dict is too large") raise ValueError("Dict is too large")
def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT): def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
@ -960,28 +1013,28 @@ class Packer(object):
self._pack(v, nest_limit - 1) self._pack(v, nest_limit - 1)
def _pack_raw_header(self, n): def _pack_raw_header(self, n):
if n <= 0x1f: if n <= 0x1F:
self._buffer.write(struct.pack('B', 0xa0 + n)) self._buffer.write(struct.pack("B", 0xA0 + n))
elif self._use_bin_type and n <= 0xff: elif self._use_bin_type and n <= 0xFF:
self._buffer.write(struct.pack('>BB', 0xd9, n)) self._buffer.write(struct.pack(">BB", 0xD9, n))
elif n <= 0xffff: elif n <= 0xFFFF:
self._buffer.write(struct.pack(">BH", 0xda, n)) self._buffer.write(struct.pack(">BH", 0xDA, n))
elif n <= 0xffffffff: elif n <= 0xFFFFFFFF:
self._buffer.write(struct.pack(">BI", 0xdb, n)) self._buffer.write(struct.pack(">BI", 0xDB, n))
else: else:
raise ValueError('Raw is too large') raise ValueError("Raw is too large")
def _pack_bin_header(self, n): def _pack_bin_header(self, n):
if not self._use_bin_type: if not self._use_bin_type:
return self._pack_raw_header(n) return self._pack_raw_header(n)
elif n <= 0xff: elif n <= 0xFF:
return self._buffer.write(struct.pack('>BB', 0xc4, n)) return self._buffer.write(struct.pack(">BB", 0xC4, n))
elif n <= 0xffff: elif n <= 0xFFFF:
return self._buffer.write(struct.pack(">BH", 0xc5, n)) return self._buffer.write(struct.pack(">BH", 0xC5, n))
elif n <= 0xffffffff: elif n <= 0xFFFFFFFF:
return self._buffer.write(struct.pack(">BI", 0xc6, n)) return self._buffer.write(struct.pack(">BI", 0xC6, n))
else: else:
raise ValueError('Bin is too large') raise ValueError("Bin is too large")
def bytes(self): def bytes(self):
"""Return internal buffer contents as bytes object""" """Return internal buffer contents as bytes object"""