Update app.py

app.py

@@ -1,823 +1,258 @@
-import base64
 import json
 import os
-import re
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.parse import urlparse
+import tempfile
+from typing import Any, Dict, List, Tuple
 
 import gradio as gr
-import requests
+from PIL import Image
+import fitz  # PyMuPDF
+from paddleocr import PaddleOCR
 
 
 # =========================
 # Config
 # =========================
 
-API_URL = os.environ.get("API_URL")
-TOKEN = os.environ.get("TOKEN")
-
-APP_TITLE = os.environ.get("APP_TITLE", "OCR Model Test Lab")
+APP_TITLE = os.environ.get("APP_TITLE", "DJ OCR Lab")
 APP_SUBTITLE = os.environ.get(
     "APP_SUBTITLE",
-    "Upload an image and test document parsing, element recognition, and spotting."
+    "Upload an image or PDF and run OCR locally. No API. No branding. No cloud goblin."
 )
 
-LOGO_IMAGE_PATH = os.environ.get("LOGO_IMAGE_PATH", "./assets/logo.jpg")
-EXAMPLES_BASE_URL = os.environ.get("EXAMPLES_BASE_URL") or os.environ.get("BOS_URL")
-
-GOOGLE_FONTS_URL = """
-<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
-"""
+LANG = os.environ.get("OCR_LANG", "en")
+PDF_DPI = int(os.environ.get("PDF_DPI", "200"))
 
-LATEX_DELIMS = [
-    {"left": "$$", "right": "$$", "display": True},
-    {"left": "$", "right": "$", "display": False},
-    {"left": "\\(", "right": "\\)", "display": False},
-    {"left": "\\[", "right": "\\]", "display": True},
-]
-
-AUTH_HEADER = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
-JSON_HEADERS = {
-    **AUTH_HEADER,
-    "Content-Type": "application/json",
-    "Client-Platform": "ocr-test-lab",
-}
+# Initialize OCR once when the app starts.
+# use_angle_cls helps rotated/skewed text.
+ocr = PaddleOCR(
+    use_angle_cls=True,
+    lang=LANG,
+)
 
 
 # =========================
-# Image / Example Helpers
+# File Helpers
 # =========================
 
-def image_to_base64_data_url(filepath: str) -> str:
-    try:
-        ext = os.path.splitext(filepath)[1].lower()
-        mime_types = {
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".png": "image/png",
-            ".gif": "image/gif",
-            ".webp": "image/webp",
-            ".bmp": "image/bmp",
-        }
-        mime_type = mime_types.get(ext, "image/jpeg")
-
-        with open(filepath, "rb") as image_file:
-            encoded = base64.b64encode(image_file.read()).decode("utf-8")
-
-        return f"data:{mime_type};base64,{encoded}"
-
-    except Exception as exc:
-        print(f"Error encoding image to base64: {exc}")
-        return ""
-
-
-def _get_examples_from_dir(dir_path: str) -> List[List[str]]:
-    supported_exts = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
-    examples = []
-
-    if not os.path.exists(dir_path):
-        print(f"Example directory not found: {dir_path}")
-        return []
-
-    for filename in sorted(os.listdir(dir_path)):
-        ext = os.path.splitext(filename)[1].lower()
-        if ext not in supported_exts:
-            continue
-
-        local_path = os.path.join(dir_path, filename)
-
-        if EXAMPLES_BASE_URL:
-            subdir = os.path.basename(dir_path.rstrip("/"))
-            examples.append([f"{EXAMPLES_BASE_URL.rstrip('/')}/{subdir}/{filename}"])
-        else:
-            examples.append([local_path])
-
-    return examples
-
-
-def render_uploaded_image_div(path_or_url: str) -> str:
-    if not path_or_url:
-        return ""
-
-    is_url = isinstance(path_or_url, str) and path_or_url.startswith(("http://", "https://"))
-    src = path_or_url if is_url else image_to_base64_data_url(path_or_url)
-
-    return f"""
-    <div class="uploaded-image">
-        <img
-            src="{src}"
-            alt="Preview image"
-            style="width:100%;height:100%;object-fit:contain;"
-            loading="lazy"
-        />
-    </div>
-    """
-
+def is_pdf(path: str) -> bool:
+    return path.lower().endswith(".pdf")
 
-def update_preview_visibility(path_or_url: Optional[str]) -> Dict:
-    if path_or_url:
-        return gr.update(value=render_uploaded_image_div(path_or_url), visible=True)
 
