solving some error and try to print it in front end

main.py

@@ -368,10 +368,14 @@ def notifications():
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
     try:
+        log_print("\n=== Starting Compute Marks Process ===")
+        
         # Wait for initialization to complete
         if not initialization_complete.is_set():
+            log_print("Waiting for initialization...")
             wait_for_initialization()
             if not initialization_complete.is_set():
+                log_print("Initialization timeout", "ERROR")
                 return jsonify({
                     "error": "Server initialization",
                     "message": "Server is still initializing. Please try again in a moment."
@@ -379,6 +383,7 @@ def compute_marks():
 
         # Check content type
         if not request.is_json and not request.form:
+            log_print("Invalid request format", "ERROR")
             return jsonify({
                 "error": "Invalid request format",
                 "message": "Request must be either JSON or form data"
@@ -387,15 +392,17 @@ def compute_marks():
         # Get correct answers
         correct_answers = request.form.getlist('correct_answers[]')
         if not correct_answers:
+            log_print("No correct answers provided", "ERROR")
             return jsonify({
                 "error": "Missing data",
                 "message": "No correct answers provided"
             }), 400
 
-        log_print(f"Received correct answers: {correct_answers}")
+        log_print(f"Received {len(correct_answers)} correct answers")
         
         # Create TFIDF values for correct answers
         try:
+            log_print("Creating TFIDF values...")
             max_tfidf = create_tfidf_values(correct_answers)
             log_print("Created TFIDF values successfully")
         except Exception as e:
@@ -408,6 +415,7 @@ def compute_marks():
         # Get all uploaded files
         files = request.files.getlist('file')
         if not files:
+            log_print("No files uploaded", "ERROR")
             return jsonify({
                 "error": "Missing data",
                 "message": "No files uploaded"
@@ -422,6 +430,7 @@ def compute_marks():
             
         max_size = 15 * 1024 * 1024  # 15MB
         if total_size > max_size:
+            log_print(f"File size limit exceeded: {total_size / 1024 / 1024:.1f}MB", "ERROR")
             return jsonify({
                 "error": "File size limit exceeded",
                 "message": f"Total file size must be less than 15MB (current size: {total_size / 1024 / 1024:.1f}MB)"
@@ -457,6 +466,8 @@ def compute_marks():
         processed_count = 0
         total_files = len(files)
         
+        log_print(f"Starting to process {total_files} files...")
+        
         try:
             # Process each file
             for file in files:
@@ -507,6 +518,7 @@ def compute_marks():
                         log_print(f"Saved file to: {filepath}")
                         
                         # Extract text
+                        log_print(f"Extracting text from: {filepath}")
                         extracted_text = extract_text_from_image(filepath)
                         
                         # Clean up the file immediately after processing
@@ -550,6 +562,7 @@ def compute_marks():
                                 clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
                                 
                                 # Calculate similarity scores
+                                log_print(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)
@@ -592,6 +605,7 @@ def compute_marks():
                             "current_file": filename
                         }
                         notification_queue.put(progress_data)
+                        log_print(f"Progress update: {processed_count}/{total_files} files processed")
                         
                     except Exception as e:
                         error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
@@ -650,10 +664,10 @@ def compute_marks():
             }
         }
         
-        log_print(f"Sending response: {response_data}")
-        
+        log_print("Sending response...")
         response = jsonify(response_data)
         response.headers['Content-Type'] = 'application/json'
+        log_print("=== Compute Marks Process Completed ===")
         return response
         
     except Exception as e:

templates/index.html

@@ -1225,24 +1225,29 @@
 
         async function computeMarks() {
             try {
+                console.log("=== Starting Compute Marks Process ===");
                 showLoading();
                 const answerBoxes = document.querySelectorAll('.answer-box');
                 
                 if (answerBoxes.length === 0) {
+                    console.error("No answer boxes found");
                     notificationSystem.error("Please generate answers first!");
                     hideLoading();
                     return;
                 }
 
                 const answerValues = Array.from(answerBoxes).map(box => box.value.trim());
+                console.log(`Found ${answerValues.length} answer boxes`);
                 
                 if (answerValues.some(answer => !answer)) {
+                    console.error("Empty answer boxes found");
                     notificationSystem.error("Please ensure all answer boxes are filled!");
                     hideLoading();
                     return;
                 }
 
                 if (selectedFiles.size === 0) {
+                    console.error("No files selected");
                     notificationSystem.error("Please upload student answer files!");
                     hideLoading();
                     return;
@@ -1257,6 +1262,8 @@
                         throw new Error(`Total file size exceeds 15MB limit. Please reduce the number of files.`);
                     }
                 }
+                console.log(`Total file size: ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
+                notificationSystem.info(`Total file size: ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
 
                 notificationSystem.info(`Processing ${selectedFiles.size} student files. This may take several minutes...`);
 
@@ -1269,6 +1276,8 @@
                 answerValues.forEach((answer, index) => {
                     formData.append('correct_answers[]', answer);
                 });
+                console.log(`Added ${answerValues.length} correct answers to form data`);
+                notificationSystem.info(`Processing ${answerValues.length} correct answers...`);
 
                 // Add files with their folder structure
                 let validFiles = 0;
@@ -1278,12 +1287,14 @@
                         validFiles++;
                     }
                 });
+                console.log(`Added ${validFiles} valid image files to form data`);
+                notificationSystem.info(`Found ${validFiles} valid image files to process`);
 
                 if (validFiles === 0) {
                     throw new Error("No valid image files found in the uploaded folder");
                 }
 
-                notificationSystem.info(`Uploading and processing ${validFiles} files. Please be patient...`);
+                notificationSystem.info(`Starting to process ${validFiles} files. Please be patient...`);
                 
                 // Update loading message with more detailed progress
                 const loadingText = document.querySelector('.loading-text');
@@ -1294,20 +1305,29 @@
                     <small>Progress: 0/${validFiles} files processed</small>
                 `;
 
+                console.log("Sending request to server...");
+                notificationSystem.info("Sending request to server...");
+                
                 try {
                     const response = await fetch('/compute_marks', {
                         method: 'POST',
                         body: formData,
                         keepalive: true
                     });
+                    console.log(`Server response status: ${response.status}`);
+                    notificationSystem.info(`Server response status: ${response.status}`);
 
                     // Set up event source for real-time notifications
+                    console.log("Setting up EventSource connection...");
+                    notificationSystem.info("Setting up real-time progress updates...");
+                    
                     const eventSource = new EventSource('/notifications');
                     let errorCount = 0;
                     const maxErrors = 3;
 
                     eventSource.onmessage = function(event) {
                         try {
+                            console.log("Received notification:", event.data);
                             const data = JSON.parse(event.data);
                             if (!data || typeof data !== 'object') {
                                 console.warn('Received invalid notification data:', event.data);
@@ -1315,8 +1335,10 @@
                             }
 
                             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) {
@@ -1328,10 +1350,13 @@
                                         Current file: ${data.current_file}</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();
@@ -1340,6 +1365,7 @@
                             }
                         } catch (e) {
                             console.error('Error parsing notification data:', e);
+                            notificationSystem.error(`Error processing server update: ${e.message}`);
                             errorCount++;
                             if (errorCount >= maxErrors) {
                                 eventSource.close();
@@ -1350,37 +1376,54 @@
 
                     eventSource.onerror = function(error) {
                         console.error('EventSource error:', error);
-                        eventSource.close();
                         notificationSystem.error('Lost connection to server. Please refresh the page.');
+                        eventSource.close();
                     };
 
                     let result;
                     const contentType = response.headers.get('content-type');
+                    console.log(`Response content type: ${contentType}`);
+                    notificationSystem.info(`Response content type: ${contentType}`);
+                    
                     if (contentType && contentType.includes('application/json')) {
                         result = await response.json();
+                        console.log("Successfully parsed JSON response");
+                        notificationSystem.info("Successfully received server response");
                     } else {
+                        console.error(`Invalid content type: ${contentType}`);
+                        notificationSystem.error(`Invalid response type: ${contentType}`);
                         throw new Error('Server returned non-JSON response');
                     }
 
                     // Close event source after getting final response
                     eventSource.close();
+                    console.log("Closed EventSource connection");
+                    notificationSystem.info("Completed processing all files");
 
                     if (!response.ok) {
+                        console.error(`Server error: ${response.status}`);
+                        notificationSystem.error(`Server error: ${response.status}`);
                         throw new Error(result.message || result.error || `Server error: ${response.status}`);
                     }
 
                     if (result.status === 'error') {
+                        console.error(`Server returned error: ${result.message || result.error}`);
+                        notificationSystem.error(`Server error: ${result.message || result.error}`);
                         throw new Error(result.message || result.error);
                     }
 
                     if (!result.results) {
+                        console.error("No results in response");
+                        notificationSystem.error("No results received from server");
                         throw new Error('No results found in server response');
                     }
 
-                    displayMarks(result.results);
+                    console.log("Successfully received results");
                     notificationSystem.success("Successfully computed marks!");
+                    displayMarks(result.results);
 
                     if (result.failed_files && result.failed_files.length > 0) {
+                        console.warn(`Some files failed to process: ${result.failed_files.length} files`);
                         const failedMessage = result.failed_files
                             .map(f => `${f.file}: ${f.error}`)
                             .join('\n');
@@ -1389,6 +1432,7 @@
 
                 } catch (fetchError) {
                     console.error('Fetch error:', fetchError);
+                    notificationSystem.error(`Fetch error: ${fetchError.message}`);
                     if (!navigator.onLine) {
                         throw new Error('No internet connection. Please check your connection and try again.');
                     } else {
@@ -1400,6 +1444,8 @@
                 console.error('Error details:', error);
                 notificationSystem.error(error.message || 'Error computing marks. Please try again.');
             } finally {
+                console.log("=== Compute Marks Process Completed ===");
+                notificationSystem.info("Process completed");
                 hideLoading();
                 const computeBtn = document.getElementById('compute-marks-btn');
                 computeBtn.disabled = false;