fastbencode 0.2__tar.gz → 0.3.2__tar.gz

fastbencode-0.3.2/.github/dependabot.yaml

@@ -0,0 +1,13 @@
+# Keep GitHub Actions up to date with GitHub's Dependabot...
+# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: weekly
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: weekly

fastbencode-0.3.2/.github/workflows/auto-merge.yml

@@ -0,0 +1,22 @@
+name: Dependabot auto-merge
+on: pull_request_target
+
+permissions:
+  pull-requests: write
+  contents: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - name: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2
+        with:
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Enable auto-merge for Dependabot PRs
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

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

@@ -0,0 +1,14 @@
+---
+name: Disperse configuration
+
+"on":
+  - push
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: jelmer/action-disperse-validate@v2

{fastbencode-0.2 → fastbencode-0.3.2}/.github/workflows/pythonpackage.yml

@@ -9,23 +9,31 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [3.7, 3.8, 3.9, '3.10', '3.11']
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.9']
       fail-fast: false
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip cython
-        pip install -U pip flake8
+        pip install -U pip ".[dev]"
     - name: Style checks
       run: |
-        python -m flake8
-    - name: Test suite run
+        python -m ruff check .
+    - name: Test suite run (pure Python)
+      run: |
+        python -m unittest fastbencode.tests.test_suite
+      env:
+        PYTHONHASHSEED: random
+    - name: Install in editable mode
+      run: |
+        pip install -e .
+    - name: Test suite run (with C extension)
       run: |
         python -m unittest fastbencode.tests.test_suite
       env:

fastbencode-0.3.2/.github/workflows/wheels.yaml

@@ -0,0 +1,93 @@
+name: Build Python distributions
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: "0 6 * * *" # Daily 6AM UTC build
+
+jobs:
+  build-wheels:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+      fail-fast: true
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install setuptools wheel cibuildwheel
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        if: "matrix.os == 'ubuntu-latest'"
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifact-${{ matrix.os }}
+          path: ./wheelhouse/*.whl
+
+  build-sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build sdist
+        run: python -m build --sdist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifact-sdist
+          path: ./dist/*.tar.gz
+
+  test-sdist:
+    needs:
+      - build-sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v5
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          # Upgrade packging to avoid a bug in twine.
+          # See https://github.com/pypa/twine/issues/1216
+          pip install "twine>=6.1.0" "packaging>=24.2"
+      - name: Download sdist
+        uses: actions/download-artifact@v4
+        with:
+          name: artifact-sdist
+          path: dist
+      - name: Test sdist
+        run: twine check dist/*
+      - name: Test installation from sdist
+        run: pip install dist/*.tar.gz
+
+  publish:
+    runs-on: ubuntu-latest
+    needs:
+      - build-wheels
+      - build-sdist
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      id-token: write
+    environment:
+      name: pypi
+      url: https://pypi.org/p/fastbencode
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+          pattern: artifact-*
+          path: dist
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{fastbencode-0.2 → fastbencode-0.3.2}/.gitignore

@@ -6,3 +6,4 @@ __pycache__
 fastbencode.egg-info
 *.pyc
 dist
+*~

{fastbencode-0.2 → fastbencode-0.3.2}/CODE_OF_CONDUCT.md

@@ -6,7 +6,7 @@ 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
+level of experience, education, socioeconomic status, nationality, personal
 appearance, race, religion, or sexual identity and orientation.
 
 ## Our Standards

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

@@ -1,24 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fastbencode
-Version: 0.2
+Version: 0.3.2
 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 :: 3.13
 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.9
+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.11.9; extra == "dev"
+Dynamic: license-file
 
 fastbencode
 ===========
@@ -38,6 +42,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.2}/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.3.2/disperse.toml

@@ -0,0 +1,8 @@
+tag-name = "v$VERSION"
+verify-command = "python3 -m unittest fastbencode.tests.test_suite"
+tarball-location = []
+release-timeout = 5
+
+[[update_version]]
+path = "fastbencode/__init__.py"
+new-line = "__version__ = $TUPLED_VERSION"

{fastbencode-0.2 → fastbencode-0.3.2}/fastbencode/__init__.py

@@ -1,4 +1,5 @@
 # Copyright (C) 2007, 2009 Canonical Ltd
+# Copyright (C) 2021-2023 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -14,12 +15,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, 2)
 
 
 _extension_load_failures = []
@@ -49,21 +49,22 @@ def failed_to_load_extension(exception):
     exception_str = str(exception)
     if exception_str not in _extension_load_failures:
         import warnings
+
         warnings.warn(
-            'failed to load compiled extension: %s' % exception_str,
-            UserWarning)
+            f"failed to load compiled extension: {exception_str}", UserWarning
+        )
         _extension_load_failures.append(exception_str)
 
 
 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.2/fastbencode/_bencode_py.py

@@ -0,0 +1,185 @@
+# 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
+# Modifications copyright (C) 2021-2023 Jelmer Vernooij
+
+
+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.2}/fastbencode/_bencode_pyx.pyi

@@ -1,7 +1,5 @@
-
 def bdecode(bytes) -> object: ...
 def bdecode_as_tuple(bytes) -> object: ...
 def bencode(object) -> bytes: ...
 
-
-class Bencached(object): ...
+class Bencached: ...