table2rules 0.5.1__tar.gz → 0.6.0__tar.gz

{table2rules-0.5.1/src/table2rules.egg-info → table2rules-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table2rules
-Version: 0.5.1
+Version: 0.6.0
 Summary: Convert HTML tables to flat, LLM-friendly rules using spatial pathfinding.
 Author: PebbleRoad Pte Ltd
 License-Expression: MIT

{table2rules-0.5.1 → table2rules-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "table2rules"
-version = "0.5.1"
+version = "0.6.0"
 description = "Convert HTML tables to flat, LLM-friendly rules using spatial pathfinding."
 readme = "README.md"
 license = "MIT"

{table2rules-0.5.1 → table2rules-0.6.0}/src/table2rules/_core.py

@@ -12,6 +12,7 @@ from .models import LogicRule
 from .quality_gate import GateResult, assess_confidence
 from .report import RenderMode, RenderReport, TableReport
 from .simple_repair import simple_repair
+from .spans import is_full_width_note
 
 
 def _split_compound_tables(soup) -> None:
@@ -155,6 +156,22 @@ def _build_rules(grid) -> List[LogicRule]:
             colspan = cell.get("colspan", 1)
             outcome_norm = cell["text"].strip().lower()
 
+            # A wide <td> that reaches the last column AND covers a majority of
+            # the grid's columns is structurally a full-width note/description
+            # (e.g. a benefit name "Accidental death and permanent disability"
+            # or "If the departure of your public transport is delayed…"
+            # spanning the whole value region), not a per-column value. We still
+            # emit at every spanned position — so the gate detects an
+            # overlapping-span corruption (a rowspan intruding into the note's
+            # row) as a conflict and fails open to flat — but attribute every
+            # position to the *origin* column's header path. The exporter's
+            # origin-aware dedup then collapses the identical lines to one,
+            # instead of stamping the sentence under each plan×cover header.
+            # Legitimate narrow spans (a right-edge colspan=2 amount covering
+            # INDIVIDUAL+FAMILY of one plan) fail the majority test and keep
+            # their genuine per-column attribution.
+            note = is_full_width_note(col_idx, colspan, n_cols)
+
             for r_offset in range(rowspan):
                 for c_offset in range(colspan):
                     target_row = row_idx + r_offset
@@ -163,7 +180,8 @@ def _build_rules(grid) -> List[LogicRule]:
                     if target_row >= len(grid) or target_col >= len(grid[0]):
                         continue
 
-                    row_headers, col_headers = find_headers_for_cell(grid, target_row, target_col)
+                    header_col = col_idx if note else target_col
+                    row_headers, col_headers = find_headers_for_cell(grid, target_row, header_col)
 
                     rules.append(
                         LogicRule(
@@ -229,6 +247,78 @@ def _build_rules(grid) -> List[LogicRule]:
     return rules
 
 
+def _mark_rowgroup_bands(grid) -> None:
+    """Promote value-region-wide body dividers to ``<th scope="rowgroup">`` so
+    the maze threads them into each value line's row path as bounded, nested
+    row-group ancestors — the row-side counterpart of the multi-level column
+    header path.
+
+    A candidate is a body cell whose span reaches the last column and covers a
+    majority of the grid (``is_full_width_note`` geometry): a section band
+    (full width) or a group header / description spanning the value region. A
+    candidate is promoted only when its extent contains at least one real data
+    row — so a standalone trailing note (which groups nothing) is left as a
+    note and still emitted, never stranded as an empty-extent rowgroup. Nested
+    candidates are bounded by colspan: a band's extent ends at the next
+    candidate whose span is equal or wider. Cells already marked
+    ``scope="rowgroup"`` by the source are honored as-is.
+    """
+    if not grid or not grid[0]:
+        return
+    n_cols = len(grid[0])
+    # Column-header texts. A full-width body cell that merely repeats a column
+    # header (a units caption like "(In thousands, except per share data)"
+    # reprinted between sections) is an annotation, not a row-group divider —
+    # promoting it would stamp it onto every row path (where it is already noise
+    # in the column path). Exclude such echoes.
+    header_texts = {
+        (cell.get("text") or "").strip().lower()
+        for row in grid
+        for cell in row
+        if cell and cell.get("is_thead") and (cell.get("text") or "").strip()
+    }
+    candidates = []  # (row, col, colspan)
+    for r in range(len(grid)):
+        for c in range(n_cols):
+            cell = grid[r][c]
+            if not cell or cell.get("is_span_copy"):
+                continue
+            if cell.get("is_thead") or cell.get("is_header_row"):
+                continue
+            text = (cell.get("text") or "").strip()
+            if not text:
+                continue
+            if text.lower() in header_texts:
+                continue
+            if is_full_width_note(c, cell.get("colspan", 1), n_cols):
+                candidates.append((r, c, cell.get("colspan", 1)))
+    candidate_rows = {r for (r, _c, _cs) in candidates}
+
+    def _next_band_below(after_row: int, min_colspan: int) -> int:
+        for rr in range(after_row + 1, len(grid)):
+            if any(r == rr and cs >= min_colspan for (r, _c, cs) in candidates):
+                return rr
+        return len(grid)
+
+    for r, c, cs in candidates:
+        extent_end = _next_band_below(r, cs) - 1
+        has_data_row = False
+        for rr in range(r + 1, extent_end + 1):
+            if rr in candidate_rows:
+                continue
+            if any(
+                grid[rr][cc]["type"] == "td" and (grid[rr][cc].get("text") or "").strip()
+                for cc in range(n_cols)
+            ):
+                has_data_row = True
+                break
+        if not has_data_row:
+            continue
+        for cc in range(c, min(c + cs, n_cols)):
+            grid[r][cc]["type"] = "th"
+            grid[r][cc]["scope"] = "rowgroup"
+
+
 def _process_table_with_gate(table_html: str) -> Tuple[List[LogicRule], GateResult]:
     """Runs the full pipeline and returns rules plus the gate verdict.
 
@@ -246,6 +336,7 @@ def _process_table_with_gate(table_html: str) -> Tuple[List[LogicRule], GateResu
     if not grid:
         return [], GateResult(ok=False, score=0.0, reasons=["empty_grid"])
 
+    _mark_rowgroup_bands(grid)
     rules = clean_rules(_build_rules(grid))
     gate = assess_confidence(grid, rules)
     if not gate.ok:
@@ -302,6 +393,8 @@ def _run(
     table_index = 0
 
     for table in all_tables:
+        if not isinstance(table, Tag):
+            continue
         # Skip nested tables — they're folded into their parent's cell text.
         if table.find_parent("table"):
             continue

{table2rules-0.5.1 → table2rules-0.6.0}/src/table2rules/grid_parser.py

@@ -465,6 +465,28 @@ def parse_table_to_grid(table: Tag) -> List[List[Dict[str, Any]]]:
                 continue
             promote_cols.add(c)
 
+        # --- Signal C: stub-dimension columns under the leftmost top-level
+        # header group ---
+        # When the leftmost top-level (row 0) header spans more than one column
+        # AND a distinct value-header group exists to its right, that leftmost
+        # group is the row-label dimension (e.g. a "SECTION" header spanning the
+        # rownum and person-class columns, beside a "MAXIMUM LIMIT" value group).
+        # Its descriptor columns are row labels even though they carry thead text
+        # — promoting them threads the row identity (the person-class) into each
+        # value line, not just the leading rownum, mirroring the column path.
+        top0 = grid[0][0] if grid and grid[0] else None
+        if top0 and top0.get("is_thead"):
+            stub_origin = top0.get("origin", (0, 0)) if top0.get("is_span_copy") else (0, 0)
+            stub_cell = grid[stub_origin[0]][stub_origin[1]]
+            stub_width = stub_cell.get("colspan", 1) if stub_cell else 1
+            has_value_group_right = stub_width < max_cols and any(
+                has_thead_text[c] for c in range(stub_width, max_cols)
+            )
+            if stub_width >= 2 and has_value_group_right:
+                for c in range(stub_width):
+                    if _descriptor_like(c):
+                        promote_cols.add(c)
+
         if promote_cols:
             for c in sorted(promote_cols):
                 for r in range(data_start_row_idx, len(grid)):

{table2rules-0.5.1 → table2rules-0.6.0}/src/table2rules/maze_pathfinder.py

@@ -116,51 +116,81 @@ def find_headers_for_cell(
             if scope == "row":
                 continue
 
-            # Locate the origin for scope and rowspan lookup.
+            # scope='rowgroup' bands are handled uniformly in Step 4 (which also
+            # reaches bands spanning the data column when the row-label is
+            # empty), so they can be ordered across columns by nesting level.
+            if scope == "rowgroup":
+                continue
+
+            # Non-scope-rowgroup <th> cells outside thead are only accepted from
+            # the explicit header block (headless tables where header detection
+            # promoted a row).
+            if not cell.get("is_header_row", False):
+                continue
+
+            # Locate the origin for dedup.
             if cell.get("is_span_copy", False):
                 origin = cell.get("origin", (r, header_col))
-                origin_cell = grid[origin[0]][origin[1]]
             else:
                 origin = (r, header_col)
-                origin_cell = cell
-
-            if scope == "rowgroup":
-                # A rowgroup header ancestors rows within its extent:
-                #   rowspan > 1  → extent = [origin_row, origin_row + rowspan - 1]
-                #                  (the rowspan itself bounds the group, as in
-                #                  a <th scope="rowgroup" rowspan="2"> pattern)
-                #   rowspan == 1 → extent = [origin_row, next_rowgroup - 1]
-                #                  (a single-cell divider row like a FinTabNet
-                #                  year label runs until the next such divider
-                #                  in the same column)
-                origin_row, origin_col = origin
-                origin_rowspan = origin_cell.get("rowspan", 1)
-                if origin_rowspan > 1:
-                    extent_end = origin_row + origin_rowspan - 1
-                else:
-                    extent_end = len(grid) - 1
-                    for rr in range(origin_row + 1, len(grid)):
-                        other = grid[rr][origin_col]
-                        if (
-                            other
-                            and not other.get("is_span_copy", False)
-                            and other.get("scope") == "rowgroup"
-                        ):
-                            extent_end = rr - 1
-                            break
-                if row > extent_end:
-                    continue
-            else:
-                # Non-scope-rowgroup <th> cells outside thead are only
-                # accepted from the explicit header block (headless
-                # tables where the header detection promoted a row).
-                is_header_row = cell.get("is_header_row", False)
-                if not is_header_row:
-                    continue
 
             if origin not in seen_origins:
                 seen_origins.add(origin)
                 # Insert at the beginning to maintain hierarchy
                 row_headers.insert(row_header_columns.index(header_col), cell["text"])
 
+    # --- 4. Row-group bands ---
+    # A band / group header ancestors the data rows within its extent. Bands are
+    # collected from the data cell's own column AND every row-label column: the
+    # own column reaches bands that span the value region even when this row's
+    # label cell is empty (which would otherwise drop the band, e.g. an
+    # unlabeled continuation row under a group divider); the row-label columns
+    # reach narrow stub-column dividers (a FinTabNet year label). Extent is
+    # bounded by COLSPAN — a band ends at the next band whose span is equal or
+    # wider — so a narrower inner group header does not close an outer one.
+    # Bands are ordered topmost-first (origin row ascending) and prepended, so
+    # the row path reads outer-band > inner-group > row-labels, mirroring the
+    # multi-level column path.
+    bands: List[Tuple[int, str]] = []  # (origin_row, text)
+    for scan_col in [col, *row_header_columns]:
+        for r in range(row - 1, -1, -1):
+            cell = grid[r][scan_col]
+            if not cell or not cell.get("text", "").strip():
+                continue
+            if cell["type"] != "th" or cell.get("is_thead", False):
+                continue
+            if cell.get("scope") != "rowgroup":
+                continue
+            if cell.get("is_span_copy", False):
+                origin = cell.get("origin", (r, scan_col))
+                origin_cell = grid[origin[0]][origin[1]]
+            else:
+                origin = (r, scan_col)
+                origin_cell = cell
+            if origin in seen_origins:
+                continue
+            origin_row, origin_col = origin
+            my_colspan = origin_cell.get("colspan", 1)
+            origin_rowspan = origin_cell.get("rowspan", 1)
+            if origin_rowspan > 1:
+                extent_end = origin_row + origin_rowspan - 1
+            else:
+                extent_end = len(grid) - 1
+                for rr in range(origin_row + 1, len(grid)):
+                    other = grid[rr][origin_col]
+                    if (
+                        other
+                        and not other.get("is_span_copy", False)
+                        and other.get("scope") == "rowgroup"
+                        and other.get("colspan", 1) >= my_colspan
+                    ):
+                        extent_end = rr - 1
+                        break
+            if row > extent_end:
+                continue
+            seen_origins.add(origin)
+            bands.append((origin_row, cell["text"]))
+    bands.sort(key=lambda b: b[0])
+    row_headers[:0] = [text for _row, text in bands]
+
     return row_headers, col_headers

{table2rules-0.5.1 → table2rules-0.6.0}/src/table2rules/simple_repair.py

@@ -301,6 +301,29 @@ def detect_header_block(rows):
             first_data_idx = r
             break
 
+    # Full-width section dividers cap the header. A row whose only non-empty
+    # content is a single DOM cell spanning the whole width (e.g. a benefits
+    # schedule "1. PERSONAL ACCIDENT" <td colspan="8"> row) reads, under the
+    # colspan-expanded non-empty count used above, as a full multi-cell header
+    # row — so without this the header sweep swallows the divider *and* the
+    # body rows between it and the first clean data row, bleeding them onto
+    # every line as fabricated column headers. When such dividers form a series
+    # (>= 2) they are body section dividers, not a one-off header subtitle like
+    # "(Dollars in thousands)"; the header ends at the first one. They stay in
+    # the body as plain cells (rendered as full-width notes downstream).
+    full_width_divider_idxs = []
+    for r in range(n):
+        origins = {grid[r][c]["origin"] for c in range(max_cols) if grid[r][c]["nonempty"]}
+        if len(origins) != 1:
+            continue
+        (orow, ocol) = next(iter(origins))
+        if grid[orow][ocol]["cs"] >= max_cols:
+            full_width_divider_idxs.append(r)
+    if len(full_width_divider_idxs) >= 2:
+        first_divider = full_width_divider_idxs[0]
+        if first_divider > 0 and (first_data_idx is None or first_divider < first_data_idx):
+            first_data_idx = first_divider
+
     if first_data_idx is None or first_data_idx == 0:
         return None
 
@@ -720,7 +743,16 @@ def simple_repair(html: str) -> str:
                     # counter stays in sync with the grid, otherwise a cell
                     # at logical col > 0 in a subsequent row would be
                     # mistaken for the first-column cell.
-                    if first.name == "td":
+                    #
+                    # A row whose single cell spans multiple columns is a
+                    # section divider / full-width note, not a row label —
+                    # promoting it to <th scope="row"> strands it (it has no
+                    # value column to anchor a rule, so it vanishes). Leave it
+                    # a <td> so it is emitted once as a full-width note.
+                    is_full_width_single = (
+                        len(cells) == 1 and clamped_span(first.get("colspan")) > 1
+                    )
+                    if first.name == "td" and not is_full_width_single:
                         first.name = "th"
                         first["scope"] = "row"
                     rowspan = clamped_span(first.get("rowspan"))

{table2rules-0.5.1 → table2rules-0.6.0}/src/table2rules/spans.py

@@ -27,6 +27,21 @@ def clamped_span(raw) -> int:
     return value
 
 
+def is_full_width_note(col_idx: int, colspan: int, n_cols: int) -> bool:
+    """True when a wide data cell is structurally a full-width note/description.
+
+    A ``<td>`` that reaches the last column AND spans a majority of the grid's
+    columns (e.g. a benefit name or a "If the departure…" sentence spanning the
+    whole value region of a plan×cover matrix) is a description, not a
+    per-column value. Such a cell must collapse to a single rule rather than fan
+    out across every spanned column — and the confidence gate must count it as a
+    single candidate position to match. Legitimate narrow spans (a right-edge
+    ``colspan=2`` amount covering two sub-columns of one group) fail the majority
+    test and keep their per-column fan-out.
+    """
+    return colspan > 1 and (col_idx + colspan == n_cols) and (colspan * 2 > n_cols)
+
+
 def assert_grid_size(rows: int, cols: int) -> None:
     """Raise if a logical grid shape would exceed the configured cell cap."""
     total_cells = rows * cols

{table2rules-0.5.1 → table2rules-0.6.0/src/table2rules.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table2rules
-Version: 0.5.1
+Version: 0.6.0
 Summary: Convert HTML tables to flat, LLM-friendly rules using spatial pathfinding.
 Author: PebbleRoad Pte Ltd
 License-Expression: MIT