Update app.py

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-import spaces
+import fitz  # PyMuPDF
 from transformers import AutoModel, AutoTokenizer
 from PIL import Image
 import numpy as np
@@ -11,7 +11,9 @@ import tempfile
 import time
 import shutil
 from pathlib import Path
+import json
 
+# Load tokenizer and model
 tokenizer = AutoTokenizer.from_pretrained('ucaslcl/GOT-OCR2_0', trust_remote_code=True)
 model = AutoModel.from_pretrained('ucaslcl/GOT-OCR2_0', trust_remote_code=True, low_cpu_mem_usage=True, device_map='cuda', use_safetensors=True)
 model = model.eval().cuda()
@@ -19,6 +21,7 @@ model = model.eval().cuda()
 UPLOAD_FOLDER = "./uploads"
 RESULTS_FOLDER = "./results"
 
+# Ensure directories exist
 for folder in [UPLOAD_FOLDER, RESULTS_FOLDER]:
     if not os.path.exists(folder):
         os.makedirs(folder)
@@ -28,75 +31,44 @@ def image_to_base64(image):
     image.save(buffered, format="PNG")
     return base64.b64encode(buffered.getvalue()).decode()
 
-@spaces.GPU
-def run_GOT(image, got_mode, fine_grained_mode="", ocr_color="", ocr_box=""):
+def pdf_to_images(pdf_path):
+    images = []
+    pdf_document = fitz.open(pdf_path)
+    for page_num in range(len(pdf_document)):
+        page = pdf_document.load_page(page_num)
+        pix = page.get_pixmap()
+        img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+        images.append(img)
+    return images
+
+def run_GOT(pdf_file):
     unique_id = str(uuid.uuid4())
-    image_path = os.path.join(UPLOAD_FOLDER, f"{unique_id}.png")
-    result_path = os.path.join(RESULTS_FOLDER, f"{unique_id}.html")
+    pdf_path = os.path.join(UPLOAD_FOLDER, f"{unique_id}.pdf")
+    shutil.copy(pdf_file, pdf_path)
     
-    shutil.copy(image, image_path)
+    images = pdf_to_images(pdf_path)
+    results = []
     
     try:
-        if got_mode == "plain texts OCR":
+        for i, image in enumerate(images):
+            image_path = os.path.join(UPLOAD_FOLDER, f"{unique_id}_page_{i+1}.png")
+            image.save(image_path)
+            
             res = model.chat(tokenizer, image_path, ocr_type='ocr')
