u-msgpack-python 2.7.2__py2.py3-none-any.whl → 2.9.0__py2.py3-none-any.whl

{u_msgpack_python-2.7.2.dist-info → u_msgpack_python-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: u-msgpack-python
-Version: 2.7.2
+Version: 2.9.0
 Summary: A portable, lightweight MessagePack serializer and deserializer written in pure Python.
 Home-page: https://github.com/vsergeev/u-msgpack-python
 Author: vsergeev
@@ -15,6 +15,17 @@ Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+Description-Content-Type: text/x-rst
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
 
-u-msgpack-python is a lightweight `MessagePack <http://msgpack.org/>`_ serializer and deserializer module written in pure Python, compatible with both Python 2 and Python 3, as well as CPython and PyPy implementations of Python. u-msgpack-python is fully compliant with the latest `MessagePack specification <https://github.com/msgpack/msgpack/blob/master/spec.md>`_. In particular, it supports the new binary, UTF-8 string, and application-defined ext types. See https://github.com/vsergeev/u-msgpack-python for more information.
+u-msgpack-python is a lightweight `MessagePack <http://msgpack.org/>`_ serializer and deserializer module written in pure Python, compatible with both Python 2 and Python 3, as well as CPython and PyPy implementations of Python. u-msgpack-python is fully compliant with the latest `MessagePack specification <https://github.com/msgpack/msgpack/blob/master/spec.md>`_. In particular, it supports the new binary, UTF-8 string, application-defined ext, and timestamp types. See https://github.com/vsergeev/u-msgpack-python for more information.

u_msgpack_python-2.9.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+u_msgpack_python-2.9.0.dist-info/licenses/LICENSE,sha256=kJ7HHWniTZmi0a_g5n8zugdLk8rdZtMLBW_amWg85w4,1099
+umsgpack/__init__.py,sha256=_Z8_0-exPbD9stBK0f45hNhMkmbV5qv6APusRxt89oQ,48613
+umsgpack/__init__.pyi,sha256=Bb8mY8eZzxXvqKOI4nE9wE5xmdRkCOzv3LIg1LhDi6Y,2988
+umsgpack/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+u_msgpack_python-2.9.0.dist-info/METADATA,sha256=WTocwq61KICY7gXP5iOivOxq0expvv6q3vPknwAdNPU,1560
+u_msgpack_python-2.9.0.dist-info/WHEEL,sha256=Uvlg2aNlEKdilsyFSJt1QX5me0eEbCjQzR3nZeFkvy4,109
+u_msgpack_python-2.9.0.dist-info/top_level.txt,sha256=vlKYkefVvMYiE2tS8E4NKGRXIGIWzQq9ar1A0j2avaA,9
+u_msgpack_python-2.9.0.dist-info/RECORD,,

{u_msgpack_python-2.7.2.dist-info → u_msgpack_python-2.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

{u_msgpack_python-2.7.2.dist-info → u_msgpack_python-2.9.0.dist-info/licenses}/LICENSE

@@ -1,4 +1,4 @@
- Copyright (c) 2013-2022 vsergeev / Ivan (Vanya) A. Sergeev
+ Copyright (c) 2013-2026 vsergeev / Ivan (Vanya) A. Sergeev
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal

umsgpack.py → umsgpack/__init__.py

@@ -1,16 +1,17 @@
-# u-msgpack-python v2.7.2 - v at sergeev.io
+# u-msgpack-python v2.9.0 - v at sergeev.io
 # https://github.com/vsergeev/u-msgpack-python
 #
 # u-msgpack-python is a lightweight MessagePack serializer and deserializer
-# module, compatible with both Python 2 and 3, as well CPython and PyPy
+# module, compatible with both Python 2 and 3, as well as CPython and PyPy
 # implementations of Python. u-msgpack-python is fully compliant with the
-# latest MessagePack specification.com/msgpack/msgpack/blob/master/spec.md). In
-# particular, it supports the new binary, UTF-8 string, and application ext
-# types.
+# latest MessagePack specification
+# (https://github.com/msgpack/msgpack/blob/master/spec.md). In particular, it
+# supports the new binary, UTF-8 string, application-defined ext, and
+# timestamp types.
 #
 # MIT License
 #
-# Copyright (c) 2013-2022 vsergeev / Ivan (Vanya) A. Sergeev
+# Copyright (c) 2013-2026 vsergeev / Ivan (Vanya) A. Sergeev
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -31,20 +32,22 @@
 # THE SOFTWARE.
 #
 """
-u-msgpack-python v2.7.2 - v at sergeev.io
+u-msgpack-python v2.9.0 - v at sergeev.io
 https://github.com/vsergeev/u-msgpack-python
 
 u-msgpack-python is a lightweight MessagePack serializer and deserializer
-module, compatible with both Python 2 and 3, as well CPython and PyPy
+module, compatible with both Python 2 and 3, as well as CPython and PyPy
 implementations of Python. u-msgpack-python is fully compliant with the
-latest MessagePack specification.com/msgpack/msgpack/blob/master/spec.md). In
-particular, it supports the new binary, UTF-8 string, and application ext
+latest MessagePack specification
+(https://github.com/msgpack/msgpack/blob/master/spec.md). In particular, it
+supports the new binary, UTF-8 string, application-defined ext, and timestamp
 types.
 
 License: MIT
 """
 import struct
 import collections
+import functools
 import datetime
 import sys
 import io
@@ -54,10 +57,11 @@ if sys.version_info[0:2] >= (3, 3):
 else:
     from collections import Hashable
 
-__version__ = "2.7.2"
+
+__version__ = "2.9.0"
 "Module version string"
 
-version = (2, 7, 2)
+version = (2, 9, 0)
 "Module version tuple"
 
 
@@ -77,24 +81,24 @@ class Ext(object):
         Construct a new Ext object.
 
         Args:
-            type: application-defined type integer
-            data: application-defined data byte array
+            type (int): application-defined type integer
+            data (bytes): application-defined data byte array
 
-        TypeError:
-            Type is not an integer.
-        ValueError:
-            Type is out of range of -128 to 127.
-        TypeError::
-            Data is not type 'bytes' (Python 3) or not type 'str' (Python 2).
+        Raises:
+            TypeError:
+                Type is not an integer.
+            ValueError:
+                Type is out of range of -128 to 127.
+            TypeError:
+                Data is not type 'bytes' (Python 3) or not type 'str' (Python 2).
 
         Example:
-        >>> foo = umsgpack.Ext(5, b"\x01\x02\x03")
-        >>> umsgpack.packb({u"special stuff": foo, u"awesome": True})
-        '\x82\xa7awesome\xc3\xadspecial stuff\xc7\x03\x05\x01\x02\x03'
-        >>> bar = umsgpack.unpackb(_)
-        >>> print(bar["special stuff"])
-        Ext Object (Type: 5, Data: 01 02 03)
-        >>>
+            >>> foo = umsgpack.Ext(5, b"\\x01\\x02\\x03")
+            >>> umsgpack.packb({u"special stuff": foo, u"awesome": True})
+            b'\\x82\\xadspecial stuff\\xc7\\x03\\x05\\x01\\x02\\x03\\xa7awesome\\xc3'
+            >>> bar = umsgpack.unpackb(_)
+            >>> print(bar["special stuff"])
+            Ext Object (Type: 5, Data: 0x01 0x02 0x03)
         """
         # Check type is type int and in range
         if not isinstance(type, int):
@@ -163,7 +167,7 @@ def ext_serializable(ext_type):
     instance of the application class.
 
     Args:
-        ext_type: application-defined Ext type code
+        ext_type (int): application-defined Ext type code
 
     Raises:
         TypeError:
@@ -238,6 +242,10 @@ class DuplicateKeyException(UnpackException):
     "Duplicate key encountered during map unpacking."
 
 
+class MaximumDepthException(UnpackException):
+    "Maximum nesting depth exceeded during unpacking."
+
+
 # Backwards compatibility
 KeyNotPrimitiveException = UnhashableKeyException
 KeyDuplicateException = DuplicateKeyException
@@ -266,13 +274,11 @@ unicode strings and bytes into the old "raw" msgpack type, and deserialize the
 old MessagePack specification.
 
 Example:
->>> umsgpack.compatibility = True
->>>
->>> umsgpack.packb([u"some string", b"some bytes"])
-b'\x92\xabsome string\xaasome bytes'
->>> umsgpack.unpackb(_)
-[b'some string', b'some bytes']
->>>
+    >>> umsgpack.compatibility = True
+    >>> umsgpack.packb([u"some string", b"some bytes"])
+    b'\\x92\\xabsome string\\xaasome bytes'
+    >>> umsgpack.unpackb(_)
+    [b'some string', b'some bytes']
 """
 
 ##############################################################################
@@ -444,7 +450,7 @@ def _pack_map(obj, fp, options):
     elif obj_len < 2**32:
         fp.write(b"\xdf" + struct.pack(">I", obj_len))
     else:
-        raise UnsupportedTypeException("huge array")
+        raise UnsupportedTypeException("huge map")
 
     for k, v in obj.items():
         pack(k, fp, **options)
@@ -462,29 +468,26 @@ def _pack2(obj, fp, **options):
         obj: a Python object
         fp: a .write()-supporting file-like object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
                              to a callable that packs an instance of the type
                              into an Ext object
         force_float_precision (str): "single" to force packing floats as
                                      IEEE-754 single-precision floats,
                                      "double" to force packing floats as
-                                     IEEE-754 double-precision floats.
+                                     IEEE-754 double-precision floats
 
     Returns:
-        None.
+        None
 
     Raises:
-        UnsupportedType(PackException):
+        UnsupportedTypeException(PackException):
             Object type not supported for packing.
 
     Example:
-    >>> f = open('test.bin', 'wb')
-    >>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
-    >>>
+        >>> f = open('test.bin', 'wb')
+        >>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
     """
-    global compatibility
-
     ext_handlers = options.get("ext_handlers")
 
     if obj is None:
@@ -498,15 +501,15 @@ def _pack2(obj, fp, **options):
             raise NotImplementedError("Ext serializable class {:s} is missing implementation of packb()".format(repr(obj.__class__)))
     elif isinstance(obj, bool):
         _pack_boolean(obj, fp, options)
-    elif isinstance(obj, (int, long)):
+    elif isinstance(obj, (int, long)):  # noqa: F821
         _pack_integer(obj, fp, options)
     elif isinstance(obj, float):
         _pack_float(obj, fp, options)
-    elif compatibility and isinstance(obj, unicode):
+    elif compatibility and isinstance(obj, unicode):  # noqa: F821
         _pack_oldspec_raw(bytes(obj), fp, options)
     elif compatibility and isinstance(obj, bytes):
         _pack_oldspec_raw(obj, fp, options)
-    elif isinstance(obj, unicode):
+    elif isinstance(obj, unicode):  # noqa: F821
         _pack_string(obj, fp, options)
     elif isinstance(obj, str):
         _pack_binary(obj, fp, options)
@@ -549,29 +552,26 @@ def _pack3(obj, fp, **options):
         obj: a Python object
         fp: a .write()-supporting file-like object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
                              to a callable that packs an instance of the type
                              into an Ext object
         force_float_precision (str): "single" to force packing floats as
                                      IEEE-754 single-precision floats,
                                      "double" to force packing floats as
-                                     IEEE-754 double-precision floats.
+                                     IEEE-754 double-precision floats
 
     Returns:
-        None.
+        None
 
     Raises:
-        UnsupportedType(PackException):
+        UnsupportedTypeException(PackException):
             Object type not supported for packing.
 
     Example:
-    >>> f = open('test.bin', 'wb')
-    >>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
-    >>>
+        >>> f = open('test.bin', 'wb')
+        >>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
     """
-    global compatibility
-
     ext_handlers = options.get("ext_handlers")
 
     if obj is None:
@@ -635,26 +635,25 @@ def _packb2(obj, **options):
     Args:
         obj: a Python object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
                              to a callable that packs an instance of the type
                              into an Ext object
         force_float_precision (str): "single" to force packing floats as
                                      IEEE-754 single-precision floats,
                                      "double" to force packing floats as
-                                     IEEE-754 double-precision floats.
+                                     IEEE-754 double-precision floats
 
     Returns:
-        A 'str' containing serialized MessagePack bytes.
+        str: Serialized MessagePack bytes
 
     Raises:
-        UnsupportedType(PackException):
+        UnsupportedTypeException(PackException):
             Object type not supported for packing.
 
     Example:
-    >>> umsgpack.packb({u"compact": True, u"schema": 0})
-    '\x82\xa7compact\xc3\xa6schema\x00'
-    >>>
+        >>> umsgpack.packb({u"compact": True, u"schema": 0})
+        '\\x82\\xa7compact\\xc3\\xa6schema\\x00'
     """
     fp = io.BytesIO()
     _pack2(obj, fp, **options)
@@ -668,26 +667,25 @@ def _packb3(obj, **options):
     Args:
         obj: a Python object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
                              to a callable that packs an instance of the type
                              into an Ext object
         force_float_precision (str): "single" to force packing floats as
                                      IEEE-754 single-precision floats,
                                      "double" to force packing floats as
-                                     IEEE-754 double-precision floats.
+                                     IEEE-754 double-precision floats
 
     Returns:
-        A 'bytes' containing serialized MessagePack bytes.
+        bytes: Serialized MessagePack bytes
 
     Raises:
-        UnsupportedType(PackException):
+        UnsupportedTypeException(PackException):
             Object type not supported for packing.
 
     Example:
-    >>> umsgpack.packb({u"compact": True, u"schema": 0})
-    b'\x82\xa7compact\xc3\xa6schema\x00'
-    >>>
+        >>> umsgpack.packb({u"compact": True, u"schema": 0})
+        b'\\x82\\xa7compact\\xc3\\xa6schema\\x00'
     """
     fp = io.BytesIO()
     _pack3(obj, fp, **options)
@@ -783,7 +781,6 @@ def _unpack_string(code, fp, options):
         raise Exception("logic error, not string: 0x{:02x}".format(ord(code)))
 
     # Always return raw bytes in compatibility mode
-    global compatibility
     if compatibility:
         return _read_except(fp, length)
 
@@ -874,7 +871,7 @@ def _unpack_ext_timestamp(ext_data, options):
                                        microseconds=microseconds)
 
 
-def _unpack_array(code, fp, options):
+def _unpack_array(code, fp, options, depth=None):
     if (ord(code) & 0xf0) == 0x90:
         length = (ord(code) & ~0xf0)
     elif code == b'\xdc':
@@ -885,9 +882,12 @@ def _unpack_array(code, fp, options):
         raise Exception("logic error, not array: 0x{:02x}".format(ord(code)))
 
     if options.get('use_tuple'):
-        return tuple((_unpack(fp, options) for i in xrange(length)))
+        return tuple((_unpack(fp, options) if depth is None
+                      else _unpack_depth(fp, options, depth)
+                      for i in xrange(length)))
 
-    return [_unpack(fp, options) for i in xrange(length)]
+    return [_unpack(fp, options) if depth is None
+            else _unpack_depth(fp, options, depth) for i in xrange(length)]
 
 
 def _deep_list_to_tuple(obj):
@@ -896,7 +896,7 @@ def _deep_list_to_tuple(obj):
     return obj
 
 
-def _unpack_map(code, fp, options):
+def _unpack_map(code, fp, options, depth=None):
     if (ord(code) & 0xf0) == 0x80:
         length = (ord(code) & ~0xf0)
     elif code == b'\xde':
@@ -909,7 +909,8 @@ def _unpack_map(code, fp, options):
     d = {} if not options.get('use_ordered_dict') else collections.OrderedDict()
     for _ in xrange(length):
         # Unpack key
-        k = _unpack(fp, options)
+        k = _unpack(fp, options) if depth is None \
+            else _unpack_depth(fp, options, depth)
 
         if isinstance(k, list):
             # Attempt to convert list into a hashable tuple
@@ -922,7 +923,8 @@ def _unpack_map(code, fp, options):
                 "encountered duplicate key: \"{:s}\" ({:s})".format(str(k), str(type(k))))
 
         # Unpack value
