diff --git "a/table_ocr_backends.py" "b/table_ocr_backends.py" new file mode 100644--- /dev/null +++ "b/table_ocr_backends.py" @@ -0,0 +1,6887 @@ +from __future__ import annotations + +import base64 +import io +import contextlib +import difflib +import html +import importlib.util +import inspect +import io +import json +import os +import math +import re +import shlex +import shutil +import subprocess +import sys +import time +import warnings +from functools import lru_cache +from pathlib import Path +from tempfile import TemporaryDirectory +from typing import Any, Callable, Dict, List, Optional, Tuple + +import requests + +try: + from dotenv import load_dotenv +except Exception: + load_dotenv = None + + +ROOT = Path(__file__).resolve().parent +ProgressHandler = Optional[Callable[[str], None]] +_DEEPSEEK_OCR_MODEL = None +_DEEPSEEK_OCR_PROCESSOR = None +_DEEPSEEK_OCR_MODEL_ID = None +_DEEPSEEK_OCR_LOAD_ERROR = None +_GENERIC_OCR_BACKENDS: Dict[str, Any] = {} + + +_QIANFAN_OCR_DEFAULT_MODEL_ID = "baidu/Qianfan-OCR" +_GLM_OCR_DEFAULT_MODEL_ID = "zai-org/GLM-OCR" +_PADDLEOCR_VL_DEFAULT_MODEL_ID = "PaddlePaddle/PaddleOCR-VL-1.5" +_GOT_OCR_DEFAULT_MODEL_ID = "stepfun-ai/GOT-OCR2_0" +_MONKEYOCR_DEFAULT_MODEL_ID = "echo840/MonkeyOCR-pro-3B" +_QWEN_OCR_DEFAULT_MODEL_ID = "Qwen/Qwen3.6-35B-A3B" +_GEMMA4_VLLM_DEFAULT_MODEL_ID = "google/gemma-4-26B-A4B-it" +_GEMMA4_LLAMA_CPP_DEFAULT_MODEL_ID = "gemma4-26b-llamacpp" + + +if load_dotenv is not None: + load_dotenv(ROOT / "sec_parser" / ".env") + load_dotenv(ROOT / ".env") + + +class TableOCRContentError(RuntimeError): + def __init__( + self, + message: str, + *, + response_payload: Optional[Dict[str, Any]] = None, + details: Optional[Dict[str, Any]] = None, + ): + super().__init__(message) + self.response_payload = response_payload or {} + self.details = details or {} + + +class TableOCRTranscriptionText(str): + def __new__( + cls, + text: str, + *, + effective_model_id: Optional[str] = None, + thinking_latency_s: Optional[float] = None, + total_latency_s: Optional[float] = None, + first_content_latency_s: Optional[float] = None, + reasoning_tokens: Optional[int] = None, + completion_tokens: Optional[int] = None, + ): + obj = super().__new__(cls, text) + obj.effective_model_id = normalize_text(effective_model_id or "") + obj.thinking_latency_s = ( + max(0.0, float(thinking_latency_s)) + if isinstance(thinking_latency_s, (int, float)) + else None + ) + obj.total_latency_s = ( + max(0.0, float(total_latency_s)) + if isinstance(total_latency_s, (int, float)) + else None + ) + obj.first_content_latency_s = ( + max(0.0, float(first_content_latency_s)) + if isinstance(first_content_latency_s, (int, float)) + else None + ) + obj.reasoning_tokens = ( + max(0, int(reasoning_tokens)) + if isinstance(reasoning_tokens, (int, float)) + else None + ) + obj.completion_tokens = ( + max(0, int(completion_tokens)) + if isinstance(completion_tokens, (int, float)) + else None + ) + return obj + + +def emit_progress(message: str, *, progress_handler: ProgressHandler = None) -> None: + if progress_handler is not None: + progress_handler(message) + return + print(message, flush=True) + + +def default_table_image_transcription_prompt() -> str: + return ( + "Transcribe the table in the image into a minimal HTML fragment.\n" + "Return only plain HTML using , ,
, ,
, and inline formatting tags such as /, /, , , and when needed.\n" + "Do not use markdown fences, commentary, CSS, or JavaScript.\n" + "Assume every visible textual element inside the image crop belongs to the table and must be transcribed.\n" + "Include all visible titles, units, stub labels, grouped headers, footnotes, side labels, and notes, even when they sit above, below, or beside the main grid.\n" + "Do not omit text just because it looks visually separate from the numeric body; if it is visible in the crop, capture it in the output table.\n" + "Preserve merged-cell structure faithfully. Use colspan and rowspan when they are needed to represent the visible table layout.\n" + "Do not duplicate merged-cell text across multiple cells unless the image itself repeats that text.\n" + "Preserve visible text formatting exactly when present, including bold, italics, underline, superscripts, and subscripts.\n" + "Ignore purely visual table styling such as thick borders, ruling lines, shading, and decorative emphasis; transcribe only the table's textual content and structure.\n" + "Preserve row order, column order, signs, punctuation, decimals, and capitalization exactly." + ) + + +def strip_code_fences(text: str) -> str: + text = (text or "").strip() + text = re.sub(r"^```(?:html)?\s*", "", text, flags=re.IGNORECASE) + text = re.sub(r"\s*```$", "", text) + return text.strip() + + +def normalize_text(text: str) -> str: + return str(text or "").strip() + + +_HTML_TABLE_RE = re.compile(r"", re.IGNORECASE) +_GEMMA4_THOUGHT_BLOCK_RE = re.compile( + r"<\|channel\>thought\s*[\s\S]*?", + re.IGNORECASE, +) +_GEMMA4_THINK_BLOCK_RE = re.compile(r"[\s\S]*?", re.IGNORECASE) +_GEMMA4_CHANNEL_MARKER_RE = re.compile( + r"<\|channel\>[A-Za-z0-9_-]*\s*|", + re.IGNORECASE, +) +_LATEX_INLINE_TEXT_RE = re.compile( + r"\\(?:[A-Za-z]+|[()[\]{}%&_#$,])" + r"|(?[^{}]*)\}(?P[\s\S]*?)\\end\s*\{tabular\}", + re.IGNORECASE, +) +_LATEX_BEGIN_ENV_RE = re.compile(r"\\begin\s*\{(?P[^{}]+)\}", re.IGNORECASE) +_LATEX_RULE_COMMAND_RE = re.compile( + r"\\(?:hline|toprule|midrule|bottomrule)\b" + r"|\\(?:c|x)?cline(?:\[[^\]]+\])?\{[^{}]*\}" + r"|\\cmidrule(?:\([^)]+\))?\{[^{}]*\}", + re.IGNORECASE, +) +_LATEX_TABLE_ENVIRONMENT_ARG_COUNTS: Dict[str, int] = { + "array": 1, + "longtable": 1, + "longtabu": 2, + "nicetabular": 1, + "tabu": 1, + "tabular": 1, + "tabular*": 2, + "tabularx": 2, + "tabulary": 2, + "tblr": 1, + "xltabular": 2, +} +_LATEX_INLINE_SYMBOLS: Dict[str, str] = { + "alpha": "α", + "beta": "β", + "gamma": "γ", + "delta": "δ", + "epsilon": "ε", + "theta": "θ", + "lambda": "λ", + "mu": "μ", + "pi": "π", + "sigma": "σ", + "tau": "τ", + "phi": "φ", + "omega": "ω", + "Gamma": "Γ", + "Delta": "Δ", + "Theta": "Θ", + "Lambda": "Λ", + "Pi": "Π", + "Sigma": "Σ", + "Phi": "Φ", + "Omega": "Ω", + "cdot": "·", + "times": "×", + "div": "÷", + "leq": "≤", + "geq": "≥", + "neq": "≠", + "approx": "≈", + "sim": "~", + "pm": "±", + "mp": "∓", + "to": "→", + "rightarrow": "→", + "leftarrow": "←", + "leftrightarrow": "↔", + "infty": "∞", + "degree": "°", + "circ": "°", + "ldots": "...", + "dots": "...", + "cdots": "...", + "vdots": "...", + "ddots": "...", +} +_LATEX_INLINE_UNWRAP_COMMANDS = { + "bar", + "boxed", + "fbox", + "hphantom", + "mathbb", + "mathcal", + "mathfrak", + "mathrm", + "mathsf", + "mathtt", + "mbox", + "operatorname", + "overline", + "phantom", + "rlap", + "smash", + "text", + "textnormal", + "textrm", + "textsf", + "texttt", + "tilde", + "vec", + "vphantom", + "widehat", + "widetilde", +} +_LATEX_INLINE_BOLD_COMMANDS = {"bf", "bfseries", "bm", "boldsymbol", "mathbf", "textbf"} +_LATEX_INLINE_ITALIC_COMMANDS = {"emph", "it", "itshape", "mathit", "textit"} +_LATEX_INLINE_UNDERLINE_COMMANDS = {"dashuline", "uline", "underline", "uwave"} +_LATEX_LAYOUT_COMMAND_RE = re.compile( + r"\\(?:addlinespace(?:\[[^\]]*\])?|arraybackslash|centering|footnotesize|Huge|huge|LARGE|Large|large|" + r"morecmidrulespace|newline|normalcolor|normalfont|normalsize|par|qquad|quad|raggedleft|raggedright|" + r"scriptsize|small|tabularnewline|tiny)\b", + re.IGNORECASE, +) +_LATEX_HEADER_FOOTER_MARKER_RE = re.compile( + r"\\(?:endfirsthead|endhead|endfoot|endlastfoot)\b", + re.IGNORECASE, +) +_LATEX_TABLENOTES_ENV_RE = re.compile( + r"\\begin\s*\{tablenotes\}(?P[\s\S]*?)\\end\s*\{tablenotes\}", + re.IGNORECASE, +) + + +def _consume_latex_braced_group(text: str, start_index: int) -> tuple[Optional[str], int]: + if start_index >= len(text) or text[start_index] != "{": + return None, start_index + depth = 0 + index = start_index + while index < len(text): + char = text[index] + if char == "\\": + index += 2 + continue + if char == "{": + depth += 1 + elif char == "}": + depth -= 1 + if depth == 0: + return text[start_index + 1 : index], index + 1 + index += 1 + return None, start_index + + +def _consume_latex_optional_bracket_group(text: str, start_index: int) -> int: + _, next_index = _consume_latex_bracket_group(text, start_index) + return next_index + + +def _consume_latex_bracket_group(text: str, start_index: int) -> tuple[Optional[str], int]: + if start_index >= len(text) or text[start_index] != "[": + return None, start_index + depth = 0 + index = start_index + while index < len(text): + char = text[index] + if char == "\\": + index += 2 + continue + if char == "[": + depth += 1 + elif char == "]": + depth -= 1 + if depth == 0: + return text[start_index + 1 : index], index + 1 + index += 1 + return None, start_index + + +def _consume_latex_command( + text: str, + command: str, + *, + required_arg_count: int, + optional_arg_count: int = 0, + allow_star: bool = False, +) -> tuple[Optional[Dict[str, Any]], int]: + index = 0 + while index < len(text) and text[index].isspace(): + index += 1 + prefix = f"\\{command}" + if not text.startswith(prefix, index): + return None, 0 + index += len(prefix) + + starred = False + if allow_star and index < len(text) and text[index] == "*": + starred = True + index += 1 + + optional_args: List[str] = [] + for _ in range(optional_arg_count): + while index < len(text) and text[index].isspace(): + index += 1 + optional_arg, next_index = _consume_latex_bracket_group(text, index) + if optional_arg is None: + break + optional_args.append(optional_arg) + index = next_index + + args: List[str] = [] + for _ in range(required_arg_count): + while index < len(text) and text[index].isspace(): + index += 1 + arg, next_index = _consume_latex_braced_group(text, index) + if arg is None: + return None, 0 + args.append(arg) + index = next_index + + return { + "args": args, + "optional_args": optional_args, + "starred": starred, + }, index + + +def _consume_latex_command_args(text: str, command: str, arg_count: int) -> tuple[Optional[List[str]], int]: + payload, end_index = _consume_latex_command( + text, + command, + required_arg_count=arg_count, + ) + if payload is None: + return None, 0 + return list(payload["args"]), end_index + + +def _split_latex_top_level(text: str, *, separator: str) -> List[str]: + parts: List[str] = [] + current: List[str] = [] + brace_depth = 0 + index = 0 + while index < len(text): + char = text[index] + if char == "\\": + if separator == "\\\\" and text.startswith("\\\\", index) and brace_depth == 0: + parts.append("".join(current)) + current = [] + index += 2 + while index < len(text) and text[index].isspace(): + index += 1 + next_index = _consume_latex_optional_bracket_group(text, index) + if next_index != index: + index = next_index + continue + if index + 1 < len(text): + current.append(text[index : index + 2]) + index += 2 + continue + if char == "{": + brace_depth += 1 + elif char == "}" and brace_depth > 0: + brace_depth -= 1 + elif separator == "&" and char == "&" and brace_depth == 0: + parts.append("".join(current)) + current = [] + index += 1 + continue + current.append(char) + index += 1 + parts.append("".join(current)) + return parts + + +def _replace_latex_command_occurrences( + text: str, + command: str, + *, + required_arg_count: int, + optional_arg_count: int = 0, + allow_star: bool = False, + replacement: Any = "", + predicate: Optional[Callable[[Dict[str, Any]], bool]] = None, +) -> str: + if not text: + return text + star_pattern = r"(?:\*)?" if allow_star else "" + pattern = re.compile( + rf"\\{re.escape(command)}{star_pattern}(?![A-Za-z])", + re.IGNORECASE, + ) + chunks: List[str] = [] + index = 0 + for match in pattern.finditer(text): + if match.start() < index: + continue + parsed, consumed = _consume_latex_command( + text[match.start() :], + command, + required_arg_count=required_arg_count, + optional_arg_count=optional_arg_count, + allow_star=allow_star, + ) + if parsed is None: + continue + if predicate is not None and not predicate(parsed): + continue + chunks.append(text[index : match.start()]) + if callable(replacement): + replacement_text = replacement(parsed) + if replacement_text: + chunks.append(str(replacement_text)) + elif replacement: + chunks.append(str(replacement)) + index = match.start() + consumed + if not chunks: + return text + chunks.append(text[index:]) + return "".join(chunks) + + +def _find_matching_latex_end( + text: str, + *, + env_name: str, + start_index: int, +) -> tuple[Optional[int], Optional[int]]: + pattern = re.compile( + rf"\\(?Pbegin|end)\s*\{{{re.escape(env_name)}\}}", + re.IGNORECASE, + ) + depth = 1 + for match in pattern.finditer(text, start_index): + if normalize_text(match.group("kind")).lower() == "begin": + depth += 1 + continue + depth -= 1 + if depth == 0: + return match.start(), match.end() + return None, None + + +def _extract_latex_table_candidates(text: str) -> List[Dict[str, Any]]: + candidates: List[Dict[str, Any]] = [] + for begin_match in _LATEX_BEGIN_ENV_RE.finditer(text): + env_name = normalize_text(begin_match.group("name")) + arg_count = _LATEX_TABLE_ENVIRONMENT_ARG_COUNTS.get(env_name.lower()) + if arg_count is None: + continue + index = begin_match.end() + valid = True + for _ in range(arg_count): + while index < len(text) and text[index].isspace(): + index += 1 + while True: + optional_arg, next_index = _consume_latex_bracket_group(text, index) + if optional_arg is None: + break + index = next_index + while index < len(text) and text[index].isspace(): + index += 1 + _, next_index = _consume_latex_braced_group(text, index) + if next_index == index: + valid = False + break + index = next_index + if not valid: + continue + body_end_start, body_end_end = _find_matching_latex_end( + text, + env_name=env_name, + start_index=index, + ) + if body_end_start is None or body_end_end is None: + continue + candidates.append( + { + "env_name": env_name, + "body": text[index:body_end_start], + "source": text[begin_match.start() : body_end_end], + "start": begin_match.start(), + "end": body_end_end, + } + ) + return candidates + + +def _read_latex_inline_argument(text: str, start_index: int) -> tuple[str, int]: + index = start_index + while index < len(text) and text[index].isspace(): + index += 1 + if index >= len(text): + return "", index + if text[index] == "{": + group, next_index = _consume_latex_braced_group(text, index) + if group is None: + return "", index + return _latex_inline_to_html(group), next_index + if text[index] == "\\" and index + 1 < len(text): + return _latex_inline_to_html(text[index : index + 2]), index + 2 + return html.escape(text[index]), index + 1 + + +def _read_latex_inline_arguments( + text: str, + start_index: int, + *, + count: int, +) -> tuple[List[str], int]: + values: List[str] = [] + index = start_index + for _ in range(count): + value_html, next_index = _read_latex_inline_argument(text, index) + values.append(value_html) + index = next_index + return values, index + + +def _latex_inline_to_html(text: str) -> str: + def parse_segment(start_index: int, *, stop_at_closing_brace: bool = False) -> tuple[str, int]: + parts: List[str] = [] + index = start_index + while index < len(text): + char = text[index] + if stop_at_closing_brace and char == "}": + return "".join(parts), index + 1 + if char == "$": + delimiter_len = 2 if text.startswith("$$", index) else 1 + search_index = index + delimiter_len + matched = False + while search_index < len(text): + matching_index = text.find("$" * delimiter_len, search_index) + if matching_index < 0: + break + if delimiter_len == 1 and matching_index > 0 and text[matching_index - 1] == "\\": + search_index = matching_index + 1 + continue + payload = text[index + delimiter_len : matching_index] + if _LATEX_INLINE_TEXT_RE.search(payload or ""): + parts.append(_latex_inline_to_html(payload)) + index = matching_index + delimiter_len + matched = True + break + if matched: + continue + parts.append(html.escape(char)) + index += 1 + continue + if char == "{": + inner, index = parse_segment(index + 1, stop_at_closing_brace=True) + parts.append(inner) + continue + if char in {"^", "_"}: + tag_name = "sup" if char == "^" else "sub" + payload_html, index = _read_latex_inline_argument(text, index + 1) + parts.append(f"<{tag_name}>{payload_html}") + continue + if char == "~": + parts.append(" ") + index += 1 + continue + if char == "\\": + if text.startswith("\\\\", index): + parts.append("
") + index += 2 + continue + index += 1 + if index >= len(text): + break + escaped_char = text[index] + if escaped_char in "{}%&$_#": + parts.append(html.escape(escaped_char)) + index += 1 + continue + if escaped_char in "()[],": + index += 1 + continue + match = re.match(r"[A-Za-z]+", text[index:]) + if not match: + parts.append(html.escape("\\" + escaped_char)) + index += 1 + continue + command = match.group(0) + index += len(command) + if command in _LATEX_INLINE_UNWRAP_COMMANDS: + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command in _LATEX_INLINE_BOLD_COMMANDS: + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(f"{payload_html}") + continue + if command in _LATEX_INLINE_ITALIC_COMMANDS: + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(f"{payload_html}") + continue + if command in _LATEX_INLINE_UNDERLINE_COMMANDS: + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(f"{payload_html}") + continue + if command in {"frac", "dfrac", "tfrac"}: + fraction_parts, index = _read_latex_inline_arguments(text, index, count=2) + numerator_html, denominator_html = fraction_parts + parts.append(f"{numerator_html}/{denominator_html}") + continue + if command in {"textcolor", "colorbox"}: + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command == "fcolorbox": + _, index = _read_latex_inline_argument(text, index) + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command in {"makecell", "shortstack"}: + while True: + optional_arg, next_index = _consume_latex_bracket_group(text, index) + if optional_arg is None: + break + index = next_index + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command in {"multicolumn", "multirow", "parbox", "rotatebox", "scalebox"}: + payload_html = "" + if command == "multicolumn": + _, index = _read_latex_inline_argument(text, index) + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + elif command == "multirow": + while True: + optional_arg, next_index = _consume_latex_bracket_group(text, index) + if optional_arg is None: + break + index = next_index + _, index = _read_latex_inline_argument(text, index) + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + else: + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command == "resizebox": + _, index = _read_latex_inline_argument(text, index) + _, index = _read_latex_inline_argument(text, index) + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command == "raisebox": + _, index = _read_latex_inline_argument(text, index) + while True: + optional_arg, next_index = _consume_latex_bracket_group(text, index) + if optional_arg is None: + break + index = next_index + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(payload_html) + continue + if command in {"footnote", "tablefootnote"}: + payload_html, index = _read_latex_inline_argument(text, index) + if payload_html: + parts.append(f"
{payload_html}") + continue + if command == "tnote": + payload_html, index = _read_latex_inline_argument(text, index) + parts.append(f"{payload_html}") + continue + if command in _LATEX_INLINE_SYMBOLS: + parts.append(_LATEX_INLINE_SYMBOLS[command]) + continue + if command in {"left", "right"}: + continue + if command in {"label", "nonumber"}: + continue + payload_html, next_index = _read_latex_inline_argument(text, index) + if next_index != index: + parts.append(payload_html) + index = next_index + continue + if char == "}": + if stop_at_closing_brace: + return "".join(parts), index + 1 + index += 1 + continue + parts.append(html.escape(char)) + index += 1 + return "".join(parts), index + + rendered, _ = parse_segment(0) + rendered = re.sub(r"\s*
\s*", "
", rendered) + rendered = re.sub(r"[ \t\r\f\v]+", " ", rendered) + return rendered.strip() + + +def normalize_inline_latex_in_html_fragment(html_fragment: str) -> str: + cleaned = strip_code_fences(str(html_fragment or "")) + if not cleaned or not _HTML_TABLE_RE.search(cleaned): + return cleaned + + try: + from bs4 import BeautifulSoup, NavigableString, Tag + except ImportError: + return cleaned + + soup = BeautifulSoup(cleaned, "html.parser") + for text_node in list(soup.find_all(string=True)): + parent = text_node.parent + if not isinstance(text_node, NavigableString) or not isinstance(parent, Tag): + continue + if parent.name in {"script", "style"}: + continue + + original = str(text_node) + if not _LATEX_INLINE_TEXT_RE.search(original): + continue + + rendered = _latex_inline_to_html(original) + if not rendered or rendered == html.escape(original): + continue + + fragment_soup = BeautifulSoup(f"{rendered}", "html.parser") + body = getattr(fragment_soup, "body", None) + replacement_nodes = list(body.contents if body is not None else fragment_soup.contents) + if not replacement_nodes: + continue + for node in replacement_nodes: + text_node.insert_before(node) + text_node.extract() + + return str(soup) + + +def _parse_latex_cell(cell_text: str) -> Dict[str, Any]: + cell = normalize_text(cell_text) + colspan = 1 + rowspan = 1 + + while cell: + matched = False + multicolumn_payload, multicolumn_end = _consume_latex_command( + cell, + "multicolumn", + required_arg_count=3, + ) + if multicolumn_payload is not None: + multicolumn_args = list(multicolumn_payload["args"]) + try: + colspan = max(1, int(normalize_text(multicolumn_args[0]))) + except ValueError: + colspan = 1 + cell = (multicolumn_args[2] + cell[multicolumn_end:]).strip() + matched = True + multirow_payload, multirow_end = _consume_latex_command( + cell, + "multirow", + required_arg_count=3, + optional_arg_count=1, + ) + if multirow_payload is not None: + multirow_args = list(multirow_payload["args"]) + try: + rowspan = max(1, int(normalize_text(multirow_args[0]).lstrip("*"))) + except ValueError: + rowspan = 1 + cell = (multirow_args[2] + cell[multirow_end:]).strip() + matched = True + block_payload, block_end = _consume_latex_command( + cell, + "Block", + required_arg_count=2, + optional_arg_count=1, + ) + if block_payload is not None: + block_args = list(block_payload["args"]) + block_spec = normalize_text(block_args[0]) + span_match = re.match(r"(?P\d+)\s*[-x,]\s*(?P\d+)", block_spec) + if span_match is not None: + rowspan = max(rowspan, int(span_match.group("rows"))) + colspan = max(colspan, int(span_match.group("cols"))) + elif block_spec.isdigit(): + rowspan = max(rowspan, int(block_spec)) + cell = (block_args[1] + cell[block_end:]).strip() + matched = True + setcell_payload, setcell_end = _consume_latex_command( + cell, + "SetCell", + required_arg_count=1, + optional_arg_count=1, + ) + if setcell_payload is not None: + option_text = ",".join( + piece + for piece in [*setcell_payload["optional_args"], *setcell_payload["args"]] + if normalize_text(piece) + ) + row_match = re.search(r"(?:^|[,; ]+)r\s*=\s*(\d+)", option_text, re.IGNORECASE) + col_match = re.search(r"(?:^|[,; ]+)c\s*=\s*(\d+)", option_text, re.IGNORECASE) + if row_match is not None: + rowspan = max(rowspan, int(row_match.group(1))) + if col_match is not None: + colspan = max(colspan, int(col_match.group(1))) + cell = cell[setcell_end:].strip() + matched = True + if not matched: + break + + return { + "html": _latex_inline_to_html(cell), + "colspan": colspan, + "rowspan": rowspan, + } + + +def _extract_latex_caption_html(text: str) -> str: + best_caption = "" + if not text: + return best_caption + + for match in re.finditer(r"\\captionof(?:\*)?(?![A-Za-z])", text, re.IGNORECASE): + payload, _ = _consume_latex_command( + text[match.start() :], + "captionof", + required_arg_count=2, + optional_arg_count=1, + allow_star=True, + ) + if payload is None: + continue + target_name = normalize_text(payload["args"][0]).lower() + if "table" not in target_name: + continue + caption_html = _latex_inline_to_html(payload["args"][1]) + if len(caption_html) > len(best_caption): + best_caption = caption_html + + for match in re.finditer(r"\\caption(?:\*)?(?![A-Za-z])", text, re.IGNORECASE): + payload, _ = _consume_latex_command( + text[match.start() :], + "caption", + required_arg_count=1, + optional_arg_count=1, + allow_star=True, + ) + if payload is None: + continue + caption_html = _latex_inline_to_html(payload["args"][0]) + if len(caption_html) > len(best_caption): + best_caption = caption_html + return best_caption + + +def _extract_latex_tablenotes_html(text: str) -> str: + note_fragments: List[str] = [] + for match in _LATEX_TABLENOTES_ENV_RE.finditer(text): + body = normalize_text(match.group("body")) + if not body: + continue + item_parts = re.split(r"\\item(?:\s*\[[^\]]*\])?", body) + rendered_items = [ + _latex_inline_to_html(piece) + for piece in item_parts + if normalize_text(piece) + ] + if rendered_items: + note_fragments.extend(rendered_items) + continue + fallback_html = _latex_inline_to_html(body) + if fallback_html: + note_fragments.append(fallback_html) + return "
".join(fragment for fragment in note_fragments if normalize_text(fragment)) + + +def _clean_latex_tabular_body(body: str) -> str: + cleaned = body.replace("\r", "\n").replace("\\tabularnewline", "\\\\") + cleaned = _LATEX_TABLENOTES_ENV_RE.sub("", cleaned) + cleaned = _replace_latex_command_occurrences( + cleaned, + "captionof", + required_arg_count=2, + optional_arg_count=1, + allow_star=True, + replacement=r"\\", + predicate=lambda payload: "table" in normalize_text(payload["args"][0]).lower(), + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "caption", + required_arg_count=1, + optional_arg_count=1, + allow_star=True, + replacement=r"\\", + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "label", + required_arg_count=1, + replacement="", + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "endfirsthead", + required_arg_count=0, + replacement=r"\\", + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "endhead", + required_arg_count=0, + replacement=r"\\", + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "endfoot", + required_arg_count=0, + replacement=r"\\", + ) + cleaned = _replace_latex_command_occurrences( + cleaned, + "endlastfoot", + required_arg_count=0, + replacement=r"\\", + ) + cleaned = _LATEX_RULE_COMMAND_RE.sub("", cleaned) + cleaned = _LATEX_LAYOUT_COMMAND_RE.sub(" ", cleaned) + cleaned = _LATEX_HEADER_FOOTER_MARKER_RE.sub(lambda _match: r"\\", cleaned) + return cleaned + + +def _parse_latex_tabular_body(body: str) -> List[List[Dict[str, Any]]]: + cleaned = _clean_latex_tabular_body(body) + rows: List[List[Dict[str, Any]]] = [] + for raw_row in _split_latex_top_level(cleaned, separator="\\\\"): + row_text = normalize_text(raw_row) + if not row_text: + continue + row_cells = [ + _parse_latex_cell(raw_cell) + for raw_cell in _split_latex_top_level(row_text, separator="&") + ] + row_cells = [ + cell + for cell in row_cells + if cell["html"] or cell["colspan"] > 1 or cell["rowspan"] > 1 + ] + if row_cells: + rows.append(row_cells) + return rows + + +def _latex_table_score( + rows: List[List[Dict[str, Any]]], + *, + caption_html: str = "", + notes_html: str = "", +) -> float: + if not rows: + return 0.0 + max_width = max(sum(int(cell["colspan"]) for cell in row) for row in rows) + alpha_count = sum( + 1 + for row in rows + for cell in row + for char in html.unescape(str(cell["html"])) + if char.isalpha() + ) + caption_bonus = len(html.unescape(caption_html or "")) + notes_bonus = len(html.unescape(notes_html or "")) + return float(len(rows) * max_width * 4 + alpha_count + caption_bonus + (notes_bonus * 0.5)) + + +def _render_latex_table_html( + rows: List[List[Dict[str, Any]]], + *, + caption_html: str = "", + notes_html: str = "", +) -> str: + max_width = max((sum(int(cell["colspan"]) for cell in row) for row in rows), default=1) + colspan_attr = f' colspan="{max_width}"' if max_width > 1 else "" + parts: List[str] = [""] + if caption_html: + parts.append(f"{caption_html}") + for row in rows: + parts.append("") + for cell in row: + attrs = "" + if int(cell["colspan"]) > 1: + attrs += f' colspan="{int(cell["colspan"])}"' + if int(cell["rowspan"]) > 1: + attrs += f' rowspan="{int(cell["rowspan"])}"' + parts.append(f"{cell['html']}") + parts.append("") + if notes_html: + parts.append(f"{notes_html}") + parts.append("
") + return "".join(parts) + + +def _looks_like_latex_table_markup(text: str) -> bool: + if not text: + return False + if re.search(r"\\begin\s*\{(?:array|longtable|longtabu|nicetabular|tabu|tabular\*?|tabularx|tabulary|tblr|xltabular)\}", text, re.IGNORECASE): + return True + return bool( + re.search( + r"\\(?:caption(?:of)?|cmidrule|multicolumn|multirow|toprule|midrule|bottomrule)\b", + text, + re.IGNORECASE, + ) + ) + + +def _latex_table_renderer_command_template() -> Optional[str]: + configured = normalize_text(os.getenv("LATEX_TABLE_RENDER_COMMAND", "")) + if configured: + return configured + if shutil.which("latexmlc"): + return "latexmlc --quiet --nocomments --format=html5 --dest={output_path} {input_path}" + if shutil.which("pandoc"): + return "pandoc --from=latex --to=html {input_path}" + return None + + +def _latex_table_renderer_timeout_s() -> int: + return _env_int("LATEX_TABLE_RENDER_TIMEOUT_S", 20) + + +def _wrap_latex_table_fragment_for_renderer(text: str) -> str: + cleaned = strip_code_fences(text) + if not cleaned: + return cleaned + if re.search(r"\\documentclass\b", cleaned, re.IGNORECASE): + return cleaned + package_names = [ + "array", + "booktabs", + "graphicx", + "longtable", + "makecell", + "multirow", + "nicematrix", + "tabularray", + "tabularx", + "tabulary", + "threeparttable", + "ulem", + "xcolor", + ] + preamble = "\n".join(f"\\usepackage{{{package_name}}}" for package_name in package_names) + return ( + "\\documentclass{article}\n" + f"{preamble}\n" + "\\begin{document}\n" + f"{cleaned}\n" + "\\end{document}\n" + ) + + +def _extract_best_html_table_fragment(rendered_html: str) -> Optional[str]: + candidates = _HTML_TABLE_FRAGMENT_RE.findall(rendered_html or "") + if not candidates: + return None + + def candidate_score(fragment: str) -> int: + visible_text = re.sub(r"<[^>]+>", " ", fragment) + return len(normalize_text(html.unescape(visible_text))) + + best_fragment = max(candidates, key=candidate_score) + return normalize_text(best_fragment) or None + + +def _maybe_render_latex_tabular_with_external_renderer(text: str) -> Optional[str]: + cleaned = strip_code_fences(text) + if not cleaned or _HTML_TABLE_RE.search(cleaned) or not _looks_like_latex_table_markup(cleaned): + return None + + command_template = _latex_table_renderer_command_template() + if not command_template: + return None + + with TemporaryDirectory(prefix="latex_table_renderer_") as tmpdir: + tmpdir_path = Path(tmpdir) + input_path = tmpdir_path / "table.tex" + output_path = tmpdir_path / "table.html" + input_path.write_text(_wrap_latex_table_fragment_for_renderer(cleaned), encoding="utf-8") + try: + completed = subprocess.run( + command_template.format( + input_path=shlex.quote(str(input_path)), + output_path=shlex.quote(str(output_path)), + ), + shell=True, + capture_output=True, + text=True, + timeout=_latex_table_renderer_timeout_s(), + ) + except (OSError, subprocess.SubprocessError): + return None + if completed.returncode != 0: + return None + + rendered_html = "" + if output_path.exists(): + rendered_html = output_path.read_text(encoding="utf-8", errors="replace") + if not rendered_html: + rendered_html = completed.stdout or "" + return _extract_best_html_table_fragment(rendered_html) + + +def maybe_convert_latex_tabular_to_html(text: str) -> Optional[str]: + cleaned = strip_code_fences(text) + if not cleaned or _HTML_TABLE_RE.search(cleaned): + return None + if not _looks_like_latex_table_markup(cleaned): + return None + + rendered_html = _maybe_render_latex_tabular_with_external_renderer(cleaned) + if rendered_html: + return rendered_html + + best_rendered_html: Optional[str] = None + best_score = 0.0 + for candidate in _extract_latex_table_candidates(cleaned): + rows = _parse_latex_tabular_body(candidate["body"]) + if not rows: + continue + source_text = str(candidate["source"]) + context_start = max(0, int(candidate["start"]) - 600) + context_end = min(len(cleaned), int(candidate["end"]) + 600) + context_text = cleaned[context_start:context_end] + caption_html = _extract_latex_caption_html(source_text) or _extract_latex_caption_html(context_text) + notes_html = _extract_latex_tablenotes_html(source_text) or _extract_latex_tablenotes_html(context_text) + score = _latex_table_score(rows, caption_html=caption_html, notes_html=notes_html) + if score > best_score: + best_rendered_html = _render_latex_table_html( + rows, + caption_html=caption_html, + notes_html=notes_html, + ) + best_score = score + + if not best_rendered_html: + return None + + return best_rendered_html + + +def _env_int(name: str, default: int) -> int: + raw_value = os.getenv(name, "").strip() + if not raw_value: + return default + try: + return max(1, int(raw_value)) + except ValueError: + return default + + +def _env_float( + name: str, + default: float, + *, + min_value: Optional[float] = None, + max_value: Optional[float] = None, +) -> float: + raw_value = os.getenv(name, "").strip() + if not raw_value: + value = float(default) + else: + try: + value = float(raw_value) + except ValueError: + value = float(default) + if min_value is not None: + value = max(float(min_value), value) + if max_value is not None: + value = min(float(max_value), value) + return value + + +def _env_flag(name: str, default: str = "0") -> bool: + return os.getenv(name, default).strip().lower() in {"1", "true", "yes", "on"} + + +def _env_nonnegative_int(name: str, default: int) -> int: + raw_value = os.getenv(name, "").strip() + if not raw_value: + return default + try: + return max(0, int(raw_value)) + except ValueError: + return default + + +def _table_ocr_normalized_max_image_pixels() -> int: + fallback = _env_nonnegative_int("TABLE_OCR_MAX_IMAGE_PIXELS", 2_000_000) + return _env_nonnegative_int("TABLE_OCR_NORMALIZED_MAX_IMAGE_PIXELS", fallback) + + +def _table_ocr_allow_backend_image_resize() -> bool: + return _env_flag("TABLE_OCR_ALLOW_BACKEND_IMAGE_RESIZE", "0") + + +def load_module_from_path(module_name: str, path: Path): + spec = importlib.util.spec_from_file_location(module_name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"Unable to load module from {path}") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +@lru_cache(maxsize=1) +def load_sec_parser_module(): + sec_parser_dir = ROOT / "sec_parser" + if not sec_parser_dir.exists(): + raise RuntimeError(f"Expected sec_parser directory at {sec_parser_dir}") + dir_str = str(sec_parser_dir) + if dir_str not in sys.path: + sys.path.insert(0, dir_str) + import sec_parser as sec_parser_mod + + return sec_parser_mod + + +class TableOCRRemoteResponseError(RuntimeError): + def __init__( + self, + message: str, + *, + response_payload: Optional[Dict[str, Any]] = None, + details: Optional[Dict[str, Any]] = None, + ): + super().__init__(message) + self.response_payload = response_payload or {} + self.details = details or {} + + +class TableOCROpenRouterResponseError(TableOCRRemoteResponseError): + pass + + +class TableOCRRemoteChatClient: + provider_label = "Remote OCR" + response_error_cls = TableOCRRemoteResponseError + api_key_env_name = "" + model_id_env_name = "" + base_url_env_name = "" + reasoning_level_env_name = "" + default_base_url = "" + require_api_key = True + + def __init__( + self, + *, + api_key: Optional[str] = None, + model_id: Optional[str] = None, + base_url: Optional[str] = None, + reasoning_level: Optional[str] = None, + timeout_s: int = 180, + ): + api_key_value = api_key + if api_key_value is None and self.api_key_env_name: + api_key_value = os.getenv(self.api_key_env_name, "") + self.api_key = normalize_text(api_key_value or "") + + model_id_value = model_id + if model_id_value is None and self.model_id_env_name: + model_id_value = os.getenv(self.model_id_env_name, "") + self.model_id = normalize_text(model_id_value or "") + + base_url_value = base_url + if base_url_value is None and self.base_url_env_name: + base_url_value = os.getenv(self.base_url_env_name, self.default_base_url) + self.base_url = normalize_text(base_url_value or self.default_base_url).rstrip("/") + + reasoning_level_value = reasoning_level + if reasoning_level_value is None and self.reasoning_level_env_name: + reasoning_level_value = os.getenv(self.reasoning_level_env_name, "") + self.reasoning_level = normalize_text(reasoning_level_value or "") + self.timeout_s = timeout_s + + if self.require_api_key and not self.api_key: + raise RuntimeError(f"Missing {self.api_key_env_name} for {self.provider_label} OCR transcription.") + if not self.model_id: + raise RuntimeError(f"Missing {self.provider_label} OCR model id.") + if not self.base_url: + raise RuntimeError(f"Missing {self.provider_label} OCR base URL.") + + self.session = requests.Session() + self.headers = self._build_headers() + + def _build_headers(self) -> Dict[str, str]: + headers = { + "Content-Type": "application/json", + } + if self.api_key: + headers["Authorization"] = f"Bearer {self.api_key}" + return headers + + def _augment_request_body(self, body: Dict[str, Any], *, include_reasoning: bool) -> None: + del body, include_reasoning + + def _raise_request_error( + self, + message: str, + *, + response_payload: Optional[Dict[str, Any]] = None, + details: Optional[Dict[str, Any]] = None, + ) -> None: + raise self.response_error_cls( + message, + response_payload=response_payload, + details=details, + ) + + def chat_completion( + self, + *, + messages: List[Dict[str, Any]], + max_tokens: int = 4096, + temperature: float = 0.0, + progress_label: str = "", + progress_handler: ProgressHandler = None, + ) -> Dict[str, Any]: + url = f"{self.base_url}/chat/completions" + body: Dict[str, Any] = { + "model": self.model_id, + "messages": messages, + "max_tokens": max_tokens, + "temperature": temperature, + } + self._augment_request_body(body, include_reasoning=False) + + if progress_label: + emit_progress( + f"{progress_label} | model {self.model_id}", + progress_handler=progress_handler, + ) + try: + response = self.session.post( + url, + headers=self.headers, + json=body, + timeout=self.timeout_s, + ) + except requests.RequestException as exc: + self._raise_request_error( + f"{self.provider_label} request failed: {exc}", + details={ + "status_code": None, + "model_id": self.model_id, + }, + ) + if response.status_code >= 400: + response_payload: Optional[Dict[str, Any]] = None + try: + decoded_payload = response.json() + if isinstance(decoded_payload, dict): + response_payload = decoded_payload + except ValueError: + response_payload = None + self._raise_request_error( + f"{self.provider_label} HTTP {response.status_code}: {response.text[:1500]}", + response_payload=response_payload, + details={ + "status_code": response.status_code, + "model_id": self.model_id, + }, + ) + if progress_label: + emit_progress( + f"{progress_label} | response received", + progress_handler=progress_handler, + ) + return response.json() + + def chat_completion_streaming( + self, + *, + messages: List[Dict[str, Any]], + max_tokens: int = 4096, + temperature: float = 0.0, + progress_label: str = "", + progress_handler: ProgressHandler = None, + include_reasoning: bool = False, + ) -> Dict[str, Any]: + url = f"{self.base_url}/chat/completions" + body: Dict[str, Any] = { + "model": self.model_id, + "messages": messages, + "max_tokens": max_tokens, + "temperature": temperature, + "stream": True, + "stream_options": {"include_usage": True}, + } + self._augment_request_body(body, include_reasoning=include_reasoning) + + if progress_label: + emit_progress( + f"{progress_label} | model {self.model_id}", + progress_handler=progress_handler, + ) + started_at = time.perf_counter() + try: + response = self.session.post( + url, + headers=self.headers, + json=body, + timeout=self.timeout_s, + stream=True, + ) + except requests.RequestException as exc: + self._raise_request_error( + f"{self.provider_label} request failed: {exc}", + details={ + "status_code": None, + "model_id": self.model_id, + }, + ) + if response.status_code >= 400: + response_payload: Optional[Dict[str, Any]] = None + response_text = "" + try: + response_payload = response.json() + response_text = json.dumps(response_payload, ensure_ascii=False) + except ValueError: + try: + response_text = response.text + except Exception: + response_text = "" + finally: + response.close() + self._raise_request_error( + f"{self.provider_label} HTTP {response.status_code}: {response_text[:1500]}", + response_payload=response_payload, + details={ + "status_code": response.status_code, + "model_id": self.model_id, + }, + ) + if progress_label: + emit_progress( + f"{progress_label} | response received", + progress_handler=progress_handler, + ) + content_parts: List[str] = [] + refusal_parts: List[str] = [] + tool_calls: List[Any] = [] + provider_payload: Any = None + usage_payload: Dict[str, Any] = {} + finish_reason = "" + message_role = "" + first_content_latency_s: Optional[float] = None + first_reasoning_latency_s: Optional[float] = None + last_reasoning_latency_s: Optional[float] = None + saw_reasoning = False + + def process_event_payload(event_payload: Dict[str, Any]) -> None: + nonlocal provider_payload, usage_payload, finish_reason, message_role + nonlocal first_content_latency_s, first_reasoning_latency_s, last_reasoning_latency_s, saw_reasoning + if provider_payload is None and event_payload.get("provider") is not None: + provider_payload = event_payload.get("provider") + event_usage = event_payload.get("usage") + if isinstance(event_usage, dict): + usage_payload = event_usage + choices = event_payload.get("choices") + first_choice = choices[0] if isinstance(choices, list) and choices else {} + if not isinstance(first_choice, dict): + return + finish_reason = normalize_text(first_choice.get("finish_reason", "")) or finish_reason + delta = first_choice.get("delta") + if not isinstance(delta, dict): + delta = {} + if not message_role: + message_role = normalize_text(delta.get("role", "")) or message_role + delta_tool_calls = delta.get("tool_calls") + if isinstance(delta_tool_calls, list): + tool_calls.extend(delta_tool_calls) + delta_refusal = delta.get("refusal") + if isinstance(delta_refusal, str) and delta_refusal.strip(): + refusal_parts.append(delta_refusal) + reasoning_payload = ( + delta.get("reasoning_details") + or delta.get("reasoning") + or delta.get("reasoning_content") + or first_choice.get("reasoning_details") + or first_choice.get("reasoning") + or first_choice.get("reasoning_content") + ) + if reasoning_payload: + saw_reasoning = True + reasoning_latency_s = time.perf_counter() - started_at + if first_reasoning_latency_s is None: + first_reasoning_latency_s = reasoning_latency_s + last_reasoning_latency_s = reasoning_latency_s + content_piece = extract_text_from_openrouter_content(delta.get("content")) + if content_piece is None: + message_payload = first_choice.get("message") + if isinstance(message_payload, dict): + content_piece = extract_text_from_openrouter_content(message_payload.get("content")) + if content_piece is not None: + if first_content_latency_s is None: + first_content_latency_s = time.perf_counter() - started_at + content_parts.append(content_piece) + + current_event_lines: List[str] = [] + with contextlib.closing(response): + for raw_line in response.iter_lines(decode_unicode=True): + if raw_line is None: + continue + line = raw_line if isinstance(raw_line, str) else raw_line.decode("utf-8", errors="replace") + if line.startswith(":"): + continue + if line == "": + if current_event_lines: + payload_text = "\n".join(current_event_lines).strip() + current_event_lines = [] + if payload_text and payload_text != "[DONE]": + try: + decoded_payload = json.loads(payload_text) + except json.JSONDecodeError: + decoded_payload = None + if isinstance(decoded_payload, dict): + process_event_payload(decoded_payload) + continue + if line.startswith("data:"): + current_event_lines.append(line[len("data:") :].lstrip()) + if current_event_lines: + payload_text = "\n".join(current_event_lines).strip() + if payload_text and payload_text != "[DONE]": + try: + decoded_payload = json.loads(payload_text) + except json.JSONDecodeError: + decoded_payload = None + if isinstance(decoded_payload, dict): + process_event_payload(decoded_payload) + + content_text = "".join(content_parts) if content_parts else None + total_latency_s = time.perf_counter() - started_at + + return { + "choices": [ + { + "message": { + "role": message_role or "assistant", + "content": content_text, + "tool_calls": tool_calls, + "refusal": "".join(refusal_parts) if refusal_parts else None, + }, + "finish_reason": finish_reason or None, + } + ], + "provider": provider_payload, + "usage": usage_payload or None, + "_stream_timing": { + "first_content_latency_s": first_content_latency_s, + "first_reasoning_latency_s": first_reasoning_latency_s, + "last_reasoning_latency_s": last_reasoning_latency_s, + "thinking_latency_s": ( + last_reasoning_latency_s + if (saw_reasoning and last_reasoning_latency_s is not None and content_text is not None) + else None + ), + "total_latency_s": max(0.0, float(total_latency_s)), + "saw_reasoning": bool(saw_reasoning), + }, + } + + +class TableOCROpenRouterClient(TableOCRRemoteChatClient): + provider_label = "OpenRouter" + response_error_cls = TableOCROpenRouterResponseError + api_key_env_name = "OPENROUTER_API_KEY" + model_id_env_name = "OPENROUTER_MODEL_ID" + base_url_env_name = "OPENROUTER_BASE_URL" + reasoning_level_env_name = "OPENROUTER_REASONING_LEVEL" + default_base_url = "https://openrouter.ai/api/v1" + + def _build_headers(self) -> Dict[str, str]: + headers = super()._build_headers() + headers["HTTP-Referer"] = "http://localhost" + headers["X-Title"] = "OCR-Bench" + return headers + + def _augment_request_body(self, body: Dict[str, Any], *, include_reasoning: bool) -> None: + if self.reasoning_level: + body["reasoning"] = { + "effort": self.reasoning_level, + "exclude": (not include_reasoning), + } + + +class TableOCRQwenClient(TableOCRRemoteChatClient): + provider_label = "Qwen OCR" + api_key_env_name = "QWEN_OCR_API_KEY" + model_id_env_name = "QWEN_OCR_MODEL_ID" + base_url_env_name = "QWEN_OCR_BASE_URL" + default_base_url = "http://127.0.0.1:8000/v1" + require_api_key = False + + def _augment_request_body(self, body: Dict[str, Any], *, include_reasoning: bool) -> None: + if include_reasoning or _env_flag("QWEN_OCR_PRESERVE_THINKING", "1"): + body["chat_template_kwargs"] = { + "preserve_thinking": True, + } + + +class TableOCRGemma4VLLMClient(TableOCRRemoteChatClient): + provider_label = "Gemma 4 vLLM" + api_key_env_name = "GEMMA4_VLLM_API_KEY" + model_id_env_name = "GEMMA4_VLLM_MODEL_ID" + base_url_env_name = "GEMMA4_VLLM_BASE_URL" + default_base_url = "http://127.0.0.1:8000/v1" + require_api_key = False + + def _augment_request_body(self, body: Dict[str, Any], *, include_reasoning: bool) -> None: + del include_reasoning + if _env_flag("GEMMA4_VLLM_ENABLE_THINKING", "1"): + body["chat_template_kwargs"] = { + "enable_thinking": True, + } + + +class TableOCRGemma4LlamaCppClient(TableOCRRemoteChatClient): + provider_label = "Gemma 4 llama.cpp" + api_key_env_name = "GEMMA4_LLAMA_CPP_API_KEY" + model_id_env_name = "GEMMA4_LLAMA_CPP_MODEL_ID" + base_url_env_name = "GEMMA4_LLAMA_CPP_BASE_URL" + default_base_url = "http://127.0.0.1:8080/v1" + require_api_key = False + + +def extract_text_from_openrouter_content(content: Any) -> Optional[str]: + if isinstance(content, str): + normalized = normalize_text(content) + return content if normalized else None + if not isinstance(content, list): + return None + + parts: List[str] = [] + for item in content: + if isinstance(item, str): + parts.append(item) + continue + if not isinstance(item, dict): + continue + for key in ("text", "content", "value"): + value = item.get(key) + if isinstance(value, str) and value.strip(): + parts.append(value) + break + + joined = "\n".join(part for part in parts if normalize_text(part)) + return joined or None + + +def estimate_openrouter_thinking_latency_s( + total_latency_s: float, + *, + reasoning_tokens: Optional[int], + completion_tokens: Optional[int], +) -> Optional[float]: + if not isinstance(total_latency_s, (int, float)) or total_latency_s < 0: + return None + if not isinstance(reasoning_tokens, int) or reasoning_tokens <= 0: + return None + if not isinstance(completion_tokens, int) or completion_tokens <= 0: + return None + ratio = max(0.0, min(1.0, float(reasoning_tokens) / float(completion_tokens))) + return float(total_latency_s) * ratio + + +def summarize_openrouter_chat_response(response: Dict[str, Any]) -> Dict[str, Any]: + choices = response.get("choices") + first_choice = choices[0] if isinstance(choices, list) and choices else {} + if not isinstance(first_choice, dict): + first_choice = {} + + message = first_choice.get("message") + if not isinstance(message, dict): + message = {} + + provider = response.get("provider") + if isinstance(provider, dict): + provider_summary = ( + provider.get("name") + or provider.get("provider_name") + or normalize_text(json.dumps(provider, ensure_ascii=False)) + ) + else: + provider_summary = normalize_text(provider) + + tool_calls = message.get("tool_calls") + tool_call_count = len(tool_calls) if isinstance(tool_calls, list) else 0 + content = message.get("content") + refusal = message.get("refusal") + finish_reason = normalize_text(first_choice.get("finish_reason", "")) + usage = response.get("usage") + usage_payload = usage if isinstance(usage, dict) else {} + completion_tokens_raw = usage_payload.get("completion_tokens") + if not isinstance(completion_tokens_raw, (int, float)): + completion_tokens_raw = usage_payload.get("output_tokens") + completion_tokens = int(completion_tokens_raw) if isinstance(completion_tokens_raw, (int, float)) else None + completion_details = usage_payload.get("completion_tokens_details") + if not isinstance(completion_details, dict): + completion_details = {} + reasoning_tokens_raw = completion_details.get("reasoning_tokens") + reasoning_tokens = int(reasoning_tokens_raw) if isinstance(reasoning_tokens_raw, (int, float)) else None + stream_timing = response.get("_stream_timing") + if not isinstance(stream_timing, dict): + stream_timing = {} + thinking_latency_s = stream_timing.get("thinking_latency_s") + if not isinstance(thinking_latency_s, (int, float)): + thinking_latency_s = None + total_latency_s = stream_timing.get("total_latency_s") + if not isinstance(total_latency_s, (int, float)): + total_latency_s = None + first_content_latency_s = stream_timing.get("first_content_latency_s") + if not isinstance(first_content_latency_s, (int, float)): + first_content_latency_s = None + + return { + "content": content, + "content_type": type(content).__name__, + "finish_reason": finish_reason or None, + "provider": provider_summary or None, + "tool_call_count": tool_call_count, + "tool_calls": tool_calls if isinstance(tool_calls, list) else [], + "refusal": refusal, + "message_role": normalize_text(message.get("role", "")) or None, + "completion_tokens": completion_tokens, + "reasoning_tokens": reasoning_tokens, + "thinking_latency_s": (max(0.0, float(thinking_latency_s)) if thinking_latency_s is not None else None), + "total_latency_s": (max(0.0, float(total_latency_s)) if total_latency_s is not None else None), + "first_content_latency_s": (max(0.0, float(first_content_latency_s)) if first_content_latency_s is not None else None), + } + + +def openrouter_ocr_model_ids() -> set[str]: + return { + value.strip() + for value in [ + os.getenv("OPENROUTER_MODEL_ID", ""), + os.getenv("TESTMODEL", ""), + ] + if value and value.strip() + } + + +def default_openrouter_retry_model_ids(model_id: str) -> List[str]: + normalized = normalize_text(model_id) + if normalized.endswith(":free"): + paid_slug = normalized[: -len(":free")] + return [paid_slug] if paid_slug else [] + return [] + + +def default_openrouter_ocr_max_attempts() -> int: + return _env_int("OPENROUTER_OCR_MAX_ATTEMPTS", 3) + + +def build_openrouter_retry_chain(model_id: str) -> List[str]: + chain: List[str] = [] + for candidate in [normalize_text(model_id), *default_openrouter_retry_model_ids(model_id)]: + if candidate and candidate not in chain: + chain.append(candidate) + return chain + + +def build_openrouter_attempt_plan(model_id: str, *, max_attempts: int) -> List[str]: + retry_chain = build_openrouter_retry_chain(model_id) + if not retry_chain: + return [] + attempt_limit = max(1, int(max_attempts)) + plan: List[str] = [] + for candidate in retry_chain: + if len(plan) >= attempt_limit: + break + plan.append(candidate) + while len(plan) < attempt_limit: + plan.append(retry_chain[-1]) + return plan + + +def default_firered_model_id() -> str: + return normalize_text(os.getenv("FIRERED_MODEL_ID", "FireRedTeam/FireRed-OCR")) or "FireRedTeam/FireRed-OCR" + + +def default_qianfan_ocr_model_id() -> str: + return normalize_text(os.getenv("QIANFAN_OCR_MODEL_ID", _QIANFAN_OCR_DEFAULT_MODEL_ID)) or _QIANFAN_OCR_DEFAULT_MODEL_ID + + +def default_glm_ocr_model_id() -> str: + return normalize_text(os.getenv("GLM_OCR_MODEL_ID", _GLM_OCR_DEFAULT_MODEL_ID)) or _GLM_OCR_DEFAULT_MODEL_ID + + +def default_paddleocr_vl_model_id() -> str: + return normalize_text(os.getenv("PADDLEOCR_VL_MODEL_ID", _PADDLEOCR_VL_DEFAULT_MODEL_ID)) or _PADDLEOCR_VL_DEFAULT_MODEL_ID + + +def default_got_ocr_model_id() -> str: + return normalize_text(os.getenv("GOT_OCR_MODEL_ID", _GOT_OCR_DEFAULT_MODEL_ID)) or _GOT_OCR_DEFAULT_MODEL_ID + + +def default_monkeyocr_model_id() -> str: + return normalize_text(os.getenv("MONKEYOCR_MODEL_ID", _MONKEYOCR_DEFAULT_MODEL_ID)) or _MONKEYOCR_DEFAULT_MODEL_ID + + +def default_qwen_ocr_model_id() -> str: + return normalize_text(os.getenv("QWEN_OCR_MODEL_ID", _QWEN_OCR_DEFAULT_MODEL_ID)) or _QWEN_OCR_DEFAULT_MODEL_ID + + +def default_gemma4_hf_model_id() -> str: + return ( + normalize_text(os.getenv("GEMMA4_HF_MODEL_ID", _GEMMA4_VLLM_DEFAULT_MODEL_ID)) + or _GEMMA4_VLLM_DEFAULT_MODEL_ID + ) + + +def default_gemma4_vllm_model_id() -> str: + return ( + normalize_text(os.getenv("GEMMA4_VLLM_MODEL_ID", _GEMMA4_VLLM_DEFAULT_MODEL_ID)) + or _GEMMA4_VLLM_DEFAULT_MODEL_ID + ) + + +def default_gemma4_llamacpp_model_id() -> str: + return ( + normalize_text(os.getenv("GEMMA4_LLAMA_CPP_MODEL_ID", _GEMMA4_LLAMA_CPP_DEFAULT_MODEL_ID)) + or _GEMMA4_LLAMA_CPP_DEFAULT_MODEL_ID + ) + + +def resolve_firered_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_firered_model_id() + if normalized.lower() in {"firered", "firered-local", "local-firered"}: + return default_firered_model_id() + return normalized + + +def resolve_qianfan_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_qianfan_ocr_model_id() + if normalized.lower() in {"qianfan", "qianfan-ocr"}: + return default_qianfan_ocr_model_id() + return normalized + + +def resolve_glm_ocr_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_glm_ocr_model_id() + if normalized.lower() in {"glm-ocr", "glmocr"}: + return default_glm_ocr_model_id() + return normalized + + +def resolve_paddleocr_vl_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_paddleocr_vl_model_id() + if normalized.lower() in {"paddleocr-vl", "paddleocr-vl-1.5", "paddleocr_vl"}: + return default_paddleocr_vl_model_id() + return normalized + + +def resolve_got_ocr_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_got_ocr_model_id() + if normalized.lower() in {"got-ocr", "got-ocr2", "got-ocr2_0", "got_ocr", "gotocr", "gotocr2"}: + return default_got_ocr_model_id() + return normalized + + +def resolve_monkeyocr_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_monkeyocr_model_id() + if normalized.lower() in {"monkeyocr", "monkeyocr-pro-3b", "monkeyocr_pro_3b"}: + return default_monkeyocr_model_id() + return normalized + + +def resolve_qwen_ocr_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_qwen_ocr_model_id() + if normalized.lower() in { + "qwen_ocr", + "qwen-ocr", + "qwenocr", + "qwen3.5-35b-a3b", + "qwen3.5-35b-a3b-fp8", + "qwen3.6-35b-a3b", + "qwen3.6-35b-a3b-fp8", + }: + return default_qwen_ocr_model_id() + return normalized + + +def resolve_gemma4_vllm_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_gemma4_vllm_model_id() + if normalized.lower().replace("_", "-") in { + "gemma4-vllm", + "gemma-4-vllm", + "gemma4-26b-vllm", + "gemma-4-26b-vllm", + "gemma4-26b-a4b", + "gemma-4-26b-a4b", + "gemma4-26b-a4b-it", + "gemma-4-26b-a4b-it", + }: + return default_gemma4_vllm_model_id() + return normalized + + +def resolve_gemma4_hf_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_gemma4_hf_model_id() + if normalized.lower().replace("_", "-") in { + "gemma4", + "gemma-4", + "gemma4-hf", + "gemma-4-hf", + "gemma4-local", + "gemma-4-local", + "gemma4-huggingface", + "gemma-4-huggingface", + "gemma4-transformers", + "gemma-4-transformers", + }: + return default_gemma4_hf_model_id() + return normalized + + +def resolve_gemma4_llamacpp_model_id(model_id: Optional[str]) -> str: + normalized = normalize_text(model_id or "") + if not normalized: + return default_gemma4_llamacpp_model_id() + if normalized.lower().replace("_", "-") in { + "gemma4", + "gemma-4", + "gemma4-26b", + "gemma-4-26b", + "gemma4-26b-it", + "gemma-4-26b-it", + "gemma4-llamacpp", + "gemma-4-llamacpp", + "gemma4-26b-llamacpp", + "gemma-4-26b-llamacpp", + "gemma4-26b-llama-cpp", + "gemma-4-26b-llama-cpp", + "gemma4-llama-cpp", + "gemma-4-llama-cpp", + "llamacpp-gemma4-26b", + "llama-cpp-gemma4-26b", + "llamacpp-gemma4", + "llama-cpp-gemma4", + }: + return default_gemma4_llamacpp_model_id() + return normalized + + +def _resolve_monkeyocr_entrypoint(repo_path: Path) -> Path: + for candidate in ( + repo_path / "parse.py", + repo_path / "infer.py", + repo_path / "inference.py", + repo_path / "run.py", + repo_path / "demo.py", + repo_path / "app.py", + ): + if candidate.exists(): + return candidate + raise RuntimeError( + "MonkeyOCR backend needs either MONKEYOCR_RUN_COMMAND or one of parse.py/infer.py/inference.py/run.py/demo.py/app.py in MONKEYOCR_REPO_DIR." + ) + + +def _extract_monkeyocr_text_payload(payload: Any, *, _depth: int = 0) -> Optional[str]: + if _depth > 8: + return None + if isinstance(payload, str): + normalized = normalize_text(payload) + return payload if normalized else None + if isinstance(payload, dict): + preferred_keys = ( + "html", + "markdown", + "md", + "table_html", + "table_markdown", + "output_html", + "output_markdown", + "prediction", + "pred", + "result", + "response", + "text", + "content", + "output", + "ocr", + "table", + "data", + ) + for key in preferred_keys: + extracted = _extract_monkeyocr_text_payload(payload.get(key), _depth=_depth + 1) + if extracted: + return extracted + for value in payload.values(): + extracted = _extract_monkeyocr_text_payload(value, _depth=_depth + 1) + if extracted: + return extracted + return None + if isinstance(payload, list): + candidates = [ + extracted + for extracted in ( + _extract_monkeyocr_text_payload(item, _depth=_depth + 1) + for item in payload + ) + if extracted + ] + if not candidates: + return None + return max(candidates, key=lambda item: len(normalize_text(re.sub(r"<[^>]+>", " ", item)))) + return None + + +def _coerce_monkeyocr_output_text(raw_text: str) -> str: + text = str(raw_text or "") + normalized = normalize_text(text) + if not normalized: + return "" + if normalized.startswith("{") or normalized.startswith("["): + try: + payload = json.loads(normalized) + except Exception: + return text + extracted = _extract_monkeyocr_text_payload(payload) + if extracted: + return extracted + return text + + +def _read_monkeyocr_output_artifact(path: Path) -> str: + suffix = path.suffix.lower() + text = path.read_text(encoding="utf-8", errors="replace") + if suffix == ".json": + try: + payload = json.loads(text) + except Exception: + return _coerce_monkeyocr_output_text(text) + extracted = _extract_monkeyocr_text_payload(payload) + return extracted or "" + return _coerce_monkeyocr_output_text(text) + + +def firered_mps_retry_pixel_limits() -> List[int]: + raw_value = normalize_text(os.getenv("FIRERED_MPS_RETRY_MAX_IMAGE_PIXELS", "1500000,1000000")) + limits: List[int] = [] + seen: set[int] = set() + for piece in raw_value.split(","): + try: + value = max(0, int(piece.strip())) + except ValueError: + continue + if value <= 0 or value in seen: + continue + limits.append(value) + seen.add(value) + return limits + + +def default_deepseek_ocr_model_id() -> str: + return normalize_text(os.getenv("DEEPSEEK_OCR_MODEL_ID", "deepseek-ai/DeepSeek-OCR-2")) or "deepseek-ai/DeepSeek-OCR-2" + + +def default_mistral_ocr_model_id() -> str: + return normalize_text(os.getenv("MISTRAL_OCR_MODEL_ID", "mistral-ocr-latest")) or "mistral-ocr-latest" + + +def default_pdf_page_ocr_model_id() -> str: + candidates = [ + normalize_text(os.getenv("PDF_PAGE_OCR_MODEL_ID", "")), + normalize_text(os.getenv("MISTRAL_OCR_MODEL_ID", "")), + default_mistral_ocr_model_id(), + ] + for candidate in candidates: + if candidate: + return candidate + return default_mistral_ocr_model_id() + + +def _mistral_ocr_table_format() -> str: + value = normalize_text(os.getenv("MISTRAL_OCR_TABLE_FORMAT", "html")).lower() + if value in {"markdown", "html"}: + return value + return "html" + + +def _deepseek_ocr_local_dir() -> Optional[str]: + value = normalize_text(os.getenv("DEEPSEEK_OCR_MODEL_LOCAL_DIR", "")) + return value or None + + +def _deepseek_ocr_cache_dir() -> Optional[str]: + value = normalize_text(os.getenv("DEEPSEEK_OCR_MODEL_CACHE_DIR", "")) + return value or None + + +def _deepseek_ocr_revision() -> Optional[str]: + value = normalize_text(os.getenv("DEEPSEEK_OCR_MODEL_REVISION", "")) + return value or None + + +def _deepseek_ocr_local_files_only() -> bool: + return _env_flag("DEEPSEEK_OCR_LOCAL_FILES_ONLY") + + +def _deepseek_ocr_trust_remote_code() -> bool: + return _env_flag("DEEPSEEK_OCR_TRUST_REMOTE_CODE", "1") + + +def _deepseek_ocr_device() -> str: + return normalize_text(os.getenv("DEEPSEEK_OCR_DEVICE", "auto")).lower() or "auto" + + +def _deepseek_ocr_device_map() -> str: + return normalize_text(os.getenv("DEEPSEEK_OCR_DEVICE_MAP", "auto")) or "auto" + + +def _deepseek_ocr_max_new_tokens() -> int: + return _env_int("DEEPSEEK_OCR_MAX_NEW_TOKENS", 4096) + + +def _deepseek_ocr_max_image_pixels() -> int: + return _env_int("DEEPSEEK_OCR_MAX_IMAGE_PIXELS", 0) + + +def _backend_env_name(prefix: str, suffix: str) -> str: + return f"{prefix.upper()}_{suffix.upper()}" + + +def _backend_model_local_dir(prefix: str) -> Optional[str]: + value = normalize_text(os.getenv(_backend_env_name(prefix, "MODEL_LOCAL_DIR"), "")) + return value or None + + +def _backend_model_cache_dir(prefix: str) -> Optional[str]: + value = normalize_text(os.getenv(_backend_env_name(prefix, "MODEL_CACHE_DIR"), "")) + return value or None + + +def _backend_model_revision(prefix: str) -> Optional[str]: + value = normalize_text(os.getenv(_backend_env_name(prefix, "MODEL_REVISION"), "")) + return value or None + + +def _backend_local_files_only(prefix: str) -> bool: + return _env_flag(_backend_env_name(prefix, "LOCAL_FILES_ONLY")) + + +def _backend_trust_remote_code(prefix: str, default: Optional[str] = None) -> bool: + if default is None: + # PaddleOCR-VL now has native Transformers support, so remote code should be + # opt-in there to avoid loading stale/incompatible model-side Python. + default = "0" if str(prefix or "").upper() == "PADDLEOCR_VL" else "1" + return _env_flag(_backend_env_name(prefix, "TRUST_REMOTE_CODE"), default) + + +def _backend_device(prefix: str) -> str: + return normalize_text(os.getenv(_backend_env_name(prefix, "DEVICE"), "auto")).lower() or "auto" + + +def _backend_device_map(prefix: str) -> str: + return normalize_text(os.getenv(_backend_env_name(prefix, "DEVICE_MAP"), "auto")) or "auto" + + +def _backend_max_new_tokens(prefix: str, default: int = 4096) -> int: + return _env_int(_backend_env_name(prefix, "MAX_NEW_TOKENS"), default) + + +def _backend_max_image_pixels(prefix: str, default: int = 0) -> int: + return _env_int(_backend_env_name(prefix, "MAX_IMAGE_PIXELS"), default) + + +def _backend_attn_implementation(prefix: str) -> Optional[str]: + value = normalize_text(os.getenv(_backend_env_name(prefix, "ATTN_IMPLEMENTATION"), "")) + return value or None + + +def _select_generic_ocr_runtime(torch, requested: str): + normalized = normalize_text(requested or "auto").lower() or "auto" + mps_available = bool(getattr(torch.backends, "mps", None)) and torch.backends.mps.is_available() + if normalized not in {"auto", "cuda", "mps", "cpu"}: + raise RuntimeError( + f"Unsupported OCR device '{requested}'. Expected one of: auto, cuda, mps, cpu." + ) + if normalized in {"auto", "cuda"} and torch.cuda.is_available(): + return "cuda", torch.bfloat16, True + if normalized == "cuda": + raise RuntimeError("CUDA was requested for OCR, but CUDA is not available.") + if normalized in {"auto", "mps"} and mps_available: + return "mps", torch.float16, False + if normalized == "mps": + raise RuntimeError("MPS was requested for OCR, but MPS is not available.") + return "cpu", torch.float32, False + + +def _resolve_generic_model_source(model_id: str, *, env_prefix: str) -> str: + local_dir = _backend_model_local_dir(env_prefix) + if not local_dir: + return model_id + local_path = Path(local_dir).expanduser() + if str(local_path).startswith("/content") and not Path("/content").exists(): + raise RuntimeError( + f"{_backend_env_name(env_prefix, 'MODEL_LOCAL_DIR')} points to '{local_dir}', which looks like a Colab path, " + "but this process is running outside Colab." + ) + if not local_path.exists(): + raise RuntimeError(f"{_backend_env_name(env_prefix, 'MODEL_LOCAL_DIR')}='{local_dir}' does not exist.") + if not local_path.is_dir(): + raise RuntimeError(f"{_backend_env_name(env_prefix, 'MODEL_LOCAL_DIR')}='{local_dir}' is not a directory.") + return str(local_path) + + +def _prepare_backend_image(image, *, env_prefix: str, runtime_device: str): + del runtime_device + if not _table_ocr_allow_backend_image_resize(): + return image + max_pixels = _backend_max_image_pixels(env_prefix, 0) + width, height = image.size + total_pixels = width * height + if max_pixels <= 0 or total_pixels <= max_pixels: + return image + scale = math.sqrt(float(max_pixels) / float(total_pixels)) + new_width = max(28, int(width * scale)) + new_height = max(28, int(height * scale)) + emit_progress( + f"Resizing {env_prefix} OCR image from {width}x{height} to {new_width}x{new_height} " + f"to stay within {max_pixels:,} pixels." + ) + return image.resize((new_width, new_height)) + + +def _ensure_transformers_dynamic_cache_compatibility() -> None: + try: + from transformers.cache_utils import Cache, DynamicCache + except ImportError: + return + + def get_seq_length_compat(cache_obj: Any, layer_idx: int = 0) -> int: + get_seq_length = getattr(cache_obj, "get_seq_length", None) + if callable(get_seq_length): + try: + return int(get_seq_length(layer_idx)) + except TypeError: + try: + return int(get_seq_length()) + except Exception: + return 0 + except Exception: + return 0 + return 0 + + def get_max_length_compat(cache_obj: Any, layer_idx: int = 0) -> Optional[int]: + get_max_cache_shape = getattr(cache_obj, "get_max_cache_shape", None) + if not callable(get_max_cache_shape): + return None + try: + max_length = get_max_cache_shape(layer_idx) + except TypeError: + try: + max_length = get_max_cache_shape() + except Exception: + return None + except Exception: + return None + if not isinstance(max_length, (int, float)): + return None + resolved = int(max_length) + return None if resolved < 0 else resolved + + def install_cache_compatibility_shims(cache_cls: Any) -> None: + if hasattr(cache_cls, "seen_tokens"): + seen_tokens_missing = False + else: + seen_tokens_missing = True + + if seen_tokens_missing: + def get_seen_tokens(self) -> int: + override = getattr(self, "_codex_seen_tokens_override", None) + if override is not None: + try: + return int(override) + except Exception: + return 0 + return get_seq_length_compat(self) + + def set_seen_tokens(self, value: Any) -> None: + try: + self._codex_seen_tokens_override = int(value) + except Exception: + self._codex_seen_tokens_override = value + + setattr(cache_cls, "seen_tokens", property(get_seen_tokens, set_seen_tokens)) + + if not hasattr(cache_cls, "get_max_length"): + def get_max_length(self, layer_idx: int = 0) -> Optional[int]: + return get_max_length_compat(self, layer_idx=layer_idx) + + setattr(cache_cls, "get_max_length", get_max_length) + + if not hasattr(cache_cls, "get_usable_length"): + def get_usable_length(self, new_seq_length: int, layer_idx: int = 0) -> int: + previous_seq_length = get_seq_length_compat(self, layer_idx=layer_idx) + max_length = get_max_length_compat(self, layer_idx=layer_idx) + if max_length is not None and previous_seq_length + int(new_seq_length) > max_length: + return max(0, max_length - int(new_seq_length)) + return previous_seq_length + + setattr(cache_cls, "get_usable_length", get_usable_length) + + install_cache_compatibility_shims(Cache) + install_cache_compatibility_shims(DynamicCache) + + +def _maybe_to_model_device(batch: Any, model_device: Any): + try: + return batch.to(model_device) + except Exception: + return batch + + +def _get_batch_item(batch: Any, key: str): + if isinstance(batch, dict): + return batch.get(key) + return getattr(batch, key, None) + + +def _decode_generated_text(processor: Any, generated_ids: Any, input_ids: Any = None) -> str: + trimmed_ids = generated_ids + if input_ids is not None: + try: + trimmed_ids = generated_ids[:, input_ids.shape[1] :] + except Exception: + trimmed_ids = generated_ids + decode_targets = [ + processor, + getattr(processor, "tokenizer", None), + ] + for target in decode_targets: + if target is None or not hasattr(target, "batch_decode"): + continue + try: + decoded = target.batch_decode( + trimmed_ids, + skip_special_tokens=True, + clean_up_tokenization_spaces=False, + ) + if isinstance(decoded, list) and decoded: + return decoded[0] + except Exception: + continue + raise RuntimeError("Could not decode OCR model output with the loaded processor/tokenizer.") + + +def _build_generic_messages(prompt_text: str, page_image) -> List[Dict[str, Any]]: + return [ + { + "role": "user", + "content": [ + {"type": "image", "image": page_image}, + {"type": "text", "text": prompt_text}, + ], + } + ] + + +def _build_transformers_multimodal_inputs(processor: Any, page_image, prompt_text: str): + messages = _build_generic_messages(prompt_text, page_image) + if hasattr(processor, "apply_chat_template"): + try: + chat_text = processor.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + ) + try: + return processor(text=[chat_text], images=[page_image], return_tensors="pt") + except Exception: + return processor(text=chat_text, images=page_image, return_tensors="pt") + except Exception: + pass + attempts = [ + {"text": [prompt_text], "images": [page_image], "return_tensors": "pt"}, + {"text": prompt_text, "images": page_image, "return_tensors": "pt"}, + {"text": [prompt_text], "image": [page_image], "return_tensors": "pt"}, + {"text": prompt_text, "image": page_image, "return_tensors": "pt"}, + ] + last_exc: Optional[Exception] = None + for kwargs in attempts: + try: + return processor(**kwargs) + except Exception as exc: + last_exc = exc + raise RuntimeError(f"Could not build multimodal OCR inputs: {last_exc}") + + +def _normalize_chat_result(result: Any) -> str: + if isinstance(result, str): + return result + if isinstance(result, tuple): + for item in result: + if isinstance(item, str) and normalize_text(item): + return item + if isinstance(result, dict): + for key in ("text", "response", "content", "answer", "output", "transcription"): + value = result.get(key) + if isinstance(value, str) and normalize_text(value): + return value + raise RuntimeError(f"OCR chat backend returned unsupported result type: {type(result).__name__}") + + +def _build_generation_config_dict(prefix: str) -> Dict[str, Any]: + return { + "max_new_tokens": _backend_max_new_tokens(prefix, 4096), + "do_sample": False, + } + + +@contextlib.contextmanager +def _known_model_load_warnings_context(*, env_prefix: str): + if env_prefix != "GOT_OCR": + yield + return + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", + message=r".*invalid escape sequence '\\l'.*", + category=SyntaxWarning, + ) + yield + + +def _call_from_pretrained_with_dtype_fallback(loader: Any, model_source: str, **kwargs: Any): + try: + return loader(model_source, **kwargs) + except TypeError as exc: + if "unexpected keyword argument 'dtype'" not in str(exc) or "dtype" not in kwargs: + raise + fallback_kwargs = dict(kwargs) + fallback_kwargs["torch_dtype"] = fallback_kwargs.pop("dtype") + return loader(model_source, **fallback_kwargs) + + +def _build_got_ocr_prompt_and_stop_text() -> tuple[str, str]: + stop_text = "<|im_end|>" + system_prompt = ( + "<|im_start|>system\n" + " You should follow the instructions carefully and explain your answers in detail." + ) + image_prompt = "" + ("" * 256) + "\nOCR with format: " + prompt = ( + system_prompt + + stop_text + + "<|im_start|>user\n" + + image_prompt + + stop_text + + "<|im_start|>assistant\n" + ) + return prompt, stop_text + + +def _build_got_ocr_image_tensor(page_image): + try: + import torchvision.transforms as T + from torchvision.transforms.functional import InterpolationMode + except ImportError as exc: + raise RuntimeError("GOT_OCR local backend requires torchvision for image preprocessing.") from exc + + transform = T.Compose( + [ + T.Lambda(lambda img: img.convert("RGB") if img.mode != "RGB" else img), + T.Resize((1024, 1024), interpolation=InterpolationMode.BICUBIC), + T.ToTensor(), + T.Normalize( + mean=(0.48145466, 0.4578275, 0.40821073), + std=(0.26862954, 0.26130258, 0.27577711), + ), + ] + ) + return transform(page_image).unsqueeze(0) + + +def _run_got_ocr_generate_backend( + model_obj: Any, + tokenizer_like: Any, + page_image, + *, + model_device: Any, +) -> str: + prompt, stop_text = _build_got_ocr_prompt_and_stop_text() + try: + tokenized_inputs = tokenizer_like([prompt], return_tensors="pt") + except Exception: + tokenized_inputs = tokenizer_like(prompt, return_tensors="pt") + + input_ids = _get_batch_item(tokenized_inputs, "input_ids") + if input_ids is None: + raise RuntimeError("GOT_OCR tokenizer did not return input_ids for the native OCR prompt.") + attention_mask = _get_batch_item(tokenized_inputs, "attention_mask") + + try: + input_ids = input_ids.to(model_device) + except Exception: + pass + if attention_mask is None: + try: + import torch + + attention_mask = torch.ones_like(input_ids) + except Exception: + attention_mask = None + elif hasattr(attention_mask, "to"): + try: + attention_mask = attention_mask.to(model_device) + except Exception: + pass + + image_tensor = _build_got_ocr_image_tensor(page_image) + image_dtype = getattr(model_obj, "dtype", None) + try: + image_tensor = image_tensor.to(device=model_device, dtype=image_dtype) + except Exception: + try: + image_tensor = image_tensor.to(model_device) + except Exception: + pass + + generate_kwargs: Dict[str, Any] = { + "input_ids": input_ids, + "images": [image_tensor], + "do_sample": False, + "num_beams": 1, + "no_repeat_ngram_size": 20, + "max_new_tokens": _backend_max_new_tokens("GOT_OCR", 4096), + # GOT's remote-code chat() helper can hit cache/attention shape mismatches. + "use_cache": False, + } + if attention_mask is not None: + generate_kwargs["attention_mask"] = attention_mask + eos_token_id = getattr(tokenizer_like, "eos_token_id", None) + pad_token_id = getattr(tokenizer_like, "pad_token_id", None) + if pad_token_id is None: + pad_token_id = eos_token_id + if pad_token_id is not None: + generate_kwargs["pad_token_id"] = pad_token_id + if eos_token_id is not None: + generate_kwargs["eos_token_id"] = eos_token_id + + with __import__("torch").inference_mode(): + generated_ids = model_obj.generate(**generate_kwargs) + + decoded_output = _decode_generated_text(tokenizer_like, generated_ids, input_ids=input_ids) + if stop_text and stop_text in decoded_output: + decoded_output = decoded_output.split(stop_text, 1)[0] + return decoded_output.strip() + + +def _run_got_ocr_backend( + model_obj: Any, + tokenizer_like: Any, + page_image, + *, + model_device: Any, +) -> str: + errors: List[str] = [] + try: + emit_progress("Trying GOT_OCR OCR via direct generate(..., attention_mask=..., use_cache=False)") + return _run_got_ocr_generate_backend( + model_obj, + tokenizer_like, + page_image, + model_device=model_device, + ) + except Exception as exc: + errors.append(f"direct generate(..., attention_mask=..., use_cache=False): {exc}") + + try: + return _run_chat_style_backend( + model_obj, + tokenizer_like, + page_image, + default_table_image_transcription_prompt(), + env_prefix="GOT_OCR", + model_device=model_device, + ) + except Exception as exc: + errors.append(f"legacy chat(...): {exc}") + + raise RuntimeError("GOT_OCR backend exhausted: " + " ; ".join(errors)) + + +def _run_generate_style_backend( + model_obj: Any, + processor: Any, + page_image, + prompt_text: str, + *, + model_device: Any, + env_prefix: str, +) -> str: + batch = _build_transformers_multimodal_inputs(processor, page_image, prompt_text) + batch = _maybe_to_model_device(batch, model_device) + input_ids = _get_batch_item(batch, "input_ids") + generate_fn = getattr(model_obj, "generate", None) + if not callable(generate_fn): + raise RuntimeError(f"{env_prefix} OCR model does not expose a callable generate() method.") + with __import__("torch").inference_mode(): + generated_ids = generate_fn( + **batch, + max_new_tokens=_backend_max_new_tokens(env_prefix, 4096), + do_sample=False, + ) + return _decode_generated_text(processor, generated_ids, input_ids=input_ids) + + +def _build_image_processor_inputs(processor: Any, page_image): + attempts = [ + {"images": [page_image], "return_tensors": "pt"}, + {"images": page_image, "return_tensors": "pt"}, + {"image": [page_image], "return_tensors": "pt"}, + {"image": page_image, "return_tensors": "pt"}, + ] + for kwargs in attempts: + try: + outputs = processor(**kwargs) + except Exception: + continue + pixel_values = _get_batch_item(outputs, "pixel_values") + if pixel_values is not None: + return pixel_values + return None + + +def _build_qianfan_pixel_values(page_image, *, image_size: int = 448, max_num: int = 12): + try: + import torch + import torchvision.transforms as T + from torchvision.transforms.functional import InterpolationMode + except ImportError as exc: + raise RuntimeError( + "QIANFAN_OCR local backend requires torch and torchvision." + ) from exc + + imagenet_mean = (0.485, 0.456, 0.406) + imagenet_std = (0.229, 0.224, 0.225) + transform = T.Compose( + [ + T.Lambda(lambda img: img.convert("RGB") if img.mode != "RGB" else img), + T.Resize((image_size, image_size), interpolation=InterpolationMode.BICUBIC), + T.ToTensor(), + T.Normalize(mean=imagenet_mean, std=imagenet_std), + ] + ) + + orig_width, orig_height = page_image.size + aspect_ratio = orig_width / max(1, orig_height) + target_ratios = sorted( + { + (i, j) + for n in range(1, max_num + 1) + for i in range(1, n + 1) + for j in range(1, n + 1) + if 1 <= i * j <= max_num + }, + key=lambda ratio: ratio[0] * ratio[1], + ) + best_ratio = (1, 1) + best_ratio_diff = float("inf") + area = orig_width * orig_height + for ratio in target_ratios: + target_aspect_ratio = ratio[0] / ratio[1] + ratio_diff = abs(aspect_ratio - target_aspect_ratio) + if ratio_diff < best_ratio_diff: + best_ratio_diff = ratio_diff + best_ratio = ratio + elif ratio_diff == best_ratio_diff: + if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]: + best_ratio = ratio + + target_width = image_size * best_ratio[0] + target_height = image_size * best_ratio[1] + resized_img = page_image.resize((target_width, target_height)) + processed_images = [] + blocks = best_ratio[0] * best_ratio[1] + for block_index in range(blocks): + box = ( + (block_index % best_ratio[0]) * image_size, + (block_index // best_ratio[0]) * image_size, + ((block_index % best_ratio[0]) + 1) * image_size, + ((block_index // best_ratio[0]) + 1) * image_size, + ) + processed_images.append(resized_img.crop(box)) + if len(processed_images) != 1: + processed_images.append(page_image.resize((image_size, image_size))) + return torch.stack([transform(image) for image in processed_images]) + + +def _run_chat_style_backend( + model_obj: Any, + tokenizer_like: Any, + page_image, + prompt_text: str, + *, + env_prefix: str, + model_device: Any, +) -> str: + chat_fn = getattr(model_obj, "chat", None) + if not callable(chat_fn): + raise RuntimeError(f"{env_prefix} OCR model does not expose a callable chat() method.") + signature = inspect.signature(chat_fn) + param_names = set(signature.parameters) + generation_config = _build_generation_config_dict(env_prefix) + + pixel_values = None + processor = getattr(model_obj, "processor", None) + if processor is not None: + pixel_values = _build_image_processor_inputs(processor, page_image) + if pixel_values is None and tokenizer_like is not None and not _processor_is_tokenizer_like(tokenizer_like): + pixel_values = _build_image_processor_inputs(tokenizer_like, page_image) + if pixel_values is not None: + try: + pixel_values = pixel_values.to(model_device) + except Exception: + pass + + with TemporaryDirectory(prefix=f"{env_prefix.lower()}_ocr_") as tmpdir: + image_path = Path(tmpdir) / "page.png" + page_image.convert("RGB").save(image_path) + attempts: List[tuple[str, Dict[str, Any]]] = [] + if {"tokenizer", "pixel_values", "question"}.issubset(param_names) and pixel_values is not None: + attempts.append( + ( + "chat(tokenizer=..., pixel_values=..., question=...)", + { + "tokenizer": tokenizer_like, + "pixel_values": pixel_values, + "question": prompt_text, + "generation_config": generation_config, + }, + ) + ) + if {"tokenizer", "image_file", "ocr_type"}.issubset(param_names): + kwargs = { + "tokenizer": tokenizer_like, + "image_file": str(image_path), + "ocr_type": "format", + } + if "question" in param_names: + kwargs["question"] = prompt_text + if "query" in param_names: + kwargs["query"] = prompt_text + if "generation_config" in param_names: + kwargs["generation_config"] = generation_config + attempts.append(("chat(tokenizer=..., image_file=..., ocr_type='format')", kwargs)) + if {"tokenizer", "image_file", "question"}.issubset(param_names): + attempts.append( + ( + "chat(tokenizer=..., image_file=..., question=...)", + { + "tokenizer": tokenizer_like, + "image_file": str(image_path), + "question": prompt_text, + "generation_config": generation_config, + }, + ) + ) + if {"tokenizer", "image", "query"}.issubset(param_names): + attempts.append( + ( + "chat(tokenizer=..., image=..., query=...)", + { + "tokenizer": tokenizer_like, + "image": page_image, + "query": prompt_text, + "generation_config": generation_config, + }, + ) + ) + if {"tokenizer", "msgs"}.issubset(param_names): + attempts.append( + ( + "chat(tokenizer=..., msgs=...)", + { + "tokenizer": tokenizer_like, + "msgs": [{"role": "user", "content": prompt_text}], + "image": page_image, + }, + ) + ) + + errors: List[str] = [] + for label, kwargs in attempts: + filtered_kwargs = {key: value for key, value in kwargs.items() if key in param_names and value is not None} + try: + emit_progress(f"Trying {env_prefix} OCR via {label}") + return _normalize_chat_result(chat_fn(**filtered_kwargs)) + except Exception as exc: + errors.append(f"{label}: {exc}") + + raise RuntimeError(f"{env_prefix} OCR chat fallback exhausted: {' ; '.join(errors)}") + + +def _build_transformers_model_kwargs( + *, + env_prefix: str, + model_source: str, + dtype: Any, + runtime_device: str, + use_device_map: bool, +) -> Dict[str, Any]: + kwargs: Dict[str, Any] = { + "trust_remote_code": _backend_trust_remote_code(env_prefix), + "local_files_only": _backend_local_files_only(env_prefix), + } + cache_dir = _backend_model_cache_dir(env_prefix) + if cache_dir: + kwargs["cache_dir"] = cache_dir + revision = _backend_model_revision(env_prefix) + if revision: + kwargs["revision"] = revision + attn_implementation = _backend_attn_implementation(env_prefix) + if attn_implementation: + kwargs["attn_implementation"] = attn_implementation + if runtime_device == "cuda": + kwargs["dtype"] = dtype + if use_device_map: + kwargs["device_map"] = _backend_device_map(env_prefix) + elif runtime_device == "cpu": + kwargs["dtype"] = dtype + return kwargs + + +def _load_first_available_processor(model_source: str, *, env_prefix: str, prefer_tokenizer: bool = False): + try: + from transformers import AutoProcessor, AutoTokenizer + except ImportError as exc: + raise RuntimeError( + f"{env_prefix} OCR requires transformers. Install a recent transformers build first." + ) from exc + + common_kwargs: Dict[str, Any] = { + "trust_remote_code": _backend_trust_remote_code(env_prefix), + "local_files_only": _backend_local_files_only(env_prefix), + } + cache_dir = _backend_model_cache_dir(env_prefix) + if cache_dir: + common_kwargs["cache_dir"] = cache_dir + revision = _backend_model_revision(env_prefix) + if revision: + common_kwargs["revision"] = revision + + constructors = [AutoProcessor, AutoTokenizer] + if prefer_tokenizer: + constructors = [AutoTokenizer, AutoProcessor] + failures: List[str] = [] + for constructor in constructors: + constructor_kwargs = dict(common_kwargs) + if constructor.__name__ == "AutoTokenizer": + constructor_kwargs.setdefault("use_fast", False) + try: + with _known_model_load_warnings_context(env_prefix=env_prefix): + return constructor.from_pretrained(model_source, **constructor_kwargs) + except Exception as exc: + failures.append(f"{constructor.__name__}: {exc}") + raise RuntimeError( + f"Could not load processor/tokenizer for {model_source}: " + " | ".join(failures) + ) + + +def _load_first_available_model(model_source: str, *, env_prefix: str): + try: + import torch + from transformers import AutoModel, AutoModelForCausalLM + except ImportError as exc: + raise RuntimeError( + f"{env_prefix} OCR requires transformers and torch." + ) from exc + + try: + from transformers import AutoModelForImageTextToText + except ImportError: + AutoModelForImageTextToText = None + try: + from transformers import AutoModelForVision2Seq + except ImportError: + AutoModelForVision2Seq = None + + runtime_device, dtype, use_device_map = _select_generic_ocr_runtime(torch, _backend_device(env_prefix)) + common_kwargs = _build_transformers_model_kwargs( + env_prefix=env_prefix, + model_source=model_source, + dtype=dtype, + runtime_device=runtime_device, + use_device_map=use_device_map, + ) + constructors = [ + constructor + for constructor in ( + AutoModelForImageTextToText, + AutoModelForVision2Seq, + AutoModelForCausalLM, + AutoModel, + ) + if constructor is not None + ] + last_exc: Optional[Exception] = None + for constructor in constructors: + try: + with _known_model_load_warnings_context(env_prefix=env_prefix): + model_obj = _call_from_pretrained_with_dtype_fallback( + constructor.from_pretrained, + model_source, + **common_kwargs, + ) + if runtime_device in {"cpu", "mps"}: + model_obj = model_obj.to(runtime_device) + return model_obj, runtime_device + except Exception as exc: + last_exc = exc + raise RuntimeError(f"Could not load model for {model_source}: {last_exc}") + + +def _get_generic_ocr_backend( + model_id: str, + *, + env_prefix: str, + prefer_tokenizer: bool = False, +): + cache_key = (env_prefix, model_id) + cached = _GENERIC_OCR_BACKENDS.get(cache_key) + if cached is not None: + return cached + model_source = _resolve_generic_model_source(model_id, env_prefix=env_prefix) + processor = _load_first_available_processor( + model_source, + env_prefix=env_prefix, + prefer_tokenizer=prefer_tokenizer, + ) + model_obj, runtime_device = _load_first_available_model( + model_source, + env_prefix=env_prefix, + ) + cached = (model_obj, processor, runtime_device) + _GENERIC_OCR_BACKENDS[cache_key] = cached + return cached + + +def _run_monkeyocr_command( + page_image, + prompt_text: str, + *, + model_id: str, + progress_handler: ProgressHandler = None, +) -> str: + repo_dir = normalize_text(os.getenv("MONKEYOCR_REPO_DIR", "")) + if not repo_dir: + raise RuntimeError( + "MonkeyOCR local backend requires MONKEYOCR_REPO_DIR to point at a local MonkeyOCR checkout." + ) + repo_path = Path(repo_dir).expanduser() + if not repo_path.exists(): + raise RuntimeError(f"MONKEYOCR_REPO_DIR='{repo_dir}' does not exist.") + runner_template = normalize_text(os.getenv("MONKEYOCR_RUN_COMMAND", "")) + if not runner_template: + default_entrypoint = _resolve_monkeyocr_entrypoint(repo_path) + runner_template = ( + "{python_bin} {entrypoint} {image_path} -o {output_dir}" + ) + python_bin = normalize_text(os.getenv("MONKEYOCR_PYTHON", sys.executable)) or sys.executable + timeout_s = _env_int("MONKEYOCR_TIMEOUT_S", 900) + output_glob = normalize_text(os.getenv("MONKEYOCR_OUTPUT_GLOB", "")) + emit_progress( + f"MonkeyOCR local wrapper | repo {repo_path} | model {model_id}", + progress_handler=progress_handler, + ) + with TemporaryDirectory(prefix="monkeyocr_") as tmpdir: + tmpdir_path = Path(tmpdir) + image_path = Path(tmpdir) / "page.png" + page_image.convert("RGB").save(image_path) + prompt_path = tmpdir_path / "prompt.txt" + prompt_path.write_text(str(prompt_text or ""), encoding="utf-8") + entrypoint = _resolve_monkeyocr_entrypoint(repo_path) + formatted_command = runner_template.format( + python_bin=shlex.quote(python_bin), + entrypoint=shlex.quote(str(entrypoint)), + image_path=shlex.quote(str(image_path)), + output_dir=shlex.quote(tmpdir), + prompt=shlex.quote(prompt_text), + prompt_path=shlex.quote(str(prompt_path)), + model_id=shlex.quote(model_id), + repo_dir=shlex.quote(str(repo_path)), + ) + child_env = os.environ.copy() + child_env["MONKEYOCR_IMAGE_PATH"] = str(image_path) + child_env["MONKEYOCR_OUTPUT_DIR_ACTIVE"] = str(tmpdir_path) + child_env["MONKEYOCR_PROMPT"] = str(prompt_text or "") + child_env["MONKEYOCR_PROMPT_FILE"] = str(prompt_path) + child_env["MONKEYOCR_MODEL_ID_ACTIVE"] = str(model_id) + try: + completed = subprocess.run( + formatted_command, + cwd=str(repo_path), + shell=True, + capture_output=True, + text=True, + env=child_env, + timeout=timeout_s, + ) + except subprocess.TimeoutExpired as exc: + raise RuntimeError( + f"MonkeyOCR command timed out after {timeout_s}s: {formatted_command}" + ) from exc + if completed.returncode != 0: + raise RuntimeError( + "MonkeyOCR command failed: " + f"{normalize_text(completed.stderr) or normalize_text(completed.stdout) or completed.returncode}" + ) + for candidate in ( + "result.md", + "result.html", + "result.json", + "output.md", + "output.html", + "output.json", + "pred.md", + "pred.html", + "pred.json", + "response.json", + "response.md", + "response.html", + "table.html", + "table.md", + "table.json", + "ocr_result.json", + "ocr_result.md", + "ocr_result.html", + "result.txt", + "output.txt", + ): + candidate_path = tmpdir_path / candidate + if candidate_path.exists(): + extracted = _read_monkeyocr_output_artifact(candidate_path) + if normalize_text(extracted): + return extracted + if output_glob: + for pattern in [piece.strip() for piece in output_glob.split(",") if piece.strip()]: + for candidate_path in sorted(tmpdir_path.glob(pattern)): + if candidate_path.is_file(): + if candidate_path.name in {"prompt.txt", image_path.name}: + continue + extracted = _read_monkeyocr_output_artifact(candidate_path) + if normalize_text(extracted): + return extracted + for candidate_path in ( + sorted(tmpdir_path.glob("**/*.html")) + + sorted(tmpdir_path.glob("**/*.md")) + + sorted(tmpdir_path.glob("**/*.json")) + + sorted(tmpdir_path.glob("**/*.txt")) + ): + if candidate_path.is_file(): + if candidate_path.name in {"prompt.txt", image_path.name}: + continue + extracted = _read_monkeyocr_output_artifact(candidate_path) + if normalize_text(extracted): + return extracted + stdout_text = _coerce_monkeyocr_output_text(completed.stdout) + if stdout_text: + return stdout_text + raise RuntimeError( + "MonkeyOCR command completed but did not produce a readable OCR output file. " + "Set MONKEYOCR_RUN_COMMAND if your checkout uses a nonstandard entrypoint, output path, or task flags." + ) + + +def is_firered_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_firered_model_id().lower() + return normalized == configured or "firered" in normalized + + +def is_deepseek_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_deepseek_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("deepseek-ai/") + or "deepseek-ocr" in normalized + ) + + +def is_mistral_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_mistral_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("mistral-ocr") + or normalized.startswith("ocr-") + or ("mistral" in normalized and "ocr" in normalized) + ) + + +def is_qianfan_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_qianfan_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("baidu/qianfan") + or normalized in {"qianfan", "qianfan-ocr"} + or "qianfan-ocr" in normalized + ) + + +def is_glm_ocr_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_glm_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("zai-org/glm-ocr") + or normalized in {"glm-ocr", "glmocr"} + or normalized.endswith("/glm-ocr") + ) + + +def is_paddleocr_vl_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_paddleocr_vl_model_id().lower() + return ( + normalized == configured + or normalized.startswith("paddlepaddle/paddleocr-vl") + or normalized in {"paddleocr-vl", "paddleocr-vl-1.5", "paddleocr_vl"} + or "paddleocr-vl" in normalized + ) + + +def is_got_ocr_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_got_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("stepfun-ai/got-ocr") + or normalized in {"got-ocr", "got-ocr2", "got-ocr2_0", "gotocr", "gotocr2"} + or "got-ocr" in normalized + or "got_ocr" in normalized + ) + + +def is_monkeyocr_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_monkeyocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("echo840/monkeyocr") + or normalized in {"monkeyocr", "monkeyocr-pro-3b", "monkeyocr_pro_3b"} + or "monkeyocr" in normalized + ) + + +def is_qwen_ocr_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower() + if not normalized: + return False + configured = default_qwen_ocr_model_id().lower() + return ( + normalized == configured + or normalized.startswith("qwen/qwen3.5-35b-a3b") + or normalized.startswith("qwen/qwen3.6-35b-a3b") + or normalized in { + "qwen_ocr", + "qwen-ocr", + "qwenocr", + "qwen3.5-35b-a3b", + "qwen3.5-35b-a3b-fp8", + "qwen3.6-35b-a3b", + "qwen3.6-35b-a3b-fp8", + } + or "qwen3.5-35b-a3b" in normalized + or "qwen3.6-35b-a3b" in normalized + ) + + +def is_gemma4_vllm_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower().replace("_", "-") + if not normalized: + return False + configured = default_gemma4_vllm_model_id().lower().replace("_", "-") + if normalized == configured: + return True + if "llamacpp" in normalized or "llama-cpp" in normalized or "llama.cpp" in normalized or "gguf" in normalized: + return False + return ( + normalized.startswith("google/gemma-4-") + or normalized.startswith("gemma-4-") + or normalized.startswith("gemma4-") + or normalized in {"gemma4-vllm", "gemma-4-vllm"} + ) + + +def is_gemma4_hf_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower().replace("_", "-") + if not normalized: + return False + if "vllm" in normalized or "llamacpp" in normalized or "llama-cpp" in normalized or "llama.cpp" in normalized or "gguf" in normalized: + return False + configured = default_gemma4_hf_model_id().lower().replace("_", "-") + if normalized == configured: + return True + return ( + normalized in { + "gemma4", + "gemma-4", + "gemma4-hf", + "gemma-4-hf", + "gemma4-local", + "gemma-4-local", + "gemma4-huggingface", + "gemma-4-huggingface", + "gemma4-transformers", + "gemma-4-transformers", + } + or normalized.startswith("google/gemma-4-") + or normalized.startswith("gemma-4-") + or normalized.startswith("gemma4-") + ) + + +def is_gemma4_llamacpp_model_id(model_id: str) -> bool: + normalized = normalize_text(model_id).lower().replace("_", "-") + if not normalized: + return False + configured = default_gemma4_llamacpp_model_id().lower().replace("_", "-") + if normalized == configured: + return True + if normalized in { + "gemma4", + "gemma-4", + "gemma4-26b", + "gemma-4-26b", + "gemma4-26b-it", + "gemma-4-26b-it", + "gemma4-llamacpp", + "gemma-4-llamacpp", + "gemma4-26b-llamacpp", + "gemma-4-26b-llamacpp", + "gemma4-26b-llama-cpp", + "gemma-4-26b-llama-cpp", + "gemma4-llama-cpp", + "gemma-4-llama-cpp", + "llamacpp-gemma4-26b", + "llama-cpp-gemma4-26b", + "llamacpp-gemma4", + "llama-cpp-gemma4", + }: + return True + return ("gemma4" in normalized or "gemma-4" in normalized) and ( + "llamacpp" in normalized + or "llama-cpp" in normalized + or "llama.cpp" in normalized + or "gguf" in normalized + ) + + +def resolve_table_ocr_backend(model_id: str) -> str: + normalized = normalize_text(model_id) + if is_firered_model_id(normalized): + return "firered" + if is_deepseek_model_id(normalized): + return "deepseek" + if is_mistral_model_id(normalized): + return "mistral" + if is_qianfan_model_id(normalized): + return "qianfan" + if is_glm_ocr_model_id(normalized): + return "glm_ocr" + if is_paddleocr_vl_model_id(normalized): + return "paddleocr_vl" + if is_got_ocr_model_id(normalized): + return "got_ocr" + if is_monkeyocr_model_id(normalized): + return "monkeyocr" + if is_qwen_ocr_model_id(normalized): + return "qwen_ocr" + if is_gemma4_hf_model_id(normalized): + return "gemma4_hf" + if is_gemma4_vllm_model_id(normalized): + return "gemma4_vllm" + if is_gemma4_llamacpp_model_id(normalized): + return "gemma4_llamacpp" + if normalized in openrouter_ocr_model_ids(): + return "openrouter" + return "openrouter" + + +def should_use_openrouter_ocr(model_id: str) -> bool: + return resolve_table_ocr_backend(model_id) == "openrouter" + + +def _resolve_deepseek_ocr_model_source(model_id: str) -> str: + local_dir = _deepseek_ocr_local_dir() + if not local_dir: + return model_id + + local_path = Path(local_dir).expanduser() + if str(local_path).startswith("/content") and not Path("/content").exists(): + raise RuntimeError( + f"DEEPSEEK_OCR_MODEL_LOCAL_DIR points to '{local_dir}', which looks like a Colab path, " + "but this Python process is running outside Colab." + ) + if not local_path.exists(): + raise RuntimeError( + f"DEEPSEEK_OCR_MODEL_LOCAL_DIR='{local_dir}' does not exist." + ) + if not local_path.is_dir(): + raise RuntimeError(f"DEEPSEEK_OCR_MODEL_LOCAL_DIR='{local_dir}' is not a directory.") + if not (local_path / "config.json").exists(): + raise RuntimeError( + f"DEEPSEEK_OCR_MODEL_LOCAL_DIR='{local_dir}' does not look like a downloaded model directory " + "(missing config.json)." + ) + return str(local_path) + + +def _select_deepseek_ocr_runtime(torch): + requested = _deepseek_ocr_device() + mps_available = bool(getattr(torch.backends, "mps", None)) and torch.backends.mps.is_available() + + if requested not in {"auto", "cuda", "mps", "cpu"}: + raise RuntimeError( + f"Unsupported DEEPSEEK_OCR_DEVICE='{requested}'. Expected one of: auto, cuda, mps, cpu." + ) + + if requested in {"auto", "cuda"} and torch.cuda.is_available(): + return "cuda", torch.bfloat16, True + if requested == "cuda": + raise RuntimeError("DEEPSEEK_OCR_DEVICE='cuda' was requested, but CUDA is not available.") + + if requested in {"auto", "mps"} and mps_available: + return "mps", torch.float16, False + if requested == "mps": + raise RuntimeError("DEEPSEEK_OCR_DEVICE='mps' was requested, but MPS is not available.") + + return "cpu", torch.float32, False + + +def _prepare_deepseek_ocr_image(image, runtime_device: str): + if not _table_ocr_allow_backend_image_resize(): + return image + max_pixels = _deepseek_ocr_max_image_pixels() + width, height = image.size + total_pixels = width * height + if max_pixels <= 0 or total_pixels <= max_pixels: + return image + + scale = math.sqrt(max_pixels / total_pixels) + new_width = max(28, int(width * scale)) + new_height = max(28, int(height * scale)) + emit_progress( + f"Resizing DeepSeek OCR image for {runtime_device} from {width}x{height} to " + f"{new_width}x{new_height} to stay within {max_pixels:,} pixels." + ) + return image.resize((new_width, new_height)) + + +def _build_deepseek_prompt_text(processor, prompt_text: str) -> str: + image_token = getattr(processor, "image_token", None) + if image_token is None: + image_token = getattr(getattr(processor, "tokenizer", None), "image_token", None) + if image_token: + return f"{image_token}\n{prompt_text}" + return prompt_text + + +def _build_deepseek_infer_prompt(prompt_text: str) -> str: + normalized = str(prompt_text or "").strip() + if not normalized: + normalized = default_table_image_transcription_prompt() + return normalized + + +def _build_deepseek_infer_prompt_candidates(prompt_text: str) -> List[tuple[str, str]]: + normalized = _build_deepseek_infer_prompt(prompt_text) + default_prompt = normalize_text(default_table_image_transcription_prompt()) + candidates: List[tuple[str, str]] = [] + seen: set[str] = set() + + def add_candidate(label: str, candidate_prompt: str) -> None: + candidate_text = normalize_text(candidate_prompt) + if not candidate_text or candidate_text in seen: + return + seen.add(candidate_text) + candidates.append((label, candidate_text)) + + # DeepSeek-OCR-2's infer() helper only returns text in eval_mode when the + # prompt includes the literal token. + if normalize_text(normalized) == default_prompt: + add_candidate("grounding markdown prompt", "\n<|grounding|>Convert the document to markdown. ") + add_candidate("free OCR prompt", "\nFree OCR. ") + add_candidate("plain markdown prompt", "\nConvert the document to markdown. ") + add_candidate("caller HTML prompt with image token", f"\n{normalized}") + else: + add_candidate("caller prompt with image token", f"\n{normalized}") + add_candidate("grounding markdown prompt", "\n<|grounding|>Convert the document to markdown. ") + add_candidate("free OCR prompt", "\nFree OCR. ") + + return candidates + + +def _require_nonempty_ocr_text_output( + text: str, + *, + backend_label: str, + details: Optional[Dict[str, Any]] = None, +) -> str: + cleaned = strip_code_fences(text) + if cleaned and _HTML_TABLE_RE.search(cleaned): + cleaned = normalize_inline_latex_in_html_fragment(cleaned) + elif cleaned: + latex_html = maybe_convert_latex_tabular_to_html(cleaned) + if latex_html: + cleaned = latex_html + if cleaned: + return cleaned + raise TableOCRContentError( + f"OCR backend returned empty text content via {backend_label}", + details=details or {"backend": backend_label}, + ) + + +def _resize_image_to_max_pixels(img, max_pixels: int): + if max_pixels <= 0: + return img + width, height = img.size + total_pixels = width * height + if total_pixels <= max_pixels: + return img + scale = math.sqrt(float(max_pixels) / float(total_pixels)) + new_width = max(28, int(width * scale)) + new_height = max(28, int(height * scale)) + return img.resize((new_width, new_height)) + + +def _is_firered_buffer_error(exc: Exception) -> bool: + message = normalize_text(str(exc)).lower() + return ( + "invalid buffer size" in message + or "out of memory" in message + or ("mps" in message and "buffer" in message) + ) + + +def _build_deepseek_inputs(processor, page_image, prompt_text: str): + messages = [ + { + "role": "user", + "content": [ + {"type": "image", "image": page_image}, + {"type": "text", "text": prompt_text}, + ], + } + ] + + if hasattr(processor, "apply_chat_template"): + try: + chat_text = processor.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + ) + return processor(text=[chat_text], images=[page_image], return_tensors="pt") + except Exception: + pass + + fallback_prompt = _build_deepseek_prompt_text(processor, prompt_text) + try: + return processor(text=[fallback_prompt], images=[page_image], return_tensors="pt") + except Exception: + return processor(text=fallback_prompt, images=page_image, return_tensors="pt") + + +def _normalize_deepseek_chat_output(result: Any) -> str: + if isinstance(result, str): + return result + if isinstance(result, tuple) and result: + first = result[0] + if isinstance(first, str): + return first + if isinstance(result, dict): + for key in ("text", "response", "content", "answer", "output"): + value = result.get(key) + if isinstance(value, str): + return value + raise RuntimeError(f"DeepSeek chat fallback returned an unsupported result type: {type(result).__name__}") + + +def _processor_is_tokenizer_like(processor: Any) -> bool: + class_name = type(processor).__name__.lower() + if "tokenizer" in class_name: + return True + try: + from transformers import PreTrainedTokenizerBase + + return isinstance(processor, PreTrainedTokenizerBase) + except Exception: + return False + + +def _model_supports_image_aware_fallback(model_obj: Any) -> bool: + if callable(getattr(model_obj, "chat", None)): + return True + + for attr_name in ("generate", "forward"): + method = getattr(model_obj, attr_name, None) + if not callable(method): + continue + try: + param_names = set(inspect.signature(method).parameters) + except Exception: + continue + if {"images", "image"} & param_names: + return True + if {"pixel_values", "image_tensors", "input_images"} & param_names: + return True + return False + + +def _decode_deepseek_generated_output(processor: Any, generated_ids: Any, input_ids: Any = None) -> str: + trimmed_ids = generated_ids + if input_ids is not None: + try: + trimmed_ids = generated_ids[:, input_ids.shape[1] :] + except Exception: + trimmed_ids = generated_ids + + if hasattr(processor, "batch_decode"): + return processor.batch_decode( + trimmed_ids, + skip_special_tokens=True, + clean_up_tokenization_spaces=False, + )[0] + if hasattr(processor, "tokenizer") and hasattr(processor.tokenizer, "batch_decode"): + return processor.tokenizer.batch_decode( + trimmed_ids, + skip_special_tokens=True, + clean_up_tokenization_spaces=False, + )[0] + raise RuntimeError("DeepSeek fallback could not find a decode path on the loaded processor/tokenizer.") + + +def _maybe_build_pixel_values(model_obj: Any, page_image, model_device: Any): + candidates = [] + image_processor = getattr(model_obj, "image_processor", None) + if image_processor is not None: + candidates.append(image_processor) + vision_tower = getattr(model_obj, "vision_tower", None) + if vision_tower is not None: + nested_processor = getattr(vision_tower, "image_processor", None) + if nested_processor is not None: + candidates.append(nested_processor) + + for candidate in candidates: + try: + if hasattr(candidate, "preprocess"): + outputs = candidate.preprocess(page_image, return_tensors="pt") + elif callable(candidate): + outputs = candidate(page_image, return_tensors="pt") + else: + continue + if isinstance(outputs, dict): + pixel_values = outputs.get("pixel_values") + else: + pixel_values = getattr(outputs, "pixel_values", None) + if pixel_values is None: + continue + return pixel_values.to(model_device) + except Exception: + continue + return None + + +def _run_deepseek_generate_fallback(model_obj, processor, page_image, prompt_text: str, model_device: Any) -> str: + generate_fn = getattr(model_obj, "generate", None) + if not callable(generate_fn): + raise RuntimeError("DeepSeek-OCR-2 did not expose a callable `generate` fallback.") + + prompt_with_image = _build_deepseek_prompt_text(processor, prompt_text) + prompt_for_tokenizer = prompt_with_image + if hasattr(processor, "apply_chat_template"): + try: + prompt_for_tokenizer = processor.apply_chat_template( + [ + { + "role": "user", + "content": [ + {"type": "image", "image": page_image}, + {"type": "text", "text": prompt_text}, + ], + } + ], + tokenize=False, + add_generation_prompt=True, + ) + except Exception: + prompt_for_tokenizer = prompt_with_image + try: + text_inputs = processor(text=[prompt_for_tokenizer], return_tensors="pt") + except Exception: + try: + text_inputs = processor([prompt_for_tokenizer], return_tensors="pt") + except Exception: + text_inputs = processor(prompt_for_tokenizer, return_tensors="pt") + + text_inputs = text_inputs.to(model_device) + input_ids = getattr(text_inputs, "input_ids", None) + if input_ids is None and isinstance(text_inputs, dict): + input_ids = text_inputs.get("input_ids") + + candidate_image_kwargs: List[tuple[str, Dict[str, Any]]] = [ + ("generate(..., images=[[PIL]])", {"images": [[page_image]]}), + ("generate(..., images=[PIL])", {"images": [page_image]}), + ("generate(..., images=PIL)", {"images": page_image}), + ("generate(..., image=PIL)", {"image": page_image}), + ("generate(..., input_images=[PIL])", {"input_images": [page_image]}), + ] + + pixel_values = _maybe_build_pixel_values(model_obj, page_image, model_device) + if pixel_values is not None: + candidate_image_kwargs.append(("generate(..., pixel_values=tensor)", {"pixel_values": pixel_values})) + + errors: List[str] = [] + for label, extra_kwargs in candidate_image_kwargs: + try: + emit_progress(f"Trying DeepSeek generate fallback via {label}") + generated_ids = generate_fn( + **text_inputs, + **extra_kwargs, + max_new_tokens=_deepseek_ocr_max_new_tokens(), + do_sample=False, + ) + return _decode_deepseek_generated_output(processor, generated_ids, input_ids=input_ids) + except Exception as exc: + errors.append(f"{label}: {exc}") + + prepare_inputs_embeds_fn = getattr(model_obj, "prepare_inputs_embeds", None) + language_model = getattr(model_obj, "language", None) + language_generate_fn = getattr(language_model, "generate", None) if language_model is not None else None + attention_mask = getattr(text_inputs, "attention_mask", None) + if attention_mask is None and isinstance(text_inputs, dict): + attention_mask = text_inputs.get("attention_mask") + if callable(prepare_inputs_embeds_fn): + embed_attempts: List[tuple[str, Dict[str, Any]]] = [ + ("prepare_inputs_embeds(..., images=[[PIL]])", {"images": [[page_image]]}), + ("prepare_inputs_embeds(..., images=[PIL])", {"images": [page_image]}), + ] + for label, extra_kwargs in embed_attempts: + try: + emit_progress(f"Trying DeepSeek embedding fallback via {label}") + inputs_embeds = prepare_inputs_embeds_fn( + input_ids=input_ids, + **extra_kwargs, + ) + if callable(language_generate_fn): + generated_ids = language_generate_fn( + inputs_embeds=inputs_embeds, + attention_mask=attention_mask, + max_new_tokens=_deepseek_ocr_max_new_tokens(), + do_sample=False, + ) + else: + generated_ids = generate_fn( + inputs_embeds=inputs_embeds, + attention_mask=attention_mask, + max_new_tokens=_deepseek_ocr_max_new_tokens(), + do_sample=False, + ) + return _decode_deepseek_generated_output(processor, generated_ids, input_ids=None) + except Exception as exc: + errors.append(f"{label}: {exc}") + + raise RuntimeError(" ; ".join(errors)) + + +def _run_deepseek_infer_fallback( + model_obj, + processor, + page_image, + prompt_text: str, + runtime_device: str, +) -> str: + infer_fn = getattr(model_obj, "infer", None) + if not callable(infer_fn): + raise RuntimeError("DeepSeek-OCR-2 did not expose a callable `infer` helper.") + if runtime_device != "cuda": + raise RuntimeError( + f"DeepSeek-OCR-2 remote-code infer helper currently requires CUDA, but runtime device is {runtime_device}." + ) + + signature = inspect.signature(infer_fn) + param_names = set(signature.parameters) + + with TemporaryDirectory(prefix="deepseek_ocr_") as tmpdir: + image_path = Path(tmpdir) / "page.png" + result_mmd_path = Path(tmpdir) / "result.mmd" + page_image.convert("RGB").save(image_path) + + infer_kwargs_base: Dict[str, Any] = { + "tokenizer": processor, + "image_file": str(image_path), + "output_path": tmpdir, + "eval_mode": True, + } + if "save_results" in param_names: + infer_kwargs_base["save_results"] = False + if "test_compress" in param_names: + infer_kwargs_base["test_compress"] = False + if "crop_mode" in param_names: + infer_kwargs_base["crop_mode"] = True + if "base_size" in param_names: + infer_kwargs_base["base_size"] = 1024 + if "image_size" in param_names: + infer_kwargs_base["image_size"] = 768 + + errors: List[str] = [] + emit_progress("Trying DeepSeek remote-code infer(...) fallback") + for attempt_label, infer_prompt in _build_deepseek_infer_prompt_candidates(prompt_text): + emit_progress(f"Trying DeepSeek infer prompt variant: {attempt_label}") + + try: + infer_kwargs = dict(infer_kwargs_base) + infer_kwargs["prompt"] = infer_prompt + infer_kwargs["eval_mode"] = True + result = infer_fn(**{key: value for key, value in infer_kwargs.items() if key in param_names}) + normalized_result = "" + if result is not None: + normalized_result = strip_code_fences(_normalize_deepseek_chat_output(result)) + if normalized_result: + return normalized_result + except Exception as exc: + errors.append(f"{attempt_label} eval_mode=True: {exc}") + continue + + if "save_results" not in param_names: + errors.append(f"{attempt_label} eval_mode=True: empty text output") + continue + + try: + if result_mmd_path.exists(): + result_mmd_path.unlink() + infer_kwargs = dict(infer_kwargs_base) + infer_kwargs["prompt"] = infer_prompt + infer_kwargs["eval_mode"] = False + infer_kwargs["save_results"] = True + with contextlib.redirect_stdout(io.StringIO()): + result = infer_fn(**{key: value for key, value in infer_kwargs.items() if key in param_names}) + normalized_result = "" + if result is not None: + normalized_result = strip_code_fences(_normalize_deepseek_chat_output(result)) + if not normalized_result and result_mmd_path.exists(): + normalized_result = strip_code_fences(result_mmd_path.read_text(encoding="utf-8")) + if normalized_result: + return normalized_result + errors.append(f"{attempt_label} save_results=True: empty text output") + except Exception as exc: + errors.append(f"{attempt_label} save_results=True: {exc}") + + raise RuntimeError(" ; ".join(errors)) + + +def _deepseek_ocr_version_guidance_message() -> str: + return ( + "DeepSeek-OCR-2 remote code expects the Hugging Face stack from the model card, " + "especially `transformers==4.46.3` and `tokenizers==0.20.3`. " + "In Colab, reinstall those versions, restart the runtime, and reload the model." + ) + + +def _run_deepseek_chat_fallback(model_obj, processor, page_image, prompt_text: str) -> str: + chat_fn = getattr(model_obj, "chat", None) + if not callable(chat_fn): + raise RuntimeError( + "DeepSeek-OCR-2 loaded a tokenizer-like processor instead of a multimodal processor, " + "and the model does not expose a callable `chat` fallback." + ) + + signature = inspect.signature(chat_fn) + param_names = set(signature.parameters) + max_new_tokens = _deepseek_ocr_max_new_tokens() + + call_attempts: List[tuple[str, Dict[str, Any]]] = [] + if {"image", "msgs", "tokenizer"}.issubset(param_names): + kwargs: Dict[str, Any] = { + "image": page_image, + "msgs": [{"role": "user", "content": prompt_text}], + "tokenizer": processor, + } + if "sampling" in param_names: + kwargs["sampling"] = False + if "do_sample" in param_names: + kwargs["do_sample"] = False + if "temperature" in param_names: + kwargs["temperature"] = 0.0 + if "max_new_tokens" in param_names: + kwargs["max_new_tokens"] = max_new_tokens + if "ocr_type" in param_names: + kwargs["ocr_type"] = "format" + call_attempts.append(("chat(image=..., msgs=..., tokenizer=...)", kwargs)) + + if {"tokenizer", "query", "image"}.issubset(param_names): + kwargs = { + "tokenizer": processor, + "query": prompt_text, + "image": page_image, + } + if "max_new_tokens" in param_names: + kwargs["max_new_tokens"] = max_new_tokens + if "temperature" in param_names: + kwargs["temperature"] = 0.0 + call_attempts.append(("chat(tokenizer=..., query=..., image=...)", kwargs)) + + if {"tokenizer", "prompt", "image"}.issubset(param_names): + kwargs = { + "tokenizer": processor, + "prompt": prompt_text, + "image": page_image, + } + if "max_new_tokens" in param_names: + kwargs["max_new_tokens"] = max_new_tokens + if "temperature" in param_names: + kwargs["temperature"] = 0.0 + call_attempts.append(("chat(tokenizer=..., prompt=..., image=...)", kwargs)) + + if {"tokenizer", "text", "image"}.issubset(param_names): + kwargs = { + "tokenizer": processor, + "text": prompt_text, + "image": page_image, + } + if "max_new_tokens" in param_names: + kwargs["max_new_tokens"] = max_new_tokens + if "temperature" in param_names: + kwargs["temperature"] = 0.0 + call_attempts.append(("chat(tokenizer=..., text=..., image=...)", kwargs)) + + if not call_attempts: + raise RuntimeError( + "DeepSeek-OCR-2 exposed a `chat` method, but this backend does not yet recognize its signature: " + f"{signature}" + ) + + errors: List[str] = [] + for label, kwargs in call_attempts: + try: + emit_progress(f"Trying DeepSeek chat fallback via {label}") + return _normalize_deepseek_chat_output(chat_fn(**kwargs)) + except Exception as exc: + errors.append(f"{label}: {exc}") + + raise RuntimeError(" ; ".join(errors)) + + +def _patch_missing_llama_flash_attention2() -> None: + try: + import transformers.models.llama.modeling_llama as llama_modeling + except Exception: + return + + if hasattr(llama_modeling, "LlamaFlashAttention2"): + return + + replacement = getattr(llama_modeling, "LlamaSdpaAttention", None) + if replacement is None: + replacement = getattr(llama_modeling, "LlamaAttention", None) + if replacement is None: + return + + setattr(llama_modeling, "LlamaFlashAttention2", replacement) + emit_progress( + "Applied compatibility shim: aliased transformers.models.llama.modeling_llama." + "LlamaFlashAttention2 to an available Llama attention implementation." + ) + + +def _get_deepseek_table_backend(model_id: str): + global _DEEPSEEK_OCR_MODEL, _DEEPSEEK_OCR_PROCESSOR, _DEEPSEEK_OCR_MODEL_ID, _DEEPSEEK_OCR_LOAD_ERROR + + if ( + _DEEPSEEK_OCR_MODEL is not None + and _DEEPSEEK_OCR_PROCESSOR is not None + and _DEEPSEEK_OCR_MODEL_ID == model_id + ): + return _DEEPSEEK_OCR_MODEL, _DEEPSEEK_OCR_PROCESSOR + + try: + import torch + except ImportError as exc: + raise RuntimeError("PyTorch is required for DeepSeek OCR transcription. Install `torch` first.") from exc + try: + import torchvision # noqa: F401 + except ImportError as exc: + raise RuntimeError( + "DeepSeek OCR transcription requires `torchvision`. Install `torchvision` and restart Python." + ) from exc + + try: + from transformers import AutoConfig, AutoModelForCausalLM, AutoProcessor + except ImportError as exc: + raise RuntimeError( + "DeepSeek OCR transcription requires a recent Hugging Face stack. " + "Install or upgrade `accelerate` and `safetensors`, then install the latest " + "`transformers` build (for example `pip install -U git+https://github.com/huggingface/transformers`)." + ) from exc + + _patch_missing_llama_flash_attention2() + + try: + from transformers import AutoModel + except ImportError: + AutoModel = None + + try: + from transformers import AutoModelForImageTextToText + except ImportError: + AutoModelForImageTextToText = None + + try: + from transformers import AutoModelForVision2Seq + except ImportError: + AutoModelForVision2Seq = None + + try: + from transformers.models.deepseek_vl import DeepseekVLForConditionalGeneration + except ImportError: + DeepseekVLForConditionalGeneration = None + + try: + from transformers.models.deepseek_vl_hybrid import DeepseekVLHybridForConditionalGeneration + except ImportError: + DeepseekVLHybridForConditionalGeneration = None + + runtime_device, dtype, use_device_map = _select_deepseek_ocr_runtime(torch) + try: + model_source = _resolve_deepseek_ocr_model_source(model_id) + common_kwargs: Dict[str, Any] = { + "trust_remote_code": _deepseek_ocr_trust_remote_code(), + } + cache_dir = _deepseek_ocr_cache_dir() + revision = _deepseek_ocr_revision() + if cache_dir: + common_kwargs["cache_dir"] = cache_dir + if revision and not _deepseek_ocr_local_dir(): + common_kwargs["revision"] = revision + if _deepseek_ocr_local_files_only(): + common_kwargs["local_files_only"] = True + + with _known_model_load_warnings_context(env_prefix="DEEPSEEK_OCR"): + config = AutoConfig.from_pretrained(model_source, **common_kwargs) + processor = AutoProcessor.from_pretrained(model_source, **common_kwargs) + processor_is_tokenizer_like = _processor_is_tokenizer_like(processor) + model_type = normalize_text(getattr(config, "model_type", "")) + + load_kwargs = dict(common_kwargs) + load_kwargs["dtype"] = dtype + if use_device_map: + load_kwargs["device_map"] = _deepseek_ocr_device_map() + else: + load_kwargs["low_cpu_mem_usage"] = True + + loader_candidates = [] + if model_type == "deepseek_vl_hybrid" and DeepseekVLHybridForConditionalGeneration is not None: + loader_candidates.append( + ("DeepseekVLHybridForConditionalGeneration", DeepseekVLHybridForConditionalGeneration.from_pretrained) + ) + elif model_type == "deepseek_vl" and DeepseekVLForConditionalGeneration is not None: + loader_candidates.append( + ("DeepseekVLForConditionalGeneration", DeepseekVLForConditionalGeneration.from_pretrained) + ) + if AutoModelForImageTextToText is not None: + loader_candidates.append(("AutoModelForImageTextToText", AutoModelForImageTextToText.from_pretrained)) + if AutoModelForVision2Seq is not None: + loader_candidates.append(("AutoModelForVision2Seq", AutoModelForVision2Seq.from_pretrained)) + if AutoModel is not None: + loader_candidates.append(("AutoModel", AutoModel.from_pretrained)) + loader_candidates.append(("AutoModelForCausalLM", AutoModelForCausalLM.from_pretrained)) + + if _deepseek_ocr_local_dir(): + emit_progress(f"Loading DeepSeek OCR model from local dir '{model_source}' on {runtime_device}...") + elif cache_dir: + emit_progress( + f"Loading DeepSeek OCR model '{model_source}' using cache '{cache_dir}' on {runtime_device}..." + ) + else: + emit_progress(f"Loading DeepSeek OCR model '{model_source}' on {runtime_device}...") + + model_errors: List[str] = [] + model_obj = None + for loader_name, loader in loader_candidates: + try: + with _known_model_load_warnings_context(env_prefix="DEEPSEEK_OCR"): + candidate_model = _call_from_pretrained_with_dtype_fallback( + loader, + model_source, + **load_kwargs, + ) + if processor_is_tokenizer_like and not _model_supports_image_aware_fallback(candidate_model): + model_errors.append( + f"{loader_name}: loaded successfully but does not expose an image-aware fallback " + "(`chat`, `generate(images=...)`, or `forward(images=...)`) while the processor is tokenizer-like" + ) + continue + model_obj = candidate_model + break + except Exception as exc: + model_errors.append(f"{loader_name}: {exc}") + + if model_obj is None: + raise RuntimeError(" ; ".join(model_errors)) + + if not use_device_map: + model_obj = model_obj.to(runtime_device) + + if getattr(model_obj, "generation_config", None) is not None: + model_obj.generation_config.temperature = None + model_obj.generation_config.top_p = None + model_obj.generation_config.top_k = None + model_obj.eval() + + _DEEPSEEK_OCR_MODEL = model_obj + _DEEPSEEK_OCR_PROCESSOR = processor + _DEEPSEEK_OCR_MODEL_ID = model_id + _DEEPSEEK_OCR_LOAD_ERROR = None + emit_progress("Loaded DeepSeek OCR model.") + return _DEEPSEEK_OCR_MODEL, _DEEPSEEK_OCR_PROCESSOR + except Exception as exc: + if "LlamaFlashAttention2" in str(exc): + exc = RuntimeError( + "DeepSeek-OCR-2 remote code is not compatible with the currently installed Transformers stack. " + f"{_deepseek_ocr_version_guidance_message()}" + ) + _DEEPSEEK_OCR_LOAD_ERROR = (model_id, str(exc)) + raise + + +def transcribe_table_image_with_openrouter( + image_data_uri: str, + *, + model_id: str, + prompt: Optional[str] = None, + reasoning_level: Optional[str] = None, + max_tokens: int = 32000, + max_attempts: Optional[int] = None, + progress_handler: ProgressHandler = None, +) -> str: + attempt_plan = build_openrouter_attempt_plan( + model_id, + max_attempts=max_attempts or default_openrouter_ocr_max_attempts(), + ) + prompt_text = prompt or default_table_image_transcription_prompt() + last_response_error: Optional[RuntimeError] = None + + for attempt_index, candidate_model in enumerate(attempt_plan, start=1): + progress_label = f"[ocr {candidate_model}]" + client = TableOCROpenRouterClient( + model_id=candidate_model, + reasoning_level=reasoning_level or os.getenv("OPENROUTER_REASONING_LEVEL", "low"), + ) + try: + request_started_at = time.perf_counter() + response = client.chat_completion( + messages=[ + { + "role": "user", + "content": [ + {"type": "text", "text": prompt_text}, + {"type": "image_url", "image_url": {"url": image_data_uri}}, + ], + } + ], + max_tokens=max_tokens, + temperature=0.0, + progress_label=f"{progress_label} | request {attempt_index}/{len(attempt_plan)}", + progress_handler=progress_handler, + ) + request_latency_s = time.perf_counter() - request_started_at + except TableOCROpenRouterResponseError as exc: + last_response_error = exc + if attempt_index < len(attempt_plan): + next_model = attempt_plan[attempt_index] + if next_model != candidate_model: + emit_progress( + f"[ocr {model_id}] | retrying with fallback model {next_model} after error: {exc}", + progress_handler=progress_handler, + ) + else: + emit_progress( + f"[ocr {model_id}] | retrying attempt {attempt_index + 1}/{len(attempt_plan)} " + f"with model {candidate_model} after error: {exc}", + progress_handler=progress_handler, + ) + continue + raise + + summary = summarize_openrouter_chat_response(response) + summary["total_latency_s"] = max(0.0, float(request_latency_s)) + text_content = extract_text_from_openrouter_content(summary["content"]) + if text_content is None: + summary["thinking_latency_s"] = None + summary["first_content_latency_s"] = None + else: + summary["thinking_latency_s"] = estimate_openrouter_thinking_latency_s( + request_latency_s, + reasoning_tokens=summary["reasoning_tokens"], + completion_tokens=summary["completion_tokens"], + ) + emit_progress( + f"{progress_label} | finish_reason={summary['finish_reason'] or 'unknown'} | " + f"provider={summary['provider'] or 'unknown'} | " + f"tool_calls={summary['tool_call_count']} | " + f"content_type={summary['content_type']}", + progress_handler=progress_handler, + ) + if summary["thinking_latency_s"] is not None: + reasoning_tokens_label = ( + str(summary["reasoning_tokens"]) + if isinstance(summary["reasoning_tokens"], int) + else "unknown" + ) + completion_tokens_label = ( + str(summary["completion_tokens"]) + if isinstance(summary["completion_tokens"], int) + else "unknown" + ) + emit_progress( + f"{progress_label} | total latency={summary['total_latency_s']:.2f}s" + f" | estimated thinking latency={summary['thinking_latency_s']:.2f}s" + f" | reasoning_tokens={reasoning_tokens_label}" + f" | completion_tokens={completion_tokens_label}", + progress_handler=progress_handler, + ) + + if text_content is None: + detail_bits = [ + f"finish_reason={summary['finish_reason'] or 'unknown'}", + f"provider={summary['provider'] or 'unknown'}", + f"tool_calls={summary['tool_call_count']}", + f"content_type={summary['content_type']}", + ] + if summary["refusal"]: + detail_bits.append(f"refusal={normalize_text(summary['refusal'])[:200]}") + exc = TableOCRContentError( + f"OCR response did not contain text content ({', '.join(detail_bits)})", + response_payload=response, + details=summary, + ) + last_response_error = exc + if attempt_index < len(attempt_plan): + next_model = attempt_plan[attempt_index] + if next_model != candidate_model: + emit_progress( + f"[ocr {model_id}] | retrying with fallback model {next_model} after content error: {exc}", + progress_handler=progress_handler, + ) + else: + emit_progress( + f"[ocr {model_id}] | retrying attempt {attempt_index + 1}/{len(attempt_plan)} " + f"with model {candidate_model} after content error: {exc}", + progress_handler=progress_handler, + ) + continue + raise exc + return TableOCRTranscriptionText( + strip_code_fences(text_content), + effective_model_id=candidate_model, + thinking_latency_s=summary["thinking_latency_s"], + total_latency_s=summary["total_latency_s"], + first_content_latency_s=summary["first_content_latency_s"], + reasoning_tokens=summary["reasoning_tokens"], + completion_tokens=summary["completion_tokens"], + ) + + if last_response_error is not None: + raise last_response_error + raise RuntimeError("OpenRouter OCR transcription failed without producing a result.") + + +def transcribe_table_image_with_qwen_ocr( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + max_tokens: int = 32000, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = resolve_qwen_ocr_model_id(model_id) + prompt_text = prompt or default_table_image_transcription_prompt() + progress_label = f"[qwen_ocr {resolved_model}]" + client = TableOCRQwenClient(model_id=resolved_model) + configured_max_tokens = normalize_text(os.getenv("QWEN_OCR_MAX_TOKENS", "")) + if configured_max_tokens: + try: + max_tokens = max(1, int(configured_max_tokens)) + except ValueError: + pass + request_started_at = time.perf_counter() + response = client.chat_completion_streaming( + messages=[ + { + "role": "user", + "content": [ + {"type": "text", "text": prompt_text}, + {"type": "image_url", "image_url": {"url": image_data_uri}}, + ], + } + ], + max_tokens=max_tokens, + temperature=0.0, + progress_label=progress_label, + progress_handler=progress_handler, + include_reasoning=True, + ) + request_latency_s = time.perf_counter() - request_started_at + + summary = summarize_openrouter_chat_response(response) + if summary["total_latency_s"] is None: + summary["total_latency_s"] = max(0.0, float(request_latency_s)) + text_content = extract_text_from_openrouter_content(summary["content"]) + if text_content is None: + raise TableOCRContentError( + "Qwen OCR response did not contain text content.", + response_payload=response, + details=summary, + ) + + emit_progress( + f"{progress_label} | finish_reason={summary['finish_reason'] or 'unknown'} | " + f"provider={summary['provider'] or 'unknown'} | " + f"total latency={summary['total_latency_s']:.2f}s" + + ( + f" | thinking latency={summary['thinking_latency_s']:.2f}s" + if isinstance(summary["thinking_latency_s"], (int, float)) + else "" + ), + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + strip_code_fences(text_content), + effective_model_id=resolved_model, + thinking_latency_s=summary["thinking_latency_s"], + total_latency_s=summary["total_latency_s"], + first_content_latency_s=summary["first_content_latency_s"], + reasoning_tokens=summary["reasoning_tokens"], + completion_tokens=summary["completion_tokens"], + ) + + +def gemma4_vllm_launch_hint() -> str: + return ( + "Start local vLLM for Gemma 4 with thinking and the full OCR vision budget, for example: " + "vllm serve google/gemma-4-26B-A4B-it --host 0.0.0.0 --port 8000 " + "--dtype bfloat16 --max-model-len 32768 --gpu-memory-utilization 0.90 " + "--limit-mm-per-prompt '{\"image\":1}' " + "--mm-processor-kwargs '{\"max_soft_tokens\":1120}' " + "--hf-overrides '{\"vision_config\":{\"default_output_length\":1120},\"vision_soft_tokens_per_image\":1120}' " + "--reasoning-parser gemma4 --default-chat-template-kwargs '{\"enable_thinking\":true}'" + ) + + +def gemma4_hf_load_hint() -> str: + return ( + "Use Gemma 4 locally through plain Hugging Face Transformers, for example after installing " + "`transformers torch torchvision accelerate` with model `google/gemma-4-26B-A4B-it`." + ) + + +def _gemma4_hf_max_new_tokens() -> int: + return _env_int("GEMMA4_HF_MAX_NEW_TOKENS", 8192) + + +def _gemma4_hf_device_map() -> str: + return normalize_text(os.getenv("GEMMA4_HF_DEVICE_MAP", "auto")) or "auto" + + +def _decode_image_data_uri_for_gemma4_hf(image_data_uri: str) -> tuple[bytes, str]: + import base64 + + normalized = normalize_text(image_data_uri) + if not normalized.startswith("data:") or "," not in normalized: + raise RuntimeError("Gemma 4 HF backend expected a data URI image payload.") + header, payload = normalized.split(",", 1) + media_type = header[5:].split(";", 1)[0].strip().lower() + suffix = { + "image/png": ".png", + "image/jpeg": ".jpg", + "image/jpg": ".jpg", + "image/webp": ".webp", + "image/gif": ".gif", + "image/bmp": ".bmp", + }.get(media_type, ".png") + try: + return base64.b64decode(payload), suffix + except Exception as exc: + raise RuntimeError("Gemma 4 HF backend could not decode the image data URI.") from exc + + +def _load_gemma4_hf_backend(model_id: str) -> tuple[Any, Any]: + cache = getattr(_load_gemma4_hf_backend, "_cache", None) + if isinstance(cache, dict) and cache.get("model_id") == model_id: + return cache["processor"], cache["model"] + + try: + import transformers + from transformers import AutoProcessor + except Exception as exc: + raise RuntimeError(f"Gemma 4 HF backend could not import Transformers. {gemma4_hf_load_hint()}") from exc + + auto_model_cls = getattr(transformers, "AutoModelForMultimodalLM", None) + if auto_model_cls is None: + auto_model_cls = getattr(transformers, "AutoModelForImageTextToText", None) + if auto_model_cls is None: + raise RuntimeError( + "Installed Transformers does not expose `AutoModelForMultimodalLM` or `AutoModelForImageTextToText`. " + f"{gemma4_hf_load_hint()}" + ) + + processor = AutoProcessor.from_pretrained(model_id) + try: + model = auto_model_cls.from_pretrained( + model_id, + device_map=_gemma4_hf_device_map(), + torch_dtype="auto", + ) + except TypeError: + model = auto_model_cls.from_pretrained( + model_id, + device_map=_gemma4_hf_device_map(), + dtype="auto", + ) + model.eval() + _load_gemma4_hf_backend._cache = { + "model_id": model_id, + "processor": processor, + "model": model, + } + return processor, model + + +def _gemma4_hf_input_device(model: Any) -> Any: + import torch + + model_device = getattr(model, "device", None) + if isinstance(model_device, torch.device) and model_device.type != "meta": + return model_device + if torch.cuda.is_available(): + return torch.device("cuda") + return torch.device("cpu") + + +def _extract_gemma4_hf_text_value(value: Any) -> Optional[str]: + if isinstance(value, str): + return value if normalize_text(value) else None + if isinstance(value, dict): + for key in ("content", "text", "response", "output", "answer", "final", "generated_text"): + extracted = _extract_gemma4_hf_text_value(value.get(key)) + if extracted: + return extracted + for nested_value in value.values(): + extracted = _extract_gemma4_hf_text_value(nested_value) + if extracted: + return extracted + return None + if isinstance(value, list): + for item in value: + extracted = _extract_gemma4_hf_text_value(item) + if extracted: + return extracted + return None + + +def _extract_gemma4_hf_response_text(processor: Any, generated_text: str) -> str: + parse_response = getattr(processor, "parse_response", None) + if callable(parse_response): + try: + parsed = parse_response(generated_text) + except Exception: + parsed = None + parsed_text = _extract_gemma4_hf_text_value(parsed) + if parsed_text: + cleaned_text, _ = _strip_gemma4_unparsed_thinking(parsed_text) + if normalize_text(cleaned_text): + return cleaned_text + cleaned_text, _ = _strip_gemma4_unparsed_thinking(generated_text) + return cleaned_text + + +def transcribe_table_image_with_gemma4_hf( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + from pathlib import Path + import tempfile + import time + import torch + + resolved_model = resolve_gemma4_hf_model_id(model_id) + prompt_text = prompt or default_table_image_transcription_prompt() + progress_label = f"[gemma4_hf {resolved_model}]" + + emit_progress( + f"{progress_label} | local transformers multimodal | thinking=off", + progress_handler=progress_handler, + ) + + try: + processor, model = _load_gemma4_hf_backend(resolved_model) + except Exception as exc: + raise RuntimeError(f"{exc}\n{gemma4_hf_load_hint()}") from exc + + started_at = time.perf_counter() + try: + image_bytes, image_suffix = _decode_image_data_uri_for_gemma4_hf(image_data_uri) + with tempfile.TemporaryDirectory(prefix="gemma4_hf_ocr_") as tmp_dir: + image_path = Path(tmp_dir) / f"table{image_suffix}" + image_path.write_bytes(image_bytes) + messages = [ + { + "role": "user", + "content": [ + {"type": "image", "path": str(image_path)}, + {"type": "text", "text": prompt_text}, + ], + } + ] + inputs = processor.apply_chat_template( + messages, + tokenize=True, + return_dict=True, + return_tensors="pt", + add_generation_prompt=True, + ).to(_gemma4_hf_input_device(model)) + input_len = inputs["input_ids"].shape[-1] + with torch.inference_mode(): + outputs = model.generate( + **inputs, + max_new_tokens=_gemma4_hf_max_new_tokens(), + do_sample=False, + ) + generated_text = processor.decode(outputs[0][input_len:], skip_special_tokens=False) + except Exception as exc: + raise RuntimeError(f"Gemma 4 HF OCR call failed: {exc}\n{gemma4_hf_load_hint()}") from exc + + total_latency_s = time.perf_counter() - started_at + text_content = _extract_gemma4_hf_response_text(processor, generated_text) + if not normalize_text(text_content): + raise TableOCRContentError( + "Gemma 4 Hugging Face response did not contain text content.", + details={ + "model_id": resolved_model, + "generated_text_preview": generated_text[-4000:], + }, + ) + + emit_progress( + f"{progress_label} | local transformers response | total latency={total_latency_s:.2f}s | content_chars={len(text_content)}", + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + strip_code_fences(text_content), + effective_model_id=resolved_model, + total_latency_s=total_latency_s, + ) + + +def _gemma4_vllm_max_tokens() -> int: + return _env_int("GEMMA4_VLLM_MAX_TOKENS", 32000) + + +def _gemma4_vllm_temperature() -> float: + return _env_float("GEMMA4_VLLM_TEMPERATURE", 0.0, min_value=0.0, max_value=2.0) + + +def _gemma4_vllm_enable_thinking() -> bool: + return _env_flag("GEMMA4_VLLM_ENABLE_THINKING", "1") + + +def _gemma4_vllm_require_thinking_latency() -> bool: + return _env_flag("GEMMA4_VLLM_REQUIRE_THINKING_LATENCY", "1") + + +def _strip_gemma4_unparsed_thinking(text: str) -> tuple[str, bool]: + rendered = str(text or "") + had_thought_block = bool(_GEMMA4_THOUGHT_BLOCK_RE.search(rendered) or _GEMMA4_THINK_BLOCK_RE.search(rendered)) + rendered = _GEMMA4_THOUGHT_BLOCK_RE.sub("", rendered) + rendered = _GEMMA4_THINK_BLOCK_RE.sub("", rendered) + if had_thought_block: + rendered = _GEMMA4_CHANNEL_MARKER_RE.sub("", rendered) + return rendered.strip(), had_thought_block + + +def transcribe_table_image_with_gemma4_vllm( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = resolve_gemma4_vllm_model_id(model_id) + prompt_text = prompt or default_table_image_transcription_prompt() + progress_label = f"[gemma4_vllm {resolved_model}]" + client = TableOCRGemma4VLLMClient(model_id=resolved_model) + + emit_progress( + f"{progress_label} | local vLLM streaming | thinking=on | expects --reasoning-parser gemma4", + progress_handler=progress_handler, + ) + try: + response = client.chat_completion_streaming( + messages=[ + { + "role": "user", + "content": [ + {"type": "image_url", "image_url": {"url": image_data_uri}}, + {"type": "text", "text": prompt_text}, + ], + } + ], + max_tokens=_gemma4_vllm_max_tokens(), + temperature=_gemma4_vllm_temperature(), + progress_label=progress_label, + progress_handler=progress_handler, + include_reasoning=True, + ) + except TableOCRRemoteResponseError as exc: + raise RuntimeError(f"{exc}\n{gemma4_vllm_launch_hint()}") from exc + + summary = summarize_openrouter_chat_response(response) + text_content = extract_text_from_openrouter_content(summary["content"]) + if text_content is None: + raise TableOCRContentError( + "Gemma 4 vLLM response did not contain text content.", + response_payload=response, + details=summary, + ) + text_content, stripped_unparsed_thinking = _strip_gemma4_unparsed_thinking(text_content) + if not normalize_text(text_content): + raise TableOCRContentError( + "Gemma 4 vLLM response contained only unparsed thinking content.", + response_payload=response, + details=summary, + ) + if ( + _gemma4_vllm_enable_thinking() + and _gemma4_vllm_require_thinking_latency() + and not isinstance(summary["thinking_latency_s"], (int, float)) + ): + raise TableOCRContentError( + "Gemma 4 vLLM thinking latency was unavailable. Restart vLLM with " + "`--reasoning-parser gemma4 --default-chat-template-kwargs '{\"enable_thinking\":true}'` " + "so reasoning is streamed separately from OCR content. " + "Set GEMMA4_VLLM_REQUIRE_THINKING_LATENCY=0 only if you intentionally want to score without it.", + response_payload=response, + details={ + **summary, + "stripped_unparsed_thinking": bool(stripped_unparsed_thinking), + "launch_hint": gemma4_vllm_launch_hint(), + }, + ) + if normalize_text(summary["finish_reason"]).lower() == "length": + raise TableOCRContentError( + "Gemma 4 vLLM hit finish_reason=length before producing a complete OCR answer. " + "This usually means thinking was not parsed out or GEMMA4_VLLM_MAX_TOKENS is too low.", + response_payload=response, + details={ + **summary, + "stripped_unparsed_thinking": bool(stripped_unparsed_thinking), + }, + ) + + emit_progress( + f"{progress_label} | finish_reason={summary['finish_reason'] or 'unknown'} | " + f"total latency={summary['total_latency_s']:.2f}s | content_chars={len(text_content)}" + + ( + f" | thinking latency={summary['thinking_latency_s']:.2f}s" + if isinstance(summary["thinking_latency_s"], (int, float)) + else " | thinking latency=unavailable; confirm vLLM was started with --reasoning-parser gemma4" + ), + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + strip_code_fences(text_content), + effective_model_id=resolved_model, + thinking_latency_s=summary["thinking_latency_s"], + total_latency_s=summary["total_latency_s"], + first_content_latency_s=summary["first_content_latency_s"], + reasoning_tokens=summary["reasoning_tokens"], + completion_tokens=summary["completion_tokens"], + ) + + +def gemma4_llamacpp_launch_hint() -> str: + return ( + "Start llama.cpp with Gemma 4 vision budget enabled, for example: " + "llama-server --model /models/Gemma4/gemma-4-26B-it-Q8_0.gguf " + "--mmproj /models/Gemma4/mmproj-F32.gguf --jinja " + "--chat-template-file /models/Gemma4/google-gemma-4-26B-it-interleaved.jinja " + "--image-min-tokens 560 --image-max-tokens 2240 " + "--batch-size 4096 --ubatch-size 4096" + ) + + +def _gemma4_llamacpp_max_tokens() -> int: + return _env_int("GEMMA4_LLAMA_CPP_MAX_TOKENS", 32000) + + +def _gemma4_llamacpp_temperature() -> float: + return _env_float("GEMMA4_LLAMA_CPP_TEMPERATURE", 0.0, min_value=0.0, max_value=2.0) + + +def transcribe_table_image_with_gemma4_llamacpp( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = resolve_gemma4_llamacpp_model_id(model_id) + prompt_text = prompt or default_table_image_transcription_prompt() + progress_label = f"[gemma4_llamacpp {resolved_model}]" + client = TableOCRGemma4LlamaCppClient(model_id=resolved_model) + + emit_progress( + f"{progress_label} | expects llama-server with --image-min-tokens 560 " + "--image-max-tokens 2240 --batch-size 4096 --ubatch-size 4096", + progress_handler=progress_handler, + ) + normalized_max_pixels = _table_ocr_normalized_max_image_pixels() + if 0 < normalized_max_pixels < 2_600_000: + emit_progress( + f"{progress_label} | shared image cap is {normalized_max_pixels:,} pixels; " + "raise TABLE_OCR_NORMALIZED_MAX_IMAGE_PIXELS for full high-budget Gemma 4 vision tests", + progress_handler=progress_handler, + ) + request_started_at = time.perf_counter() + try: + response = client.chat_completion( + messages=[ + { + "role": "user", + "content": [ + {"type": "text", "text": prompt_text}, + {"type": "image_url", "image_url": {"url": image_data_uri}}, + ], + } + ], + max_tokens=_gemma4_llamacpp_max_tokens(), + temperature=_gemma4_llamacpp_temperature(), + progress_label=progress_label, + progress_handler=progress_handler, + ) + except TableOCRRemoteResponseError as exc: + raise RuntimeError(f"{exc}\n{gemma4_llamacpp_launch_hint()}") from exc + request_latency_s = time.perf_counter() - request_started_at + + summary = summarize_openrouter_chat_response(response) + summary["total_latency_s"] = max(0.0, float(request_latency_s)) + text_content = extract_text_from_openrouter_content(summary["content"]) + if text_content is None: + raise TableOCRContentError( + "Gemma 4 llama.cpp response did not contain text content.", + response_payload=response, + details=summary, + ) + + emit_progress( + f"{progress_label} | finish_reason={summary['finish_reason'] or 'unknown'} | " + f"total latency={summary['total_latency_s']:.2f}s | content_chars={len(text_content)}", + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + strip_code_fences(text_content), + effective_model_id=resolved_model, + total_latency_s=summary["total_latency_s"], + first_content_latency_s=summary["first_content_latency_s"], + reasoning_tokens=summary["reasoning_tokens"], + completion_tokens=summary["completion_tokens"], + ) + + +def transcribe_table_image_with_deepseek( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + del progress_handler + sec_parser = load_sec_parser_module() + resolved_model = normalize_text(model_id or default_deepseek_ocr_model_id()) + if not resolved_model: + raise RuntimeError( + "Missing DeepSeek OCR model id. Pass a Hugging Face model id or set DEEPSEEK_OCR_MODEL_ID." + ) + try: + import torch + except ImportError as exc: + raise RuntimeError("PyTorch is required for DeepSeek OCR transcription.") from exc + + model_obj, processor = _get_deepseek_table_backend(resolved_model) + model_device = sec_parser._model_input_device(model_obj) + runtime_device = model_device.type + page_image = _prepare_deepseek_ocr_image( + sec_parser._decode_data_uri_to_pil_image(image_data_uri), + runtime_device, + ) + prompt_text = prompt or default_table_image_transcription_prompt() + infer_exc: Optional[Exception] = None + if callable(getattr(model_obj, "infer", None)): + try: + return _require_nonempty_ocr_text_output( + _run_deepseek_infer_fallback( + model_obj, + processor, + page_image, + prompt_text, + runtime_device, + ), + backend_label="DeepSeek infer(...) fallback", + ) + except Exception as exc: + infer_exc = exc + infer_message = str(infer_exc) + if "position_embeddings" in infer_message or "LlamaAttention.forward()" in infer_message: + raise RuntimeError(_deepseek_ocr_version_guidance_message()) from infer_exc + emit_progress(f"DeepSeek infer fallback failed: {infer_exc}") + try: + inputs = _build_deepseek_inputs( + processor, + page_image, + prompt_text, + ) + except TypeError as exc: + if "unexpected keyword argument 'images'" not in str(exc): + raise + generate_exc: Optional[Exception] = None + try: + return _require_nonempty_ocr_text_output( + _run_deepseek_generate_fallback(model_obj, processor, page_image, prompt_text, model_device), + backend_label="DeepSeek generate() fallback", + details={"infer_failure": str(infer_exc) if infer_exc else None}, + ) + except Exception as exc2: + generate_exc = exc2 + emit_progress(f"DeepSeek generate fallback failed: {generate_exc}") + try: + return _require_nonempty_ocr_text_output( + _run_deepseek_chat_fallback(model_obj, processor, page_image, prompt_text), + backend_label="DeepSeek chat() fallback", + details={ + "infer_failure": str(infer_exc) if infer_exc else None, + "generate_failure": str(generate_exc) if generate_exc else None, + }, + ) + except Exception as chat_exc: + raise RuntimeError( + "DeepSeek OCR fallback exhausted. " + f"model={type(model_obj).__name__}, processor={type(processor).__name__}; " + f"infer fallback failed: {infer_exc}; " + f"generate fallback failed: {generate_exc}; " + f"chat fallback failed: {chat_exc}" + ) from chat_exc + inputs = inputs.to(model_device) + + with torch.inference_mode(): + generated_ids = model_obj.generate( + **inputs, + max_new_tokens=_deepseek_ocr_max_new_tokens(), + do_sample=False, + ) + + input_ids = getattr(inputs, "input_ids", None) + if input_ids is None and isinstance(inputs, dict): + input_ids = inputs.get("input_ids") + raw_output = _decode_deepseek_generated_output(processor, generated_ids, input_ids=input_ids) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="DeepSeek direct generate()", + details={"infer_failure": str(infer_exc) if infer_exc else None}, + ) + + +def _decode_image_data_uri_bytes(image_data_uri: str) -> bytes: + try: + header, encoded = image_data_uri.split(",", 1) + except ValueError as exc: + raise RuntimeError("Expected a valid data URI for Mistral OCR image transcription.") from exc + if ";base64" not in header: + raise RuntimeError("Expected a base64-encoded data URI for Mistral OCR image transcription.") + try: + return base64.b64decode(encoded) + except Exception as exc: + raise RuntimeError("Could not decode the Mistral OCR image data URI.") from exc + + +def _decode_table_ocr_image_data_uri_bytes(image_data_uri: str) -> bytes: + try: + header, encoded = image_data_uri.split(",", 1) + except ValueError as exc: + raise RuntimeError("Expected a valid data URI for table OCR image transcription.") from exc + if ";base64" not in header: + raise RuntimeError("Expected a base64-encoded data URI for table OCR image transcription.") + try: + return base64.b64decode(encoded) + except Exception as exc: + raise RuntimeError("Could not decode the table OCR image data URI.") from exc + + +def _normalize_table_ocr_image_data_uri( + image_data_uri: str, + *, + progress_handler: ProgressHandler = None, +) -> str: + max_pixels = _table_ocr_normalized_max_image_pixels() + if max_pixels <= 0: + return image_data_uri + + image_bytes = _decode_table_ocr_image_data_uri_bytes(image_data_uri) + try: + from PIL import Image + + with Image.open(io.BytesIO(image_bytes)) as opened_image: + opened_image.load() + original_image = opened_image.convert("RGB") + except ImportError as exc: + raise RuntimeError("Pillow is required to normalize table OCR image resolution.") from exc + except Exception as exc: + raise RuntimeError("Could not read the table OCR image for resolution normalization.") from exc + + original_width, original_height = original_image.size + normalized_image = _resize_image_to_max_pixels(original_image, max_pixels) + normalized_width, normalized_height = normalized_image.size + if (normalized_width, normalized_height) == (original_width, original_height): + return image_data_uri + + output = io.BytesIO() + normalized_image.save(output, format="PNG") + emit_progress( + f"Normalized table OCR image from {original_width}x{original_height} " + f"to {normalized_width}x{normalized_height} with max {max_pixels:,} pixels.", + progress_handler=progress_handler, + ) + encoded = base64.b64encode(output.getvalue()).decode("ascii") + return f"data:image/png;base64,{encoded}" + + +def _data_uri_file_suffix(image_data_uri: str) -> str: + header = image_data_uri.split(",", 1)[0].lower() + if "image/jpeg" in header or "image/jpg" in header: + return ".jpg" + if "image/webp" in header: + return ".webp" + return ".png" + + +def _inline_mistral_table_placeholders(page_obj: Dict[str, Any], text_content: str) -> str: + rendered = str(text_content or "") + tables = page_obj.get("tables") + if not isinstance(tables, list) or not tables: + return rendered + + inlined_count = 0 + fallback_contents: List[str] = [] + for table in tables: + if not isinstance(table, dict): + continue + table_id = normalize_text(table.get("id")) + table_content = normalize_text(table.get("content")) + if not table_content: + continue + if table_id: + placeholder = f"[{table_id}]({table_id})" + if placeholder in rendered: + rendered = rendered.replace(placeholder, table_content) + inlined_count += 1 + continue + fallback_contents.append(table_content) + + # Some OCR responses may return only placeholders or very short markdown. + # If we failed to inline but do have table payloads, return the table contents directly. + if inlined_count == 0 and fallback_contents: + return "\n\n".join(fallback_contents) + + return rendered + + +def _build_mistral_ocr_payload( + *, + model: str, + signed_url: str, + table_format: str, + prompt_text: str, +) -> Dict[str, Any]: + payload: Dict[str, Any] = { + "model": model, + "document": { + "type": "document_url", + "document_url": signed_url, + }, + "table_format": table_format, + } + normalized_prompt = normalize_text(prompt_text) + if normalized_prompt: + # Mistral OCR does not expose a direct prompt field for the page markdown/tables + # output. The supported guided path is document_annotation_prompt + format. + # The API currently requires a json_schema-backed document_annotation_format. + payload["document_annotation_format"] = { + "type": "json_schema", + "json_schema": { + "name": "ocr_table_transcription", + "strict": True, + "schema": { + "type": "object", + "properties": { + "transcription": {"type": "string"}, + }, + "required": ["transcription"], + "additionalProperties": False, + }, + }, + } + payload["document_annotation_prompt"] = normalized_prompt + return payload + + +def _extract_mistral_prompted_text(response_payload: Dict[str, Any]) -> str: + def unwrap_annotation_text(value: Any) -> str: + if not isinstance(value, str): + return "" + normalized = normalize_text(value) + if not normalized: + return "" + stripped = normalized.strip() + if stripped.startswith("{") and stripped.endswith("}"): + try: + payload = json.loads(stripped) + except Exception: + return normalized + if isinstance(payload, dict): + for key in ("transcription", "text", "content", "value", "html"): + nested = payload.get(key) + if isinstance(nested, str) and normalize_text(nested): + return normalize_text(nested) + return normalized + + annotation = response_payload.get("document_annotation") + if isinstance(annotation, str): + return unwrap_annotation_text(annotation) + if isinstance(annotation, dict): + transcription = annotation.get("transcription") + if isinstance(transcription, str) and normalize_text(transcription): + return unwrap_annotation_text(transcription) + for key in ("text", "content", "value"): + value = annotation.get(key) + if isinstance(value, str) and normalize_text(value): + return unwrap_annotation_text(value) + return "" + + +def transcribe_table_image_with_mistral( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = normalize_text(model_id or default_mistral_ocr_model_id()) + if not resolved_model: + raise RuntimeError( + "Missing Mistral OCR model id. Pass a model id or set MISTRAL_OCR_MODEL_ID." + ) + + api_key = normalize_text(os.getenv("MISTRAL_API_KEY", "")) + if not api_key: + raise RuntimeError("Missing MISTRAL_API_KEY for Mistral OCR transcription.") + + sec_parser = load_sec_parser_module() + progress_label = f"[ocr {resolved_model}]" + image_bytes = _decode_image_data_uri_bytes(image_data_uri) + table_format = _mistral_ocr_table_format() + prompt_text = normalize_text(prompt or default_table_image_transcription_prompt()) + + emit_progress( + f"{progress_label} | upload image to Mistral OCR", + progress_handler=progress_handler, + ) + client = sec_parser.Mistral(api_key=api_key) + upload = client.files.upload( + file={ + "file_name": f"ocr_table{_data_uri_file_suffix(image_data_uri)}", + "content": image_bytes, + }, + purpose="ocr", + ) + if not upload or not getattr(upload, "id", None): + raise RuntimeError("Mistral OCR image upload failed to return a valid file id.") + + signed_url = sec_parser.get_signed_url_with_retry(client, file_id=upload.id) + payload = _build_mistral_ocr_payload( + model=resolved_model, + signed_url=signed_url, + table_format=table_format, + prompt_text=prompt_text, + ) + + emit_progress( + f"{progress_label} | request 1/1 | table_format={table_format}", + progress_handler=progress_handler, + ) + response = requests.post( + sec_parser.OCR_API_URL, + headers={ + "Authorization": f"Bearer {api_key}", + "Content-Type": "application/json", + }, + json=payload, + timeout=600, + ) + if response.status_code >= 400: + raise RuntimeError(f"Mistral OCR HTTP {response.status_code}: {response.text[:1500]}") + response_payload = response.json() + emit_progress( + f"{progress_label} | response received", + progress_handler=progress_handler, + ) + + prompted_text_content = _extract_mistral_prompted_text(response_payload) + if prompted_text_content: + emit_progress( + f"{progress_label} | using prompted document_annotation | content_chars={len(prompted_text_content)}", + progress_handler=progress_handler, + ) + return strip_code_fences(prompted_text_content) + + pages = response_payload.get("pages") + if not isinstance(pages, list) or not pages: + raise TableOCRContentError( + "Mistral OCR response did not include any pages.", + response_payload=response_payload, + details={ + "top_level_keys": sorted(str(key) for key in response_payload.keys()), + }, + ) + + first_page = pages[0] + if not isinstance(first_page, dict): + raise TableOCRContentError( + f"Mistral OCR first page was {type(first_page).__name__}, expected an object.", + response_payload=response_payload, + details={"page_type": type(first_page).__name__}, + ) + + raw_text_content = normalize_text(sec_parser._pick_text(first_page)) + text_content = normalize_text(_inline_mistral_table_placeholders(first_page, raw_text_content)) + if not text_content: + raise TableOCRContentError( + "Mistral OCR response did not contain markdown/text content for the first page.", + response_payload=response_payload, + details={ + "page_keys": sorted(str(key) for key in first_page.keys()), + "page_count": len(pages), + "table_format": table_format, + }, + ) + + emit_progress( + f"{progress_label} | pages={len(pages)} | content_chars={len(text_content)}", + progress_handler=progress_handler, + ) + return strip_code_fences(text_content) + + +def transcribe_table_image_with_firered( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + sec_parser = load_sec_parser_module() + model_name = resolve_firered_model_id(model_id) + if not model_name: + raise RuntimeError("Missing OCR model id for FireRed transcription.") + progress_label = f"[ocr {model_name}]" + + try: + import torch + except ImportError as exc: + raise RuntimeError("PyTorch is required for OCR transcription.") from exc + + emit_progress( + f"{progress_label} | local FireRed load", + progress_handler=progress_handler, + ) + model_obj, processor = sec_parser._get_firered_table_backend(model_name) + runtime_device = sec_parser._model_input_device(model_obj).type + original_image = sec_parser._decode_data_uri_to_pil_image(image_data_uri) + if _table_ocr_allow_backend_image_resize(): + base_page_image = sec_parser._prepare_firered_image(original_image, runtime_device) + else: + base_page_image = original_image.convert("RGB") + + prompt_text = prompt or default_table_image_transcription_prompt() + candidate_images = [("initial", base_page_image)] + if runtime_device == "mps" and _table_ocr_allow_backend_image_resize(): + base_pixels = base_page_image.size[0] * base_page_image.size[1] + seen_sizes = {base_page_image.size} + for retry_limit in firered_mps_retry_pixel_limits(): + if retry_limit >= base_pixels: + continue + retry_image = _resize_image_to_max_pixels(original_image, retry_limit) + if retry_image.size in seen_sizes: + continue + candidate_images.append((f"retry_max_pixels={retry_limit}", retry_image)) + seen_sizes.add(retry_image.size) + + last_exc: Optional[Exception] = None + for attempt_index, (attempt_label, page_image) in enumerate(candidate_images, start=1): + if attempt_index > 1: + emit_progress( + f"{progress_label} | retry local FireRed with {attempt_label} after buffer error: {last_exc}", + progress_handler=progress_handler, + ) + + messages = [ + { + "role": "user", + "content": [ + {"type": "image", "image": page_image}, + {"type": "text", "text": prompt_text}, + ], + } + ] + + chat_text = processor.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + ) + + inputs = processor( + text=[chat_text], + images=[page_image], + return_tensors="pt", + ) + inputs = inputs.to(sec_parser._model_input_device(model_obj)) + + emit_progress( + f"{progress_label} | local FireRed generate | device={runtime_device} | attempt={attempt_index}/{len(candidate_images)} | image={page_image.size[0]}x{page_image.size[1]}", + progress_handler=progress_handler, + ) + try: + with torch.inference_mode(): + generated_ids = model_obj.generate( + **inputs, + max_new_tokens=sec_parser.Config.FIRERED_MAX_NEW_TOKENS, + do_sample=False, + ) + except Exception as exc: + last_exc = exc + if runtime_device == "mps" and attempt_index < len(candidate_images) and _is_firered_buffer_error(exc): + continue + raise + + trimmed = generated_ids[:, inputs.input_ids.shape[1] :] + raw_output = processor.batch_decode( + trimmed, + skip_special_tokens=True, + clean_up_tokenization_spaces=False, + )[0] + cleaned_output = _require_nonempty_ocr_text_output( + raw_output, + backend_label="FireRed local generate()", + details={"model_id": model_name, "device": runtime_device}, + ) + emit_progress( + f"{progress_label} | local FireRed response | content_chars={len(cleaned_output)}", + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + cleaned_output, + effective_model_id=model_name, + ) + + if last_exc is not None: + raise last_exc + raise RuntimeError("FireRed OCR exhausted local retries without producing output.") + + +def transcribe_table_image_with_qianfan( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + del progress_handler + resolved_model = resolve_qianfan_model_id(model_id) + sec_parser = load_sec_parser_module() + model_obj, processor, runtime_device = _get_generic_ocr_backend( + resolved_model, + env_prefix="QIANFAN_OCR", + ) + model_device = sec_parser._model_input_device(model_obj) + page_image = _prepare_backend_image( + sec_parser._decode_data_uri_to_pil_image(image_data_uri), + env_prefix="QIANFAN_OCR", + runtime_device=runtime_device, + ) + prompt_text = prompt or default_table_image_transcription_prompt() + tokenizer_like = processor + pixel_values = _build_qianfan_pixel_values(page_image) + try: + pixel_values = pixel_values.to(device=model_device, dtype=getattr(model_obj, "dtype", None)) + except Exception: + try: + pixel_values = pixel_values.to(model_device) + except Exception: + pass + with __import__("torch").inference_mode(): + raw_output = model_obj.chat( + tokenizer_like, + pixel_values=pixel_values, + question=prompt_text, + generation_config={"max_new_tokens": _backend_max_new_tokens("QIANFAN_OCR", 4096)}, + ) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="Qianfan OCR local chat()", + details={"model_id": resolved_model, "device": runtime_device}, + ) + + +def transcribe_table_image_with_glm_ocr( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + del progress_handler + resolved_model = resolve_glm_ocr_model_id(model_id) + sec_parser = load_sec_parser_module() + model_obj, processor, runtime_device = _get_generic_ocr_backend( + resolved_model, + env_prefix="GLM_OCR", + ) + model_device = sec_parser._model_input_device(model_obj) + page_image = _prepare_backend_image( + sec_parser._decode_data_uri_to_pil_image(image_data_uri), + env_prefix="GLM_OCR", + runtime_device=runtime_device, + ) + prompt_text = prompt or "Table Recognition:" + raw_output = _run_generate_style_backend( + model_obj, + processor, + page_image, + prompt_text, + env_prefix="GLM_OCR", + model_device=model_device, + ) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="GLM-OCR local generate()", + details={"model_id": resolved_model, "device": runtime_device}, + ) + + +def transcribe_table_image_with_paddleocr_vl( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + del progress_handler + resolved_model = resolve_paddleocr_vl_model_id(model_id) + sec_parser = load_sec_parser_module() + model_obj, processor, runtime_device = _get_generic_ocr_backend( + resolved_model, + env_prefix="PADDLEOCR_VL", + ) + model_device = sec_parser._model_input_device(model_obj) + page_image = _prepare_backend_image( + sec_parser._decode_data_uri_to_pil_image(image_data_uri), + env_prefix="PADDLEOCR_VL", + runtime_device=runtime_device, + ) + prompt_text = prompt or default_table_image_transcription_prompt() + raw_output = _run_generate_style_backend( + model_obj, + processor, + page_image, + prompt_text, + env_prefix="PADDLEOCR_VL", + model_device=model_device, + ) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="PaddleOCR-VL local generate()", + details={"model_id": resolved_model, "device": runtime_device}, + ) + + +def transcribe_table_image_with_got_ocr( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + del progress_handler + # GOT-OCR's exposed local interface only supports its native formatted OCR prompt. + del prompt + _ensure_transformers_dynamic_cache_compatibility() + resolved_model = resolve_got_ocr_model_id(model_id) + sec_parser = load_sec_parser_module() + model_obj, processor, runtime_device = _get_generic_ocr_backend( + resolved_model, + env_prefix="GOT_OCR", + prefer_tokenizer=True, + ) + model_device = sec_parser._model_input_device(model_obj) + page_image = _prepare_backend_image( + sec_parser._decode_data_uri_to_pil_image(image_data_uri), + env_prefix="GOT_OCR", + runtime_device=runtime_device, + ) + raw_output = _run_got_ocr_backend( + model_obj, + processor, + page_image, + model_device=model_device, + ) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="GOT-OCR local backend", + details={"model_id": resolved_model, "device": runtime_device}, + ) + + +def transcribe_table_image_with_monkeyocr( + image_data_uri: str, + *, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = resolve_monkeyocr_model_id(model_id) + sec_parser = load_sec_parser_module() + page_image = sec_parser._decode_data_uri_to_pil_image(image_data_uri) + prompt_text = prompt or default_table_image_transcription_prompt() + raw_output = _run_monkeyocr_command( + page_image, + prompt_text, + model_id=resolved_model, + progress_handler=progress_handler, + ) + return _require_nonempty_ocr_text_output( + raw_output, + backend_label="MonkeyOCR local wrapper", + details={"model_id": resolved_model}, + ) + + +def _pdf_fastpath_raster_fallback_model_id(explicit_model_id: Optional[str] = None) -> str: + candidates = [ + normalize_text(explicit_model_id or ""), + normalize_text(os.getenv("PDF_FASTPATH_RASTER_OCR_MODEL_ID", "")), + normalize_text(os.getenv("OPENROUTER_MODEL_ID", "")), + normalize_text(os.getenv("DEEPSEEK_OCR_MODEL_ID", "")), + normalize_text(os.getenv("FIRERED_MODEL_ID", "")), + normalize_text(os.getenv("GEMMA4_LLAMA_CPP_MODEL_ID", "")), + ] + for candidate in candidates: + if candidate and candidate.lower() != "pdf_native_fastpath": + return candidate + raise RuntimeError( + "Raster PDF fast-path fallback needs an OCR model id. Pass ocr_model_id=... " + "or set PDF_FASTPATH_RASTER_OCR_MODEL_ID / OPENROUTER_MODEL_ID." + ) + + +def _pdf_fastpath_raster_render_zoom() -> float: + raw_value = normalize_text(os.getenv("PDF_FASTPATH_RASTER_RENDER_ZOOM", "2.0")) + try: + return max(1.0, float(raw_value)) + except ValueError: + return 2.0 + + +def _pdf_fastpath_raster_padding_pt() -> float: + raw_value = normalize_text(os.getenv("PDF_FASTPATH_RASTER_PADDING_PT", "6.0")) + try: + return max(0.0, float(raw_value)) + except ValueError: + return 6.0 + + +def _pdf_fastpath_raster_max_tables() -> int: + return _env_int("PDF_FASTPATH_RASTER_MAX_TABLES", 3) + + +def _pdf_fastpath_page_render_zoom() -> float: + raw_value = normalize_text(os.getenv("PDF_FASTPATH_PAGE_RENDER_ZOOM", "2.0")) + try: + return max(1.0, float(raw_value)) + except ValueError: + return 2.0 + + +def _render_pdf_page_data_uri( + page: Any, + *, + zoom: float, +) -> str: + try: + import fitz + except ImportError as exc: + raise RuntimeError("PyMuPDF is required for PDF page rendering.") from exc + + pix = page.get_pixmap(matrix=fitz.Matrix(float(zoom), float(zoom)), alpha=False) + return f"data:image/png;base64,{base64.b64encode(pix.tobytes('png')).decode('utf-8')}" + + +def _render_pdf_table_region_data_uri( + page: Any, + *, + bbox: List[float] | tuple[float, float, float, float], + zoom: float, + padding_pt: float, +) -> str: + try: + import fitz + except ImportError as exc: + raise RuntimeError("PyMuPDF is required for PDF fast-path raster fallback rendering.") from exc + + page_rect = page.rect + left = max(float(page_rect.x0), float(bbox[0]) - padding_pt) + top = max(float(page_rect.y0), float(bbox[1]) - padding_pt) + right = min(float(page_rect.x1), float(bbox[2]) + padding_pt) + bottom = min(float(page_rect.y1), float(bbox[3]) + padding_pt) + clip_rect = fitz.Rect(left, top, right, bottom) + pix = page.get_pixmap(matrix=fitz.Matrix(float(zoom), float(zoom)), clip=clip_rect, alpha=False) + return f"data:image/png;base64,{base64.b64encode(pix.tobytes('png')).decode('utf-8')}" + + +def _normalize_table_match_text(text: str) -> str: + normalized = html.unescape(normalize_text(text)) + normalized = re.sub(r"\s+", " ", normalized) + return normalized.strip().lower() + + +def _bbox_to_attr_value(bbox: Any) -> str: + if not isinstance(bbox, (list, tuple)) or len(bbox) != 4: + return "" + try: + return ",".join(f"{float(value):.2f}" for value in bbox) + except (TypeError, ValueError): + return "" + + +def _sequence_similarity(left_text: str, right_text: str) -> float: + left_normalized = _normalize_table_match_text(left_text) + right_normalized = _normalize_table_match_text(right_text) + if not left_normalized or not right_normalized: + return 0.0 + return float(difflib.SequenceMatcher(None, left_normalized, right_normalized).ratio()) + + +def _table_text_overlap_score(left_texts: List[str], right_texts: List[str]) -> float: + left_set = {_normalize_table_match_text(text) for text in left_texts if _normalize_table_match_text(text)} + right_set = {_normalize_table_match_text(text) for text in right_texts if _normalize_table_match_text(text)} + if not left_set or not right_set: + return 0.0 + intersection = len(left_set & right_set) + union = max(1, len(left_set | right_set)) + return float(intersection) / float(union) + + +def _parse_html_table_cells(table_tag: Any, *, table_index: int) -> Dict[str, Any]: + occupied: Dict[Tuple[int, int], bool] = {} + cells: List[Dict[str, Any]] = [] + row_tags = list(table_tag.find_all("tr")) + max_column = 0 + for row_index, row_tag in enumerate(row_tags): + column_index = 0 + for cell_tag in row_tag.find_all(["th", "td"], recursive=False): + while occupied.get((row_index, column_index)): + column_index += 1 + try: + rowspan = max(1, int(cell_tag.get("rowspan", 1))) + except (TypeError, ValueError): + rowspan = 1 + try: + colspan = max(1, int(cell_tag.get("colspan", 1))) + except (TypeError, ValueError): + colspan = 1 + for row_offset in range(rowspan): + for column_offset in range(colspan): + occupied[(row_index + row_offset, column_index + column_offset)] = True + cell_text = normalize_text(cell_tag.get_text(" ", strip=True)) + cells.append( + { + "row": row_index, + "col": column_index, + "rowspan": rowspan, + "colspan": colspan, + "text": cell_text, + "match_text": _normalize_table_match_text(cell_text), + "tag": cell_tag, + } + ) + max_column = max(max_column, column_index + colspan) + column_index += colspan + return { + "index": table_index, + "tag": table_tag, + "cells": cells, + "texts": [cell["text"] for cell in cells if normalize_text(cell["text"])], + "row_count": len(row_tags), + "column_count": max_column, + "match_text": " | ".join( + _normalize_table_match_text(cell["text"]) + for cell in cells + if _normalize_table_match_text(cell["text"]) + ), + } + + +def _build_native_table_descriptor(table_payload: Dict[str, Any], *, table_index: int) -> Dict[str, Any]: + cells = [ + cell + for cell in list(table_payload.get("cells") or []) + if isinstance(cell, dict) + ] + row_count = max( + ( + int(cell.get("row", 0)) + max(1, int(cell.get("rowspan", 1))) + for cell in cells + ), + default=0, + ) + column_count = max( + ( + int(cell.get("col", 0)) + max(1, int(cell.get("colspan", 1))) + for cell in cells + ), + default=0, + ) + texts = [normalize_text(str(cell.get("text", ""))) for cell in cells if normalize_text(str(cell.get("text", "")))] + for cell in cells: + cell["match_text"] = _normalize_table_match_text(str(cell.get("text", ""))) + return { + "index": table_index, + "bbox": list(table_payload.get("bbox") or []), + "source": normalize_text(str(table_payload.get("source", ""))), + "cells": cells, + "texts": texts, + "row_count": row_count, + "column_count": column_count, + "match_text": " | ".join(cell["match_text"] for cell in cells if cell["match_text"]), + } + + +def _score_html_table_match(html_table: Dict[str, Any], native_table: Dict[str, Any]) -> float: + text_score = _sequence_similarity(str(html_table.get("match_text", "")), str(native_table.get("match_text", ""))) + overlap_score = _table_text_overlap_score( + list(html_table.get("texts") or []), + list(native_table.get("texts") or []), + ) + row_score = 1.0 / (1.0 + abs(int(html_table.get("row_count", 0)) - int(native_table.get("row_count", 0)))) + column_score = 1.0 / (1.0 + abs(int(html_table.get("column_count", 0)) - int(native_table.get("column_count", 0)))) + return (0.55 * text_score) + (0.20 * overlap_score) + (0.15 * row_score) + (0.10 * column_score) + + +def _match_html_tables_to_native_tables( + html_tables: List[Dict[str, Any]], + native_tables: List[Dict[str, Any]], +) -> Dict[int, Dict[str, Any]]: + scored_pairs: List[Tuple[float, int, int]] = [] + for html_table in html_tables: + for native_table in native_tables: + scored_pairs.append( + ( + _score_html_table_match(html_table, native_table), + int(html_table["index"]), + int(native_table["index"]), + ) + ) + scored_pairs.sort(reverse=True) + assignments: Dict[int, Dict[str, Any]] = {} + used_html: set[int] = set() + used_native: set[int] = set() + for score, html_index, native_index in scored_pairs: + if score <= 0.10 or html_index in used_html or native_index in used_native: + continue + assignments[html_index] = { + "native_index": native_index, + "score": float(score), + } + used_html.add(html_index) + used_native.add(native_index) + return assignments + + +def _grid_iou(left_cell: Dict[str, Any], right_cell: Dict[str, Any]) -> float: + left_row_start = int(left_cell.get("row", 0)) + left_row_end = left_row_start + max(1, int(left_cell.get("rowspan", 1))) + left_col_start = int(left_cell.get("col", 0)) + left_col_end = left_col_start + max(1, int(left_cell.get("colspan", 1))) + right_row_start = int(right_cell.get("row", 0)) + right_row_end = right_row_start + max(1, int(right_cell.get("rowspan", 1))) + right_col_start = int(right_cell.get("col", 0)) + right_col_end = right_col_start + max(1, int(right_cell.get("colspan", 1))) + + row_overlap = max(0, min(left_row_end, right_row_end) - max(left_row_start, right_row_start)) + col_overlap = max(0, min(left_col_end, right_col_end) - max(left_col_start, right_col_start)) + intersection = row_overlap * col_overlap + left_area = max(1, left_row_end - left_row_start) * max(1, left_col_end - left_col_start) + right_area = max(1, right_row_end - right_row_start) * max(1, right_col_end - right_col_start) + union = max(1, left_area + right_area - intersection) + return float(intersection) / float(union) + + +def _score_html_cell_match(html_cell: Dict[str, Any], native_cell: Dict[str, Any]) -> float: + text_score = _sequence_similarity(str(html_cell.get("text", "")), str(native_cell.get("text", ""))) + grid_score = _grid_iou(html_cell, native_cell) + same_anchor_score = ( + 1.0 + if ( + int(html_cell.get("row", -1)) == int(native_cell.get("row", -2)) + and int(html_cell.get("col", -1)) == int(native_cell.get("col", -2)) + ) + else 0.0 + ) + span_score = 1.0 / ( + 1.0 + + abs(int(html_cell.get("rowspan", 1)) - int(native_cell.get("rowspan", 1))) + + abs(int(html_cell.get("colspan", 1)) - int(native_cell.get("colspan", 1))) + ) + if not _normalize_table_match_text(str(html_cell.get("text", ""))) or not _normalize_table_match_text(str(native_cell.get("text", ""))): + return (0.65 * grid_score) + (0.20 * same_anchor_score) + (0.15 * span_score) + return (0.50 * text_score) + (0.25 * grid_score) + (0.15 * same_anchor_score) + (0.10 * span_score) + + +def _match_html_cells_to_native_cells( + html_table: Dict[str, Any], + native_table: Dict[str, Any], +) -> Dict[int, Dict[str, Any]]: + matches: Dict[int, Dict[str, Any]] = {} + native_cells = list(native_table.get("cells") or []) + unused_native_indexes = set(range(len(native_cells))) + exact_key_to_indexes: Dict[Tuple[int, int, int, int], List[int]] = {} + for index, native_cell in enumerate(native_cells): + key = ( + int(native_cell.get("row", 0)), + int(native_cell.get("col", 0)), + max(1, int(native_cell.get("rowspan", 1))), + max(1, int(native_cell.get("colspan", 1))), + ) + exact_key_to_indexes.setdefault(key, []).append(index) + + for html_cell_index, html_cell in enumerate(list(html_table.get("cells") or [])): + key = ( + int(html_cell.get("row", 0)), + int(html_cell.get("col", 0)), + max(1, int(html_cell.get("rowspan", 1))), + max(1, int(html_cell.get("colspan", 1))), + ) + exact_indexes = [index for index in exact_key_to_indexes.get(key, []) if index in unused_native_indexes] + if exact_indexes: + native_index = exact_indexes[0] + unused_native_indexes.remove(native_index) + matches[html_cell_index] = { + "native_cell": native_cells[native_index], + "score": 1.0, + } + + for html_cell_index, html_cell in enumerate(list(html_table.get("cells") or [])): + if html_cell_index in matches: + continue + best_native_index: Optional[int] = None + best_score = 0.0 + for native_index in unused_native_indexes: + candidate_score = _score_html_cell_match(html_cell, native_cells[native_index]) + if candidate_score <= best_score: + continue + best_score = candidate_score + best_native_index = native_index + if best_native_index is None or best_score <= 0.15: + continue + unused_native_indexes.remove(best_native_index) + matches[html_cell_index] = { + "native_cell": native_cells[best_native_index], + "score": float(best_score), + } + return matches + + +def _soup_fragment_contents(soup: Any) -> str: + body = getattr(soup, "body", None) + if body is not None: + return body.decode_contents() + return str(soup) + + +def _cell_markup_has_tag(markup: str, *tag_names: str) -> bool: + if not markup: + return False + pattern = r"<(?:%s)\b" % "|".join(re.escape(tag_name) for tag_name in tag_names) + return bool(re.search(pattern, markup, flags=re.IGNORECASE)) + + +def _style_attr_text(value: Any) -> str: + return re.sub(r"\s+", " ", str(value or "")).strip().lower() + + +def _tag_and_descendants(tag: Any) -> List[Any]: + tags = [tag] + if hasattr(tag, "find_all"): + try: + tags.extend(list(tag.find_all(True))) + except Exception: + pass + return tags + + +def _tag_descendants_have_css_style(tag: Any, pattern: str) -> bool: + compiled = re.compile(pattern, re.IGNORECASE) + for candidate in _tag_and_descendants(tag): + style_text = "" + if hasattr(candidate, "get"): + style_text = _style_attr_text(candidate.get("style", "")) + if style_text and compiled.search(style_text): + return True + return False + + +def _tag_has_bold_style(tag: Any) -> bool: + return _cell_markup_has_tag(str(tag), "strong", "b") or _tag_descendants_have_css_style( + tag, + r"font-weight\s*:\s*(?:bold|bolder|[6-9]00)\b", + ) + + +def _tag_has_italic_style(tag: Any) -> bool: + return _cell_markup_has_tag(str(tag), "em", "i") or _tag_descendants_have_css_style( + tag, + r"font-style\s*:\s*(?:italic|oblique)\b", + ) + + +def _tag_has_underline_style(tag: Any) -> bool: + return _cell_markup_has_tag(str(tag), "u") or _tag_descendants_have_css_style( + tag, + r"text-decoration(?:-line)?\s*:[^;]*underline\b", + ) + + +def _replace_tag_contents_with_html(tag: Any, html_fragment: str) -> None: + try: + from bs4 import BeautifulSoup + except ImportError as exc: + raise RuntimeError("beautifulsoup4 is required for HTML fragment replacement.") from exc + + fragment_soup = BeautifulSoup(f"{html_fragment}", "html.parser") + body = getattr(fragment_soup, "body", None) + replacement_nodes = list(body.contents if body is not None else fragment_soup.contents) + tag.clear() + for node in replacement_nodes: + tag.append(node) + + +def _wrap_cell_markup_with_style_tags(markup: str, *, bold: bool, italic: bool, underline: bool) -> str: + rendered = str(markup or "") + if bold and not _cell_markup_has_tag(rendered, "strong", "b"): + rendered = f"{rendered}" + if italic and not _cell_markup_has_tag(rendered, "em", "i"): + rendered = f"{rendered}" + if underline and not _cell_markup_has_tag(rendered, "u"): + rendered = f"{rendered}" + return rendered + + +def _style_overlay_min_match_score() -> float: + return _env_float("PDF_STYLE_OVERLAY_MIN_MATCH_SCORE", 0.75, min_value=0.0, max_value=1.0) + + +def _style_overlay_min_text_similarity() -> float: + return _env_float("PDF_STYLE_OVERLAY_MIN_TEXT_SIMILARITY", 0.90, min_value=0.0, max_value=1.0) + + +def _style_overlay_bold_min_match_score() -> float: + return _env_float("PDF_STYLE_OVERLAY_BOLD_MIN_MATCH_SCORE", 0.90, min_value=0.0, max_value=1.0) + + +def _style_overlay_bold_min_text_similarity() -> float: + return _env_float("PDF_STYLE_OVERLAY_BOLD_MIN_TEXT_SIMILARITY", 0.97, min_value=0.0, max_value=1.0) + + +def _resolved_style_overlay_flags( + *, + current_text: str, + native_text: str, + match_score: Optional[float], + bold: bool, + italic: bool, + underline: bool, +) -> Dict[str, bool]: + normalized_current = _normalize_table_match_text(current_text) + normalized_native = _normalize_table_match_text(native_text) + if not normalized_current or not normalized_native: + return { + "bold": False, + "italic": False, + "underline": False, + } + + score = max(0.0, min(1.0, float(match_score))) if isinstance(match_score, (int, float)) else 0.0 + text_similarity = _sequence_similarity(current_text, native_text) + texts_match = normalized_current == normalized_native + + general_confident = score >= _style_overlay_min_match_score() and ( + texts_match or text_similarity >= _style_overlay_min_text_similarity() + ) + bold_confident = score >= _style_overlay_bold_min_match_score() and ( + texts_match or text_similarity >= _style_overlay_bold_min_text_similarity() + ) + + return { + "bold": bool(bold) and bold_confident, + "italic": bool(italic) and general_confident, + "underline": bool(underline) and general_confident, + } + + +def _resolve_style_overlay_mode(style_overlay_mode: Optional[str]) -> str: + normalized = normalize_text(style_overlay_mode or "auto").lower() or "auto" + if normalized in {"none", "attrs_only", "formatting_only", "auto", "aggressive"}: + return normalized + return "auto" + + +def _apply_native_style_overlay_to_cell( + cell_tag: Any, + *, + html_cell: Dict[str, Any], + native_cell: Dict[str, Any], + style_overlay_mode: str, + match_score: Optional[float] = None, +) -> str: + current_markup = str(cell_tag.decode_contents() or "") + native_html = normalize_text(str(native_cell.get("html", ""))) + current_text = str(html_cell.get("text", "")) + native_text = str(native_cell.get("text", "")) + text_similarity = _sequence_similarity(current_text, native_text) + texts_match = _normalize_table_match_text(current_text) == _normalize_table_match_text(native_text) + style_flags = _resolved_style_overlay_flags( + current_text=current_text, + native_text=native_text, + match_score=match_score, + bold=bool(native_cell.get("bold")), + italic=bool(native_cell.get("italic")), + underline=bool(native_cell.get("underline")), + ) + uniform_style_markup = _wrap_cell_markup_with_style_tags( + current_markup, + bold=style_flags["bold"], + italic=style_flags["italic"], + underline=style_flags["underline"], + ) + + if style_overlay_mode == "none": + return current_markup + if style_overlay_mode == "attrs_only": + return current_markup + if style_overlay_mode == "formatting_only": + if uniform_style_markup != current_markup: + _replace_tag_contents_with_html(cell_tag, uniform_style_markup) + return str(cell_tag.decode_contents() or "") + if style_overlay_mode == "aggressive" and native_html: + _replace_tag_contents_with_html(cell_tag, native_html) + return str(cell_tag.decode_contents() or "") + if style_overlay_mode == "auto" and native_html and (texts_match or text_similarity >= 0.92): + _replace_tag_contents_with_html(cell_tag, native_html) + return str(cell_tag.decode_contents() or "") + if uniform_style_markup != current_markup: + _replace_tag_contents_with_html(cell_tag, uniform_style_markup) + return str(cell_tag.decode_contents() or "") + + +def annotate_table_html_with_pdf_cells( + table_html: str, + *, + pdf_path: str | Path, + page_number: int, + native_payload: Optional[Dict[str, Any]] = None, + style_overlay_mode: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> Dict[str, Any]: + try: + import pdf_table_fastpath + except ImportError as exc: + raise RuntimeError( + "The pdf_table_fastpath module is required for PDF cell/style annotation." + ) from exc + try: + from bs4 import BeautifulSoup + except ImportError as exc: + raise RuntimeError( + "beautifulsoup4 is required for annotating Mistral HTML with PDF cell metadata." + ) from exc + + resolved_pdf_path = Path(pdf_path).resolve() + resolved_page_number = max(1, int(page_number)) + resolved_style_overlay_mode = _resolve_style_overlay_mode(style_overlay_mode) + started_at = time.perf_counter() + if native_payload is None: + emit_progress( + f"[pdf-cell-overlay] {resolved_pdf_path.name} | page {resolved_page_number} | extract native cells", + progress_handler=progress_handler, + ) + native_payload = pdf_table_fastpath.extract_tables_from_pdf_page( + resolved_pdf_path, + page_number=resolved_page_number, + ) + + soup = BeautifulSoup(str(table_html or ""), "html.parser") + html_tables = [ + _parse_html_table_cells(table_tag, table_index=index) + for index, table_tag in enumerate(soup.find_all("table")) + ] + native_tables = [ + _build_native_table_descriptor(table_payload, table_index=index) + for index, table_payload in enumerate(list((native_payload or {}).get("tables") or [])) + if isinstance(table_payload, dict) + ] + + annotated_tables: List[Dict[str, Any]] = [] + if html_tables and native_tables and normalize_text(str((native_payload or {}).get("mode", ""))) == "pdf_native": + table_matches = _match_html_tables_to_native_tables(html_tables, native_tables) + for html_table in html_tables: + match = table_matches.get(int(html_table["index"])) + if match is None: + annotated_tables.append( + { + "table_index": int(html_table["index"]), + "matched": False, + "cells": [], + } + ) + continue + + native_table = native_tables[int(match["native_index"])] + table_tag = html_table["tag"] + table_bbox_attr = _bbox_to_attr_value(native_table.get("bbox")) + table_tag["data-pdf-native-index"] = str(native_table["index"]) + table_tag["data-pdf-match-score"] = f"{float(match['score']):.3f}" + if table_bbox_attr: + table_tag["data-pdf-bbox"] = table_bbox_attr + if normalize_text(str(native_table.get("source", ""))): + table_tag["data-pdf-source"] = str(native_table["source"]) + + cell_matches = _match_html_cells_to_native_cells(html_table, native_table) + annotated_cells: List[Dict[str, Any]] = [] + for html_cell_index, html_cell in enumerate(list(html_table.get("cells") or [])): + cell_tag = html_cell["tag"] + matched_payload = cell_matches.get(html_cell_index) + if matched_payload is None: + cell_tag["data-pdf-matched"] = "0" + annotated_cells.append( + { + "row": int(html_cell["row"]), + "col": int(html_cell["col"]), + "rowspan": int(html_cell["rowspan"]), + "colspan": int(html_cell["colspan"]), + "text": str(html_cell["text"]), + "matched": False, + } + ) + continue + + native_cell = matched_payload["native_cell"] + cell_tag["data-pdf-matched"] = "1" + cell_tag["data-pdf-match-score"] = f"{float(matched_payload['score']):.3f}" + bbox_attr = _bbox_to_attr_value(native_cell.get("bbox")) + if bbox_attr: + cell_tag["data-pdf-bbox"] = bbox_attr + cell_tag["data-pdf-native-row"] = str(int(native_cell.get("row", 0))) + cell_tag["data-pdf-native-col"] = str(int(native_cell.get("col", 0))) + cell_tag["data-pdf-bold"] = "1" if bool(native_cell.get("bold")) else "0" + cell_tag["data-pdf-italic"] = "1" if bool(native_cell.get("italic")) else "0" + cell_tag["data-pdf-underline"] = "1" if bool(native_cell.get("underline")) else "0" + cell_tag["data-pdf-header"] = "1" if bool(native_cell.get("header")) else "0" + styled_html = _apply_native_style_overlay_to_cell( + cell_tag, + html_cell=html_cell, + native_cell=native_cell, + style_overlay_mode=resolved_style_overlay_mode, + match_score=float(matched_payload["score"]), + ) + annotated_cells.append( + { + "row": int(html_cell["row"]), + "col": int(html_cell["col"]), + "rowspan": int(html_cell["rowspan"]), + "colspan": int(html_cell["colspan"]), + "text": str(html_cell["text"]), + "matched": True, + "match_score": round(float(matched_payload["score"]), 4), + "bbox": list(native_cell.get("bbox") or []), + "native_row": int(native_cell.get("row", 0)), + "native_col": int(native_cell.get("col", 0)), + "bold": bool(native_cell.get("bold")), + "italic": bool(native_cell.get("italic")), + "underline": bool(native_cell.get("underline")), + "header": bool(native_cell.get("header")), + "styled_html": styled_html, + } + ) + annotated_tables.append( + { + "table_index": int(html_table["index"]), + "matched": True, + "match_score": round(float(match["score"]), 4), + "native_table_index": int(native_table["index"]), + "bbox": list(native_table.get("bbox") or []), + "source": str(native_table.get("source", "")), + "cells": annotated_cells, + } + ) + + elapsed_ms = (time.perf_counter() - started_at) * 1000.0 + return { + "html": _soup_fragment_contents(soup), + "mode": normalize_text(str((native_payload or {}).get("mode", ""))) or None, + "tables": annotated_tables, + "native_tables": native_tables, + "style_overlay_mode": resolved_style_overlay_mode, + "timings_ms": { + "annotation_ms": round(float(elapsed_ms), 2), + }, + } + + +def _build_native_html_table_descriptor(table_tag: Any, *, table_index: int) -> Dict[str, Any]: + parsed = _parse_html_table_cells(table_tag, table_index=table_index) + native_cells: List[Dict[str, Any]] = [] + texts: List[str] = [] + for cell in list(parsed.get("cells") or []): + source_tag = cell["tag"] + bold = _tag_has_bold_style(source_tag) + italic = _tag_has_italic_style(source_tag) + underline = _tag_has_underline_style(source_tag) + rendered_html = _wrap_cell_markup_with_style_tags( + str(source_tag.decode_contents() or ""), + bold=bold, + italic=italic, + underline=underline, + ) + text = normalize_text(str(cell.get("text", ""))) + if text: + texts.append(text) + native_cells.append( + { + "row": int(cell["row"]), + "col": int(cell["col"]), + "rowspan": int(cell["rowspan"]), + "colspan": int(cell["colspan"]), + "text": text, + "html": rendered_html, + "bold": bold, + "italic": italic, + "underline": underline, + "header": normalize_text(getattr(source_tag, "name", "")).lower() == "th", + "match_text": _normalize_table_match_text(text), + } + ) + return { + "index": table_index, + "source": "html_native", + "cells": native_cells, + "texts": texts, + "row_count": int(parsed.get("row_count", 0)), + "column_count": int(parsed.get("column_count", 0)), + "match_text": str(parsed.get("match_text", "")), + } + + +def annotate_table_html_with_native_html( + table_html: str, + *, + native_html: str, + style_overlay_mode: Optional[str] = None, +) -> Dict[str, Any]: + try: + from bs4 import BeautifulSoup + except ImportError as exc: + raise RuntimeError( + "beautifulsoup4 is required for annotating OCR HTML with native HTML style metadata." + ) from exc + + resolved_style_overlay_mode = _resolve_style_overlay_mode(style_overlay_mode) + started_at = time.perf_counter() + + soup = BeautifulSoup(str(table_html or ""), "html.parser") + native_soup = BeautifulSoup(str(native_html or ""), "html.parser") + html_tables = [ + _parse_html_table_cells(table_tag, table_index=index) + for index, table_tag in enumerate(soup.find_all("table")) + ] + native_tables = [ + _build_native_html_table_descriptor(table_tag, table_index=index) + for index, table_tag in enumerate(native_soup.find_all("table")) + ] + + annotated_tables: List[Dict[str, Any]] = [] + if html_tables and native_tables: + table_matches = _match_html_tables_to_native_tables(html_tables, native_tables) + for html_table in html_tables: + match = table_matches.get(int(html_table["index"])) + if match is None: + annotated_tables.append( + { + "table_index": int(html_table["index"]), + "matched": False, + "cells": [], + } + ) + continue + + native_table = native_tables[int(match["native_index"])] + table_tag = html_table["tag"] + table_tag["data-native-index"] = str(native_table["index"]) + table_tag["data-native-match-score"] = f"{float(match['score']):.3f}" + if normalize_text(str(native_table.get("source", ""))): + table_tag["data-native-source"] = str(native_table["source"]) + + cell_matches = _match_html_cells_to_native_cells(html_table, native_table) + annotated_cells: List[Dict[str, Any]] = [] + for html_cell_index, html_cell in enumerate(list(html_table.get("cells") or [])): + cell_tag = html_cell["tag"] + matched_payload = cell_matches.get(html_cell_index) + if matched_payload is None: + cell_tag["data-native-matched"] = "0" + annotated_cells.append( + { + "row": int(html_cell["row"]), + "col": int(html_cell["col"]), + "rowspan": int(html_cell["rowspan"]), + "colspan": int(html_cell["colspan"]), + "text": str(html_cell["text"]), + "matched": False, + } + ) + continue + + native_cell = matched_payload["native_cell"] + cell_tag["data-native-matched"] = "1" + cell_tag["data-native-match-score"] = f"{float(matched_payload['score']):.3f}" + cell_tag["data-native-row"] = str(int(native_cell.get("row", 0))) + cell_tag["data-native-col"] = str(int(native_cell.get("col", 0))) + cell_tag["data-native-bold"] = "1" if bool(native_cell.get("bold")) else "0" + cell_tag["data-native-italic"] = "1" if bool(native_cell.get("italic")) else "0" + cell_tag["data-native-underline"] = "1" if bool(native_cell.get("underline")) else "0" + cell_tag["data-native-header"] = "1" if bool(native_cell.get("header")) else "0" + styled_html = _apply_native_style_overlay_to_cell( + cell_tag, + html_cell=html_cell, + native_cell=native_cell, + style_overlay_mode=resolved_style_overlay_mode, + match_score=float(matched_payload["score"]), + ) + annotated_cells.append( + { + "row": int(html_cell["row"]), + "col": int(html_cell["col"]), + "rowspan": int(html_cell["rowspan"]), + "colspan": int(html_cell["colspan"]), + "text": str(html_cell["text"]), + "matched": True, + "match_score": round(float(matched_payload["score"]), 4), + "native_row": int(native_cell.get("row", 0)), + "native_col": int(native_cell.get("col", 0)), + "bold": bool(native_cell.get("bold")), + "italic": bool(native_cell.get("italic")), + "underline": bool(native_cell.get("underline")), + "header": bool(native_cell.get("header")), + "styled_html": styled_html, + } + ) + annotated_tables.append( + { + "table_index": int(html_table["index"]), + "matched": True, + "match_score": round(float(match["score"]), 4), + "native_table_index": int(native_table["index"]), + "source": str(native_table.get("source", "")), + "cells": annotated_cells, + } + ) + + elapsed_ms = (time.perf_counter() - started_at) * 1000.0 + return { + "html": _soup_fragment_contents(soup), + "mode": "html_native", + "tables": annotated_tables, + "native_tables": native_tables, + "style_overlay_mode": resolved_style_overlay_mode, + "timings_ms": { + "annotation_ms": round(float(elapsed_ms), 2), + }, + } + + +def overlay_table_html_with_native_html( + table_html: str, + *, + native_html: str, + effective_model_id: Optional[str] = None, + style_overlay_mode: Optional[str] = None, + timings_ms: Optional[Dict[str, Any]] = None, +) -> Dict[str, Any]: + annotation = annotate_table_html_with_native_html( + table_html, + native_html=native_html, + style_overlay_mode=style_overlay_mode, + ) + matched_table_count = sum(1 for table in annotation["tables"] if bool(table.get("matched"))) + resolved_timings_ms: Dict[str, Any] = {} + for key, value in dict(timings_ms or {}).items(): + if isinstance(value, (int, float)): + resolved_timings_ms[str(key)] = round(float(value), 2) + annotation_ms = annotation.get("timings_ms", {}).get("annotation_ms") + if isinstance(annotation_ms, (int, float)): + resolved_timings_ms["annotation_ms"] = round(float(annotation_ms), 2) + return { + "html": str(annotation["html"]), + "raw_html": strip_code_fences(str(table_html)), + "tables": list(annotation["tables"]), + "overlay_mode": annotation.get("mode"), + "overlay_applied": bool(matched_table_count), + "style_overlay_mode": annotation.get("style_overlay_mode"), + "effective_model_id": normalize_text(effective_model_id or ""), + "timings_ms": resolved_timings_ms, + "native_payload": { + "mode": annotation.get("mode"), + "tables": annotation.get("native_tables"), + }, + } + + +def overlay_pdf_page_html_with_native_cells( + table_html: str, + *, + pdf_path: str | Path, + page_number: int, + effective_model_id: Optional[str] = None, + native_payload: Optional[Dict[str, Any]] = None, + style_overlay_mode: Optional[str] = None, + timings_ms: Optional[Dict[str, Any]] = None, + progress_handler: ProgressHandler = None, +) -> Dict[str, Any]: + annotation = annotate_table_html_with_pdf_cells( + table_html, + pdf_path=pdf_path, + page_number=page_number, + native_payload=native_payload, + style_overlay_mode=style_overlay_mode, + progress_handler=progress_handler, + ) + matched_table_count = sum(1 for table in annotation["tables"] if bool(table.get("matched"))) + resolved_timings_ms: Dict[str, Any] = {} + for key, value in dict(timings_ms or {}).items(): + if isinstance(value, (int, float)): + resolved_timings_ms[str(key)] = round(float(value), 2) + annotation_ms = annotation.get("timings_ms", {}).get("annotation_ms") + if isinstance(annotation_ms, (int, float)): + resolved_timings_ms["annotation_ms"] = round(float(annotation_ms), 2) + resolved_native_payload = native_payload + if resolved_native_payload is None: + resolved_native_payload = { + "mode": annotation.get("mode"), + "tables": annotation.get("native_tables"), + } + return { + "html": str(annotation["html"]), + "raw_html": strip_code_fences(str(table_html)), + "tables": list(annotation["tables"]), + "overlay_mode": annotation.get("mode"), + "overlay_applied": bool(matched_table_count), + "style_overlay_mode": annotation.get("style_overlay_mode"), + "effective_model_id": normalize_text(effective_model_id or ""), + "timings_ms": resolved_timings_ms, + "native_payload": resolved_native_payload, + } + + +def _table_ocr_transcription_text_from_pdf_payload(payload: Dict[str, Any]) -> TableOCRTranscriptionText: + transcription = TableOCRTranscriptionText( + str(payload.get("html") or ""), + effective_model_id=normalize_text(str(payload.get("effective_model_id") or "")), + ) + transcription.raw_html = str(payload.get("raw_html") or "") + transcription.tables = list(payload.get("tables") or []) + transcription.overlay_mode = normalize_text(str(payload.get("overlay_mode") or "")) + transcription.overlay_applied = bool(payload.get("overlay_applied")) + transcription.style_overlay_mode = normalize_text(str(payload.get("style_overlay_mode") or "")) + transcription.native_payload = payload.get("native_payload") + transcription.timings_ms = dict(payload.get("timings_ms") or {}) + transcription.payload = payload + return transcription + + +def transcribe_pdf_page_with_mistral_and_pdf_cells( + pdf_path: str | Path, + *, + page_number: int, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + page_render_zoom: Optional[float] = None, + style_overlay_mode: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> Dict[str, Any]: + try: + import fitz + except ImportError as exc: + raise RuntimeError("PyMuPDF is required for PDF page rendering.") from exc + try: + import pdf_table_fastpath + except ImportError as exc: + raise RuntimeError( + "The pdf_table_fastpath module is required for Mistral PDF cell/style overlay." + ) from exc + + resolved_pdf_path = Path(pdf_path).resolve() + resolved_page_number = max(1, int(page_number)) + resolved_zoom = max(1.0, float(page_render_zoom or _pdf_fastpath_page_render_zoom())) + total_started_at = time.perf_counter() + + emit_progress( + f"[mistral+pdf-cells] {resolved_pdf_path.name} | page {resolved_page_number} | render page", + progress_handler=progress_handler, + ) + render_started_at = time.perf_counter() + with fitz.open(str(resolved_pdf_path)) as document: + page = document.load_page(resolved_page_number - 1) + image_data_uri = _render_pdf_page_data_uri( + page, + zoom=resolved_zoom, + ) + page_render_ms = (time.perf_counter() - render_started_at) * 1000.0 + + emit_progress( + f"[mistral+pdf-cells] {resolved_pdf_path.name} | page {resolved_page_number} | extract native cells", + progress_handler=progress_handler, + ) + native_started_at = time.perf_counter() + native_payload = pdf_table_fastpath.extract_tables_from_pdf_page( + resolved_pdf_path, + page_number=resolved_page_number, + ) + native_overlay_ms = (time.perf_counter() - native_started_at) * 1000.0 + + emit_progress( + f"[mistral+pdf-cells] {resolved_pdf_path.name} | page {resolved_page_number} | mistral OCR", + progress_handler=progress_handler, + ) + mistral_started_at = time.perf_counter() + mistral_html = transcribe_table_image_with_mistral( + image_data_uri, + model_id=model_id, + prompt=prompt, + progress_handler=progress_handler, + ) + mistral_ocr_ms = (time.perf_counter() - mistral_started_at) * 1000.0 + + payload = overlay_pdf_page_html_with_native_cells( + str(mistral_html), + pdf_path=resolved_pdf_path, + page_number=resolved_page_number, + effective_model_id=( + normalize_text(getattr(mistral_html, "effective_model_id", "") or model_id or default_mistral_ocr_model_id()) + ), + native_payload=native_payload, + style_overlay_mode=style_overlay_mode, + timings_ms={ + "page_render_ms": page_render_ms, + "native_overlay_ms": native_overlay_ms, + "mistral_ocr_ms": mistral_ocr_ms, + }, + progress_handler=progress_handler, + ) + total_ms = (time.perf_counter() - total_started_at) * 1000.0 + payload["timings_ms"]["total_ms"] = round(float(total_ms), 2) + emit_progress( + f"[mistral+pdf-cells] {resolved_pdf_path.name} | page {resolved_page_number} | " + f"matched_tables={sum(1 for table in payload['tables'] if bool(table.get('matched')))}/{len(payload['tables'])} | " + f"total_ms={total_ms:.2f}", + progress_handler=progress_handler, + ) + return payload + + +def transcribe_pdf_page_to_payload( + pdf_path: str | Path, + *, + page_number: int, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + page_render_zoom: Optional[float] = None, + overlay_pdf_cells: Optional[bool] = None, + style_overlay_mode: Optional[str] = None, + max_tables: Optional[int] = None, + progress_handler: ProgressHandler = None, +) -> Dict[str, Any]: + resolved_pdf_path = Path(pdf_path).resolve() + resolved_page_number = max(1, int(page_number)) + resolved_model = normalize_text(model_id or default_pdf_page_ocr_model_id()) + if not resolved_model: + raise RuntimeError( + "Missing PDF page OCR model id. Pass model_id=... or set PDF_PAGE_OCR_MODEL_ID / MISTRAL_OCR_MODEL_ID." + ) + + if resolved_model.lower() in {"pdf_native_fastpath", "pdf_fastpath"}: + started_at = time.perf_counter() + rendered = transcribe_pdf_page_with_fastpath( + resolved_pdf_path, + page_number=resolved_page_number, + ocr_model_id=None, + prompt=prompt, + max_tables=max_tables, + progress_handler=progress_handler, + ) + return { + "html": str(rendered), + "raw_html": str(rendered), + "tables": [], + "overlay_mode": None, + "overlay_applied": False, + "style_overlay_mode": _resolve_style_overlay_mode(style_overlay_mode), + "effective_model_id": normalize_text(getattr(rendered, "effective_model_id", "") or resolved_model), + "timings_ms": { + "total_ms": round((time.perf_counter() - started_at) * 1000.0, 2), + }, + "native_payload": None, + } + + backend = resolve_table_ocr_backend(resolved_model) + if overlay_pdf_cells is None: + overlay_pdf_cells = backend == "mistral" + if backend == "mistral" and overlay_pdf_cells: + return transcribe_pdf_page_with_mistral_and_pdf_cells( + resolved_pdf_path, + page_number=resolved_page_number, + model_id=resolved_model, + prompt=prompt, + page_render_zoom=page_render_zoom, + style_overlay_mode=style_overlay_mode, + progress_handler=progress_handler, + ) + + try: + import fitz + except ImportError as exc: + raise RuntimeError("PyMuPDF is required for PDF page rendering.") from exc + + total_started_at = time.perf_counter() + resolved_zoom = max(1.0, float(page_render_zoom or _pdf_fastpath_page_render_zoom())) + emit_progress( + f"[pdf-page-ocr] {resolved_pdf_path.name} | page {resolved_page_number} | render page", + progress_handler=progress_handler, + ) + render_started_at = time.perf_counter() + with fitz.open(str(resolved_pdf_path)) as document: + page = document.load_page(resolved_page_number - 1) + image_data_uri = _render_pdf_page_data_uri( + page, + zoom=resolved_zoom, + ) + page_render_ms = (time.perf_counter() - render_started_at) * 1000.0 + + emit_progress( + f"[pdf-page-ocr] {resolved_pdf_path.name} | page {resolved_page_number} | {resolved_model}", + progress_handler=progress_handler, + ) + ocr_started_at = time.perf_counter() + rendered_html = transcribe_table_image( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + ocr_ms = (time.perf_counter() - ocr_started_at) * 1000.0 + effective_model_id = normalize_text(getattr(rendered_html, "effective_model_id", "") or resolved_model) + + if overlay_pdf_cells: + try: + import pdf_table_fastpath + except ImportError as exc: + raise RuntimeError( + "The pdf_table_fastpath module is required for PDF cell/style overlay." + ) from exc + emit_progress( + f"[pdf-page-ocr] {resolved_pdf_path.name} | page {resolved_page_number} | extract native cells", + progress_handler=progress_handler, + ) + native_started_at = time.perf_counter() + native_payload = pdf_table_fastpath.extract_tables_from_pdf_page( + resolved_pdf_path, + page_number=resolved_page_number, + ) + native_overlay_ms = (time.perf_counter() - native_started_at) * 1000.0 + payload = overlay_pdf_page_html_with_native_cells( + str(rendered_html), + pdf_path=resolved_pdf_path, + page_number=resolved_page_number, + effective_model_id=effective_model_id, + native_payload=native_payload, + style_overlay_mode=style_overlay_mode, + timings_ms={ + "page_render_ms": page_render_ms, + "ocr_ms": ocr_ms, + "native_overlay_ms": native_overlay_ms, + }, + progress_handler=progress_handler, + ) + else: + payload = { + "html": strip_code_fences(str(rendered_html)), + "raw_html": strip_code_fences(str(rendered_html)), + "tables": [], + "overlay_mode": None, + "overlay_applied": False, + "style_overlay_mode": _resolve_style_overlay_mode(style_overlay_mode), + "effective_model_id": effective_model_id, + "timings_ms": { + "page_render_ms": round(float(page_render_ms), 2), + "ocr_ms": round(float(ocr_ms), 2), + }, + "native_payload": None, + } + + total_ms = (time.perf_counter() - total_started_at) * 1000.0 + payload["timings_ms"]["total_ms"] = round(float(total_ms), 2) + emit_progress( + f"[pdf-page-ocr] {resolved_pdf_path.name} | page {resolved_page_number} | " + f"overlay={'on' if payload.get('overlay_applied') else 'off'} | total_ms={total_ms:.2f}", + progress_handler=progress_handler, + ) + return payload + + +def transcribe_pdf_page( + pdf_path: str | Path, + *, + page_number: int, + model_id: Optional[str] = None, + prompt: Optional[str] = None, + page_render_zoom: Optional[float] = None, + overlay_pdf_cells: Optional[bool] = None, + style_overlay_mode: Optional[str] = None, + max_tables: Optional[int] = None, + progress_handler: ProgressHandler = None, +) -> TableOCRTranscriptionText: + payload = transcribe_pdf_page_to_payload( + pdf_path, + page_number=page_number, + model_id=model_id, + prompt=prompt, + page_render_zoom=page_render_zoom, + overlay_pdf_cells=overlay_pdf_cells, + style_overlay_mode=style_overlay_mode, + max_tables=max_tables, + progress_handler=progress_handler, + ) + return _table_ocr_transcription_text_from_pdf_payload(payload) + + +def transcribe_pdf_page_with_fastpath( + pdf_path: str | Path, + *, + page_number: int, + ocr_model_id: Optional[str] = None, + prompt: Optional[str] = None, + max_tables: Optional[int] = None, + progress_handler: ProgressHandler = None, +) -> str: + try: + import pdf_table_fastpath + except ImportError as exc: + raise RuntimeError( + "The pdf_table_fastpath module is required for native PDF table extraction." + ) from exc + + resolved_pdf_path = Path(pdf_path).resolve() + resolved_page_number = max(1, int(page_number)) + emit_progress( + f"[pdf-fastpath] {resolved_pdf_path.name} | page {resolved_page_number}", + progress_handler=progress_handler, + ) + payload = pdf_table_fastpath.extract_tables_from_pdf_page( + resolved_pdf_path, + page_number=resolved_page_number, + ) + html_fragments = [ + str(fragment) + for fragment in payload.get("html_fragments") or [] + if normalize_text(fragment) + ] + if payload.get("mode") == "image_morphology" and payload.get("tables"): + try: + import fitz + except ImportError as exc: + raise RuntimeError("PyMuPDF is required for PDF fast-path raster fallback OCR.") from exc + + resolved_fallback_model = _pdf_fastpath_raster_fallback_model_id(ocr_model_id) + zoom = _pdf_fastpath_raster_render_zoom() + padding_pt = _pdf_fastpath_raster_padding_pt() + table_limit = max(1, int(max_tables or _pdf_fastpath_raster_max_tables())) + raster_tables = list(payload.get("tables") or [])[:table_limit] + emitted_fragments: List[str] = [] + with fitz.open(str(resolved_pdf_path)) as document: + page = document.load_page(resolved_page_number - 1) + for table_index, table_payload in enumerate(raster_tables, start=1): + bbox = table_payload.get("bbox") if isinstance(table_payload, dict) else None + if not isinstance(bbox, list) or len(bbox) != 4: + continue + emit_progress( + f"[pdf-fastpath] {resolved_pdf_path.name} | page {resolved_page_number} | raster table {table_index}/{len(raster_tables)} -> {resolved_fallback_model}", + progress_handler=progress_handler, + ) + image_data_uri = _render_pdf_table_region_data_uri( + page, + bbox=bbox, + zoom=zoom, + padding_pt=padding_pt, + ) + rendered_fragment = transcribe_table_image( + image_data_uri, + model_id=resolved_fallback_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if normalize_text(rendered_fragment): + emitted_fragments.append(strip_code_fences(str(rendered_fragment))) + if not emitted_fragments: + raise TableOCRContentError( + "PDF fast-path raster fallback found candidate regions but OCR did not return table HTML.", + details={ + "pdf_path": str(resolved_pdf_path), + "page_number": resolved_page_number, + "mode": payload.get("mode"), + "table_count": len(payload.get("tables") or []), + "ocr_model_id": resolved_fallback_model, + }, + ) + emit_progress( + f"[pdf-fastpath] {resolved_pdf_path.name} | page {resolved_page_number} | raster tables={len(emitted_fragments)}", + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + "\n".join(emitted_fragments), + effective_model_id=f"pdf_fastpath_raster+{resolved_fallback_model}", + ) + if not html_fragments: + raise TableOCRContentError( + "Native PDF fast path did not find any renderable table HTML fragments.", + details={ + "pdf_path": str(resolved_pdf_path), + "page_number": resolved_page_number, + "mode": payload.get("mode"), + "table_count": len(payload.get("tables") or []), + }, + ) + emit_progress( + f"[pdf-fastpath] {resolved_pdf_path.name} | page {resolved_page_number} | tables={len(html_fragments)}", + progress_handler=progress_handler, + ) + return TableOCRTranscriptionText( + "\n".join(html_fragments), + effective_model_id="pdf_native_fastpath", + ) + + +def transcribe_table_image( + image_data_uri: str, + *, + model_id: str, + prompt: Optional[str] = None, + progress_handler: ProgressHandler = None, +) -> str: + resolved_model = normalize_text(model_id) + if not resolved_model: + raise RuntimeError( + "Missing OCR model id. Pass an explicit model id or set DEEPSEEK_OCR_MODEL_ID / OPENROUTER_MODEL_ID." + ) + + backend = resolve_table_ocr_backend(resolved_model) + image_data_uri = _normalize_table_ocr_image_data_uri( + image_data_uri, + progress_handler=progress_handler, + ) + if backend == "firered": + return transcribe_table_image_with_firered( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "deepseek": + return transcribe_table_image_with_deepseek( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "mistral": + return transcribe_table_image_with_mistral( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "qianfan": + return transcribe_table_image_with_qianfan( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "glm_ocr": + return transcribe_table_image_with_glm_ocr( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "paddleocr_vl": + return transcribe_table_image_with_paddleocr_vl( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "got_ocr": + return transcribe_table_image_with_got_ocr( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "monkeyocr": + return transcribe_table_image_with_monkeyocr( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "qwen_ocr": + return transcribe_table_image_with_qwen_ocr( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "gemma4_hf": + return transcribe_table_image_with_gemma4_hf( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "gemma4_llamacpp": + return transcribe_table_image_with_gemma4_llamacpp( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + if backend == "gemma4_vllm": + return transcribe_table_image_with_gemma4_vllm( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + ) + return transcribe_table_image_with_openrouter( + image_data_uri, + model_id=resolved_model, + prompt=prompt, + progress_handler=progress_handler, + )