-    return gr.update(value="", visible=False)
+def is_image(path: str) -> bool:
+    return path.lower().endswith((".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"))
 
 
-# =========================
-# Markdown / Math Helpers
-# =========================
+def render_pdf_to_images(pdf_path: str, dpi: int = 200) -> List[str]:
+    """
+    Converts each PDF page to a temporary PNG image.
+    """
+    image_paths = []
 
-def _escape_inequalities_in_math(md: str) -> str:
-    math_patterns = [
-        re.compile(r"\$\$([\s\S]+?)\$\$"),
-        re.compile(r"\$([^\$]+?)\$"),
-        re.compile(r"\\\[([\s\S]+?)\\\]"),
-        re.compile(r"\\\(([\s\S]+?)\\\)"),
-    ]
+    doc = fitz.open(pdf_path)
+    zoom = dpi / 72
+    matrix = fitz.Matrix(zoom, zoom)
 
-    def fix_math_symbols(text: str) -> str:
-        text = text.replace("<=", r" \le ").replace(">=", r" \ge ")
-        text = text.replace("≤", r" \le ").replace("≥", r" \ge ")
-        text = text.replace("<", r" \lt ").replace(">", r" \gt ")
-        return text
+    for page_index in range(len(doc)):
+        page = doc.load_page(page_index)
+        pix = page.get_pixmap(matrix=matrix, alpha=False)
 
