fix json formate from main.py

main.py

@@ -250,152 +250,136 @@ def compute_answers():
 
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
-    if request.headers.get('Accept') == 'application/json':
-        try:
-            log_print("\n=== Starting Marks Computation ===")
-            
-            # Get correct answers
-            correct_answers = request.form.getlist('correct_answers[]')
-            if not correct_answers:
-                log_print("No correct answers provided", "ERROR")
-                return jsonify({"error": "No correct answers provided"}), 400
-                
-            # Create TFIDF values for correct answers
-            max_tfidf = create_tfidf_values(correct_answers)
+    try:
+        # Get correct answers
+        correct_answers = request.form.getlist('correct_answers[]')
+        if not correct_answers:
+            return jsonify({"error": "No correct answers provided"}), 400, {'Content-Type': 'application/json'}
             
-            # Get all uploaded files
-            files = request.files.getlist('file')
-            if not files:
-                log_print("No files uploaded", "ERROR")
-                return jsonify({"error": "No files uploaded"}), 400
+        # Create TFIDF values for correct answers
+        max_tfidf = create_tfidf_values(correct_answers)
+        
+        # Get all uploaded files
+        files = request.files.getlist('file')
+        if not files:
+            return jsonify({"error": "No files uploaded"}), 400, {'Content-Type': 'application/json'}
 
-            # Create a temporary directory for processing
-            base_temp_dir = tempfile.mkdtemp()
-            
-            # Dictionary to store results by student folder
-            results = {}
-            failed_files = []
-            
-            try:
-                # Process each file
-                for file in files:
-                    try:
-                        # Get folder structure from file path
-                        path_parts = file.filename.split('/')
-                        if len(path_parts) < 2:
-                            continue
-                            
-                        student_folder = path_parts[-2]
-                        filename = path_parts[-1]
-                        
-                        if student_folder not in results:
-                            results[student_folder] = [0] * len(correct_answers)
-                            
-                        # Save and process file
-                        student_dir = os.path.join(base_temp_dir, student_folder)
-                        os.makedirs(student_dir, exist_ok=True)
-                        filepath = os.path.join(student_dir, filename)
-                        file.save(filepath)
-                        
-                        # Extract text
-                        extracted_text = extract_text_from_image(filepath)
-                        if not extracted_text:
-                            log_print(f"No text extracted from {file.filename}", "WARNING")
-                            failed_files.append({
-                                "file": file.filename,
-                                "error": "No text could be extracted"
-                            })
-                            continue
-                        
-                        # Clean the extracted text for JSON
-                        extracted_text = extracted_text.encode('ascii', 'ignore').decode('ascii')
-                        log_print(f"Extracted text from {file.filename}: {extracted_text}")
-                        
-                        # Find best matching answer
-                        best_score = 0
-                        best_answer_index = 0
-                        
-                        for i, correct_answer in enumerate(correct_answers):
-                            try:
-                                # Clean the correct answer for comparison
-                                clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
-                                
-                                # Calculate similarity scores
-                                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)
-                                
-                                combined_score = (
-                                    semantic_score * 0.3 +
-                                    word_score * 0.2 +
-                                    tfidf_score * 0.2 +
-                                    ft_score * 0.2 +
-                                    llm_marks * 0.1
-                                )
-                                
-                                if combined_score > best_score:
-                                    best_score = combined_score
-                                    best_answer_index = i
-                                    
-                            except Exception as score_error:
-                                error_msg = str(score_error).encode('ascii', 'ignore').decode('ascii')
-                                failed_files.append({
-                                    "file": file.filename,
-                                    "error": f"Error calculating scores: {error_msg}"
-                                })
-                                continue
+        # Create a temporary directory for processing
+        base_temp_dir = tempfile.mkdtemp()
+        
+        # Dictionary to store results by student folder
+        results = {}
+        failed_files = []
+        
+        try:
+            # Process each file
+            for file in files:
+                try:
+                    # Get folder structure from file path
+                    path_parts = file.filename.split('/')
+                    if len(path_parts) < 2:
+                        continue
                         
-                        marks = new_value(best_score, 0, 1, 0, 5)
-                        results[student_folder][best_answer_index] = round(marks, 2)
+                    student_folder = path_parts[-2]
+                    filename = path_parts[-1]
+                    
+                    if student_folder not in results:
+                        results[student_folder] = [0] * len(correct_answers)
                         
-                    except Exception as e:
-                        error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+                    # Save and process file
+                    student_dir = os.path.join(base_temp_dir, student_folder)
+                    os.makedirs(student_dir, exist_ok=True)
+                    filepath = os.path.join(student_dir, filename)
+                    file.save(filepath)
+                    
+                    # Extract text
+                    extracted_text = extract_text_from_image(filepath)
+                    if not extracted_text:
                         failed_files.append({
                             "file": file.filename,
-                            "error": error_msg
+                            "error": "No text could be extracted"
                         })
                         continue
-                        
-            finally:
-                # Clean up temp directory
-                try:
-                    shutil.rmtree(base_temp_dir)
-                except Exception:
-                    pass
                     
