Enhanced paddle test

archive/app -og.py

@@ -0,0 +1,400 @@
+# app.py - Correct structure with monkey patch BEFORE any fitz imports
+
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import base64
+import json
+
+# SSL fix function (keep as is)
+def fix_ssl_library():
+    """Download and install libssl1.1 if not present"""
+    try:
+        if os.path.exists('/usr/lib/x86_64-linux-gnu/libssl.so.1.1'):
+            print("libssl.so.1.1 already exists")
+            return True
+            
+        print("Attempting to install libssl1.1...")
+        
+        subprocess.run([
+            'wget', '-q', 
+            'http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2_amd64.deb',
+            '-O', '/tmp/libssl1.1.deb'
+        ], check=True)
+        
+        result = subprocess.run([
+            'dpkg', '-i', '/tmp/libssl1.1.deb'
+        ], capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print("dpkg install failed, trying manual extraction...")
+            subprocess.run([
+                'dpkg', '-x', '/tmp/libssl1.1.deb', '/tmp/ssl_extract'
+            ], check=True)
+            
+            lib_path = '/tmp/ssl_extract/usr/lib/x86_64-linux-gnu'
+            current_ld_path = os.environ.get('LD_LIBRARY_PATH', '')
+            if current_ld_path:
+                os.environ['LD_LIBRARY_PATH'] = f"{lib_path}:{current_ld_path}"
+            else:
+                os.environ['LD_LIBRARY_PATH'] = lib_path
+            print(f"Set LD_LIBRARY_PATH to: {os.environ['LD_LIBRARY_PATH']}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Failed to install libssl1.1: {e}")
+        return False
+
+# CRITICAL: Apply monkey patch BEFORE importing fitz/PyMuPDF
+def monkey_patch_pymupdf():
+    """Fix PaddleOCR compatibility with newer PyMuPDF versions"""
+    print("Applying PyMuPDF compatibility patches...")
+    
+    # Import fitz here to apply patches
+    import fitz
+    
+    # Add pageCount property to Document class if it doesn't exist
+    if not hasattr(fitz.Document, 'pageCount'):
+        def pageCount_property(self):
+            return self.page_count
+        
+        fitz.Document.pageCount = property(pageCount_property)
+        print("✓ Added pageCount compatibility property to PyMuPDF Document class")
+    else:
+        print("✓ pageCount already exists")
+    
+    # Add getPixmap method to Page class if it doesn't exist
+    if not hasattr(fitz.Page, 'getPixmap'):
+        def getPixmap(self, matrix=None, alpha=True):
+            return self.get_pixmap(matrix=matrix, alpha=alpha)
+        
+        fitz.Page.getPixmap = getPixmap
+        print("✓ Added getPixmap compatibility method to PyMuPDF Page class")
+    else:
+        print("✓ getPixmap already exists")
+    
+    # Add getText method if it doesn't exist
+    if not hasattr(fitz.Page, 'getText'):
+        def getText(self, option="text"):
+            return self.get_text(option)
+        
+        fitz.Page.getText = getText
+        print("✓ Added getText compatibility method to PyMuPDF Page class")
+    else:
+        print("✓ getText already exists")
+    
+    print("✓ PyMuPDF compatibility patches applied successfully")
+
+def try_paddle_import():
+    """Try different approaches to import PaddleOCR"""
+    
+    # First try the SSL fix
+    fix_ssl_library()
+    
+    # CRITICAL: Apply PyMuPDF compatibility patches BEFORE importing PaddleOCR
+    monkey_patch_pymupdf()
+    
+    # Try importing with different environment variables
+    os.environ['PADDLE_GIT_DISABLE'] = '1'
+    
+    try:
+        from paddleocr import PaddleOCR
+        return PaddleOCR
+    except ImportError as e:
+        if 'libssl.so.1.1' in str(e):
+            print("Still having SSL issues, trying alternative PaddlePaddle version...")
+            
+            try:
+                subprocess.run([sys.executable, '-m', 'pip', 'uninstall', 'paddlepaddle', '-y'], 
+                             capture_output=True)
+                subprocess.run([sys.executable, '-m', 'pip', 'install', 'paddlepaddle==2.4.2'], 
+                             check=True)
+                from paddleocr import PaddleOCR
+                return PaddleOCR
+            except Exception as inner_e:
+                print(f"Failed to install alternative version: {inner_e}")
+                
+        print(f"PaddleOCR import failed: {e}")
+        raise e
+
+# Import Gradio
+import gradio as gr
+
+# Import PyMuPDF AFTER monkey patch is defined but BEFORE PaddleOCR
+import fitz  # This import will use the patched version
+
+# Try to import PaddleOCR with fixes
+print("Attempting to import PaddleOCR...")
+try:
+    PaddleOCR = try_paddle_import()
+    print("Loading PaddleOCR models...")
+    ocr = PaddleOCR(use_angle_cls=True, lang='en', show_log=False)
+    print("PaddleOCR models loaded successfully!")
+except Exception as e:
+    print(f"Failed to load PaddleOCR: {e}")
+    print("Application will exit - compatibility issue not resolved")
+    sys.exit(1)
+
+# Test the monkey patch
+print("Testing monkey patch...")
+test_doc = None
+try:
+    # Create a simple test to verify pageCount exists
+    import io
+    pdf_content = b"%PDF-1.4\n1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\nxref\n0 4\n0000000000 65535 f \n0000000010 00000 n \n0000000053 00000 n \n0000000100 00000 n \ntrailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n179\n%%EOF"
+    test_doc = fitz.open(stream=pdf_content, filetype="pdf")
+    
+    if hasattr(test_doc, 'pageCount'):
+        print(f"✓ Monkey patch successful! pageCount = {test_doc.pageCount}")
+    else:
+        print("✗ Monkey patch failed - pageCount not found")
+        print(f"Available attributes: {[attr for attr in dir(test_doc) if 'count' in attr.lower()]}")
+    
+    test_doc.close()
+except Exception as e:
+    print(f"Monkey patch test failed: {e}")
+    if test_doc:
+        test_doc.close()
+
+# Rest of your app code (process_document, API functions, Gradio interface, etc.)
+def process_document(file):
+    """Process uploaded document with PaddleOCR"""
+    if file is None:
+        return "No file uploaded", "", ""
+    
+    start_time = time.time()
+    
+    try:
+        filename = os.path.basename(file.name)
+        print(f"Processing: {filename}")
+        
+        file_path = file.name
+        print(f"File path: {file_path}")
+        
+        # Count pages if PDF
+        total_pages = 1
+        if filename.lower().endswith('.pdf'):
+            try:
+                print(f"Opening PDF: {file_path}")
+                doc = fitz.open(file_path)
+                
+                # Test pageCount attribute
+                print(f"Document has pageCount attribute: {hasattr(doc, 'pageCount')}")
+                print(f"Document has page_count attribute: {hasattr(doc, 'page_count')}")
+                
+                if hasattr(doc, 'pageCount'):
+                    total_pages = doc.pageCount
+                    print(f"Used pageCount: {total_pages}")
+                elif hasattr(doc, 'page_count'):
+                    total_pages = doc.page_count
+                    print(f"Used page_count: {total_pages}")
+                else:
+                    total_pages = len(doc)
+                    print(f"Used len(): {total_pages}")
+                    
+                doc.close()
+            except Exception as e:
+                print(f"PDF page counting error: {e}")
+                total_pages = 1
+        
+        # Run OCR
+        print(f"Running OCR on: {file_path}")
+        result = ocr.ocr(file_path, cls=True)
+        
+        # Extract text
+        extracted_text = ""
+        pages_processed = 0
+        
+        if result:
+            for page_idx, page_result in enumerate(result):
+                if page_result:
+                    pages_processed += 1
+                    for line in page_result:
+                        if len(line) >= 2 and line[1][1] > 0.5:
+                            extracted_text += line[1][0] + "\n"
+        
+        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
+        """
+        
+        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"
+        }, 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
+            result = ocr.ocr(tmp_file_path, cls=True)
+            
+            # Extract text
+            text = ""
+            for page_result in result:
+                if page_result:
+                    for line in page_result:
+                        if len(line) >= 2:
+                            text += line[1][0] + "\n"
+            
+            return json.dumps({
+                "success": True,
+                "text": text,
+                "filename": filename,
+                "ocr_engine": "PaddleOCR"
+            })
+            
+        finally:
+            os.unlink(tmp_file_path)
+            
+    except Exception as e:
+        return json.dumps({"success": False, "error": str(e)})
+
+# Create Gradio interface with multiple tabs
+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.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"
+    }
+  ]
+}
+                ''', 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
+        - Medical document optimization
+        - Multi-page PDF support
+        - RESTful API integration
+        - Free hosting on Hugging Face
+        - SSL compatibility fixes included
+        
+        ### 🔗 Integration URL
+        `https://mbuck17-paddleocr-processor.hf.space/api/predict`
+        """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

archive/paddle_ocr_standalone.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+# paddle_ocr_standalone.py - Robust version with comprehensive error handling
+
+import sys
+import os
+import json
+import tempfile
+import traceback
+
+def safe_print_stderr(message):
+    """Safely print to stderr"""
+    try:
+        print(message, file=sys.stderr, flush=True)
+    except:
+        pass
+
+def safe_print_json(data):
+    """Safely print JSON to stdout"""
+    try:
+        print(json.dumps(data), flush=True)
+    except Exception as e:
+        safe_print_stderr(f"Error printing JSON: {e}")
+        print('{"success": false, "error": "JSON serialization failed"}')
+
+# Check if file path was provided
+if len(sys.argv) < 2:
+    safe_print_json({"success": False, "error": "Usage: python paddle_ocr_standalone.py <file_path>"})
+    sys.exit(1)
+
+file_path = sys.argv[1]
+temp_files = []
+
+try:
+    safe_print_stderr(f"=== Starting OCR processing for: {os.path.basename(file_path)} ===")
+    
+    # Check if file exists and is readable
+    if not os.path.exists(file_path):
+        raise Exception(f"File does not exist: {file_path}")
+    
+    if not os.access(file_path, os.R_OK):
+        raise Exception(f"File is not readable: {file_path}")
+    
+    file_size = os.path.getsize(file_path)
+    safe_print_stderr(f"File size: {file_size} bytes")
+    
+    # Import dependencies one by one with error handling
+    safe_print_stderr("Importing PyMuPDF...")
+    try:
+        import fitz
+        safe_print_stderr("✓ PyMuPDF imported successfully")
+    except Exception as e:
+        raise Exception(f"Failed to import PyMuPDF: {e}")
+    
+    # Apply monkey patch for PyMuPDF compatibility
+    safe_print_stderr("Applying PyMuPDF compatibility patches...")
+    try:
+        if not hasattr(fitz.Document, 'pageCount'):
+            def pageCount_property(self):
+                return self.page_count
+            fitz.Document.pageCount = property(pageCount_property)
+            safe_print_stderr("✓ Added pageCount property")
+
+        if not hasattr(fitz.Page, 'getPixmap'):
+            def getPixmap(self, matrix=None, alpha=True):
+                return self.get_pixmap(matrix=matrix, alpha=alpha)
+            fitz.Page.getPixmap = getPixmap
+            safe_print_stderr("✓ Added getPixmap method")
+
+        if not hasattr(fitz.Page, 'getText'):
+            def getText(self, option="text"):
+                return self.get_text(option)
+            fitz.Page.getText = getText
+            safe_print_stderr("✓ Added getText method")
+            
+    except Exception as e:
+        safe_print_stderr(f"Warning: Monkey patch failed: {e}")
+    
+    # Test PDF opening
+    safe_print_stderr("Testing PDF opening...")
+    try:
+        test_doc = fitz.open(file_path)
+        page_count = len(test_doc)
+        safe_print_stderr(f"✓ PDF opened successfully, {page_count} pages detected")
+        test_doc.close()
+    except Exception as e:
+        raise Exception(f"Failed to open PDF: {e}")
+    
+    # Import PaddleOCR
+    safe_print_stderr("Importing PaddleOCR...")
+    try:
+        from paddleocr import PaddleOCR
+        safe_print_stderr("✓ PaddleOCR imported successfully")
+    except Exception as e:
+        raise Exception(f"Failed to import PaddleOCR: {e}")
+    
+    # Initialize PaddleOCR
+    safe_print_stderr("Initializing PaddleOCR...")
+    try:
+        ocr = PaddleOCR(
+            use_angle_cls=True, 
+            lang='en', 
+            show_log=False,
+            use_gpu=False
+        )
+        safe_print_stderr("✓ PaddleOCR initialized successfully")
+    except Exception as e:
+        raise Exception(f"Failed to initialize PaddleOCR: {e}")
+    
+    def pdf_to_images(pdf_path, dpi=150):
+        """Convert PDF pages to images"""
+        try:
+            safe_print_stderr(f"Converting PDF to images (DPI: {dpi})...")
+            doc = fitz.open(pdf_path)
+            image_paths = []
+            
+            total_pages = len(doc)  # Store this before we close the document
+            safe_print_stderr(f"PDF has {total_pages} pages")
+            
+            for page_num in range(total_pages):
+                try:
+                    safe_print_stderr(f"Converting page {page_num + 1}...")
+                    page = doc[page_num]
+                    
+                    # Create transformation matrix
+                    mat = fitz.Matrix(dpi/72, dpi/72)
+                    
+                    # Render page to pixmap
+                    if hasattr(page, 'getPixmap'):
+                        pix = page.getPixmap(matrix=mat)
+                    else:
+                        pix = page.get_pixmap(matrix=mat)
+                    
+                    # Save to temporary file
+                    temp_img_path = f"/tmp/ocr_page_{page_num}_{os.getpid()}.png"
+                    pix.save(temp_img_path)
+                    
+                    # Verify file creation
+                    if os.path.exists(temp_img_path):
+                        file_size = os.path.getsize(temp_img_path)
+                        safe_print_stderr(f"✓ Page {page_num + 1} converted: {temp_img_path} (size: {file_size} bytes, {pix.width}x{pix.height})")
+                        image_paths.append(temp_img_path)
+                    else:
+                        safe_print_stderr(f"✗ Failed to create image: {temp_img_path}")
+                        
+                except Exception as page_error:
+                    safe_print_stderr(f"✗ Error converting page {page_num + 1}: {page_error}")
+                    continue
+            
+            doc.close()
+            safe_print_stderr(f"✓ Successfully converted {len(image_paths)}/{total_pages} pages")
+            return image_paths
+            
+        except Exception as e:
+            safe_print_stderr(f"✗ PDF conversion failed: {e}")
+            traceback.print_exc(file=sys.stderr)
+            return []
+    
+    def cleanup_temp_files(file_paths):
+        """Clean up temporary files"""
+        for file_path in file_paths:
+            try:
+                if os.path.exists(file_path):
+                    os.unlink(file_path)
+                    safe_print_stderr(f"✓ Cleaned up: {file_path}")
+            except Exception as e:
+                safe_print_stderr(f"Warning: Could not clean up {file_path}: {e}")
+    
+    # Determine file type and convert if needed
+    is_pdf = file_path.lower().endswith('.pdf')
+    
+    if is_pdf:
+        safe_print_stderr("Processing PDF file...")
+        image_paths = pdf_to_images(file_path)
+        temp_files = image_paths
+        
+        if not image_paths:
+            raise Exception("PDF conversion produced no images")
+        
+        total_pages = len(image_paths)
+        safe_print_stderr(f"Will process {total_pages} images")
+    else:
+        safe_print_stderr("Processing image file...")
+        image_paths = [file_path]
+        total_pages = 1
+    
+    safe_print_stderr(f"TOTAL_PAGES:{total_pages}")
+    
+    # Process each image with OCR
+    safe_print_stderr("Starting OCR processing...")
+    extracted_text = ""
+    pages_processed = 0
+    
+    for i, img_path in enumerate(image_paths):
+        try:
+            current_page = i + 1
+            safe_print_stderr(f"CURRENT_PAGE:{current_page}")
+            safe_print_stderr(f"Processing image: {img_path}")
+            
+            # Verify image exists and is readable
+            if not os.path.exists(img_path):
+                safe_print_stderr(f"✗ Image file does not exist: {img_path}")
+                continue
+                
+            img_size = os.path.getsize(img_path)
+            safe_print_stderr(f"Image size: {img_size} bytes")
+            
+            # Run OCR on the image
+            safe_print_stderr(f"Running OCR on page {current_page}...")
+            result = ocr.ocr(img_path, cls=True)
+            
+            safe_print_stderr(f"OCR result type: {type(result)}")
+            if result:
+                safe_print_stderr(f"OCR result length: {len(result)}")
+                if result[0]:
+                    safe_print_stderr(f"Page {current_page} has {len(result[0])} text regions detected")
+                else:
+                    safe_print_stderr(f"Page {current_page}: OCR returned empty result")
+            else:
+                safe_print_stderr(f"Page {current_page}: OCR returned None")
+                continue
+            
+            if result and result[0]:
+                pages_processed += 1
+                page_text = ""
+                
+                for line_idx, line in enumerate(result[0]):
+                    try:
+                        if len(line) >= 2:
+                            text_content = line[1][0] if isinstance(line[1], (list, tuple)) else str(line[1])
+                            confidence = line[1][1] if isinstance(line[1], (list, tuple)) and len(line[1]) > 1 else 1.0
+                            
+                            safe_print_stderr(f"Line {line_idx}: '{text_content}' (confidence: {confidence:.2f})")
+                            
+                            if confidence > 0.3:
+                                page_text += text_content + "\n"
+                    except Exception as line_error:
+                        safe_print_stderr(f"Error processing line {line_idx}: {line_error}")
+                        continue
+                
+                if page_text.strip():
+                    extracted_text += f"\n--- Page {current_page} ---\n"
+                    extracted_text += page_text
+                    safe_print_stderr(f"✓ Page {current_page}: Added {len(page_text)} characters of text")
+                else:
+                    safe_print_stderr(f"Page {current_page}: No text above confidence threshold")
+                
+            else:
+                safe_print_stderr(f"Page {current_page}: No OCR results")
+                
+        except Exception as page_error:
+            safe_print_stderr(f"✗ Error processing page {current_page}: {page_error}")
+            traceback.print_exc(file=sys.stderr)
+            continue
+    
+    # Clean up temporary files
+    if temp_files:
+        safe_print_stderr("Cleaning up temporary files...")
+        cleanup_temp_files(temp_files)
+    
+    # Prepare final result
+    result_data = {
+        "success": True,
+        "text": extracted_text,
+        "total_pages": total_pages,
+        "pages_processed": pages_processed,
+        "method": "pdf_to_images" if is_pdf else "direct_image"
+    }
+    
+    safe_print_stderr(f"=== OCR Complete: {pages_processed}/{total_pages} pages processed ===")
+    safe_print_stderr(f"Total text length: {len(extracted_text)} characters")
+    
+    # Output final JSON result
+    safe_print_json(result_data)
+    
+except Exception as e:
+    # Clean up on error
+    if temp_files:
+        try:
+            cleanup_temp_files(temp_files)
+        except:
+            pass
+    
+    safe_print_stderr(f"=== FATAL ERROR ===")
+    safe_print_stderr(f"Error: {e}")
+    traceback.print_exc(file=sys.stderr)
+    
+    error_data = {
+        "success": False,
+        "error": str(e)
+    }
+    safe_print_json(error_data)
+    sys.exit(1)

enhanced_paddle_test.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+# enhanced_paddle_test.py - Trying to match your local implementation quality
+
+import sys
+import os
+import json
+import fitz
+from paddleocr import PaddleOCR
+
+def test_multiple_approaches():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No file path provided"}))
+        return
+    
+    file_path = sys.argv[1]
+    
+    try:
+        print(f"Testing multiple OCR approaches on: {file_path}", file=sys.stderr)
+        
+        # Test different DPI settings and OCR configurations
+        approaches = [
+            {"name": "High DPI (300)", "dpi": 300, "det_limit_side_len": 1960},
+            {"name": "Medium DPI (200)", "dpi": 200, "det_limit_side_len": 1280}, 
+            {"name": "Low DPI (150)", "dpi": 150, "det_limit_side_len": 960},
+            {"name": "Your Local Settings", "dpi": 200, "det_limit_side_len": None}
+        ]
+        
+        doc = fitz.open(file_path)
+        print(f"PDF has {len(doc)} pages", file=sys.stderr)
+        
+        all_results = {}
+        
+        for approach in approaches:
+            print(f"\n=== Testing {approach['name']} ===", file=sys.stderr)
+            
+            # Convert first page with specific DPI
+            page = doc[0]
+            mat = fitz.Matrix(approach['dpi']/72, approach['dpi']/72)
+            pix = page.get_pixmap(matrix=mat)
+            
+            temp_img = f"/tmp/test_{approach['dpi']}.png"
+            pix.save(temp_img)
+            
+            if os.path.exists(temp_img):
+                img_size = os.path.getsize(temp_img)
+                print(f"Image: {temp_img} (size: {img_size} bytes, {pix.width}x{pix.height})", file=sys.stderr)
+                
+                # Initialize OCR with specific settings
+                ocr_kwargs = {
+                    'use_angle_cls': True,
+                    'lang': 'en',
+                    'show_log': False,
+                    'use_gpu': False
+                }
+                
+                if approach['det_limit_side_len']:
+                    ocr_kwargs['det_limit_side_len'] = approach['det_limit_side_len']
+                
+                print(f"OCR settings: {ocr_kwargs}", file=sys.stderr)
+                ocr = PaddleOCR(**ocr_kwargs)
+                
+                # Run OCR
+                result = ocr.ocr(temp_img, cls=True)
+                
+                if result and result[0]:
+                    detections = len(result[0])
+                    print(f"Detections: {detections}", file=sys.stderr)
+                    
+                    # Extract all text
+                    text_parts = []
+                    for i, detection in enumerate(result[0]):
+                        if len(detection) >= 2:
+                            text = str(detection[1][0]) if isinstance(detection[1], (list, tuple)) else str(detection[1])
+                            conf = float(detection[1][1]) if isinstance(detection[1], (list, tuple)) and len(detection[1]) > 1 else 1.0
+                            
+                            if conf > 0.3:  # Lower threshold for testing
+                                text_parts.append(text)
+                                if i < 10:  # Show first 10 detections
+                                    print(f"  {i}: '{text}' ({conf:.2f})", file=sys.stderr)
+                    
+                    all_results[approach['name']] = {
+                        'detections': detections,
+                        'text': '\n'.join(text_parts),
+                        'settings': ocr_kwargs
+                    }
+                else:
+                    print("No detections", file=sys.stderr)
+                    all_results[approach['name']] = {'detections': 0, 'text': '', 'settings': ocr_kwargs}
+                
+                # Clean up
+                if os.path.exists(temp_img):
+                    os.unlink(temp_img)
+            else:
+                print(f"Failed to create image: {temp_img}", file=sys.stderr)
+        
+        doc.close()
+        
+        # Find best result
+        best_approach = max(all_results.keys(), key=lambda k: all_results[k]['detections'])
+        
+        print(f"\nBest approach: {best_approach} with {all_results[best_approach]['detections']} detections", file=sys.stderr)
+        
+        # Return the best result
+        print(json.dumps({
+            "success": True,
+            "best_approach": best_approach,
+            "all_results": all_results,
+            "text": all_results[best_approach]['text'],
+            "detections": all_results[best_approach]['detections']
+        }))
+        
+    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_multiple_approaches()