parse-bench 1.0.1__tar.gz → 1.0.2__tar.gz

{parse_bench-1.0.1 → parse_bench-1.0.2}/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to `parse-bench` are recorded here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
 [Semantic Versioning](https://semver.org/).
 
+## [1.0.2] - 2026-09-04
+
+Ports two fixes that landed in the internal harness while 1.0.1 was being cut.
+
+### Scoring (changes evaluation numbers)
+- `chart_data_point`: number parsing accepts accounting negatives (`(4)`,
+  `$(4)`, `($4)`, trailing minus), the `bn` billion suffix, and no longer
+  reads a comma followed by a space as a decimal separator. A numeric rule
+  value no longer fuzzy-matches a compound cell (`249` vs `249, 188`); a cell
+  that carries one numeric token plus an axis unit (`68.7 days`) does match.
+  A repeated column header after a body section label counts as local scope
+  only when the complete pair precedes the candidate.
+
+### Added
+- Granular pages carry a `cells` layer; the LlamaParse adapter reads the
+  provider-neutral `granular_layers` on normalized pages before falling back
+  to the grounded-page payload.
+
 ## [1.0.1] - 2026-09-03
 
 Harness-facing release: no evaluation number changes. Everything here lets a

{parse_bench-1.0.1 → parse_bench-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: parse-bench
-Version: 1.0.1
+Version: 1.0.2
 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.1 → parse_bench-1.0.2}/src/parse_bench/__init__.py

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

{parse_bench-1.0.1 → parse_bench-1.0.2}/src/parse_bench/evaluation/layout_adapters/adapters.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import re
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 
 from parse_bench.evaluation.layout_adapters.base import LayoutAdapter
@@ -60,6 +60,7 @@ class _GranularPage:
     page_number: int
     lines: list[_GranularTextUnit]
     words: list[_GranularTextUnit]
+    cells: list[_GranularTextUnit] = field(default_factory=list)
 
 
 @register_layout_adapter("__default__", priority=-100)
@@ -213,8 +214,12 @@ class LlamaParseLayoutAdapter(LayoutAdapter):
         )
 
     def to_granular_pages(self, inference_result: InferenceResult) -> list[_GranularPage]:
-        if isinstance(inference_result.output, ParseOutput) and inference_result.output.grounded_pages:
-            return _build_llamaparse_granular_pages_from_payload(inference_result.output.grounded_pages)
+        if isinstance(inference_result.output, ParseOutput):
+            normalized_pages = _build_normalized_granular_pages(inference_result.output.layout_pages)
+            if normalized_pages:
+                return normalized_pages
+            if inference_result.output.grounded_pages:
+                return _build_llamaparse_granular_pages_from_payload(inference_result.output.grounded_pages)
 
         raw_output = inference_result.raw_output if isinstance(inference_result.raw_output, dict) else {}
         grounded_pages = raw_output.get("v2_grounded_items", raw_output.get("grounded_items"))
@@ -284,6 +289,44 @@ class WarpIngestLayoutAdapter(LayoutAdapter):
         )
 
 
+def _build_normalized_granular_pages(layout_pages: list[Any]) -> list[_GranularPage]:
+    """Read provider-neutral granular layers retained on normalized Parse pages."""
+    pages: list[_GranularPage] = []
+    for page in layout_pages:
+        units_by_granularity: dict[str, list[_GranularTextUnit]] = {
+            "line": [],
+            "word": [],
+            "cell": [],
+        }
+        for layer in page.granular_layers:
+            if layer.granularity not in units_by_granularity:
+                continue
+            for unit in layer.units:
+                units_by_granularity[layer.granularity].append(
+                    _GranularTextUnit(
+                        text=unit.text,
+                        bbox=_GranularSegment(
+                            x=unit.bbox.x,
+                            y=unit.bbox.y,
+                            w=unit.bbox.w,
+                            h=unit.bbox.h,
+                            r=unit.bbox.r,
+                        ),
+                        order_index=unit.order_index,
+                    )
+                )
+        if any(units_by_granularity.values()):
+            pages.append(
+                _GranularPage(
+                    page_number=page.page_number,
+                    lines=units_by_granularity["line"],
+                    words=units_by_granularity["word"],
+                    cells=units_by_granularity["cell"],
+                )
+            )
+    return pages
+
+
 def _build_llamaparse_granular_pages_from_payload(grounded_pages: Any) -> list[_GranularPage]:
     if not isinstance(grounded_pages, list):
         return []

{parse_bench-1.0.1 → parse_bench-1.0.2}/src/parse_bench/evaluation/metrics/parse/rules_chart.py

@@ -45,6 +45,7 @@ def normalize_number_string(s: str) -> float | None:
 
     Handles:
     - Currency symbols: $, €, £, ¥
+    - Accounting negatives: (4), $(4), ($4), and trailing minus
     - Thousands separators: commas
     - Suffixes: k, K, m, M, million, billion, b, B, etc.
     - Percentage signs
