new main

main.py

@@ -1,6 +1,19 @@
 import os
 import tempfile
 import nltk
+import logging
+import sys
+
+# Set up logging at the start of your main.py
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger(__name__)
 
 # Set up all cache and data directories in /tmp
 cache_dir = tempfile.mkdtemp()
@@ -122,56 +135,51 @@ def compute_marks():
         # Get and process answers
         a = request.form.get('answers')
         if not a:
+            logger.error("No answers provided")
             return jsonify({"error": "No answers provided"}), 400
         
-        print("\n=== Processing Answers ===")
-        print("Received answers:", a)
+        logger.info("=== Processing Answers ===")
+        logger.info(f"Received answers: {a}")
         a = json.loads(a)
         answers = []
         for i in a:
             ans = i.split('\n\n')
             answers.append(ans)
-        print("Number of reference answers:", len(answers))
+        logger.info(f"Processed answers structure: {answers}")
 
         # Process files and create data structure
         data = {}
         parent_folder = os.path.join(cache_dir, 'student_answers')
         os.makedirs(parent_folder, exist_ok=True)
         
-        print("\n=== Processing Uploaded Files ===")
-        # First, save uploaded files
+        logger.info("=== Processing Uploaded Files ===")
         files = request.files.getlist('files[]')
         if not files:
+            logger.error("No files uploaded")
             return jsonify({"error": "No files uploaded"}), 400
 
-        print(f"Number of files received: {len(files)}")
+        logger.info(f"Number of files received: {len(files)}")
         
-        # Save files to temporary directory with proper naming
+        # File processing with logging
         for file in files:
             if file.filename.endswith(('.jpg', '.jpeg', '.png')):
                 relative_path = file.filename.replace('\\', '/')
                 path_parts = relative_path.split('/')
                 
-                print(f"\nProcessing file: {file.filename}")
-                print(f"Path parts: {path_parts}")
+                logger.info(f"Processing file: {file.filename}")
+                logger.info(f"Path parts: {path_parts}")
                 
                 if len(path_parts) >= 2:
                     student_folder = path_parts[1]
                     file_name = path_parts[-1]
                     
-                    print(f"Student folder: {student_folder}")
-                    print(f"File name: {file_name}")
-                    
-                    # Create student folder
                     student_dir = os.path.join(parent_folder, student_folder)
                     os.makedirs(student_dir, exist_ok=True)
                     
-                    # Save file with original name to maintain order
                     save_path = os.path.join(student_dir, file_name)
                     file.save(save_path)
-                    print(f"Saved to: {save_path}")
+                    logger.info(f"Saved file: {save_path}")
                     
-                    # Store in data structure
                     if student_folder not in data:
                         data[student_folder] = []
                     data[student_folder].append({
@@ -179,64 +187,32 @@ def compute_marks():
                         'name': os.path.splitext(file_name)[0]
                     })
                 else:
-                    print(f"Warning: File {file.filename} doesn't have the expected folder structure")
+                    logger.warning(f"File {file.filename} doesn't have expected structure")
 
-        print("\n=== Final Data Structure ===")
+        # Log data structure
+        logger.info("=== Final Data Structure ===")
         for student, images in data.items():
-            print(f"\nStudent: {student}")
-            print("Images:")
+            logger.info(f"Student: {student}")
             for img in sorted(images, key=lambda x: x['name']):
-                print(f"  - {img['name']} ({img['path']})")
+                logger.info(f"  - {img['name']} ({img['path']})")
 
-        # Verify mapping before processing
-        print("\n=== Verifying File Mapping ===")
-        for student_folder, images in data.items():
-            print(f"\nChecking student folder: {student_folder}")
-            actual_files = os.listdir(os.path.join(parent_folder, student_folder))
-            mapped_files = [os.path.basename(img['path']) for img in images]
-            
-            print(f"Files in directory: {actual_files}")
-            print(f"Files in data structure: {mapped_files}")
-            
-            # Check for mismatches
-            missing_files = set(actual_files) - set(mapped_files)
-            extra_files = set(mapped_files) - set(actual_files)
-            
-            if missing_files:
-                print(f"Warning: Files in directory but not mapped: {missing_files}")
-            if extra_files:
-                print(f"Warning: Files mapped but not in directory: {extra_files}")
-
-        # Create vectors for reference answers
-        sen_vec_answers = []
-        word_vec_answers = []
-        for answer_set in answers:
-            temp_v = []
-            temp_w = []
-            for ans in answer_set:
-                temp_v.append(question_vector_sentence(ans))
-                temp_w.append(question_vector_word(ans))
-            sen_vec_answers.append(temp_v)
-            word_vec_answers.append(temp_w)
-
-        # Calculate marks
+        # Calculate marks with logging
         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}/{image_info['name']}:")
-                    print(f"Extracted answer: {s_answer}")
+                    logger.info(f"\nProcessing {student_folder}/{image_info['name']}:")
+                    logger.info(f"Extracted answer: {s_answer}")
                     
                     if s_answer and idx < len(answers):
