fastbencode 0.2__tar.gz → 0.3.1__tar.gz

{fastbencode-0.2 → fastbencode-0.3.1}/PKG-INFO

@@ -1,24 +1,27 @@
 Metadata-Version: 2.1
 Name: fastbencode
-Version: 0.2
+Version: 0.3.1
 Summary: Implementation of bencode with optional fast C extensions
-Home-page: https://github.com/breezy-team/fastbencode
-Maintainer: Breezy Developers
-Maintainer-email: breezy-core@googlegroups.com
+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.7
 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.7
-Provides-Extra: cext
+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
 ===========
@@ -38,6 +41,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.2 → 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.2 → 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, 2)
+__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.2 → 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.2 → 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.2 → 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,15 +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:
             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):
@@ -107,7 +105,7 @@ def apply_scenario(test, scenario):
         test.
     :return: The adapted test.
     """
-    new_id = "{}({})".format(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)
@@ -188,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}),
@@ -213,7 +210,7 @@ def load_tests(loader, standard_tests, pattern):
 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()
 
@@ -290,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')
@@ -338,7 +341,7 @@ 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)
@@ -348,6 +351,47 @@ class TestBencodeDecode(TestCase):
         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
@@ -411,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}})

{fastbencode-0.2 → fastbencode-0.3.1}/fastbencode.egg-info/PKG-INFO

@@ -1,24 +1,27 @@
 Metadata-Version: 2.1
 Name: fastbencode
-Version: 0.2
+Version: 0.3.1
 Summary: Implementation of bencode with optional fast C extensions
-Home-page: https://github.com/breezy-team/fastbencode
-Maintainer: Breezy Developers
-Maintainer-email: breezy-core@googlegroups.com
+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.7
 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.7
-Provides-Extra: cext
+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
 ===========
@@ -38,6 +41,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.2 → fastbencode-0.3.1}/fastbencode.egg-info/SOURCES.txt

@@ -1,16 +1,8 @@
-.gitignore
-CODE_OF_CONDUCT.md
 COPYING
 MANIFEST.in
 README.md
-SECURITY.md
-disperse.conf
 pyproject.toml
-setup.cfg
 setup.py
-.github/workflows/disperse.yml
-.github/workflows/pythonpackage.yml
-.github/workflows/pythonpublish.yml
 fastbencode/__init__.py
 fastbencode/_bencode_py.py
 fastbencode/_bencode_pyx.h

{fastbencode-0.2 → fastbencode-0.3.1}/fastbencode.egg-info/requires.txt

@@ -1,3 +1,6 @@
 
 [cext]
 cython>=0.29
+
+[dev]
+ruff==0.4.3

fastbencode-0.3.1/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = [
+    "setuptools>=61.2",
+    "cython>=0.29",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastbencode"
+description = "Implementation of bencode with optional fast C extensions"
+maintainers = [{name = "Breezy Developers", email = "breezy-core@googlegroups.com"}]
+readme = "README.md"
+license = {text = "GPLv2 or later"}
+classifiers = [
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Operating System :: POSIX",
+    "Operating System :: Microsoft :: Windows",
+]
+requires-python = ">=3.8"
+dynamic = ["version"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/breezy-team/fastbencode"
+GitHub = "https://github.com/breezy-team/fastbencode"
+
+[project.optional-dependencies]
+cext = ["cython>=0.29"]
+dev = [
+    "ruff==0.4.3"
+]
+
+[tool.setuptools]
+packages = ["fastbencode"]
+include-package-data = false
+
+[tool.setuptools.dynamic]
+version = {attr = "fastbencode.__version__"}
+
+[tool.ruff]
+target-version = "py37"
+line-length = 79
+
+[tool.ruff.lint]
+select = [
+    "ANN",
+    "D",
+    "E",
+    "F",
+    "I",
+    "UP",
+]
+ignore = [
+    "ANN001",
+    "ANN002",
+    "ANN101",
+    "ANN201",
+    "ANN202",
+    "ANN204",
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D105",
+    "D107",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"

fastbencode-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{fastbencode-0.2 → fastbencode-0.3.1}/setup.py

@@ -2,15 +2,17 @@
 
 import os
 import sys
-from setuptools import setup, Extension
+
+from setuptools import Extension, setup
+
 try:
     from packaging.version import Version
 except ImportError:
     from distutils.version import LooseVersion as Version
 
 try:
-    from Cython.Distutils import build_ext
     from Cython.Compiler.Version import version as cython_version
+    from Cython.Distutils import build_ext
 except ImportError:
     have_cython = False
     # try to build the extension from the prior generated source.
@@ -26,8 +28,8 @@ else:
     cython_version_info = Version(cython_version)
     if cython_version_info < Version(minimum_cython_version):
         print("Version of Cython is too old. "
-              "Current is %s, need at least %s."
-              % (cython_version, minimum_cython_version))
+              f"Current is {cython_version}, "
+              f"need at least {minimum_cython_version}.")
         print("If the .c files are available, they will be built,"
               " but modifying the .pyx files will not rebuild them.")
         have_cython = False

fastbencode-0.2/.github/workflows/disperse.yml

@@ -1,24 +0,0 @@
----
-name: Disperse configuration
-
-"on":
-  - push
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-      - name: Install dependencies
-        run: |
-          sudo apt install protobuf-compiler
-      - name: Install disperse
-        run: |
-          pip install git+https://github.com/jelmer/disperse
-      - name: Validate disperse.conf
-        run: |
-          PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python disperse validate .

fastbencode-0.2/.github/workflows/pythonpackage.yml

@@ -1,32 +0,0 @@
-name: Python package
-
-on: [push, pull_request]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [3.7, 3.8, 3.9, '3.10', '3.11']
-      fail-fast: false
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip cython
-        pip install -U pip flake8
-    - name: Style checks
-      run: |
-        python -m flake8
-    - name: Test suite run
-      run: |
-        python -m unittest fastbencode.tests.test_suite
-      env:
-        PYTHONHASHSEED: random

fastbencode-0.2/.github/workflows/pythonpublish.yml

@@ -1,58 +0,0 @@
----
-name: Build Python Wheels
-
-"on":
-  push:
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-      fail-fast: true
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip cython
-          pip install setuptools wheel cibuildwheel
-      - name: Run test suite
-        run: python -m unittest fastbencode.tests.test_suite
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-        if: "matrix.os == 'ubuntu-latest'"
-      - name: Build wheels
-        run: python -m cibuildwheel --output-dir wheelhouse
-        env:
-          CIBW_ARCHS_LINUX: x86_64 aarch64
-          CIBW_ARCHS_MACOS: x86_64 arm64 universal2
-          CIBW_ARCHS_WINDOWS: AMD64 x86
-      - name: Upload wheels
-        uses: actions/upload-artifact@v3
-        with:
-          path: ./wheelhouse/*.whl
-
-  publish:
-    runs-on: ubuntu-latest
-
-    needs: build
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
-    steps:
-      - uses: actions/setup-python@v3
-
-      - name: Install twine
-        run: |
-          python -m pip install --upgrade pip
-          pip install twine
-      - name: Download wheels
-        uses: actions/download-artifact@v2
-      - name: Display structure of downloaded files
-        run: ls -R
-      - name: Publish wheels
-        env:
-          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-        run: twine upload artifact/*.whl

fastbencode-0.2/.gitignore

@@ -1,8 +0,0 @@
-*.so
-build
-fastbencode/_bencode_pyx.c
-fastbencode/_bencode_pyx.h
-__pycache__
-fastbencode.egg-info
-*.pyc
-dist

fastbencode-0.2/CODE_OF_CONDUCT.md

@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at core@breezy-vcs.org. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

fastbencode-0.2/SECURITY.md

@@ -1,5 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please report security issues by e-mail to core@breezy-vcs.org.

fastbencode-0.2/disperse.conf

@@ -1,8 +0,0 @@
-# See https://github.com/jelmer/disperse
-timeout_days: 5
-tag_name: "v$VERSION"
-verify_command: "python3 -m unittest fastbencode.tests.test_suite"
-update_version {
-  path: "fastbencode/__init__.py"
-  new_line: '__version__ = $TUPLED_VERSION'
-}

fastbencode-0.2/fastbencode/_bencode_py.py

@@ -1,162 +0,0 @@
-# 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 Dict, Type, Callable, List
-
-
-class BDecoder(object):
-
-    def __init__(self, yield_tuples=False):
-        """Constructor.
-
-        :param yield_tuples: if true, decode "l" elements as tuples rather than
-            lists.
-        """
-        self.yield_tuples = yield_tuples
-        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_string
-        decode_func[b'1'] = self.decode_string
-        decode_func[b'2'] = self.decode_string
-        decode_func[b'3'] = self.decode_string
-        decode_func[b'4'] = self.decode_string
-        decode_func[b'5'] = self.decode_string
-        decode_func[b'6'] = self.decode_string
-        decode_func[b'7'] = self.decode_string
-        decode_func[b'8'] = self.decode_string
-        decode_func[b'9'] = self.decode_string
-        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_string(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
-        return (x[colon:colon + n], 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_string(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
-
-
-class Bencached(object):
-    __slots__ = ['bencoded']
-
-    def __init__(self, s):
-        self.bencoded = s
-
-
-def encode_bencached(x, r):
-    r.append(x.bencoded)
-
-
-def encode_bool(x, r):
-    encode_int(int(x), r)
-
-
-def encode_int(x, r):
-    r.extend((b'i', int_to_bytes(x), b'e'))
-
-
-def encode_string(x, r):
-    r.extend((int_to_bytes(len(x)), b':', x))
-
-
-def encode_list(x, r):
-    r.append(b'l')
-    for i in x:
-        encode_func[type(i)](i, r)
-    r.append(b'e')
-
-
-def encode_dict(x, r):
-    r.append(b'd')
-    ilist = sorted(x.items())
-    for k, v in ilist:
-        r.extend((int_to_bytes(len(k)), b':', k))
-        encode_func[type(v)](v, r)
-    r.append(b'e')
-
-
-encode_func: Dict[Type, Callable[[object, List[bytes]], None]] = {}
-encode_func[type(Bencached(0))] = encode_bencached
-encode_func[int] = encode_int
-
-
-def int_to_bytes(n):
-    return b'%d' % n
-
-
-encode_func[bytes] = encode_string
-encode_func[list] = encode_list
-encode_func[tuple] = encode_list
-encode_func[dict] = encode_dict
-encode_func[bool] = encode_bool
-
-
-def bencode(x):
-    r = []
-    encode_func[type(x)](x, r)
-    return b''.join(r)

fastbencode-0.2/pyproject.toml

@@ -1,3 +0,0 @@
-[build-system]
-requires = ["setuptools", "cython>=0.29", "packaging"]
-build-backend = "setuptools.build_meta"

fastbencode-0.2/setup.cfg

@@ -1,35 +0,0 @@
-[metadata]
-name = fastbencode
-description = Implementation of bencode with optional fast C extensions
-maintainer = Breezy Developers
-maintainer_email = breezy-core@googlegroups.com
-url = https://github.com/breezy-team/fastbencode
-long_description = file:README.md
-license = GPLv2 or later
-version = attr:fastbencode.__version__
-project_urls = 
-	GitHub = https://github.com/breezy-team/fastbencode
-classifiers = 
-	Programming Language :: Python :: 3.7
-	Programming Language :: Python :: 3.8
-	Programming Language :: Python :: 3.9
-	Programming Language :: Python :: 3.10
-	Programming Language :: Python :: 3.11
-	Programming Language :: Python :: Implementation :: CPython
-	Programming Language :: Python :: Implementation :: PyPy
-	Operating System :: POSIX
-	Operating System :: Microsoft :: Windows
-
-[options]
-python_requires = >=3.7
-packages = fastbencode
-setup_requires = 
-	cython>=0.29
-
-[options.extras_require]
-cext = cython>=0.29
-
-[egg_info]
-tag_build = 
-tag_date = 0
-