fastbencode 0.1__tar.gz → 0.3.1__tar.gz

fastbencode-0.3.1/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: fastbencode
+Version: 0.3.1
+Summary: Implementation of bencode with optional fast C extensions
+Maintainer-email: Breezy Developers <breezy-core@googlegroups.com>
+License: GPLv2 or later
+Project-URL: Homepage, https://github.com/breezy-team/fastbencode
+Project-URL: GitHub, https://github.com/breezy-team/fastbencode
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: COPYING
+Provides-Extra: cext
+Requires-Dist: cython>=0.29; extra == "cext"
+Provides-Extra: dev
+Requires-Dist: ruff==0.4.3; extra == "dev"
+
+fastbencode
+===========
+
+fastbencode is an implementation of the bencode serialization format originally
+used by BitTorrent.
+
+The package includes both a pure-Python version and an optional C extension
+based on Cython.  Both provide the same functionality, but the C extension
+provides significantly better performance.
+
+Example:
+
+    >>> from fastbencode import bencode, bdecode
+    >>> bencode([1, 2, b'a', {b'd': 3}])
+    b'li1ei2e1:ad1:di3eee'
+    >>> bdecode(bencode([1, 2, b'a', {b'd': 3}]))
+    [1, 2, b'a', {b'd': 3}]
+
+The default ``bencode``/``bdecode`` functions just operate on
+bytestrings. Use ``bencode_utf8`` / ``bdecode_utf8`` to
+serialize/deserialize all plain strings as UTF-8 bytestrings.
+Note that for performance reasons, all dictionary keys still have to be
+bytestrings.
+
+License
+=======
+fastbencode is available under the GNU GPL, version 2 or later.
+
+Copyright
+=========
+
+* Original Pure-Python bencoder (c) Petru Paler
+* Cython version and modifications (c) Canonical Ltd
+* Split out from Bazaar/Breezy by Jelmer Vernooij

{fastbencode-0.1 → fastbencode-0.3.1}/README.md

@@ -16,6 +16,12 @@ Example:
     >>> bdecode(bencode([1, 2, b'a', {b'd': 3}]))
     [1, 2, b'a', {b'd': 3}]
 
+The default ``bencode``/``bdecode`` functions just operate on
+bytestrings. Use ``bencode_utf8`` / ``bdecode_utf8`` to
+serialize/deserialize all plain strings as UTF-8 bytestrings.
+Note that for performance reasons, all dictionary keys still have to be
+bytestrings.
+
 License
 =======
 fastbencode is available under the GNU GPL, version 2 or later.

{fastbencode-0.1 → fastbencode-0.3.1}/fastbencode/__init__.py

@@ -14,12 +14,11 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
-"""Wrapper around the bencode cython and python implementation"""
+"""Wrapper around the bencode cython and python implementation."""
 
 from typing import Type
 
-
-__version__ = (0, 1)
+__version__ = (0, 3, 1)
 
 
 _extension_load_failures = []
@@ -50,7 +49,7 @@ def failed_to_load_extension(exception):
     if exception_str not in _extension_load_failures:
         import warnings
         warnings.warn(
-            'failed to load compiled extension: %s' % exception_str,
+            f'failed to load compiled extension: {exception_str}',
             UserWarning)
         _extension_load_failures.append(exception_str)
 
@@ -58,12 +57,12 @@ def failed_to_load_extension(exception):
 Bencached: Type
 
 try:
-    from ._bencode_pyx import bdecode, bdecode_as_tuple, bencode, Bencached
+    from ._bencode_pyx import Bencached, bdecode, bdecode_as_tuple, bencode
 except ImportError as e:
     failed_to_load_extension(e)
     from ._bencode_py import (  # noqa: F401
+        Bencached,
         bdecode,
         bdecode_as_tuple,
         bencode,
-        Bencached,
-        )
+    )

fastbencode-0.3.1/fastbencode/_bencode_py.py

