Minimal test edition

app.py

@@ -1,298 +1,64 @@
-# app.py - Using subprocess approach like your local Node.js implementation
-
-import os
 import subprocess
-import sys
-import tempfile
-import time
-import base64
 import json
-
-# Import Gradio
+import sys
 import gradio as gr
 
-def run_paddle_ocr_subprocess(file_path):
-    """Run PaddleOCR as a subprocess - mirrors your local Node.js approach"""
+def test_ocr_minimal(file):
+    if file is None:
+        return "No file uploaded", ""
+    
     try:
-        # Get the path to our standalone OCR script
-        script_path = os.path.join(os.path.dirname(__file__), 'paddle_ocr_standalone.py')
-        
-        # Run the subprocess - exactly like your Node.js implementation
-        command = [sys.executable, script_path, file_path]
+        # Run the minimal test script
+        script_path = "/home/user/app/minimal_test_paddle.py"
+        command = [sys.executable, script_path, file.name]
         
-        print(f"Running command: {' '.join(command)}")
+        print(f"Running: {' '.join(command)}")
         
-        # Track progress
-        total_pages = 1
-        current_page = 0
-        
-        process = subprocess.Popen(
+        process = subprocess.run(
             command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            capture_output=True,
             text=True,
-            bufsize=1,
-            universal_newlines=True
+            timeout=120
         )
         
-        # Read stderr for progress updates (like your Node.js implementation)
-        stderr_output = ""
-        while True:
-            stderr_line = process.stderr.readline()
-            if not stderr_line:
-                break
-                
-            stderr_output += stderr_line
-            
-            if stderr_line.startswith('TOTAL_PAGES:'):
-                total_pages = int(stderr_line.split(':')[1].strip())
-                print(f"Processing document with {total_pages} pages")
-                
-            elif stderr_line.startswith('CURRENT_PAGE:'):
-                current_page = int(stderr_line.split(':')[1].strip())
-                print(f"Processing page {current_page} of {total_pages}")
-        
-        # Wait for process to complete and get stdout
-        stdout, remaining_stderr = process.communicate()
-        
-        if process.returncode != 0:
-            print(f"OCR process failed with return code {process.returncode}")
-            print(f"stderr: {stderr_output + remaining_stderr}")
-            return {
-                "success": False,
-                "error": f"OCR process failed: {stderr_output + remaining_stderr}"
-            }
-        
-        # Parse the JSON result from stdout
-        try:
-            result = json.loads(stdout.strip())
-            print(f"OCR completed successfully: {result.get('pages_processed', 0)}/{result.get('total_pages', 0)} pages")
-            return result
-        except json.JSONDecodeError as e:
-            print(f"Failed to parse OCR result: {e}")
-            print(f"stdout: {stdout}")
-            return {
-                "success": False,
-                "error": f"Failed to parse OCR result: {str(e)}"
-            }
+        print(f"Return code: {process.returncode}")
+        print(f"Stderr: {process.stderr}")
+        print(f"Stdout: {process.stdout}")
+        
+        if process.returncode == 0:
+            try:
+                result = json.loads(process.stdout.strip())
+                summary = f"""
+**Success!**
+- Detections: {result.get('detections', 0)}
+- Text length: {len(result.get('text', ''))}
+"""
+                return summary, result.get('text', '')
+            except json.JSONDecodeError:
+                return f"JSON parse error. Stdout: {process.stdout}", ""
+        else:
+            return f"Process failed with code {process.returncode}\nStderr: {process.stderr}", ""
             
     except Exception as e:
-        print(f"Error running OCR subprocess: {e}")
-        return {
-            "success": False,
-            "error": str(e)
-        }
+        return f"Error: {e}", ""
 
-def process_document(file):
-    """Process uploaded document using subprocess OCR"""
-    if file is None:
-        return "No file uploaded", "", ""
+# Simple Gradio interface for testing
+with gr.Blocks(title="OCR Test") as demo:
+    gr.Markdown("# Simple OCR Test")
     
-    start_time = time.time()
+    with gr.Row():
+        file_input = gr.File(label="Upload PDF", file_types=[".pdf"])
+        test_btn = gr.Button("Test OCR")
     
-    try:
-        filename = os.path.basename(file.name)
-        print(f"Processing: {filename}")
-        
-        file_path = file.name
-        print(f"File path: {file_path}")
-        
-        # Run OCR using subprocess (like your Node.js implementation)
-        ocr_result = run_paddle_ocr_subprocess(file_path)
-        
-        if not ocr_result.get("success", False):
-            error_msg = f"❌ OCR failed: {ocr_result.get('error', 'Unknown error')}"
-            return error_msg, "", json.dumps(ocr_result)
-        
-        # Extract results
-        extracted_text = ocr_result.get("text", "")
-        pages_processed = ocr_result.get("pages_processed", 0)
-        total_pages = ocr_result.get("total_pages", 1)
-        
-        processing_time = time.time() - start_time
-        
-        summary = f"""
-📄 **File**: {filename}
-📊 **Pages Processed**: {pages_processed}/{total_pages}
-⏱️ **Processing Time**: {processing_time:.2f} seconds
-📝 **Text Length**: {len(extracted_text)} characters
-🔧 **OCR Engine**: PaddleOCR (Subprocess)
-✅ **Method**: Subprocess execution (like your local Node.js implementation)
-        """
-        
-        api_response = json.dumps({
-            "success": True,
-            "text": extracted_text,
-            "filename": filename,
-            "pages_processed": pages_processed,
-            "total_pages": total_pages,
-            "processing_time": processing_time,
-            "ocr_engine": "PaddleOCR",
-            "method": "subprocess"
-        }, indent=2)
-        
-        return summary, extracted_text, api_response
-        
-    except Exception as e:
-        error_msg = f"❌ Error processing file: {str(e)}"
-        print(f"Full error: {e}")
-        import traceback
-        traceback.print_exc()
-        return error_msg, "", json.dumps({"success": False, "error": str(e)})
-
-def process_api_request(api_data):
-    """Process API-style requests (for integration with your Vercel app)"""
-    try:
-        data = json.loads(api_data)
-        
-        if 'file' not in data:
-            return json.dumps({"success": False, "error": "No file data provided"})
-        
-        # Decode base64 file
-        file_data = base64.b64decode(data['file'])
-        filename = data.get('filename', 'unknown.pdf')
-        
-        # Save to temp file
-        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(filename)[1]) as tmp_file:
-            tmp_file.write(file_data)
-            tmp_file_path = tmp_file.name
-        
-        try:
-            # Run OCR using subprocess
-            ocr_result = run_paddle_ocr_subprocess(tmp_file_path)
-            
-            if ocr_result.get("success", False):
-                return json.dumps({
-                    "success": True,
-                    "text": ocr_result.get("text", ""),
-                    "filename": filename,
-                    "pages_processed": ocr_result.get("pages_processed", 0),
-                    "total_pages": ocr_result.get("total_pages", 1),
-                    "ocr_engine": "PaddleOCR",
-                    "method": "subprocess"
-                })
-            else:
-                return json.dumps(ocr_result)
-            
-        finally:
-            os.unlink(tmp_file_path)
-            
-    except Exception as e:
-        return json.dumps({"success": False, "error": str(e)})
-
-# Create Gradio interface
-with gr.Blocks(title="PaddleOCR Medical Document Processor") as demo:
-    gr.Markdown("# 🏥 PaddleOCR Medical Document Processor")
-    gr.Markdown("Upload medical documents (PDF/images) to extract text using PaddleOCR")
-    
-    with gr.Tab("📄 File Upload"):
-        with gr.Row():
-            with gr.Column():
-                file_input = gr.File(
-                    label="Upload Document (PDF, JPG, PNG)",
-                    file_types=[".pdf", ".jpg", ".jpeg", ".png"]
-                )
-                process_btn = gr.Button("🔍 Process Document", variant="primary")
-            
-            with gr.Column():
-                summary_output = gr.Markdown(label="📊 Processing Summary")
-        
-        with gr.Row():
-            text_output = gr.Textbox(
-                label="📝 Extracted Text",
-                lines=15,
-                max_lines=20
-            )
-        
-        process_btn.click(
-            fn=process_document,
-            inputs=[file_input],
-            outputs=[summary_output, text_output, gr.Textbox(visible=False)]
-        )
+    with gr.Row():
+        summary_output = gr.Markdown(label="Summary")
+        text_output = gr.Textbox(label="Extracted Text", lines=10)
     
