tablecodec 0.0.18__py3-none-any.whl

tablecodec/teds.py

@@ -0,0 +1,243 @@
+"""TEDS (Tree-Edit-Distance based Similarity) for table samples.
+
+TEDS scores the similarity of two tables in ``[0, 1]`` by the normalized
+tree-edit distance between their HTML-DOM trees (Zhong et al., "Image-based
+table recognition: data, model, and evaluation"). ``1.0`` means identical
+structure and content; ``structure_only=True`` ignores cell text (TEDS-Struct).
+
+This is the optional ``[teds]`` feature: it imports ``apted`` and ``lxml`` and
+therefore lives OUTSIDE the zero-dependency core. It is never imported by
+``tablecodec/__init__`` — use ``from tablecodec.teds import teds``.
+
+Attribution: the tree construction, the rename-cost rule, and the
+``1 - dist / max_nodes`` formula are adapted from IBM's PubTabNet reference
+metric (``src/metric.py``, Apache License 2.0, Copyright 2020 IBM,
+peter.zhong@au1.ibm.com). This is NOT a verbatim copy: the IR-native entry
+point, a pure-Python normalized Levenshtein (replacing the ``distance``
+package), and the removal of batching/parallelism are tablecodec's. See
+``THIRD_PARTY_NOTICES.md`` and ``docs/adr/0011-teds-metric-port.md``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from apted import APTED, Config  # pyright: ignore[reportMissingTypeStubs]
+from lxml import html  # pyright: ignore[reportMissingTypeStubs]
+
+from tablecodec.ir import GridCell, TableSample
+
+__all__ = ["teds", "teds_html"]
+
+
+# ---------- normalized Levenshtein (pure stdlib; replaces `distance`) ----------
+
+
+def _levenshtein(a: list[str], b: list[str]) -> int:
+    """Edit distance between two token sequences."""
+    if a == b:
+        return 0
+    if not a:
+        return len(b)
+    if not b:
+        return len(a)
+    previous = list(range(len(b) + 1))
+    for i, ca in enumerate(a, start=1):
+        current = [i]
+        for j, cb in enumerate(b, start=1):
+            cost = 0 if ca == cb else 1
+            current.append(min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost))
+        previous = current
+    return previous[-1]
+
+
+def _normalized_distance(a: list[str], b: list[str]) -> float:
+    """Levenshtein distance scaled to ``[0, 1]`` by the longer sequence."""
+    longest = max(len(a), len(b))
+    if longest == 0:
+        return 0.0
+    return _levenshtein(a, b) / longest
+
+
+# ---------- apted tree + config (adapted from IBM PubTabNet metric.py) ----------
+
+
+class _TableTree:
+    """An apted tree node for one HTML table element."""
+
+    def __init__(
+        self,
+        tag: str,
+        colspan: int | None,
+        rowspan: int | None,
+        content: list[str] | None,
+        *children: _TableTree,
+    ) -> None:
+        self.tag = tag
+        self.colspan = colspan
+        self.rowspan = rowspan
+        self.content = content
+        self.children: list[_TableTree] = list(children)
+
+
+class _CustomConfig(Config):
+    def children(self, node: _TableTree) -> list[_TableTree]:
+        return node.children
+
+    # apted annotates rename as `-> int`, but TEDS uses fractional content
+    # costs; apted sums costs as numbers, so a float is correct at runtime.
+    def rename(self, node1: _TableTree, node2: _TableTree) -> float:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """Cost of relabeling ``node1`` to ``node2``."""
+        if (
+            node1.tag != node2.tag
+            or node1.colspan != node2.colspan
+            or node1.rowspan != node2.rowspan
+        ):
+            return 1.0
+        if node1.tag == "td" and (node1.content or node2.content):
+            return _normalized_distance(node1.content or [], node2.content or [])
+        return 0.0
+
+
+# ---------- untyped third-party boundary (apted + lxml have no stubs) ----------
+#
+# apted and lxml ship no type information, so pyright (strict) cannot type the
+# few lines that touch them. These thin wrappers confine that boundary: each
+# returns a concretely-typed value, so the rest of the module is fully checked.
+
+
+def _parse_first_table(doc: str) -> Any:
+    """Parse `doc` and return its first ``body/table`` element, or ``None``."""
+    parser = cast("Any", html.HTMLParser(remove_comments=True))
+    root = cast("Any", html.fromstring(doc, parser=parser))  # pyright: ignore[reportUnknownMemberType]
+    tables = cast("list[Any]", root.xpath("body/table"))
+    return tables[0] if tables else None
+
+
+def _count_descendant_elements(table: Any) -> int:
+    """Number of element nodes below `table` (the TEDS denominator term)."""
+    return len(cast("list[Any]", table.xpath(".//*")))
+
+
+def _tree_edit_distance(tree1: _TableTree, tree2: _TableTree) -> float:
+    raw = cast("Any", APTED(tree1, tree2, _CustomConfig()).compute_edit_distance())
+    return float(raw)
+
+
+# ---------- lxml element -> apted tree (adapted from IBM PubTabNet) ----------
+
+
+def _tokenize(node: Any, tokens: list[str]) -> None:
+    """Flatten an element into tokens: char-level text + tag markers."""
+    tokens.append(f"<{node.tag}>")
+    if node.text is not None:
+        tokens.extend(list(node.text))
+    for child in node:
+        _tokenize(child, tokens)
+    if node.tag != "unk":
+        tokens.append(f"</{node.tag}>")
+    if node.tag != "td" and node.tail is not None:
+        tokens.extend(list(node.tail))
+
+
+def _load_html_tree(node: Any, *, structure_only: bool) -> _TableTree:
+    """Convert an lxml table element into the apted tree apted expects."""
+    if node.tag == "td":
+        if structure_only:
+            content: list[str] = []
+        else:
+            tokens: list[str] = []
+            _tokenize(node, tokens)
+            content = tokens[1:-1]
+        new_node = _TableTree(
+            "td",
+            int(node.attrib.get("colspan", "1")),
+            int(node.attrib.get("rowspan", "1")),
+            content,
+        )
+    else:
+        new_node = _TableTree(str(node.tag), None, None, None)
+        for child in node:
+            new_node.children.append(_load_html_tree(child, structure_only=structure_only))
+    return new_node
+
+
+# ---------- IR -> HTML ----------
+
+
+def _is_header_row(cells: list[GridCell]) -> bool:
+    return any(cell.role == "header" for cell in cells)
+
+
+def _cell_html(cell: GridCell) -> str:
+    attrs = ""
+    if cell.colspan != 1:
+        attrs += f' colspan="{cell.colspan}"'
+    if cell.rowspan != 1:
+        attrs += f' rowspan="{cell.rowspan}"'
+    return f"<td{attrs}>{''.join(cell.tokens)}</td>"
+
+
+def _row_html(cells: list[GridCell]) -> str:
+    inner = "".join(_cell_html(cell) for cell in sorted(cells, key=lambda c: c.col))
+    return f"<tr>{inner}</tr>"
+
+
+def _sample_to_html(sample: TableSample) -> str:
+    """Render a sample as ``<html><body><table>...`` for TEDS.
+
+    Cells are grouped by anchor row (HTML rowspan/colspan handle the rest);
+    header rows go in ``<thead>``, body rows in ``<tbody>``. All cells render
+    as ``<td>`` (PubTabNet convention) so the metric scores their content.
+    """
+    rows: dict[int, list[GridCell]] = {}
+    for cell in sample.cells:
+        rows.setdefault(cell.row, []).append(cell)
+
+    header = [r for r in sorted(rows) if _is_header_row(rows[r])]
+    body = [r for r in sorted(rows) if not _is_header_row(rows[r])]
+
+    parts = ["<html><body><table>"]
+    if header:
+        parts.append("<thead>")
+        parts.extend(_row_html(rows[r]) for r in header)
+        parts.append("</thead>")
+    if body:
+        parts.append("<tbody>")
+        parts.extend(_row_html(rows[r]) for r in body)
+        parts.append("</tbody>")
+    parts.append("</table></body></html>")
+    return "".join(parts)
+
+
+# ---------- public API ----------
+
+
+def teds_html(pred_html: str, true_html: str, *, structure_only: bool = False) -> float:
+    """TEDS between two HTML table documents.
+
+    Each input is parsed; the first ``body/table`` is scored. Empty input or
+    HTML with no table scores ``0.0`` (the canonical convention).
+    """
+    if not pred_html or not true_html:
+        return 0.0
+    pred_table = _parse_first_table(pred_html)
+    true_table = _parse_first_table(true_html)
+    if pred_table is None or true_table is None:
+        return 0.0
+    n_nodes = max(_count_descendant_elements(pred_table), _count_descendant_elements(true_table))
+    if n_nodes == 0:
+        return 1.0
+    tree_pred = _load_html_tree(pred_table, structure_only=structure_only)
+    tree_true = _load_html_tree(true_table, structure_only=structure_only)
+    distance = _tree_edit_distance(tree_pred, tree_true)
+    return 1.0 - distance / n_nodes
+
+
+def teds(pred: TableSample, true: TableSample, *, structure_only: bool = False) -> float:
+    """TEDS between two :class:`TableSample`s.
+
+    Both samples are rendered to HTML with the same renderer, so the score is
+    a well-defined similarity in ``[0, 1]`` regardless of their source codecs.
+    """
+    return teds_html(_sample_to_html(pred), _sample_to_html(true), structure_only=structure_only)

tablecodec/validate.py

@@ -0,0 +1,185 @@
+"""Validation entry-point and named profiles.
+
+SPEC §8: a user explicitly opts into the strictness they need. Five
+profiles ship: ``LENIENT``, ``DEFAULT``, ``PUBTABNET_2_0``, ``TABLEFORMER``,
+``STRICT``. Custom profiles can be constructed by composing the
+``check_iXX`` functions in :mod:`tablecodec._invariants`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from types import SimpleNamespace
+
+from tablecodec._invariants import (
+    ValidationError,
+    check_i01_nrows_ncols_positive,
+    check_i02_cell_in_bounds,
+    check_i03_span_in_bounds,
+    check_i04_grid_exact_cover,
+    check_i05_bbox_well_formed,
+    check_i06_header_contiguous_top,
+    check_i07_tokens_is_tuple,
+)
+from tablecodec.ir import TableSample
+
+__all__ = ["Profile", "ValidationError", "profiles", "validate"]
+
+Check = Callable[[TableSample], list[ValidationError]]
+
+
+@dataclass(frozen=True, slots=True)
+class Profile:
+    """A named bundle of invariant checks.
+
+    Attributes:
+        name: Human-visible profile identifier.
+        checks: Ordered tuple of check functions. Order determines the
+            order of errors in the returned list (lower-numbered
+            invariants first, by convention).
+    """
+
+    name: str
+    checks: tuple[Check, ...] = field(default_factory=tuple)
+
+
+# ---------- profile-specific extra checks ----------
+
+
+def _check_pubtabnet_20_bbox(sample: TableSample) -> list[ValidationError]:
+    """SPEC §8 pubtabnet-2.0 profile: non-empty cells must have bbox."""
+    errors: list[ValidationError] = []
+    for idx, cell in enumerate(sample.cells):
+        if cell.tokens and cell.bbox is None:
+            errors.append(
+                ValidationError(
+                    invariant="PUBTABNET-2.0-BBOX",
+                    message=f"non-empty cell index {idx} is missing bbox",
+                    cell_index=idx,
+                )
+            )
+    return errors
+
+
+def _check_tableformer_bbox(sample: TableSample) -> list[ValidationError]:
+    """SPEC §8 tableformer profile: every cell (even empty) must have bbox."""
+    errors: list[ValidationError] = []
+    for idx, cell in enumerate(sample.cells):
+        if cell.bbox is None:
+            errors.append(
+                ValidationError(
+                    invariant="TABLEFORMER-BBOX",
+                    message=f"cell index {idx} is missing bbox",
+                    cell_index=idx,
+                )
+            )
+    return errors
+
+
+def _check_strict_bbox_in_image(sample: TableSample) -> list[ValidationError]:
+    """SPEC §8 strict profile / ADR 0012: cross-check bbox vs image dimensions.
+
+    Semantics (option C): a bbox-free sample needs no image metadata. If any
+    cell carries a bbox, the sample MUST declare ``image_width`` and
+    ``image_height`` (else the coordinates cannot be bound-checked), and every
+    bbox must lie within the image rectangle ``0 <= x0 < x1 <= width`` and
+    ``0 <= y0 < y1 <= height`` (upper bound inclusive — a bbox may touch the
+    image edge).
+    """
+    cells_with_bbox = [(idx, c.bbox) for idx, c in enumerate(sample.cells) if c.bbox is not None]
+    if not cells_with_bbox:
+        return []
+
+    width, height = sample.image_width, sample.image_height
+    if width is None or height is None:
+        return [
+            ValidationError(
+                invariant="STRICT-IMAGE-METADATA",
+                message=(
+                    "sample carries cell bboxes but no image_width/image_height "
+                    "to cross-check them against"
+                ),
+                cell_index=None,
+            )
+        ]
+
+    errors: list[ValidationError] = []
+    for idx, bbox in cells_with_bbox:
+        x0, y0, x1, y1 = bbox
+        if not (0 <= x0 and x1 <= width):
+            errors.append(
+                ValidationError(
+                    invariant="STRICT-BBOX-OUT-OF-BOUNDS",
+                    message=(f"bbox x-range [{x0}, {x1}] outside [0, {width}] at cell index {idx}"),
+                    cell_index=idx,
+                )
+            )
+        if not (0 <= y0 and y1 <= height):
+            errors.append(
+                ValidationError(
+                    invariant="STRICT-BBOX-OUT-OF-BOUNDS",
+                    message=(
+                        f"bbox y-range [{y0}, {y1}] outside [0, {height}] at cell index {idx}"
+                    ),
+                    cell_index=idx,
+                )
+            )
+    return errors
+
+
+# ---------- profile registry ----------
+
+_DEFAULT_CHECKS: tuple[Check, ...] = (
+    check_i01_nrows_ncols_positive,
+    check_i02_cell_in_bounds,
+    check_i03_span_in_bounds,
+    check_i04_grid_exact_cover,
+    check_i05_bbox_well_formed,
+    check_i06_header_contiguous_top,
+    check_i07_tokens_is_tuple,
+)
+
+# SPEC §8: LENIENT enforces I-01, I-02, I-03, I-05 only.
+_LENIENT_CHECKS: tuple[Check, ...] = (
+    check_i01_nrows_ncols_positive,
+    check_i02_cell_in_bounds,
+    check_i03_span_in_bounds,
+    check_i05_bbox_well_formed,
+)
+
+
+# SimpleNamespace exposes the five built-in profiles as ``profiles.NAME``
+# without pyright flagging uppercase attributes as ``reportConstantRedefinition``.
+# SPEC §8 / ADR 0012: STRICT = DEFAULT + a bbox-in-image cross-check that
+# requires image metadata whenever a sample carries bboxes.
+profiles = SimpleNamespace(
+    LENIENT=Profile(name="LENIENT", checks=_LENIENT_CHECKS),
+    DEFAULT=Profile(name="DEFAULT", checks=_DEFAULT_CHECKS),
+    PUBTABNET_2_0=Profile(
+        name="PUBTABNET_2_0",
+        checks=(*_DEFAULT_CHECKS, _check_pubtabnet_20_bbox),
+    ),
+    TABLEFORMER=Profile(
+        name="TABLEFORMER",
+        checks=(*_DEFAULT_CHECKS, _check_tableformer_bbox),
+    ),
+    STRICT=Profile(name="STRICT", checks=(*_DEFAULT_CHECKS, _check_strict_bbox_in_image)),
+)
+
+
+def validate(sample: TableSample, profile: Profile) -> list[ValidationError]:
+    """Run the checks bundled in *profile* against *sample*.
+
+    Returns a flat list of :class:`ValidationError`. Empty list = valid.
+    Never raises on data; raises ``TypeError`` if *profile* is not a
+    :class:`Profile` instance (SPEC §8 "raise only on programmer error").
+    """
+    if not isinstance(profile, Profile):  # pyright: ignore[reportUnnecessaryIsInstance]
+        msg = f"profile must be a Profile instance, got {type(profile).__name__}"
+        raise TypeError(msg)
+
+    errors: list[ValidationError] = []
+    for check in profile.checks:
+        errors.extend(check(sample))
+    return errors