@@ -0,0 +1,186 @@
+# bencode structured encoding
+#
+# Written by Petru Paler
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# Modifications copyright (C) 2008 Canonical Ltd
+
+
+from typing import Callable, Dict, List, Type
+
+
+class BDecoder:
+
+    def __init__(self, yield_tuples=False, bytestring_encoding=None) -> None:
+        """Constructor.
+
+        :param yield_tuples: if true, decode "l" elements as tuples rather than
+            lists.
+        """
+        self.yield_tuples = yield_tuples
+        self.bytestring_encoding = bytestring_encoding
+        decode_func = {}
+        decode_func[b'l'] = self.decode_list
+        decode_func[b'd'] = self.decode_dict
+        decode_func[b'i'] = self.decode_int
+        decode_func[b'0'] = self.decode_bytes
+        decode_func[b'1'] = self.decode_bytes
+        decode_func[b'2'] = self.decode_bytes
+        decode_func[b'3'] = self.decode_bytes
+        decode_func[b'4'] = self.decode_bytes
+        decode_func[b'5'] = self.decode_bytes
+        decode_func[b'6'] = self.decode_bytes
+        decode_func[b'7'] = self.decode_bytes
+        decode_func[b'8'] = self.decode_bytes
+        decode_func[b'9'] = self.decode_bytes
+        self.decode_func = decode_func
+
+    def decode_int(self, x, f):
+        f += 1
+        newf = x.index(b'e', f)
+        n = int(x[f:newf])
+        if x[f:f + 2] == b'-0':
+            raise ValueError
+        elif x[f:f + 1] == b'0' and newf != f + 1:
+            raise ValueError
+        return (n, newf + 1)
+
+    def decode_bytes(self, x, f):
+        colon = x.index(b':', f)
+        n = int(x[f:colon])
+        if x[f:f + 1] == b'0' and colon != f + 1:
+            raise ValueError
+        colon += 1
+        d = x[colon:colon + n]
+        if self.bytestring_encoding:
+            d = d.decode(self.bytestring_encoding)
+        return (d, colon + n)
+
+    def decode_list(self, x, f):
+        r, f = [], f + 1
+        while x[f:f + 1] != b'e':
+            v, f = self.decode_func[x[f:f + 1]](x, f)
+            r.append(v)
+        if self.yield_tuples:
+            r = tuple(r)
+        return (r, f + 1)
+
+    def decode_dict(self, x, f):
+        r, f = {}, f + 1
+        lastkey = None
+        while x[f:f + 1] != b'e':
+            k, f = self.decode_bytes(x, f)
+            if lastkey is not None and lastkey >= k:
+                raise ValueError
+            lastkey = k
+            r[k], f = self.decode_func[x[f:f + 1]](x, f)
+        return (r, f + 1)
+
+    def bdecode(self, x):
+        if not isinstance(x, bytes):
+            raise TypeError
+        try:
+            r, l = self.decode_func[x[:1]](x, 0)  # noqa: E741
+        except (IndexError, KeyError, OverflowError) as e:
+            raise ValueError(str(e))
+        if l != len(x):  # noqa: E741
+            raise ValueError
+        return r
+
+
+_decoder = BDecoder()
+bdecode = _decoder.bdecode
+
+_tuple_decoder = BDecoder(True)
+bdecode_as_tuple = _tuple_decoder.bdecode
+
+_utf8_decoder = BDecoder(bytestring_encoding='utf-8')
+bdecode_utf8 = _utf8_decoder.bdecode
+
+
+class Bencached:
+    __slots__ = ['bencoded']
+
+    def __init__(self, s) -> None:
+        self.bencoded = s
+
+
+class BEncoder:
+
+    def __init__(self, bytestring_encoding=None):
+        self.bytestring_encoding = bytestring_encoding
+        self.encode_func: Dict[Type, Callable[[object, List[bytes]], None]] = {
+            Bencached: self.encode_bencached,
+            int: self.encode_int,
+            bytes: self.encode_bytes,
+            list: self.encode_list,
+            tuple: self.encode_list,
+            dict: self.encode_dict,
+            bool: self.encode_bool,
+            str: self.encode_str,
+        }
+
+    def encode_bencached(self, x, r):
+        r.append(x.bencoded)
+
+
+    def encode_bool(self, x, r):
+        self.encode_int(int(x), r)
+
+
+    def encode_int(self, x, r):
+        r.extend((b'i', int_to_bytes(x), b'e'))
+
+
+    def encode_bytes(self, x, r):
+        r.extend((int_to_bytes(len(x)), b':', x))
+
+    def encode_list(self, x, r):
+        r.append(b'l')
+        for i in x:
+            self.encode(i, r)
+        r.append(b'e')
+
+
+    def encode_dict(self, x, r):
+        r.append(b'd')
+        ilist = sorted(x.items())
+        for k, v in ilist:
+            r.extend((int_to_bytes(len(k)), b':', k))
+            self.encode(v, r)
+        r.append(b'e')
+
+    def encode_str(self, x, r):
+        if self.bytestring_encoding is None:
+            raise TypeError("string found but no encoding specified. "
+                            "Use bencode_utf8 rather bencode?")
+        return self.encode_bytes(x.encode(self.bytestring_encoding), r)
+
+    def encode(self, x, r):
+        self.encode_func[type(x)](x, r)
+
+
+def int_to_bytes(n):
+    return b'%d' % n
+
+def bencode(x):
+    r = []
+    encoder = BEncoder()
+    encoder.encode(x, r)
+    return b''.join(r)
+
+def bencode_utf8(x):
+    r = []
+    encoder = BEncoder(bytestring_encoding='utf-8')
+    encoder.encode(x, r)
+    return b''.join(r)