-        v = _unpack(fp, options)
+        v = _unpack(fp, options) if depth is None \
+            else _unpack_depth(fp, options, depth)
 
         try:
             d[k] = v
@@ -936,6 +938,33 @@ def _unpack(fp, options):
     code = _read_except(fp, 1)
     return _unpack_dispatch_table[code](code, fp, options)
 
+
+def _unpack_depth(fp, options, depth):
+    code = _read_except(fp, 1)
+    return _unpack_depth_dispatch_table[code](code, fp, options, depth)
+
+
+def _limit_depth(unpack_container):
+    """Wrap a depth-aware container unpacker to enforce options['max_depth'].
+
+    depth is passed as a local argument and incremented on entry.
+    """
+    @functools.wraps(unpack_container)
+    def wrapper(code, fp, options, depth):
+        depth += 1
+        if depth > options['max_depth']:
+            raise MaximumDepthException("maximum nesting depth exceeded")
+        return unpack_container(code, fp, options, depth)
+    return wrapper
+
+
+def _ignore_depth(unpacker):
+    """Adapt a scalar (non-container) unpacker to the depth dispatch signature."""
+    @functools.wraps(unpacker)
+    def wrapper(code, fp, options, depth):
+        return unpacker(code, fp, options)
+    return wrapper
+
 ########################################
 
 