-            if not results:
-                log_print("No results computed", "ERROR")
-                return jsonify({"error": "No results computed"}), 400
-                
-            # Clean the results for JSON response
-            clean_results = {}
-            for student, scores in results.items():
-                clean_student = student.encode('ascii', 'ignore').decode('ascii')
-                clean_results[clean_student] = scores
+                    # Clean the extracted text for JSON
+                    extracted_text = extracted_text.encode('ascii', 'ignore').decode('ascii')
+                    
+                    # Find best matching answer
+                    best_score = 0
+                    best_answer_index = 0
+                    
+                    for i, correct_answer in enumerate(correct_answers):
+                        try:
+                            # Clean the correct answer for comparison
+                            clean_correct_answer = correct_answer.encode('ascii', 'ignore').decode('ascii')
+                            
+                            # Calculate similarity scores
+                            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)
+                            
+                            combined_score = (
+                                semantic_score * 0.3 +
+                                word_score * 0.2 +
+                                tfidf_score * 0.2 +
+                                ft_score * 0.2 +
+                                llm_marks * 0.1
+                            )
+                            
+                            if combined_score > best_score:
+                                best_score = combined_score
+                                best_answer_index = i
+                                
+                        except Exception as score_error:
+                            error_msg = str(score_error).encode('ascii', 'ignore').decode('ascii')
+                            failed_files.append({
+                                "file": file.filename,
+                                "error": f"Error calculating scores: {error_msg}"
+                            })
+                            continue
+                    
+                    marks = new_value(best_score, 0, 1, 0, 5)
+                    results[student_folder][best_answer_index] = round(marks, 2)
+                    
+                except Exception as e:
+                    error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+                    failed_files.append({
+                        "file": file.filename,
+                        "error": error_msg
+                    })
+                    continue
+                    
+        finally:
+            # Clean up temp directory
+            try:
+                shutil.rmtree(base_temp_dir)
+            except Exception:
+                pass
                 
-            response_data = {
-                "results": clean_results,
-                "failed_files": [{
-                    "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
-                    "error": f["error"].encode('ascii', 'ignore').decode('ascii')
-                } for f in failed_files]
-            }
+        if not results:
+            return jsonify({"error": "No results computed"}), 400, {'Content-Type': 'application/json'}
             
-            response = make_response(jsonify(response_data))
-            response.headers['Content-Type'] = 'application/json'
-            return response, 200
+        # Clean the results for JSON response
+        clean_results = {}
+        for student, scores in results.items():
+            clean_student = student.encode('ascii', 'ignore').decode('ascii')
+            clean_results[clean_student] = scores
             
-        except Exception as e:
-            error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
-            response = make_response(jsonify({"error": f"Error computing marks: {error_msg}"}))
-            response.headers['Content-Type'] = 'application/json'
-            return response, 500
-    else:
-        response = make_response(jsonify({"error": "Invalid content type requested"}))
-        response.headers['Content-Type'] = 'application/json'
-        return response, 400
+        response_data = {
+            "results": clean_results,
+            "failed_files": [{
+                "file": f["file"].encode('ascii', 'ignore').decode('ascii'),
+                "error": f["error"].encode('ascii', 'ignore').decode('ascii')
+            } for f in failed_files]
+        }
+        
+        return jsonify(response_data), 200, {'Content-Type': 'application/json'}
+        
+    except Exception as e:
+        error_msg = str(e).encode('ascii', 'ignore').decode('ascii')
+        return jsonify({"error": f"Error computing marks: {error_msg}"}), 500, {'Content-Type': 'application/json'}
 
 @app.route('/check_logs')
 def check_logs():

templates/index.html

@@ -987,6 +987,7 @@
                     throw new Error("No valid image files found in the uploaded folder");
                 }
 
+                console.log('Sending request to compute marks...');
                 const response = await fetch('/compute_marks', {
                     method: 'POST',
                     headers: {
@@ -995,21 +996,34 @@
                     body: formData
                 });
 
+                console.log('Response received:', response);
+                console.log('Response headers:', response.headers);
                 const contentType = response.headers.get('Content-Type');
-                if (!contentType || !contentType.includes('application/json')) {
-                    throw new Error('Server did not return JSON');
+                console.log('Content-Type:', contentType);
+
+                let result;
+                const responseText = await response.text();
+                console.log('Response text:', responseText);
+
+                try {
+                    result = JSON.parse(responseText);
+                } catch (e) {
+                    console.error('Error parsing JSON:', e);
+                    throw new Error('Failed to parse server response as JSON');
                 }
 
                 if (!response.ok) {
-                    const errorData = await response.json();
-                    throw new Error(errorData.error || 'Server returned an error response');
+                    throw new Error(result.error || 'Server returned an error response');
                 }
 
-                const result = await response.json();
                 if (result.error) {
                     throw new Error(result.error);
                 }
 
+                if (!result.results) {
+                    throw new Error('No results found in server response');
+                }
+
                 displayMarks(result.results);
 
             } catch (error) {