Upload SEC parser release files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+__pycache__/table_ocr_backends.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.8-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential python3-dev pkg-config curl xz-utils ca-certificates \
+    wkhtmltopdf \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# build exact libs
+RUN curl -LO https://download.gnome.org/sources/libxml2/2.11/libxml2-2.11.9.tar.xz \
+ && tar -xf libxml2-2.11.9.tar.xz && cd libxml2-2.11.9 \
+ && ./configure --prefix=/opt/xml && make -j && make install && cd .. \
+ && rm -rf libxml2-2.11.9 libxml2-2.11.9.tar.xz \
+ && curl -LO https://download.gnome.org/sources/libxslt/1.1/libxslt-1.1.39.tar.xz \
+ && tar -xf libxslt-1.1.39.tar.xz && cd libxslt-1.1.39 \
+ && PKG_CONFIG_PATH=/opt/xml/lib/pkgconfig ./configure --prefix=/opt/xml \
+ && make -j && make install && cd .. \
+ && rm -rf libxslt-1.1.39 libxslt-1.1.39.tar.xz
+
+ENV CFLAGS="-I/opt/xml/include" \
+    LDFLAGS="-L/opt/xml/lib" \
+    PKG_CONFIG_PATH="/opt/xml/lib/pkgconfig" \
+    LD_LIBRARY_PATH="/opt/xml/lib"
+
+COPY requirements.txt .
+RUN pip install -U pip setuptools wheel \
+ && pip install --no-binary lxml -r requirements.txt
+
+RUN playwright install --with-deps chromium
+
+COPY . .

Dockerfile.linux

@@ -0,0 +1,7 @@
+FROM python:3.12.12-bookworm
+ENV DEBIAN_FRONTEND=noninteractive
+WORKDIR /app
+RUN apt-get update && apt-get install -y wkhtmltopdf && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+RUN playwright install chromium --with-deps

README.md