{fastbencode-0.1 → fastbencode-0.3.1}/fastbencode/_bencode_pyx.pyi

@@ -4,4 +4,4 @@ def bdecode_as_tuple(bytes) -> object: ...
 def bencode(object) -> bytes: ...
 
 
-class Bencached(object): ...
+class Bencached: ...

{fastbencode-0.1 → fastbencode-0.3.1}/fastbencode/_bencode_pyx.pyx

@@ -46,15 +46,22 @@ from cpython.mem cimport (
     PyMem_Malloc,
     PyMem_Realloc,
     )
+from cpython.unicode cimport (
+    PyUnicode_FromEncodedObject,
+    PyUnicode_FromStringAndSize,
+    PyUnicode_Check,
+    )
 from cpython.tuple cimport (
     PyTuple_CheckExact,
     )
 
 from libc.stdlib cimport (
     strtol,
+    free,
     )
 from libc.string cimport (
     memcpy,
+    strdup,
     )
 
 cdef extern from "python-compat.h":
@@ -79,9 +86,10 @@ cdef class Decoder:
     cdef readonly char *tail
     cdef readonly int size
     cdef readonly int _yield_tuples
+    cdef readonly char *_bytestring_encoding
     cdef object text
 
-    def __init__(self, s, yield_tuples=0):
+    def __init__(self, s, yield_tuples=0, str bytestring_encoding=None):
         """Initialize decoder engine.
         @param  s:  Python string.
         """
@@ -92,6 +100,13 @@ cdef class Decoder:
         self.tail = PyBytes_AS_STRING(s)
         self.size = PyBytes_GET_SIZE(s)
         self._yield_tuples = int(yield_tuples)
+        if bytestring_encoding is None:
+            self._bytestring_encoding = NULL
+        else:
+            self._bytestring_encoding = strdup(bytestring_encoding.encode('utf-8'))
+
+    def __dealloc__(self):
+        free(self._bytestring_encoding)
 
     def decode(self):
         result = self._decode_object()
@@ -112,7 +127,7 @@ cdef class Decoder:
         try:
             ch = self.tail[0]
             if c'0' <= ch <= c'9':
-                return self._decode_string()
+                return self._decode_bytes()
             elif ch == c'l':
                 D_UPDATE_TAIL(self, 1)
                 return self._decode_list()
@@ -155,12 +170,12 @@ cdef class Decoder:
         D_UPDATE_TAIL(self, i+1)
         return ret
 