@@ -946,20 +975,24 @@ def _unpack2(fp, **options):
     Args:
         fp: a .read()-supporting file-like object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext
                              type to a callable that unpacks an instance of
                              Ext into an object
-        use_ordered_dict (bool): unpack maps into OrderedDict, instead of
-                                 unordered dict (default False)
+        use_ordered_dict (bool): unpack maps into OrderedDict, instead of dict
+                                 (default False)
         use_tuple (bool): unpacks arrays into tuples, instead of lists (default
                           False)
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
-                                   InvalidString, for access to the bytes
-                                   (default False)
+                                   :class:`InvalidString`, for access to the
+                                   bytes (default False)
+        max_depth (int): maximum nesting depth of arrays/maps to unpack; when
+                         exceeded, :class:`MaximumDepthException` is raised. If
+                         None (default), depth is bounded only by the
+                         interpreter's recursion limit.
 
     Returns:
-        A Python object.
+        Python object
 
     Raises:
         InsufficientDataException(UnpackException):
@@ -975,14 +1008,23 @@ def _unpack2(fp, **options):
             The serialized map cannot be deserialized into a Python dictionary.
         DuplicateKeyException(UnpackException):
             Duplicate key encountered during map unpacking.
+        MaximumDepthException(UnpackException):
+            Maximum nesting depth exceeded while unpacking a deeply-nested
+            object, or the configured limit was exceeded (when ``max_depth`` is
+            set).
 
     Example:
