app.py

# app.py - Gradio Interface for Hugging Face Spaces
import gradio as gr
import os
import json
import shutil
import subprocess
from datetime import datetime
from pathlib import Path
from typing import Tuple

# Import our OCR functionality
from main6_pix2text import extract_all_text_advanced_pix2text, initialize_pix2text
from eval import evaluate_ocr_accuracy, clean_control_characters

def check_system_dependencies():
    """Check and report system dependencies status."""
    print("🔍 Checking system dependencies...")
    
    # Check Tesseract
    try:
        result = subprocess.run(['tesseract', '--version'], capture_output=True, text=True)
        if result.returncode == 0:
            print("✅ Tesseract is available")
        else:
            print("❌ Tesseract check failed")
    except FileNotFoundError:
        print("❌ Tesseract not found in PATH")
    
    # Check Poppler
    poppler_tools = ['pdftoppm', 'pdfinfo']
    for tool in poppler_tools:
        try:
            result = subprocess.run(['which', tool], capture_output=True, text=True)
            if result.returncode == 0:
                print(f"✅ {tool} is available")
            else:
                print(f"❌ {tool} not found")
        except FileNotFoundError:
            print(f"❌ {tool} not available")
    
    # Check pdf2image
    try:
        import importlib.util
        if importlib.util.find_spec("pdf2image") is not None:
            print("✅ pdf2image is available")
        else:
            print("❌ pdf2image module not found")
    except Exception as e:
        print(f"❌ pdf2image check failed: {e}")
    
    print(f"📍 PATH: {os.environ.get('PATH', 'NOT SET')}")

# Run dependency check on startup
check_system_dependencies()


# Initialize directories
def create_directories():
    """Create necessary directories for file storage."""
    directories = ["documents", "extracted", "temp"]
    for directory in directories:
        Path(directory).mkdir(exist_ok=True)


create_directories()


def process_pdf_ocr(pdf_file) -> Tuple[str, str, str]:
    """
    Process uploaded PDF file and extract text using advanced OCR.

    Args:
        pdf_file: Gradio file input (temporary file path)

    Returns:
        Tuple of (extracted_text, json_results, analysis_results)
    """
    if pdf_file is None:
        return "❌ No file uploaded", "", ""

    try:
        # Generate timestamp for unique naming
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

        # Get original filename
        original_name = os.path.basename(pdf_file.name)
        base_name = os.path.splitext(original_name)[0]

        # Create unique filenames
        pdf_filename = f"{base_name}_{timestamp}.pdf"
        text_filename = f"{base_name}_{timestamp}_extract.txt"
        json_filename = f"{base_name}_{timestamp}_extract.json"
        analysis_filename = f"{base_name}_{timestamp}_analysis.json"

        # Create paths
        pdf_path = Path("temp") / pdf_filename
        text_path = Path("extracted") / text_filename
        json_path = Path("extracted") / json_filename
        analysis_path = Path("extracted") / analysis_filename

        # Copy uploaded file to our temp directory
        shutil.copy2(pdf_file.name, pdf_path)

        # Process the PDF using our advanced OCR system
        extract_all_text_advanced_pix2text(
            pdf_path=str(pdf_path),
            output_text_file=str(text_path),
            output_json_file=str(json_path),
            output_analysis_file=str(analysis_path),
        )

        # Read results
        with open(text_path, "r", encoding="utf-8") as f:
            extracted_text = f.read()

        with open(json_path, "r", encoding="utf-8") as f:
            json_results = json.load(f)

        with open(analysis_path, "r", encoding="utf-8") as f:
            analysis_results = json.load(f)

        # Format results for display
        json_display = json.dumps(json_results, indent=2, ensure_ascii=False)
        analysis_display = json.dumps(analysis_results, indent=2, ensure_ascii=False)

        # Clean up temp file
        try:
            os.remove(pdf_path)
        except Exception:
            pass

        return extracted_text, json_display, analysis_display

    except Exception as e:
        error_msg = str(e)

        # Provide specific guidance for common errors
        if (
            "poppler" in error_msg.lower()
            or "unable to get page count" in error_msg.lower()
        ):
            error_msg = """❌ PDF Processing Error: Poppler not found
            
🔧 This error occurs because Poppler (PDF utilities) is not properly installed.

📋 For Hugging Face Spaces:
1. Ensure your setup.sh script runs during deployment
2. Check that poppler-utils is installed in the container
3. Verify the setup logs show successful poppler installation

💡 The setup.sh script should install these packages:
   - poppler-utils
   - libpoppler-cpp-dev
   - pkg-config

🚨 Original error: {error_msg}

🔄 Try restarting the space if this persists."""
        elif "tesseract" in error_msg.lower():
            error_msg = f"""❌ OCR Engine Error: Tesseract issue
            
🔧 This error is related to Tesseract OCR engine.

📋 Possible solutions:
1. Check Tesseract installation in setup.sh
2. Verify language data files are available
3. Ensure proper permissions on tessdata directory

🚨 Original error: {error_msg}"""
        else:
            error_msg = f"❌ Error processing PDF: {error_msg}"

        return error_msg, "", ""


