Update app.py

app.py

@@ -57,7 +57,7 @@ if not ADMIN_PASSWORD_HASH:
 EXCEL_LOG_PATH = "/tmp/prediction_logs.xlsx"
 
 # OCR API settings
-OCR_API_KEY = "9e11346f1288957"  # This is a partial key - replace with the full one
+OCR_API_KEY = "9e11346f1288957"  # Now using the complete key
 OCR_API_ENDPOINT = "https://api.ocr.space/parse/image"
 OCR_MAX_PDF_PAGES = 3
 OCR_MAX_FILE_SIZE_MB = 1
@@ -95,10 +95,6 @@ class OCRProcessor:
         file_type = self._get_file_type(file_path)
         ocr_logger.info(f"Detected file type: {file_type}")
         
-        # Prepare the API request
-        with open(file_path, 'rb') as f:
-            file_data = f.read()
-            
         # Set up API parameters
         payload = {
             'isOverlayRequired': 'false',
@@ -113,9 +109,9 @@ class OCRProcessor:
             ocr_logger.info("PDF document detected, enforcing page limit")
             payload['filetype'] = 'PDF'
         
-        # Prepare file for OCR API
+        # Prepare file for OCR API - using file object directly as in the test script
         files = {
-            'file': (os.path.basename(file_path), file_data, file_type)
+            'file': (os.path.basename(file_path), open(file_path, 'rb'))
         }
         
         headers = {
@@ -124,33 +120,52 @@ class OCRProcessor:
         
         # Make the OCR API request
         try:
-            ocr_logger.info("Sending request to OCR.space API")
+            ocr_logger.info(f"Sending request to OCR.space API for file: {os.path.basename(file_path)}")
             response = requests.post(
                 self.endpoint, 
                 files=files,
                 data=payload,
-                headers=headers
+                headers=headers,
+                timeout=60  # Add 60 second timeout
             )
+            
+            ocr_logger.info(f"OCR API status code: {response.status_code}")
+            
+            # Log response text for debugging (first 200 chars)
+            ocr_logger.info(f"OCR API response preview: {response.text[:200]}...")
+            
             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")
+            try:
+                result = response.json()
+                ocr_logger.info(f"OCR API exit code: {result.get('OCRExitCode')}")
                 
-                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')}")
+                # 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")
+                    ocr_logger.info(f"Extracted text word count: {len(extracted_text.split())}")
+                    
+                    return {
+                        "success": True,
+                        "text": extracted_text,
+                        "word_count": len(extracted_text.split()),
+                        "processing_time_ms": int(processing_time * 1000)
+                    }
+                else:
+                    error_msg = result.get('ErrorMessage', 'OCR processing failed')
+                    ocr_logger.error(f"OCR API error: {error_msg}")
+                    return {
+                        "success": False,
+                        "error": error_msg,
+                        "text": ""
+                    }
+            except ValueError as e:
+                ocr_logger.error(f"Invalid JSON response: {str(e)}")
                 return {
                     "success": False,
-                    "error": result.get('ErrorMessage', 'OCR processing failed'),
+                    "error": f"Invalid response from OCR API: {str(e)}",
                     "text": ""
                 }
                 
@@ -161,6 +176,9 @@ class OCRProcessor:
                 "error": f"OCR API request failed: {str(e)}",
                 "text": ""
             }
+        finally:
+            # Close the file handle
+            files['file'][1].close()
     
     def _extract_text_from_result(self, result: Dict) -> str:
         """
@@ -504,35 +522,50 @@ def handle_file_upload_and_analyze(file_obj, mode: str, classifier: TextClassifi
             "No file uploaded for analysis"
         )
     
-    # Create a temporary file with an appropriate extension based on content
-    content_start = file_obj[:20]  # Look at the first few bytes
-    
-    # Default to .bin extension
-    file_ext = ".bin"
-    
-    # Try to detect PDF files
-    if content_start.startswith(b'%PDF'):
-        file_ext = ".pdf"
-    # For images, detect by common magic numbers
-    elif content_start.startswith(b'\xff\xd8'):  # JPEG
-        file_ext = ".jpg"
-    elif content_start.startswith(b'\x89PNG'):  # PNG
-        file_ext = ".png"
-    elif content_start.startswith(b'GIF'):      # GIF
-        file_ext = ".gif"
-    
-    # Create a temporary file with the detected extension
-    with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as temp_file:
-        temp_file_path = temp_file.name
-        # Write uploaded file data to the temporary file
-        temp_file.write(file_obj)
+    # Log the type of file object received
+    logger.info(f"Received file upload of type: {type(file_obj)}")
     
     try:
+        # Create a temporary file with an appropriate extension based on content
+        if isinstance(file_obj, bytes):
+            content_start = file_obj[:20]  # Look at the first few bytes
+            
+            # Default to .bin extension
+            file_ext = ".bin"
+            
+            # Try to detect PDF files
+            if content_start.startswith(b'%PDF'):
+                file_ext = ".pdf"
+            # For images, detect by common magic numbers
+            elif content_start.startswith(b'\xff\xd8'):  # JPEG
+                file_ext = ".jpg"
+            elif content_start.startswith(b'\x89PNG'):  # PNG
+                file_ext = ".png"
+            elif content_start.startswith(b'GIF'):      # GIF
+                file_ext = ".gif"
+            
+            # Create a temporary file with the detected extension
+            with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as temp_file:
+                temp_file_path = temp_file.name
+                # Write uploaded file data to the temporary file
+                temp_file.write(file_obj)
+                logger.info(f"Saved uploaded file to {temp_file_path}")
+        else:
+            # Handle other file object types (should not typically happen with Gradio)
+            logger.error(f"Unexpected file object type: {type(file_obj)}")
+            return (
+                "File upload error",
+                "Unexpected file format",
+                "Unable to process this file format"
+            )
+        
         # Process the file with OCR
         ocr_processor = OCRProcessor()
+        logger.info(f"Starting OCR processing for file: {temp_file_path}")
         ocr_result = ocr_processor.process_file(temp_file_path)
         
         if not ocr_result["success"]:
+            logger.error(f"OCR processing failed: {ocr_result['error']}")
             return (
                 "OCR Processing Error",
                 ocr_result["error"],
@@ -541,9 +574,11 @@ def handle_file_upload_and_analyze(file_obj, mode: str, classifier: TextClassifi
         
         # Get the extracted text
         extracted_text = ocr_result["text"]
+        logger.info(f"OCR processing complete. Extracted {len(extracted_text.split())} words")
         
         # If no text was extracted
         if not extracted_text.strip():
+            logger.warning("No text extracted from file")
             return (
                 "No text extracted",
                 "The OCR process did not extract any text from the uploaded file.",
@@ -551,12 +586,24 @@ def handle_file_upload_and_analyze(file_obj, mode: str, classifier: TextClassifi
             )
         
         # Call the original text analysis function with the extracted text
+        logger.info("Proceeding with text analysis")
         return analyze_text(extracted_text, mode, classifier)
     
+    except Exception as e:
+        logger.error(f"Error in file upload processing: {str(e)}")
+        return (
+            "Error Processing File",
+            f"An error occurred while processing the file: {str(e)}",
+            "File processing error. Please try again or try a different file."
+        )
     finally:
         # Clean up the temporary file
-        if os.path.exists(temp_file_path):
-            os.remove(temp_file_path)
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            try:
+                os.remove(temp_file_path)
+                logger.info(f"Removed temporary file: {temp_file_path}")
+            except Exception as e:
+                logger.warning(f"Could not remove temporary file: {str(e)}")
 
 def initialize_excel_log():
     """Initialize the Excel log file if it doesn't exist."""