-            return res, None
-        elif got_mode == "format texts OCR":
-            res = model.chat(tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-        elif got_mode == "plain multi-crop OCR":
-            res = model.chat_crop(tokenizer, image_path, ocr_type='ocr')
-            return res, None
-        elif got_mode == "format multi-crop OCR":
-            res = model.chat_crop(tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
-        elif got_mode == "plain fine-grained OCR":
-            res = model.chat(tokenizer, image_path, ocr_type='ocr', ocr_box=ocr_box, ocr_color=ocr_color)
-            return res, None
-        elif got_mode == "format fine-grained OCR":
-            res = model.chat(tokenizer, image_path, ocr_type='format', ocr_box=ocr_box, ocr_color=ocr_color, render=True, save_render_file=result_path)
-
-        # res_markdown = f"$$ {res} $$"
-        res_markdown = res
-
-        if "format" in got_mode and os.path.exists(result_path):
-            with open(result_path, 'r') as f:
-                html_content = f.read()
-            encoded_html = base64.b64encode(html_content.encode('utf-8')).decode('utf-8')
-            iframe_src = f"data:text/html;base64,{encoded_html}"
-            iframe = f'<iframe src="{iframe_src}" width="100%" height="600px"></iframe>'
-            download_link = f'<a href="data:text/html;base64,{encoded_html}" download="result_{unique_id}.html">Download Full Result</a>'
-            return res_markdown, f"{download_link}<br>{iframe}"
-        else:
-            return res_markdown, None
+            results.append({
+                "page_number": i + 1,
+                "text": res
+            })
+            
+            if os.path.exists(image_path):
+                os.remove(image_path)
     except Exception as e:
         return f"Error: {str(e)}", None
     finally:
-        if os.path.exists(image_path):
-            os.remove(image_path)
-
-def task_update(task):
-    if "fine-grained" in task:
-        return [
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=False),
-        ]
-    else:
-        return [
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-        ]
-
-def fine_grained_update(task):
-    if task == "box":
-        return [
-            gr.update(visible=False, value = ""),
-            gr.update(visible=True),
-        ]
-    elif task == 'color':
-        return [
-            gr.update(visible=True),
-            gr.update(visible=False, value = ""),
-        ]
+        if os.path.exists(pdf_path):
+            os.remove(pdf_path)
+    
+    return json.dumps(results, indent=4)
 
 def cleanup_old_files():
     current_time = time.time()
@@ -118,83 +90,49 @@ with gr.Blocks() as demo:
     "🔥🔥🔥This is the official online demo of GOT-OCR-2.0 model!!!"
     
     ### Demo Guidelines
-    You need to upload your image below and choose one mode of GOT, then click "Submit" to run GOT model. More characters will result in longer wait times.
-    - **plain texts OCR & format texts OCR**: The two modes are for the image-level OCR.
-    - **plain multi-crop OCR & format multi-crop OCR**: For images with more complex content, you can achieve higher-quality results with these modes.
-    - **plain fine-grained OCR & format fine-grained OCR**: In these modes, you can specify fine-grained regions on the input image for more flexible OCR. Fine-grained regions can be coordinates of the box, red color, blue color, or green color.
+    You need to upload your PDF below, and the model will automatically perform plain text OCR on each page.
     """)
     
     with gr.Row():
         with gr.Column():
-            image_input = gr.Image(type="filepath", label="upload your image")
-            task_dropdown = gr.Dropdown(
-                choices=[
-                    "plain texts OCR",
-                    "format texts OCR",
-                    "plain multi-crop OCR",
-                    "format multi-crop OCR",
-                    "plain fine-grained OCR",
-                    "format fine-grained OCR",
-                ],
-                label="Choose one mode of GOT",
-                value="plain texts OCR"
-            )
-            fine_grained_dropdown = gr.Dropdown(
-                choices=["box", "color"],
-                label="fine-grained type",
-                visible=False
-            )
-            color_dropdown = gr.Dropdown(
-                choices=["red", "green", "blue"],
-                label="color list",
-                visible=False
-            )
-            box_input = gr.Textbox(
-                label="input box: [x1,y1,x2,y2]",
-                placeholder="e.g., [0,0,100,100]",
-                visible=False
-            )
+            pdf_input = gr.File(type="filepath", label="Upload your PDF")
             submit_button = gr.Button("Submit")
         
         with gr.Column():
-            ocr_result = gr.Textbox(label="GOT output")
+            ocr_result = gr.JSON(label="GOT output")
 
     with gr.Column():
-        gr.Markdown("**If you choose the mode with format, the mathpix result will be automatically rendered as follows:**")
-        html_result = gr.HTML(label="rendered html", show_label=True)
-    
-    gr.Examples(
-        examples=[
-            ["assets/coco.jpg", "plain texts OCR", "", "", ""],
-            ["assets/en_30.png", "plain texts OCR", "", "", ""],
-            ["assets/table.jpg", "format texts OCR", "", "", ""],
-            ["assets/eq.jpg", "format texts OCR", "", "", ""],
-            ["assets/exam.jpg", "format texts OCR", "", "", ""],
-            ["assets/giga.jpg", "format multi-crop OCR", "", "", ""],
-            ["assets/aff2.png", "plain fine-grained OCR", "box", "", "[409,763,756,891]"],
-            ["assets/color.png", "plain fine-grained OCR", "color", "red", ""],
-        ],
-        inputs=[image_input, task_dropdown, fine_grained_dropdown, color_dropdown, box_input],
-        outputs=[ocr_result, html_result],
-        fn=run_GOT,
-        label="examples",
-    )
+        gr.Markdown("**PDF Preview:**")
+        pdf_preview = gr.HTML(label="PDF Preview", show_label=True)
 
-    task_dropdown.change(
-        task_update,
-        inputs=[task_dropdown],
-        outputs=[fine_grained_dropdown, color_dropdown, box_input]
-    )
-    fine_grained_dropdown.change(
-        fine_grained_update,
-        inputs=[fine_grained_dropdown],
-        outputs=[color_dropdown, box_input]
-    )
-    
     submit_button.click(
         run_GOT,
-        inputs=[image_input, task_dropdown, fine_grained_dropdown, color_dropdown, box_input],
-        outputs=[ocr_result, html_result]
+        inputs=[pdf_input],
+        outputs=[ocr_result]
+    )
+
+    # Function to update PDF preview
+    def update_pdf_preview(pdf_file):
+        if not pdf_file:
+            return ""
+        pdf_path = pdf_file
+        pdf_document = fitz.open(pdf_path)
+        html_content = ""
+        for page_num in range(len(pdf_document)):
+            page = pdf_document.load_page(page_num)
+            pix = page.get_pixmap()
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            img_byte_arr = io.BytesIO()
+            img.save(img_byte_arr, format='PNG')
+            img_byte_arr = img_byte_arr.getvalue()
+            img_base64 = base64.b64encode(img_byte_arr).decode('utf-8')
+            html_content += f'<img src="data:image/png;base64,{img_base64}" width="100%"><br>'
+        return html_content
+    
+    pdf_input.change(
+        update_pdf_preview,
+        inputs=[pdf_input],
+        outputs=[pdf_preview]
     )
 
 if __name__ == "__main__":