def evaluate_ocr_files(extracted_file, baseline_file) -> Tuple[str, str]:
    """
    Evaluate OCR accuracy by comparing extracted text with baseline.

    Args:
        extracted_file: Gradio file input (extracted text file)
        baseline_file: Gradio file input (baseline/ground truth text file)

    Returns:
        Tuple of (evaluation_summary, detailed_results)
    """
    if extracted_file is None or baseline_file is None:
        return "❌ Please upload both files", ""

    try:
        # Read file contents
        with open(extracted_file.name, "r", encoding="utf-8") as f:
            extracted_text = f.read()

        with open(baseline_file.name, "r", encoding="utf-8") as f:
            baseline_text = f.read()

        # Clean texts
        extracted_text_clean = clean_control_characters(extracted_text)
        baseline_text_clean = clean_control_characters(baseline_text)

        # Perform evaluation
        results = evaluate_ocr_accuracy(
            extracted_text=extracted_text_clean,
            baseline_text=baseline_text_clean,
        )

        if "error" in results:
            return f"❌ Evaluation error: {results['error']}", ""

        # Create summary
        summary = f"""
📊 **OCR Evaluation Results**

🎯 **Overall Grade: {results["evaluation_summary"]["grade"]}**
📈 **Overall Accuracy: {results["overall_accuracy"]:.2f}%**
🔍 **Similarity Score: {results["similarity_score"]:.2f}%**

📝 **Character Metrics:**
- Total Characters: {results["character_metrics"]["total_chars"]}
- Correct Characters: {results["character_metrics"]["correct_chars"]}
- Character Accuracy: {results["character_metrics"]["accuracy"]:.2f}%

📄 **Word Metrics:**
- Total Words: {results["word_metrics"]["total_words"]}
- Correct Words: {results["word_metrics"]["correct_words"]}
- Word Accuracy: {results["word_metrics"]["accuracy"]:.2f}%

📋 **Line Metrics:**
- Total Lines: {results["line_metrics"]["total_lines"]}
- Correct Lines: {results["line_metrics"]["correct_lines"]}
- Line Accuracy: {results["line_metrics"]["accuracy"]:.2f}%

🌐 **Language-Specific Accuracy:**
- English: {results["language_specific"]["english"]["accuracy"]:.2f}%
- Bangla: {results["language_specific"]["bangla"]["accuracy"]:.2f}%
- Mathematical: {results["language_specific"]["math"]["accuracy"]:.2f}%

💡 **Recommendations:**
{chr(10).join(f"• {rec}" for rec in results["evaluation_summary"]["recommendations"])}
"""

        # Detailed results
        detailed = json.dumps(results, indent=2, ensure_ascii=False)

        return summary, detailed

    except Exception as e:
        error_msg = f"❌ Error during evaluation: {str(e)}"
        return error_msg, ""


