new main

main.py

@@ -119,49 +119,64 @@ def compute_answers():
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
     try:
-        # Create a temporary directory for this session
-        temp_dir = os.path.join(cache_dir, 'student_answers')
-        os.makedirs(temp_dir, exist_ok=True)
+        # Get and process answers
+        a = request.form.get('answers')
+        if not a:
+            return jsonify({"error": "No answers provided"}), 400
         
-        # Add validation for folder structure
-        def validate_file_structure(file_path):
-            parts = file_path.replace('\\', '/').split('/')
-            if len(parts) < 3:  # Should have: main_folder/student_folder/image.jpg
-                return False
-            if not parts[1]:  # Check if student folder name exists
-                return False
-            if not parts[-1].lower().endswith(('.jpg', '.jpeg', '.png')):
-                return False
-            return True
-
-        print("=== Starting compute_marks in temporary directory ===")
-        print(f"Using temporary directory: {temp_dir}")
-        
-        # Process answers with validation
-        try:
-            a = request.form.get('answers')
-            if not a:
-                return jsonify({"error": "No answers provided"}), 400
-            
-            answers = json.loads(a)
-            if not isinstance(answers, list):
-                return jsonify({"error": "Invalid answer format"}), 400
-            
-            processed_answers = []
-            for ans in answers:
-                if isinstance(ans, str):
-                    processed_answers.append([ans])
-                elif isinstance(ans, list):
-                    processed_answers.append(ans)
-                else:
-                    return jsonify({"error": "Invalid answer format"}), 400
-            
-            answers = processed_answers
-            
-        except json.JSONDecodeError:
-            return jsonify({"error": "Invalid JSON format for answers"}), 400
+        print("Received answers:", a)
+        a = json.loads(a)
+        answers = []
+        for i in a:
+            ans = i.split('\n\n')
+            answers.append(ans)
+        print("Processed answers:", answers)
+
+        # Process files and create data structure
+        data = {}
+        parent_folder = os.path.join(cache_dir, 'student_answers')  # Use temp directory
         
-        # Create vectors for reference answers first
+        # First, save uploaded files
+        files = request.files.getlist('files[]')
+        if not files:
+            return jsonify({"error": "No files uploaded"}), 400
+
+        # Save files to temporary directory
+        for file in files:
+            if file.filename.endswith(('.jpg', '.jpeg', '.png')):
+                relative_path = file.filename.replace('\\', '/')
+                path_parts = relative_path.split('/')
+                
+                if len(path_parts) >= 2:
+                    student_folder = path_parts[1]
+                    file_name = path_parts[-1]
+                    
+                    # Create student folder
+                    student_dir = os.path.join(parent_folder, student_folder)
+                    os.makedirs(student_dir, exist_ok=True)
+                    
+                    # Save file
+                    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]
+
+        print("Folder structure:", data)
+
+        # Create vectors for reference answers
         sen_vec_answers = []
         word_vec_answers = []
         for answer_set in answers:
@@ -172,159 +187,56 @@ def compute_marks():
                 temp_w.append(question_vector_word(ans))
             sen_vec_answers.append(temp_v)
             word_vec_answers.append(temp_w)
-        
-        # Process uploaded files with better validation
-        files = request.files.getlist('files[]')
-        if not files:
-            return jsonify({"error": "No files uploaded"}), 400
-            
-        data = {}
-        invalid_files = []
-        
-        for file in files:
-            try:
-                if not validate_file_structure(file.filename):
-                    invalid_files.append(file.filename)
-                    continue
 
