Update app.py

app.py

@@ -18,10 +18,6 @@ from openpyxl.utils import get_column_letter
 from io import BytesIO
 import base64
 import hashlib
-import requests
-import tempfile
-from pathlib import Path
-import mimetypes
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -36,17 +32,6 @@ CONFIDENCE_THRESHOLD = 0.65
 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')
 
@@ -56,138 +41,10 @@ if not ADMIN_PASSWORD_HASH:
 # Excel file path for logs
 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_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
-        """
-        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}")
-        
-        # 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
-        """
-        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
-        """
-        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
-
 def is_admin_password(input_text: str) -> bool:
     """
     Check if the input text matches the admin password using secure hash comparison.
+    This prevents the password from being visible in the source code.
     """
     # Hash the input text
     input_hash = hashlib.sha256(input_text.strip().encode()).hexdigest()
@@ -248,6 +105,11 @@ class TextWindowProcessor:
 
 class TextClassifier:
     def __init__(self):
+        # Set thread configuration before any model loading or parallel work
+        if not torch.cuda.is_available():
+            torch.set_num_threads(MAX_WORKERS)
+            torch.set_num_interop_threads(MAX_WORKERS)
+            
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.model_name = MODEL_NAME
         self.tokenizer = None
@@ -282,7 +144,6 @@ class TextClassifier:
             
         self.model.eval()
 
-    # [Other TextClassifier methods remain the same as in paste.txt]
     def quick_scan(self, text: str) -> Dict:
         """Perform a quick scan using simple window analysis."""
         if not text.strip():
@@ -392,7 +253,7 @@ class TextClassifier:
                 for window_idx, indices in enumerate(batch_indices):
                     center_idx = len(indices) // 2
                     center_weight = 0.7  # Higher weight for center sentence
-                    edge_weight = 0.3 / (len(indices) - 1) if len(indices) > 1 else 0  # Distribute remaining weight
+                    edge_weight = 0.3 / (len(indices) - 1)  # Distribute remaining weight
 
                     for pos, sent_idx in enumerate(indices):
                         # Apply higher weight to center sentence
@@ -415,10 +276,10 @@ class TextClassifier:
 
                 # Apply minimal smoothing at prediction boundaries
                 if i > 0 and i < len(sentences) - 1:
-                    prev_human = sentence_scores[i-1]['human_prob'] / max(sentence_appearances[i-1], 1e-10)
-                    prev_ai = sentence_scores[i-1]['ai_prob'] / max(sentence_appearances[i-1], 1e-10)
-                    next_human = sentence_scores[i+1]['human_prob'] / max(sentence_appearances[i+1], 1e-10)
-                    next_ai = sentence_scores[i+1]['ai_prob'] / max(sentence_appearances[i+1], 1e-10)
+                    prev_human = sentence_scores[i-1]['human_prob'] / sentence_appearances[i-1]
+                    prev_ai = sentence_scores[i-1]['ai_prob'] / sentence_appearances[i-1]
+                    next_human = sentence_scores[i+1]['human_prob'] / sentence_appearances[i+1]
+                    next_ai = sentence_scores[i+1]['ai_prob'] / sentence_appearances[i+1]
 
                     # Check if we're at a prediction boundary
                     current_pred = 'human' if human_prob > ai_prob else 'ai'
@@ -493,72 +354,6 @@ class TextClassifier:
             'num_sentences': num_sentences
         }
 
-# Function to handle file upload, OCR processing, and text analysis
-def handle_file_upload_and_analyze(file_obj, mode: str, classifier) -> tuple:
-    """
-    Handle file upload, OCR processing, and text analysis
-    """
-    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 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:
-        # 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)
-
 def initialize_excel_log():
     """Initialize the Excel log file if it doesn't exist."""
     if not os.path.exists(EXCEL_LOG_PATH):
@@ -586,7 +381,6 @@ def initialize_excel_log():
         wb.save(EXCEL_LOG_PATH)
         logger.info(f"Initialized Excel log file at {EXCEL_LOG_PATH}")
 
-
 def log_prediction_data(input_text, word_count, prediction, confidence, execution_time, mode):
     """Log prediction data to an Excel file in the /tmp directory."""
     # Initialize the Excel file if it doesn't exist