@@ -0,0 +1,34 @@
+---
+license: apache-2.0
+pretty_name: SEC Edgar Filings Datasets Parser
+tags:
+- sec
+- edgar
+- financial-documents
+- document-parsing
+- markdown
+---
+
+# SEC Edgar Filings Datasets Parser
+
+This repository contains the core parser used to convert SEC EDGAR filings into layout-faithful Markdown-style text for downstream dataset construction and evaluation.
+
+## Contents
+
+- `sec_parser/sec_parser.py`: main parser implementation
+- `sec_parser/special_chars.py`: special-character normalization tables
+- `sec_parser/hardcodes.py`: filing cleanup hardcodes
+- `sec_parser/config.py`: parser configuration
+- `pdf_table_fastpath.py`, `table_ocr_backends.py`, `mistral_pdf_ocr_overlay.py`: PDF/table OCR helper code
+- `test_sec_parser.py`: smoke/regression tests
+- `Dockerfile`, `Dockerfile.linux`, `requirements.txt`: reproducible environment files
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+python -m unittest test_sec_parser.py
+python sec_parser/sec_parser.py path/to/filing.txt
+```
+
+Some PDF/OCR paths require external OCR credentials and browser rendering dependencies.

__pycache__/table_ocr_backends.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6279f3fb60ef8f8b51bf25284cdf4035f8ed3e17b86975f4762d3b1d1ab000b7
+size 322041

mistral_pdf_ocr_overlay.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import table_ocr_backends
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Run OCR on a PDF page, then overlay born-digital PDF cell bboxes "
+            "and recovered bold/italic/underline formatting onto the returned table HTML."
+        )
+    )
+    parser.add_argument("--pdf", required=True, help="Path to the source PDF.")
+    parser.add_argument("--page", required=True, type=int, help="1-based PDF page number.")
+    parser.add_argument(
+        "--model-id",
+        default=None,
+        help="Optional OCR model id override. Defaults to the configured/default PDF page OCR model.",
+    )
+    parser.add_argument(
+        "--input-html",
+        default=None,
+        help="Optional path to an existing OCR HTML fragment. When provided, the script skips OCR and only applies the PDF-native overlay.",
+    )
+    parser.add_argument(
+        "--style-overlay-mode",
+        default="auto",
+        choices=["none", "attrs_only", "formatting_only", "auto", "aggressive"],
+        help=(
+            "Formatting overlay behavior. "
+            "`formatting_only` preserves OCR text and only injects semantic bold/italic/underline tags. "
+            "`auto` safely swaps in native styled cell HTML when the text match is strong. "
+            "`aggressive` prefers native styled cell HTML whenever a cell matches."
+        ),
+    )
+    parser.add_argument("--page-render-zoom", type=float, default=None, help="Optional PDF render zoom before OCR.")
+    parser.add_argument("--output-html", default=None, help="Optional path to write the final annotated HTML.")
+    parser.add_argument(
+        "--output-raw-html",
+        default=None,
+        help=(
+            "Optional path to write the original OCR HTML before PDF-native overlay. "
+            "If omitted and --output-html is set, defaults to a sibling '*.raw.html' file."
+        ),
+    )
+    parser.add_argument("--output-json", default=None, help="Optional path to write the full JSON payload.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    if args.input_html:
+        input_html_path = Path(args.input_html).resolve()
+        input_html = input_html_path.read_text(encoding="utf-8")
+        payload = table_ocr_backends.overlay_pdf_page_html_with_native_cells(
+            input_html,
+            pdf_path=args.pdf,
+            page_number=max(1, int(args.page)),
+            effective_model_id=args.model_id or "existing-html+pdf-overlay",
+            style_overlay_mode=args.style_overlay_mode,
+        )
+    else:
+        payload = table_ocr_backends.transcribe_pdf_page_to_payload(
+            args.pdf,
+            page_number=max(1, int(args.page)),
+            model_id=args.model_id,
+            page_render_zoom=args.page_render_zoom,
+            overlay_pdf_cells=True,
+            style_overlay_mode=args.style_overlay_mode,
+        )
+
+    output_html = str(payload.get("html") or "")
+    raw_html = str(payload.get("raw_html") or output_html)
+    output_html_path = Path(args.output_html).resolve() if args.output_html else None
+    output_raw_html_path = None
+    if args.output_raw_html:
+        output_raw_html_path = Path(args.output_raw_html).resolve()
+    elif output_html_path is not None:
+        output_raw_html_path = output_html_path.with_name(f"{output_html_path.stem}.raw.html")
+
+    if args.output_html:
+        assert output_html_path is not None
+        output_html_path.parent.mkdir(parents=True, exist_ok=True)
+        output_html_path.write_text(output_html, encoding="utf-8")
+
+    if output_raw_html_path is not None:
+        output_raw_html_path.parent.mkdir(parents=True, exist_ok=True)
+        output_raw_html_path.write_text(raw_html, encoding="utf-8")
+
+    if args.output_json:
+        output_json_path = Path(args.output_json).resolve()
+        output_json_path.parent.mkdir(parents=True, exist_ok=True)
+        output_json_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    if not args.output_html and not args.output_json:
+        print(output_html)
+        return
+
+    summary = {
+        "pdf": str(Path(args.pdf).resolve()),
+        "page": int(args.page),
+        "model_id": payload.get("effective_model_id"),
+        "overlay_applied": bool(payload.get("overlay_applied")),
+        "overlay_changed_html": output_html != raw_html,
+        "style_overlay_mode": payload.get("style_overlay_mode"),
+        "timings_ms": payload.get("timings_ms"),
+        "output_html": str(output_html_path) if output_html_path is not None else None,
+        "output_raw_html": str(output_raw_html_path) if output_raw_html_path is not None else None,
+        "output_json": str(Path(args.output_json).resolve()) if args.output_json else None,
+    }
+    print(json.dumps(summary, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

pdf_table_fastpath.py

@@ -0,0 +1,1197 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+import fitz
+import numpy as np
+from PIL import Image, ImageDraw
+
+
+MIN_NATIVE_SPAN_COUNT = 24
+
+
+@dataclass
+class StyledFragment:
+    text: str
+    bbox: Tuple[float, float, float, float]
+    font: str
+    flags: int
+    size: float
+    bold: bool
+    italic: bool
+    underline: bool
+
+    def to_payload(self) -> Dict[str, Any]:
+        return {
+            "text": self.text,
+            "bbox": [round(value, 2) for value in self.bbox],
+            "font": self.font,
+            "flags": int(self.flags),
+            "size": round(float(self.size), 2),
+            "bold": bool(self.bold),
+            "italic": bool(self.italic),
+            "underline": bool(self.underline),
+        }
+
+
+@dataclass
+class RowGroup:
+    cy: float
+    items: List[StyledFragment]
+
+    @property
+    def bbox(self) -> Tuple[float, float, float, float]:
+        return union_bbox(item.bbox for item in self.items)
+
+    def to_payload(self) -> Dict[str, Any]:
+        return {
+            "bbox": [round(value, 2) for value in self.bbox],
+            "text": " | ".join(item.text for item in self.items),
+            "fragments": [item.to_payload() for item in self.items],
+        }
+
+
+@dataclass
+class TableCandidate:
+    rect: Tuple[float, float, float, float]
+    source: str
+    score: float
+    rows: List[RowGroup]
+
+    def to_payload(self) -> Dict[str, Any]:
+        return {
+            "bbox": [round(value, 2) for value in self.rect],
+            "source": self.source,
+            "score": round(float(self.score), 2),
+            "row_count": len(self.rows),
+            "fragment_count": sum(len(row.items) for row in self.rows),
+            "rows": [row.to_payload() for row in self.rows],
+        }
+
+
+@dataclass
+class TableCellCandidate:
+    row: int
+    col: int
+    rowspan: int
+    colspan: int
+    bbox: Tuple[float, float, float, float]
+    text: str
+    html: str
+    header: bool
+    bold: bool
+    italic: bool
+    underline: bool
+
+    def to_payload(self) -> Dict[str, Any]:
+        return {
+            "row": int(self.row),
+            "col": int(self.col),
+            "rowspan": int(self.rowspan),
+            "colspan": int(self.colspan),
+            "bbox": [round(value, 2) for value in self.bbox],
+            "text": self.text,
+            "html": self.html,
+            "header": bool(self.header),
+            "bold": bool(self.bold),
+            "italic": bool(self.italic),
+            "underline": bool(self.underline),
+        }
+
+
+@dataclass
+class RasterCandidate:
+    rect: Tuple[float, float, float, float]
+    score: float
+    row_count: int
+    avg_components_per_row: float
+    text_density: float
+    line_density: float
+
+    def to_payload(self) -> Dict[str, Any]:
+        return {
+            "bbox": [round(value, 2) for value in self.rect],
+            "score": round(float(self.score), 2),
+            "row_count": int(self.row_count),
+            "avg_components_per_row": round(float(self.avg_components_per_row), 2),
+            "text_density": round(float(self.text_density), 4),
+            "line_density": round(float(self.line_density), 4),
+        }
+
+
+def union_bbox(boxes: Iterable[Sequence[float]]) -> Tuple[float, float, float, float]:
+    points = [tuple(float(value) for value in box) for box in boxes]
+    if not points:
+        return (0.0, 0.0, 0.0, 0.0)
+    return (
+        min(box[0] for box in points),
+        min(box[1] for box in points),
+        max(box[2] for box in points),
+        max(box[3] for box in points),
+    )
+
+
+def bbox_iou(box_a: Sequence[float], box_b: Sequence[float]) -> float:
+    left = max(float(box_a[0]), float(box_b[0]))
+    top = max(float(box_a[1]), float(box_b[1]))
+    right = min(float(box_a[2]), float(box_b[2]))
+    bottom = min(float(box_a[3]), float(box_b[3]))
+    inter_w = max(0.0, right - left)
+    inter_h = max(0.0, bottom - top)
+    inter_area = inter_w * inter_h
+    area_a = max(0.0, float(box_a[2]) - float(box_a[0])) * max(0.0, float(box_a[3]) - float(box_a[1]))
+    area_b = max(0.0, float(box_b[2]) - float(box_b[0])) * max(0.0, float(box_b[3]) - float(box_b[1]))
+    union = max(1e-6, area_a + area_b - inter_area)
+    return inter_area / union
+
+
+def width(box: Sequence[float]) -> float:
+    return max(0.0, float(box[2]) - float(box[0]))
+
+
+def height(box: Sequence[float]) -> float:
+    return max(0.0, float(box[3]) - float(box[1]))
+
+
+def center_y(box: Sequence[float]) -> float:
+    return (float(box[1]) + float(box[3])) / 2.0
+
+
+def center_x(box: Sequence[float]) -> float:
+    return (float(box[0]) + float(box[2])) / 2.0
+
+
+def is_numeric_like(text: str) -> bool:
+    normalized = str(text or "").strip()
+    if not normalized:
+        return False
+    return any(char.isdigit() for char in normalized)
+
+
+def is_bold(font_name: str, flags: int) -> bool:
+    font_name = str(font_name or "").lower()
+    return "bold" in font_name or bool(int(flags or 0) & 16)
+
+
+def is_italic(font_name: str, flags: int) -> bool:
+    font_name = str(font_name or "").lower()
+    return "italic" in font_name or "oblique" in font_name or bool(int(flags or 0) & 2)
+
+
+def extract_horizontal_line_boxes(page: fitz.Page) -> List[Tuple[float, float, float, float]]:
+    line_boxes: List[Tuple[float, float, float, float]] = []
+    for drawing in page.get_drawings():
+        rect = drawing.get("rect")
+        if rect is None:
+            continue
+        if rect.width <= 0 or rect.height > 2.5:
+            continue
+        line_boxes.append((rect.x0, rect.y0, rect.x1, rect.y1))
+    return line_boxes
+
+
+def span_has_underline(
+    bbox: Sequence[float],
+    *,
+    line_boxes: Sequence[Sequence[float]],
+) -> bool:
+    span_left, _span_top, span_right, span_bottom = (float(value) for value in bbox)
+    span_width = max(1.0, span_right - span_left)
+    for line_box in line_boxes:
+        line_left, line_top, line_right, line_bottom = (float(value) for value in line_box)
+        overlap = max(0.0, min(span_right, line_right) - max(span_left, line_left))
+        if overlap < (0.60 * span_width):
+            continue
+        if abs(line_top - span_bottom) <= 2.5 or abs(line_bottom - span_bottom) <= 2.5:
+            return True
+    return False
+
+
+def extract_styled_fragments(page: fitz.Page) -> List[StyledFragment]:
+    rawdict = page.get_text("rawdict")
+    line_boxes = extract_horizontal_line_boxes(page)
+    fragments: List[StyledFragment] = []
+    for block in rawdict.get("blocks", []):
+        for line in block.get("lines", []):
+            for span in line.get("spans", []):
+                text = "".join(char.get("c", "") for char in span.get("chars", [])).strip()
+                if not text:
+                    continue
+                bbox = tuple(float(value) for value in span.get("bbox", (0, 0, 0, 0)))
+                font = str(span.get("font") or "")
+                flags = int(span.get("flags") or 0)
+                fragments.append(
+                    StyledFragment(
+                        text=text,
+                        bbox=bbox,
+                        font=font,
+                        flags=flags,
+                        size=float(span.get("size") or 0.0),
+                        bold=is_bold(font, flags),
+                        italic=is_italic(font, flags),
+                        underline=span_has_underline(bbox, line_boxes=line_boxes),
+                    )
+                )
+    return fragments
+
+
+def extract_layout_fragments(page: fitz.Page) -> List[StyledFragment]:
+    words = page.get_text("words", sort=True)
+    grouped_words: Dict[Tuple[int, int], List[Tuple[float, float, float, float, str]]] = {}
+    for word in words:
+        if len(word) < 8:
+            continue
+        x0, y0, x1, y1, text, block_no, line_no, _word_no = word[:8]
+        normalized_text = str(text or "").strip()
+        if not normalized_text:
+            continue
+        grouped_words.setdefault((int(block_no), int(line_no)), []).append(
+            (float(x0), float(y0), float(x1), float(y1), normalized_text)
+        )
+
+    fragments: List[StyledFragment] = []
+    for _line_key, line_words in sorted(grouped_words.items(), key=lambda item: (item[0][0], item[0][1])):
+        current_texts: List[str] = []
+        current_boxes: List[Tuple[float, float, float, float]] = []
+        previous_right: Optional[float] = None
+        current_height = 0.0
+        for x0, y0, x1, y1, text in sorted(line_words, key=lambda item: item[0]):
+            box = (x0, y0, x1, y1)
+            box_height = height(box)
+            gap = float("inf") if previous_right is None else max(0.0, x0 - previous_right)
+            merge_gap = max(8.0, current_height * 0.45, box_height * 0.45)
+            if current_texts and gap > merge_gap:
+                merged_box = union_bbox(current_boxes)
+                fragments.append(
+                    StyledFragment(
+                        text=" ".join(current_texts),
+                        bbox=merged_box,
+                        font="",
+                        flags=0,
+                        size=max(current_height, 0.0),
+                        bold=False,
+                        italic=False,
+                        underline=False,
+                    )
+                )
+                current_texts = []
+                current_boxes = []
+                current_height = 0.0
+            current_texts.append(text)
+            current_boxes.append(box)
+            current_height = max(current_height, box_height)
+            previous_right = x1
+        if current_texts:
+            merged_box = union_bbox(current_boxes)
+            fragments.append(
+                StyledFragment(
+                    text=" ".join(current_texts),
+                    bbox=merged_box,
+                    font="",
+                    flags=0,
+                    size=max(current_height, 0.0),
+                    bold=False,
+                    italic=False,
+                    underline=False,
+                )
+            )
+    return fragments
+
+
+def group_rows(items: Sequence[StyledFragment], *, y_tolerance: float = 3.5) -> List[RowGroup]:
+    rows: List[RowGroup] = []
+    for item in sorted(items, key=lambda fragment: (center_y(fragment.bbox), fragment.bbox[0])):
+        item_cy = center_y(item.bbox)
+        if rows and abs(rows[-1].cy - item_cy) <= y_tolerance:
+            rows[-1].items.append(item)
+            rows[-1].cy = float(np.mean([center_y(existing.bbox) for existing in rows[-1].items]))
+            continue
+        rows.append(RowGroup(cy=item_cy, items=[item]))
+    return rows
+
+
+def is_headerish_row(row: RowGroup, *, page_width: float) -> bool:
+    bbox = row.bbox
+    text = " ".join(item.text for item in row.items)
+    centered = bbox[0] > (page_width * 0.25) and bbox[2] < (page_width * 0.85)
+    short_text = len(text) <= 80
+    return centered or short_text or row.items[0].italic
+
+
+def _fragment_style_weight(fragment: StyledFragment) -> float:
+    normalized_text = "".join(char for char in str(fragment.text or "") if not char.isspace())
+    if normalized_text:
+        return float(len(normalized_text))
+    return max(1.0, width(fragment.bbox))
+
+
+def _fragment_style_fraction(
+    fragments: Sequence[StyledFragment],
+    *,
+    attr_name: str,
+) -> float:
+    total_weight = 0.0
+    styled_weight = 0.0
+    for fragment in fragments:
+        weight = _fragment_style_weight(fragment)
+        total_weight += weight
+        if bool(getattr(fragment, attr_name, False)):
+            styled_weight += weight
+    if total_weight <= 0:
+        return 0.0
+    return styled_weight / total_weight
+
+
+def _native_cell_bold_min_fraction() -> float:
+    raw_value = str(os.getenv("PDF_NATIVE_CELL_BOLD_MIN_FRACTION", "0.60")).strip()
+    try:
+        return min(1.0, max(0.0, float(raw_value)))
+    except ValueError:
+        return 0.60
+
+
+def drawing_based_candidates(page: fitz.Page) -> List[Tuple[float, float, float, float]]:
+    candidate_boxes: List[Tuple[float, float, float, float]] = []
+    page_width = float(page.rect.width)
+    for drawing in page.get_drawings():
+        rect = drawing.get("rect")
+        if rect is None:
+            continue
+        candidate = (float(rect.x0), float(rect.y0), float(rect.x1), float(rect.y1))
+        if width(candidate) < (page_width * 0.35):
+            continue
+        draw_type = str(drawing.get("type") or "")
+        if draw_type in {"f", "fs"} and height(candidate) <= 30.0:
+            candidate_boxes.append(candidate)
+            continue
+        if draw_type in {"s", "fs"} and height(candidate) <= 2.0:
+            candidate_boxes.append(candidate)
+    candidate_boxes.sort(key=lambda box: (box[1], box[0]))
+
+    merged: List[Tuple[float, float, float, float]] = []
+    for candidate in candidate_boxes:
+        if (
+            merged
+            and candidate[1] - merged[-1][3] <= 18.0
+            and min(candidate[2], merged[-1][2]) - max(candidate[0], merged[-1][0]) > (page_width * 0.20)
+        ):
+            merged[-1] = (
+                min(merged[-1][0], candidate[0]),
+                min(merged[-1][1], candidate[1]),
+                max(merged[-1][2], candidate[2]),
+                max(merged[-1][3], candidate[3]),
+            )
+            continue
+        merged.append(candidate)
+    return merged
+
+
+def row_is_tabular_core(row: RowGroup) -> bool:
+    numeric_count = sum(is_numeric_like(item.text) for item in row.items)
+    if len(row.items) >= 4:
+        return True
+    if len(row.items) >= 3 and numeric_count >= 1:
+        return True
+    if len(row.items) >= 2 and numeric_count >= 2:
+        return True
+    return False
+
+
+def row_is_tabular_support(row: RowGroup) -> bool:
+    numeric_count = sum(is_numeric_like(item.text) for item in row.items)
+    if row_is_tabular_core(row):
+        return True
+    if len(row.items) >= 2 and numeric_count >= 1:
+        return True
+    return False
+
+
+def alignment_based_candidates(
+    rows: Sequence[RowGroup],
+    *,
+    page_width: float,
+) -> List[Tuple[float, float, float, float]]:
+    candidates: List[Tuple[float, float, float, float]] = []
+    index = 0
+    while index < len(rows):
+        row = rows[index]
+        if not row_is_tabular_core(row):
+            index += 1
+            continue
+        start = index
+        end = index + 1
+        while end < len(rows):
+            row_gap = rows[end].bbox[1] - rows[end - 1].bbox[3]
+            if row_gap > 22.0 or not row_is_tabular_support(rows[end]):
+                break
+            end += 1
+        run = list(rows[start:end])
+        core_count = sum(row_is_tabular_core(candidate_row) for candidate_row in run)
+        avg_items = float(np.mean([len(candidate_row.items) for candidate_row in run])) if run else 0.0
+        if core_count >= 3 and avg_items >= 2.8:
+            expanded_start = start
+            for _ in range(3):
+                if expanded_start <= 0:
+                    break
+                previous_row = rows[expanded_start - 1]
+                gap = rows[expanded_start].bbox[1] - previous_row.bbox[3]
+                if gap > 18.0 or not is_headerish_row(previous_row, page_width=page_width):
+                    break
+                expanded_start -= 1
+            expanded_end = end
+            while expanded_end < len(rows):
+                next_row = rows[expanded_end]
+                if rows[expanded_end].bbox[1] - rows[expanded_end - 1].bbox[3] > 18.0:
+                    break
+                if len(next_row.items) > 2:
+                    break
+                next_text = " ".join(item.text for item in next_row.items).strip()
+                if not next_text.startswith("("):
+                    break
+                expanded_end += 1
+            run_rows = rows[expanded_start:expanded_end]
+            candidate_box = union_bbox(row_group.bbox for row_group in run_rows)
+            if width(candidate_box) >= (page_width * 0.35):
+                candidates.append(candidate_box)
+        index = max(end, index + 1)
+    return candidates
+
+
+def filter_fragments_in_rect(
+    rect: Sequence[float],
+    *,
+    fragments: Sequence[StyledFragment],
+) -> List[StyledFragment]:
+    left, top, right, bottom = (float(value) for value in rect)
+    kept: List[StyledFragment] = []
+    for fragment in fragments:
+        x0, y0, x1, y1 = fragment.bbox
+        cx = (x0 + x1) / 2.0
+        cy = (y0 + y1) / 2.0
+        if left <= cx <= right and top <= cy <= bottom:
+            kept.append(fragment)
+    return kept
+
+
+def score_candidate(
+    rect: Sequence[float],
+    *,
+    fragments: Sequence[StyledFragment],
+) -> Optional[TableCandidate]:
+    inside_fragments = filter_fragments_in_rect(rect, fragments=fragments)
+    if len(inside_fragments) < 6:
+        return None
+    rows = group_rows(inside_fragments)
+    dense_rows = [row for row in rows if len(row.items) >= 2]
+    if len(dense_rows) < 3:
+        return None
+    numeric_fragments = sum(is_numeric_like(fragment.text) for fragment in inside_fragments)
+    bold_fragments = sum(bool(fragment.bold) for fragment in inside_fragments)
+    score = (len(dense_rows) * 5.0) + min(20.0, float(numeric_fragments)) + min(10.0, float(bold_fragments))
+    return TableCandidate(
+        rect=tuple(float(value) for value in rect),
+        source="scored",
+        score=score,
+        rows=rows,
+    )
+
+
+def dedupe_candidates(candidates: Sequence[TableCandidate]) -> List[TableCandidate]:
+    kept: List[TableCandidate] = []
+    for candidate in sorted(candidates, key=lambda item: (item.score, width(item.rect) * height(item.rect)), reverse=True):
+        if any(bbox_iou(candidate.rect, existing.rect) >= 0.85 for existing in kept):
+            continue
+        kept.append(candidate)
+    return kept
+
+
+def render_fragment_html(fragment: StyledFragment) -> str:
+    rendered = html.escape(fragment.text, quote=False)
+    if fragment.bold:
+        rendered = f"<strong>{rendered}</strong>"
+    if fragment.italic:
+        rendered = f"<em>{rendered}</em>"
+    if fragment.underline:
+        rendered = f"<u>{rendered}</u>"
+    return rendered
+
+
+def column_anchor_x(fragment: StyledFragment) -> float:
+    if is_numeric_like(fragment.text):
+        return float(fragment.bbox[2])
+    return float(fragment.bbox[0])
+
+
+def infer_column_centers(
+    rows: Sequence[RowGroup],
+    *,
+    table_rect: Sequence[float],
+) -> List[float]:
+    table_width = width(table_rect)
+    tolerance = max(14.0, table_width * 0.03)
+    centers: List[float] = []
+    counts: List[int] = []
+    dense_rows = [row for row in rows if len(row.items) >= 2]
+    for row in dense_rows:
+        for item in sorted(row.items, key=lambda fragment: fragment.bbox[0]):
+            item_center = column_anchor_x(item)
+            matched_index: Optional[int] = None
+            for index, existing_center in enumerate(centers):
+                if abs(existing_center - item_center) <= tolerance:
+                    matched_index = index
+                    break
+            if matched_index is None:
+                centers.append(item_center)
+                counts.append(1)
+                continue
+            counts[matched_index] += 1
+            centers[matched_index] = (
+                (centers[matched_index] * float(counts[matched_index] - 1)) + item_center
+            ) / float(counts[matched_index])
+    ranked_pairs = sorted(
+        zip(centers, counts),
+        key=lambda pair: pair[0],
+    )
+    filtered = [center for center, count in ranked_pairs if count >= 2]
+    if filtered:
+        return filtered
+    if dense_rows:
+        widest_row = max(dense_rows, key=lambda row: len(row.items))
+        return [column_anchor_x(item) for item in sorted(widest_row.items, key=lambda fragment: fragment.bbox[0])]
+    return []
+
+
+def build_column_boundaries(
+    column_centers: Sequence[float],
+    *,
+    table_rect: Sequence[float],
+) -> List[float]:
+    if not column_centers:
+        return [float(table_rect[0]), float(table_rect[2])]
+    boundaries = [float(table_rect[0])]
+    sorted_centers = sorted(float(value) for value in column_centers)
+    for index in range(len(sorted_centers) - 1):
+        boundaries.append((sorted_centers[index] + sorted_centers[index + 1]) / 2.0)
+    boundaries.append(float(table_rect[2]))
+    return boundaries
+
+
+def build_row_boundaries(
+    rows: Sequence[RowGroup],
+    *,
+    table_rect: Sequence[float],
+) -> List[float]:
+    if not rows:
+        return [float(table_rect[1]), float(table_rect[3])]
+    boundaries = [float(table_rect[1])]
+    for index in range(len(rows) - 1):
+        boundaries.append((float(rows[index].bbox[3]) + float(rows[index + 1].bbox[1])) / 2.0)
+    boundaries.append(float(table_rect[3]))
+    return boundaries
+
+
+def infer_header_row_count(rows: Sequence[RowGroup]) -> int:
+    header_row_count = 0
+    for row in rows[:3]:
+        numeric_count = sum(is_numeric_like(item.text) for item in row.items)
+        bold_count = sum(bool(item.bold) for item in row.items)
+        if header_row_count == 0 and (numeric_count == 0 or len(row.items) <= 2):
+            header_row_count += 1
+            continue
+        if numeric_count == 0 and len(row.items) >= 2:
+            header_row_count += 1
+            continue
+        if bold_count >= max(1, len(row.items) - 1) and numeric_count <= 2:
+            header_row_count += 1
+            continue
+        break
+    return header_row_count
+
+
+def assign_fragment_to_columns(
+    fragment: StyledFragment,
+    *,
+    column_centers: Sequence[float],
+    boundaries: Sequence[float],
+    allow_spans: bool,
+) -> Tuple[int, int]:
+    if len(boundaries) < 2:
+        return 0, 0
+    item_left, _item_top, item_right, _item_bottom = fragment.bbox
+    item_width = max(1.0, item_right - item_left)
+    overlapping_columns: List[int] = []
+    for index in range(len(boundaries) - 1):
+        boundary_left = float(boundaries[index])
+        boundary_right = float(boundaries[index + 1])
+        overlap = max(0.0, min(item_right, boundary_right) - max(item_left, boundary_left))
+        if overlap >= max(4.0, item_width * 0.12):
+            overlapping_columns.append(index)
+    if overlapping_columns:
+        if not allow_spans:
+            nearest_index = min(
+                overlapping_columns,
+                key=lambda index: abs(column_anchor_x(fragment) - float(column_centers[index])),
+            )
+            return nearest_index, nearest_index
+        return overlapping_columns[0], overlapping_columns[-1]
+    if not column_centers:
+        return 0, 0
+    nearest_index = min(
+        range(len(column_centers)),
+        key=lambda index: abs(column_anchor_x(fragment) - float(column_centers[index])),
+    )
+    return nearest_index, nearest_index
+
+
+def infer_table_candidate_cells(candidate: TableCandidate) -> List[TableCellCandidate]:
+    rows = [RowGroup(cy=row.cy, items=sorted(row.items, key=lambda fragment: fragment.bbox[0])) for row in candidate.rows]
+    if not rows:
+        return []
+    column_centers = infer_column_centers(rows, table_rect=candidate.rect)
+    if not column_centers:
+        return []
+    boundaries = build_column_boundaries(column_centers, table_rect=candidate.rect)
+    row_boundaries = build_row_boundaries(rows, table_rect=candidate.rect)
+    header_row_count = infer_header_row_count(rows)
+
+    cells: List[TableCellCandidate] = []
+    for row_index, row in enumerate(rows):
+        assigned_cells: List[Dict[str, Any]] = []
+        for fragment in row.items:
+            start_column, end_column = assign_fragment_to_columns(
+                fragment,
+                column_centers=column_centers,
+                boundaries=boundaries,
+                allow_spans=(len(row.items) == 1),
+            )
+            fragment_html = render_fragment_html(fragment)
+            if assigned_cells and start_column <= int(assigned_cells[-1]["end_column"]):
+                assigned_cells[-1]["end_column"] = max(int(assigned_cells[-1]["end_column"]), end_column)
+                assigned_cells[-1]["html"] += "<br>" + fragment_html
+                assigned_cells[-1]["texts"].append(fragment.text)
+                assigned_cells[-1]["fragments"].append(fragment)
+                continue
+            assigned_cells.append(
+                {
+                    "start_column": start_column,
+                    "end_column": end_column,
+                    "html": fragment_html,
+                    "texts": [fragment.text],
+                    "fragments": [fragment],
+                }
+            )
+
+        cursor = 0
+        for cell in assigned_cells:
+            start_column = max(cursor, int(cell["start_column"]))
+            end_column = max(start_column, int(cell["end_column"]))
+            cursor = end_column + 1
+            left = float(boundaries[start_column])
+            right = float(boundaries[end_column + 1])
+            top = float(row_boundaries[row_index])
+            bottom = float(row_boundaries[row_index + 1])
+            fragments = list(cell["fragments"])
+            cells.append(
+                TableCellCandidate(
+                    row=row_index,
+                    col=start_column,
+                    rowspan=1,
+                    colspan=max(1, end_column - start_column + 1),
+                    bbox=(left, top, right, bottom),
+                    text="\n".join(str(piece) for piece in cell["texts"] if str(piece).strip()),
+                    html=str(cell["html"]),
+                    header=(row_index < header_row_count),
+                    bold=(
+                        _fragment_style_fraction(fragments, attr_name="bold")
+                        >= _native_cell_bold_min_fraction()
+                    ),
+                    italic=any(bool(fragment.italic) for fragment in fragments),
+                    underline=any(bool(fragment.underline) for fragment in fragments),
+                )
+            )
+    return cells
+
+
+def render_table_candidate_html(candidate: TableCandidate) -> str:
+    cells = infer_table_candidate_cells(candidate)
+    if not cells:
+        return ""
+    row_count = max(int(cell.row + cell.rowspan) for cell in cells)
+    column_count = max(int(cell.col + cell.colspan) for cell in cells)
+    cells_by_row: Dict[int, List[TableCellCandidate]] = {}
+    for cell in cells:
+        cells_by_row.setdefault(int(cell.row), []).append(cell)
+
+    parts: List[str] = ["<table>"]
+    for row_index in range(row_count):
+        row_cells = sorted(cells_by_row.get(row_index, []), key=lambda cell: (cell.col, cell.colspan))
+        default_tag_name = "th" if any(bool(cell.header) for cell in row_cells) else "td"
+        parts.append("<tr>")
+        cursor = 0
+        for cell in row_cells:
+            start_column = max(cursor, int(cell.col))
+            end_column = max(start_column, int(cell.col + cell.colspan - 1))
+            while cursor < start_column:
+                parts.append(f"<{default_tag_name}></{default_tag_name}>")
+                cursor += 1
+            colspan = max(1, end_column - start_column + 1)
+            colspan_attr = f' colspan="{colspan}"' if colspan > 1 else ""
+            tag_name = "th" if cell.header else "td"
+            parts.append(f"<{tag_name}{colspan_attr}>{cell.html}</{tag_name}>")
+            cursor = end_column + 1
+        while cursor < column_count:
+            parts.append(f"<{default_tag_name}></{default_tag_name}>")
+            cursor += 1
+        parts.append("</tr>")
+    parts.append("</table>")
+    return "".join(parts)
+
+
+def detect_native_tables(page: fitz.Page) -> Dict[str, Any]:
+    timings: Dict[str, float] = {}
+    started_at = time.perf_counter()
+
+    layout_started_at = time.perf_counter()
+    layout_fragments = extract_layout_fragments(page)
+    timings["layout_extraction_ms"] = (time.perf_counter() - layout_started_at) * 1000.0
+
+    page_width = float(page.rect.width)
+    grouped_rows = group_rows(layout_fragments)
+
+    alignment_started_at = time.perf_counter()
+    alignment_rects = alignment_based_candidates(grouped_rows, page_width=page_width)
+    timings["alignment_candidate_ms"] = (time.perf_counter() - alignment_started_at) * 1000.0
+    if not alignment_rects:
+        timings["total_detection_ms"] = (time.perf_counter() - started_at) * 1000.0
+        return {
+            "mode": "pdf_native",
+            "fragments": layout_fragments,
+            "tables": [],
+            "timings_ms": timings,
+            "row_count": len(grouped_rows),
+        }
+
+    spans_started_at = time.perf_counter()
+    fragments = extract_styled_fragments(page)
+    timings["span_extraction_ms"] = (time.perf_counter() - spans_started_at) * 1000.0
+
+    drawing_started_at = time.perf_counter()
+    drawing_rects = drawing_based_candidates(page)
+    timings["drawing_candidate_ms"] = (time.perf_counter() - drawing_started_at) * 1000.0
+
+    scored_candidates: List[TableCandidate] = []
+    for rect in [*drawing_rects, *alignment_rects]:
+        candidate = score_candidate(rect, fragments=fragments)
+        if candidate is None:
+            continue
+        candidate.source = "drawing" if rect in drawing_rects else "alignment"
+        scored_candidates.append(candidate)
+
+    deduped_candidates = dedupe_candidates(scored_candidates)
+    timings["total_detection_ms"] = (time.perf_counter() - started_at) * 1000.0
+    return {
+        "mode": "pdf_native",
+        "fragments": fragments,
+        "tables": deduped_candidates,
+        "timings_ms": timings,
+        "row_count": len(grouped_rows),
+    }
+
+
+def render_page_image(page: fitz.Page, *, zoom: float = 2.0) -> Image.Image:
+    pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False)
+    return Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+
+
+def group_component_boxes_into_rows(
+    component_boxes: Sequence[Sequence[int]],
+    *,
+    y_tolerance: float,
+) -> List[List[Tuple[int, int, int, int]]]:
+    rows: List[List[Tuple[int, int, int, int]]] = []
+    row_centers: List[float] = []
+    for box in sorted(
+        ((int(box[0]), int(box[1]), int(box[2]), int(box[3])) for box in component_boxes),
+        key=lambda item: (((item[1] + item[3]) / 2.0), item[0]),
+    ):
+        cy = (box[1] + box[3]) / 2.0
+        if rows and abs(row_centers[-1] - cy) <= y_tolerance:
+            rows[-1].append(box)
+            row_centers[-1] = float(np.mean([(item[1] + item[3]) / 2.0 for item in rows[-1]]))
+            continue
+        rows.append([box])
+        row_centers.append(cy)
+    return rows
+
+
+def analyze_raster_candidate(
+    *,
+    text_mask: np.ndarray,
+    line_mask: np.ndarray,
+    x: int,
+    y: int,
+    width_px_box: int,
+    height_px_box: int,
+    scale_x: float,
+    scale_y: float,
+    page_height: float,
+) -> Optional[RasterCandidate]:
+    try:
+        import cv2  # type: ignore
+    except ImportError as exc:  # pragma: no cover - depends on environment
+        raise RuntimeError("Raster fallback requires cv2 (opencv-python-headless).") from exc
+
+    crop_text = text_mask[y : y + height_px_box, x : x + width_px_box]
+    crop_lines = line_mask[y : y + height_px_box, x : x + width_px_box]
+    if crop_text.size == 0:
+        return None
+
+    cc_kernel = cv2.getStructuringElement(
+        cv2.MORPH_RECT,
+        (max(4, width_px_box // 120), max(2, height_px_box // 160)),
+    )
+    grouped_components = cv2.dilate(crop_text, cc_kernel, iterations=1)
+    component_count, _labels, stats, _centroids = cv2.connectedComponentsWithStats(grouped_components, connectivity=8)
+
+    component_boxes: List[Tuple[int, int, int, int]] = []
+    for component_index in range(1, component_count):
+        comp_x, comp_y, comp_w, comp_h, comp_area = stats[component_index]
+        if comp_area < 20 or comp_w < 4 or comp_h < 4:
+            continue
+        component_boxes.append((comp_x, comp_y, comp_x + comp_w, comp_y + comp_h))
+
+    row_groups = group_component_boxes_into_rows(
+        component_boxes,
+        y_tolerance=max(8.0, height_px_box * 0.01),
+    )
+    populated_rows = [row for row in row_groups if row]
+    row_count = len(populated_rows)
+    avg_components_per_row = (
+        float(np.mean([len(row) for row in populated_rows])) if populated_rows else 0.0
+    )
+    line_density = float((crop_lines > 0).mean())
+    text_density = float((crop_text > 0).mean())
+
+    # Narrative paragraphs tend to have dense full-width text and fewer disconnected
+    # column clusters per row than real tables.
+    if line_density < 0.003 and avg_components_per_row < 2.4:
+        return None
+    if text_density > 0.09 and line_density < 0.003:
+        return None
+    if line_density > 0.12:
+        return None
+    if row_count < 4:
+        return None
+
+    left = x * scale_x
+    top = y * scale_y
+    right = (x + width_px_box) * scale_x
+    bottom = (y + height_px_box) * scale_y
+    candidate_box = (left, top, right, bottom)
+    score = (
+        (avg_components_per_row * 8.0)
+        + (line_density * 220.0)
+        + (text_density * 35.0)
+        + (height(candidate_box) / max(1.0, page_height) * 8.0)
+    )
+    return RasterCandidate(
+        rect=candidate_box,
+        score=score,
+        row_count=row_count,
+        avg_components_per_row=avg_components_per_row,
+        text_density=text_density,
+        line_density=line_density,
+    )
+
+
+def detect_raster_table_regions(page: fitz.Page) -> Dict[str, Any]:
+    try:
+        import cv2  # type: ignore
+    except ImportError as exc:  # pragma: no cover - depends on environment
+        raise RuntimeError("Raster fallback requires cv2 (opencv-python-headless).") from exc
+
+    timings: Dict[str, float] = {}
+    started_at = time.perf_counter()
+
+    render_started_at = time.perf_counter()
+    image = render_page_image(page, zoom=2.0)
+    timings["render_ms"] = (time.perf_counter() - render_started_at) * 1000.0
+
+    grayscale_started_at = time.perf_counter()
+    rgb = np.asarray(image, dtype=np.uint8)
+    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+    _threshold, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    timings["binarize_ms"] = (time.perf_counter() - grayscale_started_at) * 1000.0
+
+    morphology_started_at = time.perf_counter()
+    height_px, width_px = gray.shape[:2]
+    horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (max(40, width_px // 25), 1))
+    vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(40, height_px // 25)))
+    horizontal = cv2.morphologyEx(binary, cv2.MORPH_OPEN, horizontal_kernel)
+    vertical = cv2.morphologyEx(binary, cv2.MORPH_OPEN, vertical_kernel)
+    line_mask = cv2.bitwise_or(horizontal, vertical)
+    text_mask = cv2.subtract(binary, line_mask)
+    text_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (max(8, width_px // 180), max(6, height_px // 180)))
+    grouped_text = cv2.dilate(text_mask, text_kernel, iterations=1)
+    candidate_mask = cv2.dilate(
+        cv2.bitwise_or(grouped_text, line_mask),
+        cv2.getStructuringElement(cv2.MORPH_RECT, (max(20, width_px // 80), max(20, height_px // 80))),
+        iterations=1,
+    )
+    contours, _hierarchy = cv2.findContours(candidate_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    timings["morphology_ms"] = (time.perf_counter() - morphology_started_at) * 1000.0
+
+    scale_x = float(page.rect.width) / float(width_px)
+    scale_y = float(page.rect.height) / float(height_px)
+    candidates: List[RasterCandidate] = []
+    for contour in contours:
+        x, y, width_px_box, height_px_box = cv2.boundingRect(contour)
+        if width_px_box < (width_px * 0.20) or height_px_box < (height_px * 0.05):
+            continue
+        candidate = analyze_raster_candidate(
+            text_mask=text_mask,
+            line_mask=line_mask,
+            x=x,
+            y=y,
+            width_px_box=width_px_box,
+            height_px_box=height_px_box,
+            scale_x=scale_x,
+            scale_y=scale_y,
+            page_height=float(page.rect.height),
+        )
+        if candidate is not None:
+            candidates.append(candidate)
+
+    kept: List[RasterCandidate] = []
+    for candidate in sorted(candidates, key=lambda item: item.score, reverse=True):
+        if any(bbox_iou(candidate.rect, existing.rect) >= 0.85 for existing in kept):
+            continue
+        kept.append(candidate)
+
+    timings["total_detection_ms"] = (time.perf_counter() - started_at) * 1000.0
+    return {
+        "mode": "image_morphology",
+        "tables": kept[:6],
+        "timings_ms": timings,
+    }
+
+
+def detect_tables_on_page(page: fitz.Page) -> Dict[str, Any]:
+    native_result = detect_native_tables(page)
+    native_fragment_count = len(native_result["fragments"])
+    if native_fragment_count >= MIN_NATIVE_SPAN_COUNT:
+        return native_result
+
+    raster_result = detect_raster_table_regions(page)
+    if native_result["tables"]:
+        return native_result
+    return raster_result
+
+
+def build_table_payload(candidate: TableCandidate) -> Dict[str, Any]:
+    payload = candidate.to_payload()
+    payload["cells"] = [cell.to_payload() for cell in infer_table_candidate_cells(candidate)]
+    html_fragment = render_table_candidate_html(candidate)
+    if html_fragment:
+        payload["html"] = html_fragment
+    return payload
+
+
+def save_overlay(
+    page: fitz.Page,
+    *,
+    detection_payload: Dict[str, Any],
+    output_path: Path,
+) -> None:
+    image = render_page_image(page, zoom=2.0)
+    draw = ImageDraw.Draw(image)
+    scale_x = float(image.width) / float(page.rect.width)
+    scale_y = float(image.height) / float(page.rect.height)
+
+    def scale_box(box: Sequence[float]) -> Tuple[float, float, float, float]:
+        return (
+            float(box[0]) * scale_x,
+            float(box[1]) * scale_y,
+            float(box[2]) * scale_x,
+            float(box[3]) * scale_y,
+        )
+
+    if detection_payload.get("mode") == "pdf_native":
+        for table in detection_payload.get("tables", []):
+            draw.rectangle(scale_box(table.rect), outline=(220, 40, 40), width=5)
+            for row in table.rows:
+                draw.rectangle(scale_box(row.bbox), outline=(255, 140, 0), width=2)
+                for fragment in row.items:
+                    outline_color = (40, 170, 40) if fragment.bold else (40, 120, 220)
+                    draw.rectangle(scale_box(fragment.bbox), outline=outline_color, width=1)
+    else:
+        for table in detection_payload.get("tables", []):
+            box = table.rect if isinstance(table, RasterCandidate) else table["bbox"]
+            draw.rectangle(scale_box(box), outline=(220, 40, 40), width=5)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    image.save(output_path)
+
+
+def build_payload(
+    pdf_path: Path,
+    *,
+    page_number: int,
+    detection_payload: Dict[str, Any],
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {
+        "pdf_path": str(pdf_path),
+        "page_number": int(page_number),
+        "mode": detection_payload.get("mode"),
+        "timings_ms": {
+            key: round(float(value), 2)
+            for key, value in dict(detection_payload.get("timings_ms") or {}).items()
+        },
+    }
+    if detection_payload.get("mode") == "pdf_native":
+        payload["native_fragment_count"] = len(detection_payload.get("fragments") or [])
+        payload["tables"] = [build_table_payload(table) for table in detection_payload.get("tables") or []]
+        payload["html_fragments"] = [
+            str(table_payload["html"])
+            for table_payload in payload["tables"]
+            if isinstance(table_payload, dict) and isinstance(table_payload.get("html"), str) and table_payload.get("html")
+        ]
+    else:
+        payload["tables"] = [table.to_payload() for table in detection_payload.get("tables") or []]
+        payload["html_fragments"] = []
+    return payload
+
+
+def detect_tables_for_page_number(document: fitz.Document, *, page_number: int) -> Dict[str, Any]:
+    opened_at = time.perf_counter()
+    page = document.load_page(page_number - 1)
+    detection_payload = detect_tables_on_page(page)
+    detection_payload.setdefault("timings_ms", {})
+    detection_payload["timings_ms"]["open_and_dispatch_ms"] = (time.perf_counter() - opened_at) * 1000.0
+    return detection_payload
+
+
+def extract_tables_from_pdf_page(
+    pdf_path: Path | str,
+    *,
+    page_number: int,
+    overlay_path: Optional[Path | str] = None,
+) -> Dict[str, Any]:
+    resolved_pdf_path = Path(pdf_path).resolve()
+    with fitz.open(str(resolved_pdf_path)) as document:
+        detection_payload = detect_tables_for_page_number(document, page_number=page_number)
+        if overlay_path:
+            overlay_started_at = time.perf_counter()
+            page = document.load_page(page_number - 1)
+            save_overlay(page, detection_payload=detection_payload, output_path=Path(overlay_path).resolve())
+            detection_payload["timings_ms"]["overlay_ms"] = (time.perf_counter() - overlay_started_at) * 1000.0
+    return build_payload(resolved_pdf_path, page_number=page_number, detection_payload=detection_payload)
+
+
+def summarize_document_payloads(page_payloads: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    latencies_ms = [
+        float(page_payload.get("timings_ms", {}).get("open_and_dispatch_ms"))
+        for page_payload in page_payloads
+        if isinstance(page_payload.get("timings_ms", {}).get("open_and_dispatch_ms"), (int, float))
+    ]
+    if latencies_ms:
+        latency_array = np.asarray(latencies_ms, dtype=float)
+        latency_summary = {
+            "median_ms": round(float(np.median(latency_array)), 2),
+            "p95_ms": round(float(np.percentile(latency_array, 95)), 2),
+            "max_ms": round(float(np.max(latency_array)), 2),
+        }
+    else:
+        latency_summary = {}
+    return {
+        "pages": len(page_payloads),
+        "pages_with_tables": sum(bool(page_payload.get("tables")) for page_payload in page_payloads),
+        "native_pages": sum(page_payload.get("mode") == "pdf_native" for page_payload in page_payloads),
+        "raster_pages": sum(page_payload.get("mode") == "image_morphology" for page_payload in page_payloads),
+        "latency_ms": latency_summary,
+    }
+
+
+def extract_tables_from_pdf_document(
+    pdf_path: Path | str,
+    *,
+    page_numbers: Optional[Sequence[int]] = None,
+) -> Dict[str, Any]:
+    resolved_pdf_path = Path(pdf_path).resolve()
+    with fitz.open(str(resolved_pdf_path)) as document:
+        total_pages = int(document.page_count)
+        selected_pages = (
+            [page_number for page_number in page_numbers if 1 <= int(page_number) <= total_pages]
+            if page_numbers is not None
+            else list(range(1, total_pages + 1))
+        )
+        page_payloads = [
+            build_payload(
+                resolved_pdf_path,
+                page_number=page_number,
+                detection_payload=detect_tables_for_page_number(document, page_number=page_number),
+            )
+            for page_number in selected_pages
+        ]
+    return {
+        "pdf_path": str(resolved_pdf_path),
+        "page_count": len(page_payloads),
+        "pages": page_payloads,
+        "summary": summarize_document_payloads(page_payloads),
+    }
+
+
+def extract_table_html_fragments_from_pdf_page(
+    pdf_path: Path | str,
+    *,
+    page_number: int,
+) -> List[str]:
+    payload = extract_tables_from_pdf_page(pdf_path, page_number=page_number)
+    return [str(fragment) for fragment in payload.get("html_fragments") or [] if str(fragment).strip()]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Fast table bbox/style extraction for PDF pages using native PDF spans and a lightweight raster fallback."
+    )
+    parser.add_argument("--pdf", required=True, help="Path to the input PDF.")
+    parser.add_argument("--page", type=int, help="1-based page number.")
+    parser.add_argument("--all-pages", action="store_true", help="Process the full PDF instead of a single page.")
+    parser.add_argument("--output-json", help="Optional JSON output path.")
+    parser.add_argument("--overlay-png", help="Optional debug overlay PNG path.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    pdf_path = Path(args.pdf).resolve()
+    if not args.all_pages and args.page is None:
+        raise SystemExit("Pass --page N for a single page or --all-pages for a full-document run.")
+
+    if args.all_pages:
+        if args.overlay_png:
+            raise SystemExit("--overlay-png is only supported with single-page mode.")
+        payload = extract_tables_from_pdf_document(pdf_path)
+    else:
+        payload = extract_tables_from_pdf_page(
+            pdf_path,
+            page_number=max(1, int(args.page)),
+            overlay_path=(Path(args.overlay_png).resolve() if args.overlay_png else None),
+        )
+    rendered = json.dumps(payload, indent=2, sort_keys=True)
+    print(rendered)
+    if args.output_json:
+        output_path = Path(args.output_json).resolve()
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(rendered + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,45 @@
+annotated-types==0.7.0
+anyio==4.12.0
+beautifulsoup4==4.12.3
+certifi==2025.11.12
+charset-normalizer==3.4.4
+eval_type_backport==0.3.1
+greenlet==3.1.1
+huggingface_hub==1.7.2
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.11
+imgkit==1.2.3
+invoke==2.2.1
+lxml==6.0.0
+mistralai==1.9.11
+numpy==2.3.5
+pandas==2.3.3
+pillow==12.0.0
+playwright==1.48.0
+pydantic==2.12.5
+pydantic_core==2.41.5
+pyee==12.0.0
+PyMuPDF==1.24.11
+PyPDF2==3.0.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2025.2
+PyYAML==6.0.2
+requests==2.32.3
+setuptools==80.9.0
+six==1.17.0
+soupsieve==2.8
+tabulate==0.9.0
+accelerate==1.13.0
+qwen-vl-utils==0.0.14
+safetensors==0.7.0
+torch==2.11.0
+torchvision==0.26.0
+transformers==5.3.0
+typing_extensions==4.15.0
+typing-inspection==0.4.2
+tzdata==2025.2
+urllib3==2.6.0
+wheel==0.45.1

sec_parser/__init__.py

@@ -0,0 +1,2 @@
+"""Core parser package for SEC Edgar Filings Datasets."""
+

sec_parser/config.py

@@ -0,0 +1,39 @@
+import os
+
+
+def _env_flag(name: str, default: str = "0") -> bool:
+    return os.getenv(name, default).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.getenv(name)
+    if raw is None or not raw.strip():
+        return default
+    return int(raw.strip())
+
+
+class Config:
+
+    HTML_TIMEOUT_LIMIT = 15 # overall timeout for parsing a single HTML document (in minutes)
+    PDF_TIMEOUT_LIMIT = 12 # timeout for processing all PDF attachments within a filing (in minutes)
+
+    OCR_MODEL = os.getenv("MISTRAL_OCR_MODEL", "mistral-ocr-latest") # model used for OCR on PDFs and rendered page images
+
+    # Legacy settings for separate OCR-bench utilities. sec_parser no longer
+    # calls FireRed/Qwen for table-specific second-pass transcription.
+    FIRERED_MODEL_LOCAL_DIR = os.getenv("FIRERED_MODEL_LOCAL_DIR", "").strip() or None
+    FIRERED_MODEL_CACHE_DIR = os.getenv("FIRERED_MODEL_CACHE_DIR", "").strip() or None
+    FIRERED_MODEL_REVISION = os.getenv("FIRERED_MODEL_REVISION", "").strip() or None
+    FIRERED_LOCAL_FILES_ONLY = _env_flag("FIRERED_LOCAL_FILES_ONLY")
+    FIRERED_DEVICE = os.getenv("FIRERED_DEVICE", "auto").strip().lower() or "auto"
+    FIRERED_DEVICE_MAP = os.getenv("FIRERED_DEVICE_MAP", "auto").strip() or "auto"
+    FIRERED_MAX_NEW_TOKENS = _env_int("FIRERED_MAX_NEW_TOKENS", 4096)
+    FIRERED_MAX_IMAGE_PIXELS = _env_int("FIRERED_MAX_IMAGE_PIXELS", 0)
+    FIRERED_MPS_AUTO_MAX_IMAGE_PIXELS = _env_int("FIRERED_MPS_AUTO_MAX_IMAGE_PIXELS", 2000000)
+
+    PER_TABLE_SLEEP_SECONDS = 0.375 # legacy delay for old second-pass table OCR utilities
+    API_MAX_RETRIES = 5 # max number of retries for failed OCR API calls
+    API_INITIAL_DELAY_SECONDS = 0.5 # initial delay before the first API retry; increases exponentially
+
+    PDF_BATCH_SIZE = 10 # number of PDF pages to process in a single batch to the OCR API (10 was found to be the most efficient on my machine)
+    IMAGE_RENDER_ZOOM = 3 # zoom factor for rendering PDF pages to images for OCR (probably wouldn't touch this)

sec_parser/hardcodes.py

@@ -0,0 +1,87 @@
+import re
+from typing import List, Sequence
+
+
+_STACKED_HEADER_COLLAPSES = [
+    {
+        "name": "net_unrealized_appreciation_depreciation",
+        "rows": [
+            ["", "Net Unrealized", ""],
+            ["", "Appreciation", ""],
+            ["", "(Depreciation)", "Net Unrealized"],
+            ["", "as a % of", "Appreciation"],
+            ["", "Trust Capital", "(Depreciation)"],
+        ],
+        "replacement": [
+            "",
+            "**Net Unrealized<br>Appreciation<br>(Depreciation)<br>as a % of<br>Trust Capital**",
+            "**Net Unrealized<br>Appreciation<br>(Depreciation)**",
+        ],
+    },
+]
+
+
+def _split_markdown_row(line: str) -> List[str] | None:
+    stripped = line.strip()
+    if not stripped.startswith("|") or not stripped.endswith("|"):
+        return None
+    return [cell.strip() for cell in stripped[1:-1].split("|")]
+
+
+def _normalize_match_cell(cell: str) -> str:
+    cell = re.sub(r"</?u>", "", cell, flags=re.IGNORECASE)
+    cell = re.sub(r"(?i)<br\s*/?>", " ", cell)
+    cell = cell.replace("**", "")
+    cell = cell.replace("&nbsp;", " ")
+    cell = re.sub(r"\s+", " ", cell)
+    if cell.strip().lower() == "nan":
+        return ""
+    return cell.strip()
+
+
+def _row_matches(line: str, expected_cells: Sequence[str]) -> bool:
+    cells = _split_markdown_row(line)
+    if cells is None or len(cells) != len(expected_cells):
+        return False
+    return all(
+        _normalize_match_cell(actual) == expected
+        for actual, expected in zip(cells, expected_cells)
+    )
+
+
+def _format_markdown_row(cells: Sequence[str]) -> str:
+    return "| " + " | ".join(cells) + " |"
+
+
+def apply_markdown_hardcodes(markdown_text: str) -> str:
+    """
+    Apply narrow markdown-level hardcoded fixes for recurring parser edge cases.
+    These are intentionally exact-pattern transforms so they do not affect
+    unrelated tables.
+    """
+    lines = markdown_text.splitlines()
+    rewritten: List[str] = []
+    i = 0
+
+    while i < len(lines):
+        matched = False
+
+        for hardcode in _STACKED_HEADER_COLLAPSES:
+            expected_rows = hardcode["rows"]
+            span = len(expected_rows)
+            if i + span > len(lines):
+                continue
+
+            if all(_row_matches(lines[i + offset], expected_rows[offset]) for offset in range(span)):
+                rewritten.append(_format_markdown_row(hardcode["replacement"]))
+                i += span
+                matched = True
+                break
+
+        if matched:
+            continue
+
+        rewritten.append(lines[i])
+        i += 1
+
+    return "\n".join(rewritten)

sec_parser/special_chars.py

@@ -0,0 +1,158 @@
+WINGDINGS_MAP = {
+    "wingdings": {
+        ' ': '\u0020', '!': '✏', '"': '✂', '#': '✁', '$': '👓', '%': '🔔',
+        '&': '📖', '\'': '🕯', '(': '🕿', ')': '✆', '*': '🖂', '+': '🖃',
+        ',': '📪', '-': '📫', '.': '📬', '/': '📭', '0': '📁', '1': '📂',
+        '2': '📄', '3': '🗏', '4': '🗐', '5': '🗄', '6': '⌛', '7': '🖮',
+        '8': '🖰', '9': '🖲', ':': '🖳', ';': '🖴', '<': '🖫', '=': '🖬',
+        '>': '✇', '?': '✍', '@': '🖎', 'A': '✌', 'B': '👌', 'C': '👍',
+        'D': '👎', 'E': '☜', 'F': '☞', 'G': '☝', 'H': '☟', 'I': '🖐',
+        'J': '☺', 'K': '😐', 'L': '☹', 'M': '💣', 'N': '☠', 'O': '🏳',
+        'P': '🏱', 'Q': '✈', 'R': '☼', 'S': '💧', 'T': '❄', 'U': '🕆',
+        'V': '✞', 'W': '🕈', 'X': '✠', 'Y': '✡', 'Z': '☪', '[': '☯',
+        '\\': 'ॐ', ']': '☸', '^': '♈', '_': '♉', '`': '♊', 'a': '♋',
+        'b': '♌', 'c': '♍', 'd': '♎', 'e': '♏', 'f': '♐', 'g': '♑',
+        'h': '♒', 'i': '♓', 'j': '🙰', 'k': '🙵', 'l': '●', 'm': '🔾',
+        'n': '■', 'o': '□', 'p': '🞐', 'q': '❑', 'r': '❒', 's': '⬧',
+        't': '⧫', 'u': '◆', 'v': '❖', 'w': '⬥', 'x': '⌧', 'y': '⮹',
+        'z': '⌘', '{': '🏵', '|': '🏶', '}': '🙶', '~': '🙷',
+        chr(128): '⓪', chr(129): '①', chr(130): '②', chr(131): '③', chr(132): '④',
+        chr(133): '⑤', chr(134): '⑥', chr(135): '⑦', chr(136): '⑧', chr(137): '⑨',
+        chr(138): '⑩', chr(139): '⓿', chr(140): '❶', chr(141): '❷', chr(142): '❸',
+        chr(143): '❹', chr(144): '❺', chr(145): '❻', chr(146): '❼', chr(147): '❽',
+        chr(148): '❾', chr(149): '❿', chr(150): '🙢', chr(151): '🙠', chr(152): '🙡',
+        chr(153): '🙣', chr(154): '🙞', chr(155): '🙜', chr(156): '🙝', chr(157): '🙟',
+        chr(158): '·', chr(159): '•', chr(160): '▪', '¡': '⚪', '¢': '🞆',
+        '£': '🞈', '¤': '◉', '¥': '◎', '¦': '🔿', '§': '▪', '¨': '◻',
+        '©': '🟂', 'ª': '✦', '«': '★', '¬': '✶', '­': '✴', '®': '✹',
+        '¯': '✵', '°': '⯐', '±': '⌖', '²': '⟡', '³': '⌑', '´': '⯑',
+        'µ': '✪', '¶': '✰', '·': '🕐', '¸': '🕑', '¹': '🕒', 'º': '🕓',
+        '»': '🕔', '¼': '🕕', '½': '🕖', '¾': '🕗', '¿': '🕘', 'À': '🕙',
+        'Á': '🕚', 'Â': '🕛', 'Ã': '⮰', 'Ä': '⮱', 'Å': '⮲', 'Æ': '⮳',
+        'Ç': '⮴', 'È': '⮵', 'É': '⮶', 'Ê': '⮷', 'Ë': '🙪', 'Ì': '🙫',
+        'Í': '🙕', 'Î': '🙔', 'Ï': '🙗', 'Ð': '🙖', 'Ñ': '🙐', 'Ò': '🙑',
+        'Ó': '🙒', 'Ô': '🙓', 'Õ': '⌫', 'Ö': '⌦', '×': '⮘', 'Ø': '⮚',
+        'Ù': '⮙', 'Ú': '⮛', 'Û': '⮈', 'Ü': '⮊', 'Ý': '⮉', 'Þ': '⮋',
+        'ß': '🡨', 'à': '🡪', 'á': '🡩', 'â': '🡫', 'ã': '🡬', 'ä': '🡭',
+        'å': '🡯', 'æ': '🡮', 'ç': '🡸', 'è': '🡺', 'é': '🡹', 'ê': '🡻',
+        'ë': '🡼', 'ì': '🡽', 'í': '🡿', 'î': '🡾', 'ï': '⇦', 'ð': '⇨',
+        'ñ': '⇧', 'ò': '⇩', 'ó': '⬄', 'ô': '⇳', 'õ': '⬀', 'ö': '⬁',
+        '÷': '⬃', 'ø': '⬂', 'ù': '🢬', 'ú': '🢭', 'û': '🗶', 'ü': '✔',
+        'ý': '🗷', 'þ': '🗹', 'ÿ': '',
+    },
+    "wingdings 2": {
+        ' ': ' ', '!': '🖊', '"': '🖋', '#': '🖌', '$': '🖍', '%': '✄',
+        '&': '✀', '\'': '🕾', '(': '🕽', ')': '🗅', '*': '🗆', '+': '🗇',
+        ',': '🗈', '-': '🗉', '.': '🗊', '/': '🗋', '0': '🗌', '1': '🗍',
+        '2': '📋', '3': '🗑', '4': '🗔', '5': '🖵', '6': '🖶', '7': '🖷',
+        '8': '🖸', '9': '🖭', ':': '🖯', ';': '🖱', '<': '🖒', '=': '🖓',
+        '>': '🖘', '?': '🖙', '@': '🖚', 'A': '🖛', 'B': '👈', 'C': '👉',
+        'D': '🖜', 'E': '🖝', 'F': '🖞', 'G': '🖟', 'H': '🖠', 'I': '🖡',
+        'J': '👆', 'K': '👇', 'L': '🖢', 'M': '🖣', 'N': '🖑', 'O': '🗴',
+        'P': '✓', 'Q': '🗵', 'R': '☑', 'S': '☒', 'T': '☒', 'U': '⮾',
+        'V': '⮿', 'W': '⦸', 'X': '⦸', 'Y': '🙱', 'Z': '🙴', '[': '🙲',
+        '\\': '🙳', ']': '‽', '^': '🙹', '_': '🙺', '`': '🙻', 'a': '🙦',
+        'b': '🙤', 'c': '🙥', 'd': '🙧', 'e': '🙚', 'f': '🙘', 'g': '🙙',
+        'h': '🙛', 'i': '⓪', 'j': '①', 'k': '②', 'l': '③', 'm': '④',
+        'n': '⑤', 'o': '⑥', 'p': '⑦', 'q': '⑧', 'r': '⑨', 's': '⑩',
+        't': '⓿', 'u': '❶', 'v': '❷', 'w': '❸', 'x': '❹', 'y': '❺',
+        'z': '❻', '{': '❼', '|': '❽', '}': '❾', '~': '❿',
+        '€': '☉', '‚': '☽', 'ƒ': '☾', '„': '⸿', '…': '✝', '†': '🕇',
+        '‡': '🕜', 'ˆ': '🕝', '‰': '🕞', 'Š': '🕟', '‹': '🕠', 'Œ': '🕡',
+        'Ž': '🕣', '‘': '🕦', '’': '🕧', '“': '🙨', '”': '🙩', '•': '•',
+        '–': '●', '—': '⚫', '˜': '⬤', '™': '🞅', 'š': '🞆', '›': '🞇',
+        'œ': '🞈', 'ž': '⦿', 'Ÿ': '◾', ' ': '■', '¡': '◼', '¢': '⬛',
+        '£': '⬜', '¤': '🞑', '¥': '🞒', '¦': '🞓', '§': '🞔', '¨': '▣',
+        '©': '🞕', 'ª': '🞖', '«': '🞗', '¬': '⬩', '­': '⬥', '®': '◆',
+        '¯': '◇', '°': '🞚', '±': '◈', '²': '🞛', '³': '🞜', '´': '🞝',
+        'µ': '⬪', '¶': '⬧', '·': '⧫', '¸': '◊', '¹': '🞠', 'º': '◖',
+        '»': '◗', '¼': '⯊', '½': '⯋', '¾': '◼', '¿': '⬥', 'À': '⬟',
+        'Á': '⯂', 'Â': '⬣', 'Ã': '⬢', 'Ä': '⯃', 'Å': '⯄', 'Æ': '🞡',
+        'Ç': '🞢', 'È': '🞣', 'É': '🞤', 'Ê': '🞥', 'Ë': '🞦', 'Ì': '🞧',
+        'Í': '🞨', 'Î': '🞩', 'Ï': '🞪', 'Ð': '🞫', 'Ñ': '🞬', 'Ò': '🞭',
+        'Ó': '🞮', 'Ô': '🞯', 'Õ': '🞰', 'Ö': '🞱', '×': '🞲', 'Ø': '🞳',
+        'Ù': '🞴', 'Ú': '🞵', 'Û': '🞶', 'Ü': '🞷', 'Ý': '🞸', 'Þ': '🞹',
+        'ß': '🞺', 'à': '🞻', 'á': '🞼', 'â': '🞽', 'ã': '🞾', 'ä': '🞿',
+        'å': '🟀', 'æ': '🟂', 'ç': '🟄', 'è': '✦', 'é': '🟉', 'ê': '★',
+        'ë': '✶', 'ì': '🟋', 'í': '✷', 'î': '🟏', 'ï': '🟒', 'ð': '✹',
+        'ñ': '🟃', 'ò': '🟇', 'ó': '✯', 'ô': '🟍', 'õ': '🟔', 'ö': '⯌',
+        '÷': '⯍', 'ø': '※', 'ù': '⁂',
+    },
+    "wingdings 3": {
+        ' ': ' ', '!': '⭠', '"': '⭢', '#': '⭡', '$': '⭣', '%': '⭦',
+        '&': '⭧', '\'': '⭩', '(': '⭨', ')': '⭰', '*': '⭲', '+': '⭱',
+        ',': '⭳', '-': '⭶', '.': '⭸', '/': '⭻', '0': '⭽', '1': '⭤',
+        '2': '⭥', '3': '⭪', '4': '⭬', '5': '⭫', '6': '⭭', '7': '⭍',
+        '8': '⮠', '9': '⮡', ':': '⮢', ';': '⮣', '<': '⮤', '=': '⮥',
+        '>': '⮦', '?': '⮧', '@': '⮐', 'A': '⮑', 'B': '⮒', 'C': '⮓',
+        'D': '⮀', 'E': '⮃', 'F': '⭾', 'G': '⭿', 'H': '⮄', 'I': '⮆',
+        'J': '⮅', 'K': '⮇', 'L': '⮏', 'M': '⮍', 'N': '⮎', 'O': '⮌',
+        'P': '⭮', 'Q': '⭯', 'R': '⎋', 'S': '⌤', 'T': '⌃', 'U': '⌥',
+        'V': '⎵', 'W': '⍽', 'X': '⇪', 'Y': '⮸', 'Z': '🢠', '[': '🢡',
+        '\\': '🢢', ']': '🢣', '^': '🢤', '_': '🢥', '`': '🢦', 'a': '🢧',
+        'b': '🢨', 'c': '🢩', 'd': '🢪', 'e': '🢫', 'f': '←', 'g': '→',
+        'h': '↑', 'i': '↓', 'j': '↖', 'k': '↗', 'l': '↙', 'm': '↘',
+        'n': '🡘', 'o': '🡙', 'p': '▲', 'q': '▼', 'r': '△', 's': '▽',
+        't': '◄', 'u': '►', 'v': '◁', 'w': '▷', 'x': '◣', 'y': '◢',
+        'z': '◤', '{': '◥', '|': '🞀', '}': '🞂', '~': '🞁',
+        '€': '🞃', '‚': '▲', 'ƒ': '◀', '„': '▶', '…': '⮜', '†': '⮞',
+        '‡': '⮝', 'ˆ': '⮟', '‰': '🠐', 'Š': '🠒', '‹': '🠑', 'Œ': '🠓',
+        'Ž': '🠖', '‘': '🠘', '’': '🠚', '“': '🠙', '”': '🠛', '•': '🠜',
+        '–': '🠞', '—': '🠝', '˜': '🠟', '™': '🠀', 'š': '🠂', '›': '🠁',
+        'œ': '🠃', 'ž': '🠆', 'Ÿ': '🠅', ' ': '🠇', '¡': '🠈', '¢': '🠊',
+        '£': '🠉', '¤': '🠋', '¥': '🠠', '¦': '🠢', '§': '🠤', '¨': '🠦',
+        '©': '🠨', 'ª': '🠪', '«': '🠬', '¬': '🢜', '­': '🢝', '®': '🢞',
+        '¯': '🢟', '°': '🠮', '±': '🠰', '²': '🠲', '³': '🠴', '´': '🠶',
+        'µ': '🠸', '¶': '🠺', '·': '🠹', '¸': '🠻', '¹': '🢘', 'º': '🢚',
+        '»': '🢙', '¼': '🢛', '½': '🠼', '¾': '🠾', '¿': '🠽', 'À': '🠿',
+        'Á': '🡀', 'Â': '🡂', 'Ã': '🡁', 'Ä': '🡃', 'Å': '🡄', 'Æ': '🡆',
+        'Ç': '🡅', 'È': '🡇', 'É': '⮨', 'Ê': '⮩', 'Ë': '⮪', 'Ì': '⮫',
+        'Í': '⮬', 'Î': '⮭', 'Ï': '⮮', 'Ð': '⮯', 'Ñ': '🡠', 'Ò': '🡢',
+        'Ó': '🡡', 'Ô': '🡣', 'Õ': '🡤', 'Ö': '🡥', '×': '🡧', 'Ø': '🡦',
+        'Ù': '🡰', 'Ú': '🡲', 'Û': '🡱', 'Ü': '🡳', 'Ý': '🡴', 'Þ': '🡵',
+        'ß': '🡷', 'à': '🡶', 'á': '🢀', 'â': '🢂', 'ã': '🢁', 'ä': '🢃',
+        'å': '🢄', 'æ': '🢅', 'ç': '🢇', 'è': '🢆', 'é': '🢐', 'ê': '🢒',
+        'ë': '🢑', 'ì': '🢓', 'í': '🢔', 'î': '🢖', 'ï': '🢕', 'ð': '🢗',
+    },
+    "webdings": {
+        ' ': '\u0020', '!': '🕷', '"': '🕸', '#': '🕲', '$': '🕶', '%': '🏆',
+        '&': '🎖', '\'': '🖇', '(': '🗨', ')': '🗩', '*': '🗰', '+': '🗱',
+        ',': '🌶', '-': '🎗', '.': '🙾', '/': '🙼', '0': '🗕', '1': '🗖',
+        '2': '🗗', '3': '⏴', '4': '⏵', '5': '⏶', '6': '⏷', '7': '⏪',
+        '8': '⏩', '9': '⏮', ':': '⏭', ';': '⏸', '<': '⏹', '=': '⏺',
+        '>': '🗚', '?': '🗳', '@': '🛠', 'A': '🏗', 'B': '🏘', 'C': '🏙',
+        'D': '🏚', 'E': '🏜', 'F': '🏭', 'G': '🏛', 'H': '🏠', 'I': '🏖',
+        'J': '🏝', 'K': '🛣', 'L': '🔍', 'M': '🏔', 'N': '👁', 'O': '👂',
+        'P': '🏞', 'Q': '🏕', 'R': '🛤', 'S': '🏟', 'T': '🛳', 'U': '🕬',
+        'V': '🕫', 'W': '🕨', 'X': '🔈', 'Y': '🎔', 'Z': '🎕', '[': '🗬',
+        '\\': '🙽', ']': '🗭', '^': '🗪', '_': '🗫', '`': '⮔', 'a': '✔',
+        'b': '🚲', 'c': '□', 'd': '🛡', 'e': '📦', 'f': '🛱', 'g': '■',
+        'h': '🚑', 'i': '🛈', 'j': '🛩', 'k': '🛰', 'l': '🟈', 'm': '🕴',
+        'n': '⚫', 'o': '🛥', 'p': '🚔', 'q': '🗘', 'r': '🗙', 's': '❓',
+        't': '🛲', 'u': '🚇', 'v': '🚍', 'w': '⛳', 'x': '🛇', 'y': '⊖',
+        'z': '🚭', '{': '🗮', '|': '|', '}': '🗯', '~': '🗲',
+        chr(128): '🚹', chr(129): '🚺', chr(130): '🛉', chr(131): '🛊', chr(132): '🚼',
+        chr(133): '👽', chr(134): '🏋', chr(135): '⛷', chr(136): '🏂', chr(137): '🏌',
+        chr(138): '🏊', chr(139): '🏄', chr(140): '🏍', chr(141): '🏎', chr(142): '🚘',
+        chr(143): '🗠', chr(144): '🛢', chr(145): '💰', chr(146): '🏷', chr(147): '💳',
+        chr(148): '👪', chr(149): '🗡', chr(150): '🗢', chr(151): '🗣', chr(152): '✯',
+        chr(153): '🖄', chr(154): '🖅', chr(155): '🖃', chr(156): '🖆', chr(157): '🖹',
+        chr(158): '🖺', chr(159): '🖻', chr(160): '🕵', '¡': '🕰', '¢': '🖽',
+        '£': '🖾', '¤': '📋', '¥': '🗒', '¦': '🗓', '§': '📖', '¨': '📚',
+        '©': '🗞', 'ª': '🗟', '«': '🗃', '¬': '🗂', '­': '🖼', '®': '🎭',
+        '¯': '🎜', '°': '🎘', '±': '🎙', '²': '🎧', '³': '💿', '´': '🎞',
+        'µ': '📷', '¶': '🎟', '·': '🎬', '¸': '📽', '¹': '📹', 'º': '📾',
+        '»': '📻', '¼': '🎚', '½': '🎛', '¾': '📺', '¿': '💻', 'À': '🖥',
+        'Á': '🖦', 'Â': '🖧', 'Ã': '🕹', 'Ä': '🎮', 'Å': '🕻', 'Æ': '🕼',
+        'Ç': '📟', 'È': '🖁', 'É': '🖀', 'Ê': '🖨', 'Ë': '🖩', 'Ì': '🖿',
+        'Í': '🖪', 'Î': '🗜', 'Ï': '🔒', 'Ð': '🔓', 'Ñ': '🗝', 'Ò': '📥',
+        'Ó': '📤', 'Ô': '🕳', 'Õ': '🌣', 'Ö': '🌤', '×': '🌥', 'Ø': '🌦',
+        'Ù': '☁', 'Ú': '🌧', 'Û': '🌨', 'Ü': '🌩', 'Ý': '🌪', 'Þ': '🌬',
+        'ß': '🌫', 'à': '🌜', 'á': '🌡', 'â': '🛋', 'ã': '🛏', 'ä': '🍽',
+        'å': '🍸', 'æ': '🛎', 'ç': '🛍', 'è': 'Ⓟ', 'é': '♿', 'ê': '🛆',
+        'ë': '🖈', 'ì': '🎓', 'í': '🗤', 'î': '🗥', 'ï': '🗦', 'ð': '🗧',
+        'ñ': '🛪', 'ò': '🐿', 'ó': '🐦', 'ô': '🐟', 'õ': '🐕', 'ö': '🐈',
+        '÷': '🙬', 'ø': '🙮', 'ù': '🙭', 'ú': '🙯', 'û': '🗺', 'ü': '🌍',
+        'ý': '🌏', 'þ': '🌎', 'ÿ': '🕊',
+    }
+}

