u-msgpack-python 2.8.0__tar.gz → 2.9.0__tar.gz

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/LICENSE

@@ -1,4 +1,4 @@
- Copyright (c) 2013-2023 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

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: u-msgpack-python
-Version: 2.8.0
+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.8.0 → u_msgpack_python-2.9.0}/README.md

@@ -1,6 +1,6 @@
-# u-msgpack-python [![Tests Status](https://github.com/vsergeev/u-msgpack-python/actions/workflows/tests.yml/badge.svg)](https://github.com/vsergeev/u-msgpack-python/actions/workflows/tests.yml) [![Docs Status](https://readthedocs.org/projects/u-msgpack-python/badge/)](https://u-msgpack-python.readthedocs.io/en/latest/) [![GitHub release](https://img.shields.io/github/release/vsergeev/u-msgpack-python.svg?maxAge=7200)](https://github.com/vsergeev/u-msgpack-python) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/vsergeev/u-msgpack-python/blob/master/LICENSE)
+# u-msgpack-python [![Tests Status](https://github.com/vsergeev/u-msgpack-python/actions/workflows/tests.yml/badge.svg)](https://github.com/vsergeev/u-msgpack-python/actions/workflows/tests.yml) [![Docs Status](https://app.readthedocs.org/projects/u-msgpack-python/badge/)](https://u-msgpack-python.readthedocs.io/en/latest/) [![GitHub release](https://img.shields.io/github/release/vsergeev/u-msgpack-python.svg?maxAge=7200)](https://github.com/vsergeev/u-msgpack-python) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/vsergeev/u-msgpack-python/blob/master/LICENSE)
 
