Update app.py

app.py

@@ -33,28 +33,36 @@ MODEL_NAME = "microsoft/deberta-v3-small"
 WINDOW_SIZE = 6
 WINDOW_OVERLAP = 2
 CONFIDENCE_THRESHOLD = 0.65
-BATCH_SIZE = 8  
-MAX_WORKERS = 4 
-
+BATCH_SIZE = 8  # Reduced batch size for CPU
+MAX_WORKERS = 4  # Number of worker threads for processing
 
+# IMPORTANT: Set PyTorch thread configuration at the module level
+# before any parallel work starts
 if not torch.cuda.is_available():
+    # Set thread configuration only once at the beginning
     torch.set_num_threads(MAX_WORKERS)
     try:
+        # Only set interop threads if it hasn't been set already
         torch.set_num_interop_threads(MAX_WORKERS)
     except RuntimeError as e:
         logger.warning(f"Could not set interop threads: {str(e)}")
 
+# Get password hash from environment variable (more secure)
 ADMIN_PASSWORD_HASH = os.environ.get('ADMIN_PASSWORD_HASH')
 
 if not ADMIN_PASSWORD_HASH:
     ADMIN_PASSWORD_HASH = "5e22d1ed71b273b1b2b5331f2d3e0f6cf34595236f201c6924d6bc81de27cdcb"
 
+# Excel file path for logs
 EXCEL_LOG_PATH = "/tmp/prediction_logs.xlsx"
-OCR_API_KEY = "9e11346f1288957"  
+
+# 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)
 
@@ -87,6 +95,10 @@ 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',
@@ -101,10 +113,7 @@ class OCRProcessor:
             ocr_logger.info("PDF document detected, enforcing page limit")
             payload['filetype'] = 'PDF'
         
-        # Prepare file for OCR API - using file data as bytes to avoid file handle issues
-        with open(file_path, 'rb') as f:
-            file_data = f.read()
-            
+        # Prepare file for OCR API
         files = {
             'file': (os.path.basename(file_path), file_data, file_type)
         }
@@ -115,61 +124,33 @@ class OCRProcessor:
         
         # Make the OCR API request
         try:
-            ocr_logger.info(f"Sending request to OCR.space API for file: {os.path.basename(file_path)}")
+            ocr_logger.info("Sending request to OCR.space API")
             response = requests.post(
                 self.endpoint, 
                 files=files,
                 data=payload,
-                headers=headers,
-                timeout=60  # Add 60 second timeout
+                headers=headers
             )
+            response.raise_for_status()
+            result = response.json()
             
-            ocr_logger.info(f"OCR API status code: {response.status_code}")
-            
-            # Log response text for debugging (first 200 chars)
-            response_preview = response.text[:200] if hasattr(response, 'text') else "No text content"
-            ocr_logger.info(f"OCR API response preview: {response_preview}...")
-            
-            try:
-                response.raise_for_status()
-            except Exception as e:
-                ocr_logger.error(f"HTTP Error: {str(e)}")
+            # 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": False,
-                    "error": f"OCR API HTTP Error: {str(e)}",
-                    "text": ""
+                    "success": True,
+                    "text": extracted_text,
+                    "word_count": len(extracted_text.split()),
+                    "processing_time_ms": int(processing_time * 1000)
                 }
-            
-            try:
-                result = response.json()
-                ocr_logger.info(f"OCR API exit code: {result.get('OCRExitCode')}")
-                
-                # 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)}")
+            else:
+                ocr_logger.error(f"OCR API error: {result.get('ErrorMessage', 'Unknown error')}")
                 return {
                     "success": False,
-                    "error": f"Invalid response from OCR API: {str(e)}",
+                    "error": result.get('ErrorMessage', 'OCR processing failed'),
                     "text": ""
                 }
                 
@@ -180,9 +161,6 @@ class OCRProcessor:
                 "error": f"OCR API request failed: {str(e)}",
                 "text": ""
             }
-        finally:
-            # No need to close file handle as we're using bytes directly
-            pass
     
     def _extract_text_from_result(self, result: Dict) -> str:
         """
@@ -515,14 +493,10 @@ class TextClassifier:
         }
 
 # Function to handle file upload, OCR processing, and text analysis
-def handle_file_upload_and_analyze(file_obj, mode: str) -> tuple:
+def handle_file_upload_and_analyze(file_obj, mode: str, classifier) -> tuple:
     """
     Handle file upload, OCR processing, and text analysis
     """
-    # Use the global classifier
-    global classifier
-    classifier_to_use = classifier
-        
     if file_obj is None:
         return (
             "No file uploaded",
@@ -530,50 +504,35 @@ def handle_file_upload_and_analyze(file_obj, mode: str) -> tuple:
             "No file uploaded for analysis"
         )
     
-    # Log the type of file object received
-    logger.info(f"Received file upload of type: {type(file_obj)}")
+    # 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)
     
     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"],
@@ -582,11 +541,9 @@ def handle_file_upload_and_analyze(file_obj, mode: str) -> tuple:
         
         # 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.",
@@ -594,24 +551,12 @@ def handle_file_upload_and_analyze(file_obj, mode: str) -> tuple:
             )
         
         # Call the original text analysis function with the extracted text
-        logger.info("Proceeding with text analysis")
-        return analyze_text(extracted_text, mode, classifier_to_use)
+        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 '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)}")
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
 
 def initialize_excel_log():
     """Initialize the Excel log file if it doesn't exist."""
