hexatess-code 0.1.0__py3-none-any.whl

hexatess/__init__.py

@@ -0,0 +1,83 @@
+"""Hexatess Code - an experimental 2D barcode on a hexagonal grid.
+
+Reference implementation of specification v0.1.  The symbol is a
+hexagonal lattice with a hexagonal bullseye finder, an
+orientation key ring, spiral serialization from the centre outwards,
+a Reed-Solomon protected header and a continuously selectable
+error-correction budget of 5-90 percent (Aztec-style).
+
+Quick start
+-----------
+>>> from hexatess import encode, decode, render
+>>> grid, params = encode("Hello, Hexatess!", ec_pct=30)
+>>> params["rmax"], params["mask"], params["data_len"]
+(11, 6, 16)
+>>> render(grid, "hello.png")
+'hello.png'
+>>> decode(grid)[0]
+'Hello, Hexatess!'
+
+See SPECIFICATION.md in the repository for the full format
+specification, and test_vectors/vectors_v0.1.json for conformance
+data usable by independent implementations.
+"""
+
+from __future__ import annotations
+
+from .decoder import decode
+from .encoder import encode
+from .geometry import (
+    DIRS,
+    hex_corner,
+    hex_distance,
+    hex_ring,
+    hex_to_pixel,
+    ring_capacity,
+)
+from .header import (
+    BULLSEYE_RINGS,
+    BLOCK_DATA_MAX,
+    DATA_RING0,
+    KEY_RING,
+    MAX_DATA_BYTES,
+    MAX_EC_PCT,
+    MAX_RINGS,
+    MIN_EC_PCT,
+    MODE_BITS,
+    MODE_BYTES,
+    MODE_ECC,
+    bits_to_bytes,
+    bytes_to_bits,
+    pack_mode,
+    plan_blocks,
+    unpack_mode,
+)
+from .masks import evaluate_mask, mask_bit, mask_payload, select_mask
+from .reedsolomon import rs_correct_msg, rs_encode_msg
+from .render import render, sample_grid_from_image
+from .resilience import add_blob_damage, add_random_noise, run_tests
+
+__version__ = "0.1.0"
+SPEC_VERSION = "0.1"
+
+__all__ = [
+    # high-level API
+    "encode", "decode", "render", "sample_grid_from_image",
+    "run_tests", "add_random_noise", "add_blob_damage",
+    # geometry
+    "DIRS", "hex_ring", "hex_distance", "hex_to_pixel", "hex_corner",
+    "ring_capacity",
+    # framing
+    "bytes_to_bits", "bits_to_bytes", "pack_mode", "unpack_mode",
+    "plan_blocks",
+    # masks
+    "mask_bit", "mask_payload", "evaluate_mask", "select_mask",
+    # error correction
+    "rs_encode_msg", "rs_correct_msg",
+    # constants
+    "BULLSEYE_RINGS", "KEY_RING", "DATA_RING0", "MAX_RINGS",
+    "BLOCK_DATA_MAX", "MODE_BYTES", "MODE_ECC", "MODE_BITS",
+    "MIN_EC_PCT", "MAX_EC_PCT", "MAX_DATA_BYTES",
+    # meta
+    "__version__", "SPEC_VERSION",
+]

hexatess/cli.py