-                relative_path = file.filename.replace('\\', '/')
-                path_parts = relative_path.split('/')
-                
-                student_folder = path_parts[1]
-                file_name = path_parts[-1]
-                
-                # Create student folder in temp directory
-                student_dir = os.path.join(temp_dir, student_folder)
-                os.makedirs(student_dir, exist_ok=True)
-                
-                # Save file with secure filename
-                secure_name = secure_filename(file_name)
-                save_path = os.path.join(student_dir, secure_name)
-                file.save(save_path)
-                
-                # Store in data structure with better organization
-                if student_folder not in data:
-                    data[student_folder] = []
-                
-                data[student_folder].append({
-                    'path': save_path.replace('\\', '/'),
-                    'name': os.path.splitext(secure_name)[0],
-                    'original_path': relative_path,
-                    'original_name': file_name
-                })
-                print(data)
-                print(f"Saved file: {save_path} for student: {student_folder}")
-            
-            except Exception as e:
-                print(f"Error processing file {file.filename}: {str(e)}")
-                invalid_files.append(file.filename)
-
-        print("\nProcessed folder structure:")
-        for student, files in data.items():
-            print(f"\nStudent folder: {student}")
-            for f in files:
-                print(f"  - {f['name']}")
-
-        # Calculate marks with better error handling
-        results = []
-        errors = []
-        
-        for student_folder, images in sorted(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 sorted(data[student_folder]):  # Sort to ensure consistent order
                 try:
-                    image_path = image_info['path']
-                    if not os.path.exists(image_path):
-                        raise FileNotFoundError(f"Image file not found: {image_path}")
-                    
                     s_answer = extract_text_from_image(image_path)
-                    if not s_answer:
-                        print(f"Warning: No text extracted from {image_path}")
-                        s_answer = ""
-                    
-                    print(f"\nProcessing {student_folder}/{image_info['name']}:")
+                    print(f"\nProcessing {student_folder}'s answer {count + 1}:")
                     print(f"Extracted answer: {s_answer}")
-
-                    if idx < len(answers):
-                        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])
+                    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])
                         
-                        mark_value = float(m.item() if isinstance(m, torch.Tensor) else m)
-                        mark_value = round(mark_value, 2)
-                        student_total += mark_value
-                        student_count += 1
+                        if isinstance(m, torch.Tensor):
+                            m = m.item()
+                        m = round(float(m), 2)
                     else:
-                        mark_value = 0
-                        errors.append(f"No answer provided for {student_folder}/{image_info['name']}")
-
-                    results.append({
-                        'student': student_folder,
-                        'image_name': image_info['name'],
-                        'marks': mark_value,
-                        'answer_extracted': bool(s_answer)
-                    })
+                        print(f"Warning: No text extracted from {image_path}")
+                        m = 0
                     
+                    s_marks[student_folder].append(m)
+                    print(f"Marks awarded: {m}")
+                    count += 1
                 except Exception as e:
-                    error_msg = f"Error processing {image_path}: {str(e)}"
-                    print(error_msg)
-                    errors.append(error_msg)
-                    results.append({
-                        'student': student_folder,
-                        'image_name': image_info['name'],
-                        'marks': 0,
-                        'error': str(e)
-                    })
-            
-            # Add student average
-            if student_count > 0:
-                results.append({
-                    'student': student_folder,
-                    'image_name': 'AVERAGE',
-                    'marks': round(student_total / student_count, 2)
-                })
-
-        # Clean up temporary files
+                    print(f"Error processing {image_path}: {str(e)}")
+                    s_marks[student_folder].append(0)
+                    count += 1
+
+        print("\nFinal marks:", s_marks)
+
+        # Clean up temporary directory
         try:
             import shutil
-            shutil.rmtree(temp_dir)
-            print(f"\nCleaned up temporary directory: {temp_dir}")
+            shutil.rmtree(parent_folder)
+            print(f"Cleaned up temporary directory: {parent_folder}")
         except Exception as e:
             print(f"Warning: Could not clean up temporary directory: {e}")
 
-        # Sort results by student folder and then by image name
-        results.sort(key=lambda x: (x['student'], x['image_name']))
-        
-        # Prepare final response
-        response_data = {
-            "message": results,
-            "summary": {
-                "total_files_processed": sum(len(files) for files in data.values()),
-                "total_students": len(data),
-                "invalid_files": invalid_files,
-                "errors": errors if errors else None
-            }
-        }
-
-        print("\nFinal Results Table:")
-        print("Student Folder\tImage Name\tMarks")
-        print("-" * 50)
-        for r in results:
-            print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
-
-        return jsonify(response_data), 200
+        return jsonify({"message": s_marks}), 200
 
     except Exception as e:
         print("Error in compute_marks:", str(e))
-        # Clean up temporary files in case of error
         try:
             import shutil
-            shutil.rmtree(temp_dir)
-            print(f"Cleaned up temporary directory after error: {temp_dir}")
+            shutil.rmtree(parent_folder)
         except:
             pass
         return jsonify({"error": str(e)}), 500