@@ -825,7 +770,7 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
 # Initialize the classifier globally
 classifier = TextClassifier()
 
-# Create Gradio interface with a file upload button matched to the radio buttons
+# Create Gradio interface with a properly sized file upload button
 def create_interface():
     # Custom CSS for the interface
     css = """
@@ -835,46 +780,49 @@ def create_interface():
         color: white !important;
     }
     
-    /* Style the file upload to be more compact */
-    .file-upload {
-        width: 150px !important;
-        margin-left: 15px !important;
+    /* Style the file upload container to match the radio buttons */
+    .file-upload-container {
+        margin-left: 15px;
+        display: inline-block;
+        vertical-align: middle;
     }
     
-    /* Hide file preview elements */
-    .file-upload .file-preview,
-    .file-upload p:not(.file-upload p:first-child),
-    .file-upload svg,
-    .file-upload [data-testid="chunkFileDropArea"],
-    .file-upload .file-drop {
+    /* Hide file info and preview */
+    .file-upload-container .file-preview {
         display: none !important;
     }
     
-    /* Style the upload button */
-    .file-upload button {
+    /* Style the upload button to a proper size */
+    .file-upload-container [data-testid="chunkFileDropArea"] {
+        width: 150px !important;
         height: 40px !important;
-        width: 100% !important;
         background-color: #f0f0f0 !important;
         border: 1px solid #d9d9d9 !important;
         border-radius: 4px !important;
-        color: #333 !important;
-        font-size: 14px !important;
         display: flex !important;
         align-items: center !important;
         justify-content: center !important;
+        padding: 0 10px !important;
         margin: 0 !important;
-        padding: 0 !important;
     }
     
-    /* Hide the "or" text */
-    .file-upload .or {
+    /* Show only the "Upload Document" text */
+    .file-upload-container [data-testid="chunkFileDropArea"] * {
         display: none !important;
     }
     
-    /* Make the container compact */
-    .file-upload [data-testid="block"] {
-        margin: 0 !important;
-        padding: 0 !important;
+    /* Add a new label */
+    .file-upload-container [data-testid="chunkFileDropArea"]::before {
+        content: "Upload Document" !important;
+        display: block !important;
+        font-size: 14px !important;
+        color: #444 !important;
+    }
+    
+    /* Hover effect */
+    .file-upload-container [data-testid="chunkFileDropArea"]:hover {
+        background-color: #e0e0e0 !important;
+        cursor: pointer !important;
     }
     """
     
@@ -905,12 +853,15 @@ def create_interface():
                         show_label=False
                     )
                     
-                    # Revert to File component but with better styling
-                    file_upload = gr.File(
-                        file_types=["pdf", "doc", "docx"],
-                        type="binary",
-                        elem_classes=["file-upload"]
-                    )
+                    # File upload component with compact styling
+                    with gr.Column(elem_classes=["file-upload-container"], scale=0):
+                        file_upload = gr.File(
+                            file_types=["image", "pdf", "doc", "docx"],
+                            type="binary",
+                            label="",
+                            show_label=False,
+                            elem_id="file-upload"
+                        )
                 
                 # Analyze button
                 analyze_btn = gr.Button("Analyze Text", elem_id="analyze-btn")
@@ -922,13 +873,14 @@ def create_interface():
                 output_result = gr.Textbox(label="Overall Result", lines=4)
         
         # Connect components
+        # 1. Analyze button click
         analyze_btn.click(
             fn=lambda text, mode: analyze_text(text, mode, classifier),
             inputs=[text_input, mode_selection],
             outputs=[output_html, output_sentences, output_result]
         )
         
-        # Use the file upload handler without passing classifier (will use global)
+        # 2. File upload change event
         file_upload.change(
             fn=handle_file_upload_and_analyze,
             inputs=[file_upload, mode_selection],
@@ -936,7 +888,7 @@ def create_interface():
         )
     
     return demo
-    
+
 # Setup the app with CORS middleware
 def setup_app():
     demo = create_interface()