table2rules 0.5.1__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table2rules
-Version: 0.5.1
+Version: 0.5.2
 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.5.2}/pyproject.toml

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

{table2rules-0.5.1 → table2rules-0.5.2}/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(
@@ -302,6 +320,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.5.2}/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.5.2}/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.5.2/src/table2rules.egg-info}/PKG-INFO

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