tablecodec-0.0.18.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: tablecodec
+Version: 0.0.18
+Summary: Neutral Internal Representation and Codec registry for image-based table-recognition datasets
+Project-URL: Homepage, https://github.com/hironow/tablecodec
+Project-URL: Repository, https://github.com/hironow/tablecodec
+Project-URL: Issues, https://github.com/hironow/tablecodec/issues
+Project-URL: Changelog, https://github.com/hironow/tablecodec/blob/main/CHANGELOG.md
+Author-email: hironow <hironow365@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dataset,doctags,fintabnet,ocr,otsl,pubtabnet,table
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: all
+Requires-Dist: apted>=1.0.3; extra == 'all'
+Requires-Dist: click>=8.1; extra == 'all'
+Requires-Dist: datasets>=2.19; extra == 'all'
+Requires-Dist: defusedxml>=0.7; extra == 'all'
+Requires-Dist: lxml>=5.0; extra == 'all'
+Provides-Extra: cli
+Requires-Dist: click>=8.1; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: coverage>=7.5; extra == 'dev'
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
+Requires-Dist: jsonschema>=4.20; extra == 'dev'
+Requires-Dist: pyright>=1.1.380; extra == 'dev'
+Requires-Dist: pytest-benchmark>=4.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: hf
+Requires-Dist: datasets>=2.19; extra == 'hf'
+Requires-Dist: defusedxml>=0.7; extra == 'hf'
+Provides-Extra: teds
+Requires-Dist: apted>=1.0.3; extra == 'teds'
+Requires-Dist: lxml>=5.0; extra == 'teds'
+Description-Content-Type: text/markdown
+
+# tablecodec
+
+> Neutral Internal Representation + Codec registry for image-based table-recognition datasets.
+
+`tablecodec` is a Python library that provides a single, lossless Internal
+Representation (IR) for tables and a registry-based codec layer that translates
+between this IR and the fragmented landscape of public table-recognition
+datasets — PubTabNet, FinTabNet, OTSL, TableFormer, DocTags-tables,
+PubTables-1M, TableBank.
+
+- Stdlib-only core. Heavier features (TEDS, CLI) are opt-in extras.
+- Streams large JSONL datasets at constant memory.
+- Self-declared loss analysis between any two codecs.
+
+## Status
+
+**0.0.18 (pre-alpha).** Not yet published to PyPI. The nine codecs, the TEDS
+metric (`[teds]`), and the STRICT validation profile were all added
+incrementally within the 0.0.x series; a separate `tablecodec-docling` bridge
+codec lives in `packages/` (its own version). The 0.x line makes no
+API-stability promises; the public surface freezes at 1.0 (see
+[docs/spec.md](docs/spec.md) §14). The specification is the source of
+truth. Auto-generated codec / loss tables live at
+[docs/format_support.md](docs/format_support.md) and
+[docs/loss_matrix.md](docs/loss_matrix.md).
+
+## Installation
+
+```bash
+pip install tablecodec            # stdlib-only core
+pip install "tablecodec[cli]"     # + command-line interface (click)
+pip install "tablecodec[teds]"    # + TEDS similarity metric (apted, lxml)
+```
+
+Requires Python 3.11+.
+
+## Basic usage
+
+```python
+import tablecodec
+from tablecodec import codecs, validate, profiles, analyze_loss
+from tablecodec.codecs.pubtabnet import PubTabNet20Codec
+
+# Register a codec (built-ins self-register through the CLI; in library
+# use you register the ones you need).
+codecs.register(PubTabNet20Codec())
+
+# Stream-read a dataset into the neutral IR.
+with open("pubtabnet_val.jsonl", encoding="utf-8") as f:
+    for sample in codecs.get("pubtabnet-2.0.0").read(f):
+        errors = validate(sample, profile=profiles.DEFAULT)
+        if errors:
+            print(sample.filename, errors)
+
+# Static, data-free loss analysis between two formats.
+report = analyze_loss(source="pubtabnet-2.0.0", target="otsl-1.0.0")
+print(report.round_trip_classification)  # "structure-preserving"
+```
+
+The core has **zero third-party runtime dependencies** (SPEC §13);
+`import tablecodec` works on a bare Python 3.11+.
+
+## TEDS similarity (optional)
+
+The `[teds]` extra adds a Tree-Edit-Distance based Similarity score between
+two samples. It lives outside the core (it imports `apted`/`lxml`), so import
+it from its submodule:
+
+```python
+from tablecodec.teds import teds
+
+score = teds(pred_sample, true_sample)              # 0.0 .. 1.0
+struct = teds(pred_sample, true_sample, structure_only=True)  # ignore cell text
+```
+
+## CLI
+
+Install with the optional ``[cli]`` extra:
+
+```bash
+pip install "tablecodec[cli]"
+```
+
+```bash
+tablecodec codecs list
+tablecodec analyze-loss --from pubtabnet-2.0.0 --to otsl-1.0.0
+tablecodec validate path/to/dataset.jsonl --codec pubtabnet-2.0.0 --profile DEFAULT
+tablecodec stats path/to/dataset.jsonl --codec pubtabnet-2.0.0 --json
+tablecodec convert in.jsonl out.jsonl --from pubtabnet-2.0.0 --to otsl-1.0.0
+tablecodec convert in.jsonl /dev/null --from pubtabnet-2.0.0 --to otsl-1.0.0 --dry-run
+tablecodec diff a.jsonl b.jsonl --codec pubtabnet-2.0.0
+```
+
+All commands stream their input; exit codes are non-zero on validation
+failures or diffs (suitable for CI / data pipelines).
+
+## End-to-end check against real datasets
+
+`scripts/e2e_hf_check.py` streams real datasets through the codecs and
+validates the resulting IR. Every shipped codec gets at least one
+official-corpus check. Two data sources are used:
+
+- the Docling OTSL family
+  (`docling-project/{PubTabNet,FinTabNet,PubTables-1M,SynthTabNet}_OTSL`)
+  — a uniform converted schema that feeds all nine codecs;
+- the **native** first-published PubTabNet annotation
+  (`apoidea/pubtabnet-html`) fed unmodified to the `pubtabnet` codecs;
+- the **native** PubTables-1M PASCAL VOC structure annotation
+  (`bsmock/pubtables-1m`, download-only) read from a local tar under
+  `input/` with the logical grid reconstructed for the `pubtables-1m`
+  codec (FinTabNet / TableBank natives stay download-only + Docling-covered).
+
+It is **occasional / local-only** (network + multi-GB datasets), not part
+of CI.
+
+```bash
+just e2e-selftest              # network-free adapter smoke test
+just e2e 200                   # 200 randomly-sampled rows per check (needs [hf] extra)
+uv run --extra hf python scripts/e2e_hf_check.py --dataset apoidea --limit 50
+just e2e-fetch-pubtables1m     # download native PubTables-1M VOC (~30MB) into input/
+uv run --extra hf python scripts/e2e_hf_check.py --dataset bsmock --limit 200
+```
+
+Rows are sampled randomly (streaming shuffle reshuffles shard order), so
+repeated runs progressively cover the multi-hundred-thousand-row corpora.
+Each run prints its `--seed` so a finding can be reproduced; pass
+`--seed N` to fix it or `--no-shuffle` for a deterministic head read.
+The harness reports parse errors and validation findings — e.g. it
+surfaces real upstream rows with geometrically invalid bboxes (I-05) —
+and appends each failed row to `output/e2e_findings/` (gitignored) with
+its full provenance and replayable payload for later audit.
+
+See [`docs/adr/0003-e2e-against-docling-otsl-family.md`](docs/adr/0003-e2e-against-docling-otsl-family.md)
+and [`docs/adr/0004-e2e-native-first-published-datasets.md`](docs/adr/0004-e2e-native-first-published-datasets.md)
+for the data-source decisions and the canonical-vs-real-shape caveats.
+
+## Documents
+
+- [`docs/spec.md`](docs/spec.md) — Specification (the single source of truth).
+- [`docs/glossary.md`](docs/glossary.md) — Precise vocabulary: terms tablecodec
+  defines vs. borrows, and the words most likely to be misread (e.g. "loss"
+  vs a "degenerate" bbox).
+- [`docs/intent.md`](docs/intent.md) — Implementation brief (milestones, order,
+  quality bar).
+- [`CHANGELOG.md`](CHANGELOG.md) — Keep a Changelog format.
+
+## License
+
+MIT. See [LICENSE](LICENSE). The OTSL grid-reconstruction logic is
+adapted (with attribution) from the MIT-licensed docling-ibm-models — see
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