-    with gr.Tab("🔌 API Integration"):
-        gr.Markdown("### For integration with your Vercel app:")
-        gr.Markdown("**Endpoint**: `https://mbuck17-paddleocr-processor.hf.space/api/predict`")
-        gr.Markdown("**Method**: POST")
-        gr.Markdown("**Headers**: `Content-Type: application/json`")
-        
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("**Sample Request:**")
-                gr.Code('''
-{
-  "data": [
-    {
-      "file": "base64_encoded_file_data_here",
-      "filename": "lab_report.pdf"
-    }
-  ]
-}
-                ''', language="json")
-            
-            with gr.Column():
-                gr.Markdown("**Sample Response:**")
-                gr.Code('''
-{
-  "data": [
-    {
-      "success": true,
-      "text": "Extracted text content...",
-      "filename": "lab_report.pdf",
-      "ocr_engine": "PaddleOCR",
-      "method": "subprocess"
-    }
-  ]
-}
-                ''', language="json")
-        
-        gr.Markdown("### Test API Request:")
-        api_input = gr.Textbox(
-            label="API Request (JSON)",
-            placeholder='{"file": "base64_encoded_file_data", "filename": "document.pdf"}',
-            lines=5
-        )
-        api_btn = gr.Button("🧪 Test API Request")
-        api_output = gr.Textbox(
-            label="API Response (JSON)",
-            lines=10
-        )
-        
-        api_btn.click(
-            fn=process_api_request,
-            inputs=[api_input],
-            outputs=[api_output]
-        )
-    
-    with gr.Tab("ℹ️ About"):
-        gr.Markdown("""
-        ### 🎯 Purpose
-        This service extracts text from medical documents using PaddleOCR, specifically designed for lab reports and medical forms.
-        
-        ### 🔧 Integration
-        This Hugging Face Space can be integrated with your Vercel app as an external OCR service.
-        
-        ### 📚 Supported Formats
-        - PDF documents (multi-page)
-        - JPEG/JPG images
-        - PNG images
-        
-        ### 🚀 Features
-        - High accuracy OCR with PaddleOCR
-        - Subprocess execution (mirrors your local Node.js implementation)
-        - Medical document optimization
-        - Multi-page PDF support
-        - RESTful API integration
-        - Free hosting on Hugging Face
-        
-        ### 🔗 Integration URL
-        `https://mbuck17-paddleocr-processor.hf.space/api/predict`
-        
-        ### ⚙️ Architecture
-        This implementation uses subprocess execution just like your local Node.js version, 
-        ensuring maximum compatibility with PaddleOCR's PDF processing capabilities.
-        """)
+    test_btn.click(
+        fn=test_ocr_minimal,
+        inputs=[file_input],
+        outputs=[summary_output, text_output]
+    )
 