-u-msgpack-python is a lightweight [MessagePack](http://msgpack.org/) serializer and deserializer module written in pure Python, compatible with Python 2 and 3, as well 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.
+u-msgpack-python is a lightweight [MessagePack](http://msgpack.org/) serializer and deserializer module written in pure Python, compatible with Python 2 and 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.
 
 u-msgpack-python is currently distributed as a package on [PyPI](https://pypi.python.org/pypi/u-msgpack-python) and as a single file module.
 
@@ -11,11 +11,6 @@ With pip:
 $ pip install u-msgpack-python
 ```
 
-With easy_install:
-``` text
-$ easy_install u-msgpack-python
-```
-
 or simply drop `umsgpack.py` into your project!
 ``` text
 $ wget https://raw.github.com/vsergeev/u-msgpack-python/master/umsgpack/__init__.py -O umsgpack.py

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/setup.cfg

@@ -1,6 +1,3 @@
-[metadata]
-description_file = README.md
-
 [bdist_wheel]
 universal = True
 

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/setup.py

@@ -5,14 +5,15 @@ except ImportError:
 
 setup(
     name='u-msgpack-python',
-    version='2.8.0',
+    version='2.9.0',
     description='A portable, lightweight MessagePack serializer and deserializer written in pure Python.',
     author='vsergeev',
     author_email='v@sergeev.io',
     url='https://github.com/vsergeev/u-msgpack-python',
     packages=['umsgpack'],
     package_data={'umsgpack': ['*.pyi', 'py.typed']},
-    long_description="""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.""",
+    long_description="""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.""",
+    long_description_content_type='text/x-rst',
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "License :: OSI Approved :: MIT License",

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/test_umsgpack.py

@@ -381,6 +381,7 @@ exported_vars_test_vector = [
     "ReservedCodeException",
     "UnhashableKeyException",
     "DuplicateKeyException",
+    "MaximumDepthException",
     "KeyNotPrimitiveException",
     "KeyDuplicateException",
     "ext_serializable",
@@ -438,9 +439,9 @@ class TestUmsgpack(unittest.TestCase):
             # one we end up with depends on the architecture (32-bit/64-bit)
             if sys.version_info[0] == 2:
                 # Allow both {int,long} -> unpackb -> {int,long}
-                if isinstance(obj, int) or isinstance(obj, long):
+                if isinstance(obj, int) or isinstance(obj, long):  # noqa: F821
                     self.assertTrue(isinstance(unpacked, int) or
-                                    isinstance(unpacked, long))
+                                    isinstance(unpacked, long))  # noqa: F821
                 else:
                     self.assertTrue(isinstance(unpacked, type(obj)))
             # In Python3, we only have the int integer type
@@ -490,7 +491,7 @@ class TestUmsgpack(unittest.TestCase):
             # so convert any string obj to bytes before comparison
             if sys.version_info[0] == 3 and isinstance(obj, str):
                 _obj = obj.encode('utf-8')
-            elif sys.version_info[0] == 2 and isinstance(obj, unicode):
+            elif sys.version_info[0] == 2 and isinstance(obj, unicode):  # noqa: F821
                 _obj = bytes(obj)
             else:
                 _obj = obj
@@ -712,11 +713,6 @@ class TestUmsgpack(unittest.TestCase):
         with self.assertRaises(NotImplementedError):
             umsgpack.unpackb(b"\xd4\x21\x00")
 
-        # Unregister Ext serializable classes to prevent interference with
-        # subsequent tests
-        umsgpack._ext_classes_to_code = {}
-        umsgpack._ext_code_to_classes = {}
-
     def test_ext_serializable_subclass(self):
         @umsgpack.ext_serializable(0x10)
         class Rectangle:
@@ -746,17 +742,12 @@ class TestUmsgpack(unittest.TestCase):
         unpacked = umsgpack.unpackb(packed)
         self.assertEqual(unpacked, Rectangle(5, 5))
 
-        # Unregister Ext serializable classes to prevent interference with
-        # subsequent tests
-        umsgpack._ext_classes_to_code = {}
-        umsgpack._ext_code_to_classes = {}
-
     def test_streaming_writer(self):
         # Try first composite test vector
         (_, obj, data) = composite_test_vectors[0]
         writer = io.BytesIO()
         umsgpack.pack(obj, writer)
-        self.assertTrue(writer.getvalue(), data)
+        self.assertEqual(writer.getvalue(), data)
 
     def test_streaming_reader(self):
         # Try first composite test vector
@@ -764,12 +755,34 @@ class TestUmsgpack(unittest.TestCase):
         reader = io.BytesIO(data)
         self.assertEqual(umsgpack.unpack(reader), obj)
 
+    def test_max_depth_default_wraps_recursion(self):
+        # Default (no max_depth): deeply nested input must raise a
+        # MaximumDepthException (an UnpackException), not a bare RecursionError.
+        payload = b"\x91" * 5000 + b"\xc0"
+        self.assertRaises(umsgpack.MaximumDepthException, umsgpack.unpackb, payload)
+        self.assertRaises(umsgpack.UnpackException, umsgpack.unpackb, payload)
+        # Moderate nesting still works.
+        self.assertEqual(umsgpack.unpackb(b"\x91" * 100 + b"\xc0"),
+                         umsgpack.unpackb(b"\x91" * 100 + b"\xc0"))
+
+    def test_max_depth_cap_arrays_and_maps(self):
+        self.assertTrue(
+            umsgpack.unpackb(b"\x91" * 32 + b"\xc0", max_depth=32) is not None)
+        self.assertRaises(umsgpack.MaximumDepthException,
+                          umsgpack.unpackb, b"\x91" * 33 + b"\xc0", max_depth=32)
+        self.assertRaises(umsgpack.MaximumDepthException,
+                          umsgpack.unpackb, b"\x81\xa1k" * 17 + b"\xc0", max_depth=16)
+        # Siblings are not counted, only nesting depth.
+        self.assertEqual(
+            len(umsgpack.unpackb(b"\xdc\x00\xc8" + b"\xc0" * 200, max_depth=1)), 200)
+
     def test_namespacing(self):
         # Get a list of global variables from umsgpack module
         exported_vars = list([x for x in dir(umsgpack) if not x.startswith("_")])
         # Ignore imports
-        exported_vars = list([x for x in exported_vars if x != "struct" and x != "collections" and x != "datetime" and x !=
-                                    "sys" and x != "io" and x != "xrange" and x != "Hashable"])
+        ignore_vars = ["struct", "collections", "datetime", "sys", "io",
+                       "xrange", "Hashable", "functools"]
+        exported_vars = [x for x in exported_vars if x not in ignore_vars]
 
         self.assertTrue(len(exported_vars) == len(exported_vars_test_vector))
         for var in exported_vars_test_vector:

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/u_msgpack_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: u-msgpack-python
-Version: 2.8.0
+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.8.0 → u_msgpack_python-2.9.0}/u_msgpack_python.egg-info/SOURCES.txt

@@ -9,4 +9,5 @@ u_msgpack_python.egg-info/SOURCES.txt
 u_msgpack_python.egg-info/dependency_links.txt
 u_msgpack_python.egg-info/top_level.txt
 umsgpack/__init__.py
-umsgpack/__init__.pyi
+umsgpack/__init__.pyi
+umsgpack/py.typed

{u-msgpack-python-2.8.0 → u_msgpack_python-2.9.0}/umsgpack/__init__.py

@@ -1,16 +1,17 @@
-# u-msgpack-python v2.8.0 - 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-2023 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.8.0 - 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.8.0"
+
+__version__ = "2.9.0"
 "Module version string"
 
-version = (2, 8, 0)
+version = (2, 9, 0)
 "Module version tuple"
 
 
@@ -91,10 +95,10 @@ class Ext(object):
         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'
+            b'\\x82\\xadspecial stuff\\xc7\\x03\\x05\\x01\\x02\\x03\\xa7awesome\\xc3'
             >>> bar = umsgpack.unpackb(_)
             >>> print(bar["special stuff"])
-            Ext Object (Type: 5, Data: 01 02 03)
+            Ext Object (Type: 5, Data: 0x01 0x02 0x03)
         """
         # Check type is type int and in range
         if not isinstance(type, int):
@@ -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
@@ -442,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)
@@ -480,8 +488,6 @@ def _pack2(obj, fp, **options):
         >>> 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:
@@ -566,8 +572,6 @@ def _pack3(obj, fp, **options):
         >>> 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:
@@ -777,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)
 
@@ -868,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':
@@ -879,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):
@@ -890,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':
@@ -903,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
@@ -916,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
@@ -930,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
+
 ########################################
 
 
@@ -951,6 +986,10 @@ def _unpack2(fp, **options):
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
                                    :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:
         Python object
@@ -969,13 +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)
+        >>> 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):
@@ -996,6 +1045,10 @@ def _unpack3(fp, **options):
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
                                    :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:
         Python object
@@ -1014,13 +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)
+        >>> 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
@@ -1042,6 +1103,10 @@ def _unpackb2(s, **options):
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
                                    :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:
         Python object
@@ -1062,6 +1127,10 @@ 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')
@@ -1069,7 +1138,13 @@ def _unpackb2(s, **options):
     """
     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
@@ -1091,6 +1166,10 @@ def _unpackb3(s, **options):
         allow_invalid_utf8 (bool): unpack invalid strings into instances of
                                    :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:
         Python object
@@ -1111,6 +1190,10 @@ 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')
@@ -1118,7 +1201,11 @@ def _unpackb3(s, **options):
     """
     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
@@ -1194,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
@@ -1244,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()

u_msgpack_python-2.9.0/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.8.0/umsgpack/__init__.pyi

@@ -1,41 +0,0 @@
-from typing import Any
-
-__version__: str
-
-version: tuple[int, int, int]
-
-def pack(obj, fp, **options) -> None: ...
-def packb(obj, **options) -> bytes: ...
-def dump(obj, fp, **options) -> None: ...
-def dumps(obj, **options) -> bytes: ...
-
-def unpackb(s: bytes | bytearray, **options) -> Any: ...
-def unpack(fp, **options) -> Any: ...
-def loads(s: bytes | bytearray, **options) -> Any: ...
-def load(fp, **options) -> Any: ...
-
-class Ext:
-    type: int
-    data: bytes
-    def __init__(self, type: int, data: bytes) -> None: ...
-    def __eq__(self, other) -> bool: ...
-    def __ne__(self, other) -> bool: ...
-    def __hash__(self) -> int: ...
-
-class InvalidString(bytes): ...
-
-def ext_serializable(ext_type: int): ...
-
-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): ...
-KeyNotPrimitiveException = UnhashableKeyException
-KeyDuplicateException = DuplicateKeyException
-
-compatibility: bool