test_sec_parser.py

@@ -0,0 +1,59 @@
+import contextlib
+import io
+import unittest
+from unittest import mock
+
+from sec_parser import sec_parser as sp
+
+
+class NormalizeTextMarkupTests(unittest.TestCase):
+    def test_valid_utf8_bypasses_detwingle(self):
+        payload = "Revenue — 2025".encode("utf-8")
+
+        with mock.patch.object(
+            sp.UnicodeDammit,
+            "detwingle",
+            side_effect=AssertionError("detwingle should not be called for valid utf-8"),
+        ):
+            normalized = sp.normalize_text_markup(payload)
+
+        self.assertEqual(normalized, "Revenue — 2025")
+
+    def test_invalid_utf8_still_uses_detwingle_path(self):
+        payload = b'\x93quoted\x94'
+
+        with mock.patch.object(sp.UnicodeDammit, "detwingle", wraps=sp.UnicodeDammit.detwingle) as detwingle:
+            normalized = sp.normalize_text_markup(payload)
+
+        self.assertTrue(detwingle.called)
+        self.assertIn("quoted", normalized)
+
+
+class DebugPrintGatingTests(unittest.TestCase):
+    def test_parse_html_filing_stage_debug_is_off_by_default(self):
+        html = "<html><body><p>Hello world</p></body></html>"
+        stdout = io.StringIO()
+
+        with mock.patch.dict("os.environ", {}, clear=False):
+            with mock.patch.object(sp, "is_document_layout_positioned", return_value=False):
+                with mock.patch.object(sp, "parse_positioned_html_islands_via_ocr", return_value=(None, False)):
+                    with contextlib.redirect_stdout(stdout):
+                        sp.parse_html_filing(html, form_type="")
+
+        self.assertNotIn("→ stage 0 (raw):", stdout.getvalue())
+
+    def test_parse_html_filing_stage_debug_can_be_enabled(self):
+        html = "<html><body><p>Hello world</p></body></html>"
+        stdout = io.StringIO()
+
+        with mock.patch.dict("os.environ", {"SEC_PARSER_DEBUG": "1"}, clear=False):
+            with mock.patch.object(sp, "is_document_layout_positioned", return_value=False):
+                with mock.patch.object(sp, "parse_positioned_html_islands_via_ocr", return_value=(None, False)):
+                    with contextlib.redirect_stdout(stdout):
+                        sp.parse_html_filing(html, form_type="")
+
+        self.assertIn("→ stage 0 (raw):", stdout.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()