pybase64 1.4.2__cp313-cp313-android_21_arm64_v8a.whl

pybase64/__init__.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._license import _license
+from ._version import _version
+
+if TYPE_CHECKING:
+    from ._typing import Buffer
+
+try:
+    from ._pybase64 import (
+        _get_simd_flags_compile,  # noqa: F401
+        _get_simd_flags_runtime,  # noqa: F401
+        _get_simd_name,
+        _get_simd_path,
+        _set_simd_path,  # noqa: F401
+        b64decode,
+        b64decode_as_bytearray,
+        b64encode,
+        b64encode_as_string,
+        encodebytes,
+    )
+except ImportError:
+    from ._fallback import (
+        _get_simd_name,
+        _get_simd_path,
+        b64decode,
+        b64decode_as_bytearray,
+        b64encode,
+        b64encode_as_string,
+        encodebytes,
+    )
+
+
+__all__ = (
+    "b64decode",
+    "b64decode_as_bytearray",
+    "b64encode",
+    "b64encode_as_string",
+    "encodebytes",
+    "standard_b64decode",
+    "standard_b64encode",
+    "urlsafe_b64decode",
+    "urlsafe_b64encode",
+)
+
+__version__ = _version
+
+
+def get_license_text() -> str:
+    """Returns pybase64 license information as a :class:`str` object.
+
+    The result includes libbase64 license information as well.
+    """
+    return _license
+
+
+def get_version() -> str:
+    """Returns pybase64 version as a :class:`str` object.
+
+    The result reports if the C extension is used or not.
+    e.g. `1.0.0 (C extension active - AVX2)`
+    """
+    simd_name = _get_simd_name(_get_simd_path())
+    if simd_name != "fallback":
+        return f"{__version__} (C extension active - {simd_name})"
+    return f"{__version__} (C extension inactive)"
+
+
+def standard_b64encode(s: Buffer) -> bytes:
+    """Encode bytes using the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` to encode.
+
+    The result is returned as a :class:`bytes` object.
+    """
+    return b64encode(s)
+
+
+def standard_b64decode(s: str | Buffer) -> bytes:
+    """Decode bytes encoded with the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` or ASCII string to
+    decode.
+
+    The result is returned as a :class:`bytes` object.
+
+    A :exc:`binascii.Error` is raised if the input is incorrectly padded.
+
+    Characters that are not in the standard alphabet are discarded prior
+    to the padding check.
+    """
+    return b64decode(s)
+
+
+def urlsafe_b64encode(s: Buffer) -> bytes:
+    """Encode bytes using the URL- and filesystem-safe Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` to encode.
+
+    The result is returned as a :class:`bytes` object.
+
+    The alphabet uses '-' instead of '+' and '_' instead of '/'.
+    """
+    return b64encode(s, b"-_")
+
+
+def urlsafe_b64decode(s: str | Buffer) -> bytes:
+    """Decode bytes using the URL- and filesystem-safe Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` or ASCII string to
+    decode.
+
+    The result is returned as a :class:`bytes` object.
+
+    A :exc:`binascii.Error` is raised if the input is incorrectly padded.
+
+    Characters that are not in the URL-safe base-64 alphabet, and are not
+    a plus '+' or slash '/', are discarded prior to the padding check.
+
+    The alphabet uses '-' instead of '+' and '_' instead of '/'.
+    """
+    return b64decode(s, b"-_")