-    for pattern in math_patterns:
-        md = pattern.sub(
-            lambda match: match.group(0).replace(match.group(1), fix_math_symbols(match.group(1))),
-            md,
+        out_path = os.path.join(
+            tempfile.gettempdir(),
+            f"ocr_page_{os.path.basename(pdf_path)}_{page_index + 1}.png"
         )
 
-    return md
-
-
-# =========================
-# API Logic
-# =========================
+        pix.save(out_path)
+        image_paths.append(out_path)
 
-def _file_to_b64_image_only(path_or_url: str) -> Tuple[str, int]:
-    if not path_or_url:
-        raise ValueError("Please upload an image first.")
+    doc.close()
+    return image_paths
 
-    is_url = isinstance(path_or_url, str) and path_or_url.startswith(("http://", "https://"))
 
-    if is_url:
-        response = requests.get(path_or_url, timeout=600)
-        response.raise_for_status()
-        content = response.content
-    else:
-        with open(path_or_url, "rb") as file:
-            content = file.read()
-
-    return base64.b64encode(content).decode("utf-8"), 1
-
-
-def _call_api(
-    api_url: str,
-    path_or_url: str,
-    use_layout_detection: bool,
-    prompt_label: Optional[str],
-    use_chart_recognition: bool = False,
-    use_doc_unwarping: bool = True,
-    use_doc_orientation_classify: bool = True,
-) -> Dict[str, Any]:
-    if not api_url:
-        raise gr.Error("API_URL is not set. Add it as an environment variable.")
-
-    is_url = isinstance(path_or_url, str) and path_or_url.startswith(("http://", "https://"))
-
-    if is_url:
-        payload = {
-            "file": path_or_url,
-            "matchHistoryJob": False,
-            "useLayoutDetection": bool(use_layout_detection),
-            "useDocUnwarping": bool(use_doc_unwarping),
-            "useDocOrientationClassify": bool(use_doc_orientation_classify),
-        }
+def normalize_ocr_result(raw_result: Any) -> List[Dict[str, Any]]:
+    """
+    PaddleOCR return shapes can vary a bit by version.
+    This tries to normalize common outputs into:
+    [
+      {
+        "text": "...",
+        "confidence": 0.99,
+        "box": [...]
+      }
+    ]
+    """
+    items = []
+
+    if not raw_result:
+        return items
+
+    # Common shape:
+    # [
+    #   [
+    #     [[[x,y],...], ("text", confidence)],
+    #     ...
+    #   ]
+    # ]
+    if isinstance(raw_result, list):
+        first_layer = raw_result
+
+        # If wrapped as one page, unwrap it.
+        if len(first_layer) == 1 and isinstance(first_layer[0], list):
+            first_layer = first_layer[0]
+
+        for entry in first_layer:
+            try:
+                box = entry[0]
+                text = entry[1][0]
+                confidence = float(entry[1][1])
+
+                items.append({
+                    "text": text,
+                    "confidence": confidence,
+                    "box": box,
+                })
+            except Exception:
+                # Keep weird entries instead of losing evidence.
+                items.append({
+                    "text": str(entry),
+                    "confidence": None,
+                    "box": None,
+                })
+
+    return items
+
+
+def ocr_image(image_path: str) -> Tuple[str, List[Dict[str, Any]]]:
+    raw = ocr.ocr(image_path, cls=True)
+    items = normalize_ocr_result(raw)
+
+    text = "\n".join(item["text"] for item in items if item.get("text"))
+    return text.strip(), items
+
+
+def run_local_ocr(file_path: str) -> Tuple[str, str]:
+    if not file_path:
+        raise gr.Error("Please upload an image or PDF first.")
+
+    if not os.path.exists(file_path):
+        raise gr.Error("Uploaded file was not found.")
+
+    page_outputs = []
+    structured_outputs = []
+
+    if is_pdf(file_path):
+        image_paths = render_pdf_to_images(file_path, dpi=PDF_DPI)
+    elif is_image(file_path):
+        image_paths = [file_path]
     else:
-        b64, file_type = _file_to_b64_image_only(path_or_url)
-        payload = {
-            "file": b64,
-            "fileType": file_type,
-            "matchHistoryJob": False,
-            "useLayoutDetection": bool(use_layout_detection),
-            "useDocUnwarping": bool(use_doc_unwarping),
-            "useDocOrientationClassify": bool(use_doc_orientation_classify),
-        }
-
-    if not use_layout_detection:
-        if not prompt_label:
-            raise gr.Error("Please select a recognition type.")
-
-        payload["promptLabel"] = prompt_label.strip().lower()
-
-    if use_layout_detection and use_chart_recognition:
-        payload["useChartRecognition"] = True
-
-    try:
-        print(f"Sending OCR API request to {api_url}")
-        print(json.dumps(payload, ensure_ascii=False, default=str)[:2000])
-
-        response = requests.post(
-            api_url,
-            json=payload,
-            headers=JSON_HEADERS,
-            timeout=600,
-        )
-        response.raise_for_status()
-        data = response.json()
-
-    except Exception as exc:
-        print(exc)
-        raise gr.Error(f"API request failed: {exc}")
-
-    if data.get("errorCode", -1) != 0:
-        message = data.get("errorMsg") or data.get("message") or "API returned an error."
-        raise gr.Error(message)
-
-    return data
+        raise gr.Error("Unsupported file type. Please upload an image or PDF.")
 
+    for index, image_path in enumerate(image_paths, start=1):
+        text, items = ocr_image(image_path)
 
-def _process_api_response_page(result: Dict[str, Any]) -> Tuple[str, str, str]:
-    layout_results = (result or {}).get("layoutParsingResults", [])
+        page_outputs.append(f"## Page {index}\n\n{text or '[No text recognized]'}")
 
-    if not layout_results:
-        return "No content was recognized.", "<p>No visualization available.</p>", ""
+        structured_outputs.append({
+            "page": index,
+            "image_path": image_path,
+            "items": items,
+        })
 
-    page0 = layout_results[0] or {}
+    markdown_text = "\n\n---\n\n".join(page_outputs)
+    json_output = json.dumps(structured_outputs, indent=2, ensure_ascii=False)
 
-    md_data = page0.get("markdown") or {}
-    md_text = md_data.get("text", "") or ""
-    md_images_map = md_data.get("images", {}) or {}
-
-    for placeholder_path, image_url in md_images_map.items():
-        md_text = (
-            md_text
-            .replace(f'src="{placeholder_path}"', f'src="{image_url}"')
-            .replace(f"]({placeholder_path})", f"]({image_url})")
-        )
-
-    output_html = "<p class='empty-state'>No visualization image available.</p>"
-    output_images = page0.get("outputImages") or {}
-
-    sorted_urls = [image_url for _, image_url in sorted(output_images.items()) if image_url]
-
-    output_image_url: Optional[str] = None
-    if len(sorted_urls) >= 2:
-        output_image_url = sorted_urls[1]
-    elif sorted_urls:
-        output_image_url = sorted_urls[0]
-
-    if output_image_url:
-        output_html = f"""
-        <img
-            src="{output_image_url}"
-            alt="Detection visualization"
-            loading="lazy"
-        />
-        """
-
-    md_text = _escape_inequalities_in_math(md_text)
-
-    return md_text or "(Empty result)", output_html, md_text
-
-
-def handle_complex_doc(
-    path_or_url: str,
-    use_chart_recognition: bool,
-    use_doc_unwarping: bool,
-    use_doc_orientation_classify: bool,
-) -> Tuple[str, str, str]:
-    if not path_or_url:
-        raise gr.Error("Please upload an image first.")
-
-    data = _call_api(
-        API_URL,
-        path_or_url,
-        use_layout_detection=True,
-        prompt_label=None,
-        use_chart_recognition=use_chart_recognition,
-        use_doc_unwarping=use_doc_unwarping,
-        use_doc_orientation_classify=use_doc_orientation_classify,
-    )
-
-    return _process_api_response_page(data.get("result", {}))
-
-
-def handle_targeted_recognition(path_or_url: str, prompt_choice: str) -> Tuple[str, str, str]:
-    if not path_or_url:
-        raise gr.Error("Please upload an image first.")
-
-    mapping = {
-        "Text Recognition": "ocr",
-        "Formula Recognition": "formula",
-        "Table Recognition": "table",
-        "Chart Recognition": "chart",
-        "Spotting": "spotting",
-        "Seal Recognition": "seal",
-    }
-
-    label = mapping.get(prompt_choice, "ocr")
-
-    data = _call_api(
-        API_URL,
-        path_or_url,
-        use_layout_detection=False,
-        prompt_label=label,
-        use_doc_unwarping=False,
-        use_doc_orientation_classify=False,
-    )
-
-    result = data.get("result", {})
-
-    md_preview, _, md_raw = _process_api_response_page(result)
-    vis_html = "<p class='empty-state'>No visualization available.</p>"
-
-    if label == "spotting":
-        page0 = (result.get("layoutParsingResults") or [{}])[0] or {}
-        pruned = page0.get("prunedResult") or {}
-        spotting_res = pruned.get("spotting_res") or {}
-
-        json_raw = json.dumps(spotting_res, ensure_ascii=False, indent=2)
-
-        output_images = page0.get("outputImages") or {}
-        spotting_image_url = output_images.get("spotting_res_img")
-
-        if spotting_image_url:
-            vis_html = f"""
-            <img
-                src="{spotting_image_url}"
-                alt="Spotting visualization"
-                loading="lazy"
-            />
-            """
-
-        return md_preview, json_raw, vis_html
-
-    return md_preview, md_raw, vis_html
+    return markdown_text, json_output
 
 
 # =========================
-# Examples
-# =========================
-
-TARGETED_EXAMPLES_DIR = "examples/targeted"
-COMPLEX_EXAMPLES_DIR = "examples/complex"
-SPOTTING_EXAMPLES_DIR = "examples/spotting"
-
-targeted_recognition_examples = _get_examples_from_dir(TARGETED_EXAMPLES_DIR)
-complex_document_examples = _get_examples_from_dir(COMPLEX_EXAMPLES_DIR)
-spotting_recognition_examples = _get_examples_from_dir(SPOTTING_EXAMPLES_DIR)
-
-
-# =========================
-# CSS
+# UI
 # =========================
 
 custom_css = """
 body,
 .gradio-container {
-    font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-}
-
-.gradio-container {
-    padding: 8px 0 !important;
+    font-family: Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
 }
 
 .app-header {
     text-align: center;
-    max-width: 960px;
-    margin: 0 auto 12px !important;
-}
-
-.app-logo {
-    max-height: 72px;
-    width: auto;
-    margin: 8px auto 12px;
-    display: block;
-    border-radius: 14px;
+    max-width: 900px;
+    margin: 0 auto 16px;
 }
 
 .app-title {
-    font-size: 30px;
+    font-size: 32px;
     font-weight: 800;
-    letter-spacing: -0.03em;
-    margin: 4px 0;
+    letter-spacing: -0.04em;
 }
 
 .app-subtitle {
     color: #64748b;
     font-size: 15px;
-    margin: 0 auto;
-    max-width: 760px;
     line-height: 1.5;
+    margin-top: 6px;
+}
+
+#ocr_output {
+    max-height: 640px;
+    overflow: auto;
 }
 
 .notice {
-    margin: 10px auto 12px;
-    max-width: 960px;
+    margin: 10px auto 16px;
+    max-width: 900px;
     padding: 12px 14px;
     border: 1px solid #e5e7eb;
     border-radius: 12px;
     background: #f8fafc;
-    font-size: 14px;
-    line-height: 1.6;
     color: #334155;
-}
-
-.prompt-grid {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px;
-    margin-top: 6px;
-}
-
-.prompt-grid button {
-    height: 40px !important;
-    padding: 0 12px !important;
-    border-radius: 9px !important;
-    font-weight: 700 !important;
-    font-size: 13px !important;
-}
-
-.checkbox-row .gradio-checkbox {
-    flex-grow: 1;
-    text-align: center;
-}
-
-#image_preview_vl,
-#image_preview_doc,
-#image_preview_spot {
-    height: 400px !important;
-    overflow: auto;
-}
-
-#image_preview_vl img,
-#image_preview_doc img,
-#image_preview_spot img,
-#vis_image_doc img,
-#vis_image_spot img {
-    width: 100% !important;
-    height: auto !important;
-    object-fit: contain !important;
-    display: block;
-}
-
-#md_preview_vl,
-#md_preview_doc {
-    max-height: 540px;
-    min-height: 180px;
-    overflow: auto;
-    scrollbar-gutter: stable both-edges;
-}
-
-#md_preview_vl .prose,
-#md_preview_doc .prose {
-    line-height: 1.7 !important;
-}
-
-#md_preview_vl .prose img,
-#md_preview_doc .prose img {
-    display: block;
-    margin: 0 auto;
-    max-width: 100%;
-    height: auto;
-}
-
-.empty-state {
-    text-align: center;
-    color: #94a3b8;
-    padding: 24px;
+    font-size: 14px;
 }
 """
 
-
-# =========================
-# UI
-# =========================
-
-with gr.Blocks(
-    head=GOOGLE_FONTS_URL,
-    css=custom_css,
-    theme=gr.themes.Soft(),
-    title=APP_TITLE,
-) as demo:
-    logo_data_url = (
-        image_to_base64_data_url(LOGO_IMAGE_PATH)
-        if os.path.exists(LOGO_IMAGE_PATH)
-        else ""
-    )
-
-    logo_html = (
-        f'<img src="{logo_data_url}" alt="App logo" class="app-logo" />'
-        if logo_data_url
-        else ""
-    )
-
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft(), title=APP_TITLE) as demo:
     gr.HTML(
         f"""
         <div class="app-header">
-            {logo_html}
             <div class="app-title">{APP_TITLE}</div>
             <div class="app-subtitle">{APP_SUBTITLE}</div>
         </div>
         """
     )
 