-    >>> f = open('test.bin', 'rb')
-    >>> umsgpack.unpackb(f)
-    {u'compact': True, u'schema': 0}
-    >>>
+        >>> f = open('test.bin', 'rb')
+        >>> umsgpack.unpack(f)
+        {u'compact': True, u'schema': 0}
     """
-    return _unpack(fp, options)
+    try:
+        return _unpack(fp, options) if options.get('max_depth') is None \
+            else _unpack_depth(fp, options, 0)
+    except RuntimeError as e:
+        if "maximum recursion depth" in str(e):
+            raise MaximumDepthException("maximum nesting depth exceeded")
+        raise
 
 
 def _unpack3(fp, **options):
@@ -992,20 +1034,24 @@ def _unpack3(fp, **options):
     Args:
         fp: a .read()-supporting file-like object
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext
                              type to a callable that unpacks an instance of
                              Ext into an object
-        use_ordered_dict (bool): unpack maps into OrderedDict, instead of
-                                 unordered dict (default False)
+        use_ordered_dict (bool): unpack maps into OrderedDict, instead of dict
+                                 (default False)
         use_tuple (bool): unpacks arrays into tuples, instead of lists (default
                           False)
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
-                                   InvalidString, for access to the bytes
-                                   (default False)
+                                   :class:`InvalidString`, for access to the
+                                   bytes (default False)
+        max_depth (int): maximum nesting depth of arrays/maps to unpack; when
+                         exceeded, :class:`MaximumDepthException` is raised. If
+                         None (default), depth is bounded only by the
+                         interpreter's recursion limit.
 
     Returns:
-        A Python object.
+        Python object
 
     Raises:
         InsufficientDataException(UnpackException):
@@ -1021,14 +1067,21 @@ def _unpack3(fp, **options):
             The serialized map cannot be deserialized into a Python dictionary.
         DuplicateKeyException(UnpackException):
             Duplicate key encountered during map unpacking.
+        MaximumDepthException(UnpackException):
+            Maximum nesting depth exceeded while unpacking a deeply-nested
+            object, or the configured limit was exceeded (when ``max_depth`` is
+            set).
 
     Example:
-    >>> f = open('test.bin', 'rb')
-    >>> umsgpack.unpackb(f)
-    {'compact': True, 'schema': 0}
-    >>>
+        >>> f = open('test.bin', 'rb')
+        >>> umsgpack.unpack(f)
+        {'compact': True, 'schema': 0}
     """