-                        print(f"Reference answer: {answers[idx]}")
+                        logger.info(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])
@@ -246,47 +222,39 @@ def compute_marks():
                         mark_value = round(float(m), 2)
                         student_total += mark_value
                         student_count += 1
+                        logger.info(f"Marks awarded: {mark_value}")
                     else:
                         mark_value = 0
+                        logger.warning(f"No text extracted or no reference answer for index {idx}")
                     
                     results.append({
                         'student': student_folder,
                         'image_name': image_info['name'],
                         'marks': mark_value
                     })
-                    print(f"Marks awarded: {mark_value}")
                     
                 except Exception as e:
-                    print(f"Error processing {image_path}: {str(e)}")
+                    logger.error(f"Error processing {image_path}: {str(e)}")
                     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:")
+        logger.info("\nFinal Results:")
         for r in results:
-            print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
+            logger.info(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
 
         # Clean up temporary directory
         try:
             import shutil
             shutil.rmtree(parent_folder)
-            print(f"Cleaned up temporary directory: {parent_folder}")
+            logger.info(f"Cleaned up temporary directory: {parent_folder}")
         except Exception as e:
-            print(f"Warning: Could not clean up temporary directory: {e}")
+            logger.warning(f"Warning: Could not clean up temporary directory: {e}")
 
         return jsonify({
             "message": results,
@@ -294,7 +262,7 @@ def compute_marks():
         }), 200
 
     except Exception as e:
-        print("Error in compute_marks:", str(e))
+        logger.error("Error in compute_marks:", str(e))
         try:
             import shutil
             shutil.rmtree(parent_folder)
@@ -304,44 +272,50 @@ def compute_marks():
 
 
 
-def marks(answer,sen_vec_answers,word_vec_answers,tf_idf_word_values, max_tfidf,correct_answers):
+def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfidf, correct_answers):
     marks = 0
-    marks1 = tfidf_answer_score(answer,tf_idf_word_values,max_tfidf,marks =10)
+    logger.info("=== Marks Calculation ===")
+    logger.info(f"Processing answer: {answer[:100]}...")  # Log first 100 chars
     
-    if marks1>3:
-        marks += new_value(marks1, old_min = 3, old_max=10, new_min=0, new_max=5)
-        # print("TFIDF Score",float(marks))
+    marks1 = tfidf_answer_score(answer, tf_idf_word_values, max_tfidf, marks=10)
+    logger.info(f"TFIDF Score: {marks1}")
+    
+    if marks1 > 3:
+        marks += new_value(marks1, old_min=3, old_max=10, new_min=0, new_max=5)
+        logger.info(f"After TFIDF adjustment: {marks}")
+        
+    if marks1 > 2:
+        marks2 = similarity_model_score(sen_vec_answers, answer)
+        logger.info(f"Sentence Similarity Score: {marks2}")
         
-    if marks1>2:
-        marks2 = similarity_model_score(sen_vec_answers,answer)
-        a = 0
-        if marks2>0.95:
+        if marks2 > 0.95:
             marks += 3
-            a = a+3
-        elif marks2>0.5:
-            marks += new_value(marks2, old_min = 0.5, old_max=0.95, new_min=0, new_max=3)
-            a = a+new_value(marks2, old_min = 0.5, old_max=0.95, new_min=0, new_max=3)
-        # print("sentence-transformers/all-MiniLM-L6-v2 with Cosine Similarity",a)
-
-        marks3 = fasttext_similarity(word_vec_answers,answer)
-        b = 0
-        if marks2>0.9:
+        elif marks2 > 0.5:
+            marks += new_value(marks2, old_min=0.5, old_max=0.95, new_min=0, new_max=3)
+        
+        marks3 = fasttext_similarity(word_vec_answers, answer)
+        logger.info(f"Word Similarity Score: {marks3}")
+        
+        if marks3 > 0.9:  # Fixed the condition to use marks3 instead of marks2
             marks += 2
-            b= b+2
-        elif marks3>0.4:
-            marks += new_value(marks3, old_min = 0.4, old_max=0.9, new_min=0, new_max=2)
-            b=b+new_value(marks3, old_min = 0.4, old_max=0.9, new_min=0, new_max=2)
-        # print("fasttext-wiki-news-subwords-300 with Soft Cosine Similarity",b)
-
-        marks4 = llm_score(correct_answers,answer)
+        elif marks3 > 0.4:
+            marks += new_value(marks3, old_min=0.4, old_max=0.9, new_min=0, new_max=2)
+        
+        marks4 = llm_score(correct_answers, answer)
+        logger.info(f"LLM Scores: {marks4}")
+        
         for i in range(len(marks4)):
             marks4[i] = float(marks4[i])
-
+        
         m = max(marks4)
-        # print("llm score",m/2)
-        marks = marks/2 + m/2
+        logger.info(f"Max LLM Score: {m}")
         
-        return marks
+        marks = marks/2 + m/2
+        logger.info(f"Final marks: {marks}")
+    else:
+        logger.warning("TFIDF score too low, returning 0")
+    
+    return marks