@@ -0,0 +1,65 @@
+"""Command-line interface for Hexatess Code.
+
+Examples
+--------
+Encode text to PNG::
+
+    hexatess-code "Hello world" -o koda.png --ec 30
+
+Render a demo symbol and run robustness tests::
+
+    hexatess-code --demo
+    hexatess-code --test
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from .decoder import decode
+from .encoder import encode
+from .render import render, sample_grid_from_image
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="hexatess",
+        description="Hexatess Code - hexagonal-grid 2D barcode "
+                    "(reference implementation, spec v0.1)")
+    ap.add_argument("text", nargs="?", help="text to encode (UTF-8)")
+    ap.add_argument("-o", "--output", default="hexatess.png",
+                    help="output PNG path (default: %(default)s)")
+    ap.add_argument("--ec", type=int, default=30,
+                    help="error-correction %% (5-90, step 5; default 30)")
+    ap.add_argument("--mask", type=int, default=None, metavar="0-7",
+                    help="force a mask instead of automatic selection")
+    ap.add_argument("--size", type=int, default=18,
+                    help="hex radius in pixels (default %(default)s)")
+    ap.add_argument("--test", action="store_true",
+                    help="run robustness tests")
+    ap.add_argument("--demo", action="store_true",
+                    help="render a demo symbol and run robustness tests")
+    args = ap.parse_args(argv)
+
+    if args.test or args.demo:
+        from .resilience import run_tests
+        run_tests()
+
+    if args.demo or args.text:
+        text = args.text or "Hexatess Code v0.1 - " * 6
+        grid, params = encode(text, ec_pct=args.ec, mask_id="auto"
+                              if args.mask is None else args.mask)
+        render(grid, args.output, size_px=args.size)
+        print("\nRendered: %s" % args.output)
+        print("  version (rings): %d, EC: %d%%, mask: %d, bytes: %d"
+              % (params["rmax"], params["ec"], params["mask"],
+                 params["data_len"]))
+        grid2 = sample_grid_from_image(args.output, params["rmax"],
+                                       size_px=args.size)
+        t, _st = decode(grid2)
+        print("  self-decode from image: %s"
+              % ("OK" if t == text else "FAILED"))
+
+
+if __name__ == "__main__":
+    main()

hexatess/decoder.py

@@ -0,0 +1,75 @@
+"""Hexatess Code decoder (ideal-sampling reference).
+
+Accepts a module grid ``{(q, r): 0|1}`` (as produced by the encoder or
+sampled from an image) and returns the decoded UTF-8 text together with
+the header parameters.  Any symbol error correctable by Reed-Solomon is
+absorbed transparently.
+"""
+
+from __future__ import annotations
+
+from .geometry import hex_distance, hex_ring
+from .header import (
+    DATA_RING0,
+    MODE_BITS,
+    bits_to_bytes,
+    plan_blocks,
+    unpack_mode,
+)
+from .masks import mask_bit
+from .reedsolomon import rs_correct_msg
+
+
+def decode(grid, params=None):
+    """Decode a module grid into text.
+
+    Parameters
+    ----------
+    grid : dict
+        Mapping ``{(q, r): 0|1}``.
+    params : dict, optional
+        Ignored; kept for API symmetry with v0.1 of the prototype.
+
+    Returns
+    -------
+    (text, stats)
+        ``text`` is the decoded UTF-8 string; ``stats`` reports the
+        parameters read from the header (``rmax``, ``mask``, ``ec``,
+        ``blocks``, ``data_len``).
+    """
+    cells = sorted(grid.keys(), key=lambda c: hex_distance(*c))
+    rmax = max(hex_distance(*c) for c in cells)
+    data_cells = [c for k in range(DATA_RING0, rmax + 1)
+                  for c in hex_ring(k)]
+    bits = [grid[c] for c in data_cells]
+
+    # --- protected header
+    mode_bits = bits[:MODE_BITS]
+    mode = unpack_mode(bits_to_bytes(mode_bits))
+    rmax_m, mask_id, ec_pct, block_count, data_len = mode
+
+    # --- masked payload
+    payload_bits = bits[MODE_BITS:MODE_BITS + (data_len + sum(
+        e for _, e in plan_blocks(data_len, ec_pct))) * 8]
+    payload_bits = [b ^ mask_bit(i, mask_id)
+                    for i, b in enumerate(payload_bits)]
+    stream = bits_to_bytes(payload_bits)
+
+    # --- per-block Reed-Solomon correction
+    blocks = plan_blocks(data_len, ec_pct)
+    out = bytearray()
+    pos_d = 0
+    pos_e = 0
+    ecc_total = sum(e for _, e in blocks)
+    data_bytes = stream[:data_len]
+    ecc_bytes = stream[data_len:data_len + ecc_total]
+    for size, ecc in blocks:
+        cw = list(data_bytes[pos_d:pos_d + size]) + \
+             list(ecc_bytes[pos_e:pos_e + ecc])
+        out += bytes(rs_correct_msg(cw, ecc))
+        pos_d += size
+        pos_e += ecc
+    text = bytes(out).decode("utf-8")
+    stats = {"rmax": rmax_m, "mask": mask_id, "ec": ec_pct,
+             "blocks": block_count, "data_len": data_len}
+    return text, stats

hexatess/encoder.py

@@ -0,0 +1,122 @@
+"""Hexatess Code encoder.
+
+Turns UTF-8 text into a hexagonal module grid ``{(q, r): 0|1}``.
+
+Layout summary (specification v0.1):
+
+* rings 0..4 -- hexagonal bullseye finder, ring ``k`` filled with
+  ``k mod 2`` (bit 1 = dark module; the centre module is LIGHT in v0.1);
+* ring 5     -- orientation key: all modules light except the first two
+  cells of ``hex_ring(5)`` (``(-5, 5)`` and ``(-4, 5)``) which are dark;
+* rings 6..rmax -- payload bits in spiral order: header (80 bits,
+  unmasked) followed by the masked payload stream; unused tail cells
+  are padded with an alternating 0,1,... pattern.
+"""
+
+from __future__ import annotations
+
+from .geometry import hex_ring, ring_capacity
+from .header import (
+    BULLSEYE_RINGS,
+    DATA_RING0,
+    KEY_RING,
+    MAX_DATA_BYTES,
+    MAX_EC_PCT,
+    MAX_RINGS,
+    MIN_EC_PCT,
+    MODE_BITS,
+    bytes_to_bits,
+    pack_mode,
+    plan_blocks,
+)
+from .masks import select_mask
+from .reedsolomon import rs_encode_msg
+
+
+def encode(text: str, ec_pct: int = 30, mask_id="auto", min_rings=None):
+    """Encode UTF-8 ``text`` into a hexagonal grid.
+
+    Parameters
+    ----------
+    text : str
+        Payload, up to 4095 UTF-8 bytes.
+    ec_pct : int
+        Error-correction budget as a percentage of data bytes,
+        5..90 in steps of 5 (continuous Aztec-style choice).
+    mask_id : int | "auto"
+        Force a mask (0..7) or let the encoder pick the best.
+    min_rings : int | None
+        Force a minimum symbol radius (1..31), e.g. for uniform look.
+
+    Returns
+    -------
+    (grid, params)
+        ``grid`` maps axial coordinates ``(q, r)`` to 0/1.
+        ``params`` is a dict with keys ``rmax``, ``mask``, ``ec``,
+        ``blocks`` (list of ``(size, ecc)``) and ``data_len``.
+    """
+    if not MIN_EC_PCT <= ec_pct <= MAX_EC_PCT or ec_pct % 5:
+        raise ValueError(
+            "ec_pct must be %d..%d in steps of %d"
+            % (MIN_EC_PCT, MAX_EC_PCT, 5))
+    data = text.encode("utf-8")
+    if len(data) > MAX_DATA_BYTES:
+        raise ValueError(
+            "v0.1 supports up to %d bytes of data" % MAX_DATA_BYTES)
+    blocks = plan_blocks(len(data), ec_pct)
+    ecc_total = sum(e for _, e in blocks)
+    need_bits = MODE_BITS + (len(data) + ecc_total) * 8
+
+    rmax = max(DATA_RING0 + 1, min_rings or 0)
+    while ring_capacity(DATA_RING0, rmax) < need_bits:
+        rmax += 1
+        if rmax > MAX_RINGS:
+            raise ValueError("data does not fit (symbol too large)")
+
+    # --- payload (unmasked at this point): data of all blocks in order,
+    #     then ECC of all blocks in order.
+    payload = []
+    pos = 0
+    for size, _ in blocks:
+        for b in data[pos:pos + size]:
+            payload += bytes_to_bits([b])
+        pos += size
+    pos = 0
+    for size, ecc in blocks:
+        cw = rs_encode_msg(list(data[pos:pos + size]), ecc)
+        payload += bytes_to_bits(cw[size:])
+        pos += size
+    pad = ring_capacity(DATA_RING0, rmax) - MODE_BITS - len(payload)
+    payload += [i % 2 for i in range(pad)]
+
+    # --- mask selection (payload only; the header carries the mask id
+    #     and stays unmasked -- same approach as Aztec Code).
+    if mask_id == "auto":
+        payload, best_mask = select_mask(payload)
+    else:
+        from .masks import mask_payload
+        if not 0 <= mask_id <= 7:
+            raise ValueError("mask_id must be 0..7 or 'auto'")
+        payload = mask_payload(payload, mask_id)
+        best_mask = mask_id
+
+    # --- header with final mask id, then the full bitstream.
+    mode = pack_mode(rmax, best_mask, ec_pct, len(blocks), len(data))
+    bits = bytes_to_bits(mode) + payload
+
+    # --- place modules: bullseye + key + spiral payload.
+    data_cells = [c for k in range(DATA_RING0, rmax + 1)
+                  for c in hex_ring(k)]
+    grid = {}
+    for k in range(BULLSEYE_RINGS + 1):
+        for c in hex_ring(k):
+            grid[c] = k % 2          # centre LIGHT in v0.1, rings alternate
+    for c in hex_ring(KEY_RING):
+        grid[c] = 0
+    key = hex_ring(KEY_RING)
+    grid[key[0]] = 1                 # orientation key cell 1
+    grid[key[1]] = 1                 # orientation key cell 2 (adjacent)
+    for idx, c in enumerate(data_cells):
+        grid[c] = bits[idx] if idx < len(bits) else 0
+    return grid, {"rmax": rmax, "mask": best_mask, "ec": ec_pct,
+                  "blocks": blocks, "data_len": len(data)}

hexatess/galois.py

@@ -0,0 +1,82 @@
+"""GF(256) Galois field arithmetic for Hexatess Code.
+
+The field uses the primitive polynomial x^8 + x^4 + x^3 + x^2 + 1
+(0x11D) -- the same choice as QR Code and Aztec Code -- with generator
+alpha = 2.  Polynomials are represented as lists of integer coefficients
+in descending order of degree (coefficient list ``[a, b, c]`` means
+a*x^2 + b*x + c), except inside the Forney algorithm where an ascending
+order convention is used explicitly and documented.
+"""
+
+from __future__ import annotations
+
+GF_EXP = [0] * 512
+GF_LOG = [0] * 256
+
+_x = 1
+for _i in range(255):
+    GF_EXP[_i] = _x
+    GF_LOG[_x] = _i
+    _x <<= 1
+    if _x & 0x100:
+        _x ^= 0x11D
+for _i in range(255, 512):
+    GF_EXP[_i] = GF_EXP[_i - 255]
+
+PRIMITIVE_POLY = 0x11D
+
+
+def gf_mul(x: int, y: int) -> int:
+    """Multiply two field elements."""
+    if x == 0 or y == 0:
+        return 0
+    return GF_EXP[GF_LOG[x] + GF_LOG[y]]
+
+
+def gf_div(x: int, y: int) -> int:
+    """Divide two field elements (raises ZeroDivisionError on y == 0)."""
+    if y == 0:
+        raise ZeroDivisionError("division by zero in GF(256)")
+    if x == 0:
+        return 0
+    return GF_EXP[(GF_LOG[x] + 255 - GF_LOG[y]) % 255]
+
+
+def gf_inv(x: int) -> int:
+    """Multiplicative inverse of a non-zero field element."""
+    return GF_EXP[(255 - GF_LOG[x]) % 255]
+
+
+def gf_poly_scale(p, x):
+    """Multiply every coefficient of polynomial ``p`` by ``x``."""
+    return [gf_mul(c, x) for c in p]
+
+
+def gf_poly_add(p, q):
+    """Add two polynomials (descending coefficient order)."""
+    r = [0] * max(len(p), len(q))
+    for i, c in enumerate(p):
+        r[i + len(r) - len(p)] = c
+    for i, c in enumerate(q):
+        r[i + len(r) - len(q)] ^= c
+    return r
+
+
+def gf_poly_mul(p, q):
+    """Multiply two polynomials (descending coefficient order)."""
+    r = [0] * (len(p) + len(q) - 1)
+    for j, qj in enumerate(q):
+        for i, pi in enumerate(p):
+            r[i + j] ^= gf_mul(pi, qj)
+    return r
+
+
+def gf_poly_eval(p, x):
+    """Evaluate polynomial ``p`` at ``x`` using Horner's scheme.
+
+    ``p[0]`` is the highest-degree coefficient.
+    """
+    y = p[0]
+    for c in p[1:]:
+        y = gf_mul(y, x) ^ c
+    return y

hexatess/geometry.py

@@ -0,0 +1,69 @@
+"""Hexagonal grid geometry for Hexatess Code.
+
+The symbol is a hexagonal lattice of "pointy-top" hexagonal modules.
+Module positions use integer *axial coordinates* ``(q, r)``.  Rings are
+sets of cells at constant hex distance ``k`` from the origin; the cells
+within ring ``k`` total ``6k`` for ``k >= 1`` and the region within
+radius ``n`` contains ``3n(n+1) + 1`` cells (centered hexagonal numbers).
+"""
+
+from __future__ import annotations
+
+import math
+
+# Neighbour directions in axial coordinates, fixed traversal order.
+DIRS = [(1, 0), (1, -1), (0, -1), (-1, 0), (-1, 1), (0, 1)]
+
+
+def hex_ring(k: int):
+    """All cells at hex distance ``k`` from the origin, in canonical order.
+
+    The ring starts at cell ``(-k, +k)`` and then takes ``k`` steps in
+    each direction of ``DIRS`` in order, appending each visited cell.
+    """
+    if k == 0:
+        return [(0, 0)]
+    cells = []
+    q, r = -k, k          # start: direction 4 * k
+    for d in range(6):
+        for _ in range(k):
+            cells.append((q, r))
+            dq, dr = DIRS[d]
+            q += dq
+            r += dr
+    return cells
+
+
+def hex_distance(q: int, r: int) -> int:
+    """Hex distance of ``(q, r)`` from the origin."""
+    return max(abs(q), abs(r), abs(q + r))
+
+
+def hex_to_pixel(q, r, size):
+    """Pointy-top conversion: centre of a module in pixel coordinates.
+
+    ``x = size * sqrt(3) * (q + r/2)``, ``y = size * 1.5 * r``.
+    """
+    x = size * math.sqrt(3.0) * (q + r / 2.0)
+    y = size * 1.5 * r
+    return x, y
+
+
+def hex_corner(cx, cy, size, i):
+    """The i-th corner (i = 0..5) of the hexagon centred at (cx, cy).
+
+    Corners lie at angles 60*i - 30 degrees (pointy-top orientation).
+    """
+    ang = math.pi / 180.0 * (60.0 * i - 30.0)
+    return (cx + size * math.cos(ang), cy + size * math.sin(ang))
+
+
+def ring_capacity(r_from: int, r_to: int) -> int:
+    """Number of cells in rings ``r_from .. r_to`` inclusive.
+
+    Uses the centered-hexagonal-number identity:
+    cells within radius n = 3n(n+1) + 1.
+    """
+    if r_to < r_from:
+        return 0
+    return (3 * r_to * (r_to + 1) + 1) - (3 * (r_from - 1) * r_from + 1)

hexatess/header.py

@@ -0,0 +1,120 @@
+"""Symbol constants, header (mode message) handling and block planning."""
+
+from __future__ import annotations
+
+import math
+
+from .reedsolomon import rs_encode_msg, rs_correct_msg
+
+# ----------------------------------------------------------------------
+# Symbol constants (fixed in specification v0.1)
+# ----------------------------------------------------------------------
+
+BULLSEYE_RINGS = 4     # rings 0..4 form the hexagonal bullseye finder
+KEY_RING = 5           # ring 5 is the orientation key
+DATA_RING0 = 6         # payload serialization starts at ring 6
+MAX_RINGS = 31         # largest permitted symbol radius
+BLOCK_DATA_MAX = 50    # max data bytes per independent RS block
+MODE_BYTES = 5         # header payload length in bytes
+MODE_ECC = 5           # header ECC symbols (corrects up to 2 byte errors)
+MODE_BITS = (MODE_BYTES + MODE_ECC) * 8   # 80 bits
+
+MIN_EC_PCT = 5         # minimum error-correction percentage
+MAX_EC_PCT = 90        # maximum error-correction percentage
+EC_STEP = 5            # EC percentage must be a multiple of 5
+MAX_DATA_BYTES = 4095  # 12-bit length field
+
+
+# ----------------------------------------------------------------------
+# Bit/byte helpers
+# ----------------------------------------------------------------------
+
+def bytes_to_bits(data) -> list:
+    """MSB-first expansion of bytes into a list of 0/1 bits."""
+    bits = []
+    for b in data:
+        for i in range(7, -1, -1):
+            bits.append((b >> i) & 1)
+    return bits
+
+
+def bits_to_bytes(bits) -> bytes:
+    """Pack a list of bits (MSB first) into bytes.
+
+    Trailing bits fewer than 8 are ignored.
+    """
+    out = bytearray()
+    for i in range(0, len(bits) - 7, 8):
+        v = 0
+        for j in range(8):
+            v = (v << 1) | bits[i + j]
+        out.append(v)
+    return bytes(out)
+
+
+# ----------------------------------------------------------------------
+# Mode message (header): 5 data bytes + 5 ECC bytes, never masked
+#
+#   byte 0: rmax (5 bits)          | mask_id (3 bits)
+#   byte 1: ec_pct/5 (5 bits)      | block_count >> 5 (3 bits)
+#   byte 2: block_count & 0x1F (5) | data_len >> 9 (3 bits)
+#   byte 3: data_len >> 1 & 0xFF (8 bits)
+#   byte 4: data_len & 1 (1 bit, leftmost) | padding 0x00 (7 bits)
+# ----------------------------------------------------------------------
+
+def pack_mode(rmax, mask_id, ec_pct, block_count, data_len) -> bytes:
+    """Encode symbol parameters into a 10-byte protected mode message.
+
+    The returned bytes are the 5 data bytes followed by 5 Reed-Solomon
+    ECC bytes.  The mode message is NEVER masked (it contains the mask
+    identifier itself -- the same design decision as Aztec Code).
+    """
+    if rmax > 31 or mask_id > 7 or ec_pct % 5 or ec_pct // 5 > 31 \
+            or block_count > 255 or data_len > 4095:
+        raise ValueError("parameters out of mode-message range")
+    ecq = ec_pct // 5
+    b0 = (rmax << 3) | mask_id
+    b1 = (ecq << 3) | (block_count >> 5)
+    b2 = ((block_count & 0x1F) << 3) | ((data_len >> 9) & 0x7)
+    b3 = (data_len >> 1) & 0xFF
+    b4 = (data_len & 1) << 7
+    payload = bytes([b0, b1, b2, b3, b4])
+    return rs_encode_msg(list(payload), MODE_ECC)
+
+
+def unpack_mode(mode_bytes):
+    """RS-correct the mode message and decode symbol parameters.
+
+    Returns ``(rmax, mask_id, ec_pct, block_count, data_len)``.
+    """
+    data = rs_correct_msg(list(mode_bytes), MODE_ECC)
+    b0, b1, b2, b3, b4 = data
+    rmax = b0 >> 3
+    mask_id = b0 & 0x7
+    ecq = b1 >> 3
+    block_count = ((b1 & 0x7) << 5) | (b2 >> 3)
+    data_len = ((b2 & 0x7) << 9) | (b3 << 1) | (b4 >> 7)
+    return rmax, mask_id, ecq * 5, block_count, data_len
+
+
+# ----------------------------------------------------------------------
+# Block planning
+# ----------------------------------------------------------------------
+
+def plan_blocks(data_len: int, ec_pct: int):
+    """Split ``data_len`` bytes into independent RS blocks.
+
+    Returns a list of ``(data_bytes, ecc_bytes)`` pairs.  Blocks carry at
+    most ``BLOCK_DATA_MAX`` data bytes each.  ECC overhead per block is
+    ``ceil(size * ec_pct / 100)``, clamped to a minimum of 2 symbols.
+    """
+    if data_len == 0:
+        return [(0, 2)]
+    bc = max(1, math.ceil(data_len / BLOCK_DATA_MAX))
+    base, extra = divmod(data_len, bc)
+    blocks = []
+    for i in range(bc):
+        size = base + (1 if i < extra else 0)
+        ecc = max(2, math.ceil(size * ec_pct / 100.0))
+        blocks.append((size, min(ecc, 255 - size)))
+    return blocks

hexatess/masks.py

@@ -0,0 +1,48 @@
+"""Mask bit generation and automatic mask selection."""
+
+from __future__ import annotations
+
+
+def mask_bit(index: int, mask_id: int) -> int:
+    """Deterministic pseudo-random mask bit (32-bit LCG + xorshift).
+
+    The mask stream is a function of the payload bit position and the
+    mask identifier (0..7).  Masking applies to the payload ONLY; the
+    mode message is never masked (it carries the mask id itself).
+    """
+    x = (index * 1103515245 + 12345 + mask_id * 2654435761) & 0x7FFFFFFF
+    x ^= x >> 13
+    return (x >> 19) & 1
+
+
+def mask_payload(payload, mask_id: int):
+    """XOR ``payload`` bit-by-bit with mask stream ``mask_id``."""
+    return [b ^ mask_bit(i, mask_id) for i, b in enumerate(payload)]
+
+
+def evaluate_mask(masked) -> int:
+    """Penalty score of an already-masked bit list (lower is better).
+
+    Score = |2 * dark - total|  (balance penalty)
+          + count of adjacent equal-bit pairs  (repetition penalty).
+    """
+    score = abs(2 * sum(masked) - len(masked))
+    for i in range(1, len(masked)):
+        if masked[i] == masked[i - 1]:
+            score += 1
+    return score
+
+
+def select_mask(payload):
+    """Evaluate all 8 masks and return ``(masked_payload, mask_id)``.
+
+    Ties resolve to the lowest mask id, mirroring the reference
+    implementation.
+    """
+    best, best_id, best_score = None, 0, None
+    for m in range(8):
+        masked = mask_payload(payload, m)
+        score = evaluate_mask(masked)
+        if best_score is None or score < best_score:
+            best, best_id, best_score = masked, m, score
+    return best, best_id

hexatess/reedsolomon.py

@@ -0,0 +1,161 @@
+"""Systematic Reed-Solomon codec over GF(256) for Hexatess Code.
+
+Encoder: polynomial long division by the generator polynomial, producing
+``nsym`` trailing ECC symbols (systematic code, identical to the scheme
+used by QR Code and Aztec Code).
+
+Decoder: syndromes -> Berlekamp-Massey error locator -> Chien search for
+error positions -> Forney algorithm for error magnitudes.  The Forney
+step internally uses an ascending-order polynomial convention:
+
+    e_i = X_i * Omega(X_i^-1) / Lambda'(X_i^-1)
+"""
+
+from __future__ import annotations
+
+from .galois import (
+    GF_EXP,
+    gf_div,
+    gf_inv,
+    gf_mul,
+    gf_poly_add,
+    gf_poly_eval,
+    gf_poly_mul,
+    gf_poly_scale,
+)
+
+
+def rs_generator_poly(nsym: int):
+    """Generator polynomial prod_{i=0..nsym-1} (x - alpha^i)."""
+    g = [1]
+    for i in range(nsym):
+        g = gf_poly_mul(g, [1, GF_EXP[i]])
+    return g
+
+
+def rs_encode_msg(msg_in, nsym: int):
+    """Return ``msg_in`` followed by ``nsym`` ECC symbols."""
+    if len(msg_in) + nsym > 255:
+        raise ValueError(
+            "block too long for RS over GF(256): %d + %d > 255"
+            % (len(msg_in), nsym))
+    gen = rs_generator_poly(nsym)
+    msg_out = list(msg_in) + [0] * nsym
+    for i in range(len(msg_in)):
+        coef = msg_out[i]
+        if coef:
+            for j in range(1, len(gen)):
+                msg_out[i + j] ^= gf_mul(gen[j], coef)
+    return list(msg_in) + msg_out[len(msg_in):]
+
+
+def rs_calc_syndromes(msg, nsym):
+    """Evaluate the received word at alpha^0 .. alpha^(nsym-1)."""
+    return [gf_poly_eval(msg, GF_EXP[i]) for i in range(nsym)]
+
+
+def rs_find_error_locator(synd, nsym):
+    """Berlekamp-Massey: derive the error locator polynomial L(x)."""
+    err_loc = [1]
+    old_loc = [1]
+    for i in range(nsym):
+        delta = synd[i]
+        for j in range(1, len(err_loc)):
+            delta ^= gf_mul(err_loc[-(j + 1)], synd[i - j])
+        old_loc = old_loc + [0]
+        if delta != 0:
+            if len(old_loc) > len(err_loc):
+                new_loc = gf_poly_scale(old_loc, delta)
+                old_loc = gf_poly_scale(err_loc, gf_inv(delta))
+                err_loc = new_loc
+            err_loc = gf_poly_add(err_loc, gf_poly_scale(old_loc, delta))
+    while err_loc and err_loc[0] == 0:
+        del err_loc[0]
+    return err_loc
+
+
+def rs_find_errors(err_loc_rev, nmess):
+    """Chien search: positions of errors, counted from the start."""
+    errs = len(err_loc_rev) - 1
+    pos = []
+    for i in range(nmess):
+        if gf_poly_eval(err_loc_rev, GF_EXP[i % 255]) == 0:
+            pos.append(nmess - 1 - i)
+    if len(pos) != errs:
+        raise ValueError(
+            "Chien: found %d roots, expected %d" % (len(pos), errs))
+    return pos
+
+
+def rs_find_errata_locator(coef_pos):
+    """Errata locator in ascending order: prod (1 + X_i * x)."""
+    e_loc = [1]
+    for i in coef_pos:
+        e_loc = gf_poly_mul(e_loc, gf_poly_add([1], [GF_EXP[i], 0]))
+    return e_loc
+
+
+def rs_find_error_evaluator(synd_rev, err_loc, nsym):
+    """Error evaluator polynomial Omega = (S * Lambda) truncated to nsym."""
+    prod = gf_poly_mul(synd_rev, err_loc)
+    return prod[len(prod) - (nsym + 1):]
+
+
+def rs_correct_errata(msg_in, synd, err_pos):
+    """Forney algorithm (pure ascending convention).
+
+    e_i = X_i * Omega(X_i^-1) / Lambda'(X_i^-1).  All polynomials are
+    kept internally in ASCENDING order of degree.
+    """
+    nmess = len(msg_in)
+    coef_pos = [nmess - 1 - p for p in err_pos]
+    Xs = [GF_EXP[c % 255] for c in coef_pos]
+    nsym = len(synd)
+
+    # Lambda in ascending order: Pi(1 + X_i * x)
+    lam = rs_find_errata_locator(coef_pos)[::-1]
+
+    # Omega = (S * Lambda) mod x^nsym   (ascending)
+    omega = gf_poly_mul(list(synd), lam)[:nsym]
+
+    # formal derivative of Lambda: odd indices
+    lam_d = [0] * max(1, len(lam) - 1)
+    for i in range(1, len(lam)):
+        if i % 2 == 1:
+            lam_d[i - 1] = lam[i]
+
+    E = [0] * nmess
+    for i, Xi in enumerate(Xs):
+        Xi_inv = gf_inv(Xi)
+        num = gf_poly_eval(omega[::-1], Xi_inv)
+        den = gf_poly_eval(lam_d[::-1], Xi_inv)
+        E[err_pos[i]] = gf_div(gf_mul(Xi, num), den)
+    return [m ^ e for m, e in zip(msg_in, E)]
+
+
+def rs_correct_msg(msg_in, nsym):
+    """Correct up to floor(nsym/2) symbol errors in one block.
+
+    Returns the data symbols only.  Raises ValueError when the number of
+    errors exceeds the correction capacity (or decoding otherwise fails
+    to verify).
+    """
+    if len(msg_in) > 255:
+        raise ValueError("block too long for RS")
+    msg = list(msg_in)
+    synd = rs_calc_syndromes(msg, nsym)
+    if max(synd) == 0:
+        return msg[:-nsym]
+    err_loc = rs_find_error_locator(synd, nsym)
+    errs = len(err_loc) - 1
+    if errs == 0:
+        raise ValueError("RS: unexpected locator state")
+    if 2 * errs > nsym:
+        raise ValueError(
+            "RS: too many errors (%d errors, capacity %d)"
+            % (errs, nsym // 2))
+    err_pos = rs_find_errors(err_loc[::-1], len(msg))
+    msg = rs_correct_errata(msg, synd, err_pos)
+    if max(rs_calc_syndromes(msg, nsym)) != 0:
+        raise ValueError("RS: correction failed verification")
+    return msg[:-nsym]

hexatess/render.py

@@ -0,0 +1,75 @@
+"""PNG rendering and ideal re-sampling of Hexatess Code symbols."""
+
+from __future__ import annotations
+
+import math
+
+from .geometry import hex_corner, hex_distance, hex_ring, hex_to_pixel
+
+
+def render(grid, path, size_px=18, quiet_module=1.5,
+           dark=(24, 22, 18), light=(255, 255, 255), ss=3):
+    """Render a module grid to a PNG file.
+
+    Parameters
+    ----------
+    grid : dict
+        Mapping ``{(q, r): 0|1}`` (1 = dark module).
+    path : str
+        Output PNG path.
+    size_px : int
+        Hexagon radius in pixels.
+    quiet_module : float
+        Quiet zone width in modules.
+    dark, light : tuple
+        RGB colours of dark / light modules.
+    ss : int
+        Supersampling factor for smooth edges.
+
+    Returns
+    -------
+    str
+        The output path.
+    """
+    try:
+        from PIL import Image, ImageDraw
+    except ImportError:
+        raise SystemExit("rendering requires Pillow: pip install pillow")
+    rmax = max(hex_distance(*c) for c in grid)
+    width = int(math.sqrt(3.0) * size_px * (2 * rmax + 1 + 2 * quiet_module))
+    height = int(1.5 * size_px * (2 * rmax + 2 * quiet_module + 2))
+    img = Image.new("RGB", (width * ss, height * ss), light)
+    dr = ImageDraw.Draw(img)
+    cx0, cy0 = width * ss / 2.0, height * ss / 2.0
+    s = size_px * ss
+    for (q, r), val in grid.items():
+        if not val:
+            continue
+        x, y = hex_to_pixel(q, r, s)
+        pts = [hex_corner(cx0 + x, cy0 + y, s * 0.995, i) for i in range(6)]
+        dr.polygon(pts, fill=dark)
+    img = img.resize((width, height), Image.LANCZOS)
+    img.save(path)
+    return path
+
+
+def sample_grid_from_image(path, rmax, size_px=18, quiet_module=1.5):
+    """Re-sample a rendered image back into a module grid (ideal sampling).
+
+    This is a self-test / conformance helper: it assumes the image was
+    produced by :func:`render` with the same geometry parameters and is
+    perfectly upright.  Real-world scanning requires finder detection
+    and perspective correction (planned for a later release).
+    """
+    from PIL import Image
+    img = Image.open(path).convert("L")
+    width, height = img.size
+    cx0, cy0 = width / 2.0, height / 2.0
+    s = size_px
+    grid = {}
+    for k in range(rmax + 1):
+        for (q, r) in hex_ring(k):
+            x, y = hex_to_pixel(q, r, s)
+            v = img.getpixel((int(cx0 + x), int(cy0 + y)))
+            grid[(q, r)] = 1 if v < 128 else 0
+    return grid

hexatess/resilience.py

@@ -0,0 +1,95 @@
+"""Robustness self-tests: random noise and blob (smudge) damage."""
+
+from __future__ import annotations
+
+import random
+
+from .decoder import decode
+from .encoder import encode
+from .geometry import hex_distance, hex_ring
+
+
+def data_cell_list(rmax):
+    """All payload cells from ring DATA_RING0 to ``rmax`` in spiral order."""
+    from .header import DATA_RING0
+    return [c for k in range(DATA_RING0, rmax + 1) for c in hex_ring(k)]
+
+
+def add_random_noise(grid, params, p, rng):
+    """Flip each payload cell independently with probability ``p``."""
+    rmax = params["rmax"]
+    g = dict(grid)
+    for c in data_cell_list(rmax):
+        if rng.random() < p:
+            g[c] ^= 1
+    return g
+
+
+def add_blob_damage(grid, params, target_frac, rng):
+    """Smudge damage: set all cells within radius ``d`` of a random
+    payload cell to 0, growing ``d`` until ~``target_frac`` of payload
+    cells are covered.  Returns ``(grid, blob_size)``."""
+    rmax = params["rmax"]
+    data_cells = data_cell_list(rmax)
+    total = len(data_cells)
+    d = 1
+    while True:
+        seed = rng.choice(data_cells)
+        blob = [c for c in data_cells
+                if hex_distance(c[0] - seed[0], c[1] - seed[1]) <= d]
+        if len(blob) >= total * target_frac or d > rmax:
+            break
+        d += 1
+    g = dict(grid)
+    for c in blob:
+        g[c] = 0
+    return g, len(blob)
+
+
+def run_tests(text="Hexatess Code - hexagonal 2D code with EC. ",
+              trials=30, seed=42, verbose=True):
+    """Round-trip plus random-noise and blob-damage survival statistics.
+
+    Physical note: one flipped module is one RS *symbol* error, so the
+    theoretical tolerance to uniformly random noise is roughly
+    ``ec_pct / 16`` percent of modules; blob damage survives much higher
+    area fractions because flips cluster inside whole bytes.
+    """
+    rng = random.Random(seed)
+    results = []
+    for ec in (30, 50, 90):
+        grid, params = encode(text, ec_pct=ec, mask_id="auto")
+        t, _ = decode(grid)
+        assert t == text, "round-trip failed at EC=%d" % ec
+        for p in (0.01, 0.02, 0.03, 0.05):
+            ok = 0
+            for _ in range(trials):
+                g2 = add_random_noise(grid, params, p, rng)
+                try:
+                    t2, _ = decode(g2)
+                    ok += (t2 == text)
+                except (ValueError, UnicodeDecodeError):
+                    pass
+            results.append(("noise %.0f%%" % (p * 100), ec, ok, trials))
+        for frac in (0.05, 0.10, 0.15, 0.20):
+            ok = 0
+            for _ in range(trials):
+                g2, _blob = add_blob_damage(grid, params, frac, rng)
+                try:
+                    t2, _ = decode(g2)
+                    ok += (t2 == text)
+                except (ValueError, UnicodeDecodeError):
+                    pass
+            results.append(("blob %.0f%%" % (frac * 100), ec, ok, trials))
+    if verbose:
+        print("=" * 56)
+        print("ROBUSTNESS TESTS (%d trials per setting, seed=%d)"
+              % (trials, seed))
+        print("payload: %d bytes; random-noise tolerance ~ EC/16%%"
+              % len(text.encode("utf-8")))
+        print("=" * 56)
+        print("%-14s %-6s %s" % ("damage", "EC%", "survival"))
+        for name, ec, ok, n in results:
+            print("%-14s %-6d %s  (%d/%d)"
+                  % (name, ec, "%.0f%%" % (100.0 * ok / n), ok, n))
+    return results

hexatess_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: hexatess-code
+Version: 0.1.0
+Summary: Hexatess Code - an experimental 2D barcode on a hexagonal grid with Reed-Solomon error correction
+Author: The Hexatess Code Authors
+License: MIT License
+        
+        Copyright (c) 2026 The Hexatess Code Authors
+        
+        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.
+        
+        ----------------------------------------------------------------------
+        Note on the specification:
+        
+        The format specification (SPECIFICATION.md) is additionally released under
+        the Creative Commons Attribution 4.0 International license (CC-BY-4.0), so
+        that anyone may implement compatible encoders/decoders in any language,
+        under any license, without restriction. Provide attribution as:
+        "Hexatess Code Specification v0.1, https://github.com/<you>/hexatess-code".
+        
+Project-URL: Homepage, https://github.com/lovro-abram/hexatess-code
+Project-URL: Specification, https://github.com/lovro-abram/hexatess-code/blob/main/SPECIFICATION.md
+Project-URL: Issues, https://github.com/lovro-abram/hexatess-code/issues
+Keywords: barcode,2d-barcode,qr-code,hexagonal,hexatess,reed-solomon,error-correction,aztec
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pillow>=9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# Hexatess Code 🐝
+
+**An experimental 2D barcode on a hexagonal grid** — with a hexagonal
+bullseye finder, spiral serialization and a continuously selectable
+Reed-Solomon error-correction budget of 5–90 %.
+
+![Hexatess Code example](docs/img/hexatess_primer.png)
+
+```python
+from hexatess import encode, decode, render
+
+grid, params = encode("Hello, Hexatess!", ec_pct=30)
+render(grid, "hello.png")
+text, stats = decode(grid)          # ('Hello, Hexatess!', {...})
+```
+
+## Symbol anatomy
+
+![Symbol anatomy](docs/img/hexatess_anatomy.png)
+
+* **A** — a real encoded symbol: hexagonal bullseye finder (rings 0–4),
+  orientation key (ring 5: two dark cells), data region (rings 6…)
+  filled in spiral order, and a quiet zone of at least 1 module;
+* **B** — finder close-up: light centre (v0.1 rule `bit = ring mod 2`),
+  alternating dark/light rings, and the key — the first two canonical
+  ring-5 cells set dark, breaking the 60-fold symmetry and marking the
+  spiral start direction;
+* **C** — spiral bit order across rings 6–7 (bit 0 at cell `(−6, +6)`),
+  rendered from the actual reference encoder output.
+
+## Why hexagons?
+
+* **+15.5 % packing density** over the square grid — hexagons tile the
+  plane with ~15.5 % more modules per area at equal module size, which
+  directly translates into more data per printed area.
+* **Rotational isotropy** — three axes of symmetry instead of two;
+  damage from any direction is statistically equivalent.
+* **Proven heritage** — MaxiCode (UPS, ISO/IEC 16023) already proved a
+  hexagonal 2D code works in the field; Hexatess Code generalizes the
+  idea to variable-size, high-capacity, Aztec-style symbols.
+* **Modern error control** — continuous EC budget from 5 % to 90 %
+  (not 7 discrete levels), independent RS blocks of ≤ 50 data bytes,
+  and a double-protected header.
+
+> **Status: experimental.** This is a young format: the symbol
+> specification and reference implementation are solid and heavily
+> tested (2,500+ tests, conformance vectors), but there is **no camera
+> decoder yet** — reading images assumes ideal upright sampling. See
+> the roadmap below. Adopting a young format is a deliberate bet; the
+> [full format specification](SPECIFICATION.md) is the insurance.
+
+## Installation
+
+```bash
+pip install hexatess-code            # from PyPI (once published)
+# or from a source checkout:
+pip install -e .
+```
+
+Requires Python ≥ 3.8 and Pillow (for rendering only).
+
+## Command line
+
+```bash
+hexatess "Hello world" -o koda.png --ec 30
+hexatess "Important URL https://example.org" -o url.png --ec 55
+hexatess-code --demo        # demo symbol + robustness statistics
+```
+
+## API
+
+| Function | Description |
+|---|---|
+| `encode(text, ec_pct=30, mask_id="auto", min_rings=None)` | UTF-8 text → `(grid, params)`; `grid` maps axial `(q, r)` to `0/1` |
+| `decode(grid)` | grid → `(text, stats)`; RS-corrects transparently |
+| `render(grid, path, size_px=18, ...)` | grid → PNG (pointy-top hexagons, quiet zone, supersampling) |
+| `sample_grid_from_image(path, rmax, ...)` | ideal re-sampling of a rendered PNG (self-test helper) |
+| `run_tests(...)` | noise/blob robustness statistics |
+
+`params` / `stats` contain `rmax` (radius in rings), `mask`, `ec`,
+`blocks` (list of `(data_bytes, ecc_bytes)`) and `data_len`.
+
+## Error-correction budget
+
+Choose any multiple of 5 between 5 and 90:
+
+| EC | Character |
+|---|---|
+| 5–15 | maximum capacity, clean environments |
+| 25–40 | general use (default 30) |
+| 50–70 | industrial / outdoor |
+| 80–90 | extreme damage tolerance |
+
+Physical behaviour (measured on the reference implementation): one
+flipped module is one RS *symbol* error, so uniform-noise tolerance is
+roughly `EC / 16` percent of modules, while clustered (smudge/blob)
+damage survives several times higher area fractions because flips
+concentrate inside whole bytes.
+
+## Implement it in your own language
+
+The format is deliberately **specification-first**: everything needed
+for an independent implementation is in
+[`SPECIFICATION.md`](SPECIFICATION.md), and
+[`test_vectors/vectors_v0.1.json`](test_vectors/vectors_v0.1.json)
+contains fixed inputs/outputs (grids, headers, damaged symbols, expected
+results) to verify conformance. If your Rust/Go/JS decoder passes the
+vectors, it speaks Hexatess Code.
+
+## Roadmap
+
+1. **v0.2 — camera decoding:** bullseye detection + perspective
+   correction (the critical ecosystem step).
+2. **v0.2 — erasure decoding:** declare blob-occluded modules as
+   erasures → doubles correctable symbol counts.
+3. **JavaScript/TypeScript SDK** + online playground (generate a code
+   in the browser in 10 seconds).
+4. Larger radii / capacity beyond 329 bytes (breaking header change).
+
+Contributions welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+* Code: [MIT](LICENSE)
+* Specification: CC-BY-4.0 — implement it anywhere, commercially, under
+  any license, no royalties, forever.
+
+---
+
+*Hexatess Code stands on the shoulders of giants: Aztec Code (bullseye +
+spiral), MaxiCode (hexagonal lattice), QR Code and Data Matrix
+(Reed-Solomon practice).*

hexatess_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+hexatess/__init__.py,sha256=Ipr99x_VZl4jkL8ri47afisdIFYzwV8xNSrQWQK1L5Q,2351
+hexatess/cli.py,sha256=e_Ou7vb4FNp_sT_viXhqWU4dAoONjiEQwMby0HRNcBY,2333
+hexatess/decoder.py,sha256=jvpWhnI3ZRWGjh_oHSRtFI2EgIYeAXooivV7kaRSqCU,2404
+hexatess/encoder.py,sha256=KbNUXCq51HeNf0oTdNHgi-6Gge_08h4zOAz_08QaqKQ,4362
+hexatess/galois.py,sha256=x-Sr8Kvi_lKY2lHPa-od2AdEU7Wty5qdowFXyKjYksU,2177
+hexatess/geometry.py,sha256=iCJ7NlqCKggm3yWacjHFJfA-b2SWTPcS68ZQAlIw_Rg,2130
+hexatess/header.py,sha256=ZhCDsEM_dKYBuaBleBddde5zAnxhRLKtQ0wQNPYD-cs,4495
+hexatess/masks.py,sha256=0xE7pAUCXIKkiZGEFZtDm76NaKkeLn1Ysw5Gf9g9mLk,1590
+hexatess/reedsolomon.py,sha256=0FYrjDC19oHmjo3VxFvVL_S6_QFVnDiytelZPKIgGZI,5174
+hexatess/render.py,sha256=Y8Lms4pXdKiqjlTaG-59WaOaPyBr25eXUwln5LLSuiQ,2440
+hexatess/resilience.py,sha256=1K6KihCizObGNwpF3r5qqr3eFrXVEkVnN_YnIUDl0iI,3418
+hexatess_code-0.1.0.dist-info/licenses/LICENSE,sha256=flrfY-EcdSw9OVuzA3XFA_zxkR5pwK8tB_gRIalGf34,1544
+hexatess_code-0.1.0.dist-info/METADATA,sha256=wJ8aNdPa-Ij8XI_m08m90Us4LY-iSKAJcAztBYyjUwM,8239
+hexatess_code-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hexatess_code-0.1.0.dist-info/entry_points.txt,sha256=iSchC2Ecsc8ksfVhHt24ulfqTL3ghIAeF6TcWbrLO_A,47
+hexatess_code-0.1.0.dist-info/top_level.txt,sha256=ZN2IgJdzQcKwK8XNCymg8LelJWQtP20L91WEFvO56KM,9
+hexatess_code-0.1.0.dist-info/RECORD,,

hexatess_code-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hexatess_code-0.1.0.dist-info/entry_points.txt

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

hexatess_code-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2026 The Hexatess Code Authors
+
+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.
+
+----------------------------------------------------------------------
+Note on the specification:
+
+The format specification (SPECIFICATION.md) is additionally released under
+the Creative Commons Attribution 4.0 International license (CC-BY-4.0), so
+that anyone may implement compatible encoders/decoders in any language,
+under any license, without restriction. Provide attribution as:
+"Hexatess Code Specification v0.1, https://github.com/<you>/hexatess-code".

hexatess_code-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hexatess