pybase64/__main__.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+import argparse
+import base64
+import sys
+from base64 import b64decode as b64decodeValidate
+from base64 import encodebytes as b64encodebytes
+from collections.abc import Sequence
+from pathlib import Path
+from timeit import default_timer as timer
+from typing import TYPE_CHECKING, Any
+
+import pybase64
+
+if TYPE_CHECKING:
+    from pybase64._typing import Decode, Encode, EncodeBytes
+
+
+def bench_one(
+    duration: float,
+    data: bytes,
+    enc: Encode,
+    dec: Decode,
+    encbytes: EncodeBytes,
+    altchars: bytes | None = None,
+    validate: bool = False,
+) -> None:
+    duration = duration / 2.0
+
+    if not validate and altchars is None:
+        number = 0
+        time = timer()
+        while True:
+            encodedcontent = encbytes(data)
+            number += 1
+            if timer() - time > duration:
+                break
+        iter = number
+        time = timer()
+        while iter > 0:
+            encodedcontent = encbytes(data)
+            iter -= 1
+        time = timer() - time
+        print(
+            "{:<32s} {:9.3f} MB/s ({:,d} bytes -> {:,d} bytes)".format(
+                encbytes.__module__ + "." + encbytes.__name__ + ":",
+                ((number * len(data)) / (1024.0 * 1024.0)) / time,
+                len(data),
+                len(encodedcontent),
+            )
+        )
+
+    number = 0
+    time = timer()
+    while True:
+        encodedcontent = enc(data, altchars=altchars)
+        number += 1
+        if timer() - time > duration:
+            break
+    iter = number
+    time = timer()
+    while iter > 0:
+        encodedcontent = enc(data, altchars=altchars)
+        iter -= 1
+    time = timer() - time
+    print(
+        "{:<32s} {:9.3f} MB/s ({:,d} bytes -> {:,d} bytes)".format(
+            enc.__module__ + "." + enc.__name__ + ":",
+            ((number * len(data)) / (1024.0 * 1024.0)) / time,
+            len(data),
+            len(encodedcontent),
+        )
+    )
+
+    number = 0
+    time = timer()
+    while True:
+        decodedcontent = dec(encodedcontent, altchars=altchars, validate=validate)
+        number += 1
+        if timer() - time > duration:
+            break
+    iter = number
+    time = timer()
+    while iter > 0:
+        decodedcontent = dec(encodedcontent, altchars=altchars, validate=validate)
+        iter -= 1
+    time = timer() - time
+    print(
+        "{:<32s} {:9.3f} MB/s ({:,d} bytes -> {:,d} bytes)".format(
+            dec.__module__ + "." + dec.__name__ + ":",
+            ((number * len(data)) / (1024.0 * 1024.0)) / time,
+            len(encodedcontent),
+            len(data),
+        )
+    )
+    assert decodedcontent == data
+
+
+def readall(file: str) -> bytes:
+    if file == "-":
+        return sys.stdin.buffer.read()
+    return Path(file).read_bytes()
+
+
+def writeall(file: str, data: bytes) -> None:
+    if file == "-":
+        sys.stdout.buffer.write(data)
+    else:
+        Path(file).write_bytes(data)
+
+
+def benchmark(duration: float, input: str) -> None:
+    print(__package__ + " " + pybase64.get_version())
+    data = readall(input)
+    for altchars in [None, b"-_"]:
+        for validate in [False, True]:
+            print(f"bench: altchars={altchars!r:s}, validate={validate!r:s}")
+            bench_one(
+                duration,
+                data,
+                pybase64.b64encode,
+                pybase64.b64decode,
+                pybase64.encodebytes,
+                altchars,
+                validate,
+            )
+            bench_one(
+                duration,
+                data,
+                base64.b64encode,
+                b64decodeValidate,
+                b64encodebytes,
+                altchars,
+                validate,
+            )
+
+
+def encode(input: str, altchars: bytes | None, output: str) -> None:
+    data = readall(input)
+    data = pybase64.b64encode(data, altchars)
+    writeall(output, data)
+
+
+def decode(input: str, altchars: bytes | None, validate: bool, output: str) -> None:
+    data = readall(input)
+    data = pybase64.b64decode(data, altchars, validate)
+    writeall(output, data)
+
+
+class LicenseAction(argparse.Action):
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        dest: str,
+        license: str | None = None,
+        help: str | None = "show license information and exit",
+    ):
+        super().__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=argparse.SUPPRESS,
+            nargs=0,
+            help=help,
+        )
+        self.license = license
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,  # noqa: ARG002
+        values: str | Sequence[Any] | None,  # noqa: ARG002
+        option_string: str | None = None,  # noqa: ARG002
+    ) -> None:
+        print(self.license)
+        parser.exit()
+
+
+def check_file(value: str, is_input: bool) -> str:
+    if value == "-":
+        return value
+    path = Path(value)
+    if is_input:
+        return str(path.resolve(strict=True))
+    return str(path.parent.resolve(strict=True) / path.name)
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    # main parser
+    parser = argparse.ArgumentParser(
+        prog=__package__, description=__package__ + " command-line tool."
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=__package__ + " " + pybase64.get_version(),
+    )
+    parser.add_argument("--license", action=LicenseAction, license=pybase64.get_license_text())
+    # create sub-parsers
+    subparsers = parser.add_subparsers(help="tool help")
+    # benchmark parser
+    benchmark_parser = subparsers.add_parser("benchmark", help="-h for usage")
+    benchmark_parser.add_argument(
+        "-d",
+        "--duration",
+        metavar="D",
+        dest="duration",
+        type=float,
+        default=1.0,
+        help="expected duration for a single encode or decode test",
+    )
+    benchmark_parser.register("type", "input file", lambda s: check_file(s, True))
+    benchmark_parser.add_argument(
+        "input", type="input file", help="input file used for the benchmark"
+    )
+    benchmark_parser.set_defaults(func=benchmark)
+    # encode parser
+    encode_parser = subparsers.add_parser("encode", help="-h for usage")
+    encode_parser.register("type", "input file", lambda s: check_file(s, True))
+    encode_parser.register("type", "output file", lambda s: check_file(s, False))
+    encode_parser.add_argument("input", type="input file", help="input file to be encoded")
+    group = encode_parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-u",
+        "--url",
+        action="store_const",
+        const=b"-_",
+        dest="altchars",
+        help="use URL encoding",
+    )
+    group.add_argument(
+        "-a",
+        "--altchars",
+        dest="altchars",
+        help="use alternative characters for encoding",
+    )
+    encode_parser.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        type="output file",
+        default="-",
+        help="encoded output file (default to stdout)",
+    )
+    encode_parser.set_defaults(func=encode)
+    # decode parser
+    decode_parser = subparsers.add_parser("decode", help="-h for usage")
+    decode_parser.register("type", "input file", lambda s: check_file(s, True))
+    decode_parser.register("type", "output file", lambda s: check_file(s, False))
+    decode_parser.add_argument("input", type="input file", help="input file to be decoded")
+    group = decode_parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-u",
+        "--url",
+        action="store_const",
+        const=b"-_",
+        dest="altchars",
+        help="use URL decoding",
+    )
+    group.add_argument(
+        "-a",
+        "--altchars",
+        dest="altchars",
+        help="use alternative characters for decoding",
+    )
+    decode_parser.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        type="output file",
+        default="-",
+        help="decoded output file (default to stdout)",
+    )
+    decode_parser.add_argument(
+        "--no-validation",
+        dest="validate",
+        action="store_false",
+        help="disable validation of the input data",
+    )
+    decode_parser.set_defaults(func=decode)
+    # ready, parse
+    if argv is None:
+        argv = sys.argv[1:]
+    if len(argv) == 0:
+        argv = ["-h"]
+    args = vars(parser.parse_args(args=argv))
+    func = args.pop("func")
+    func(**args)
+
+
+if __name__ == "__main__":
+    main()