-    cdef object _decode_string(self):
+    cdef object _decode_bytes(self):
         cdef int n
         cdef char *next_tail
         # strtol allows leading whitespace, negatives, and leading zeros
         # however, all callers have already checked that '0' <= tail[0] <= '9'
-        # or they wouldn't have called _decode_string
+        # or they wouldn't have called _decode_bytes
         # strtol will stop at trailing whitespace, etc
         n = strtol(self.tail, &next_tail, 10)
         if next_tail == NULL or next_tail[0] != c':':
@@ -171,13 +186,22 @@ cdef class Decoder:
             raise ValueError('leading zeros are not allowed')
         D_UPDATE_TAIL(self, next_tail - self.tail + 1)
         if n == 0:
-            return b''
+            if self._bytestring_encoding == NULL:
+                return b''
+            else:
+                return ''
         if n > self.size:
             raise ValueError('stream underflow')
         if n < 0:
             raise ValueError('string size below zero: %d' % n)
 
-        result = PyBytes_FromStringAndSize(self.tail, n)
+        if self._bytestring_encoding == NULL:
+            result = PyBytes_FromStringAndSize(self.tail, n)
+        elif self._bytestring_encoding == b'utf-8':
+            result = PyUnicode_FromStringAndSize(self.tail, n)
+        else:
+            result = PyBytes_FromStringAndSize(self.tail, n)
+            result = PyUnicode_FromEncodedObject(result, self._bytestring_encoding, NULL)
         D_UPDATE_TAIL(self, n)
         return result
 
@@ -214,7 +238,7 @@ cdef class Decoder:
                 # keys should be strings only
                 if self.tail[0] < c'0' or self.tail[0] > c'9':
                     raise ValueError('key was not a simple string.')
-                key = self._decode_string()
+                key = self._decode_bytes()
                 if lastkey is not None and lastkey >= key:
                     raise ValueError('dict keys disordered')
                 else:
@@ -235,6 +259,11 @@ def bdecode_as_tuple(object s):
     return Decoder(s, True).decode()
 
 
+def bdecode_utf8(object s):
+    """Decode string x to Python object, decoding bytestrings as UTF8 strings."""
+    return Decoder(s, bytestring_encoding='utf-8').decode()
+
+
 class Bencached(object):
     __slots__ = ['bencoded']
 
@@ -254,8 +283,9 @@ cdef class Encoder:
     cdef readonly int size
     cdef readonly char *buffer
     cdef readonly int maxsize
+    cdef readonly object _bytestring_encoding
 
-    def __init__(self, int maxsize=INITSIZE):
+    def __init__(self, int maxsize=INITSIZE, str bytestring_encoding=None):
         """Initialize encoder engine
         @param  maxsize:    initial size of internal char buffer
         """
@@ -273,6 +303,8 @@ cdef class Encoder:
         self.maxsize = maxsize
         self.tail = p
 
+        self._bytestring_encoding = bytestring_encoding
+
     def __dealloc__(self):
         PyMem_Free(self.buffer)
         self.buffer = NULL
@@ -329,7 +361,7 @@ cdef class Encoder:
         E_UPDATE_TAIL(self, n)
         return 1
 
-    cdef int _encode_string(self, x) except 0:
+    cdef int _encode_bytes(self, x) except 0:
         cdef int n
         cdef Py_ssize_t x_len
         x_len = PyBytes_GET_SIZE(x)
@@ -341,6 +373,12 @@ cdef class Encoder:
         E_UPDATE_TAIL(self, n + x_len)
         return 1
 
+    cdef int _encode_string(self, x) except 0:
+        if self._bytestring_encoding is None:
+            raise TypeError("string found but no encoding specified. "
+                            "Use bencode_utf8 rather bencode?")
+        return self._encode_bytes(x.encode(self._bytestring_encoding))
+
     cdef int _encode_list(self, x) except 0:
         self._ensure_buffer(1)
         self.tail[0] = c'l'
@@ -362,7 +400,7 @@ cdef class Encoder:
         for k in sorted(x):
             if not PyBytes_CheckExact(k):
                 raise TypeError('key in dict should be string')
-            self._encode_string(k)
+            self._encode_bytes(k)
             self.process(x[k])
 
         self._ensure_buffer(1)
