printing answers

main.py

@@ -6,12 +6,15 @@ import sys
 import builtins
 from datetime import datetime
 from flask_cors import CORS
-from flask import Flask, request, jsonify, render_template, make_response
+from flask import Flask, request, jsonify, render_template, make_response, Response
 from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 import json
 import shutil
 from threading import Thread, Event
+import queue
+import time
+from contextlib import contextmanager
 
 # Load environment variables
 load_dotenv()
@@ -30,6 +33,7 @@ log_file = os.path.join(log_dir, 'app.log')  # Add log file path
 # Global variables for model caching and initialization status
 global_models = {}
 initialization_complete = Event()
+notification_queue = queue.Queue()
 
 def ensure_directory(path):
     """Create directory and ensure full permissions with better error handling"""
@@ -327,6 +331,35 @@ def validate_folder_structure(files):
     except Exception as e:
         return False, f"Error validating folder structure: {str(e)}"
 
+@app.route('/notifications')
+def notifications():
+    def generate():
+        start_time = time.time()
+        timeout = 300  # 5 minutes timeout
+        
+        while True:
+            try:
+                # Check timeout
+                if time.time() - start_time > timeout:
+                    yield "data: {\"type\": \"timeout\", \"message\": \"Connection timed out\"}\n\n"
+                    break
+                    
+                # Get notification from queue (non-blocking)
+                try:
+                    notification = notification_queue.get_nowait()
+                    yield f"data: {json.dumps(notification)}\n\n"
+                except queue.Empty:
+                    # If no notification, yield empty to keep connection alive
+                    yield "data: {}\n\n"
+                    time.sleep(0.5)  # Increased delay to reduce server load
+                    
+            except Exception as e:
+                log_print(f"Error in notification stream: {str(e)}", "ERROR")
+                yield f"data: {{\"type\": \"error\", \"message\": \"{str(e)}\"}}\n\n"
+                break
+
+    return Response(generate(), mimetype='text/event-stream')
+
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
     try:
@@ -415,6 +448,7 @@ def compute_marks():
         # Dictionary to store results by student folder and image name
         results = {}
         failed_files = []
+        extracted_texts = {}  # Add this line to store extracted texts
         
         try:
             # Process each file
@@ -484,6 +518,18 @@ def compute_marks():
                         
                         log_print(f"Extracted text: {extracted_text[:100]}...")
                         
+                        # Send notification for extracted text immediately
+                        notification_data = {
+                            "type": "extracted_text",
+                            "filename": filename,
+                            "text": extracted_text[:200] + ("..." if len(extracted_text) > 200 else "")
+                        }
+                        notification_queue.put(notification_data)
+                        log_print(f"Notification queued for {filename}")
+                        
+                        # Store extracted text for final response
+                        extracted_texts[filename] = extracted_text
+                        
                         # Clean the extracted text for JSON
                         extracted_text = extracted_text.encode('ascii', 'ignore').decode('ascii')
                         
@@ -580,7 +626,11 @@ def compute_marks():
             "failed_files": [{
                 "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
                 "error": f["error"].encode('ascii', 'ignore').decode('ascii')
-            } for f in failed_files]
+            } for f in failed_files],
+            "extracted_texts": {  # Add this section to include extracted texts
+                filename: text.encode('ascii', 'ignore').decode('ascii')
+                for filename, text in extracted_texts.items()
+            }
         }
         
         log_print(f"Sending response: {response_data}")
@@ -675,25 +725,51 @@ def ensure_initialization():
         wait_for_initialization()
 
 def cleanup_temp_files():
-    """Clean up temporary files with proper error handling"""
+    """Clean up temporary files with proper error handling and timeout"""
     try:
-        # Clean up the temporary processing directory
+        # Clean up the temporary processing directory with timeout
         temp_processing_dir = os.path.join(BASE_DIR, 'temp_processing')
         if os.path.exists(temp_processing_dir):
-            shutil.rmtree(temp_processing_dir, ignore_errors=True)
+            try:
+                with timeout(30):  # 30 second timeout for cleanup
+                    shutil.rmtree(temp_processing_dir, ignore_errors=True)
+            except TimeoutError:
+                log_print("Warning: Cleanup of temp_processing_dir timed out", "WARNING")
         
-        # Clean up the images directory
+        # Clean up the images directory with timeout
         if os.path.exists(images_dir):
             for file in os.listdir(images_dir):
                 try:
                     file_path = os.path.join(images_dir, file)
                     if os.path.isfile(file_path):
-                        os.unlink(file_path)
+                        with timeout(5):  # 5 second timeout per file
+                            os.unlink(file_path)
+                except TimeoutError:
+                    log_print(f"Warning: Cleanup of file {file_path} timed out", "WARNING")
                 except Exception as e:
                     log_print(f"Warning: Could not delete file {file_path}: {e}", "WARNING")
     except Exception as e:
         log_print(f"Error cleaning up temporary files: {e}", "ERROR")
 
+# Add timeout context manager
+class timeout:
+    def __init__(self, seconds):
+        self.seconds = seconds
+
+    def __enter__(self):
+        import signal
+        def timeout_handler(signum, frame):
+            raise TimeoutError("Timed out!")
+        # Set the signal handler and a 5-second alarm
+        self.original_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(self.seconds)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        import signal
+        signal.alarm(0)
+        signal.signal(signal.SIGALRM, self.original_handler)
+
 if __name__ == '__main__':
     try:
         # Create essential directories

templates/index.html

@@ -1303,6 +1303,15 @@
                         keepalive: true
                     });
 
+                    // Set up event source for real-time notifications
+                    const eventSource = new EventSource('/notifications');
+                    eventSource.onmessage = function(event) {
+                        const data = JSON.parse(event.data);
+                        if (data.type === 'extracted_text') {
+                            notificationSystem.info(`Extracted text from ${data.filename}:\n${data.text}`, 8000);
+                        }
+                    };
+
                     let result;
                     const contentType = response.headers.get('content-type');
                     if (contentType && contentType.includes('application/json')) {
@@ -1311,6 +1320,9 @@
                         throw new Error('Server returned non-JSON response');
                     }
 
+                    // Close event source after getting final response
+                    eventSource.close();
+
                     if (!response.ok) {
                         throw new Error(result.message || result.error || `Server error: ${response.status}`);
                     }