openmd-cli 0.1.0__py3-none-any.whl

openmd/ocr/office.py

@@ -0,0 +1,305 @@
+"""Keep MarkItDown Office defaults; recover suspected visual/text loss locally."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from dataclasses import replace
+from pathlib import Path, PurePosixPath
+from urllib.parse import urlsplit
+from xml.etree import ElementTree
+from zipfile import BadZipFile, ZipFile
+
+from openmd.core.local_config import load_local_config
+from openmd.runtime.interpreters import owned_popen, process_options, terminate_quietly, wait_interruptibly
+from .config import settings
+
+from openmd.runtime.tempdirs import owned_temporary_directory
+
+
+_WORD_NAMESPACES = {
+    "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "http://purl.oclc.org/ooxml/wordprocessingml/main",
+}
+_REL_NAMESPACES = {
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "http://purl.oclc.org/ooxml/officeDocument/relationships",
+}
+# An exemption proves text-only use, rather than trusting a relationship Type.
+_TEXT_LINK_TAGS = {"hyperlink", "r", "t", "rPr", "rStyle", "b", "bCs", "i", "iCs",
+                   "u", "color", "sz", "szCs", "rFonts", "lang", "highlight", "vertAlign"}
+_EXTERNAL_FIELD = re.compile(r"^\s*(INCLUDEPICTURE|INCLUDETEXT|LINK)\b", re.I)
+_FIELD_TARGET = re.compile(r'''(?:[a-z][a-z0-9+.-]*://|\\\\|//)[^\s"'<>]+''', re.I)
+
+
+def _target_host(target: str) -> str | None:
+    """Retain a destination hostname without userinfo, port, path or query."""
+    try:
+        parsed = urlsplit(target.strip().replace("\\", "/"))
+        return parsed.hostname
+    except ValueError:
+        return None
+
+
+def _local_name(name: str) -> str:
+    return name.rsplit("}", 1)[-1]
+
+
+def _attribute(node, name: str) -> str:
+    prefix = node.tag.rsplit("}", 1)[0] + "}" if node.tag.startswith("{") else ""
+    return node.get(prefix + name, node.get(name, ""))
+
+
+def _field_instructions(root):
+    """Read both simple and run-split Word fields without reading display text."""
+    stack: list[list[str]] = []
+    orphans: list[str] = []
+    for node in root.iter():
+        kind = _local_name(node.tag)
+        if kind == "fldSimple":
+            yield _attribute(node, "instr")
+        elif kind == "fldChar":
+            marker = _attribute(node, "fldCharType")
+            if marker == "begin":
+                stack.append([])
+            elif marker in {"separate", "end"} and stack:
+                yield "".join(stack[-1])
+                if marker == "end":
+                    stack.pop()
+        elif kind in {"instrText", "delInstrText"}:
+            text = "".join(node.itertext())
+            if stack:
+                # Nested QUOTE/IF fields can supply a parent's resource target.
+                # Collect their instructions in every enclosing field as well.
+                for pieces in stack:
+                    pieces.append(text)
+            else:
+                orphans.append(text)
+                yield text
+    for pieces in stack:
+        yield "".join(pieces)
+    # Incomplete fields can still be acted upon by a repairing converter.
+    yield "".join(orphans)
+
+
+def _field_requires_resource(instruction: str, command_end: int) -> bool:
+    """Only exempt an explicit local drive target; dynamic/unknown fields deny.
+
+    In particular a single backslash may be a converter-repaired network path.
+    Resolving Word field expressions is not a safe preflight operation.
+    """
+    target = instruction[command_end:].strip()
+    # LINK has an application identifier before its filename. Treat it as an
+    # external dependency whenever its target cannot be proved a local path.
+    if instruction[:command_end].strip().upper() == "LINK":
+        return True
+    return not any(re.fullmatch(pattern, target) for pattern in (
+        r'''"[a-zA-Z]:[\\/][^"'\r\n:{}]+"''',
+        r"'[a-zA-Z]:[\\/][^\"'\r\n:{}]+'",
+        r'''[a-zA-Z]:[\\/][^\s"':{}]+''',
+    ))
+
+
+def _text_hyperlink(node) -> bool:
+    return bool("".join(node.itertext()).strip()) and all(
+        child.tag in {"{" + namespace + "}" + tag for namespace in _WORD_NAMESPACES for tag in _TEXT_LINK_TAGS}
+        for child in node.iter()
+    )
+
+
+def _only_text_hyperlink_references(root, relation_id: str) -> bool:
+    if root is None or not relation_id:
+        return False
+    references = []
+    for node in root.iter():
+        for attribute, value in node.attrib.items():
+            if relation_id not in value.split():
+                continue
+            references.append(
+                node.tag in {"{" + namespace + "}hyperlink" for namespace in _WORD_NAMESPACES}
+                and attribute in {"{" + namespace + "}id" for namespace in _REL_NAMESPACES}
+                and value == relation_id
+                and _text_hyperlink(node)
+            )
+    return bool(references) and all(references)
+
+
+def _relationship_source(name: str) -> str | None:
+    path = PurePosixPath(name)
+    if path.parent.name != "_rels" or path.name == ".rels":
+        return None
+    return str(path.parent.parent / path.name.removesuffix(".rels"))
+
+
+def inspect_external_resources(path: Path) -> dict:
+    """Preflight every relationship and Word field before launching LibreOffice.
+
+    Relationship targets and field contents may contain credentials; receipts only
+    contain relationship/field types and hostnames. Parsing never resolves URLs.
+    Malformed containers/parts fail closed in the caller.
+    """
+    relationship_types: set[str] = set()
+    field_types: set[str] = set()
+    target_hosts: set[str] = set()
+    inspected_parts = 0
+    hyperlinks = 0
+    with ZipFile(path) as archive:
+        roots = {}
+        for info in archive.infolist():
+            name = info.filename.replace("\\", "/")
+            if not name.lower().endswith((".rels", ".xml", ".vml")):
+                continue
+            if name in roots:
+                raise ValueError("duplicate_office_xml_part")
+            root = ElementTree.fromstring(archive.read(info))
+            roots[name] = root
+            inspected_parts += 1
+        for name, root in list(roots.items()):
+            if name.lower().endswith(".rels"):
+                source_name = _relationship_source(name)
+                source = roots.get(source_name)
+                # OPC parts need not have an .xml extension. Parse the actual
+                # referring source part before granting its exemption.
+                if source is None and source_name in archive.namelist():
+                    source = ElementTree.fromstring(archive.read(source_name))
+                    inspected_parts += 1
+                relation_ids = [node.get("Id", "") for node in root.iter() if _local_name(node.tag) == "Relationship"]
+                for node in root.iter():
+                    if _local_name(node.tag) != "Relationship" or not any(
+                        _local_name(key) == "TargetMode" and value.strip().lower() == "external"
+                        for key, value in node.attrib.items()
+                    ):
+                        continue
+                    relation_type = node.get("Type", "")
+                    relation_id = node.get("Id", "")
+                    well_formed = (relation_id == relation_id.strip()
+                                   and all(node.get(key, "").strip() for key in ("Id", "Type", "Target", "TargetMode"))
+                                   and all(key in {"Id", "Type", "Target", "TargetMode"} for key in node.attrib))
+                    if well_formed and relation_ids.count(relation_id) == 1 and _only_text_hyperlink_references(source, relation_id):
+                        hyperlinks += 1
+                    else:
+                        relationship_types.add(relation_type or "unknown")
+                        host = _target_host(node.get("Target", ""))
+                        if host:
+                            target_hosts.add(host)
+            if name.lower().startswith("word/") and name.lower().endswith((".xml", ".vml")):
+                for instruction in _field_instructions(root):
+                    match = _EXTERNAL_FIELD.match(instruction)
+                    if match and _field_requires_resource(instruction, match.end()):
+                        field_types.add(match.group(1).upper())
+                        for target in _FIELD_TARGET.findall(instruction[match.end():]):
+                            host = _target_host(target)
+                            if host:
+                                target_hosts.add(host)
+    return {
+        "blocked": bool(relationship_types or field_types),
+        "relationship_types": sorted(relationship_types),
+        "field_types": sorted(field_types),
+        "target_hosts": sorted(target_hosts),
+        "hyperlinks": hyperlinks,
+        "inspected_parts": inspected_parts,
+    }
+
+
+def soffice_path() -> str | None:
+    explicit = os.getenv("OPENMD_SOFFICE") or load_local_config().get("soffice")
+    if explicit:
+        path = Path(explicit).expanduser()
+        return str(path.resolve()) if path.is_file() else shutil.which(explicit)
+    discovered = shutil.which("soffice") or shutil.which("soffice.exe")
+    if discovered:
+        return discovered
+    for root in (os.getenv("PROGRAMFILES"), os.getenv("PROGRAMFILES(X86)")):
+        if root:
+            path = Path(root) / "LibreOffice/program/soffice.exe"
+            if path.is_file():
+                return str(path)
+    return None
+
+
+def suspected_loss(path: Path, text: str, config: dict) -> dict:
+    objects = {"images": 0, "charts": 0, "smartart": 0}
+    try:
+        with ZipFile(path) as archive:
+            names = archive.namelist()
+            objects["images"] = sum("/media/" in name and not name.endswith("/") for name in names)
+            objects["charts"] = sum(bool(re.search(r"/charts/chart\d+\.xml$", name)) for name in names)
+            objects["smartart"] = sum(bool(re.search(r"/diagrams/data\d+\.xml$", name)) for name in names)
+    except (OSError, BadZipFile):
+        return {"suspected": False, "reason": "invalid_container", **objects}
+    visible = re.sub(r"<!--.*?-->|<[^>]+>|!\[[^\]]*\]\([^)]*\)", "", text, flags=re.S)
+    visible = re.sub(r"^#{1,6} .*?$", "", visible, flags=re.M)
+    count = sum(c.isalnum() for c in visible)
+    loss = count == 0 or (sum(objects.values()) > 0 and count < config["office_sparse_chars"])
+    return {"suspected": loss, "reason": "empty_result" if count == 0 else "visual_objects_sparse_text" if loss else None, "text_chars": count, **objects}
+
+
+def recover_office(item, result, *, allow_ocr: bool, allow_external_resources: bool = False):
+    from .documents import extract_pdf
+
+    path = Path(item.raw_meta["local_path"])
+    detection = suspected_loss(path, result.text if result.has_usable_text else "", settings())
+    if not detection["suspected"]:
+        return replace(result, metadata={**result.metadata, "office_loss_check": detection})
+    resources = None
+    external_fetched = False
+
+    def external_metadata():
+        return {"office_external_resources_fetched": external_fetched,
+                **({"external_resources": resources, "external_resources_allowed": allow_external_resources} if resources is not None else {})}
+
+    def external_notes():
+        return ["Office content depends on external resources; --enable-network-backends allowed LibreOffice to fetch them. Resource availability and content may change."] if external_fetched else []
+
+    def incomplete(reason: str, extracted=None):
+        recovery = {"status": "blocked" if reason == "office_external_resource_blocked" else "unavailable", "reason": reason}
+        recovery.update(external_metadata())
+        pages = {"pages": extracted.metadata["pages"]} if extracted is not None and "pages" in extracted.metadata else {}
+        return replace(result, status="partial", error_code=reason, error_summary=reason, source_notes=[*result.source_notes, *external_notes(), "Office content may be missing: " + detection["reason"], "Office PDF recovery unavailable: " + reason + "; usable native text was retained. No automatic installation was attempted."], metadata={**result.metadata, **pages, "office_loss_check": detection, "office_external_resources_fetched": external_fetched, "office_recovery": recovery, "terminal_partial": True})
+
+    try:
+        resources = inspect_external_resources(path)
+    except (OSError, BadZipFile, ElementTree.ParseError, RuntimeError, ValueError):
+        return incomplete("office_external_resource_check_failed")
+    if resources["blocked"] and not allow_external_resources:
+        return incomplete("office_external_resource_blocked")
+    executable = soffice_path()
+
+    if not executable:
+        return incomplete("libreoffice_missing")
+    try:
+        with owned_temporary_directory(prefix="openmd-office-") as tmp:
+            directory = Path(tmp)
+            with (directory / "convert.log").open("wb") as log:
+                process = owned_popen([executable, "-env:UserInstallation=" + (directory / "profile").as_uri(), "--headless", "--convert-to", "pdf", "--outdir", str(directory), str(path.resolve())], stdin=subprocess.DEVNULL, stdout=log, stderr=log, **process_options())
+                external_fetched = bool(resources["blocked"] and allow_external_resources)
+                try:
+                    wait_interruptibly(process, 120)
+                except BaseException:
+                    terminate_quietly(process)
+                    raise
+            converted = directory / (path.stem + ".pdf")
+            if process.returncode or not converted.is_file():
+                return incomplete("libreoffice_conversion_failed")
+            document = replace(item, url=converted.as_uri(), raw_meta={**item.raw_meta, "local_path": str(converted)})
+            from .documents import _office_pdf_origin
+
+            origin = _office_pdf_origin(converted, path)
+            extracted = extract_pdf(document, allow_ocr=allow_ocr, _office_origin=origin)
+            if not extracted.has_usable_text:
+                return incomplete(extracted.error_code or "office_recovery_empty", extracted)
+            page_extractions = [{"page": page.get("page"), "route": page.get("route"), "engine": page.get("engine")} for page in extracted.metadata.get("pages", [])]
+            formula_metadata = {}
+            if path.suffix.lower() == ".docx" and page_extractions and all(page.get("route") == "textlayer" and page.get("status") == "verified" for page in extracted.metadata["pages"]):
+                from .native_math import restore_docx_math
+
+                text, formula_metadata = restore_docx_math(path, extracted.text)
+                extracted = replace(extracted, text=text)
+                if formula_metadata["restored"]:
+                    extracted = replace(extracted, source_notes=[*extracted.source_notes, "Native formula structure restored from DOCX OMML only where reliable PDF text matched uniquely, character for character except whitespace; no model was used."])
+            return replace(extracted, backend=result.backend, title=item.title, source_notes=[*extracted.source_notes, *external_notes(), "Office loss suspected; rendered locally through existing LibreOffice and extracted page by page."], metadata={**extracted.metadata, "source_format": path.suffix.lstrip("."), "office_loss_check": detection, "office_external_resources_fetched": external_fetched, "office_recovery": {"status": "completed" if extracted.status == "verified" else "partial", "converter": "LibreOffice", "page_extractions": page_extractions, **({"native_formula_restoration": formula_metadata} if formula_metadata else {}), **external_metadata()}})
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return incomplete("libreoffice_conversion_failed")

openmd/ocr/ollama.py

@@ -0,0 +1,200 @@
+"""Read-only model discovery and bounded, interruptible Ollama inference.
+
+No server lifecycle or model download operations exist in this module.
+"""
+
+from __future__ import annotations
+
+import base64
+import http.client
+import io
+import json
+import math
+import queue
+import socket
+import threading
+import time
+import urllib.request
+from urllib.parse import urlsplit
+
+from .breakers import breaker_reason, estimate_expected_chars
+from .endpoint import validate_ollama_url
+
+
+class OllamaError(RuntimeError):
+    pass
+
+
+def api_json(url: str, path: str, payload: dict | None = None, *, timeout: float = 3) -> dict:
+    url = validate_ollama_url(url)
+    data = json.dumps(payload).encode() if payload is not None else None
+    request = urllib.request.Request(url + path, data=data, headers={"Content-Type": "application/json"})
+    # Local inference must not be routed through an ambient proxy.
+    class NoRedirect(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, *args, **kwargs):
+            raise OllamaError("ocr_ollama_redirect_rejected")
+
+    with urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect()).open(request, timeout=timeout) as response:
+        result = json.load(response)
+    if not isinstance(result, dict) or result.get("error"):
+        raise OllamaError("ollama_invalid_response")
+    return result
+
+
+def model_identity(tags: dict, name: str) -> dict:
+    matches = [m for m in tags.get("models", []) if str(m.get("name", "")).removesuffix(":latest") == name.removesuffix(":latest")]
+    if len(matches) != 1 or not isinstance(matches[0].get("digest"), str) or not matches[0]["digest"]:
+        raise OllamaError("ollama_model_missing: " + name)
+    return {"name": matches[0]["name"], "digest": matches[0]["digest"]}
+
+
+def probe_ollama(config: dict) -> dict:
+    report = {"url": config["ollama_url"], "reachable": False, "models": {}, "ready": False}
+    try:
+        tags = api_json(config["ollama_url"], "/api/tags")
+        report["reachable"] = True
+        report["version"] = api_json(config["ollama_url"], "/api/version").get("version")
+        for key in ("ovis_model", "minicpm_model"):
+            try:
+                report["models"][key] = {**model_identity(tags, config[key]), "available": True}
+            except OllamaError:
+                report["models"][key] = {"name": config[key], "available": False, "digest": None}
+        report["ready"] = all(m["available"] for m in report["models"].values())
+        if not report["ready"]:
+            report["error_code"] = "ollama_model_missing"
+    except (OSError, ValueError, OllamaError) as exc:
+        report["error_code"] = getattr(exc, "code", "ollama_not_reachable")
+    return report
+
+
+def running_models(payload: dict) -> list[str]:
+    models = payload.get("models")
+    if not isinstance(models, list):
+        raise OllamaError("ollama_ps_invalid")
+    names = []
+    for model in models:
+        if not isinstance(model, dict):
+            raise OllamaError("ollama_ps_invalid")
+        name = model.get("name", model.get("model"))
+        if not isinstance(name, str) or not name.strip():
+            raise OllamaError("ollama_ps_invalid")
+        names.append(name)
+    return names
+
+
+def unload_model(config: dict, name: str) -> None:
+    """Wait for unload before another GPU engine can start."""
+    api_json(config["ollama_url"], "/api/generate", {"model": name, "keep_alive": 0, "stream": False}, timeout=15)
+    deadline = time.monotonic() + 15
+    while True:
+        running = running_models(api_json(config["ollama_url"], "/api/ps"))
+        if not any(m.removesuffix(":latest") == name.removesuffix(":latest") for m in running):
+            return
+        if time.monotonic() >= deadline:
+            raise OllamaError("ollama_unload_unconfirmed")
+        time.sleep(0.1)
+
+
+def stream_recognize(image, *, model: str, prompt: str, config: dict, deadline: float) -> dict:
+    """Read the stream on a disposable I/O thread; poll on the main thread.
+
+    Shutdown the socket on timeout/Ctrl+C/breaker before issuing unload. This
+    avoids Windows blocking socket reads masking Ctrl+C for a whole page budget.
+    """
+    config = {**config, "ollama_url": validate_ollama_url(config["ollama_url"])}
+    from PIL import Image
+
+    budget = estimate_expected_chars(image, config)
+    prepared = image.copy()
+    if prepared.width * prepared.height > config["max_pixels"]:
+        factor = math.sqrt(config["max_pixels"] / (prepared.width * prepared.height))
+        prepared = prepared.resize((max(1, int(prepared.width * factor)), max(1, int(prepared.height * factor))), Image.Resampling.LANCZOS)
+    buffer = io.BytesIO()
+    prepared.save(buffer, format="PNG")
+    payload = {"model": model, "messages": [{"role": "user", "content": prompt, "images": [base64.b64encode(buffer.getvalue()).decode("ascii")]}], "stream": True, "keep_alive": "10m", "think": False, "options": {"temperature": 0, "top_p": 0.001, "top_k": 1, "repeat_penalty": 1, "num_ctx": config["num_ctx"], "num_predict": config["num_predict"]}}
+    address = urlsplit(config["ollama_url"])
+    events: queue.Queue = queue.Queue()
+    sockets: list = []
+    canceled = threading.Event()
+
+    def read():
+        connection = None
+        try:
+            remaining = max(0.1, deadline - time.monotonic())
+            cls = http.client.HTTPSConnection if address.scheme == "https" else http.client.HTTPConnection
+            connection = cls(address.hostname, address.port, timeout=remaining)
+            connection.connect()
+            sockets.append(connection.sock)
+            if canceled.is_set():
+                return
+            connection.request("POST", address.path.rstrip("/") + "/api/chat", body=json.dumps(payload).encode(), headers={"Content-Type": "application/json"})
+            response = connection.getresponse()
+            if response.status != 200:
+                raise OllamaError(f"ollama_http_{response.status}")
+            while not canceled.is_set():
+                line = response.readline()
+                if not line:
+                    break
+                if not line.strip():
+                    continue
+                chunk = json.loads(line)
+                if chunk.get("error"):
+                    raise OllamaError("ollama_inference_error")
+                events.put(("chunk", chunk))
+                if chunk.get("done"):
+                    break
+        except Exception as exc:
+            events.put(("error", exc))
+        finally:
+            if connection is not None:
+                connection.close()
+            events.put(("end", None))
+
+    start = time.monotonic()
+    thread = threading.Thread(target=read, name="openmd-ollama-stream", daemon=True)
+    thread.start()
+    parts, final = [], {}
+    reason = None
+    try:
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                reason = {"rule": "page_deadline"}
+                break
+            try:
+                kind, value = events.get(timeout=min(0.1, remaining))
+            except queue.Empty:
+                continue
+            if kind == "error":
+                if time.monotonic() >= deadline or isinstance(value, TimeoutError):
+                    reason = {"rule": "page_deadline"}
+                    break
+                raise OllamaError("ollama_stream_failed") from value
+            if kind == "end":
+                if not final.get("done"):
+                    reason = {"rule": "stream_incomplete"}
+                break
+            content = value.get("message", {}).get("content", "")
+            if not isinstance(content, str):
+                raise OllamaError("ollama_invalid_content")
+            parts.append(content)
+            reason = breaker_reason("".join(parts), budget, config)
+            if reason:
+                break
+            if value.get("done"):
+                final = value
+                if value.get("done_reason") == "length" or value.get("eval_count", 0) >= config["num_predict"]:
+                    reason = {"rule": "token_limit", "num_predict": config["num_predict"]}
+                break
+    finally:
+        canceled.set()
+        for sock in sockets:
+            if sock:
+                try:
+                    sock.shutdown(socket.SHUT_RDWR)
+                except OSError:
+                    pass
+        thread.join(timeout=2)
+    if thread.is_alive():
+        raise OllamaError("ollama_stream_cancel_unconfirmed")
+    return {"text": "".join(parts), "seconds": round(time.monotonic() - start, 3), "breaker": reason, "tokens_generated": final.get("eval_count"), "input_size": list(prepared.size), "capacity": budget}

openmd/ocr/otsl.py

@@ -0,0 +1,51 @@
+"""Convert MiniCPM OTSL cell markers to raw HTML without adding dependencies."""
+
+from __future__ import annotations
+
+import html
+import re
+
+
+def table_html(text: str) -> str:
+    value = re.sub(r"^\s*<otsl>|</otsl>\s*$", "", text.strip())
+    if not value.startswith(("<fcel>", "<ecel>", "<lcel>", "<ucel>", "<xcel>")):
+        value = "<fcel>" + value
+    tokens = re.split(r"(<(?:fcel|ecel|lcel|ucel|xcel|nl)>)", value)
+    cells, grid = [], {}
+    row = col = 0
+    current = None
+    for token in tokens:
+        if token == "<nl>":
+            row, col, current = row + 1, 0, None
+        elif token in {"<fcel>", "<ecel>"}:
+            current = {"row": row, "col": col, "row_end": row, "col_end": col, "text": ""}
+            cells.append(current)
+            grid[row, col] = current
+            col += 1
+        elif token in {"<lcel>", "<ucel>", "<xcel>"}:
+            owner = grid.get((row, col - 1)) if token == "<lcel>" else grid.get((row - 1, col))
+            if owner is None:
+                raise ValueError("invalid OTSL span")
+            owner["row_end"] = max(owner["row_end"], row)
+            owner["col_end"] = max(owner["col_end"], col)
+            grid[row, col] = owner
+            current = None
+            col += 1
+        elif token.strip():
+            if current is None:
+                raise ValueError("invalid OTSL content")
+            current["text"] += token
+    if not cells:
+        raise ValueError("empty OTSL table")
+    lines = ["<table>"]
+    for index in range(max(c["row"] for c in cells) + 1):
+        lines.append("<tr>")
+        for cell in (c for c in cells if c["row"] == index):
+            attrs = ""
+            for attr, start, end in (("rowspan", "row", "row_end"), ("colspan", "col", "col_end")):
+                span = cell[end] - cell[start] + 1
+                if span > 1:
+                    attrs += f' {attr}="{span}"'
+            lines.append(f"<td{attrs}>{html.escape(cell['text'].strip())}</td>")
+        lines.append("</tr>")
+    return "\n".join([*lines, "</table>"])

openmd/ocr/ovis-prompt.txt

@@ -0,0 +1 @@
+Extract all readable content from the image in natural human reading order and output the result as a single Markdown document. For charts or images, represent them using an HTML image tag: <img src="images/bbox_{left}_{top}_{right}_{bottom}.jpg" />, where left, top, right, bottom are bounding box coordinates scaled to [0, 1000). Format formulas as LaTeX. Format tables as HTML: <table>...</table>. Transcribe all other text as standard Markdown. Preserve the original text without translation or paraphrasing.