update_

main.py

@@ -198,127 +198,78 @@ def compute_marks():
             answers.append(ans)
         log_print(f"Processed answers structure: {answers}")
 
-        # Process files and create data structure
+        # Initialize data structure and parent folder
         data = {}
-        parent_folder = os.path.join(cache_dir, 'student_answers')
-        os.makedirs(parent_folder, exist_ok=True)
+        parent_folder = "ans_image"  # Changed from cache_dir to match reference code
         
-        log_print("\n=== Processing Uploaded Files ===")
-        files = request.files.getlist('files[]')
-        if not files:
-            log_print("No files uploaded", "ERROR")
-            return jsonify({"error": "No files uploaded"}), 400
+        # Check if answers exist
+        if not answers:
+            log_print("No answers found", "ERROR")
+            return jsonify({"error": "Missing required files"}), 400
 
-        log_print(f"Number of files received: {len(files)}")
-        
-        # File processing
-        for file in files:
-            if file.filename.endswith(('.jpg', '.jpeg', '.png')):
-                relative_path = file.filename.replace('\\', '/')
-                path_parts = relative_path.split('/')
-                
-                log_print(f"\nProcessing file: {file.filename}")
-                log_print(f"Path parts: {path_parts}")
-                
-                if len(path_parts) >= 2:
-                    student_folder = path_parts[1]
-                    file_name = path_parts[-1]
-                    
-                    student_dir = os.path.join(parent_folder, student_folder)
-                    os.makedirs(student_dir, exist_ok=True)
-                    
-                    save_path = os.path.join(student_dir, file_name)
-                    file.save(save_path)
-                    log_print(f"Saved file: {save_path}")
-                    
-                    if student_folder not in data:
-                        data[student_folder] = []
-                    data[student_folder].append({
-                        'path': save_path,
-                        'name': os.path.splitext(file_name)[0]
-                    })
-                else:
-                    log_print(f"WARNING: File {file.filename} doesn't have expected structure")
+        # Process student folders and images
+        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')):  # Changed to match reference code
+                        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]
 
-        # Log data structure
-        log_print("\n=== Final Data Structure ===")
-        for student, images in data.items():
-            log_print(f"Student: {student}")
-            for img in sorted(images, key=lambda x: x['name']):
-                log_print(f"  - {img['name']} ({img['path']})")
+        # Initialize vectors for answers
+        sen_vec_answers = []
+        word_vec_answers = []
+        for i in answers:
+            temp_v = []
+            temp_w = []
+            for j in i:
+                temp_v.append(question_vector_sentence(j))
+                temp_w.append(question_vector_word(j))
+            sen_vec_answers.append(temp_v)
+            word_vec_answers.append(temp_w)
 
-        # Calculate marks with logging
-        results = []
-        for student_folder, images in data.items():
-            student_total = 0
-            student_count = 0
-            
-            sorted_images = sorted(images, key=lambda x: x['name'])
-            
-            for idx, image_info in enumerate(sorted_images):
+        # Calculate marks
+        s_marks = {}
+        for student_folder in data:
+            s_marks[student_folder] = []
+            count = 0
+            for image_path in data[student_folder]:
                 try:
-                    image_path = image_info['path']
                     s_answer = extract_text_from_image(image_path)
-                    log_print(f"\nProcessing {student_folder}/{image_info['name']}:")
+                    log_print(f"\nProcessing {student_folder}/{os.path.basename(image_path)}:")
                     log_print(f"Extracted answer: {s_answer}")
                     
-                    if s_answer and idx < len(answers):
-                        log_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 s_answer and count < len(answers):
+                        log_print(f"Reference answer: {answers[count]}")
+                        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 isinstance(m, torch.Tensor):
                             m = m.item()
-                        mark_value = round(float(m), 2)
-                        student_total += mark_value
-                        student_count += 1
-                        log_print(f"Marks awarded: {mark_value}")
+                        s_marks[student_folder].append(round(float(m), 2))
+                        log_print(f"Marks awarded: {m}")
                     else:
-                        mark_value = 0
-                        log_print(f"No text extracted or no reference answer for index {idx}", "WARNING")
+                        s_marks[student_folder].append(0)
+                        log_print(f"No text extracted or no reference answer for index {count}", "WARNING")
                     
-                    results.append({
-                        'student': student_folder,
-                        'image_name': image_info['name'],
-                        'marks': mark_value
-                    })
+                    count += 1
                     
                 except Exception as e:
                     log_print(f"Error processing {image_path}: {str(e)}", "ERROR")
-                    results.append({
-                        'student': student_folder,
-                        'image_name': image_info['name'],
-                        'marks': 0
-                    })
-
-        # Sort results
-        results.sort(key=lambda x: (x['student'], x['image_name']))
+                    s_marks[student_folder].append(0)
 
         log_print("\nFinal Results:")
-        for r in results:
-            log_print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
-
-        # Clean up temporary directory
-        try:
-            import shutil
-            shutil.rmtree(parent_folder)
-            log_print(f"Cleaned up temporary directory: {parent_folder}")
-        except Exception as e:
-            log_print(f"Warning: Could not clean up temporary directory: {e}", "WARNING")
+        for student, marks_list in s_marks.items():
+            log_print(f"{student}: {marks_list}")
 
-        return jsonify({
-            "message": results,
-            "status": "success"
-        }), 200
+        return jsonify({"message": s_marks}), 200
 
     except Exception as e:
         log_print(f"Error in compute_marks: {str(e)}", "ERROR")
-        try:
-            import shutil
-            shutil.rmtree(parent_folder)
-        except:
-            pass
         return jsonify({"error": str(e)}), 500
 
 def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfidf, correct_answers):