-    if not API_URL:
-        gr.HTML(
-            """
-            <div class="notice">
-                <strong>Setup needed:</strong> API_URL is not currently set.
-                Add it as an environment variable before running OCR requests.
-            </div>
-            """
-        )
-    else:
-        gr.HTML(
-            """
-            <div class="notice">
-                <strong>Testing note:</strong> Large images and complex documents can take a little while.
-                For best results, start with a clean screenshot or scan.
-            </div>
-            """
-        )
-
-    with gr.Tabs():
-        # =====================
-        # Tab 1: Document Parsing
-        # =====================
-
-        with gr.Tab("Document Parsing"):
-            with gr.Row():
-                with gr.Column(scale=5):
-                    file_doc = gr.File(
-                        label="Upload Image",
-                        file_count="single",
-                        type="filepath",
-                        file_types=["image"],
-                    )
-
-                    preview_doc_html = gr.HTML(
-                        value="",
-                        elem_id="image_preview_doc",
-                        visible=False,
-                    )
-
-                    gr.Markdown("Use this mode for full-page documents.")
-
-                    example_url_doc = gr.State(value=None)
-
-                    with gr.Row(variant="panel"):
-                        with gr.Column(scale=2):
-                            btn_parse = gr.Button("Parse Document", variant="primary")
-
-                        with gr.Column(scale=3):
-                            with gr.Row(elem_classes=["checkbox-row"]):
-                                chart_switch = gr.Checkbox(label="Chart parsing", value=False)
-                                unwarp_switch = gr.Checkbox(label="Doc unwarping", value=False)
-                                orient_switch = gr.Checkbox(label="Orientation", value=False)
-
-                    if complex_document_examples:
-                        complex_paths = [example[0] for example in complex_document_examples]
-                        complex_state = gr.State(complex_paths)
-
-                        gallery_complex = gr.Gallery(
-                            value=complex_paths,
-                            columns=4,
-                            height=400,
-                            preview=False,
-                            label="Examples",
-                            allow_preview=False,
-                        )
-
-                        def on_gallery_doc(paths, evt: gr.SelectData):
-                            index = int(evt.index) if isinstance(evt.index, int) else evt.index[0]
-                            url = paths[index]
-                            return url, update_preview_visibility(url)
-
-                        gallery_complex.select(
-                            on_gallery_doc,
-                            complex_state,
-                            [example_url_doc, preview_doc_html],
-                        )
-
-                with gr.Column(scale=7):
-                    with gr.Tabs():
-                        with gr.Tab("Markdown Preview"):
-                            md_preview_doc = gr.Markdown(
-                                latex_delimiters=LATEX_DELIMS,
-                                elem_id="md_preview_doc",
-                            )
-
-                        with gr.Tab("Visualization"):
-                            vis_image_doc = gr.HTML(elem_id="vis_image_doc")
-
-                        with gr.Tab("Markdown Source"):
-                            md_raw_doc = gr.Code(language="markdown")
-
-            file_doc.change(
-                lambda filepath: (None, update_preview_visibility(filepath)),
-                file_doc,
-                [example_url_doc, preview_doc_html],
-            )
-
-            def parse_doc(filepath, example_url, chart, unwarp, orientation):
-                src = filepath if filepath else example_url
-
-                if not src:
-                    raise gr.Error("Please upload an image or choose an example.")
-
-                return handle_complex_doc(src, chart, unwarp, orientation)
-
-            btn_parse.click(
-                parse_doc,
-                [file_doc, example_url_doc, chart_switch, unwarp_switch, orient_switch],
-                [md_preview_doc, vis_image_doc, md_raw_doc],
-            )
-
-        # =====================
-        # Tab 2: Element Recognition
-        # =====================
-
-        with gr.Tab("Element Recognition"):
-            with gr.Row():
-                with gr.Column(scale=5):
-                    file_vl = gr.File(
-                        label="Upload Image",
-                        file_count="single",
-                        type="filepath",
-                        file_types=["image"],
-                    )
-
-                    preview_vl_html = gr.HTML(
-                        value="",
-                        elem_id="image_preview_vl",
-                        visible=False,
-                    )
-
-                    gr.Markdown("Use this mode for single elements like text blocks, tables, charts, seals, or formulas.")
-
-                    with gr.Row(elem_classes=["prompt-grid"]):
-                        btn_ocr = gr.Button("Text Recognition", variant="secondary")
-                        btn_formula = gr.Button("Formula Recognition", variant="secondary")
-
-                    with gr.Row(elem_classes=["prompt-grid"]):
-                        btn_table = gr.Button("Table Recognition", variant="secondary")
-                        btn_chart = gr.Button("Chart Recognition", variant="secondary")
-
-                    with gr.Row(elem_classes=["prompt-grid"]):
-                        btn_seal = gr.Button("Seal Recognition", variant="secondary")
-
-                    example_url_vl = gr.State(value=None)
-
-                    if targeted_recognition_examples:
-                        targeted_paths = [example[0] for example in targeted_recognition_examples]
-                        targeted_state = gr.State(targeted_paths)
-
-                        gallery_targeted = gr.Gallery(
-                            value=targeted_paths,
-                            columns=4,
-                            height=400,
-                            preview=False,
-                            label="Examples",
-                            allow_preview=False,
-                        )
-
-                        def on_gallery_vl(paths, evt: gr.SelectData):
-                            index = int(evt.index) if isinstance(evt.index, int) else evt.index[0]
-                            url = paths[index]
-                            return url, update_preview_visibility(url)
-
-                        gallery_targeted.select(
-                            on_gallery_vl,
-                            targeted_state,
-                            [example_url_vl, preview_vl_html],
-                        )
-
-                with gr.Column(scale=7):
-                    with gr.Tabs():
-                        with gr.Tab("Recognition Result"):
-                            md_preview_vl = gr.Markdown(
-                                latex_delimiters=LATEX_DELIMS,
-                                elem_id="md_preview_vl",
-                            )
-
-                        with gr.Tab("Raw Output"):
-                            md_raw_vl = gr.Code(language="markdown")
-
-                        with gr.Tab("Visualization"):
-                            hidden_vis_vl = gr.HTML(visible=False)
-
-            file_vl.change(
-                lambda filepath: (None, update_preview_visibility(filepath)),
-                file_vl,
-                [example_url_vl, preview_vl_html],
-            )
+    gr.HTML(
+        f"""
+        <div class="notice">
+            <strong>Local mode:</strong> OCR runs inside this app using PaddleOCR.
+            Current language: <code>{LANG}</code>. PDF render DPI: <code>{PDF_DPI}</code>.
+        </div>
+        """
+    )
 
