bitlab 0.1.0__py3-none-any.whl

bitlab/__init__.py

@@ -0,0 +1,18 @@
+"""bitlab: a toolkit for embedded systems, binary data, and digital
+communications.
+
+Organized as submodules by domain rather than one flat namespace:
+
+    from bitlab.parity import get_parity_bit, encode_hamming, decode_hamming
+    from bitlab.crc import crc8, crc16, crc32, explain, export_c
+    from bitlab.bitutils import popcount, rotate_left, reflect
+
+`import bitlab` alone also gives you `bitlab.parity`, `bitlab.crc`, and
+`bitlab.bitutils` as attributes, e.g. `bitlab.crc.crc32(b"...")`.
+"""
+
+from . import bitutils, crc, parity
+
+__version__ = "0.1.0"
+
+__all__ = ["bitutils", "parity", "crc", "__version__"]

bitlab/bitutils/__init__.py

@@ -0,0 +1,25 @@
+"""Foundational bit-manipulation helpers used across bitlab's submodules."""
+
+from .core import (
+    flip_bit,
+    get_bit,
+    has_odd_parity,
+    popcount,
+    random_bit_position,
+    reflect,
+    rotate_left,
+    rotate_right,
+    set_bit,
+)
+
+__all__ = [
+    "popcount",
+    "has_odd_parity",
+    "get_bit",
+    "set_bit",
+    "flip_bit",
+    "reflect",
+    "rotate_left",
+    "rotate_right",
+    "random_bit_position",
+]

bitlab/bitutils/core.py

@@ -0,0 +1,73 @@
+"""Low-level bit helpers shared across every bitlab submodule.
+
+These are foundational operations used by parity, crc, and future
+submodules (register field mapping, endianness, etc).
+"""
+
+from __future__ import annotations
+
+import random
+
+
+def popcount(n: int) -> int:
+    """Counts the number of 1-bits in a non-negative integer."""
+    if n < 0:
+        raise ValueError("popcount expects a non-negative integer")
+    return bin(n).count("1")
+
+
+def has_odd_parity(n: int) -> bool:
+    """Returns True if `n` has an odd number of 1-bits."""
+    return popcount(n) % 2 == 1
+
+
+def get_bit(n: int, position: int) -> int:
+    """Extracts the bit at `position` (0 = least significant) from `n`."""
+    return (n >> position) & 1
+
+
+def set_bit(n: int, position: int, bit: int) -> int:
+    """Returns a copy of `n` with the bit at `position` set to `bit` (0 or 1)."""
+    if bit:
+        return n | (1 << position)
+    return n & ~(1 << position)
+
+
+def flip_bit(n: int, position: int) -> int:
+    """Flips (inverts) the bit at `position` in `n`."""
+    return n ^ (1 << position)
+
+
+def reflect(value: int, width: int) -> int:
+    """Reverses the lowest `width` bits of `value` (bit-mirror).
+
+    Used throughout CRC algorithms (refin/refout) and relevant to Gray-code
+    style bit-order tricks. Example: reflect(0b1100, 4) -> 0b0011.
+    """
+    result = 0
+    for _ in range(width):
+        result = (result << 1) | (value & 1)
+        value >>= 1
+    return result
+
+
+def rotate_left(value: int, amount: int, width: int) -> int:
+    """Rotates `value` left by `amount` bits within a `width`-bit register."""
+    amount %= width
+    mask = (1 << width) - 1
+    value &= mask
+    return ((value << amount) | (value >> (width - amount))) & mask
+
+
+def rotate_right(value: int, amount: int, width: int) -> int:
+    """Rotates `value` right by `amount` bits within a `width`-bit register."""
+    amount %= width
+    mask = (1 << width) - 1
+    value &= mask
+    return ((value >> amount) | (value << (width - amount))) & mask
+
+
+def random_bit_position(width: int) -> int:
+    """Returns a random bit position in [0, width) using the `random` module
+    (not cryptographically secure)."""
+    return random.randrange(width)

bitlab/cli.py