@@ -629,7 +423,6 @@ def log_prediction_data(input_text, word_count, prediction, confidence, executio
         logger.error(f"Error logging prediction data to Excel: {str(e)}")
         return False
 
-
 def get_logs_as_base64():
     """Read the Excel logs file and return as base64 for downloading."""
     if not os.path.exists(EXCEL_LOG_PATH):
@@ -648,7 +441,6 @@ def get_logs_as_base64():
         logger.error(f"Error reading Excel logs: {str(e)}")
         return None
 
-
 def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
     """Analyze text using specified mode and return formatted results."""
     # Check if the input text matches the admin password using secure comparison
@@ -771,146 +563,47 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
 # Initialize the classifier globally
 classifier = TextClassifier()
 
-# Create Gradio interface with a small file upload button next to the radio buttons
-# Modified approach - simplify by using custom HTML/CSS to achieve the exact layout
-def setup_interface():
-    # Create analyzer functions
-    def analyze_text_wrapper(text, mode):
-        return analyze_text(text, mode, classifier)
-        
-    def handle_file_upload_wrapper(file_obj, mode):
-        if file_obj is None:
-            return analyze_text_wrapper("", mode)
-        return handle_file_upload_and_analyze(file_obj, mode, classifier)
-    
-    def clear_inputs():
-        return "", None, None, None
-    
-    # Create a custom CSS class
-    css = """
-    #analyze-btn {
-        background-color: #FF8C00 !important;
-        border-color: #FF8C00 !important;
-        color: white !important;
-    }
-    
-    .radio-with-icon {
-        display: flex;
-        align-items: center;
-    }
-    
-    .paperclip-icon {
-        display: inline-block;
-        margin-left: 10px;
-        font-size: 20px;
-        cursor: pointer;
-        opacity: 0.7;
-    }
-    
-    .paperclip-icon:hover {
-        opacity: 1;
-    }
-    """
-    
-    # Create the interface with custom CSS
-    with gr.Blocks(title="AI Text Detector", css=css) as demo:
-        gr.Markdown("# AI Text Detector")
-        
-        with gr.Row():
-            # Left column - Input
-            with gr.Column():
-                text_input = gr.Textbox(
-                    lines=8,
-                    placeholder="Enter text to analyze...",
-                    label="Input Text"
-                )
-                
-                gr.Markdown("Analysis Mode")
-                gr.Markdown("Quick mode for faster analysis. Detailed mode for sentence-level analysis.")
-                
-                # Create a visible radio button row
-                with gr.Row(elem_classes=["radio-with-icon"]):
-                    mode_selection = gr.Radio(
-                        choices=["quick", "detailed"],
-                        value="quick",
-                        label=""
-                    )
-                    
-                    # Create a button that looks like a paperclip and triggers file upload
-                    upload_trigger = gr.Button("📎", elem_classes=["paperclip-icon"])
-                
-                # Hidden file upload that will be triggered by the paperclip button
-                file_upload = gr.File(
-                    file_types=["image", "pdf", "doc", "docx"],
-                    type="binary",
-                    visible=False
-                )
-                
-                # Action buttons
-                with gr.Row():
-                    clear_btn = gr.Button("Clear")
-                    analyze_btn = gr.Button("Analyze Text", elem_id="analyze-btn")
-            
-            # Right column - Results
-            with gr.Column():
-                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)
-        
-        # Connect the components
-        analyze_btn.click(
-            analyze_text_wrapper,
-            inputs=[text_input, mode_selection],
-            outputs=[output_html, output_sentences, output_result]
+# 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"
         )
-        
-        clear_btn.click(
-            clear_inputs,
-            inputs=None,
-            outputs=[text_input, output_html, output_sentences, output_result]
-        )
-        
-        # Make the paperclip button trigger the file upload
-        def trigger_upload():
-            return gr.update(visible=True)
-            
-        upload_trigger.click(
-            trigger_upload,
-            inputs=None,
-            outputs=file_upload
-        )
-        
-        # Process the file when uploaded
-        file_upload.change(
-            handle_file_upload_wrapper,
-            inputs=[file_upload, mode_selection],
-            outputs=[output_html, output_sentences, output_result]
-        )
-    
-    return demo
-# Setup the app with CORS middleware
-def setup_app():
-    demo = setup_interface()
-    
-    # Get the FastAPI app from Gradio
-    app = demo.app
-    
-    # Add CORS middleware
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],  # For development
-        allow_credentials=True,
-        allow_methods=["GET", "POST", "OPTIONS"],
-        allow_headers=["*"],
-    )
-    
-    return demo
-
-# Initialize the application
+    ],
+    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"
+)
+
+# Get the FastAPI app from Gradio
+app = demo.app
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # For development
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_headers=["*"],
+)
+
+# Ensure CORS is applied before launching
 if __name__ == "__main__":
-    demo = setup_app()
-    
-    # Start the server
     demo.queue()
     demo.launch(
         server_name="0.0.0.0",