@@ -374,7 +412,7 @@ cdef class Encoder:
         BrzPy_EnterRecursiveCall(" while bencode encoding")
         try:
             if PyBytes_CheckExact(x):
-                self._encode_string(x)
+                self._encode_bytes(x)
             elif PyInt_CheckExact(x) and x.bit_length() < 32:
                 self._encode_int(x)
             elif PyLong_CheckExact(x):
@@ -385,6 +423,8 @@ cdef class Encoder:
                 self._encode_dict(x)
             elif PyBool_Check(x):
                 self._encode_int(int(x))
+            elif PyUnicode_Check(x):
+                self._encode_string(x)
             elif isinstance(x, Bencached):
                 self._append_string(x.bencoded)
             else:
@@ -394,7 +434,17 @@ cdef class Encoder:
 
 
 def bencode(x):
-    """Encode Python object x to string"""
+    """Encode Python object x to bytestring"""
     encoder = Encoder()
     encoder.process(x)
     return encoder.to_bytes()
+
+
+def bencode_utf8(x):
+    """Encode Python object x to bytestring.
+
+    Encode any strings as UTF8
+    """
+    encoder = Encoder(bytestring_encoding='utf-8')
+    encoder.process(x)
+    return encoder.to_bytes()

{fastbencode-0.1 → fastbencode-0.3.1}/fastbencode/tests/test_bencode.py

@@ -14,11 +14,10 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
-"""Tests for bencode structured encoding"""
+"""Tests for bencode structured encoding."""
 
 import copy
 import sys
-
 from unittest import TestCase, TestSuite
 
 
@@ -62,16 +61,14 @@ def get_named_object(module_name, member_name=None):
 
 
 def iter_suite_tests(suite):
-    """Return all tests in a suite, recursing through nested suites"""
+    """Return all tests in a suite, recursing through nested suites."""
     if isinstance(suite, TestCase):
         yield suite
     elif isinstance(suite, TestSuite):
         for item in suite:
-            for r in iter_suite_tests(item):
-                yield r
+            yield from iter_suite_tests(item)
     else:
-        raise Exception('unknown type %r for object %r'
-                        % (type(suite), suite))
+        raise Exception(f'unknown type {type(suite)!r} for object {suite!r}')
 
 
 def clone_test(test, new_id):
@@ -108,7 +105,7 @@ def apply_scenario(test, scenario):
         test.
     :return: The adapted test.
     """
-    new_id = "%s(%s)" % (test.id(), scenario[0])
+    new_id = f"{test.id()}({scenario[0]})"
     new_test = clone_test(test, new_id)
     for name, value in scenario[1].items():
         setattr(new_test, name, value)
@@ -189,7 +186,6 @@ def permute_tests_for_extension(standard_tests, loader, py_module_name,
         tests. feature is the Feature object that can be used to determine if
         the module is available.
     """
-
     py_module = get_named_object(py_module_name)
     scenarios = [
         ('python', {'module': py_module}),
@@ -211,10 +207,10 @@ def load_tests(loader, standard_tests, pattern):
         'fastbencode._bencode_pyx')
 
 
-class RecursionLimit(object):
+class RecursionLimit:
     """Context manager that lowers recursion limit for testing."""
 
-    def __init__(self, limit=100):
+    def __init__(self, limit=100) -> None:
         self._new_limit = limit
         self._old_limit = sys.getrecursionlimit()
 
@@ -291,10 +287,16 @@ class TestBencodeDecode(TestCase):
 
     def test_list_deepnested(self):
         import platform
-        if platform.python_implementation() == 'PyPy':
-            self.skipTest('recursion not an issue on pypy')
-        with RecursionLimit():
-            self._run_check_error(RuntimeError, (b"l" * 100) + (b"e" * 100))
+        if (platform.python_implementation() == 'PyPy'
+                or sys.version_info[:2] >= (3, 12)):
+            expected = []
+            for i in range(99):
+                expected = [expected]
+            self._check(expected, (b"l" * 100) + (b"e" * 100))
+        else:
+            with RecursionLimit():
+                self._run_check_error(
+                    RuntimeError, (b"l" * 100) + (b"e" * 100))
 
     def test_malformed_list(self):
         self._run_check_error(ValueError, b'l')
