Source code for pybase64._fallback

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


[docs] 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)
[docs] 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))
[docs] 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)
[docs] 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")
[docs] 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)