@@ -61,15 +62,19 @@ def normalize_number_string(s: str) -> float | None:
     if not s:
         return None
 
-    # Remove whitespace and normalize
-    s = s.strip()
+    # Remove whitespace / approximate prefixes and normalize sign glyphs.
+    s = re.sub(r"^[~≈]\s*", "", s.strip().replace("−", "-"))
 
-    # Remove currency symbols
-    s = re.sub(r"^[$€£¥]\s*", "", s)
-    s = re.sub(r"\s*[$€£¥]$", "", s)
-
-    # Remove approximate prefixes
-    s = re.sub(r"^[~≈]\s*", "", s)
+    # Accounting reports commonly print negatives with parentheses, sometimes with
+    # the currency symbol outside them ("$(4)") and sometimes inside ("($4)").
+    negative = False
+    s = re.sub(r"[$€£¥]", "", s).strip()
+    if len(s) >= 2 and s.startswith("(") and s.endswith(")"):
+        negative = True
+        s = s[1:-1].strip()
+    if s.endswith("-"):
+        negative = not negative
+        s = s[:-1].strip()
 
     # Remove percentage sign (but remember the value)
     s = s.rstrip("%")
@@ -85,7 +90,7 @@ def normalize_number_string(s: str) -> float | None:
     multiplier = 1.0
     suffix_patterns = [
         (r"(?i)\s*(trillion|trill|trn)$", 1e12),
-        (r"(?i)\s*(billion|bill|bln)$", 1e9),
+        (r"(?i)\s*(billion|bill|bln|bn)$", 1e9),
         (r"(?i)\s*(million|mill|mln)$", 1e6),
         (r"(?i)\s*t$", 1e12),
         (r"(?i)\s*g$", 1e9),  # G = giga = billion
@@ -102,7 +107,8 @@ def normalize_number_string(s: str) -> float | None:
 
     # Try to parse as float
     try:
-        return float(s) * multiplier
+        value = float(s) * multiplier
+        return -value if negative else value
     except ValueError:
         return None
 
@@ -120,7 +126,7 @@ def _normalize_number_candidates(s: str) -> list[float]:
     if val is not None:
         candidates.append(val)
     # If s contains a comma, also try the decimal-separator interpretation.
-    if "," in s:
+    if "," in s and not re.search(r",\s", s):
         val2 = normalize_number_string(s.replace(",", "."))
         if val2 is not None and val2 not in candidates:
             candidates.append(val2)
@@ -264,11 +270,28 @@ class ChartDataPointRule(ParseTestRule):
                 # Try exact fuzzy match first
                 threshold = max(0.5, 1.0 - (self.max_diffs / max(len(value), 1)))
                 similarity = fuzz.ratio(value, cell_text) / 100.0
+                numeric_rule = self.normalize_numbers and bool(extract_numeric_parts(value))
 
-                if similarity >= threshold:
+                # Fuzzy text distance is not meaningful for numeric rules:
+                # ``249`` must not match the compound cell ``249, 188``.
+                if not numeric_rule and similarity >= threshold:
                     matches.append((row_idx, col_idx))
                 elif self.normalize_numbers and numbers_match(value, cell_text, self.relative_tolerance):
                     matches.append((row_idx, col_idx))
+                elif self.normalize_numbers:
+                    # Parsers often retain the axis unit in a numeric cell
+                    # (for example ``68.7 days``) even when the chart rule
+                    # stores only the numeric datum.  Accept that form only
+                    # when the cell contains one numeric token; a cell such as
+                    # ``249, 188`` remains ambiguous and must not satisfy
+                    # either value independently.
+                    numeric_parts = extract_numeric_parts(cell_text)
+                    if len(numeric_parts) == 1 and numbers_match(
+                        value,
+                        numeric_parts[0],
+                        self.relative_tolerance,
+                    ):
+                        matches.append((row_idx, col_idx))
 
         # Fallback: try composite value decomposition for values like "25 (13.0%)"
         # where the number and percentage are in adjacent cells.
@@ -499,8 +522,58 @@ class ChartDataPointRule(ParseTestRule):
             if (header_row, value_col) not in table_data.header_cells:
                 add(table_array[header_row, value_col])
 
+        # A chart data table may repeat a column header after a body section
+        # label, for example ``Urban`` followed by ``[blank], Total, Rural``.
+        # Some parsers preserve both rows as ``td`` cells.  Treat them as local
+        # scope only when the complete pair occurs before this candidate.  A
+        # lone body row or a lone header-like row is never allowed to leak.
+        body_section_scope = self._candidate_body_section_scope(
+            table_array,
+            value_row,
+            value_col,
+            table_data,
+        )
+        for item in body_section_scope:
+            add(item)
+
         return scope
 
+    def _candidate_body_section_scope(  # type: ignore[no-untyped-def]
+        self,
+        table_array,
+        value_row: int,
+        value_col: int,
+        table_data: TableData,
+    ) -> list[str]:
+        """Return a paired body section label and repeated column header."""
+        if value_row not in table_data.tbody_rows:
+            return []
+
+        _, cols = table_array.shape
+        repeated_header: str | None = None
+
+        for row_idx in range(value_row - 1, -1, -1):
+            if row_idx not in table_data.tbody_rows:
+                break
+
+            cells = [normalize_text(str(table_array[row_idx, col_idx])) for col_idx in range(cols)]
+            nonempty = [cell for cell in cells if cell]
+            if not nonempty:
+                continue
+
+            all_text = all(not extract_numeric_parts(cell) for cell in nonempty)
+            if repeated_header is None:
+                if all_text and not cells[0] and value_col < cols and cells[value_col]:
+                    repeated_header = cells[value_col]
+                continue
+
+            # Colspan expansion may repeat the section label in every cell,
+            # so compare unique non-empty text rather than physical cells.
+            if all_text and len(set(nonempty)) == 1:
+                return [nonempty[0], repeated_header]
+
+        return []
+
     def _labels_match_candidate_scope(  # type: ignore[no-untyped-def]
         self,
         table_array,

{parse_bench-1.0.1 → parse_bench-1.0.2}/tests/parse_bench/evaluation/metrics/parse/test_chart_data_point_rule.py

@@ -5,6 +5,7 @@ import pytest
 from parse_bench.evaluation.metrics.parse.rules_chart import (
     ChartDataPointRule,
     extract_numeric_parts,
+    numbers_match,
 )
 from parse_bench.evaluation.metrics.parse.table_parsing import (
     parse_html_tables,
@@ -37,6 +38,9 @@ class TestExtractNumericParts:
     def test_thousands_separator(self):
         assert extract_numeric_parts("1,234 (56.7%)") == ["1,234", "56.7%"]
 
+    def test_billion_abbreviation_matches_full_value(self):
+        assert numbers_match("$4.2bn", "4,200,000,000", tolerance=0)
+
 
 # ---------------------------------------------------------------------------
 # parse_html_tables – colspan/rowspan grid alignment
@@ -810,6 +814,76 @@ class TestChartDataPointRuleCandidateScope:
         assert rule.run(within)[0]
         assert not rule.run(outside)[0]
 
+    def test_single_numeric_token_with_axis_unit_matches(self) -> None:
+        table = """\
+| Category | Actual |
+| --- | --- |
+| Series A | 68.7 days |
+"""
+
+        passed, message, score = _chart_rule(
+            "68.7",
+            ["Series A", "Actual"],
+            normalize_numbers=True,
+        ).run(table)
+
+        assert passed, message
+        assert score == 1.0
+
+    def test_multiple_numeric_tokens_in_one_cell_stay_ambiguous(self) -> None:
+        table = """\
+| Country | Panel A |
+| --- | --- |
+| Finland | 249, 188 |
+"""
+
+        passed, message, score = _chart_rule(
+            "249",
+            ["Finland", "Panel A"],
+            normalize_numbers=True,
+        ).run(table)
+
+        assert not passed, message
+        assert score == 0.0
+
+    def test_paired_body_section_and_repeated_header_supply_local_scope(self) -> None:
+        table = """\
+<table>
+  <thead><tr><th></th><th>Total</th><th>Rural</th></tr></thead>
+  <tbody>
+    <tr><td>FY2016</td><td>926</td><td>637</td></tr>
+    <tr><td>Urban</td><td></td><td></td></tr>
+    <tr><td></td><td>Total</td><td>Rural</td></tr>
+    <tr><td>FY2016</td><td>960</td><td>715</td></tr>
+    <tr><td>Rural</td><td></td><td></td></tr>
+    <tr><td></td><td>Total</td><td>Rural</td></tr>
+    <tr><td>FY2016</td><td>1,042</td><td>774</td></tr>
+  </tbody>
+</table>
+"""
+
+        urban_passed, urban_message, _ = _chart_rule("960", ["Urban", "FY2016", "Total"]).run(table)
+        rural_passed, rural_message, _ = _chart_rule("774", ["Rural", "FY2016", "Rural"]).run(table)
+        stale_passed, _, stale_score = _chart_rule("774", ["Urban", "FY2016", "Rural"]).run(table)
+
+        assert urban_passed, urban_message
+        assert rural_passed, rural_message
+        assert not stale_passed
+        assert stale_score == 0.0
+
+    def test_body_section_without_repeated_header_does_not_leak(self) -> None:
+        table = """\
+<table><tbody>
+  <tr><td>Urban</td><td></td></tr>
+  <tr><td>FY2016</td><td>960</td></tr>
+</tbody></table>
+"""
+
+        passed, message, score = _chart_rule("960", ["Urban", "FY2016"]).run(table)
+
+        assert not passed, message
+        assert score == 0.0
+
     def test_later_correct_duplicate_value_is_selected(self) -> None:
         table = """\
 | Country | Year | Value |