-    return _unpack(fp, options)
+    try:
+        return _unpack(fp, options) if options.get('max_depth') is None \
+            else _unpack_depth(fp, options, 0)
+    except RecursionError:
+        raise MaximumDepthException("maximum nesting depth exceeded")
 
 
 # For Python 2, expects a str object
@@ -1037,22 +1090,26 @@ def _unpackb2(s, **options):
     Deserialize MessagePack bytes into a Python object.
 
     Args:
-        s: a 'str' or 'bytearray' containing serialized MessagePack bytes
+        s (str, bytearray): serialized MessagePack bytes
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext
                              type to a callable that unpacks an instance of
                              Ext into an object
-        use_ordered_dict (bool): unpack maps into OrderedDict, instead of
-                                 unordered dict (default False)
+        use_ordered_dict (bool): unpack maps into OrderedDict, instead of dict
+                                 (default False)
         use_tuple (bool): unpacks arrays into tuples, instead of lists (default
                           False)
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
-                                   InvalidString, for access to the bytes
-                                   (default False)
+                                   :class:`InvalidString`, for access to the
+                                   bytes (default False)
+        max_depth (int): maximum nesting depth of arrays/maps to unpack; when
+                         exceeded, :class:`MaximumDepthException` is raised. If
+                         None (default), depth is bounded only by the
+                         interpreter's recursion limit.
 
     Returns:
