adding count down 1 2 3 4 and removing the null return error

main.py

@@ -334,29 +334,34 @@ def validate_folder_structure(files):
 @app.route('/notifications')
 def notifications():
     def generate():
-        start_time = time.time()
-        timeout = 300  # 5 minutes timeout
+        error_count = 0
+        max_errors = 3
         
         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"
+                    if notification:
+                        yield "data: " + json.dumps(notification) + "\n\n"
+                        error_count = 0  # Reset error count on successful notification
                 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
+                    yield "data: " + json.dumps({"type": "ping"}) + "\n\n"
+                    time.sleep(0.5)  # Keep the connection alive
                     
             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
+                error_count += 1
+                error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+                log_print(f"Error in notification stream: {error_msg}", "ERROR")
+                
+                yield "data: " + json.dumps({
+                    "type": "error",
+                    "message": f"Server error: {error_msg}"
+                }) + "\n\n"
+                
+                if error_count >= max_errors:
+                    break
 
     return Response(generate(), mimetype='text/event-stream')
 
@@ -448,7 +453,9 @@ 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
+        extracted_texts = {}
+        processed_count = 0
+        total_files = len(files)
         
         try:
             # Process each file
@@ -576,6 +583,16 @@ def compute_marks():
                         results[student_folder][filename] = round(marks, 2)
                         log_print(f"Assigned marks for {filename} in {student_folder}: {marks}")
                         
+                        # Update progress
+                        processed_count += 1
+                        progress_data = {
+                            "type": "progress",
+                            "processed": processed_count,
+                            "total": total_files,
+                            "current_file": filename
+                        }
+                        notification_queue.put(progress_data)
+                        
                     except Exception as e:
                         error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
                         log_print(f"Error processing file {file.filename}: {error_msg}", "ERROR")
@@ -627,7 +644,7 @@ def compute_marks():
                 "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
                 "error": f["error"].encode('ascii', 'ignore').decode('ascii')
             } for f in failed_files],
-            "extracted_texts": {  # Add this section to include extracted texts
+            "extracted_texts": {
                 filename: text.encode('ascii', 'ignore').decode('ascii')
                 for filename, text in extracted_texts.items()
             }
@@ -725,51 +742,25 @@ def ensure_initialization():
         wait_for_initialization()
 
 def cleanup_temp_files():
-    """Clean up temporary files with proper error handling and timeout"""
+    """Clean up temporary files with proper error handling"""
     try:
-        # Clean up the temporary processing directory with timeout
+        # Clean up the temporary processing directory
         temp_processing_dir = os.path.join(BASE_DIR, 'temp_processing')
         if os.path.exists(temp_processing_dir):
-            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")
+            shutil.rmtree(temp_processing_dir, ignore_errors=True)
         
-        # Clean up the images directory with timeout
+        # Clean up the images directory
         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):
-                        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")
+                        os.unlink(file_path)
                 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
@@ -778,7 +769,7 @@ if __name__ == '__main__':
         
         # Configure server for long-running requests
         app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
-        app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # Increase to 50MB
+        app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB max file size
         
         # Add additional server configurations
         app.config['PERMANENT_SESSION_LIFETIME'] = 3600  # 1 hour session lifetime

templates/index.html

@@ -1295,23 +1295,65 @@
                 `;
 
                 try {
-                    const controller = new AbortController();
                     const response = await fetch('/compute_marks', {
                         method: 'POST',
                         body: formData,
-                        signal: controller.signal,
                         keepalive: true
                     });
 
                     // Set up event source for real-time notifications
                     const eventSource = new EventSource('/notifications');
+                    let errorCount = 0;
+                    const maxErrors = 3;
+
                     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);
+                        try {
+                            const data = JSON.parse(event.data);
+                            if (!data || typeof data !== 'object') {
+                                console.warn('Received invalid notification data:', event.data);
+                                return;
+                            }
+
+                            if (data.type === 'extracted_text') {
+                                notificationSystem.info(`Extracted text from ${data.filename}:\n${data.text}`, 8000);
+                            } else if (data.type === 'progress') {
+                                // Update progress in loading text
+                                const loadingText = document.querySelector('.loading-text');
+                                if (loadingText) {
+                                    loadingText.innerHTML = `
+                                        Processing ${data.total} files...<br>
+                                        This may take several minutes depending on the number of files.<br>
+                                        Please keep this window open.<br>
+                                        <small>Progress: ${data.processed}/${data.total} files processed<br>
+                                        Current file: ${data.current_file}</small>
+                                    `;
+                                }
+                                // Reset error count on successful progress update
+                                errorCount = 0;
+                            } else if (data.type === 'error') {
+                                console.error('Server notification error:', data.message);
+                                errorCount++;
+                                if (errorCount >= maxErrors) {
+                                    eventSource.close();
+                                    notificationSystem.error('Lost connection to server. Please refresh the page.');
+                                }
+                            }
+                        } catch (e) {
+                            console.error('Error parsing notification data:', e);
+                            errorCount++;
+                            if (errorCount >= maxErrors) {
+                                eventSource.close();
+                                notificationSystem.error('Error processing server updates. Please refresh the page.');
+                            }
                         }
                     };
 
+                    eventSource.onerror = function(error) {
+                        console.error('EventSource error:', error);
+                        eventSource.close();
+                        notificationSystem.error('Lost connection to server. Please refresh the page.');
+                    };
+
                     let result;
                     const contentType = response.headers.get('content-type');
                     if (contentType && contentType.includes('application/json')) {
@@ -1349,8 +1391,6 @@
                     console.error('Fetch error:', fetchError);
                     if (!navigator.onLine) {
                         throw new Error('No internet connection. Please check your connection and try again.');
-                    } else if (fetchError.name === 'AbortError') {
-                        throw new Error('Request was cancelled. Please try again.');
                     } else {
                         throw new Error(`Server error: ${fetchError.message}`);
                     }