mirror of
https://github.com/pre-commit/pre-commit-hooks.git
synced 2026-04-14 06:34:44 +00:00
[pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
This commit is contained in:
pre-commit-ci[bot]
parent
72ad6dc953
commit
f4cd1ba0d6
813 changed files with 66015 additions and 58839 deletions
|
|
@ -1,13 +1,15 @@
|
|||
# coding: utf-8
|
||||
from ._version import version
|
||||
from .exceptions import *
|
||||
from .ext import ExtType, Timestamp
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
from ._version import version
|
||||
from .exceptions import *
|
||||
from .ext import ExtType
|
||||
from .ext import Timestamp
|
||||
|
||||
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
|
||||
else:
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -1 +1,2 @@
|
|||
from __future__ import annotations
|
||||
version = (1, 0, 3)
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
from __future__ import annotations
|
||||
|
||||
|
||||
class UnpackException(Exception):
|
||||
"""Base class for some exceptions raised while unpacking.
|
||||
|
||||
|
|
@ -39,7 +42,7 @@ class ExtraData(UnpackValueError):
|
|||
self.extra = extra
|
||||
|
||||
def __str__(self):
|
||||
return "unpack(b) received extra data."
|
||||
return 'unpack(b) received extra data.'
|
||||
|
||||
|
||||
# Deprecated. Use Exception instead to catch all exception during packing.
|
||||
|
|
|
|||
|
|
@ -1,8 +1,9 @@
|
|||
# coding: utf-8
|
||||
from collections import namedtuple
|
||||
from __future__ import annotations
|
||||
|
||||
import datetime
|
||||
import sys
|
||||
import struct
|
||||
import sys
|
||||
from collections import namedtuple
|
||||
|
||||
|
||||
PY2 = sys.version_info[0] == 2
|
||||
|
|
@ -18,20 +19,20 @@ else:
|
|||
_utc = datetime.timezone(datetime.timedelta(0))
|
||||
|
||||
|
||||
class ExtType(namedtuple("ExtType", "code data")):
|
||||
class ExtType(namedtuple('ExtType', 'code data')):
|
||||
"""ExtType represents ext type in msgpack."""
|
||||
|
||||
def __new__(cls, code, data):
|
||||
if not isinstance(code, int):
|
||||
raise TypeError("code must be int")
|
||||
raise TypeError('code must be int')
|
||||
if not isinstance(data, bytes):
|
||||
raise TypeError("data must be bytes")
|
||||
raise TypeError('data must be bytes')
|
||||
if not 0 <= code <= 127:
|
||||
raise ValueError("code must be 0~127")
|
||||
return super(ExtType, cls).__new__(cls, code, data)
|
||||
raise ValueError('code must be 0~127')
|
||||
return super().__new__(cls, code, data)
|
||||
|
||||
|
||||
class Timestamp(object):
|
||||
class Timestamp:
|
||||
"""Timestamp represents the Timestamp extension type in msgpack.
|
||||
|
||||
When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`. When using pure-Python
|
||||
|
|
@ -40,7 +41,7 @@ class Timestamp(object):
|
|||
This class is immutable: Do not override seconds and nanoseconds.
|
||||
"""
|
||||
|
||||
__slots__ = ["seconds", "nanoseconds"]
|
||||
__slots__ = ['seconds', 'nanoseconds']
|
||||
|
||||
def __init__(self, seconds, nanoseconds=0):
|
||||
"""Initialize a Timestamp object.
|
||||
|
|
@ -56,20 +57,20 @@ class Timestamp(object):
|
|||
Note: Negative times (before the UNIX epoch) are represented as negative seconds + positive ns.
|
||||
"""
|
||||
if not isinstance(seconds, int_types):
|
||||
raise TypeError("seconds must be an interger")
|
||||
raise TypeError('seconds must be an interger')
|
||||
if not isinstance(nanoseconds, int_types):
|
||||
raise TypeError("nanoseconds must be an integer")
|
||||
raise TypeError('nanoseconds must be an integer')
|
||||
if not (0 <= nanoseconds < 10 ** 9):
|
||||
raise ValueError(
|
||||
"nanoseconds must be a non-negative integer less than 999999999."
|
||||
'nanoseconds must be a non-negative integer less than 999999999.',
|
||||
)
|
||||
self.seconds = seconds
|
||||
self.nanoseconds = nanoseconds
|
||||
|
||||
def __repr__(self):
|
||||
"""String representation of Timestamp."""
|
||||
return "Timestamp(seconds={0}, nanoseconds={1})".format(
|
||||
self.seconds, self.nanoseconds
|
||||
return 'Timestamp(seconds={}, nanoseconds={})'.format(
|
||||
self.seconds, self.nanoseconds,
|
||||
)
|
||||
|
||||
def __eq__(self, other):
|
||||
|
|
@ -100,17 +101,17 @@ class Timestamp(object):
|
|||
:rtype: Timestamp
|
||||
"""
|
||||
if len(b) == 4:
|
||||
seconds = struct.unpack("!L", b)[0]
|
||||
seconds = struct.unpack('!L', b)[0]
|
||||
nanoseconds = 0
|
||||
elif len(b) == 8:
|
||||
data64 = struct.unpack("!Q", b)[0]
|
||||
data64 = struct.unpack('!Q', b)[0]
|
||||
seconds = data64 & 0x00000003FFFFFFFF
|
||||
nanoseconds = data64 >> 34
|
||||
elif len(b) == 12:
|
||||
nanoseconds, seconds = struct.unpack("!Iq", b)
|
||||
nanoseconds, seconds = struct.unpack('!Iq', b)
|
||||
else:
|
||||
raise ValueError(
|
||||
"Timestamp type can only be created from 32, 64, or 96-bit byte objects"
|
||||
'Timestamp type can only be created from 32, 64, or 96-bit byte objects',
|
||||
)
|
||||
return Timestamp(seconds, nanoseconds)
|
||||
|
||||
|
|
@ -126,13 +127,13 @@ class Timestamp(object):
|
|||
data64 = self.nanoseconds << 34 | self.seconds
|
||||
if data64 & 0xFFFFFFFF00000000 == 0:
|
||||
# nanoseconds is zero and seconds < 2**32, so timestamp 32
|
||||
data = struct.pack("!L", data64)
|
||||
data = struct.pack('!L', data64)
|
||||
else:
|
||||
# timestamp 64
|
||||
data = struct.pack("!Q", data64)
|
||||
data = struct.pack('!Q', data64)
|
||||
else:
|
||||
# timestamp 96
|
||||
data = struct.pack("!Iq", self.nanoseconds, self.seconds)
|
||||
data = struct.pack('!Iq', self.nanoseconds, self.seconds)
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
|
|
@ -179,7 +180,7 @@ class Timestamp(object):
|
|||
:rtype: datetime.
|
||||
"""
|
||||
return datetime.datetime.fromtimestamp(0, _utc) + datetime.timedelta(
|
||||
seconds=self.to_unix()
|
||||
seconds=self.to_unix(),
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
|
|
|
|||
|
|
@ -1,7 +1,11 @@
|
|||
"""Fallback pure Python implementation of msgpack"""
|
||||
from datetime import datetime as _DateTime
|
||||
import sys
|
||||
from __future__ import annotations
|
||||
from .ext import ExtType, Timestamp
|
||||
from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
|
||||
|
||||
import struct
|
||||
import sys
|
||||
from datetime import datetime as _DateTime
|
||||
|
||||
|
||||
PY2 = sys.version_info[0] == 2
|
||||
|
|
@ -21,25 +25,11 @@ else:
|
|||
return d.items()
|
||||
|
||||
|
||||
if sys.version_info < (3, 5):
|
||||
# Ugly hack...
|
||||
RecursionError = RuntimeError
|
||||
|
||||
def _is_recursionerror(e):
|
||||
return (
|
||||
len(e.args) == 1
|
||||
and isinstance(e.args[0], str)
|
||||
and e.args[0].startswith("maximum recursion depth exceeded")
|
||||
)
|
||||
def _is_recursionerror(e):
|
||||
return True
|
||||
|
||||
|
||||
else:
|
||||
|
||||
def _is_recursionerror(e):
|
||||
return True
|
||||
|
||||
|
||||
if hasattr(sys, "pypy_version_info"):
|
||||
if hasattr(sys, 'pypy_version_info'):
|
||||
# StringIO is slow on PyPy, StringIO is faster. However: PyPy's own
|
||||
# StringBuilder is fastest.
|
||||
from __pypy__ import newlist_hint
|
||||
|
|
@ -50,8 +40,8 @@ if hasattr(sys, "pypy_version_info"):
|
|||
from __pypy__.builders import StringBuilder
|
||||
USING_STRINGBUILDER = True
|
||||
|
||||
class StringIO(object):
|
||||
def __init__(self, s=b""):
|
||||
class StringIO:
|
||||
def __init__(self, s=b''):
|
||||
if s:
|
||||
self.builder = StringBuilder(len(s))
|
||||
self.builder.append(s)
|
||||
|
|
@ -73,12 +63,7 @@ else:
|
|||
USING_STRINGBUILDER = False
|
||||
from io import BytesIO as StringIO
|
||||
|
||||
newlist_hint = lambda size: []
|
||||
|
||||
|
||||
from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
|
||||
|
||||
from .ext import ExtType, Timestamp
|
||||
def newlist_hint(size): return []
|
||||
|
||||
|
||||
EX_SKIP = 0
|
||||
|
|
@ -106,7 +91,7 @@ def _check_type_strict(obj, t, type=type, tuple=tuple):
|
|||
def _get_data_from_buffer(obj):
|
||||
view = memoryview(obj)
|
||||
if view.itemsize != 1:
|
||||
raise ValueError("cannot unpack from multi-byte object")
|
||||
raise ValueError('cannot unpack from multi-byte object')
|
||||
return view
|
||||
|
||||
|
||||
|
|
@ -127,7 +112,7 @@ def unpackb(packed, **kwargs):
|
|||
try:
|
||||
ret = unpacker._unpack()
|
||||
except OutOfData:
|
||||
raise ValueError("Unpack failed: incomplete input")
|
||||
raise ValueError('Unpack failed: incomplete input')
|
||||
except RecursionError as e:
|
||||
if _is_recursionerror(e):
|
||||
raise StackError
|
||||
|
|
@ -147,40 +132,40 @@ if sys.version_info < (2, 7, 6):
|
|||
else:
|
||||
_unpack_from = struct.unpack_from
|
||||
|
||||
_NO_FORMAT_USED = ""
|
||||
_NO_FORMAT_USED = ''
|
||||
_MSGPACK_HEADERS = {
|
||||
0xC4: (1, _NO_FORMAT_USED, TYPE_BIN),
|
||||
0xC5: (2, ">H", TYPE_BIN),
|
||||
0xC6: (4, ">I", TYPE_BIN),
|
||||
0xC7: (2, "Bb", TYPE_EXT),
|
||||
0xC8: (3, ">Hb", TYPE_EXT),
|
||||
0xC9: (5, ">Ib", TYPE_EXT),
|
||||
0xCA: (4, ">f"),
|
||||
0xCB: (8, ">d"),
|
||||
0xC5: (2, '>H', TYPE_BIN),
|
||||
0xC6: (4, '>I', TYPE_BIN),
|
||||
0xC7: (2, 'Bb', TYPE_EXT),
|
||||
0xC8: (3, '>Hb', TYPE_EXT),
|
||||
0xC9: (5, '>Ib', TYPE_EXT),
|
||||
0xCA: (4, '>f'),
|
||||
0xCB: (8, '>d'),
|
||||
0xCC: (1, _NO_FORMAT_USED),
|
||||
0xCD: (2, ">H"),
|
||||
0xCE: (4, ">I"),
|
||||
0xCF: (8, ">Q"),
|
||||
0xD0: (1, "b"),
|
||||
0xD1: (2, ">h"),
|
||||
0xD2: (4, ">i"),
|
||||
0xD3: (8, ">q"),
|
||||
0xD4: (1, "b1s", TYPE_EXT),
|
||||
0xD5: (2, "b2s", TYPE_EXT),
|
||||
0xD6: (4, "b4s", TYPE_EXT),
|
||||
0xD7: (8, "b8s", TYPE_EXT),
|
||||
0xD8: (16, "b16s", TYPE_EXT),
|
||||
0xCD: (2, '>H'),
|
||||
0xCE: (4, '>I'),
|
||||
0xCF: (8, '>Q'),
|
||||
0xD0: (1, 'b'),
|
||||
0xD1: (2, '>h'),
|
||||
0xD2: (4, '>i'),
|
||||
0xD3: (8, '>q'),
|
||||
0xD4: (1, 'b1s', TYPE_EXT),
|
||||
0xD5: (2, 'b2s', TYPE_EXT),
|
||||
0xD6: (4, 'b4s', TYPE_EXT),
|
||||
0xD7: (8, 'b8s', TYPE_EXT),
|
||||
0xD8: (16, 'b16s', TYPE_EXT),
|
||||
0xD9: (1, _NO_FORMAT_USED, TYPE_RAW),
|
||||
0xDA: (2, ">H", TYPE_RAW),
|
||||
0xDB: (4, ">I", TYPE_RAW),
|
||||
0xDC: (2, ">H", TYPE_ARRAY),
|
||||
0xDD: (4, ">I", TYPE_ARRAY),
|
||||
0xDE: (2, ">H", TYPE_MAP),
|
||||
0xDF: (4, ">I", TYPE_MAP),
|
||||
0xDA: (2, '>H', TYPE_RAW),
|
||||
0xDB: (4, '>I', TYPE_RAW),
|
||||
0xDC: (2, '>H', TYPE_ARRAY),
|
||||
0xDD: (4, '>I', TYPE_ARRAY),
|
||||
0xDE: (2, '>H', TYPE_MAP),
|
||||
0xDF: (4, '>I', TYPE_MAP),
|
||||
}
|
||||
|
||||
|
||||
class Unpacker(object):
|
||||
class Unpacker:
|
||||
"""Streaming unpacker.
|
||||
|
||||
Arguments:
|
||||
|
|
@ -297,13 +282,13 @@ class Unpacker(object):
|
|||
max_ext_len=-1,
|
||||
):
|
||||
if unicode_errors is None:
|
||||
unicode_errors = "strict"
|
||||
unicode_errors = 'strict'
|
||||
|
||||
if file_like is None:
|
||||
self._feeding = True
|
||||
else:
|
||||
if not callable(file_like.read):
|
||||
raise TypeError("`file_like.read` must be callable")
|
||||
raise TypeError('`file_like.read` must be callable')
|
||||
self.file_like = file_like
|
||||
self._feeding = False
|
||||
|
||||
|
|
@ -336,14 +321,14 @@ class Unpacker(object):
|
|||
|
||||
self._max_buffer_size = max_buffer_size
|
||||
if read_size > self._max_buffer_size:
|
||||
raise ValueError("read_size must be smaller than max_buffer_size")
|
||||
raise ValueError('read_size must be smaller than max_buffer_size')
|
||||
self._read_size = read_size or min(self._max_buffer_size, 16 * 1024)
|
||||
self._raw = bool(raw)
|
||||
self._strict_map_key = bool(strict_map_key)
|
||||
self._unicode_errors = unicode_errors
|
||||
self._use_list = use_list
|
||||
if not (0 <= timestamp <= 3):
|
||||
raise ValueError("timestamp must be 0..3")
|
||||
raise ValueError('timestamp must be 0..3')
|
||||
self._timestamp = timestamp
|
||||
self._list_hook = list_hook
|
||||
self._object_hook = object_hook
|
||||
|
|
@ -357,17 +342,17 @@ class Unpacker(object):
|
|||
self._stream_offset = 0
|
||||
|
||||
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):
|
||||
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):
|
||||
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:
|
||||
raise TypeError(
|
||||
"object_pairs_hook and object_hook are mutually " "exclusive"
|
||||
'object_pairs_hook and object_hook are mutually ' 'exclusive',
|
||||
)
|
||||
if not callable(ext_hook):
|
||||
raise TypeError("`ext_hook` is not callable")
|
||||
raise TypeError('`ext_hook` is not callable')
|
||||
|
||||
def feed(self, next_bytes):
|
||||
assert self._feeding
|
||||
|
|
@ -393,7 +378,7 @@ class Unpacker(object):
|
|||
return self._buff_i < len(self._buffer)
|
||||
|
||||
def _get_extradata(self):
|
||||
return self._buffer[self._buff_i :]
|
||||
return self._buffer[self._buff_i:]
|
||||
|
||||
def read_bytes(self, n):
|
||||
ret = self._read(n, raise_outofdata=False)
|
||||
|
|
@ -404,7 +389,7 @@ class Unpacker(object):
|
|||
# (int) -> bytearray
|
||||
self._reserve(n, raise_outofdata=raise_outofdata)
|
||||
i = self._buff_i
|
||||
ret = self._buffer[i : i + n]
|
||||
ret = self._buffer[i: i + n]
|
||||
self._buff_i = i + len(ret)
|
||||
return ret
|
||||
|
||||
|
|
@ -455,20 +440,20 @@ class Unpacker(object):
|
|||
n = b & 0b00011111
|
||||
typ = TYPE_RAW
|
||||
if n > self._max_str_len:
|
||||
raise ValueError("%s exceeds max_str_len(%s)" % (n, self._max_str_len))
|
||||
raise ValueError('{} exceeds max_str_len({})'.format(n, self._max_str_len))
|
||||
obj = self._read(n)
|
||||
elif b & 0b11110000 == 0b10010000:
|
||||
n = b & 0b00001111
|
||||
typ = TYPE_ARRAY
|
||||
if n > self._max_array_len:
|
||||
raise ValueError(
|
||||
"%s exceeds max_array_len(%s)" % (n, self._max_array_len)
|
||||
'{} exceeds max_array_len({})'.format(n, self._max_array_len),
|
||||
)
|
||||
elif b & 0b11110000 == 0b10000000:
|
||||
n = b & 0b00001111
|
||||
typ = TYPE_MAP
|
||||
if n > self._max_map_len:
|
||||
raise ValueError("%s exceeds max_map_len(%s)" % (n, self._max_map_len))
|
||||
raise ValueError('{} exceeds max_map_len({})'.format(n, self._max_map_len))
|
||||
elif b == 0xC0:
|
||||
obj = None
|
||||
elif b == 0xC2:
|
||||
|
|
@ -484,7 +469,7 @@ class Unpacker(object):
|
|||
n = self._buffer[self._buff_i]
|
||||
self._buff_i += size
|
||||
if n > self._max_bin_len:
|
||||
raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
|
||||
raise ValueError('{} exceeds max_bin_len({})'.format(n, self._max_bin_len))
|
||||
obj = self._read(n)
|
||||
elif 0xC7 <= b <= 0xC9:
|
||||
size, fmt, typ = _MSGPACK_HEADERS[b]
|
||||
|
|
@ -492,7 +477,7 @@ class Unpacker(object):
|
|||
L, n = _unpack_from(fmt, self._buffer, self._buff_i)
|
||||
self._buff_i += size
|
||||
if L > self._max_ext_len:
|
||||
raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
|
||||
raise ValueError('{} exceeds max_ext_len({})'.format(L, self._max_ext_len))
|
||||
obj = self._read(L)
|
||||
elif 0xCA <= b <= 0xD3:
|
||||
size, fmt = _MSGPACK_HEADERS[b]
|
||||
|
|
@ -506,7 +491,7 @@ class Unpacker(object):
|
|||
size, fmt, typ = _MSGPACK_HEADERS[b]
|
||||
if self._max_ext_len < size:
|
||||
raise ValueError(
|
||||
"%s exceeds max_ext_len(%s)" % (size, self._max_ext_len)
|
||||
'{} exceeds max_ext_len({})'.format(size, self._max_ext_len),
|
||||
)
|
||||
self._reserve(size + 1)
|
||||
n, obj = _unpack_from(fmt, self._buffer, self._buff_i)
|
||||
|
|
@ -520,7 +505,7 @@ class Unpacker(object):
|
|||
n = self._buffer[self._buff_i]
|
||||
self._buff_i += size
|
||||
if n > self._max_str_len:
|
||||
raise ValueError("%s exceeds max_str_len(%s)" % (n, self._max_str_len))
|
||||
raise ValueError('{} exceeds max_str_len({})'.format(n, self._max_str_len))
|
||||
obj = self._read(n)
|
||||
elif 0xDC <= b <= 0xDD:
|
||||
size, fmt, typ = _MSGPACK_HEADERS[b]
|
||||
|
|
@ -529,7 +514,7 @@ class Unpacker(object):
|
|||
self._buff_i += size
|
||||
if n > self._max_array_len:
|
||||
raise ValueError(
|
||||
"%s exceeds max_array_len(%s)" % (n, self._max_array_len)
|
||||
'{} exceeds max_array_len({})'.format(n, self._max_array_len),
|
||||
)
|
||||
elif 0xDE <= b <= 0xDF:
|
||||
size, fmt, typ = _MSGPACK_HEADERS[b]
|
||||
|
|
@ -537,9 +522,9 @@ class Unpacker(object):
|
|||
(n,) = _unpack_from(fmt, self._buffer, self._buff_i)
|
||||
self._buff_i += size
|
||||
if n > self._max_map_len:
|
||||
raise ValueError("%s exceeds max_map_len(%s)" % (n, self._max_map_len))
|
||||
raise ValueError('{} exceeds max_map_len({})'.format(n, self._max_map_len))
|
||||
else:
|
||||
raise FormatError("Unknown header: 0x%x" % b)
|
||||
raise FormatError('Unknown header: 0x%x' % b)
|
||||
return typ, n, obj
|
||||
|
||||
def _unpack(self, execute=EX_CONSTRUCT):
|
||||
|
|
@ -547,11 +532,11 @@ class Unpacker(object):
|
|||
|
||||
if execute == EX_READ_ARRAY_HEADER:
|
||||
if typ != TYPE_ARRAY:
|
||||
raise ValueError("Expected array")
|
||||
raise ValueError('Expected array')
|
||||
return n
|
||||
if execute == EX_READ_MAP_HEADER:
|
||||
if typ != TYPE_MAP:
|
||||
raise ValueError("Expected map")
|
||||
raise ValueError('Expected map')
|
||||
return n
|
||||
# TODO should we eliminate the recursion?
|
||||
if typ == TYPE_ARRAY:
|
||||
|
|
@ -585,7 +570,7 @@ class Unpacker(object):
|
|||
key = self._unpack(EX_CONSTRUCT)
|
||||
if self._strict_map_key and type(key) not in (unicode, bytes):
|
||||
raise ValueError(
|
||||
"%s is not allowed for map key" % str(type(key))
|
||||
'%s is not allowed for map key' % str(type(key)),
|
||||
)
|
||||
if not PY2 and type(key) is str:
|
||||
key = sys.intern(key)
|
||||
|
|
@ -599,7 +584,7 @@ class Unpacker(object):
|
|||
if self._raw:
|
||||
obj = bytes(obj)
|
||||
else:
|
||||
obj = obj.decode("utf_8", self._unicode_errors)
|
||||
obj = obj.decode('utf_8', self._unicode_errors)
|
||||
return obj
|
||||
if typ == TYPE_BIN:
|
||||
return bytes(obj)
|
||||
|
|
@ -661,7 +646,7 @@ class Unpacker(object):
|
|||
return self._stream_offset
|
||||
|
||||
|
||||
class Packer(object):
|
||||
class Packer:
|
||||
"""
|
||||
MessagePack Packer
|
||||
|
||||
|
|
@ -746,12 +731,12 @@ class Packer(object):
|
|||
self._use_bin_type = use_bin_type
|
||||
self._buffer = StringIO()
|
||||
if PY2 and datetime:
|
||||
raise ValueError("datetime is not supported in Python 2")
|
||||
raise ValueError('datetime is not supported in Python 2')
|
||||
self._datetime = bool(datetime)
|
||||
self._unicode_errors = unicode_errors or "strict"
|
||||
self._unicode_errors = unicode_errors or 'strict'
|
||||
if default is not None:
|
||||
if not callable(default):
|
||||
raise TypeError("default must be callable")
|
||||
raise TypeError('default must be callable')
|
||||
self._default = default
|
||||
|
||||
def _pack(
|
||||
|
|
@ -769,62 +754,62 @@ class Packer(object):
|
|||
list_types = (list, tuple)
|
||||
while True:
|
||||
if nest_limit < 0:
|
||||
raise ValueError("recursion limit exceeded")
|
||||
raise ValueError('recursion limit exceeded')
|
||||
if obj is None:
|
||||
return self._buffer.write(b"\xc0")
|
||||
return self._buffer.write(b'\xc0')
|
||||
if check(obj, bool):
|
||||
if obj:
|
||||
return self._buffer.write(b"\xc3")
|
||||
return self._buffer.write(b"\xc2")
|
||||
return self._buffer.write(b'\xc3')
|
||||
return self._buffer.write(b'\xc2')
|
||||
if check(obj, int_types):
|
||||
if 0 <= obj < 0x80:
|
||||
return self._buffer.write(struct.pack("B", obj))
|
||||
return self._buffer.write(struct.pack('B', obj))
|
||||
if -0x20 <= obj < 0:
|
||||
return self._buffer.write(struct.pack("b", obj))
|
||||
return self._buffer.write(struct.pack('b', obj))
|
||||
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:
|
||||
return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
|
||||
return self._buffer.write(struct.pack('>Bb', 0xD0, obj))
|
||||
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:
|
||||
return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
|
||||
return self._buffer.write(struct.pack('>Bh', 0xD1, obj))
|
||||
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:
|
||||
return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
|
||||
return self._buffer.write(struct.pack('>Bi', 0xD2, obj))
|
||||
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:
|
||||
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:
|
||||
obj = self._default(obj)
|
||||
default_used = True
|
||||
continue
|
||||
raise OverflowError("Integer value out of range")
|
||||
raise OverflowError('Integer value out of range')
|
||||
if check(obj, (bytes, bytearray)):
|
||||
n = len(obj)
|
||||
if n >= 2 ** 32:
|
||||
raise ValueError("%s is too large" % type(obj).__name__)
|
||||
raise ValueError('%s is too large' % type(obj).__name__)
|
||||
self._pack_bin_header(n)
|
||||
return self._buffer.write(obj)
|
||||
if check(obj, unicode):
|
||||
obj = obj.encode("utf-8", self._unicode_errors)
|
||||
obj = obj.encode('utf-8', self._unicode_errors)
|
||||
n = len(obj)
|
||||
if n >= 2 ** 32:
|
||||
raise ValueError("String is too large")
|
||||
raise ValueError('String is too large')
|
||||
self._pack_raw_header(n)
|
||||
return self._buffer.write(obj)
|
||||
if check(obj, memoryview):
|
||||
n = len(obj) * obj.itemsize
|
||||
if n >= 2 ** 32:
|
||||
raise ValueError("Memoryview is too large")
|
||||
raise ValueError('Memoryview is too large')
|
||||
self._pack_bin_header(n)
|
||||
return self._buffer.write(obj)
|
||||
if check(obj, float):
|
||||
if self._use_float:
|
||||
return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
|
||||
return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
|
||||
return self._buffer.write(struct.pack('>Bf', 0xCA, obj))
|
||||
return self._buffer.write(struct.pack('>Bd', 0xCB, obj))
|
||||
if check(obj, (ExtType, Timestamp)):
|
||||
if check(obj, Timestamp):
|
||||
code = -1
|
||||
|
|
@ -836,22 +821,22 @@ class Packer(object):
|
|||
assert isinstance(data, bytes)
|
||||
L = len(data)
|
||||
if L == 1:
|
||||
self._buffer.write(b"\xd4")
|
||||
self._buffer.write(b'\xd4')
|
||||
elif L == 2:
|
||||
self._buffer.write(b"\xd5")
|
||||
self._buffer.write(b'\xd5')
|
||||
elif L == 4:
|
||||
self._buffer.write(b"\xd6")
|
||||
self._buffer.write(b'\xd6')
|
||||
elif L == 8:
|
||||
self._buffer.write(b"\xd7")
|
||||
self._buffer.write(b'\xd7')
|
||||
elif L == 16:
|
||||
self._buffer.write(b"\xd8")
|
||||
self._buffer.write(b'\xd8')
|
||||
elif L <= 0xFF:
|
||||
self._buffer.write(struct.pack(">BB", 0xC7, L))
|
||||
self._buffer.write(struct.pack('>BB', 0xC7, L))
|
||||
elif L <= 0xFFFF:
|
||||
self._buffer.write(struct.pack(">BH", 0xC8, L))
|
||||
self._buffer.write(struct.pack('>BH', 0xC8, L))
|
||||
else:
|
||||
self._buffer.write(struct.pack(">BI", 0xC9, L))
|
||||
self._buffer.write(struct.pack("b", code))
|
||||
self._buffer.write(struct.pack('>BI', 0xC9, L))
|
||||
self._buffer.write(struct.pack('b', code))
|
||||
self._buffer.write(data)
|
||||
return
|
||||
if check(obj, list_types):
|
||||
|
|
@ -862,7 +847,7 @@ class Packer(object):
|
|||
return
|
||||
if check(obj, dict):
|
||||
return self._pack_map_pairs(
|
||||
len(obj), dict_iteritems(obj), nest_limit - 1
|
||||
len(obj), dict_iteritems(obj), nest_limit - 1,
|
||||
)
|
||||
|
||||
if self._datetime and check(obj, _DateTime) and obj.tzinfo is not None:
|
||||
|
|
@ -876,9 +861,9 @@ class Packer(object):
|
|||
continue
|
||||
|
||||
if self._datetime and check(obj, _DateTime):
|
||||
raise ValueError("Cannot serialize %r where tzinfo=None" % (obj,))
|
||||
raise ValueError('Cannot serialize {!r} where tzinfo=None'.format(obj))
|
||||
|
||||
raise TypeError("Cannot serialize %r" % (obj,))
|
||||
raise TypeError('Cannot serialize {!r}'.format(obj))
|
||||
|
||||
def pack(self, obj):
|
||||
try:
|
||||
|
|
@ -918,50 +903,50 @@ class Packer(object):
|
|||
|
||||
def pack_ext_type(self, typecode, data):
|
||||
if not isinstance(typecode, int):
|
||||
raise TypeError("typecode must have int type.")
|
||||
raise TypeError('typecode must have int type.')
|
||||
if not 0 <= typecode <= 127:
|
||||
raise ValueError("typecode should be 0-127")
|
||||
raise ValueError('typecode should be 0-127')
|
||||
if not isinstance(data, bytes):
|
||||
raise TypeError("data must have bytes type")
|
||||
raise TypeError('data must have bytes type')
|
||||
L = len(data)
|
||||
if L > 0xFFFFFFFF:
|
||||
raise ValueError("Too large data")
|
||||
raise ValueError('Too large data')
|
||||
if L == 1:
|
||||
self._buffer.write(b"\xd4")
|
||||
self._buffer.write(b'\xd4')
|
||||
elif L == 2:
|
||||
self._buffer.write(b"\xd5")
|
||||
self._buffer.write(b'\xd5')
|
||||
elif L == 4:
|
||||
self._buffer.write(b"\xd6")
|
||||
self._buffer.write(b'\xd6')
|
||||
elif L == 8:
|
||||
self._buffer.write(b"\xd7")
|
||||
self._buffer.write(b'\xd7')
|
||||
elif L == 16:
|
||||
self._buffer.write(b"\xd8")
|
||||
self._buffer.write(b'\xd8')
|
||||
elif L <= 0xFF:
|
||||
self._buffer.write(b"\xc7" + struct.pack("B", L))
|
||||
self._buffer.write(b'\xc7' + struct.pack('B', L))
|
||||
elif L <= 0xFFFF:
|
||||
self._buffer.write(b"\xc8" + struct.pack(">H", L))
|
||||
self._buffer.write(b'\xc8' + struct.pack('>H', L))
|
||||
else:
|
||||
self._buffer.write(b"\xc9" + struct.pack(">I", L))
|
||||
self._buffer.write(struct.pack("B", typecode))
|
||||
self._buffer.write(b'\xc9' + struct.pack('>I', L))
|
||||
self._buffer.write(struct.pack('B', typecode))
|
||||
self._buffer.write(data)
|
||||
|
||||
def _pack_array_header(self, n):
|
||||
if n <= 0x0F:
|
||||
return self._buffer.write(struct.pack("B", 0x90 + n))
|
||||
return self._buffer.write(struct.pack('B', 0x90 + n))
|
||||
if n <= 0xFFFF:
|
||||
return self._buffer.write(struct.pack(">BH", 0xDC, n))
|
||||
return self._buffer.write(struct.pack('>BH', 0xDC, n))
|
||||
if n <= 0xFFFFFFFF:
|
||||
return self._buffer.write(struct.pack(">BI", 0xDD, n))
|
||||
raise ValueError("Array is too large")
|
||||
return self._buffer.write(struct.pack('>BI', 0xDD, n))
|
||||
raise ValueError('Array is too large')
|
||||
|
||||
def _pack_map_header(self, n):
|
||||
if n <= 0x0F:
|
||||
return self._buffer.write(struct.pack("B", 0x80 + n))
|
||||
return self._buffer.write(struct.pack('B', 0x80 + n))
|
||||
if n <= 0xFFFF:
|
||||
return self._buffer.write(struct.pack(">BH", 0xDE, n))
|
||||
return self._buffer.write(struct.pack('>BH', 0xDE, n))
|
||||
if n <= 0xFFFFFFFF:
|
||||
return self._buffer.write(struct.pack(">BI", 0xDF, n))
|
||||
raise ValueError("Dict is too large")
|
||||
return self._buffer.write(struct.pack('>BI', 0xDF, n))
|
||||
raise ValueError('Dict is too large')
|
||||
|
||||
def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
|
||||
self._pack_map_header(n)
|
||||
|
|
@ -971,27 +956,27 @@ class Packer(object):
|
|||
|
||||
def _pack_raw_header(self, n):
|
||||
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:
|
||||
self._buffer.write(struct.pack(">BB", 0xD9, n))
|
||||
self._buffer.write(struct.pack('>BB', 0xD9, n))
|
||||
elif n <= 0xFFFF:
|
||||
self._buffer.write(struct.pack(">BH", 0xDA, n))
|
||||
self._buffer.write(struct.pack('>BH', 0xDA, n))
|
||||
elif n <= 0xFFFFFFFF:
|
||||
self._buffer.write(struct.pack(">BI", 0xDB, n))
|
||||
self._buffer.write(struct.pack('>BI', 0xDB, n))
|
||||
else:
|
||||
raise ValueError("Raw is too large")
|
||||
raise ValueError('Raw is too large')
|
||||
|
||||
def _pack_bin_header(self, n):
|
||||
if not self._use_bin_type:
|
||||
return self._pack_raw_header(n)
|
||||
elif n <= 0xFF:
|
||||
return self._buffer.write(struct.pack(">BB", 0xC4, n))
|
||||
return self._buffer.write(struct.pack('>BB', 0xC4, n))
|
||||
elif n <= 0xFFFF:
|
||||
return self._buffer.write(struct.pack(">BH", 0xC5, n))
|
||||
return self._buffer.write(struct.pack('>BH', 0xC5, n))
|
||||
elif n <= 0xFFFFFFFF:
|
||||
return self._buffer.write(struct.pack(">BI", 0xC6, n))
|
||||
return self._buffer.write(struct.pack('>BI', 0xC6, n))
|
||||
else:
|
||||
raise ValueError("Bin is too large")
|
||||
raise ValueError('Bin is too large')
|
||||
|
||||
def bytes(self):
|
||||
"""Return internal buffer contents as bytes object"""
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue