nix-base32 0.4.2__py3-none-any.whl

base32/__init__.py

@@ -0,0 +1,47 @@
+"""Pure-Python implementation of the Nix-style base32 codec.
+
+The interface is two functions—:func:`encode` and :func:`decode`.
+The codec generally follows upstream implementation (in Nix source tree)
+
+The Nix base32 variant differs from RFC 4648 base32:
+letters *e*, *o*, *u*, and *t* are omitted.
+
+Example
+-------
+
+>>> from base32 import encode, decode
+>>> s = encode(b"hello")
+>>> s
+NixBase32Str('nbswy3dp')
+>>> decode(s)
+b'hello'
+
+The :class:`~base32.detail.types.NixBase32Str` type is returned to
+ensure all encoded representations are valid according to Nix alphabet.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("nix-base32")
+except PackageNotFoundError:
+    from typing import Final
+
+    __version__: Final[str] = "dev"
+
+
+from .decode import decode, decode_iter, decode_stream, decode_to_stream
+from .detail import NixBase32Str
+from .encode import encode, encode_iter, encode_stream, encode_to_stream
+
+__all__ = [
+    "NixBase32Str",
+    "decode",
+    "decode_iter",
+    "decode_stream",
+    "decode_to_stream",
+    "encode",
+    "encode_iter",
+    "encode_stream",
+    "encode_to_stream",
+]

base32/cli/__init__.py

@@ -0,0 +1,32 @@
+"""CLI interface."""
+
+import click
+
+from .. import __version__
+from . import ops
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]}, invoke_without_command=True)
+@click.version_option(__version__, "--version", "-v")
+@click.option("-d", "decode", is_flag=True, help="Decode input.")
+@click.option(
+    "--sri",
+    is_flag=True,
+    help="Decode input, producing output in SRI format if the digest matches a known hash length.",
+)
+@click.option(
+    "-i", "--input", is_flag=False, default="-", help='input file (default: "-" for stdin)'
+)
+@click.option(
+    "-o", "--output", is_flag=False, default="-", help='output file (default: "-" for stdout)'
+)
+def base32(input: str, output: str, decode: bool, sri: bool) -> None:
+    """
+    The base32 utility acts as a Nix base32 variant decoder when passed the --decode (or -d) flag and as
+    a Nix base32 encoder otherwise.
+    """
+
+    if decode or sri:
+        ops.decode(input, output, sri)
+    else:
+        ops.encode(input, output)

base32/cli/__main__.py

@@ -0,0 +1,9 @@
+"""Entry point for running the CLI as a module.
+
+Allows invocation via: python -m base32.cli
+"""
+
+from . import base32
+
+if __name__ == "__main__":
+    base32()

base32/cli/io.py

@@ -0,0 +1,26 @@
+import sys
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, TextIO, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+@contextmanager
+def infile(name: str) -> Iterator[TextIO]:
+    """Yield a readable text stream for a filename or stdin if '-'."""
+    if name == "-":
+        yield cast("TextIO", sys.stdin)
+    else:
+        with open(name, encoding="utf-8") as f:
+            yield f
+
+
+@contextmanager
+def outfile(name: str) -> Iterator[TextIO]:
+    """Yield a writable text stream for a filename or stdout if '-'."""
+    if name == "-":
+        yield cast("TextIO", sys.stdout)
+    else:
+        with open(name, "w", encoding="utf-8") as f:
+            yield f

base32/cli/ops.py

@@ -0,0 +1,100 @@
+import re
+import sys
+import base64
+import binascii
+
+import click
+
+import base32
+
+from .io import infile, outfile
+
+# Expected hash lengths for SRI validation
+SRI_HASH_LENGTHS: dict[str, int] = {
+    "sha256": 32,
+    "sha384": 48,
+    "sha512": 64,
+}
+
+
+def encode(input: str, output: str) -> None:
+    """Reads input and writes Nix base32 output
+
+    :param input: input filename or '-' for stdin
+    :type input: str
+    :param output: output filename or '-' for stdout
+    :type output: str
+    """
+
+    data: str
+
+    with infile(input) as f:
+        data = f.read().strip()
+
+    # if data is SRI hash (e.g., sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=)
+    if m := re.match(
+        r"^(sha256|sha384|sha512)-((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?)$",
+        data,
+    ):
+        hash_type = m.group(1)
+        payload = base64.b64decode(m.group(2))
+
+        # Validate hash length matches algorithm
+        expected_len = SRI_HASH_LENGTHS[hash_type]
+        if len(payload) != expected_len:
+            click.echo(
+                f"error: {hash_type} hash must be {expected_len} bytes, got {len(payload)}",
+                err=True,
+            )
+            sys.exit(1)
+    else:
+        if not re.fullmatch(r"[0-9a-fA-F]+", data):
+            click.echo("error: only hex or SRI input supported", err=True)
+            sys.exit(1)
+        payload = binascii.unhexlify(data)
+
+    with outfile(output) as f:
+        f.write(base32.encode(payload))
+
+
+def decode(input: str, output: str, sri: bool) -> None:
+    """Reads Nix base32 input and writes decoded output
+
+    :param input: input filename or '-' for stdin
+    :type input: str
+    :param output: output filename or '-' for stdout
+    :type output: str
+    :param sri: if set
+    :type sri: bool
+    """
+
+    data: str
+
+    with infile(input) as f:
+        data = f.read().strip()
+
+    try:
+        decoded = base32.decode(data)
+    except Exception as exc:
+        click.echo(f"decode error: {exc}", err=True)
+        sys.exit(1)
+
+    hexed = binascii.hexlify(decoded).decode("utf-8")
+
+    with outfile(output) as f:
+        if sri:
+            length = len(hexed)
+            prefix = {
+                64: "sha256",
+                96: "sha384",
+                128: "sha512",
+            }.get(length)
+
+            if prefix is None:
+                click.echo("SRI mode supported only for SHA256/384/512 digests", err=True)
+                sys.exit(1)
+
+            b64 = base64.b64encode(decoded).decode("utf-8")
+            f.write(f"{prefix}-{b64}")
+        else:
+            f.write(hexed)

base32/decode.py

@@ -0,0 +1,148 @@
+"""base32 decoding utility following the Nix variant.
+
+Implements :func:`decode`, the inverse of
+:func:`base32.encode`.
+"""
+
+from typing import TYPE_CHECKING, BinaryIO, TextIO
+
+from .detail import NixBase32Str, max_decoded_length, reverse_lookup
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def decode(s: str | NixBase32Str) -> bytes:
+    """Decode a Nix base32 string back into the original bytes.
+
+    The algorithm reverses :func:`base32.encode`, consuming bits
+    five at a time from LSB to MSB (right to left).
+
+    :param s: Nix base32 string to decode.
+    :type s: str | base32.detail.types.NixBase32Str
+    :returns: Original binary data represented by ``s``.
+    :rtype: bytes
+    :raises ValueError: If the string contains invalid base32 symbol(s).
+
+    :example:
+        >>> from base32 import encode, decode
+        >>> s = encode(b"hi")
+        >>> s
+        NixBase32Str('nbqwcid')
+        >>> decode(s)
+        b'hi'
+    """
+    if not s:
+        return b""
+
+    # Upper-bound capacity = ceil(len(s) * 5 / 8)
+    cap = max_decoded_length(len(s))
+    out = bytearray(cap)
+    used = 0
+
+    for n, ch in enumerate(reversed(s)):
+        digit = reverse_lookup(ch)
+        if digit is None:
+            raise ValueError(f"invalid character {ch!r}")
+
+        b = n * 5
+        i = b // 8
+        j = b % 8
+
+        out[i] = (out[i] | ((digit << j) & 0xFF)) & 0xFF
+        if used < i + 1:
+            used = i + 1
+
+        # If 5-bit group crosses byte boundary, spill over.
+        if j and (digit >> (8 - j)):
+            out[i + 1] = (out[i + 1] | (digit >> (8 - j))) & 0xFF
+            if used < i + 2:
+                used = i + 2
+
+    return bytes(out[:used])
+
+
+def decode_iter(s: str | NixBase32Str, chunk_size: int = 8192) -> Iterator[bytes]:
+    """Decode a Nix base32 string and yield output in chunks.
+
+    This is useful for memory-efficient writing of large decoded data.
+    The decoding itself requires the full input, but output is yielded
+    in manageable chunks.
+
+    :param s: Nix base32 string to decode.
+    :param chunk_size: Maximum bytes per yielded chunk.
+    :yields: Bytes chunks of the decoded output.
+    :raises ValueError: If the string contains invalid base32 symbol(s).
+
+    :example:
+        >>> for chunk in decode_iter("0" * 1000, chunk_size=100):
+        ...     print(len(chunk))  # Each chunk <= 100 bytes
+    """
+    decoded = decode(s)
+    for i in range(0, len(decoded), chunk_size):
+        yield decoded[i : i + chunk_size]
+
+
+def decode_to_stream(
+    s: str | NixBase32Str,
+    writer: BinaryIO,
+    *,
+    chunk_size: int = 8192,
+) -> int:
+    """Decode a Nix base32 string and write to a binary stream.
+
+    :param s: Nix base32 string to decode.
+    :param writer: Binary stream to write decoded output to.
+    :param chunk_size: Write buffer size in bytes.
+    :returns: Number of bytes written.
+    :raises ValueError: If the string contains invalid base32 symbol(s).
+
+    :example:
+        >>> import io
+        >>> buf = io.BytesIO()
+        >>> decode_to_stream("nbswy3dp", buf)
+        5
+        >>> buf.getvalue()
+        b'hello'
+    """
+    written = 0
+    for chunk in decode_iter(s, chunk_size):
+        writer.write(chunk)
+        written += len(chunk)
+    return written
+
+
+def decode_stream(
+    reader: TextIO,
+    writer: BinaryIO,
+    *,
+    chunk_size: int = 8192,
+    strip: bool = True,
+) -> int:
+    """Read base32 text from a stream, decode, and write to binary stream.
+
+    .. note::
+        Due to the Nix base32 algorithm processing characters in reverse
+        order, the full input must be buffered before decoding.
+        This function provides streaming I/O but not streaming computation.
+
+    :param reader: Text stream to read base32 input from.
+    :param writer: Binary stream to write decoded output to.
+    :param chunk_size: I/O buffer size.
+    :param strip: Whether to strip whitespace from input (default True).
+    :returns: Number of bytes written.
+    :raises ValueError: If the input contains invalid base32 symbol(s).
+
+    :example:
+        >>> import io
+        >>> inp = io.StringIO("nbswy3dp")
+        >>> out = io.BytesIO()
+        >>> decode_stream(inp, out)
+        5
+        >>> out.getvalue()
+        b'hello'
+    """
+    data = reader.read()
+    if strip:
+        data = data.strip()
+    return decode_to_stream(data, writer, chunk_size=chunk_size)

base32/detail/__init__.py

@@ -0,0 +1,32 @@
+"""Low-level internal utilities for Nix-style base32 encoding and decoding.
+
+This subpackage provides fine-grained tools used by higher-level base32
+logic.  It encapsulates Nix-specific alphabet definitions, validation
+types, length computations, and fast reverse-lookup functionality.
+
+The exposed API is intentionally narrow—only stable primitives required
+by the public encoder/decoder surface are exported.
+
+Example usage::
+
+    from base32.detail import encoded_length, reverse_lookup
+
+    n = 16
+    print(f"{n} bytes -> roughly {encoded_length(n)} base32 chars")
+
+    digit = reverse_lookup("f")
+    print(f"Digit for 'f': {digit}")
+"""
+
+from .lengths import encoded_length, max_decoded_length
+from .reverse_lookup import reverse_lookup
+from .types import INVALID, NixBase32Str, charset
+
+__all__ = [
+    "INVALID",
+    "NixBase32Str",
+    "charset",
+    "encoded_length",
+    "max_decoded_length",
+    "reverse_lookup",
+]

base32/detail/lengths.py

@@ -0,0 +1,58 @@
+"""Length computation helpers for Nix base32 encoding.
+
+These functions mirror the capacity and sizing formulas used by the
+official Nix implementation. They allow callers to estimate the output
+length of encoded data or the maximum number of bytes that can be safely
+decoded from a given base32 representation.
+"""
+
+
+def encoded_length(n: int) -> int:
+    """Compute the number of Nix base32 characters required to encode ``n`` bytes.
+
+    The calculation uses the formula::
+
+        ceil((n * 8) / 5)
+
+    expressed in integer arithmetic as ``(n * 8 - 1) // 5 + 1``.
+    It ensures sufficient capacity even when input length isn't a multiple
+    of 5-bits.
+
+    :param n: Number of bytes in the input data.
+    :type n: int
+    :returns: Number of base32 characters required to represent the input.
+    :rtype: int
+
+    :example:
+        >>> encoded_length(1)
+        2
+        >>> encoded_length(5)
+        8
+    """
+    return (n * 8 - 1) // 5 + 1
+
+
+def max_decoded_length(n: int) -> int:
+    """Compute the maximum number of bytes that may decode from ``n`` base32 characters.
+
+    This mirrors the logic used in the Nix reference decoder:
+    ``ceil(n * 5 / 8)``.
+    It yields the upper bound of decoded bytes to aid buffer preallocation.
+
+    :param n: Number of base32 characters in the encoded input.
+    :type n: int
+    :returns: Maximum number of bytes that can be decoded.
+    :rtype: int
+
+    :example:
+        >>> max_decoded_length(2)
+        1
+        >>> max_decoded_length(8)
+        5
+
+    .. seealso::
+       **Nix reference implementation:**
+       https://github.com/NixOS/nix/blob/fb117e0cacc9b0bb29288ee9d3cb6dc0b5ff34a5/src/libutil/base-nix-32.cc#L45
+    """
+    # ceil(n * 5 / 8): capacity upper-bound used by the reference decoder
+    return (n * 5 + 7) // 8

base32/detail/reverse_lookup.py

@@ -0,0 +1,71 @@
+"""Reverse lookup utilities for the Nix-style base32 alphabet.
+
+Provides a table-based constant-time mapping from base32 characters back
+to their numeric digit values.
+Invalid characters are consistently mapped to the :data:`INVALID`
+sentinel value, enabling efficient checks during decoding.
+"""
+
+from .types import INVALID, charset
+
+
+def build_lookup_table() -> list[int]:
+    """Construct the ASCII lookup table for the Nix base32 alphabet.
+
+    Builds a 256-element array mapping every possible 8-bit character
+    to its corresponding base32 digit value or :data:`INVALID` if the
+    character is not part of the alphabet.
+
+    :returns:
+        Table of integer values indexed by character ordinal
+        (0..255).
+    :rtype: list[int]
+
+    .. important::
+       Called automatically at module import to initialize
+       :data:`lookup_table`. In normal use this function need not
+       be invoked manually.
+    """
+    result: list[int] = [INVALID] * 256
+    for i, ch in enumerate(charset):
+        result[ord(ch)] = i
+    return result
+
+
+lookup_table: list[int] = build_lookup_table()
+"""Prebuilt lookup table for ASCII → base32 digit mapping.
+
+This table is generated once at import time to provide constant-time
+access for all subsequent reverse lookups.
+
+:meta hide-value:
+"""
+
+
+def reverse_lookup(ch: str) -> int | None:
+    """Convert a Nix base32 character to its numeric digit index.
+
+    Uses :data:`lookup_table` for a direct translation of the character
+    to its digit value. Returns ``None`` for invalid characters.
+
+    :param ch: Single base32 character to convert.
+    :type ch: str
+    :returns:
+        Integer digit index (0..31) or ``None`` if invalid.
+    :rtype: int | None
+
+    :example:
+        >>> reverse_lookup("a")
+        10
+        >>> reverse_lookup("?")
+        None
+    """
+    if len(ch) != 1:
+        return None
+
+    codepoint = ord(ch)
+    if codepoint >= len(lookup_table):
+        return None
+
+    digit: int = lookup_table[codepoint]
+    return None if digit == INVALID else digit

base32/detail/types.py

@@ -0,0 +1,54 @@
+# fmt: off
+"""Type definitions and constants for Nix-style base32 encoding.
+
+Defines the Nix-specific alphabet, type aliases for valid characters and
+strings, and validation logic that ensures base32 strings contain only
+permitted symbols.
+
+The alphabet used here omits ambiguous letters ("e", "o", "u", "t") to
+reduce transcription errors, following the Nix convention.
+"""
+
+
+from typing import ClassVar, Literal, get_args
+
+INVALID: int = 0xFF
+"""Sentinel integer used for invalid base32 character mappings."""
+
+# Original reference:
+# https://github.com/NixOS/nix/blob/fb117e0cacc9b0bb29288ee9d3cb6dc0b5ff34a5/src/libutil/include/nix/util/base-nix-32.hh#L17
+# Note: 'e', 'o', 'u', 't' - omitted to avoid ambiguity.
+
+type NixBase32Charset = Literal["0123456789abcdfghijklmnpqrsvwxyz"]
+"""Literal of the full concatenated Nix base32 alphabet."""
+
+charset: NixBase32Charset = get_args(NixBase32Charset.__value__)[0]
+"""Canonical string representation of the Nix base32 alphabet, in order."""
+
+
+class NixBase32Str(str):
+    """Validated string subclass restricted to Nix base32 characters.
+
+    Instances of this class behave like built-in :class:`str` but cannot
+    contain invalid symbols. Construction will raise :class:`ValueError`
+    if the input includes any character not in the official Nix alphabet.
+
+    :param value: base32 string value to validate and store.
+    :type value: str
+    :raises ValueError: If the input contains any disallowed character.
+
+    :example:
+        >>> NixBase32Str("abc123")
+        'abc123'
+        >>> NixBase32Str("abcd$")  # invalid
+        Traceback (most recent call last):
+            ...
+        ValueError: Invalid Nix base32 string: abcd$
+    """
+
+    _allowed: ClassVar[set[str]] = set(charset)
+
+    def __new__(cls, value: str) -> NixBase32Str:  # noqa: PYI034
+        if not set(value) <= cls._allowed:
+            raise ValueError(f"Invalid Nix base32 string: {value}")
+        return super().__new__(cls, value)

base32/encode.py

@@ -0,0 +1,136 @@
+"""base32 encoding following the Nix variant semantics.
+
+This module defines :func:`encode`, which converts arbitrary byte
+strings into a :class:`~base32.detail.types.NixBase32Str`.
+
+The algorithm mirrors the Nix implementation.
+"""
+
+from typing import TYPE_CHECKING, BinaryIO, TextIO
+
+from .detail import NixBase32Str, charset, encoded_length
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def encode(bs: bytes) -> NixBase32Str:
+    """Encode a byte sequence into a Nix base32 string.
+
+    Each group of five bits in ``bs`` is mapped to a single
+    character from the Nix base32 alphabet. The result omits
+    padding characters and is guaranteed to roundtrip through
+    :func:`base32.decode`.
+
+    :param bs: Bytes to encode.
+    :type bs: bytes
+    :returns: base32 string representation.
+    :rtype: base32.detail.types.NixBase32Str
+
+    :example:
+        >>> from base32 import encode
+        >>> encode(b"foo")
+        NixBase32Str('mzxw6')
+        >>> encode(b"")
+        NixBase32Str('')
+    .. seealso::
+       **Nix reference implementation:**
+       https://github.com/NixOS/nix/blob/fb117e0cacc9b0bb29288ee9d3cb6dc0b5ff34a5/src/libutil/base-nix-32.cc#L20
+    """
+    if not bs:
+        return NixBase32Str("")
+
+    length = encoded_length(len(bs))
+    out: list[str] = []
+
+    #  Walk 5-bit groups from MSB to LSB.
+    for n in reversed(range(length)):
+        b = n * 5
+        i = b // 8
+        j = b % 8
+
+        b1 = bs[i]
+        b2 = bs[i + 1] if i + 1 < len(bs) else 0
+        c = ((b1 >> j) | ((b2 << (8 - j)) & 0xFF)) & 0xFF
+        out.append(charset[c & 0x1F])
+
+    return NixBase32Str("".join(out))
+
+
+def encode_iter(bs: bytes, chunk_size: int = 8192) -> Iterator[str]:
+    """Encode bytes and yield output in chunks.
+
+    This is useful for memory-efficient writing of large encoded data.
+    The encoding itself requires the full input, but output is yielded
+    in manageable chunks.
+
+    :param bs: Bytes to encode.
+    :param chunk_size: Maximum characters per yielded chunk.
+    :yields: String chunks of the encoded output.
+
+    :example:
+        >>> for chunk in encode_iter(b"hello" * 1000, chunk_size=100):
+        ...     print(len(chunk))  # Each chunk <= 100 chars
+    """
+    encoded = encode(bs)
+    for i in range(0, len(encoded), chunk_size):
+        yield str(encoded[i : i + chunk_size])
+
+
+def encode_to_stream(
+    bs: bytes,
+    writer: TextIO,
+    *,
+    chunk_size: int = 8192,
+) -> int:
+    """Encode bytes and write to a text stream.
+
+    :param bs: Bytes to encode.
+    :param writer: Text stream to write encoded output to.
+    :param chunk_size: Write buffer size in characters.
+    :returns: Number of characters written.
+
+    :example:
+        >>> import io
+        >>> buf = io.StringIO()
+        >>> encode_to_stream(b"hello", buf)
+        8
+        >>> buf.getvalue()
+        'nbswy3dp'
+    """
+    written = 0
+    for chunk in encode_iter(bs, chunk_size):
+        writer.write(chunk)
+        written += len(chunk)
+    return written
+
+
+def encode_stream(
+    reader: BinaryIO,
+    writer: TextIO,
+    *,
+    chunk_size: int = 8192,
+) -> int:
+    """Read binary data from a stream, encode, and write to text stream.
+
+    .. note::
+        Due to the Nix base32 algorithm processing bits in reverse order
+        (MSB to LSB), the full input must be buffered before encoding.
+        This function provides streaming I/O but not streaming computation.
+
+    :param reader: Binary stream to read input from.
+    :param writer: Text stream to write encoded output to.
+    :param chunk_size: I/O buffer size.
+    :returns: Number of characters written.
+
+    :example:
+        >>> import io
+        >>> inp = io.BytesIO(b"hello")
+        >>> out = io.StringIO()
+        >>> encode_stream(inp, out)
+        8
+        >>> out.getvalue()
+        'nbswy3dp'
+    """
+    data = reader.read()
+    return encode_to_stream(data, writer, chunk_size=chunk_size)

nix_base32-0.4.2.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: nix-base32
+Version: 0.4.2
+Summary: Pure Python implementation of nix variant of base32
+Author-email: "Peter A." <ink.splatters@pm.me>
+License: MIT License
+        
+        Copyright (c) 2025 Peter A.
+        
+        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.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.14
+Provides-Extra: cli
+Requires-Dist: click>=8.3.0; extra == 'cli'
+Description-Content-Type: text/markdown
+
+# nix‑base32
+
+Pure‑Python implementation of the Nix‑specific base32 variant.
+
+______________________________________________________________________
+
+## Installation
+
+```bash
+uv tool install 'nix-base32[cli] @ git+https://github.com/ink-splatters/nix-base32'
+```
+
+______________________________________________________________________
+
+## Usage
+
+### Python
+
+```python
+from base32 import encode, decode
+
+data = b"hello"
+encoded = encode(data)
+print(encoded)           # -> NixBase32Str('nbswy3dp')
+print(decode(encoded))   # -> b'hello'
+```
+
+### CLI
+
+the CLI was inspired by BSD bintrans' `base64` util (now part of standard macOS distribution).
+
+_Examples:_
+
+```bash
+❯ echo de2fc4ce5252da49a272fb22e68c73dcfa12ef08077ac26b40ad3a40dd31376e | base32
+0vip67fl0fmd81mw4yh713pi5ynwff6fc8pvfai4knjjab7c8byy
+
+❯ echo 0vip67fl0fmd81mw4yh713pi5ynwff6fc8pvfai4knjjab7c8byy | base32 --sri
+sha256-3i/EzlJS2kmicvsi5oxz3PoS7wgHesJrQK06QN0xN24=
+
+❯ echo de2fc4ce5252da49a272fb22e68c73dcfa12ef08077ac26b40ad3a40dd31376e | base32 | base32 -d
+de2fc4ce5252da49a272fb22e68c73dcfa12ef08077ac26b40ad3a40dd31376e
+```
+
+______________________________________________________________________
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Contributions
+
+Contributions are welcome at the author's discretion; please open an issue first.
+See any standard open collaborative code of conduct such as
+[Contributor Covenant](https://www.contributor-covenant.org/).

nix_base32-0.4.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+base32/__init__.py,sha256=BvePOqVgt46zTmg7LJp7PO2VvsMpyOWMSTH19qvKR30,1155
+base32/decode.py,sha256=qp29n0yHEDbDa3fTX8sPOYBZQ6eFhXGwl_twcvH3zLY,4381
+base32/encode.py,sha256=LWfjsb7JgwypuJvth6YdNUTbe3HxlMeUjEZZNzndB1c,3920
+base32/cli/__init__.py,sha256=UDzlMCCYAy7o0VUF_GHRU96KdXJoTbsclcgcK-Plgpg,1005
+base32/cli/__main__.py,sha256=mzo6ohPJvgG2zMydqiln_PAciPUryZoYmq8siMbJ4i4,160
+base32/cli/io.py,sha256=u19qO2EDiCCeL_G5-2k8xBpN33V6uF1ymlYI4nlDohk,704
+base32/cli/ops.py,sha256=x4uZT4jolIBileuB02-yzD-Yu2gaDeRtqHHHmb6F6Ms,2592
+base32/detail/__init__.py,sha256=lsyKSdi9neCLBh0uPOk-uqev7A81WkPSbwXOYO3oQi8,931
+base32/detail/lengths.py,sha256=vzWGO1xNymTd_astOuqB0O-hmmZQOinAm1RlhOHiiMQ,1788
+base32/detail/reverse_lookup.py,sha256=KPfqgJTMkbZ3XIxsiTj8MWc_OxMZG1mgQlc6RUJHigc,2035
+base32/detail/types.py,sha256=WxJiaiyazmEV7XOnumxYF978PBoihoxQNbIcY4S89bE,1966
+nix_base32-0.4.2.dist-info/METADATA,sha256=RPgIMsoN37nGNJpb7W1Y9fBAf6_g-Kq3QcLzfCLuYeA,3395
+nix_base32-0.4.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+nix_base32-0.4.2.dist-info/entry_points.txt,sha256=dFW5GNmB92k6Q-qAGYBsOueZPaJBAYjeS68gshohRCQ,45
+nix_base32-0.4.2.dist-info/licenses/LICENSE,sha256=yCbF7A9Qpm2aPKI-pOyuORXIcq_TAxy-4pD8pOOhfbU,1065
+nix_base32-0.4.2.dist-info/RECORD,,

nix_base32-0.4.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nix_base32-0.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+base32 = base32.cli:base32

nix_base32-0.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Peter A.
+
+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.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.