-# Launch the app
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)

minimal_test_paddle.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# minimal_test_paddle.py - Minimal test to isolate the OCR issue
+
+import sys
+import os
+import json
+import fitz
+from paddleocr import PaddleOCR
+
+def test_ocr():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No file path provided"}))
+        return
+    
+    file_path = sys.argv[1]
+    
+    try:
+        print(f"Testing OCR on: {file_path}", file=sys.stderr)
+        
+        # Test 1: Can we open the PDF?
+        print("Opening PDF...", file=sys.stderr)
+        doc = fitz.open(file_path)
+        print(f"PDF has {len(doc)} pages", file=sys.stderr)
+        
+        # Test 2: Convert first page to image
+        print("Converting first page to image...", file=sys.stderr)
+        page = doc[0]
+        mat = fitz.Matrix(150/72, 150/72)
+        pix = page.get_pixmap(matrix=mat)
+        
+        temp_img = "/tmp/test_page.png"
+        pix.save(temp_img)
+        
+        if os.path.exists(temp_img):
+            img_size = os.path.getsize(temp_img)
+            print(f"Image created: {temp_img} (size: {img_size} bytes, {pix.width}x{pix.height})", file=sys.stderr)
+        else:
+            print("Failed to create image", file=sys.stderr)
+            doc.close()
+            return
+        
+        doc.close()
+        
+        # Test 3: Initialize OCR
+        print("Initializing OCR...", file=sys.stderr)
+        ocr = PaddleOCR(use_angle_cls=True, lang='en', show_log=False)
+        print("OCR initialized", file=sys.stderr)
+        
+        # Test 4: Run OCR on the image
+        print("Running OCR...", file=sys.stderr)
+        result = ocr.ocr(temp_img, cls=True)
+        
+        print(f"OCR result type: {type(result)}", file=sys.stderr)
+        if result:
+            print(f"Result length: {len(result)}", file=sys.stderr)
+            if result[0]:
+                print(f"First page has {len(result[0])} detections", file=sys.stderr)
+                
+                # Print all detected text
+                for i, detection in enumerate(result[0]):
+                    if len(detection) >= 2:
+                        text = detection[1][0] if isinstance(detection[1], (list, tuple)) else str(detection[1])
+                        conf = detection[1][1] if isinstance(detection[1], (list, tuple)) and len(detection[1]) > 1 else 1.0
+                        print(f"Detection {i}: '{text}' (confidence: {conf})", file=sys.stderr)
+            else:
+                print("First page result is empty", file=sys.stderr)
+        else:
+            print("OCR returned None", file=sys.stderr)
+        
+        # Clean up
+        if os.path.exists(temp_img):
+            os.unlink(temp_img)
+        
+        # Return simple result
+        text_found = ""
+        if result and result[0]:
+            for detection in result[0]:
+                if len(detection) >= 2:
+                    text_found += detection[1][0] + "\n"
+        
+        print(json.dumps({
+            "success": True,
+            "text": text_found,
+            "detections": len(result[0]) if result and result[0] else 0
+        }))
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
+        print(json.dumps({"success": False, "error": str(e)}))
+
+if __name__ == "__main__":
+    test_ocr()