new main

main.py

@@ -134,14 +134,15 @@ def compute_marks():
 
         # Process files and create data structure
         data = {}
-        parent_folder = os.path.join(cache_dir, 'student_answers')  # Use temp directory
+        parent_folder = os.path.join(cache_dir, 'student_answers')
+        os.makedirs(parent_folder, exist_ok=True)
         
         # First, save uploaded files
         files = request.files.getlist('files[]')
         if not files:
             return jsonify({"error": "No files uploaded"}), 400
 
-        # Save files to temporary directory
+        # Save files to temporary directory with proper naming
         for file in files:
             if file.filename.endswith(('.jpg', '.jpeg', '.png')):
                 relative_path = file.filename.replace('\\', '/')
@@ -155,26 +156,19 @@ def compute_marks():
                     student_dir = os.path.join(parent_folder, student_folder)
                     os.makedirs(student_dir, exist_ok=True)
                     
-                    # Save file
+                    # Save file with original name to maintain order
                     save_path = os.path.join(student_dir, file_name)
                     file.save(save_path)
-                    print(f"Saved file: {save_path}")
-
-        print("Files saved, now processing folders...")
-
-        # Process the saved files
-        for student_folder in os.listdir(parent_folder):
-            student_path = os.path.join(parent_folder, student_folder)
-            if os.path.isdir(student_path):
-                for image_file in os.listdir(student_path):
-                    if image_file.endswith(('.jpg', '.jpeg', '.png')):
-                        full_path = os.path.join(student_path, image_file).replace("\\", "/")
-                        if student_folder in data:
-                            data[student_folder].append(full_path)
-                        else:
-                            data[student_folder] = [full_path]
+                    
+                    # Store in data structure
+                    if student_folder not in data:
+                        data[student_folder] = []
+                    data[student_folder].append({
+                        'path': save_path,
+                        'name': os.path.splitext(file_name)[0]
+                    })
 
-        print("Folder structure:", data)
+        print("Initial data structure:", data)
 
         # Create vectors for reference answers
         sen_vec_answers = []
@@ -189,38 +183,65 @@ def compute_marks():
             word_vec_answers.append(temp_w)
 
         # Calculate marks
-        s_marks = {}
-        for student_folder in data:
-            s_marks[student_folder] = []
-            count = 0
-            for image_path in sorted(data[student_folder]):  # Sort to ensure consistent order
+        results = []
+        for student_folder, images in data.items():
+            student_total = 0
+            student_count = 0
+            
+            # Sort images by name to maintain order
+            sorted_images = sorted(images, key=lambda x: x['name'])
+            
+            for idx, image_info in enumerate(sorted_images):
                 try:
+                    image_path = image_info['path']
                     s_answer = extract_text_from_image(image_path)
-                    print(f"\nProcessing {student_folder}'s answer {count + 1}:")
+                    print(f"\nProcessing {student_folder}/{image_info['name']}:")
                     print(f"Extracted answer: {s_answer}")
-                    print(f"Reference answer: {answers[count]}")
                     
-                    if s_answer:
-                        tf_idf_word_values, max_tfidf = create_tfidf_values(answers[count])
-                        m = marks(s_answer, sen_vec_answers[count], word_vec_answers[count],
-                                tf_idf_word_values, max_tfidf, answers[count])
+                    if s_answer and idx < len(answers):
+                        print(f"Reference answer: {answers[idx]}")
+                        tf_idf_word_values, max_tfidf = create_tfidf_values(answers[idx])
+                        m = marks(s_answer, sen_vec_answers[idx], word_vec_answers[idx],
+                                tf_idf_word_values, max_tfidf, answers[idx])
                         
                         if isinstance(m, torch.Tensor):
                             m = m.item()
-                        m = round(float(m), 2)
+                        mark_value = round(float(m), 2)
+                        student_total += mark_value
+                        student_count += 1
                     else:
-                        print(f"Warning: No text extracted from {image_path}")
-                        m = 0
+                        mark_value = 0
+                    
+                    results.append({
+                        'student': student_folder,
+                        'image_name': image_info['name'],
+                        'marks': mark_value
+                    })
+                    print(f"Marks awarded: {mark_value}")
                     
-                    s_marks[student_folder].append(m)
-                    print(f"Marks awarded: {m}")
-                    count += 1
                 except Exception as e:
                     print(f"Error processing {image_path}: {str(e)}")
-                    s_marks[student_folder].append(0)
-                    count += 1
-
-        print("\nFinal marks:", s_marks)
+                    results.append({
+                        'student': student_folder,
+                        'image_name': image_info['name'],
+                        'marks': 0
+                    })
+            
+            # Add average for student
+            if student_count > 0:
+                avg_mark = round(student_total / student_count, 2)
+                results.append({
+                    'student': student_folder,
+                    'image_name': 'AVERAGE',
+                    'marks': avg_mark
+                })
+
+        # Sort results
+        results.sort(key=lambda x: (x['student'], x['image_name']))
+
+        print("\nFinal Results:")
+        for r in results:
+            print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
 
         # Clean up temporary directory
         try:
@@ -230,7 +251,10 @@ def compute_marks():
         except Exception as e:
             print(f"Warning: Could not clean up temporary directory: {e}")
 
-        return jsonify({"message": s_marks}), 200
+        return jsonify({
+            "message": results,
+            "status": "success"
+        }), 200
 
     except Exception as e:
         print("Error in compute_marks:", str(e))