adding some more thing for popup

main.py

@@ -377,6 +377,7 @@ def compute_marks():
             if not initialization_complete.is_set():
                 log_print("Initialization timeout", "ERROR")
                 return jsonify({
+                    "status": "error",
                     "error": "Server initialization",
                     "message": "Server is still initializing. Please try again in a moment."
                 }), 503
@@ -385,6 +386,7 @@ def compute_marks():
         if not request.is_json and not request.form:
             log_print("Invalid request format", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Invalid request format",
                 "message": "Request must be either JSON or form data"
             }), 400
@@ -394,6 +396,7 @@ def compute_marks():
         if not correct_answers:
             log_print("No correct answers provided", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Missing data",
                 "message": "No correct answers provided"
             }), 400
@@ -402,14 +405,28 @@ def compute_marks():
         
         # Create TFIDF values for correct answers
         try:
-            log_print("Creating TFIDF values...")
+            log_print("Starting TFIDF value creation...")
+            notification_queue.put({
+                "type": "info",
+                "message": "Starting TFIDF value creation..."
+            })
             max_tfidf = create_tfidf_values(correct_answers)
-            log_print("Created TFIDF values successfully")
+            log_print("TFIDF values created successfully")
+            notification_queue.put({
+                "type": "success",
+                "message": "TFIDF values created successfully"
+            })
         except Exception as e:
-            log_print(f"TFIDF error: {str(e)}", "ERROR")
+            error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+            log_print(f"TFIDF error: {error_msg}", "ERROR")
+            notification_queue.put({
+                "type": "error",
+                "message": f"TFIDF error: {error_msg}"
+            })
             return jsonify({
+                "status": "error",
                 "error": "TFIDF error",
-                "message": f"Error creating TFIDF values: {str(e)}"
+                "message": f"Error creating TFIDF values: {error_msg}"
             }), 400
         
         # Get all uploaded files
@@ -417,6 +434,7 @@ def compute_marks():
         if not files:
             log_print("No files uploaded", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Missing data",
                 "message": "No files uploaded"
             }), 400
@@ -432,6 +450,7 @@ def compute_marks():
         if total_size > max_size:
             log_print(f"File size limit exceeded: {total_size / 1024 / 1024:.1f}MB", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "File size limit exceeded",
                 "message": f"Total file size must be less than 15MB (current size: {total_size / 1024 / 1024:.1f}MB)"
             }), 413
@@ -443,6 +462,7 @@ def compute_marks():
         if not is_valid:
             log_print(f"Invalid folder structure: {message}", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Invalid folder structure",
                 "message": message
             }), 400
@@ -455,6 +475,7 @@ def compute_marks():
         except Exception as e:
             log_print(f"Error creating temp directory: {str(e)}", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Server error",
                 "message": "Could not create temporary directory"
             }), 500
@@ -478,6 +499,10 @@ def compute_marks():
                         continue
 
                     log_print(f"Processing file: {file.filename}")
+                    notification_queue.put({
+                        "type": "info",
+                        "message": f"Processing file: {file.filename}"
+                    })
                     
                     # Get folder structure from file path
                     path_parts = file.filename.split('/')
@@ -518,9 +543,31 @@ def compute_marks():
                         log_print(f"Saved file to: {filepath}")
                         
                         # Extract text
-                        log_print(f"Extracting text from: {filepath}")
+                        log_print(f"Starting text extraction from: {filepath}")
+                        notification_queue.put({
+                            "type": "info",
+                            "message": f"Starting text extraction from: {filename}"
+                        })
                         extracted_text = extract_text_from_image(filepath)
                         
+                        if not extracted_text:
+                            log_print(f"No text extracted from: {filepath}", "WARNING")
+                            notification_queue.put({
+                                "type": "warning",
+                                "message": f"No text could be extracted from: {filename}"
+                            })
+                            failed_files.append({
+                                "file": file.filename,
+                                "error": "No text could be extracted from the image"
+                            })
+                            continue
+                        
+                        log_print(f"Text extracted successfully from: {filename}")
+                        notification_queue.put({
+                            "type": "success",
+                            "message": f"Text extracted successfully from: {filename}"
+                        })
+                        
                         # Clean up the file immediately after processing
                         try:
                             os.remove(filepath)
