Update app.py

app.py

@@ -41,6 +41,336 @@ if not ADMIN_PASSWORD_HASH:
 # Excel file path for logs
 EXCEL_LOG_PATH = "/tmp/prediction_logs.xlsx"
 
+
+import requests
+import base64
+import os
+import tempfile
+from typing import Dict, List, Optional, Union, Tuple
+import mimetypes
+import logging
+import time
+from pathlib import Path
+
+# OCR API settings
+OCR_API_KEY = "9e11346f1288957"  # This is a partial key - replace with the full one
+OCR_API_ENDPOINT = "https://api.ocr.space/parse/image"
+OCR_MAX_PDF_PAGES = 3
+OCR_MAX_FILE_SIZE_MB = 1
+
+# Configure logging for OCR module
+ocr_logger = logging.getLogger("ocr_module")
+ocr_logger.setLevel(logging.INFO)
+
+class OCRProcessor:
+    """
+    Handles OCR processing of image and document files using OCR.space API
+    """
+    def __init__(self, api_key: str = OCR_API_KEY):
+        self.api_key = api_key
+        self.endpoint = OCR_API_ENDPOINT
+        
+    def process_file(self, file_path: str) -> Dict:
+        """
+        Process a file using OCR.space API
+        
+        Args:
+            file_path: Path to the file to be processed
+            
+        Returns:
+            Dictionary containing the OCR results and status
+        """
+        start_time = time.time()
+        ocr_logger.info(f"Starting OCR processing for file: {os.path.basename(file_path)}")
+        
+        # Validate file size
+        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
+        if file_size_mb > OCR_MAX_FILE_SIZE_MB:
+            ocr_logger.warning(f"File size ({file_size_mb:.2f} MB) exceeds limit of {OCR_MAX_FILE_SIZE_MB} MB")
+            return {
+                "success": False,
+                "error": f"File size ({file_size_mb:.2f} MB) exceeds limit of {OCR_MAX_FILE_SIZE_MB} MB",
+                "text": ""
+            }
+        
+        # Determine file type and handle accordingly
+        file_type = self._get_file_type(file_path)
+        ocr_logger.info(f"Detected file type: {file_type}")
+        
+        # Special handling for Word documents - convert to PDF if needed
+        if file_type.startswith('application/vnd.openxmlformats-officedocument') or file_type == 'application/msword':
+            ocr_logger.info("Word document detected, processing directly")
+            # Note: OCR.space may handle Word directly, but if not, conversion would be needed here
+        
+        # Prepare the API request
+        with open(file_path, 'rb') as f:
+            file_data = f.read()
+            
+        # Set up API parameters
+        payload = {
+            'isOverlayRequired': 'false',
+            'language': 'eng',
+            'OCREngine': '2',  # Use more accurate engine
+            'scale': 'true',
+            'detectOrientation': 'true',
+        }
+        
+        # For PDF files, check page count limitations
+        if file_type == 'application/pdf':
+            ocr_logger.info("PDF document detected, enforcing page limit")
+            payload['filetype'] = 'PDF'
+        
+        # Prepare file for OCR API
+        files = {
+            'file': (os.path.basename(file_path), file_data, file_type)
+        }
+        
+        headers = {
+            'apikey': self.api_key,
+        }
+        
+        # Make the OCR API request
+        try:
+            ocr_logger.info("Sending request to OCR.space API")
+            response = requests.post(
+                self.endpoint, 
+                files=files,
+                data=payload,
+                headers=headers
+            )
+            response.raise_for_status()
+            result = response.json()
+            
+            # Process the OCR results
+            if result.get('OCRExitCode') in [1, 2]:  # Success or partial success
+                extracted_text = self._extract_text_from_result(result)
+                processing_time = time.time() - start_time
+                ocr_logger.info(f"OCR processing completed in {processing_time:.2f} seconds")
+                
+                return {
+                    "success": True,
+                    "text": extracted_text,
+                    "word_count": len(extracted_text.split()),
+                    "processing_time_ms": int(processing_time * 1000)
+                }
+            else:
+                ocr_logger.error(f"OCR API error: {result.get('ErrorMessage', 'Unknown error')}")
+                return {
+                    "success": False,
+                    "error": result.get('ErrorMessage', 'OCR processing failed'),
+                    "text": ""
+                }
+                
+        except requests.exceptions.RequestException as e:
+            ocr_logger.error(f"OCR API request failed: {str(e)}")
+            return {
+                "success": False,
+                "error": f"OCR API request failed: {str(e)}",
+                "text": ""
+            }
+    
+    def _extract_text_from_result(self, result: Dict) -> str:
+        """
+        Extract all text from the OCR API result
+        
+        Args:
+            result: The OCR API response JSON
+            
+        Returns:
+            Extracted text as a single string
+        """
+        extracted_text = ""
+        
+        if 'ParsedResults' in result and result['ParsedResults']:
+            for parsed_result in result['ParsedResults']:
+                if parsed_result.get('ParsedText'):
+                    extracted_text += parsed_result['ParsedText']
+        
+        return extracted_text
+    
+    def _get_file_type(self, file_path: str) -> str:
+        """
+        Determine MIME type of a file
+        
+        Args:
+            file_path: Path to the file
+            
+        Returns:
+            MIME type as string
+        """
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type is None:
+            # Default to binary if MIME type can't be determined
+            return 'application/octet-stream'
+        return mime_type
+
+
+# Function to be integrated with the main application
+def handle_file_upload_and_analyze(file_obj, mode: str, classifier) -> tuple:
+    """
+    Handle file upload, OCR processing, and text analysis
+    
+    Args:
+        file_obj: Uploaded file object from Gradio
+        mode: Analysis mode (quick or detailed)
+        classifier: The TextClassifier instance
+        
+    Returns:
+        Analysis results as a tuple (same format as original analyze_text function)
+    """
+    if file_obj is None:
+        return (
+            "No file uploaded",
+            "Please upload a file to analyze",
+            "No file uploaded for analysis"
+        )
+    
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(file_obj.name).suffix) as temp_file:
+        temp_file_path = temp_file.name
+        # Write uploaded file to the temporary file
+        temp_file.write(file_obj.read())
+    
+    try:
+        # Process the file with OCR
+        ocr_processor = OCRProcessor()
+        ocr_result = ocr_processor.process_file(temp_file_path)
+        
+        if not ocr_result["success"]:
+            return (
+                "OCR Processing Error",
+                ocr_result["error"],
+                "Failed to extract text from the uploaded file"
+            )
+        
+        # Get the extracted text
+        extracted_text = ocr_result["text"]
+        
+        # If no text was extracted
+        if not extracted_text.strip():
+            return (
+                "No text extracted",
+                "The OCR process did not extract any text from the uploaded file.",
+                "No text was found in the uploaded file"
+            )
+        
+        # Call the original text analysis function with the extracted text
+        return analyze_text(extracted_text, mode, classifier)
+    
+    finally:
+        # Clean up the temporary file
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+
+# Modified Gradio interface setup function to include file upload
+def setup_gradio_interface(classifier):
+    """
+    Set up Gradio interface with text input and file upload options
+    
+    Args:
+        classifier: The TextClassifier instance
+        
+    Returns:
+        Gradio Interface object
+    """
+    import gradio as gr
+    
+    with gr.Blocks(title="AI Text Detector") as demo:
+        gr.Markdown("# AI Text Detector with Document Upload")
+        gr.Markdown("Analyze text to detect if it was written by a human or AI. You can paste text directly or upload images, PDFs, or Word documents.")
+        
+        with gr.Tab("Text Input"):
+            text_input = gr.Textbox(
+                lines=8,
+                placeholder="Enter text to analyze...",
+                label="Input Text"
+            )
+            
+            mode_selection = gr.Radio(
+                choices=["quick", "detailed"],
+                value="quick",
+                label="Analysis Mode",
+                info="Quick mode for faster analysis, Detailed mode for sentence-level analysis"
+            )
+            
+            text_submit_button = gr.Button("Analyze Text")
+            
+            output_html = gr.HTML(label="Highlighted Analysis")
+            output_sentences = gr.Textbox(label="Sentence-by-Sentence Analysis", lines=10)
+            output_result = gr.Textbox(label="Overall Result", lines=4)
+            
+            text_submit_button.click(
+                analyze_text,
+                inputs=[text_input, mode_selection, classifier],
+                outputs=[output_html, output_sentences, output_result]
+            )
+        
+        with gr.Tab("File Upload"):
+            file_upload = gr.File(
+                label="Upload Document",
+                file_types=["image", "pdf", "doc", "docx"],
+                type="file"
+            )
+            
+            file_mode_selection = gr.Radio(
+                choices=["quick", "detailed"],
+                value="quick",
+                label="Analysis Mode",
+                info="Quick mode for faster analysis, Detailed mode for sentence-level analysis"
+            )
+            
+            upload_submit_button = gr.Button("Process and Analyze")
+            
+            file_output_html = gr.HTML(label="Highlighted Analysis")
+            file_output_sentences = gr.Textbox(label="Sentence-by-Sentence Analysis", lines=10)
+            file_output_result = gr.Textbox(label="Overall Result", lines=4)
+            
+            upload_submit_button.click(
+                handle_file_upload_and_analyze,
+                inputs=[file_upload, file_mode_selection, classifier],
+                outputs=[file_output_html, file_output_sentences, file_output_result]
+            )
+            
+            gr.Markdown("""
+            ### File Upload Limitations
+            - Maximum file size: 1MB
+            - PDF files: Maximum 3 pages (OCR.space API limitation)
+            - Supported formats: Images (PNG, JPG, GIF), PDF, Word documents (DOCX, DOC)
+            """)
+    
+    return demo
+
+
+# This function is a replacement for the original main app setup
+def setup_app_with_ocr():
+    """
+    Setup the application with OCR capabilities
+    """
+    # Initialize the classifier (use existing code)
+    classifier = TextClassifier()
+    
+    # Create the Gradio interface with file upload functionality
+    demo = setup_gradio_interface(classifier)
+    
+    # Get the FastAPI app from Gradio
+    app = demo.app
+    
+    # Add CORS middleware (same as original code)
+    from fastapi.middleware.cors import CORSMiddleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # For development
+        allow_credentials=True,
+        allow_methods=["GET", "POST", "OPTIONS"],
+        allow_headers=["*"],
+    )
+    
+    # Return the demo for launching
+    return demo
+
+
+
 def is_admin_password(input_text: str) -> bool:
     """
     Check if the input text matches the admin password using secure hash comparison.
@@ -564,31 +894,8 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
 classifier = TextClassifier()
 
 # Create Gradio interface
-demo = gr.Interface(
-    fn=lambda text, mode: analyze_text(text, mode, classifier),
-    inputs=[
-        gr.Textbox(
-            lines=8,
-            placeholder="Enter text to analyze...",
-            label="Input Text"
-        ),
-        gr.Radio(
-            choices=["quick", "detailed"],
-            value="quick",
-            label="Analysis Mode",
-            info="Quick mode for faster analysis, Detailed mode for sentence-level analysis"
-        )
-    ],
-    outputs=[
-        gr.HTML(label="Highlighted Analysis"),
-        gr.Textbox(label="Sentence-by-Sentence Analysis", lines=10),
-        gr.Textbox(label="Overall Result", lines=4)
-    ],
-    title="AI Text Detector",
-    description="Analyze text to detect if it was written by a human or AI. Choose between quick scan and detailed sentence-level analysis. 200+ words suggested for accurate predictions.",
-    api_name="predict",
-    flagging_mode="never"
-)
+demo = setup_app_with_ocr()
+
 
 # Get the FastAPI app from Gradio
 app = demo.app