@@ -0,0 +1,157 @@
+"""Unified command-line interface for bitlab.
+
+Usage:
+    bitlab parity bit <value> [--type even|odd] [--width N]
+    bitlab parity append <value> [--type even|odd] [--width N]
+    bitlab parity check <value> [--type even|odd] [--width N]
+
+    bitlab hamming encode <4bitValue>
+    bitlab hamming decode <7bitCodeword>
+
+    bitlab crc compute <data> [--preset crc8|crc16-ccitt|crc16-modbus|crc32] [--hex]
+    bitlab crc explain <data> [--preset ...] [--hex]
+    bitlab crc export-c [--preset ...] [--name FN_NAME]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from dataclasses import asdict
+
+from .crc.engine import compute
+from .crc.codegen import export_c as crc_export_c
+from .crc.explain import explain as crc_explain
+from .crc.presets import PRESETS
+from .parity.hamming import decode_hamming, encode_hamming
+from .parity.parity import ParityType, append_parity, check_parity, get_parity_bit
+
+
+def _parse_number(token: str) -> int:
+    """Parses a decimal, 0b-binary, or 0x-hex integer literal."""
+    return int(token, 0) if token.lower().startswith(("0b", "0x", "0o")) else int(token)
+
+
+def _parse_crc_data(value: str, as_hex: bool) -> bytes:
+    if as_hex:
+        cleaned = value.replace(" ", "").replace("0x", "")
+        return bytes.fromhex(cleaned)
+    return value.encode("utf-8")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bitlab",
+        description="Toolkit for parity, Hamming codes, and CRC — computation, "
+        "explanation, and C code export.",
+    )
+    subparsers = parser.add_subparsers(dest="group")
+
+    # --- parity ---
+    parity_parser = subparsers.add_parser("parity", help="Parity bit tools")
+    parity_sub = parity_parser.add_subparsers(dest="command")
+
+    def add_parity_args(sub: argparse.ArgumentParser) -> None:
+        sub.add_argument("value", type=str, help="Integer value (decimal, 0b, or 0x)")
+        sub.add_argument("--type", choices=["even", "odd"], default="even")
+        sub.add_argument("--width", type=int, default=8)
+
+    add_parity_args(parity_sub.add_parser("bit", help="Print the parity bit for a value"))
+    add_parity_args(parity_sub.add_parser("append", help="Append a parity bit to a value"))
+    add_parity_args(
+        parity_sub.add_parser("check", help="Check parity of a value with parity bit appended")
+    )
+
+    # --- hamming ---
+    hamming_parser = subparsers.add_parser("hamming", help="Hamming(7,4) error correction")
+    hamming_sub = hamming_parser.add_subparsers(dest="command")
+    encode_p = hamming_sub.add_parser("encode", help="Encode a 4-bit value into a 7-bit codeword")
+    encode_p.add_argument("value", type=str)
+    decode_p = hamming_sub.add_parser("decode", help="Decode/correct a 7-bit codeword")
+    decode_p.add_argument("value", type=str)
+
+    # --- crc ---
+    crc_parser = subparsers.add_parser("crc", help="CRC compute / explain / export-c")
+    crc_sub = crc_parser.add_subparsers(dest="command")
+
+    compute_p = crc_sub.add_parser("compute", help="Compute a CRC")
+    compute_p.add_argument("data", type=str, help="Input data (UTF-8 text, or hex with --hex)")
+    compute_p.add_argument("--preset", choices=list(PRESETS), default="crc32")
+    compute_p.add_argument("--hex", action="store_true", help="Treat <data> as hex bytes")
+
+    explain_p = crc_sub.add_parser("explain", help="Step-by-step CRC trace")
+    explain_p.add_argument("data", type=str)
+    explain_p.add_argument("--preset", choices=list(PRESETS), default="crc32")
+    explain_p.add_argument("--hex", action="store_true")
+    explain_p.add_argument("--max-bytes", type=int, default=4)
+
+    export_p = crc_sub.add_parser("export-c", help="Export a CRC config as C source")
+    export_p.add_argument("--preset", choices=list(PRESETS), default="crc32")
+    export_p.add_argument("--name", type=str, default=None, help="C function name")
+
+    return parser
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    try:
+        return _main(argv)
+    except BrokenPipeError:
+        # Output was piped into something like `head` that closed early.
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        return 0
+
+
+def _main(argv: "list[str] | None") -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.group is None or getattr(args, "command", None) is None:
+        parser.print_help()
+        return 0 if args.group is None else 1
+
+    if args.group == "parity":
+        value = _parse_number(args.value)
+        type_: ParityType = args.type
+        width: int = args.width
+        if args.command == "bit":
+            print(get_parity_bit(value, type_, width))
+        elif args.command == "append":
+            result = append_parity(value, type_, width)
+            print(f"{result} (0b{result:b})")
+        elif args.command == "check":
+            print(check_parity(value, type_, width))
+        return 0
+
+    if args.group == "hamming":
+        value = _parse_number(args.value)
+        if args.command == "encode":
+            codeword = encode_hamming(value)
+            print(f"{codeword} (0b{codeword:07b})")
+        elif args.command == "decode":
+            result = decode_hamming(value)
+            print(json.dumps(asdict(result), indent=2))
+        return 0
+
+    if args.group == "crc":
+        config = PRESETS[args.preset]
+        if args.command == "compute":
+            data = _parse_crc_data(args.data, args.hex)
+            result = compute(data, config)
+            hexw = config.width // 4
+            print(f"0x{result:0{hexw}X} ({result})")
+        elif args.command == "explain":
+            data = _parse_crc_data(args.data, args.hex)
+            print(crc_explain(data, config, max_bytes=args.max_bytes))
+        elif args.command == "export-c":
+            print(crc_export_c(config, function_name=args.name))
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bitlab/crc/__init__.py

@@ -0,0 +1,52 @@
+"""CRC (Cyclic Redundancy Check) generation, checking, explanation, and C
+code export.
+
+Quick start:
+    >>> from bitlab.crc import crc32
+    >>> hex(crc32(b"123456789"))
+    '0xcbf43926'
+
+Custom polynomial:
+    >>> from bitlab.crc import crc, CRCConfig
+    >>> config = CRCConfig("my-crc", 16, 0x8005, 0xFFFF, True, True, 0x0000, 0x4B37)
+    >>> crc(b"123456789", config)
+
+Educational trace:
+    >>> from bitlab.crc import explain, CRC8_SMBUS
+    >>> print(explain(b"AB", CRC8_SMBUS))
+
+Export to C for firmware use:
+    >>> from bitlab.crc import export_c, CRC32_ISO_HDLC
+    >>> print(export_c(CRC32_ISO_HDLC))
+"""
+
+from .codegen import export_c
+from .engine import build_table, compute, compute_bitwise, compute_table, self_test
+from .explain import explain
+from .functions import crc, crc8, crc16, crc32
+from .presets import (
+    CRC8_SMBUS,
+    CRC16_CCITT_FALSE,
+    CRC16_MODBUS,
+    CRC32_ISO_HDLC,
+    CRCConfig,
+)
+
+__all__ = [
+    "CRCConfig",
+    "CRC8_SMBUS",
+    "CRC16_CCITT_FALSE",
+    "CRC16_MODBUS",
+    "CRC32_ISO_HDLC",
+    "crc",
+    "crc8",
+    "crc16",
+    "crc32",
+    "compute",
+    "compute_bitwise",
+    "compute_table",
+    "build_table",
+    "self_test",
+    "explain",
+    "export_c",
+]

bitlab/crc/codegen.py

@@ -0,0 +1,91 @@
+"""Export a CRC configuration as standalone, table-driven C source.
+
+This is what turns bitlab from "a Python learning tool" into something an
+embedded developer actually keeps: design/verify a CRC in Python, then drop
+the generated C straight into a firmware project. The lookup table embedded
+in the generated code is built by the exact same `engine.build_table` used
+by bitlab's own fast Python path, so the C output and the Python output are
+guaranteed to agree.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..bitutils import reflect
+from .engine import build_table
+from .presets import CRCConfig
+
+_C_TYPE_BY_WIDTH = {8: "uint8_t", 16: "uint16_t", 32: "uint32_t"}
+
+
+def _sanitize_identifier(name: str) -> str:
+    ident = re.sub(r"[^0-9a-zA-Z_]", "_", name.lower())
+    ident = re.sub(r"_+", "_", ident).strip("_")
+    if ident and ident[0].isdigit():
+        ident = f"_{ident}"
+    return ident or "crc"
+
+
+def export_c(config: CRCConfig, function_name: str = None) -> str:
+    """Returns standalone C source (C99) implementing `config` as a
+    table-driven CRC function with an embedded 256-entry lookup table.
+
+    Args:
+        config: The CRC configuration to export.
+        function_name: Optional explicit C function name. Defaults to a
+            sanitized version of `config.name` (e.g. "CRC-32/ISO-HDLC" ->
+            "crc_32_iso_hdlc").
+    """
+    if config.width not in _C_TYPE_BY_WIDTH:
+        raise ValueError(
+            f"export_c only supports width 8, 16, or 32 (got {config.width})"
+        )
+
+    ctype = _C_TYPE_BY_WIDTH[config.width]
+    fn_name = function_name or _sanitize_identifier(config.name)
+    hexw = config.width // 4
+    table = build_table(config)
+
+    rows = []
+    for i in range(0, 256, 8):
+        row = ", ".join(f"0x{v:0{hexw}X}" for v in table[i : i + 8])
+        rows.append("    " + row + ",")
+    table_str = "\n".join(rows)
+
+    if config.refin:
+        init_val = reflect(config.init, config.width)
+        body = (
+            f"    {ctype} crc = 0x{init_val:0{hexw}X}U;\n"
+            f"    for (size_t i = 0; i < len; i++) {{\n"
+            f"        uint8_t idx = (uint8_t)(crc ^ data[i]);\n"
+            f"        crc = (crc >> 8) ^ {fn_name}_table[idx];\n"
+            f"    }}\n"
+            f"    return (crc ^ 0x{config.xorout:0{hexw}X}U);"
+        )
+    else:
+        shift = config.width - 8
+        body = (
+            f"    {ctype} crc = 0x{config.init:0{hexw}X}U;\n"
+            f"    for (size_t i = 0; i < len; i++) {{\n"
+            f"        uint8_t idx = (uint8_t)((crc >> {shift}) ^ data[i]);\n"
+            f"        crc = (crc << 8) ^ {fn_name}_table[idx];\n"
+            f"    }}\n"
+            f"    return (crc ^ 0x{config.xorout:0{hexw}X}U);"
+        )
+
+    return (
+        f"/* Generated by bitlab.crc.codegen.export_c -- {config.name}\n"
+        f" * width={config.width} poly=0x{config.poly:0{hexw}X} init=0x{config.init:0{hexw}X}\n"
+        f" * refin={config.refin} refout={config.refout} xorout=0x{config.xorout:0{hexw}X}\n"
+        f" */\n"
+        f"#include <stdint.h>\n"
+        f"#include <stddef.h>\n\n"
+        f"static const {ctype} {fn_name}_table[256] = {{\n"
+        f"{table_str}\n"
+        f"}};\n\n"
+        f"{ctype} {fn_name}(const uint8_t *data, size_t len)\n"
+        f"{{\n"
+        f"{body}\n"
+        f"}}\n"
+    )