@@ -529,6 +576,10 @@ def compute_marks():
                             
                         if not extracted_text:
                             log_print(f"No text extracted from: {filepath}", "WARNING")
+                            notification_queue.put({
+                                "type": "warning",
+                                "message": f"No text could be extracted from: {filename}"
+                            })
                             failed_files.append({
                                 "file": file.filename,
                                 "error": "No text could be extracted from the image"
@@ -562,13 +613,35 @@ def compute_marks():
                                 clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
                                 
                                 # Calculate similarity scores
+                                log_print("Starting similarity score calculations...")
+                                notification_queue.put({
+                                    "type": "info",
+                                    "message": "Starting similarity score calculations..."
+                                })
+                                
                                 log_print(f"Calculating scores for answer {i+1}...")
+                                notification_queue.put({
+                                    "type": "info",
+                                    "message": f"Calculating scores for answer {i+1}..."
+                                })
+                                
                                 semantic_score = question_vector_sentence(extracted_text, clean_correct_answer)
                                 word_score = question_vector_word(extracted_text, clean_correct_answer)
                                 tfidf_score = tfidf_answer_score(extracted_text, clean_correct_answer, max_tfidf)
                                 ft_score = fasttext_similarity(extracted_text, clean_correct_answer)
                                 llm_marks = llm_score(extracted_text, clean_correct_answer)
                                 
+                                # Send individual scores to frontend
+                                notification_queue.put({
+                                    "type": "info",
+                                    "message": f"Scores for answer {i+1}:\n" +
+                                             f"Semantic: {semantic_score:.2f}\n" +
+                                             f"Word: {word_score:.2f}\n" +
+                                             f"TFIDF: {tfidf_score:.2f}\n" +
+                                             f"FastText: {ft_score:.2f}\n" +
+                                             f"LLM: {llm_marks:.2f}"
+                                })
+                                
                                 combined_score = (
                                     semantic_score * 0.3 +
                                     word_score * 0.2 +
@@ -586,6 +659,10 @@ def compute_marks():
                             except Exception as score_error:
                                 error_msg = str(score_error).encode('ascii', 'ignore').decode('ascii')
                                 log_print(f"Error calculating scores for {filepath}: {error_msg}", "ERROR")
+                                notification_queue.put({
+                                    "type": "error",
+                                    "message": f"Error calculating scores for {filename}: {error_msg}"
+                                })
                                 failed_files.append({
                                     "file": file.filename,
                                     "error": f"Error calculating scores: {error_msg}"
@@ -595,6 +672,10 @@ def compute_marks():
                         marks = new_value(best_score, 0, 1, 0, 5)
                         results[student_folder][filename] = round(marks, 2)
                         log_print(f"Assigned marks for {filename} in {student_folder}: {marks}")
+                        notification_queue.put({
+                            "type": "success",
+                            "message": f"Assigned marks for {filename}: {marks}"
+                        })
                         
                         # Update progress
                         processed_count += 1
@@ -610,6 +691,10 @@ def compute_marks():
                     except Exception as e:
                         error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
                         log_print(f"Error processing file {file.filename}: {error_msg}", "ERROR")
+                        notification_queue.put({
+                            "type": "error",
+                            "message": f"Error processing file {file.filename}: {error_msg}"
+                        })
                         failed_files.append({
                             "file": file.filename,
                             "error": error_msg
@@ -619,6 +704,10 @@ def compute_marks():
                 except Exception as e:
                     error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
                     log_print(f"Error processing file {file.filename}: {error_msg}", "ERROR")
+                    notification_queue.put({
+                        "type": "error",
+                        "message": f"Error processing file {file.filename}: {error_msg}"
+                    })
                     failed_files.append({
                         "file": file.filename,
                         "error": error_msg
@@ -636,6 +725,7 @@ def compute_marks():
         if not results:
             log_print("No results computed", "ERROR")
             return jsonify({
+                "status": "error",
                 "error": "Processing error",
                 "message": "No results computed"
             }), 400
@@ -653,6 +743,7 @@ def compute_marks():
         log_print(f"Final results: {clean_results}")
         
         response_data = {
+            "status": "success",
             "results": clean_results,
             "failed_files": [{
                 "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
@@ -674,6 +765,7 @@ def compute_marks():
         error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
         log_print(f"Error in compute_marks: {error_msg}", "ERROR")
         return jsonify({
+            "status": "error",
             "error": "Server error",
             "message": f"Error computing marks: {error_msg}"
         }), 500

templates/index.html

@@ -1312,7 +1312,11 @@
                     const response = await fetch('/compute_marks', {
                         method: 'POST',
                         body: formData,
-                        keepalive: true
+                        keepalive: true,
+                        headers: {
+                            'Accept': 'application/json',
+                            'X-Requested-With': 'XMLHttpRequest'
+                        }
                     });
                     console.log(`Server response status: ${response.status}`);
                     notificationSystem.info(`Server response status: ${response.status}`);
@@ -1334,34 +1338,57 @@
                                 return;
                             }
 
-                            if (data.type === 'extracted_text') {
-                                console.log(`Extracted text from ${data.filename}`);
-                                notificationSystem.info(`Extracted text from ${data.filename}:\n${data.text}`, 8000);
-                            } else if (data.type === 'progress') {
-                                console.log(`Progress update: ${data.processed}/${data.total} files`);
-                                // Update progress in loading text
-                                const loadingText = document.querySelector('.loading-text');
-                                if (loadingText) {
-                                    loadingText.innerHTML = `
+                            // Update loading text with more detailed information
+                            const loadingText = document.querySelector('.loading-text');
+                            if (loadingText) {
+                                let currentText = loadingText.innerHTML;
+                                if (data.type === 'progress') {
+                                    currentText = `
                                         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>
                                     `;
+                                } else if (data.type === 'info' || data.type === 'success' || data.type === 'warning' || data.type === 'error') {
+                                    // Add the new message to the existing text
+                                    currentText += `<br><small>${data.message}</small>`;
                                 }
-                                // Show progress notification
-                                notificationSystem.info(`Progress: ${data.processed}/${data.total} files processed\nCurrent file: ${data.current_file}`, 5000);
-                                // Reset error count on successful progress update
-                                errorCount = 0;
-                            } else if (data.type === 'error') {
-                                console.error('Server notification error:', data.message);
-                                notificationSystem.error(`Server error: ${data.message}`);
-                                errorCount++;
-                                if (errorCount >= maxErrors) {
-                                    eventSource.close();
-                                    notificationSystem.error('Lost connection to server. Please refresh the page.');
-                                }
+                                loadingText.innerHTML = currentText;
+                            }
+
+                            // Handle different notification types
+                            switch (data.type) {
+                                case 'extracted_text':
+                                    console.log(`Extracted text from ${data.filename}`);
+                                    notificationSystem.info(`Extracted text from ${data.filename}:\n${data.text}`, 8000);
+                                    break;
+                                case 'progress':
+                                    console.log(`Progress update: ${data.processed}/${data.total} files`);
+                                    notificationSystem.info(`Progress: ${data.processed}/${data.total} files processed\nCurrent file: ${data.current_file}`, 5000);
+                                    errorCount = 0;
+                                    break;
+                                case 'info':
+                                    console.log('Info:', data.message);
+                                    notificationSystem.info(data.message, 5000);
+                                    break;
+                                case 'success':
+                                    console.log('Success:', data.message);
+                                    notificationSystem.success(data.message, 5000);
+                                    break;
+                                case 'warning':
+                                    console.warn('Warning:', data.message);
+                                    notificationSystem.warning(data.message, 6000);
+                                    break;
+                                case 'error':
+                                    console.error('Error:', data.message);
+                                    notificationSystem.error(data.message, 8000);
+                                    errorCount++;
+                                    if (errorCount >= maxErrors) {
+                                        eventSource.close();
+                                        notificationSystem.error('Lost connection to server. Please refresh the page.');
+                                    }
+                                    break;
                             }
                         } catch (e) {
                             console.error('Error parsing notification data:', e);