Upload 3 files

app.py

@@ -0,0 +1,149 @@
+import os
+import io
+import json
+from typing import List, Tuple, Dict, Any
+
+import fitz  # PyMuPDF
+from PIL import Image
+import gradio as gr
+
+
+# Lazy-load the OCR model to reduce startup time and memory
+_ocr_model = None
+
+
+def get_ocr_model(lang: str = "en"):
+    global _ocr_model
+    if _ocr_model is not None:
+        return _ocr_model
+
+    # PaddleOCR supports language packs like 'en', 'ch', 'fr', 'german', etc.
+    # The Spaces container will download the model weights on first run and cache them.
+    from paddleocr import PaddleOCR  # import here to avoid heavy import at startup
+
+    _ocr_model = PaddleOCR(use_angle_cls=True, lang=lang, show_log=False)
+    return _ocr_model
+
+
+def pdf_page_to_image(pdf_doc: fitz.Document, page_index: int, dpi: int = 170) -> Image.Image:
+    page = pdf_doc.load_page(page_index)
+    zoom = dpi / 72.0  # 72 dpi is PDF default
+    mat = fitz.Matrix(zoom, zoom)
+    pix = page.get_pixmap(matrix=mat, alpha=False)
+    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+    return img
+
+
+def run_paddle_ocr_on_image(image: Image.Image, lang: str = "en") -> Tuple[str, List[Dict[str, Any]]]:
+    ocr = get_ocr_model(lang=lang)
+    # Convert PIL image to numpy array for PaddleOCR
+    import numpy as np
+
+    img_np = np.array(image)
+    result = ocr.ocr(img_np, cls=True)
+
+    lines: List[str] = []
+    items: List[Dict[str, Any]] = []
+
+    # PaddleOCR returns list per image: [[(box, (text, conf)), ...]]
+    for page_result in result:
+        if page_result is None:
+            continue
+        for det in page_result:
+            box = det[0]
+            text = det[1][0]
+            conf = float(det[1][1])
+            lines.append(text)
+            items.append({"bbox": box, "text": text, "confidence": conf})
+
+    return "\n".join(lines), items
+
+
+def extract_text_from_pdf(file_obj, dpi: int = 170, max_pages: int | None = None, lang: str = "en") -> Tuple[str, str]:
+    """
+    Returns combined text and a JSON string with per-page OCR results.
+    """
+    if file_obj is None:
+        return "", json.dumps({"pages": []}, ensure_ascii=False)
+
+    # Gradio may pass a path or a tempfile.NamedTemporaryFile-like with .name
+    pdf_path = file_obj if isinstance(file_obj, str) else getattr(file_obj, "name", None)
+    if pdf_path is None or not os.path.exists(pdf_path):
+        # If bytes were passed, fall back to reading from buffer
+        file_bytes = file_obj.read() if hasattr(file_obj, "read") else None
+        if not file_bytes:
+            return "", json.dumps({"pages": []}, ensure_ascii=False)
+        pdf_doc = fitz.open(stream=file_bytes, filetype="pdf")
+    else:
+        pdf_doc = fitz.open(pdf_path)
+
+    try:
+        num_pages = pdf_doc.page_count
+        if max_pages is not None:
+            num_pages = min(num_pages, max_pages)
+
+        all_text_lines: List[str] = []
+        pages_payload: List[Dict[str, Any]] = []
+
+        for page_index in range(num_pages):
+            image = pdf_page_to_image(pdf_doc, page_index, dpi=dpi)
+            page_text, page_items = run_paddle_ocr_on_image(image, lang=lang)
+
+            all_text_lines.append(page_text)
+            pages_payload.append({
+                "page": page_index + 1,
+                "items": page_items,
+            })
+
+        combined_text = "\n\n".join([t for t in all_text_lines if t])
+        json_payload = json.dumps({"pages": pages_payload}, ensure_ascii=False)
+
+        return combined_text, json_payload
+    finally:
+        pdf_doc.close()
+
+
+def gradio_predict(pdf_file, dpi, max_pages, lang):
+    text, payload = extract_text_from_pdf(pdf_file, dpi=int(dpi), max_pages=(int(max_pages) if max_pages else None), lang=lang)
+    return text, payload
+
+
+with gr.Blocks(title="PDF OCR with PaddleOCR + PyMuPDF") as demo:
+    gr.Markdown("""
+    # PDF OCR (PaddleOCR + PyMuPDF)
+
+    Upload a PDF to extract text using OCR. Processes each page as an image rendered by PyMuPDF, then recognizes text with PaddleOCR.
+    """)
+
+    with gr.Row():
+        pdf_input = gr.File(label="PDF", file_types=[".pdf"], file_count="single")
+        with gr.Column():
+            dpi_input = gr.Slider(100, 300, value=170, step=10, label="Render DPI (higher = slower but more accurate)")
+            max_pages_input = gr.Number(value=None, label="Max pages (optional)")
+            lang_input = gr.Dropdown(choices=["en", "ch", "fr", "german", "korean", "japanese", "ta", "te", "latin"], value="en", label="OCR Language")
+
+    with gr.Row():
+        text_output = gr.Textbox(label="Extracted Text", lines=15)
+        json_output = gr.JSON(label="Per-page OCR details (bbox, text, confidence)")
+
+    run_btn = gr.Button("Run OCR")
+    run_btn.click(gradio_predict, inputs=[pdf_input, dpi_input, max_pages_input, lang_input], outputs=[text_output, json_output])
+
+    gr.Examples(
+        examples=[],
+        inputs=[pdf_input, dpi_input, max_pages_input, lang_input],
+    )
+
+    # Enable simple API for clients via gradio_client or Spaces Inference API
+    gr.Markdown("""
+    ## API usage
+    - Use `gradio_client` to call this Space programmatically.
+    - Endpoint function: `gradio_predict(pdf_file, dpi, max_pages, lang)` returning `(text, json)`.
+    """)
+
+
+if __name__ == "__main__":
+    # On Spaces, the host/port are managed by the platform. Locally, this runs on 7860 by default.
+    demo.launch()
+
+

requirements.txt

@@ -0,0 +1,10 @@
+gradio==4.42.0
+Pillow>=9.5.0
+PyMuPDF>=1.24.0
+paddlepaddle==2.6.1; platform_system != 'Windows'
+paddlepaddle==2.5.2; platform_system == 'Windows'
+paddleocr==2.7.0.3
+numpy>=1.24.0
+opencv-python-headless>=4.8.0.76
+shapely>=2.0.0
+

runtime.txt

@@ -0,0 +1,2 @@
+python-3.10
+