bitlab/crc/engine.py

@@ -0,0 +1,134 @@
+"""Generic, parameterized CRC engine.
+
+Implements the standard "Rocksoft model" CRC algorithm: any CRC (CRC-8,
+CRC-16, CRC-32, ...) can be described by (width, poly, init, refin, refout,
+xorout). Two computation strategies are provided:
+
+- `compute_bitwise`: the canonical, easy-to-verify reference algorithm.
+  Processes one bit at a time. This is what `CRCConfig.check` is validated
+  against, and what `explain()` walks through step by step.
+- `compute_table`: a table-driven implementation (the same algorithm real
+  hardware/firmware uses for speed). The lookup table is also what
+  `codegen.export_c()` embeds in the generated C source, so the Python fast
+  path and the exported C code are built from the exact same table.
+
+Both strategies are cross-validated against each other and against published
+CRC-catalogue check values in the test suite.
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from ..bitutils import reflect
+from .presets import CRCConfig
+
+
+def compute_bitwise(data: bytes, config: CRCConfig) -> int:
+    """Computes a CRC using the canonical bit-by-bit algorithm.
+
+    This is the reference implementation: simple enough to read and trust,
+    at the cost of processing 8 shifts per input byte instead of 1 table
+    lookup. Fine for typical prototyping payloads; use `compute_table` (or
+    just `compute`, which picks the fast path automatically) for large data.
+    """
+    width = config.width
+    mask = (1 << width) - 1
+    topbit = 1 << (width - 1)
+    reg = config.init & mask
+
+    for byte in data:
+        b = reflect(byte, 8) if config.refin else byte
+        reg ^= (b << (width - 8)) & mask
+        for _ in range(8):
+            if reg & topbit:
+                reg = ((reg << 1) ^ config.poly) & mask
+            else:
+                reg = (reg << 1) & mask
+
+    if config.refout:
+        reg = reflect(reg, width)
+    return (reg ^ config.xorout) & mask
+
+
+def build_table(config: CRCConfig) -> List[int]:
+    """Builds the 256-entry lookup table for `config`.
+
+    Two distinct table algorithms exist depending on whether the CRC
+    processes bits MSB-first (refin=False) or LSB-first (refin=True); this
+    picks the correct one automatically. The returned table is exactly what
+    `codegen.export_c` embeds in generated C source.
+    """
+    width = config.width
+    mask = (1 << width) - 1
+
+    if config.refin:
+        rpoly = reflect(config.poly, width)
+        table = []
+        for i in range(256):
+            reg = i
+            for _ in range(8):
+                if reg & 1:
+                    reg = (reg >> 1) ^ rpoly
+                else:
+                    reg = reg >> 1
+            table.append(reg & mask)
+        return table
+
+    topbit = 1 << (width - 1)
+    table = []
+    for i in range(256):
+        reg = i << (width - 8)
+        for _ in range(8):
+            if reg & topbit:
+                reg = ((reg << 1) ^ config.poly) & mask
+            else:
+                reg = (reg << 1) & mask
+        table.append(reg & mask)
+    return table
+
+
+def compute_table(data: bytes, config: CRCConfig, table: List[int] = None) -> int:
+    """Computes a CRC using a lookup table (builds one if not supplied).
+
+    Pass a pre-built table (from `build_table`) when computing many CRCs
+    with the same config to avoid rebuilding it each call.
+    """
+    width = config.width
+    mask = (1 << width) - 1
+    if table is None:
+        table = build_table(config)
+
+    if config.refin:
+        reg = reflect(config.init & mask, width)
+        for byte in data:
+            idx = (reg ^ byte) & 0xFF
+            reg = ((reg >> 8) ^ table[idx]) & mask
+        return (reg ^ config.xorout) & mask
+
+    reg = config.init & mask
+    shift = width - 8
+    for byte in data:
+        idx = ((reg >> shift) ^ byte) & 0xFF
+        reg = ((reg << 8) ^ table[idx]) & mask
+    if config.refout:
+        reg = reflect(reg, width)
+    return (reg ^ config.xorout) & mask
+
+
+def compute(data: bytes, config: CRCConfig) -> int:
+    """Computes a CRC using the fast table-driven path. This is what the
+    `crc8`/`crc16`/`crc32` convenience functions and the generic `crc()`
+    function call."""
+    return compute_table(data, config)
+
+
+def self_test(config: CRCConfig) -> bool:
+    """Verifies `config` against its known check value (CRC of b"123456789"),
+    using both the bitwise and table-driven implementations. Returns True
+    only if both agree with `config.check`."""
+    check_input = b"123456789"
+    return (
+        compute_bitwise(check_input, config) == config.check
+        and compute_table(check_input, config) == config.check
+    )

bitlab/crc/explain.py

@@ -0,0 +1,79 @@
+"""Human-readable, step-by-step CRC trace — the educational counterpart to
+the fast `compute()` path.
+
+`explain()` runs the exact same bitwise algorithm as `engine.compute_bitwise`
+(this is not a separate/approximate explanation — it's the real computation
+with a narration attached), so what a student reads here is guaranteed to
+match what the fast path actually computes.
+"""
+
+from __future__ import annotations
+
+from ..bitutils import reflect
+from .presets import CRCConfig
+
+
+def explain(data: bytes, config: CRCConfig, max_bytes: int = 4) -> str:
+    """Returns a step-by-step trace of computing the CRC of `data` under
+    `config`.
+
+    Args:
+        data: The bytes to checksum.
+        config: The CRC configuration to explain.
+        max_bytes: Show detailed per-byte register state for at most this
+            many leading bytes, then summarize the rest (keeps the trace
+            readable for longer payloads).
+    """
+    width = config.width
+    mask = (1 << width) - 1
+    topbit = 1 << (width - 1)
+    hexw = width // 4
+    reg = config.init & mask
+
+    lines = []
+    lines.append(f"CRC algorithm: {config.name}")
+    lines.append(
+        f"  width={width}  poly=0x{config.poly:0{hexw}X}  init=0x{config.init:0{hexw}X}  "
+        f"refin={config.refin}  refout={config.refout}  xorout=0x{config.xorout:0{hexw}X}"
+    )
+    lines.append("")
+    lines.append(f"Input bytes ({len(data)} total): {data[:16].hex(' ')}" + (" ..." if len(data) > 16 else ""))
+    lines.append("")
+    lines.append(f"Initial register: 0x{reg:0{hexw}X}")
+
+    for i, byte in enumerate(data):
+        b = reflect(byte, 8) if config.refin else byte
+        reg ^= (b << (width - 8)) & mask
+
+        if i < max_bytes:
+            note = " (bit-reversed for refin)" if config.refin else ""
+            lines.append("")
+            lines.append(f"Byte {i}: 0x{byte:02X}{note} -> XORed in, register = 0x{reg:0{hexw}X}")
+
+        for bit_num in range(8):
+            if reg & topbit:
+                reg = ((reg << 1) ^ config.poly) & mask
+                bit_note = "MSB=1 -> shift left, XOR polynomial"
+            else:
+                reg = (reg << 1) & mask
+                bit_note = "MSB=0 -> shift left"
+            if i < max_bytes:
+                lines.append(f"    bit {bit_num}: {bit_note} -> 0x{reg:0{hexw}X}")
+
+        if i == max_bytes and len(data) > max_bytes:
+            lines.append("")
+            lines.append(f"... ({len(data) - max_bytes} more bytes processed the same way) ...")
+
+    lines.append("")
+    lines.append(f"Register after all bytes: 0x{reg:0{hexw}X}")
+
+    if config.refout:
+        reg = reflect(reg, width)
+        lines.append(f"refout=True -> bit-reverse register: 0x{reg:0{hexw}X}")
+
+    result = (reg ^ config.xorout) & mask
+    lines.append(f"XOR with xorout (0x{config.xorout:0{hexw}X}): 0x{result:0{hexw}X}")
+    lines.append("")
+    lines.append(f"Final CRC: 0x{result:0{hexw}X}")
+
+    return "\n".join(lines)

bitlab/crc/functions.py

@@ -0,0 +1,59 @@
+"""Convenience functions for the common CRC variants, plus a generic
+parameterized entry point for custom polynomials."""
+
+from __future__ import annotations
+
+from typing import Union
+
+from .engine import compute
+from .presets import (
+    CRC8_SMBUS,
+    CRC16_CCITT_FALSE,
+    CRC16_MODBUS,
+    CRC32_ISO_HDLC,
+    CRCConfig,
+)
+
+
+def crc8(data: bytes) -> int:
+    """CRC-8/SMBUS of `data`."""
+    return compute(data, CRC8_SMBUS)
+
+
+def crc16(data: bytes, variant: str = "ccitt") -> int:
+    """CRC-16 of `data`.
+
+    Args:
+        variant: 'ccitt' (CRC-16/CCITT-FALSE, default) or 'modbus'
+            (CRC-16/MODBUS, used by the Modbus protocol).
+    """
+    if variant == "ccitt":
+        return compute(data, CRC16_CCITT_FALSE)
+    if variant == "modbus":
+        return compute(data, CRC16_MODBUS)
+    raise ValueError(f"Unknown CRC-16 variant: {variant!r} (expected 'ccitt' or 'modbus')")
+
+
+def crc32(data: bytes) -> int:
+    """CRC-32/ISO-HDLC of `data` (the CRC used by Ethernet, zlib, PNG)."""
+    return compute(data, CRC32_ISO_HDLC)
+
+
+def crc(data: bytes, config: Union[CRCConfig, str]) -> int:
+    """Generic CRC entry point.
+
+    Args:
+        data: The bytes to checksum.
+        config: Either a `CRCConfig` (for a fully custom polynomial) or the
+            name of a built-in preset: 'crc8', 'crc16-ccitt', 'crc16-modbus',
+            or 'crc32'.
+    """
+    if isinstance(config, str):
+        from .presets import PRESETS
+
+        if config not in PRESETS:
+            raise ValueError(
+                f"Unknown preset {config!r}. Available: {', '.join(PRESETS)}"
+            )
+        config = PRESETS[config]
+    return compute(data, config)

bitlab/crc/presets.py

@@ -0,0 +1,94 @@
+"""CRC configuration presets.
+
+Each preset's parameters (poly/init/refin/refout/xorout) and `check` value
+come from the standard CRC catalogue (the CRC of the ASCII string
+"123456789"). Every preset here is verified against that check value in the
+test suite via `bitlab.crc.engine.self_test`, so you can trust these match
+what real hardware/protocols expect — not just "a CRC that happens to run".
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CRCConfig:
+    """Parameters that fully define a CRC algorithm (the "Rocksoft model").
+
+    Attributes:
+        name: Human-readable name, e.g. "CRC-32/ISO-HDLC".
+        width: Register width in bits (8, 16, or 32).
+        poly: The generator polynomial, without its implicit leading term.
+        init: Initial register value.
+        refin: If True, each input byte is bit-reversed before processing.
+        refout: If True, the final register is bit-reversed before xorout.
+        xorout: Value XORed with the final register to produce the result.
+        check: The known-correct CRC of b"123456789" for this configuration,
+            used to self-test the engine against the published catalogue.
+    """
+
+    name: str
+    width: int
+    poly: int
+    init: int
+    refin: bool
+    refout: bool
+    xorout: int
+    check: int
+
+
+# CRC-8/SMBUS -- used in SMBus, some simple embedded checksums.
+CRC8_SMBUS = CRCConfig(
+    name="CRC-8/SMBUS",
+    width=8,
+    poly=0x07,
+    init=0x00,
+    refin=False,
+    refout=False,
+    xorout=0x00,
+    check=0xF4,
+)
+
+# CRC-16/CCITT-FALSE -- widely used in firmware/bootloader integrity checks.
+CRC16_CCITT_FALSE = CRCConfig(
+    name="CRC-16/CCITT-FALSE",
+    width=16,
+    poly=0x1021,
+    init=0xFFFF,
+    refin=False,
+    refout=False,
+    xorout=0x0000,
+    check=0x29B1,
+)
+
+# CRC-16/MODBUS -- the CRC used by the Modbus serial protocol.
+CRC16_MODBUS = CRCConfig(
+    name="CRC-16/MODBUS",
+    width=16,
+    poly=0x8005,
+    init=0xFFFF,
+    refin=True,
+    refout=True,
+    xorout=0x0000,
+    check=0x4B37,
+)
+
+# CRC-32/ISO-HDLC -- the "standard" CRC-32 used by Ethernet, zlib/gzip, PNG.
+CRC32_ISO_HDLC = CRCConfig(
+    name="CRC-32/ISO-HDLC",
+    width=32,
+    poly=0x04C11DB7,
+    init=0xFFFFFFFF,
+    refin=True,
+    refout=True,
+    xorout=0xFFFFFFFF,
+    check=0xCBF43926,
+)
+
+PRESETS = {
+    "crc8": CRC8_SMBUS,
+    "crc16-ccitt": CRC16_CCITT_FALSE,
+    "crc16-modbus": CRC16_MODBUS,
+    "crc32": CRC32_ISO_HDLC,
+}