pybase64/_fallback.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from base64 import b64decode as builtin_decode
+from base64 import b64encode as builtin_encode
+from base64 import encodebytes as builtin_encodebytes
+from binascii import Error as BinAsciiError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._typing import Buffer
+
+_bytes_types = (bytes, bytearray)  # Types acceptable as binary data
+
+
+def _get_simd_name(flags: int) -> str:
+    assert flags == 0
+    return "fallback"
+
+
+def _get_simd_path() -> int:
+    return 0
+
+
+def _get_bytes(s: str | Buffer) -> bytes | bytearray:
+    if isinstance(s, str):
+        try:
+            return s.encode("ascii")
+        except UnicodeEncodeError:
+            msg = "string argument should contain only ASCII characters"
+            raise ValueError(msg) from None
+    if isinstance(s, _bytes_types):
+        return s
+    try:
+        mv = memoryview(s)
+        if not mv.c_contiguous:
+            msg = f"{s.__class__.__name__!r:s}: underlying buffer is not C-contiguous"
+            raise BufferError(msg)
+        return mv.tobytes()
+    except TypeError:
+        msg = (
+            "argument should be a bytes-like object or ASCII "
+            f"string, not {s.__class__.__name__!r:s}"
+        )
+        raise TypeError(msg) from None
+
+
+def b64decode(
+    s: str | Buffer, altchars: str | Buffer | None = None, validate: bool = False
+) -> bytes:
+    """Decode bytes encoded with the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` or ASCII string to
+    decode.
+
+    Optional ``altchars`` must be a :term:`bytes-like object` or ASCII
+    string of length 2 which specifies the alternative alphabet used instead
+    of the '+' and '/' characters.
+
+    If ``validate`` is ``False`` (the default), characters that are neither in
+    the normal base-64 alphabet nor the alternative alphabet are discarded
+    prior to the padding check.
+    If ``validate`` is ``True``, these non-alphabet characters in the input
+    result in a :exc:`binascii.Error`.
+
+    The result is returned as a :class:`bytes` object.
+
+    A :exc:`binascii.Error` is raised if ``s`` is incorrectly padded.
+    """
+    s = _get_bytes(s)
+    if altchars is not None:
+        altchars = _get_bytes(altchars)
+    if validate:
+        if len(s) % 4 != 0:
+            msg = "Incorrect padding"
+            raise BinAsciiError(msg)
+        result = builtin_decode(s, altchars, validate=False)
+
+        # check length of result vs length of input
+        expected_len = 0
+        if len(s) > 0:
+            padding = 0
+            # len(s) % 4 != 0 implies len(s) >= 4 here
+            if s[-2] == 61:  # 61 == ord("=")
+                padding += 1
+            if s[-1] == 61:
+                padding += 1
+            expected_len = 3 * (len(s) // 4) - padding
+        if expected_len != len(result):
+            msg = "Non-base64 digit found"
+            raise BinAsciiError(msg)
+        return result
+    return builtin_decode(s, altchars, validate=False)
+
+
+def b64decode_as_bytearray(
+    s: str | Buffer, altchars: str | Buffer | None = None, validate: bool = False
+) -> bytearray:
+    """Decode bytes encoded with the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` or ASCII string to
+    decode.
+
+    Optional ``altchars`` must be a :term:`bytes-like object` or ASCII
+    string of length 2 which specifies the alternative alphabet used instead
+    of the '+' and '/' characters.
+
+    If ``validate`` is ``False`` (the default), characters that are neither in
+    the normal base-64 alphabet nor the alternative alphabet are discarded
+    prior to the padding check.
+    If ``validate`` is ``True``, these non-alphabet characters in the input
+    result in a :exc:`binascii.Error`.
+
+    The result is returned as a :class:`bytearray` object.
+
+    A :exc:`binascii.Error` is raised if ``s`` is incorrectly padded.
+    """
+    return bytearray(b64decode(s, altchars=altchars, validate=validate))
+
+
+def b64encode(s: Buffer, altchars: str | Buffer | None = None) -> bytes:
+    """Encode bytes using the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` to encode.
+
+    Optional ``altchars`` must be a byte string of length 2 which specifies
+    an alternative alphabet for the '+' and '/' characters.  This allows an
+    application to e.g. generate url or filesystem safe Base64 strings.
+
+    The result is returned as a :class:`bytes` object.
+    """
+    mv = memoryview(s)
+    if not mv.c_contiguous:
+        msg = f"{s.__class__.__name__!r:s}: underlying buffer is not C-contiguous"
+        raise BufferError(msg)
+    if altchars is not None:
+        altchars = _get_bytes(altchars)
+    return builtin_encode(s, altchars)
+
+
+def b64encode_as_string(s: Buffer, altchars: str | Buffer | None = None) -> str:
+    """Encode bytes using the standard Base64 alphabet.
+
+    Argument ``s`` is a :term:`bytes-like object` to encode.
+
+    Optional ``altchars`` must be a byte string of length 2 which specifies
+    an alternative alphabet for the '+' and '/' characters.  This allows an
+    application to e.g. generate url or filesystem safe Base64 strings.
+
+    The result is returned as a :class:`str` object.
+    """
+    return b64encode(s, altchars).decode("ascii")
+
+
+def encodebytes(s: Buffer) -> bytes:
+    """Encode bytes into a bytes object with newlines (b'\\\\n') inserted after
+    every 76 bytes of output, and ensuring that there is a trailing newline,
+    as per :rfc:`2045` (MIME).
+
+    Argument ``s`` is a :term:`bytes-like object` to encode.
+
+    The result is returned as a :class:`bytes` object.
+    """
+    mv = memoryview(s)
+    if not mv.c_contiguous:
+        msg = f"{s.__class__.__name__!r:s}: underlying buffer is not C-contiguous"
+        raise BufferError(msg)
+    return builtin_encodebytes(s)

pybase64/_license.py

@@ -0,0 +1,61 @@
+_license = """pybase64
+===============================================================================
+BSD 2-Clause License
+
+Copyright (c) 2017-2022, Matthieu Darbois
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+===============================================================================
+
+libbase64
+===============================================================================
+Copyright (c) 2005-2007, Nick Galbreath
+Copyright (c) 2015-2018, Wojciech Muła
+Copyright (c) 2016-2017, Matthieu Darbois
+Copyright (c) 2013-2022, Alfred Klomp
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+==========================================================================""" \
+    + "====="

pybase64/_license.pyi

@@ -0,0 +1 @@
+_license: str

pybase64/_pybase64.pyi

@@ -0,0 +1,16 @@
+from ._typing import Buffer
+
+def _get_simd_flags_compile() -> int: ...
+def _get_simd_flags_runtime() -> int: ...
+def _get_simd_name(flags: int) -> str: ...
+def _get_simd_path() -> int: ...
+def _set_simd_path(flags: int) -> None: ...
+def b64decode(
+    s: str | Buffer, altchars: str | Buffer | None = None, validate: bool = False
+) -> bytes: ...
+def b64decode_as_bytearray(
+    s: str | Buffer, altchars: str | Buffer | None = None, validate: bool = False
+) -> bytearray: ...
+def b64encode(s: Buffer, altchars: str | Buffer | None = None) -> bytes: ...
+def b64encode_as_string(s: Buffer, altchars: str | Buffer | None = None) -> str: ...
+def encodebytes(s: Buffer) -> bytes: ...

pybase64/_typing.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import sys
+from typing import Protocol
+
+if sys.version_info < (3, 12):
+    from typing_extensions import Buffer
+else:
+    from collections.abc import Buffer
+
+
+class Decode(Protocol):
+    __name__: str
+    __module__: str
+
+    def __call__(
+        self, s: str | Buffer, altchars: str | Buffer | None = None, validate: bool = False
+    ) -> bytes: ...
+
+
+class Encode(Protocol):
+    __name__: str
+    __module__: str
+
+    def __call__(self, s: Buffer, altchars: Buffer | None = None) -> bytes: ...
+
+
+class EncodeBytes(Protocol):
+    __name__: str
+    __module__: str
+
+    def __call__(self, s: Buffer) -> bytes: ...
+
+
+__all__ = ("Buffer", "Decode", "Encode", "EncodeBytes")

pybase64/_version.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+_version = "1.4.2"

pybase64-1.4.2.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.4
+Name: pybase64
+Version: 1.4.2
+Summary: Fast Base64 encoding/decoding
+Home-page: https://github.com/mayeut/pybase64
+Author: Matthieu Darbois
+License: BSD-2-Clause
+Project-URL: Source, https://github.com/mayeut/pybase64
+Project-URL: Tracker, https://github.com/mayeut/pybase64/issues
+Project-URL: Documentation, https://pybase64.readthedocs.io/en/stable
+Keywords: base64
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+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 :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+.. SETUP VARIABLES
+.. |license-status| image:: https://img.shields.io/badge/license-BSD%202--Clause-blue.svg
+  :target: https://github.com/mayeut/pybase64/blob/master/LICENSE
+.. |pypi-status| image:: https://img.shields.io/pypi/v/pybase64.svg
+  :target: https://pypi.python.org/pypi/pybase64
+.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pybase64.svg
+.. |rtd-status| image:: https://readthedocs.org/projects/pybase64/badge/?version=stable
+  :target: http://pybase64.readthedocs.io/en/stable/?badge=stable
+  :alt: Documentation Status
+.. |gha-status| image:: https://github.com/mayeut/pybase64/workflows/Build%20and%20upload%20to%20PyPI/badge.svg
+  :target: https://github.com/mayeut/pybase64/actions?query=workflow%3A%22Build+and+upload+to+PyPI%22
+.. |codecov-status| image:: https://codecov.io/gh/mayeut/pybase64/branch/master/graph/badge.svg
+  :target: https://codecov.io/gh/mayeut/pybase64/branch/master
+.. END OF SETUP
+
+Fast Base64 implementation
+==========================
+
+|license-status| |pypi-status| |python-versions| |rtd-status| |gha-status| |codecov-status|
+
+This project is a wrapper on `libbase64 <https://github.com/aklomp/base64>`_.
+
+It aims to provide a fast base64 implementation for base64 encoding/decoding.
+
+Installation
+============
+
+.. code::
+
+    pip install pybase64
+
+Usage
+=====
+
+``pybase64`` uses the same API as Python base64 "modern interface" (introduced in Python 2.4) for an easy integration.
+
+To get the fastest decoding, it is recommended to use the ``pybase64.b64decode`` and ``validate=True`` when possible.
+
+.. code:: python
+
+    import pybase64
+
+    print(pybase64.b64encode(b'>>>foo???', altchars='_:'))
+    # b'Pj4_Zm9vPz8:'
+    print(pybase64.b64decode(b'Pj4_Zm9vPz8:', altchars='_:', validate=True))
+    # b'>>>foo???'
+
+    # Standard encoding helpers
+    print(pybase64.standard_b64encode(b'>>>foo???'))
+    # b'Pj4+Zm9vPz8/'
+    print(pybase64.standard_b64decode(b'Pj4+Zm9vPz8/'))
+    # b'>>>foo???'
+
+    # URL safe encoding helpers
+    print(pybase64.urlsafe_b64encode(b'>>>foo???'))
+    # b'Pj4-Zm9vPz8_'
+    print(pybase64.urlsafe_b64decode(b'Pj4-Zm9vPz8_'))
+    # b'>>>foo???'
+
+.. begin cli
+
+A command-line tool is also provided. It has encode, decode and benchmark subcommands.
+
+.. code::
+
+    usage: pybase64 [-h] [-V] {benchmark,encode,decode} ...
+
+    pybase64 command-line tool.
+
+    positional arguments:
+      {benchmark,encode,decode}
+                            tool help
+        benchmark           -h for usage
+        encode              -h for usage
+        decode              -h for usage
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      -V, --version         show program's version number and exit
+
+.. end cli
+
+Full documentation on `Read the Docs <http://pybase64.readthedocs.io/en/stable/?badge=stable>`_.
+
+Benchmark
+=========
+
+.. begin benchmark
+
+Running Python 3.7.2, Apple LLVM version 10.0.0 (clang-1000.11.45.5), Mac OS X 10.14.2 on an Intel Core i7-4870HQ @ 2.50GHz
+
+.. code::
+
+    pybase64 0.5.0 (C extension active - AVX2)
+    bench: altchars=None, validate=False
+    pybase64._pybase64.encodebytes:   1734.776 MB/s (13,271,472 bytes -> 17,928,129 bytes)
+    pybase64._pybase64.b64encode:     4039.539 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    pybase64._pybase64.b64decode:     1854.423 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    base64.encodebytes:                 78.352 MB/s (13,271,472 bytes -> 17,928,129 bytes)
+    base64.b64encode:                  539.840 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    base64.b64decode:                  287.826 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    bench: altchars=None, validate=True
+    pybase64._pybase64.b64encode:     4156.607 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    pybase64._pybase64.b64decode:     4107.997 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    base64.b64encode:                  559.342 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    base64.b64decode:                  143.674 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    bench: altchars=b'-_', validate=False
+    pybase64._pybase64.b64encode:     2786.776 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    pybase64._pybase64.b64decode:     1124.136 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    base64.b64encode:                  322.427 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    base64.b64decode:                  205.195 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    bench: altchars=b'-_', validate=True
+    pybase64._pybase64.b64encode:     2806.271 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    pybase64._pybase64.b64decode:     2740.456 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+    base64.b64encode:                  314.709 MB/s (13,271,472 bytes -> 17,695,296 bytes)
+    base64.b64decode:                  121.803 MB/s (17,695,296 bytes -> 13,271,472 bytes)
+
+.. end benchmark
+
+.. begin changelog
+
+Changelog
+=========
+1.4.2
+-----
+- Update base64 library (Windows ARM64 Neon support)
+- Publish Python 3.14 wheels
+- Publish Linux riscv64 wheels
+- Publish Android wheels
+- Publish iOS wheels
+- Publish GraalPy wheels
+
+1.4.1
+-----
+- Publish PyPy 3.11 wheels
+- Publish armv7l wheels
+
+1.4.0
+-----
+- Publish python 3.13 wheels
+- Add support for free-threaded builds
+- Add MSYS2 support for C-extension
+- Better logging on base64 build failure when C-extension build is optional
+- Drop python 3.6 & 3.7 support
+
+1.3.2
+-----
+- Update base64 library
+- PyPy: fix wrong outcome with non C-contiguous buffer
+
+1.3.1
+-----
+- Add missing py.typed marker
+
+1.3.0
+-----
+- Update base64 library
+- Add AVX512-VBMI implementation
+- Rework extension build to remove adherence on distutils
+- Publish python 3.12 wheels
+- Documentation now uses furo theme
+
+1.2.3
+-----
+- Update base64 library
+- Publish python 3.11 wheels
+
+1.2.2
+-----
+- Update base64 library
+- Fix C extension build on musl distros
+- Publish musllinux wheels
+
+1.2.1
+-----
+- Publish PyPy 3.8 (pypy38_pp73) wheels
+
+1.2.0
+-----
+- Release the GIL
+- Publish CPython 3.10 wheels
+- Drop python 3.5 support
+
+1.1.4
+-----
+- Add macOS arm64 wheel
+
+1.1.3
+-----
+- GitHub Actions: fix build on tag
+
+1.1.2
+-----
+- Add PyPy wheels
+- Add aarch64, ppc64le & s390x manylinux wheels
+
+1.1.1
+-----
+- Move CI from TravisCI/AppVeyor to GitHub Actions
+- Fix publication of Linux/macOS wheels
+
+1.1.0
+-----
+- Add b64encode_as_string, same as b64encode but returns a str object instead of a bytes object
+- Add b64decode_as_bytearray, same as b64decode but returns a bytarray object instead of a bytes object
+- Speed-Up decoding from UCS1 strings
+
+1.0.2
+-----
+- Update base64 library
+- Publish python 3.9 wheels
+
+1.0.1
+-----
+- Publish python 3.8 wheels
+
+1.0.0
+-----
+- Drop python 3.4 support
+- Drop python 2.7 support
+
+0.5.0
+-----
+- Publish python 3.7 wheels
+- Drop python 3.3 support
+
+0.4.0
+-----
+- Speed-up decoding when validate==False
+
+0.3.1
+-----
+- Fix deployment issues
+
+0.3.0
+-----
+- Add encodebytes function
+
+0.2.1
+-----
+- Fixed invalid results on Windows
+
+0.2.0
+-----
+- Added documentation
+- Added subcommands to the main script:
+
+    * help
+    * version
+    * encode
+    * decode
+    * benchmark
+
+0.1.2
+-----
+- Updated base64 native library
+
+0.1.1
+-----
+- Fixed deployment issues
+
+0.1.0
+-----
+- First public release
+
+.. end changelog

pybase64-1.4.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+pybase64/__init__.py,sha256=wb_YG09m0-rC6lPmDKF62XsEcVhGkCxcPw2GZyxE9L4,3230
+pybase64/__main__.py,sha256=djZqQ6QNmgIAjvYHQa-uIApZhxyUZj2UzvDeQjfLn0w,8530
+pybase64/_fallback.py,sha256=L-i5KnRtLU2PfBbKIL2hNiHmNrWs1LeWYh3xGD8mriM,5800
+pybase64/_license.py,sha256=Lu3v1O3buEcMPgKC5f4r523lGvNGgoTXhHnHh0Ys1kw,3116
+pybase64/_license.pyi,sha256=aTpwZqUJh82NsyBwHhQo_cJRZsBYSARCKxGdtb1QYPk,14
+pybase64/_pybase64.cpython-313-aarch64-linux-android.so,sha256=W7dRgH0KrQLx3SMGigFag79Asc3b1LeNudS56UB8vSc,48016
+pybase64/_pybase64.pyi,sha256=wxk6eoWmafyE9NOVr2j9T0E2w2lSC-ImIL5E-HP1XcE,679
+pybase64/_typing.py,sha256=QvyxFSzktrAAOT2ohlB5ah1WDbqL6bnZDRvgemDZY1k,709
+pybase64/_version.py,sha256=_VSFxJfXwKW9isWsQYEeKF59rytvn_LO7yJ2uuV-LL0,55
+pybase64/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybase64-1.4.2.dist-info/licenses/LICENSE,sha256=XlI7VMFYHUT0WL_dLNOUTWIrsaMqpB8Hc-5No5D7RbQ,1326
+pybase64-1.4.2.dist-info/METADATA,sha256=JJqLdcfA01uCrnwagf4Jn44a_WeJcs9fTZaoL_IjXa0,8663
+pybase64-1.4.2.dist-info/WHEEL,sha256=5I58AbR9O_ArnZQueeIBJrrQjT_lZqa3wHwMOp-EJ_E,112
+pybase64-1.4.2.dist-info/entry_points.txt,sha256=qLhLeuPRnj6ju76SqeVYOuxavmDKx9ZWjXHLltpLa5o,52
+pybase64-1.4.2.dist-info/top_level.txt,sha256=Tm3tmGpMnLWAvjrxORS2E5I6LARaLepOEUjGaTmFuZg,9
+pybase64-1.4.2.dist-info/RECORD,,

pybase64-1.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-android_21_arm64_v8a
+

pybase64-1.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pybase64 = pybase64.__main__:main

pybase64-1.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017-2022, Matthieu Darbois
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pybase64-1.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pybase64