-        A Python object.
+        Python object
 
     Raises:
         TypeError:
@@ -1070,15 +1127,24 @@ def _unpackb2(s, **options):
             The serialized map cannot be deserialized into a Python dictionary.
         DuplicateKeyException(UnpackException):
             Duplicate key encountered during map unpacking.
+        MaximumDepthException(UnpackException):
+            Maximum nesting depth exceeded while unpacking a deeply-nested
+            object, or the configured limit was exceeded (when ``max_depth`` is
+            set).
 
     Example:
-    >>> umsgpack.unpackb(b'\x82\xa7compact\xc3\xa6schema\x00')
-    {u'compact': True, u'schema': 0}
-    >>>
+        >>> umsgpack.unpackb(b'\\x82\\xa7compact\\xc3\\xa6schema\\x00')
+        {u'compact': True, u'schema': 0}
     """
     if not isinstance(s, (str, bytearray)):
         raise TypeError("packed data must be type 'str' or 'bytearray'")
-    return _unpack(io.BytesIO(s), options)
+    try:
+        return _unpack(io.BytesIO(s), options) if options.get('max_depth') is None \
+            else _unpack_depth(io.BytesIO(s), options, 0)
+    except RuntimeError as e:
+        if "maximum recursion depth" in str(e):
+            raise MaximumDepthException("maximum nesting depth exceeded")
+        raise
 
 
 # For Python 3, expects a bytes object
@@ -1087,22 +1153,26 @@ def _unpackb3(s, **options):
     Deserialize MessagePack bytes into a Python object.
 
     Args:
-        s: a 'bytes' or 'bytearray' containing serialized MessagePack bytes
+        s (bytes, bytearray): serialized MessagePack bytes
 
-    Kwargs:
+    Keyword Args:
         ext_handlers (dict): dictionary of Ext handlers, mapping integer Ext
                              type to a callable that unpacks an instance of
                              Ext into an object
-        use_ordered_dict (bool): unpack maps into OrderedDict, instead of
-                                 unordered dict (default False)
+        use_ordered_dict (bool): unpack maps into OrderedDict, instead of dict
+                                 (default False)
         use_tuple (bool): unpacks arrays into tuples, instead of lists (default
                           False)
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
-                                   InvalidString, for access to the bytes
-                                   (default False)
+                                   :class:`InvalidString`, for access to the
+                                   bytes (default False)
+        max_depth (int): maximum nesting depth of arrays/maps to unpack; when
+                         exceeded, :class:`MaximumDepthException` is raised. If
+                         None (default), depth is bounded only by the
+                         interpreter's recursion limit.
 
     Returns:
-        A Python object.
+        Python object
 
     Raises:
         TypeError:
@@ -1120,15 +1190,22 @@ def _unpackb3(s, **options):
             The serialized map cannot be deserialized into a Python dictionary.
         DuplicateKeyException(UnpackException):
             Duplicate key encountered during map unpacking.
+        MaximumDepthException(UnpackException):
+            Maximum nesting depth exceeded while unpacking a deeply-nested
+            object, or the configured limit was exceeded (when ``max_depth`` is
+            set).
 
     Example:
-    >>> umsgpack.unpackb(b'\x82\xa7compact\xc3\xa6schema\x00')
-    {'compact': True, 'schema': 0}
-    >>>
+        >>> umsgpack.unpackb(b'\\x82\\xa7compact\\xc3\\xa6schema\\x00')
+        {'compact': True, 'schema': 0}
     """
     if not isinstance(s, (bytes, bytearray)):
         raise TypeError("packed data must be type 'bytes' or 'bytearray'")