bitlab/parity/__init__.py

@@ -0,0 +1,27 @@
+"""Parity bit checking and Hamming(7,4) single-bit error correction."""
+
+from .hamming import HammingDecodeResult, decode_hamming, encode_hamming
+from .parity import (
+    ParityType,
+    append_parity,
+    check_parity,
+    check_parity_array,
+    compute_message_parity,
+    flip_random_bit,
+    generate_parity_array,
+    get_parity_bit,
+)
+
+__all__ = [
+    "ParityType",
+    "get_parity_bit",
+    "append_parity",
+    "check_parity",
+    "generate_parity_array",
+    "check_parity_array",
+    "compute_message_parity",
+    "flip_random_bit",
+    "HammingDecodeResult",
+    "encode_hamming",
+    "decode_hamming",
+]

bitlab/parity/hamming.py

@@ -0,0 +1,110 @@
+"""Hamming(7,4) single-error-correcting code.
+
+Encodes 4 data bits into a 7-bit codeword using 3 parity bits, positioned
+(1-indexed) as:
+    bit 1 = p1, bit 2 = p2, bit 3 = d1, bit 4 = p3, bit 5 = d2, bit 6 = d3, bit 7 = d4
+
+p1 covers bits 1,3,5,7
+p2 covers bits 2,3,6,7
+p3 covers bits 4,5,6,7
+
+This is the classic textbook layout, so codewords produced here match what
+you'd compute by hand on paper.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class HammingDecodeResult:
+    """Result of decoding a 7-bit Hamming codeword."""
+
+    data: int
+    """The 4 recovered data bits, packed as d1d2d3d4 -> value 0-15."""
+
+    error_position: int
+    """1-indexed position of the corrected bit, or 0 if no error was found."""
+
+    corrected: bool
+    """True if a single-bit error was detected (and corrected)."""
+
+    codeword: int
+    """The (possibly corrected) 7-bit codeword."""
+
+
+def _bit_at(codeword: int, position_1_indexed: int) -> int:
+    # Bit 1 (1-indexed) is stored as the MSB of a 7-bit value.
+    shift = 7 - position_1_indexed
+    return (codeword >> shift) & 1
+
+
+def _with_bit(codeword: int, position_1_indexed: int, bit: int) -> int:
+    shift = 7 - position_1_indexed
+    if bit:
+        return codeword | (1 << shift)
+    return codeword & ~(1 << shift)
+
+
+def encode_hamming(data: int) -> int:
+    """Encodes 4 data bits (0-15, interpreted as d1 d2 d3 d4 MSB-first) into
+    a 7-bit Hamming codeword."""
+    if data < 0 or data > 0b1111:
+        raise ValueError("encode_hamming expects a 4-bit value (0-15)")
+
+    d1 = (data >> 3) & 1
+    d2 = (data >> 2) & 1
+    d3 = (data >> 1) & 1
+    d4 = data & 1
+
+    codeword = 0
+    codeword = _with_bit(codeword, 3, d1)
+    codeword = _with_bit(codeword, 5, d2)
+    codeword = _with_bit(codeword, 6, d3)
+    codeword = _with_bit(codeword, 7, d4)
+
+    p1 = d1 ^ d2 ^ d4  # covers 1,3,5,7
+    p2 = d1 ^ d3 ^ d4  # covers 2,3,6,7
+    p3 = d2 ^ d3 ^ d4  # covers 4,5,6,7
+
+    codeword = _with_bit(codeword, 1, p1)
+    codeword = _with_bit(codeword, 2, p2)
+    codeword = _with_bit(codeword, 4, p3)
+
+    return codeword
+
+
+def decode_hamming(codeword: int) -> HammingDecodeResult:
+    """Decodes a 7-bit Hamming codeword, detecting and correcting a
+    single-bit error if present."""
+    if codeword < 0 or codeword > 0b1111111:
+        raise ValueError("decode_hamming expects a 7-bit value (0-127)")
+
+    bits = [0] + [_bit_at(codeword, i) for i in range(1, 8)]
+
+    c1 = bits[1] ^ bits[3] ^ bits[5] ^ bits[7]
+    c2 = bits[2] ^ bits[3] ^ bits[6] ^ bits[7]
+    c3 = bits[4] ^ bits[5] ^ bits[6] ^ bits[7]
+
+    error_position = (c1 << 0) | (c2 << 1) | (c3 << 2)
+
+    corrected = False
+    fixed_codeword = codeword
+    if error_position != 0:
+        bad_bit = _bit_at(codeword, error_position)
+        fixed_codeword = _with_bit(codeword, error_position, bad_bit ^ 1)
+        corrected = True
+
+    d1 = _bit_at(fixed_codeword, 3)
+    d2 = _bit_at(fixed_codeword, 5)
+    d3 = _bit_at(fixed_codeword, 6)
+    d4 = _bit_at(fixed_codeword, 7)
+    data = (d1 << 3) | (d2 << 2) | (d3 << 1) | d4
+
+    return HammingDecodeResult(
+        data=data,
+        error_position=error_position,
+        corrected=corrected,
+        codeword=fixed_codeword,
+    )

bitlab/parity/parity.py

@@ -0,0 +1,89 @@
+"""Parity bit generation, appending, and checking for integers, sequences,
+and strings."""
+
+from __future__ import annotations
+
+from typing import List, Literal, Sequence
+
+from ..bitutils import flip_bit, get_bit, popcount, random_bit_position, set_bit
+
+ParityType = Literal["even", "odd"]
+
+
+def get_parity_bit(value: int, type: ParityType = "even", bit_width: int = 8) -> int:
+    """Computes the parity bit needed so that `value`'s 1-bit count (over
+    `bit_width` bits) plus the parity bit satisfies the requested parity type.
+
+    Args:
+        value: The data value to compute parity for.
+        type: 'even' (default) or 'odd'.
+        bit_width: Number of bits of `value` to consider (default 8).
+    """
+    mask = (1 << bit_width) - 1
+    ones = popcount(value & mask)
+    is_odd = ones % 2 == 1
+
+    if type == "even":
+        return 1 if is_odd else 0
+    return 0 if is_odd else 1
+
+
+def append_parity(value: int, type: ParityType = "even", bit_width: int = 8) -> int:
+    """Appends a parity bit to `value` as the most-significant bit (at
+    position `bit_width`), returning the combined (bit_width + 1)-bit value.
+
+    Example: append_parity(0b1011, 'even', 4) -> 0b11011 (parity bit = 1)
+    """
+    parity_bit = get_parity_bit(value, type, bit_width)
+    return set_bit(value, bit_width, parity_bit)
+
+
+def check_parity(
+    value_with_parity: int, type: ParityType = "even", bit_width: int = 8
+) -> bool:
+    """Checks whether `value_with_parity` (a value that includes its parity
+    bit at position `bit_width`) is internally consistent with the requested
+    parity type. Returns False if a (single-bit) error is detected.
+    """
+    data_mask = (1 << bit_width) - 1
+    data = value_with_parity & data_mask
+    parity_bit = get_bit(value_with_parity, bit_width)
+    expected = get_parity_bit(data, type, bit_width)
+    return parity_bit == expected
+
+
+def generate_parity_array(
+    values: Sequence[int], type: ParityType = "even", bit_width: int = 8
+) -> List[int]:
+    """Generates a parity bit for each value (bit_width-wide) in a sequence."""
+    return [get_parity_bit(v, type, bit_width) for v in values]
+
+
+def check_parity_array(
+    values_with_parity: Sequence[int], type: ParityType = "even", bit_width: int = 8
+) -> List[bool]:
+    """Checks parity for a sequence of values that already include their
+    parity bit (see append_parity). Returns a list of booleans, one per input
+    value."""
+    return [check_parity(v, type, bit_width) for v in values_with_parity]
+
+
+def compute_message_parity(message: str, type: ParityType = "even") -> int:
+    """Computes a single overall parity bit for a whole message (string),
+    based on the total 1-bit count across all UTF-8 code units. Useful as a
+    cheap, whole-message integrity check (NOT a substitute for a real
+    checksum/CRC on anything that matters).
+    """
+    ones = sum(popcount(b) for b in message.encode("utf-8"))
+    is_odd = ones % 2 == 1
+    if type == "even":
+        return 1 if is_odd else 0
+    return 0 if is_odd else 1
+
+
+def flip_random_bit(value: int, bit_width: int = 8) -> int:
+    """Flips a random bit within the lowest `bit_width` bits of `value`.
+    Handy for simulating a single-bit transmission error when testing
+    parity/Hamming code."""
+    position = random_bit_position(bit_width)
+    return flip_bit(value, position)

bitlab-0.1.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: bitlab
+Version: 0.1.0
+Summary: A toolkit for embedded systems, binary data, and digital communications: parity, Hamming codes, and CRC — with C code export.
+Project-URL: Homepage, https://github.com/KenKambi/bitlab
+Project-URL: Issues, https://github.com/KenKambi/bitlab/issues
+License: MIT
+License-File: LICENSE
+Keywords: bit-manipulation,c-code-generation,crc,crc16,crc32,crc8,embedded,error-correction,error-detection,hamming-code,parity,serial,uart
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# bitlab
+
+[![CI](https://github.com/KenKambi/bitlab/actions/workflows/ci.yml/badge.svg)](https://github.com/KenKambi/bitlab/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/bitlab.svg)](https://pypi.org/project/bitlab/)
+
+A toolkit for embedded systems, binary data, and digital communications.
+
+Built around the topics an Electronic & Computer Engineering degree
+actually covers: digital logic, computer architecture, embedded systems,
+and communications. Each domain is a self-contained submodule, so the
+package can keep growing without becoming a junk drawer.
+
+- Zero dependencies
+- Type-hinted (PEP 561, ships a `py.typed` marker)
+- One CLI: `bitlab`
+- Production functions **and** step-by-step educational explanations, side by side
+- CRC configs export directly to compiled, table-driven C — the same table your Python code uses
+
+```
+bitlab/
+├── bitutils/   # foundational bit ops used by every other submodule
+├── parity/     # parity bit checking + Hamming(7,4) error correction
+└── crc/        # CRC-8/16/32, generic engine, explain(), export_c()
+```
+
+## Install
+
+```bash
+pip install bitlab
+```
+
+## `bitlab.crc` — CRC generation, checking, explanation, and C export
+
+```python
+from bitlab.crc import crc8, crc16, crc32
+
+crc8(b"hello")              # CRC-8/SMBUS
+crc16(b"hello")             # CRC-16/CCITT-FALSE (default)
+crc16(b"hello", variant="modbus")  # CRC-16/MODBUS
+crc32(b"hello")              # CRC-32/ISO-HDLC (Ethernet, zlib, PNG)
+```
+
+Every built-in preset is verified against its published CRC-catalogue check
+value (the CRC of `b"123456789"`) in the test suite — these aren't "a CRC
+that happens to run", they match what real hardware and protocols expect.
+
+### Custom polynomials
+
+```python
+from bitlab.crc import crc, CRCConfig
+
+my_crc = CRCConfig(
+    name="my-custom-crc",
+    width=16, poly=0x8005, init=0xFFFF,
+    refin=True, refout=True, xorout=0x0000,
+    check=0x4B37,  # CRC of b"123456789", for self-testing your config
+)
+crc(b"some data", my_crc)
+```
+
+### Step-by-step explanation (the same computation, narrated)
+
+```python
+from bitlab.crc import explain, CRC8_SMBUS
+
+print(explain(b"AB", CRC8_SMBUS))
+```
+
+```
+CRC algorithm: CRC-8/SMBUS
+  width=8  poly=0x07  init=0x00  refin=False  refout=False  xorout=0x00
+
+Input bytes (2 total): 41 42
+
+Initial register: 0x00
+
+Byte 0: 0x41 -> XORed in, register = 0x41
+    bit 0: MSB=0 -> shift left -> 0x82
+    bit 1: MSB=1 -> shift left, XOR polynomial -> 0x03
+    ...
+
+Final CRC: 0x87
+```
+
+`explain()` runs the real bitwise algorithm with a narration attached — it's
+not a separate simplified explanation, so what you read is guaranteed to
+match what `crc8`/`crc16`/`crc32` actually compute.
+
+### Export to C
+
+```python
+from bitlab.crc import export_c, CRC32_ISO_HDLC
+
+print(export_c(CRC32_ISO_HDLC, function_name="my_crc32"))
+```
+
+```c
+#include <stdint.h>
+#include <stddef.h>
+
+static const uint32_t my_crc32_table[256] = {
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, ...
+};
+
+uint32_t my_crc32(const uint8_t *data, size_t len)
+{
+    uint32_t crc = 0xFFFFFFFFU;
+    for (size_t i = 0; i < len; i++) {
+        uint8_t idx = (uint8_t)(crc ^ data[i]);
+        crc = (crc >> 8) ^ my_crc32_table[idx];
+    }
+    return (crc ^ 0xFFFFFFFFU);
+}
+```
+
+The exported table is built by the exact same code Python's fast path
+uses — the test suite actually compiles the generated C with `gcc` and
+checks the output against the CRC catalogue, so this isn't just
+"code that looks right."
+
+## `bitlab.parity` — parity bits and Hamming(7,4)
+
+```python
+from bitlab.parity import get_parity_bit, append_parity, check_parity
+
+get_parity_bit(0b1011, "even", 4)      # -> 1
+append_parity(0b1011, "even", 4)       # -> 0b11011
+check_parity(0b11011, "even", 4)       # -> True
+```
+
+```python
+from bitlab.parity import encode_hamming, decode_hamming
+
+codeword = encode_hamming(0b1101)
+corrupted = codeword ^ 0b0000100        # simulate a single-bit flip
+result = decode_hamming(corrupted)
+# HammingDecodeResult(data=13, error_position=6, corrected=True, codeword=...)
+```
+
+See the full parity/Hamming API reference at the bottom of this file.
+
+## `bitlab.bitutils` — shared low-level bit helpers
+
+```python
+from bitlab.bitutils import popcount, reflect, rotate_left, rotate_right
+
+popcount(0b1011)           # -> 3
+reflect(0b1100, 4)         # -> 0b0011 (bit-mirror, used internally by crc)
+rotate_left(0b10000001, 1, 8)   # -> 0b00000011
+```
+
+## CLI
+
+```bash
+bitlab parity bit 0b1011 --type even --width 4
+# -> 1
+
+bitlab hamming encode 13
+# -> 85 (0b1010101)
+
+bitlab crc compute "123456789" --preset crc32
+# -> 0xCBF43926 (3421780262)
+
+bitlab crc explain "AB" --preset crc8
+# -> step-by-step trace
+
+bitlab crc export-c --preset crc32 --name my_crc32
+# -> C source on stdout
+```
+
+Run `bitlab --help`, `bitlab crc --help`, etc. for full usage.
+
+## API reference
+
+### `bitlab.crc`
+
+| Function | Description |
+|---|---|
+| `crc8(data)` | CRC-8/SMBUS. |
+| `crc16(data, variant="ccitt")` | CRC-16/CCITT-FALSE or CRC-16/MODBUS. |
+| `crc32(data)` | CRC-32/ISO-HDLC (Ethernet/zlib/PNG). |
+| `crc(data, config)` | Generic entry point. `config` is a `CRCConfig` or a preset name string. |
+| `explain(data, config, max_bytes=4)` | Step-by-step trace of the computation. |
+| `export_c(config, function_name=None)` | Table-driven C99 source implementing `config`. |
+| `build_table(config)` | The 256-entry lookup table (also used internally and by `export_c`). |
+| `compute_bitwise(data, config)` | Canonical bit-by-bit reference implementation. |
+| `compute_table(data, config, table=None)` | Fast table-driven implementation. |
+| `self_test(config)` | Verifies a config against its `check` value. |
+| `CRCConfig` | Dataclass: `name, width, poly, init, refin, refout, xorout, check`. |
+| `CRC8_SMBUS`, `CRC16_CCITT_FALSE`, `CRC16_MODBUS`, `CRC32_ISO_HDLC` | Built-in preset configs. |
+
+### `bitlab.parity`
+
+| Function | Description |
+|---|---|
+| `get_parity_bit(value, type="even", bit_width=8)` | Computes the parity bit for `value`. |
+| `append_parity(value, type="even", bit_width=8)` | Returns `value` with a parity bit appended as bit `bit_width`. |
+| `check_parity(value_with_parity, type="even", bit_width=8)` | Returns `True` if the parity bit matches the data. |
+| `generate_parity_array(values, type="even", bit_width=8)` | Parity bit for each value in a sequence. |
+| `check_parity_array(values_with_parity, type="even", bit_width=8)` | Parity check for each value in a sequence. |
+| `compute_message_parity(message, type="even")` | Single overall parity bit for a whole string. |
+| `flip_random_bit(value, bit_width=8)` | Flips one random bit — useful for simulating errors in tests. |
+| `encode_hamming(data)` | Encodes a 4-bit value (0–15) into a 7-bit Hamming codeword. |
+| `decode_hamming(codeword)` | Decodes a 7-bit codeword, correcting a single-bit error if present. |
+
+### `bitlab.bitutils`
+
+| Function | Description |
+|---|---|
+| `popcount(n)` | Number of 1-bits. |
+| `has_odd_parity(n)` | True if `n` has an odd number of 1-bits. |
+| `get_bit` / `set_bit` / `flip_bit` | Single-bit read/write/toggle. |
+| `reflect(value, width)` | Bit-mirror the lowest `width` bits. |
+| `rotate_left` / `rotate_right` | Bitwise rotation within a fixed-width register. |
+
+## Roadmap
+
+Planned next:
+
+- **Register field mapper** — define a hardware register's bit layout in
+  Python, pack/unpack values, export to C `#define`s or a bitfield struct.
+- **Computer architecture toolkit** — IEEE 754 float deconstruction,
+  endianness swapping, Gray code, Q-format fixed-point conversion.
+- **COBS framing** — Consistent Overhead Byte Stuffing for serial protocols.
+- **Reed-Solomon** — burst error correction (QR codes, satellite comms) —
+  planned as a later, dedicated release given its complexity.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest              # run the test suite (56 tests, including compiling
+                     # and running the generated C against gcc)
+python -m build      # produce a wheel + sdist in dist/
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full dev workflow and release
+process, and [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## License
+
+MIT

bitlab-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+bitlab/__init__.py,sha256=Y9cj8jKfiQDXFAFLWTmR4wb1dwJs-qL-teUARnqRAuc,616
+bitlab/cli.py,sha256=lJDBOYguT4LKT9yIch3lyrYILAAqWai17ubhPWoBaKw,6005
+bitlab/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bitlab/bitutils/__init__.py,sha256=eUQrAL2utxzy_3XzeT1O4tSZLrgaQQouUEvWeSYEiJ4,427
+bitlab/bitutils/core.py,sha256=rTNfPF7uaJw6wNOnXnSZwp3xPnOaqormMiQCtQA2kHg,2214
+bitlab/crc/__init__.py,sha256=E7A21HYGLT2ckhABUgxkss1OIzSWoGXe7VGGzpa98Xk,1217
+bitlab/crc/codegen.py,sha256=iXOvGEGMpr3rOpF22EdqpZ25mCwq29Zg-lGeS_obtAQ,3339
+bitlab/crc/engine.py,sha256=OCUfAkblvpXHmA5Tfe0T5qhfWgwdztITUulHwlKr7AI,4611
+bitlab/crc/explain.py,sha256=lIwCv-McnDnMCBWgCaY6LeBzyk2Jzotyd73kObScY4M,2952
+bitlab/crc/functions.py,sha256=s3kDPhMS--qqA6aFpN4tyLCp8N3BsNAkQ6sAFWaAcx8,1665
+bitlab/crc/presets.py,sha256=M84YVRAlzpGudKBQavYJombtKosTsfYG6fxeeiNjmk4,2479
+bitlab/parity/__init__.py,sha256=aUjmhVdLDr6uzlAOgQOeCG4xmpDM4Fgr2IQBqfgTqGY,618
+bitlab/parity/hamming.py,sha256=VB5HROfOI4S99q-ByqC8XyYsahZ3CdYG-sRpxUHyadQ,3257
+bitlab/parity/parity.py,sha256=wa_ChuLzJ0BGGrMxte9CiQJyIP6jMfDcmXApV83lwX0,3342
+bitlab-0.1.0.dist-info/METADATA,sha256=dcu-x1B_6W6ekWPovY7_7iGFmLaWjjOV3duaJCwsHfc,9254
+bitlab-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+bitlab-0.1.0.dist-info/entry_points.txt,sha256=2kxt8uDPirHOjiI3pKConKVOedj9jfQDl0XbHOD2_yg,43
+bitlab-0.1.0.dist-info/licenses/LICENSE,sha256=3F_ETwL5bPb1_XAbkPVss05-xZbSWuBf0f4tsiQld_g,1066
+bitlab-0.1.0.dist-info/RECORD,,

bitlab-0.1.0.dist-info/WHEEL

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

bitlab-0.1.0.dist-info/entry_points.txt

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

bitlab-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ken Kambi
+
+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.