@@ -339,16 +341,57 @@ class TestBencodeDecode(TestCase):
         self.assertRaises(ValueError, self.module.bdecode, b'relwjhrlewjh')
 
     def test_unsupported_type(self):
-        self._run_check_error(TypeError, float(1.5))
+        self._run_check_error(TypeError, 1.5)
         self._run_check_error(TypeError, None)
         self._run_check_error(TypeError, lambda x: x)
         self._run_check_error(TypeError, object)
-        self._run_check_error(TypeError, u"ie")
+        self._run_check_error(TypeError, "ie")
 
     def test_decoder_type_error(self):
         self.assertRaises(TypeError, self.module.bdecode, 1)
 
 
+class TestBdecodeUtf8(TestCase):
+
+    module = None
+
+    def _check(self, expected, source):
+        self.assertEqual(expected, self.module.bdecode_utf8(source))
+
+    def _run_check_error(self, exc, bad):
+        """Check that bdecoding a string raises a particular exception."""
+        self.assertRaises(exc, self.module.bdecode_utf8, bad)
+
+    def test_string(self):
+        self._check('', b'0:')
+        self._check('aäc', b'4:a\xc3\xa4c')
+        self._check('1234567890', b'10:1234567890')
+
+    def test_large_string(self):
+        self.assertRaises(
+            ValueError, self.module.bdecode_utf8, b"2147483639:foo")
+
+    def test_malformed_string(self):
+        self._run_check_error(ValueError, b'10:x')
+        self._run_check_error(ValueError, b'10:')
+        self._run_check_error(ValueError, b'10')
+        self._run_check_error(ValueError, b'01:x')
+        self._run_check_error(ValueError, b'00:')
+        self._run_check_error(ValueError, b'35208734823ljdahflajhdf')
+        self._run_check_error(ValueError, b'432432432432432:foo')
+        self._run_check_error(ValueError, b' 1:x')  # leading whitespace
+        self._run_check_error(ValueError, b'-1:x')  # negative
+        self._run_check_error(ValueError, b'1 x')  # space vs colon
+        self._run_check_error(ValueError, b'1x')  # missing colon
+        self._run_check_error(ValueError, (b'1' * 1000) + b':')
+
+    def test_empty_string(self):
+        self.assertRaises(ValueError, self.module.bdecode_utf8, b'')
+
+    def test_invalid_utf8(self):
+        self._run_check_error(UnicodeDecodeError, b'3:\xff\xfe\xfd')
+
+
 class TestBencodeEncode(TestCase):
 
     module = None
@@ -412,3 +455,32 @@ class TestBencodeEncode(TestCase):
     def test_bool(self):
         self._check(b'i1e', True)
         self._check(b'i0e', False)
+
+
+class TestBencodeEncodeUtf8(TestCase):
+
+    module = None
+
+    def _check(self, expected, source):
+        self.assertEqual(expected, self.module.bencode_utf8(source))
+
+    def test_string(self):
+        self._check(b'0:', '')
+        self._check(b'3:abc', 'abc')
+        self._check(b'10:1234567890', '1234567890')
+
+    def test_list(self):
+        self._check(b'le', [])
+        self._check(b'li1ei2ei3ee', [1, 2, 3])
+        self._check(b'll5:Alice3:Bobeli2ei3eee', [['Alice', 'Bob'], [2, 3]])
+
+    def test_list_as_tuple(self):
+        self._check(b'le', ())
+        self._check(b'li1ei2ei3ee', (1, 2, 3))
+        self._check(b'll5:Alice3:Bobeli2ei3eee', (('Alice', 'Bob'), (2, 3)))
+
+    def test_dict(self):
+        self._check(b'de', {})
+        self._check(b'd3:agei25e4:eyes4:bluee', {b'age': 25, b'eyes': 'blue'})
+        self._check(b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee',
+                    {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})