-    return _unpack(io.BytesIO(s), options)
+    try:
+        return _unpack(io.BytesIO(s), options) if options.get('max_depth') is None \
+            else _unpack_depth(io.BytesIO(s), options, 0)
+    except RecursionError:
+        raise MaximumDepthException("maximum nesting depth exceeded")
 
 #############################################################################
 # Module Initialization
@@ -1204,7 +1281,7 @@ def __init():
     # Build a dispatch table for fast lookup of unpacking function
 
     _unpack_dispatch_table = {}
-    # Fix uint
+    # Positive fixint
     for code in range(0, 0x7f + 1):
         _unpack_dispatch_table[struct.pack("B", code)] = _unpack_integer
     # Fix map
@@ -1254,5 +1331,17 @@ def __init():
     for code in range(0xe0, 0xff + 1):
         _unpack_dispatch_table[struct.pack("B", code)] = _unpack_integer
 
+    # Parallel dispatch table for the optional max_depth path. The array/map
+    # entries are the same container functions as the default table, wrapped by
+    # _limit_depth; scalar unpackers are adapted to accept (and ignore) the
+    # depth argument so _unpack() can dispatch uniformly with no per-code switch.
+    global _unpack_depth_dispatch_table
+    _unpack_depth_dispatch_table = {}
+    for code_bytes, unpacker in _unpack_dispatch_table.items():
+        if unpacker is _unpack_array or unpacker is _unpack_map:
+            _unpack_depth_dispatch_table[code_bytes] = _limit_depth(unpacker)
+        else:
+            _unpack_depth_dispatch_table[code_bytes] = _ignore_depth(unpacker)
+
 
 __init()

umsgpack/__init__.pyi