tablecodec-0.0.18.dist-info/RECORD

@@ -0,0 +1,27 @@
+tablecodec/__init__.py,sha256=_U9z_gMXJt-WA6_rOxFhiWtn_G8D8e425Kg1zZQijTc,678
+tablecodec/_invariants.py,sha256=jLaypJX0Z-YSLLN0rAs0bWQbQbtTDl2wO66KH3XnPa4,11054
+tablecodec/cli.py,sha256=iyxzB4VPKDTTQ9FDHp-RmZ4Jk3I1iQf26fcq4nKAiBM,10419
+tablecodec/io.py,sha256=Zyc9Xr-ZC7Ga0SXybW9nNl0fWXhe-F7N-hQjv07X_Mc,2873
+tablecodec/ir.py,sha256=7AQXFVmq56WjuSehlLv3rmUbfhcIatiUg-0LWKhu30w,3683
+tablecodec/loss.py,sha256=PBssNn9EOPw6ttl828c5VKcDtl3upd7EReCD2Sz1c70,4195
+tablecodec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tablecodec/teds.py,sha256=FXtscI55jOJHt7bQ84-qCawfA2qOeE-LBKT64q-5YK4,8812
+tablecodec/validate.py,sha256=d_WyQ5i7pwataS4Qb3N6RMBVd-cGrwlG_fSQkafcp5Q,6484
+tablecodec/codecs/__init__.py,sha256=hUOBUiQB7LuF5mWxC5nkacTVYqOoTFxZvG0clVylRF4,3618
+tablecodec/codecs/_base.py,sha256=5EGO5-cYNxlR8rFrtLtroCiy1Vp1OKDwjbXuY7LwnHk,2578
+tablecodec/codecs/_htmltable.py,sha256=wlT9POZ_famRPuSqyS0fSG-rNDBLmn3jfXW0NzlWlZw,15644
+tablecodec/codecs/_otslgrid.py,sha256=jM-g8Cf20s6sC6DGrGhSi4Kdzsns3D_6UHPxXrnEaIA,11559
+tablecodec/codecs/builtins.py,sha256=S0CLZtbBLkQOF_K5FQqXcTGUL2iL82xsYZGi7Iz4Fi8,1255
+tablecodec/codecs/doctags.py,sha256=liBBrJFYuwOKpcEsnxT4cn7ovarqBI81ZJKJMA02suA,8546
+tablecodec/codecs/fintabnet.py,sha256=UYeD_xvAtGNAuZ5PTWfA9lL64RvTjBwPyrnjUMoMg44,2746
+tablecodec/codecs/fintabnet_otsl.py,sha256=0dKhBXTwL9c8F6iRMLqkvqkmpixJGV6WmpjwNA5dMqw,4740
+tablecodec/codecs/otsl.py,sha256=ZBLWu8NMKgiX3-9qoGUdNpcGDcw_8UHInSxVl-8c5nQ,4604
+tablecodec/codecs/pubtables1m.py,sha256=ev3bHSGaoRDcnFBNThFXw5W9baKx_NbJNP3NVbYTR3g,5450
+tablecodec/codecs/pubtabnet.py,sha256=0OtrmrKjSddNJ4S7aH-4qD05D_sZq1MWuTGdsb8j0lM,4424
+tablecodec/codecs/tablebank.py,sha256=KVeKCCWXAnQkfaFIjDSloH1rgEyOQ0ZJ3sflg6MQsxs,2608
+tablecodec/codecs/tableformer.py,sha256=V_WHjP2sl77GCj-9f8gN12PPeC40gJLnEa02jXdt-kg,2823
+tablecodec-0.0.18.dist-info/METADATA,sha256=4qpPkHuoBPUuDqg62G_opJh4wdiWwvGR3yqxEDnNZc8,8356
+tablecodec-0.0.18.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+tablecodec-0.0.18.dist-info/entry_points.txt,sha256=CxI3i14zvY80ATqZIUhuNVYt5a4Yt363HirK237RW2U,51
+tablecodec-0.0.18.dist-info/licenses/LICENSE,sha256=A7Sy6xlibOHoadZDwSczt7tulPwnUmzF_XDQUuJmYr4,1092
+tablecodec-0.0.18.dist-info/RECORD,,

tablecodec-0.0.18.dist-info/WHEEL

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

tablecodec-0.0.18.dist-info/entry_points.txt

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

tablecodec-0.0.18.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hironow and tablecodec contributors
+
+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.