parse-bench 1.0.6__tar.gz → 1.0.7__tar.gz

{parse_bench-1.0.6 → parse_bench-1.0.7}/CHANGELOG.md

@@ -66,6 +66,13 @@ All notable changes to `parse-bench` are recorded here. The format follows
   now computed with a small numpy implementation that matches
   `sklearn.metrics.average_precision_score` (including tied-score handling),
   so evaluation numbers are unchanged. `scipy` remains a core dependency.
+- Built-in providers now register on the first `create_provider` call instead
+  of when `parse_bench.inference.providers` (or any module under it) is
+  imported. Importing `parse_bench.extensions` or the layout adapter and label
+  mapper registries no longer loads every provider and its SDK: about 0.4 s
+  instead of about 4.8 s in a full install. The provider subpackages expose
+  `load_providers()` and the registry `load_builtin_providers()`; code that
+  read `_PROVIDER_REGISTRY` directly should call the latter first.
 
 ## [1.0.2] - 2026-09-04
 

{parse_bench-1.0.6 → parse_bench-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: parse-bench
-Version: 1.0.6
+Version: 1.0.7
 Summary: ParseBench: a benchmark and evaluation harness for document parsing systems on real-world enterprise documents
 Project-URL: Homepage, https://parsebench.ai
 Project-URL: Repository, https://github.com/run-llama/ParseBench

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/__init__.py

@@ -1,3 +1,3 @@
 """Document parsing evaluation system for competitive benchmarking."""
 
-__version__ = "1.0.6"
+__version__ = "1.0.7"

parse_bench-1.0.7/src/parse_bench/evaluation/_registration.py

@@ -0,0 +1,37 @@
+"""Shared replacement semantics for keyed layout registrations."""
+
+from collections.abc import Sequence
+from typing import Protocol
+
+
+class _KeyedRegistration(Protocol):
+    @property
+    def keys(self) -> tuple[str, ...]: ...
+
+
+def updated_registrations[RegistrationT: _KeyedRegistration](
+    registrations: Sequence[RegistrationT],
+    replacement: RegistrationT,
+    *,
+    dangerous_override: bool,
+) -> Sequence[RegistrationT]:
+    """Replace at the first matched position, retaining unrelated tie order."""
+    requested = set(replacement.keys)
+    updated: list[RegistrationT] = []
+    inserted = False
+    for entry in registrations:
+        overlap = requested.intersection(entry.keys)
+        if len(overlap) == 0:
+            updated.append(entry)
+            continue
+        if not dangerous_override:
+            raise ValueError(f"Layout implementation already registered for keys {sorted(overlap)}")
+        omitted = set(entry.keys) - requested
+        if len(omitted) > 0:
+            raise ValueError(f"Override must include all aliases of the replaced registration: {sorted(omitted)}")
+        if not inserted:
+            updated.append(replacement)
+            inserted = True
+    if not inserted:
+        updated.append(replacement)
+    return updated

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/layout_adapters/registry.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import TypeVar
 
+from parse_bench.evaluation._registration import updated_registrations
 from parse_bench.evaluation.layout_adapters.base import LayoutAdapter
 from parse_bench.inference.pipelines import get_pipeline
 from parse_bench.schemas.pipeline import PipelineSpec
@@ -22,27 +24,23 @@ class _LayoutAdapterRegistration:
 
 _LAYOUT_ADAPTER_REGISTRY: list[_LayoutAdapterRegistration] = []
 
+# Bound to the concrete class so the decorator hands back that class, not ``type[LayoutAdapter]``.
+LayoutAdapterT = TypeVar("LayoutAdapterT", bound=type[LayoutAdapter])
+
 
 def register_layout_adapter(
     *provider_keys: str,
     priority: int = 0,
-) -> Callable[[type[LayoutAdapter]], type[LayoutAdapter]]:
+    _DANGEROUSLY_OVERRIDE: bool = False,
+) -> Callable[[LayoutAdapterT], LayoutAdapterT]:
     """Register a layout adapter class for one or more provider keys."""
     if not provider_keys:
         raise ValueError("register_layout_adapter requires at least one provider key")
 