# Create Gradio Interface
def create_interface():
    """Create the main Gradio interface."""

    with gr.Blocks(
        title="🔍 Advanced Multi-Language OCR System",
        theme=gr.themes.Soft(),
        css="""
        .gradio-container {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
        .header {
            text-align: center;
            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 2rem;
            border-radius: 10px;
            margin-bottom: 2rem;
        }
        """,
    ) as app:
        # Header
        gr.HTML("""
        <div class="header">
            <h1>🔍 Advanced Multi-Language OCR System</h1>
            <p>Extract text from PDFs containing English, Bangla, and Mathematical expressions</p>
            <p>Powered by Tesseract, Pix2Text, and Advanced Language Detection</p>
        </div>
        """)

        with gr.Tabs():
            # OCR Processing Tab
            with gr.Tab("📄 OCR Processing", id="ocr"):
                gr.Markdown("""
                ## 📄 PDF Text Extraction
                
                Upload a PDF file to extract text using advanced multi-language OCR technology.
                
                **Features:**
                - 🌐 Multi-language support (English, Bangla, Mathematical expressions)
                - 🧮 Advanced mathematical formula recognition with Pix2Text
                - 📊 Detailed character-by-character analysis
                - 🏷️ Automatic content classification
                """)

                with gr.Row():
                    with gr.Column():
                        pdf_input = gr.File(
                            label="📎 Upload PDF File",
                            file_types=[".pdf"],
                            file_count="single",
                        )

                        process_btn = gr.Button(
                            "🚀 Extract Text", variant="primary", size="lg"
                        )

                with gr.Row():
                    with gr.Column():
                        extracted_output = gr.Textbox(
                            label="📝 Extracted Text",
                            lines=15,
                            max_lines=20,
                            placeholder="Extracted text will appear here...",
                        )

                    with gr.Column():
                        json_output = gr.Textbox(
                            label="📋 Detailed JSON Results",
                            lines=8,
                            max_lines=15,
                            placeholder="JSON results will appear here...",
                        )

                        analysis_output = gr.Textbox(
                            label="📊 Analysis Report",
                            lines=7,
                            max_lines=10,
                            placeholder="Analysis report will appear here...",
                        )

                # Connect OCR processing
                process_btn.click(
                    fn=process_pdf_ocr,
                    inputs=[pdf_input],
                    outputs=[extracted_output, json_output, analysis_output],
                )

            # Evaluation Tab
            with gr.Tab("📊 OCR Evaluation", id="eval"):
                gr.Markdown("""
                ## 📊 OCR Accuracy Evaluation
                
                Compare extracted text with ground truth baseline to measure OCR accuracy.
                
                **Features:**
                - 🎯 Character, word, and line-level accuracy metrics
                - 🌐 Language-specific accuracy analysis
                - 📈 Overall grading system (A+ to F)
                - 💡 Improvement recommendations
                """)

                with gr.Row():
                    with gr.Column():
                        extracted_file = gr.File(
                            label="📄 Extracted Text File (.txt)",
                            file_types=[".txt"],
                            file_count="single",
                        )

                    with gr.Column():
                        baseline_file = gr.File(
                            label="📋 Baseline/Ground Truth File (.txt)",
                            file_types=[".txt"],
                            file_count="single",
                        )

                evaluate_btn = gr.Button(
                    "🔍 Evaluate Accuracy", variant="primary", size="lg"
                )

                with gr.Row():
                    with gr.Column():
                        eval_summary = gr.Textbox(
                            label="📊 Evaluation Summary",
                            lines=20,
                            max_lines=25,
                            placeholder="Evaluation summary will appear here...",
                        )

                    with gr.Column():
                        eval_detailed = gr.Textbox(
                            label="📋 Detailed Results (JSON)",
                            lines=20,
                            max_lines=25,
                            placeholder="Detailed evaluation results will appear here...",
                        )

                # Connect evaluation
                evaluate_btn.click(
                    fn=evaluate_ocr_files,
                    inputs=[extracted_file, baseline_file],
                    outputs=[eval_summary, eval_detailed],
                )

            # About Tab
            with gr.Tab("ℹ️ About", id="about"):
                gr.Markdown("""
                ## 🔍 Advanced Multi-Language OCR System
                
                ### 🌟 Overview
                This system provides state-of-the-art OCR capabilities for documents containing mixed languages and mathematical expressions.
                
                ### 🚀 Key Features
                
                #### 📄 Multi-Language OCR
                - **English**: Advanced text recognition with high accuracy
                - **Bangla**: Native Bengali script support with proper Unicode handling
                - **Mathematical**: LaTeX and formula recognition using Pix2Text
                
                #### 🧮 Advanced Math Processing
                - Integration with **Pix2Text** for superior mathematical expression recognition
                - LaTeX output for mathematical formulas
                - Support for complex equations and symbols
                
                #### 📊 Comprehensive Analysis
                - Character-by-character classification and confidence scoring
                - Language detection and content categorization
                - Detailed extraction statistics and reports
                
                #### 🎯 Accuracy Evaluation
                - Compare extracted text with ground truth baseline
                - Character, word, and line-level accuracy metrics
                - Language-specific performance analysis
                - Grading system with improvement recommendations
                
                ### 🛠️ Technology Stack
                - **OCR Engine**: Tesseract with custom language models
                - **Math Recognition**: Pix2Text for advanced mathematical expressions
                - **Language Detection**: Custom algorithms for multi-language content
                - **Backend**: FastAPI with async processing
                - **Frontend**: Gradio for interactive web interface
                
                ### 📝 Usage Tips
                
                #### For Best OCR Results:
                1. **File Quality**: Use high-resolution PDF files (300 DPI or higher)
                2. **Text Clarity**: Ensure text is clear and not blurry or distorted
                3. **Language**: The system works best with properly formatted text
                4. **Mathematical Content**: Complex formulas are processed using specialized Pix2Text models
                
                #### For Accurate Evaluation:
                1. **File Format**: Upload plain text files (.txt) in UTF-8 encoding
                2. **Content Matching**: Ensure baseline file corresponds to the same source document
                3. **Text Cleaning**: The system automatically cleans control characters
                
                ### 🔗 Links
                - **GitHub Repository**: [aaladin-ocr](https://github.com/ashfaqbracu/aaladin-ocr)
                - **Documentation**: Available in the repository
                - **Issues/Support**: Report issues on GitHub
                
                ### 📧 Contact
                For questions or support, please visit our GitHub repository or create an issue.
                
                ---
                
                **Developed with ❤️ for advanced document processing and OCR accuracy.**
                """)

        return app


# Initialize Pix2Text on startup
print("🚀 Initializing Pix2Text model...")
try:
    pix2text_model = initialize_pix2text()
    if pix2text_model:
        print("✅ Pix2Text initialized successfully")
    else:
        print("⚠️ Pix2Text initialization failed - math extraction may be limited")
except Exception as e:
    print(f"⚠️ Pix2Text initialization error: {e}")

# Create and launch the interface
if __name__ == "__main__":
    app = create_interface()

    # Launch with proper configuration for Hugging Face Spaces
    app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)