encoding.base64

from typing import Sequence

_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"


def base64_encode(bytes: Sequence[int]) -> str:
    """Bytes as standard base64 (RFC 4648 section 4), padded with "=".

    A Python ``bytes`` value is accepted as is; a list must hold integers
    0-255, and anything else is refused rather than masked to a byte.
    """
    if isinstance(bytes, (str, dict)) or not hasattr(bytes, "__len__"):
        raise TypeError("bytes must be a list of integers from 0 to 255")
    for b in bytes:
        if type(b) is not int or b < 0 or b > 255:
            raise ValueError("bytes must be a list of integers from 0 to 255")
    out = []
    n_full = len(bytes) - len(bytes) % 3
    for i in range(0, n_full, 3):
        n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
        out.append(_ALPHABET[(n >> 18) & 63] + _ALPHABET[(n >> 12) & 63] + _ALPHABET[(n >> 6) & 63] + _ALPHABET[n & 63])
    rest = len(bytes) - n_full
    if rest == 1:
        n = bytes[n_full] << 16
        out.append(_ALPHABET[(n >> 18) & 63] + _ALPHABET[(n >> 12) & 63] + "==")
    elif rest == 2:
        n = (bytes[n_full] << 16) | (bytes[n_full + 1] << 8)
        out.append(_ALPHABET[(n >> 18) & 63] + _ALPHABET[(n >> 12) & 63] + _ALPHABET[(n >> 6) & 63] + "=")
    return "".join(out)

from typing import List


def _sextet(ch: str) -> int:
    # Character ranges rather than str.isalnum(), which is true for letters
    # and digits of every script.
    if "A" <= ch <= "Z":
        return ord(ch) - 65
    if "a" <= ch <= "z":
        return ord(ch) - 71
    if "0" <= ch <= "9":
        return ord(ch) + 4
    if ch == "+":
        return 62
    if ch == "/":
        return 63
    return -1


def base64_decode(text: str) -> List[int]:
    """Standard, padded base64 back to bytes, strictly.

    No whitespace, no characters outside the alphabet, padding to a multiple
    of four, and zero bits after the last byte, so every byte string has
    exactly one spelling. The standard library's decoder skips or accepts
    some of these, which is why this is written out.
    """
    if not isinstance(text, str):
        raise TypeError("base64 text must be a string")
    values = []
    padding = 0
    for ch in text:
        if ch == "=":
            padding += 1
            continue
        v = _sextet(ch)
        if v < 0 or padding > 0:
            raise ValueError("base64 text may only contain A-Z, a-z, 0-9, + and /, with = padding at the end")
        values.append(v)
    if len(text) % 4 != 0:
        raise ValueError("base64 text must be a multiple of 4 characters long, received %d" % len(text))
    if padding > 2:
        raise ValueError("base64 text has too much = padding")
    out = []
    n_full = len(values) - len(values) % 4
    for i in range(0, n_full, 4):
        n = (values[i] << 18) | (values[i + 1] << 12) | (values[i + 2] << 6) | values[i + 3]
        out.extend(((n >> 16) & 255, (n >> 8) & 255, n & 255))
    rest = len(values) - n_full
    if rest == 2:
        if values[n_full + 1] & 15:
            raise ValueError("base64 text has non-zero bits after its last byte")
        out.append(((values[n_full] << 2) | (values[n_full + 1] >> 4)) & 255)
    elif rest == 3:
        if values[n_full + 2] & 3:
            raise ValueError("base64 text has non-zero bits after its last byte")
        n = (values[n_full] << 18) | (values[n_full + 1] << 12) | (values[n_full + 2] << 6)
        out.extend(((n >> 16) & 255, (n >> 8) & 255))
    return out

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import Sequence

from .encoding_base64_base64_encode import base64_encode  ← base64Encode, another function of this group · built into the same file, even by a slim install


def base64_url_encode(bytes: Sequence[int]) -> str:
    """Bytes as base64url (RFC 4648 section 5) without padding, as JWTs use it."""
    return base64_encode(bytes).rstrip("=").replace("+", "-").replace("/", "_")

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import List

from .encoding_base64_base64_decode import base64_decode  ← base64Decode, another function of this group · built into the same file, even by a slim install


def base64_url_decode(text: str) -> List[int]:
    """base64url text back to bytes, with or without correct padding."""
    if not isinstance(text, str):
        raise TypeError("base64url text must be a string")
    body = []
    padding = 0
    for ch in text:
        if ch == "=":
            padding += 1
            continue
        ok = ("A" <= ch <= "Z") or ("a" <= ch <= "z") or ("0" <= ch <= "9") or ch == "-" or ch == "_"
        if not ok or padding > 0:
            raise ValueError(
                "base64url text may only contain A-Z, a-z, 0-9, - and _, with optional = padding at the end"
            )
        body.append("+" if ch == "-" else "/" if ch == "_" else ch)
    if len(body) % 4 == 1:
        raise ValueError(
            "base64url text cannot be %d characters long; no number of bytes encodes to that" % len(body)
        )
    needed = (4 - len(body) % 4) % 4
    if padding != 0 and padding != needed:
        raise ValueError("base64url text has the wrong amount of = padding")
    return base64_decode("".join(body) + "=" * needed)