-    def decorator(cls: type[LayoutAdapter]) -> type[LayoutAdapter]:
-        existing_keys = {key for entry in _LAYOUT_ADAPTER_REGISTRY for key in entry.keys}
-        for key in provider_keys:
-            if key in existing_keys:
-                raise ValueError(f"Layout adapter already registered for provider key '{key}'")
-
-        _LAYOUT_ADAPTER_REGISTRY.append(
-            _LayoutAdapterRegistration(
-                keys=tuple(provider_keys),
-                priority=priority,
-                adapter_cls=cls,
-            )
+    def decorator(cls: LayoutAdapterT) -> LayoutAdapterT:
+        replacement = _LayoutAdapterRegistration(keys=tuple(provider_keys), priority=priority, adapter_cls=cls)
+        _LAYOUT_ADAPTER_REGISTRY[:] = updated_registrations(
+            _LAYOUT_ADAPTER_REGISTRY, replacement, dangerous_override=_DANGEROUSLY_OVERRIDE
         )
         return cls
 

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/layout_label_mappers/registry.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import TypeVar
 
+from parse_bench.evaluation._registration import updated_registrations
 from parse_bench.evaluation.layout_adapters.registry import resolve_layout_provider_name
 from parse_bench.evaluation.layout_label_mappers.base import (
     LayoutLabelMapper,
@@ -26,26 +28,23 @@ _LAYOUT_LABEL_MAPPER_REGISTRY: list[_LayoutLabelMapperRegistration] = []
 _DEFAULT_LAYOUT_MAPPER_KEY = "__default__"
 
 
+# Bound to the concrete class so the decorator hands back that class, not ``type[LayoutLabelMapper]``.
+LayoutLabelMapperT = TypeVar("LayoutLabelMapperT", bound=type[LayoutLabelMapper])
+
+
 def register_layout_label_mapper(
     *mapper_keys: str,
     priority: int = 0,
-) -> Callable[[type[LayoutLabelMapper]], type[LayoutLabelMapper]]:
+    _DANGEROUSLY_OVERRIDE: bool = False,
+) -> Callable[[LayoutLabelMapperT], LayoutLabelMapperT]:
     """Register a layout label mapper for one or more keys."""
     if not mapper_keys:
         raise ValueError("register_layout_label_mapper requires at least one key")
 
-    def decorator(cls: type[LayoutLabelMapper]) -> type[LayoutLabelMapper]:
-        existing_keys = {key for entry in _LAYOUT_LABEL_MAPPER_REGISTRY for key in entry.keys}
-        for key in mapper_keys:
-            if key in existing_keys:
-                raise ValueError(f"Layout label mapper already registered for key '{key}'")
-
-        _LAYOUT_LABEL_MAPPER_REGISTRY.append(
-            _LayoutLabelMapperRegistration(
-                keys=tuple(mapper_keys),
-                priority=priority,
-                mapper_cls=cls,
-            )
+    def decorator(cls: LayoutLabelMapperT) -> LayoutLabelMapperT:
+        replacement = _LayoutLabelMapperRegistration(keys=tuple(mapper_keys), priority=priority, mapper_cls=cls)
+        _LAYOUT_LABEL_MAPPER_REGISTRY[:] = updated_registrations(
+            _LAYOUT_LABEL_MAPPER_REGISTRY, replacement, dangerous_override=_DANGEROUSLY_OVERRIDE
         )
         return cls
 

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/metrics/parse/rules_base.py

@@ -3,6 +3,7 @@
 import logging
 import re
 from collections.abc import Callable
+from dataclasses import dataclass
 from html import unescape
 from pathlib import Path
 from typing import Any
@@ -494,26 +495,38 @@ class ParseTestRule:
         }
 
 
-_RULE_CLASS_REGISTRY: dict[str, type["ParseTestRule"]] = {}
+@dataclass(frozen=True)
+class _RuleClassRegistration:
+    rule_class: type[ParseTestRule]
+    overrides_normalization: bool
 
 
-def register_rule_class(rule_type: str, rule_class: type["ParseTestRule"]) -> None:
+_RULE_CLASS_REGISTRY: dict[str, _RuleClassRegistration] = {}
+
+
+def register_rule_class(
+    rule_type: str, rule_class: type["ParseTestRule"], *, _DANGEROUSLY_OVERRIDE: bool = False
+) -> None:
     """Register the scoring class for an additional rule ``type``.
 
     Consulted by :func:`create_test_rule` before the built-in dispatch, so an
     extension can add rule types without editing this module. Pair with
     ``parse_rule_schemas.register_parse_rule_model`` so the payload validates.
     """
-    if not isinstance(rule_type, str) or not rule_type:
+    _validate_rule_class(rule_type, rule_class)
+    _RULE_CLASS_REGISTRY[rule_type] = _RuleClassRegistration(rule_class, _DANGEROUSLY_OVERRIDE)
+
+
+def _validate_rule_class(rule_type: str, rule_class: type["ParseTestRule"]) -> None:
+    if not isinstance(rule_type, str) or len(rule_type) == 0:
         raise ValueError("rule_type must be a non-empty string")
-    if not (isinstance(rule_type, str) and isinstance(rule_class, type) and issubclass(rule_class, ParseTestRule)):
+    if not (isinstance(rule_class, type) and issubclass(rule_class, ParseTestRule)):
         raise TypeError("rule_class must subclass ParseTestRule")
-    _RULE_CLASS_REGISTRY[rule_type] = rule_class
 
 
 def registered_rule_classes() -> dict[str, type["ParseTestRule"]]:
     """Snapshot of extension rule classes keyed by rule ``type``."""
-    return dict(_RULE_CLASS_REGISTRY)
+    return {rule_type: entry.rule_class for rule_type, entry in _RULE_CLASS_REGISTRY.items()}
 
 
 _REFERENCE_THUMBNAILER: Callable[[Path], str | None] | None = None
@@ -643,6 +656,10 @@ def create_test_rule(rule_data: ParseRuleInput) -> "ParseTestRule":
 
     typed_rule: Any = coerce_parse_rule(rule_data)
     rule_type = get_rule_type(typed_rule)
+    registered = _RULE_CLASS_REGISTRY.get(rule_type)
+    if registered is not None and registered.overrides_normalization:
+        return registered.rule_class(typed_rule)
+
     if typed_rule.get("text_normalization") == "text-v2.1":
         from parse_bench.evaluation.metrics.parse.text_v21 import RULE_TYPES, VisibleTextBagRule
 
@@ -652,9 +669,8 @@ def create_test_rule(rule_data: ParseRuleInput) -> "ParseTestRule":
     if not rule_type:
         raise ValueError("Rule must have a 'type' field")
 
-    registered = _RULE_CLASS_REGISTRY.get(rule_type)
     if registered is not None:
-        return registered(typed_rule)
+        return registered.rule_class(typed_rule)
 
     if rule_type in {TestType.PRESENT.value, TestType.ABSENT.value}:
         return TextPresenceRule(typed_rule)

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/metrics/parse/rules_formatting.py

@@ -12,7 +12,7 @@ from parse_bench.evaluation.metrics.parse.rules_base import (
     is_degenerate_marker_text,
 )
 from parse_bench.evaluation.metrics.parse.test_types import TestType
-from parse_bench.evaluation.metrics.parse.utils import _normalize_quotes, normalize_text
+from parse_bench.evaluation.metrics.parse.utils import _TAG_REST, _normalize_quotes, normalize_text
 from parse_bench.test_cases.parse_rule_schemas import (
     ParseAbsentUnlessStrikeoutRule,
     ParseCodeBlockRule,
@@ -121,28 +121,28 @@ _STRIP_PATTERNS: dict[str, list[tuple[re.Pattern, str]]] = {
     "bold": [
         (re.compile(r"\*\*\*(.+?)\*\*\*", re.DOTALL), r"\1"),
         (re.compile(r"\*\*(.+?)\*\*", re.DOTALL), r"\1"),
-        (re.compile(r"</?(?:b|strong)>", re.IGNORECASE), ""),
+        (re.compile(rf"</?(?:b|strong){_TAG_REST}", re.IGNORECASE), ""),
     ],
     "italic": [
         (re.compile(r"(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)"), r"\1"),
         (re.compile(r"(?<!_)_(?!_)(.+?)(?<!_)_(?!_)"), r"\1"),
-        (re.compile(r"</?(?:i|em)>", re.IGNORECASE), ""),
+        (re.compile(rf"</?(?:i|em){_TAG_REST}", re.IGNORECASE), ""),
     ],
     "underline": [
-        (re.compile(r"</?(?:u|ins)>", re.IGNORECASE), ""),
+        (re.compile(rf"</?(?:u|ins){_TAG_REST}", re.IGNORECASE), ""),
     ],
     "strikeout": [
         (re.compile(r"~~"), ""),
-        (re.compile(r"</?(?:s|del|strike)>", re.IGNORECASE), ""),
+        (re.compile(rf"</?(?:s|del|strike){_TAG_REST}", re.IGNORECASE), ""),
     ],
     "mark": [
-        (re.compile(r"</?mark\b[^>]*>", re.IGNORECASE), ""),
+        (re.compile(rf"</?mark{_TAG_REST}", re.IGNORECASE), ""),
     ],
     "sup": [
-        (re.compile(r"</?sup>", re.IGNORECASE), ""),
+        (re.compile(rf"</?sup{_TAG_REST}", re.IGNORECASE), ""),
     ],
     "sub": [
-        (re.compile(r"</?sub>", re.IGNORECASE), ""),
+        (re.compile(rf"</?sub{_TAG_REST}", re.IGNORECASE), ""),
     ],
 }
 
@@ -514,6 +514,9 @@ class MarkColorRule(ParseTestRule):
     2. The ``<mark>`` tag contains the expected color string in any of its attributes
        (e.g. ``style="background-color: yellow"``, ``background="yellow"``,
        ``backgroundColor="yellow"``).
+       When the expected color is a hue family name (``yellow``, ``green``, ...),
+       a hex, ``rgb()`` or named value in that family also passes
+       (``background-color:#ffff00``).
     """
 
     def __init__(self, rule_data: ParseMarkColorRule | dict):
@@ -533,6 +536,14 @@ class MarkColorRule(ParseTestRule):
             raise ValueError("Color field cannot be empty")
         self.color = raw_color.strip().lower()
 
+    def _attrs_carry_color(self, attrs_str: str) -> bool:
+        """True when the attributes name the expected color, or a highlight
+        (background) value is a hex, ``rgb()`` or named color in its hue family
+        (adjacent families accepted, as in ``TextColorRule``)."""
+        if self.color in attrs_str.lower():
+            return True
+        return any(_families_match(self.color, f) for f in _highlight_color_families(attrs_str))
+
     def run(self, md_content: str, normalized_content: str | None = None) -> tuple[bool, str]:
         """Check if text is inside a <mark> tag that contains the expected color."""
         escaped_query = re.escape(self.text)
@@ -549,8 +560,7 @@ class MarkColorRule(ParseTestRule):
             if not text_pattern.search(inner_text):
                 continue
 
-            # Check if the color string appears in the tag attributes
-            if self.color in attrs_str.lower():
+            if self._attrs_carry_color(attrs_str):
                 return True, ""
 
         # Fallback: strip other formatting and retry
@@ -562,7 +572,7 @@ class MarkColorRule(ParseTestRule):
             if not text_pattern.search(inner_text):
                 continue
 
-            if self.color in attrs_str.lower():
+            if self._attrs_carry_color(attrs_str):
                 return True, ""
 
         return (
@@ -787,6 +797,26 @@ def _extract_color_families(attrs_str: str) -> set[str]:
     return families
 
 
+# Highlight color declarations or attributes: CSS background / background-color,
+# HTML background=, React-style backgroundColor=. Foreground color is excluded.
+_HIGHLIGHT_VALUE_RE = re.compile(r"(?<![\w-])background(?:-?color)?\s*[:=]\s*[\"']?([^;\"'>]+)", re.IGNORECASE)
+
+
+def _highlight_color_families(attrs_str: str) -> set[str]:
+    """Hue families of a tag's highlight (background) colors only: hex, ``rgb()``
+    or a named color such as ``gold``. A foreground ``color`` never counts."""
+    families: set[str] = set()
+    for m in _HIGHLIGHT_VALUE_RE.finditer(attrs_str):
+        value = m.group(1)
+        families |= _extract_color_families(value)
+        for name in re.findall(r"[a-zA-Z]+", value):
+            rgb = _NAMED_COLOR_RGB.get(name.lower())
+            fam = _rgb_to_hue_family(*rgb) if rgb else None
+            if fam:
+                families.add(fam)
+    return families
+
+
 class TextColorRule(ParseTestRule):
     """Test rule verifying that text carries a specific text color.
 

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/metrics/parse/table_record_match_metric.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 
 import logging
 import re
+from collections.abc import Sequence
+from dataclasses import replace
 from typing import Any
 
 import numpy as np
@@ -132,87 +134,57 @@ def _normalize_trm_table_text(text: str) -> str:
     return _normalize_trm_cell_text(text)
 
 
-def normalize_table(table: TableData) -> TableData:
-    """Normalize all cell text in a table for comparison.
-
-    Applies normalize_text() + _normalize_trm_cell_text() to every cell in
-    table.data and to col_headers text, producing a new TableData with
-    normalized values throughout. Columns whose data cells AND header
-    entries are all empty strings after normalization are dropped, and
-    remaining column indices are renumbered to stay contiguous.
-    """
-    if table.data.size == 0:
-        return table
-    n_rows, n_cols = table.data.shape
+def _normalize_table_text(table: TableData) -> TableData:
     normalized = np.empty_like(table.data)
-    for r in range(n_rows):
-        for c in range(n_cols):
-            normalized[r, c] = _normalize_trm_table_text(str(table.data[r, c]))
-    # Normalize col_headers and row_headers metadata to match data cell normalization
-    normalized_col_headers: dict[int, list[tuple[int, str]]] = {}
-    for col_idx, entries in table.col_headers.items():
-        normalized_col_headers[col_idx] = [(row_idx, _normalize_trm_table_text(text)) for row_idx, text in entries]
-    normalized_row_headers: dict[int, list[tuple[int, str]]] = {}
-    for row_idx, entries in table.row_headers.items():
-        normalized_row_headers[row_idx] = [(col_idx, _normalize_trm_table_text(text)) for col_idx, text in entries]
-
-    # Drop columns whose data cells AND header entries are all literally
-    # empty strings after normalization. Such columns add noise to header
-    # alignment and inflate the union denominator used by _record_similarity
-    # without contributing any signal. Sentinel values like "-" or "n/a"
-    # count as real content and are NOT dropped.
-    #
-    # This runs independently on GT and pred, so the two normalized tables
-    # may end up with *different* column counts when (say) GT has an empty
-    # column 2 but pred has real content there. That's intentional: record
-    # matching is content-driven — ``_record_similarity`` compares columns
-    # via the ``column_mapping`` keyed by header text, not by positional
-    # index, so differing shapes are fine and the unmapped column on the
-    # longer side penalizes the score via ``max(n_gt_cols, n_pred_cols)``.
-    def _col_is_empty(c: int) -> bool:
-        for r in range(n_rows):
-            if str(normalized[r, c]) != "":
-                return False
-        for _row_idx, text in normalized_col_headers.get(c, []):
-            if text != "":
-                return False
-        return True
-
-    keep_cols = [c for c in range(n_cols) if not _col_is_empty(c)]
-    if len(keep_cols) != n_cols:
-        old_to_new = {old: new for new, old in enumerate(keep_cols)}
-        normalized = normalized[:, keep_cols]
-        normalized_col_headers = {
-            old_to_new[c]: normalized_col_headers[c] for c in keep_cols if c in normalized_col_headers
-        }
-        header_cols = {old_to_new[c] for c in table.header_cols if c in old_to_new}
-        header_cells = {(r, old_to_new[c]) for (r, c) in table.header_cells if c in old_to_new}
-        normalized_row_headers = {
-            row_idx: [(old_to_new[c], text) for c, text in entries if c in old_to_new]
-            for row_idx, entries in normalized_row_headers.items()
-        }
-    else:
-        header_cols = table.header_cols
-        header_cells = table.header_cells
-
-    return TableData(
+    for row in range(table.data.shape[0]):
+        for col in range(table.data.shape[1]):
+            normalized[row, col] = _normalize_trm_table_text(str(table.data[row, col]))
+    return replace(
+        table,
         data=normalized,
-        header_rows=table.header_rows,
-        header_cols=header_cols,
-        col_headers=normalized_col_headers,
-        row_headers=normalized_row_headers,
-        header_cells=header_cells,
-        thead_rows=table.thead_rows,
-        tbody_rows=table.tbody_rows,
-        tfoot_rows=table.tfoot_rows,
-        column_scope_rows=table.column_scope_rows,
-        row_scope_rows=table.row_scope_rows,
-        caption=table.caption,
-        context_before=table.context_before,
-        context_after=table.context_after,
+        col_headers={
+            col: [(row, _normalize_trm_table_text(text)) for row, text in entries]
+            for col, entries in table.col_headers.items()
+        },
+        row_headers={
+            row: [(col, _normalize_trm_table_text(text)) for col, text in entries]
+            for row, entries in table.row_headers.items()
+        },
     )
 
 
+def _select_table_columns(table: TableData, columns: Sequence[int]) -> TableData:
+    old_to_new = {old: new for new, old in enumerate(columns)}
+    return replace(
+        table,
+        data=table.data[:, list(columns)],
+        header_cols={old_to_new[col] for col in table.header_cols if col in old_to_new},
+        col_headers={old_to_new[col]: entries for col, entries in table.col_headers.items() if col in old_to_new},
+        row_headers={
+            row: [(old_to_new[col], text) for col, text in entries if col in old_to_new]
+            for row, entries in table.row_headers.items()
+        },
+        header_cells={(row, old_to_new[col]) for row, col in table.header_cells if col in old_to_new},
+        spanned_cells={(row, old_to_new[col]) for row, col in table.spanned_cells if col in old_to_new},
+    )
+
+
+def normalize_table(table: TableData, *, preserve_text: bool = False) -> TableData:
+    """Drop normalized-empty columns, returning normalized or original text."""
+    if table.data.size == 0:
+        return table
+    normalized = _normalize_table_text(table)
+    # Both representations use normalized emptiness, including header text.
+    # Sentinel values such as "-" and "n/a" remain real content.
+    columns = [
+        col
+        for col in range(normalized.data.shape[1])
+        if any(value != "" for value in normalized.data[:, col])
+        or any(text != "" for _, text in normalized.col_headers.get(col, []))
+    ]
+    return _select_table_columns(table if preserve_text else normalized, columns)
+
+
 def cell_score(expected: str, actual: str) -> float:
     """Score similarity between two cell values: 1.0 for match, 0.0 otherwise.
 

{parse_bench-1.0.6 → parse_bench-1.0.7}/src/parse_bench/evaluation/metrics/parse/table_splitting.py

@@ -22,7 +22,7 @@ circular import with ``table_record_match_metric``.
 from __future__ import annotations
 
 import itertools
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING
 
 from rapidfuzz import fuzz
@@ -99,50 +99,56 @@ def _detect_period_candidates(
     return candidates
 
 
+def _trim_trailing_padding(table: TableData) -> TableData:
+    """Remove only empty tail rows, preserving metadata for retained rows."""
+    end = table.data.shape[0]
+    # Metadata can carry header text even when the grid cell is empty.
+    header_text_rows = {
+        r for entries in table.col_headers.values() for r, text in entries if len(str(text).strip()) > 0
+    }
+    header_text_rows.update(
+        r for r, entries in table.row_headers.items() if any(len(str(text).strip()) > 0 for _, text in entries)
+    )
+    while (
+        end > 0
+        and end - 1 not in header_text_rows
+        and not any(len(str(value).strip()) > 0 for value in table.data[end - 1])
+    ):
+        end -= 1
+    if end == table.data.shape[0]:
+        return table
+    row_sets = ("header_rows", "thead_rows", "tbody_rows", "tfoot_rows", "column_scope_rows", "row_scope_rows")
+    return replace(
+        table,
+        data=table.data[:end],
+        **{name: {r for r in getattr(table, name) if r < end} for name in row_sets},
+        col_headers={c: [(r, text) for r, text in entries if r < end] for c, entries in table.col_headers.items()},
+        row_headers={r: entries for r, entries in table.row_headers.items() if r < end},
+        header_cells={(r, c) for r, c in table.header_cells if r < end},
+        spanned_cells={(r, c) for r, c in table.spanned_cells if r < end},
+    )
+
+
 def build_sub_table(
     pred_table: TableData,
     start: int,
     end: int,
 ) -> TableData:
-    """Build a sub-table from a column range of the pred table."""
-    sub_data = pred_table.data[:, start:end]
-
-    n_rows = sub_data.shape[0]
-    last_nonempty = n_rows
-    for r in range(n_rows - 1, -1, -1):
-        if any(str(sub_data[r, c]).strip() for c in range(sub_data.shape[1])):
-            last_nonempty = r + 1
-            break
-    else:
-        last_nonempty = 0
-    if last_nonempty < n_rows:
-        sub_data = sub_data[:last_nonempty, :]
-
-    sub_col_headers: dict[int, list[tuple[int, str]]] = {}
-    sub_header_cols: set[int] = set()
-    for new_c, old_c in enumerate(range(start, end)):
-        if old_c in pred_table.col_headers:
-            sub_col_headers[new_c] = pred_table.col_headers[old_c]
-        if old_c in pred_table.header_cols:
-            sub_header_cols.add(new_c)
-
-    sub_header_cells: set[tuple[int, int]] = set()
-    for r, c in pred_table.header_cells:
-        if start <= c < end and r < last_nonempty:
-            sub_header_cells.add((r, c - start))
-
-    return TableData(
-        data=sub_data,
-        header_rows=pred_table.header_rows.copy(),
-        header_cols=sub_header_cols,
-        col_headers=sub_col_headers,
-        row_headers={},
-        header_cells=sub_header_cells,
-        thead_rows=set(pred_table.thead_rows),
-        tbody_rows={r for r in pred_table.tbody_rows if r < last_nonempty},
-        tfoot_rows={r for r in pred_table.tfoot_rows if r < last_nonempty},
-        column_scope_rows={r for r in pred_table.column_scope_rows if r < last_nonempty},
-        row_scope_rows={r for r in pred_table.row_scope_rows if r < last_nonempty},
+    """Slice columns and trim blank tail rows without losing header relationships."""
+    return _trim_trailing_padding(
+        replace(
+            pred_table,
+            data=pred_table.data[:, start:end],
+            header_cols={c - start for c in pred_table.header_cols if start <= c < end},
+            col_headers={c - start: entries for c, entries in pred_table.col_headers.items() if start <= c < end},
+            row_headers={
+                r: [(c - start, text) for c, text in entries if start <= c < end]
+                for r, entries in pred_table.row_headers.items()
+                if any(start <= c < end for c, _ in entries)
+            },
+            header_cells={(r, c - start) for r, c in pred_table.header_cells if start <= c < end},
+            spanned_cells={(r, c - start) for r, c in pred_table.spanned_cells if start <= c < end},
+        )
     )
 
 
@@ -283,8 +289,15 @@ def split_ambiguous_merged_pred(
     sub-tables emitted from a split have ``raw_html=""`` since they have no
     meaningful HTML to attribute back to the source.
 
+    When a split is applied, normalize trailing blank padding on both sides.
+    The peer ``expected`` list is updated in place with replacement tables;
+    original TableData objects and source HTML remain unchanged. No-split
+    calls leave both inputs untouched.
+
     Returns ``(possibly_rewritten_actual, did_split)``.
     """
+    from parse_bench.evaluation.metrics.parse.table_record_match_metric import normalize_table
+
     if len(expected) <= len(actual):
         return actual, False
 
@@ -297,5 +310,16 @@ def split_ambiguous_merged_pred(
         if opt.sub_tables is None:
             new_actual.append(original)
         else:
-            new_actual.extend(ExtractedTable(raw_html="", table_data=sub) for sub in opt.sub_tables)
+            # Keep the candidate geometry: normalization may remove spacer
+            # columns, so its offsets cannot slice the original grid directly.
+            source = normalize_table(original.table_data, preserve_text=True)
+            new_actual.extend(
+                ExtractedTable(
+                    raw_html="",
+                    table_data=build_sub_table(source, i * opt.period, (i + 1) * opt.period),
+                )
+                for i in range(opt.n_segments)
+            )
+    expected[:] = [replace(t, table_data=_trim_trailing_padding(t.table_data)) for t in expected]
+    new_actual = [replace(t, table_data=_trim_trailing_padding(t.table_data)) for t in new_actual]
     return new_actual, True