-            def run_vl(filepath, example_url, prompt):
-                src = filepath if filepath else example_url
-
-                if not src:
-                    raise gr.Error("Please upload an image or choose an example.")
-
-                return handle_targeted_recognition(src, prompt)
-
-            for button, prompt in [
-                (btn_ocr, "Text Recognition"),
-                (btn_formula, "Formula Recognition"),
-                (btn_table, "Table Recognition"),
-                (btn_chart, "Chart Recognition"),
-                (btn_seal, "Seal Recognition"),
-            ]:
-                button.click(
-                    run_vl,
-                    [file_vl, example_url_vl, gr.State(prompt)],
-                    [md_preview_vl, md_raw_vl, hidden_vis_vl],
-                )
-
-        # =====================
-        # Tab 3: Spotting
-        # =====================
-
-        with gr.Tab("Spotting"):
-            with gr.Row():
-                with gr.Column(scale=5):
-                    file_spot = gr.File(
-                        label="Upload Image",
-                        file_count="single",
-                        type="filepath",
-                        file_types=["image"],
-                    )
-
-                    preview_spot_html = gr.HTML(
-                        value="",
-                        elem_id="image_preview_spot",
-                        visible=False,
-                    )
-
-                    gr.Markdown("Use this mode to detect and locate elements in the image.")
-
-                    btn_run_spot = gr.Button("Run Spotting", variant="primary")
-
-                    example_url_spot = gr.State(value=None)
-
-                    if spotting_recognition_examples:
-                        spotting_paths = [example[0] for example in spotting_recognition_examples]
-                        spot_state = gr.State(spotting_paths)
-
-                        gallery_spot = gr.Gallery(
-                            value=spotting_paths,
-                            columns=4,
-                            height=400,
-                            preview=False,
-                            label="Examples",
-                            allow_preview=False,
-                        )
-
-                        def on_gallery_spot(paths, evt: gr.SelectData):
-                            index = int(evt.index) if isinstance(evt.index, int) else evt.index[0]
-                            url = paths[index]
-                            return url, update_preview_visibility(url)
-
-                        gallery_spot.select(
-                            on_gallery_spot,
-                            spot_state,
-                            [example_url_spot, preview_spot_html],
-                        )
-
-                with gr.Column(scale=7):
-                    with gr.Tabs():
-                        with gr.Tab("Visualization"):
-                            vis_image_spot = gr.HTML(
-                                "<p class='empty-state'>No visualization yet.</p>",
-                                elem_id="vis_image_spot",
-                            )
-
-                        with gr.Tab("JSON Result"):
-                            json_spot = gr.Code(
-                                label="Detection Results",
-                                language="json",
-                            )
-
-            file_spot.change(
-                lambda filepath: (None, update_preview_visibility(filepath)),
-                file_spot,
-                [example_url_spot, preview_spot_html],
+    with gr.Row():
+        with gr.Column(scale=4):
+            upload = gr.File(
+                label="Upload image or PDF",
+                file_count="single",
+                type="filepath",
+                file_types=[".pdf", ".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"],
             )
 
-            def run_spotting_wrapper(filepath, example_url):
-                src = filepath if filepath else example_url
+            run_btn = gr.Button("Run OCR", variant="primary")
 
-                if not src:
-                    raise gr.Error("Please upload an image or choose an example.")
+        with gr.Column(scale=8):
+            with gr.Tabs():
+                with gr.Tab("Text Output"):
+                    text_output = gr.Markdown(elem_id="ocr_output")
 
-                _, json_result, visualization = handle_targeted_recognition(src, "Spotting")
-                return visualization, json_result
+                with gr.Tab("Structured Output"):
+                    json_output = gr.Code(language="json")
 
-            btn_run_spot.click(
-                fn=run_spotting_wrapper,
-                inputs=[file_spot, example_url_spot],
-                outputs=[vis_image_spot, json_spot],
-            )
+    run_btn.click(
+        fn=run_local_ocr,
+        inputs=[upload],
+        outputs=[text_output, json_output],
+    )
 
 
 if __name__ == "__main__":
-    demo.queue(max_size=64).launch()
+    demo.queue(max_size=8).launch()