@@ -0,0 +1,126 @@
+from typing import Any, Callable, Protocol, TypeVar
+
+_T = TypeVar("_T")
+
+__version__: str
+
+version: tuple[int, int, int]
+
+
+def pack(
+    obj: Any,
+    fp: _SupportsWrite,
+    *,
+    ext_handlers: dict[type[Any], Callable[[Any], Ext]] | None = None,
+    force_float_precision: str = ...,
+) -> None: ...
+
+
+def packb(
+    obj: Any,
+    *,
+    ext_handlers: dict[type[Any], Callable[[Any], Ext]] | None = None,
+    force_float_precision: str = ...,
+) -> bytes: ...
+
+
+def dump(
+    obj: Any,
+    fp: _SupportsWrite,
+    *,
+    ext_handlers: dict[type[Any], Callable[[Any], Ext]] | None = None,
+    force_float_precision: str = ...,
+) -> None: ...
+
+
+def dumps(
+    obj: Any,
+    *,
+    ext_handlers: dict[type[Any], Callable[[Any], Ext]] | None = None,
+    force_float_precision: str = ...,
+) -> bytes: ...
+
+
+def unpackb(
+    s: bytes | bytearray | memoryview,
+    *,
+    ext_handlers: dict[int, Callable[[Ext], Any]] | None = None,
+    use_ordered_dict: bool = False,
+    use_tuple: bool = False,
+    allow_invalid_utf8: bool = False,
+    max_depth: int | None = None,
+) -> Any: ...
+
+
+def unpack(
+    fp: _SupportsRead,
+    *,
+    ext_handlers: dict[int, Callable[[Ext], Any]] | None = None,
+    use_ordered_dict: bool = False,
+    use_tuple: bool = False,
+    allow_invalid_utf8: bool = False,
+    max_depth: int | None = None,
+) -> Any: ...
+
+
+def loads(
+    s: bytes | bytearray | memoryview,
+    *,
+    ext_handlers: dict[int, Callable[[Ext], Any]] | None = None,
+    use_ordered_dict: bool = False,
+    use_tuple: bool = False,
+    allow_invalid_utf8: bool = False,
+    max_depth: int | None = None,
+) -> Any: ...
+
+
+def load(
+    fp: _SupportsRead,
+    *,
+    ext_handlers: dict[int, Callable[[Ext], Any]] | None = None,
+    use_ordered_dict: bool = False,
+    use_tuple: bool = False,
+    allow_invalid_utf8: bool = False,
+    max_depth: int | None = None,
+) -> Any: ...
+
+
+class _SupportsRead(Protocol):
+    def read(self, __size: int) -> bytes: ...
+
+
+class _SupportsWrite(Protocol):
+    def write(self, __data: bytes) -> Any: ...
+
+
+class Ext:
+    type: int
+    data: bytes
+    def __init__(self, type: int, data: bytes) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+
+class InvalidString(bytes): ...
+
+
+def ext_serializable(ext_type: int) -> Callable[[type[_T]], type[_T]]: ...
+
+
+class PackException(Exception): ...
+class UnpackException(Exception): ...
+class UnsupportedTypeException(PackException): ...
+class InsufficientDataException(UnpackException): ...
+class InvalidStringException(UnpackException): ...
+class UnsupportedTimestampException(UnpackException): ...
+class ReservedCodeException(UnpackException): ...
+class UnhashableKeyException(UnpackException): ...
+class DuplicateKeyException(UnpackException): ...
+class MaximumDepthException(UnpackException): ...
+
+
+KeyNotPrimitiveException = UnhashableKeyException
+KeyDuplicateException = DuplicateKeyException
+
+compatibility: bool

u_msgpack_python-2.7.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-umsgpack.py,sha256=VWgh4SBZWK060TEiMp4WJeHMv3gzhDYnr7swCxkGlLM,43450
-u_msgpack_python-2.7.2.dist-info/LICENSE,sha256=-Tj-LTt7MpAF1LKFHxBv1DUcpV8INjNay-UjhjEvfzE,1099
-u_msgpack_python-2.7.2.dist-info/METADATA,sha256=tdNeKjl9_s0IV_nhLk1rddYv51B6LPp5kxrv1cxcm9g,1306
-u_msgpack_python-2.7.2.dist-info/WHEEL,sha256=i6ErtKpGt3EuCna4OpOTBhgJrMWAh_eDBLj9VXrKHUE,110
-u_msgpack_python-2.7.2.dist-info/top_level.txt,sha256=vlKYkefVvMYiE2tS8E4NKGRXIGIWzQq9ar1A0j2avaA,9
-u_msgpack_python-2.7.2.dist-info/RECORD,,