printing extracted text

main.py

@@ -536,29 +536,41 @@ def compute_marks():
             count = 0
             for filename, image_path in sorted_images:
                 try:
+                    # Extract text from image
                     s_answer = extract_text_from_image(image_path)
-                    logger.info(f"Extracted text from {image_path}: {s_answer}")
+                    logger.info(f"Processing student: {student}, image: {filename}")
+                    logger.info(f"Extracted text: {s_answer}")
                     
                     if not s_answer:
                         logger.warning(f"No text extracted from {image_path}")
                         results.append({
                             "subfolder": student,
                             "image": filename,
-                            "marks": 0
+                            "marks": 0,
+                            "extracted_text": "",
+                            "error": "No text could be extracted from image"
                         })
                         count += 1
                         continue
                     
+                    # Calculate TF-IDF scores
                     tf_idf_word_values, max_tfidf = create_tfidf_values(answers[count])
+                    logger.info(f"TF-IDF max value: {max_tfidf}")
+                    
+                    # Calculate marks
                     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()
+                        
+                    # Add result with extracted text
                     results.append({
                         "subfolder": student,
                         "image": filename,
-                        "marks": round(m, 2)  # Round marks to 2 decimal places
+                        "marks": round(m, 2),
+                        "extracted_text": s_answer,
+                        "correct_answer": answers[count]
                     })
                     count += 1
                     
@@ -570,7 +582,9 @@ def compute_marks():
                     results.append({
                         "subfolder": student,
                         "image": filename,
-                        "marks": 0
+                        "marks": 0,
+                        "extracted_text": "",
+                        "error": str(e)
                     })
                     count += 1
                     continue
@@ -586,10 +600,18 @@ def compute_marks():
         # Final memory cleanup
         cleanup_memory()
         
-        return jsonify({"results": results}), 200
+        return jsonify({
+            "results": results,
+            "debug_info": {
+                "total_students": len(data),
+                "total_answers": len(answers),
+                "answers_processed": count
+            }
+        }), 200
         
     except Exception as e:
         error_msg = str(e)
+        logger.error(f"Error in compute_marks: {error_msg}")
         notification_queue.put({
             "type": "error",
             "message": error_msg
@@ -602,41 +624,65 @@ def compute_marks():
 def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfidf, correct_answers):
     try:
         marks = 0
+        logger.info(f"Starting marks calculation for answer: {answer}")
+        logger.info(f"Correct answers: {correct_answers}")
+        
+        # Calculate TF-IDF score
         marks1 = tfidf_answer_score(answer, tf_idf_word_values, max_tfidf, marks=10)
+        logger.info(f"Initial TF-IDF score: {marks1}")
         
         if marks1 > 3:
-            marks += new_value(marks1, old_min=3, old_max=10, new_min=0, new_max=5)
-            logger.info(f"TFIDF Score: {float(marks)}")
+            tfidf_contribution = new_value(marks1, old_min=3, old_max=10, new_min=0, new_max=5)
+            marks += tfidf_contribution
+            logger.info(f"TF-IDF contribution (>3): {tfidf_contribution}")
             
         if marks1 > 2:
+            # Calculate sentence transformer score
             marks2 = similarity_model_score(sen_vec_answers, answer)
+            logger.info(f"Sentence transformer raw score: {marks2}")
+            
             a = 0
             if marks2 > 0.95:
                 marks += 3
-                a = a + 3
+                a = 3
+                logger.info("High sentence similarity (>0.95): +3 marks")
             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)
-            logger.info(f"Sentence transformers score: {a}")
+                sentence_contribution = new_value(marks2, old_min=0.5, old_max=0.95, new_min=0, new_max=3)
+                marks += sentence_contribution
+                a = sentence_contribution
+                logger.info(f"Medium sentence similarity (>0.5): +{sentence_contribution} marks")
 
+            # Calculate FastText similarity
             marks3 = fasttext_similarity(word_vec_answers, answer)
+            logger.info(f"FastText similarity raw score: {marks3}")
+            
             b = 0
             if marks2 > 0.9:
                 marks += 2
-                b = b + 2
+                b = 2
+                logger.info("High word similarity (>0.9): +2 marks")
             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)
-            logger.info(f"Fasttext score: {b}")
+                word_contribution = new_value(marks3, old_min=0.4, old_max=0.9, new_min=0, new_max=2)
+                marks += word_contribution
+                b = word_contribution
+                logger.info(f"Medium word similarity (>0.4): +{word_contribution} marks")
 
+            # Calculate LLM score
             marks4 = llm_score(correct_answers, answer)
+            logger.info(f"Raw LLM scores: {marks4}")
+            
             for i in range(len(marks4)):
                 marks4[i] = float(marks4[i])
 
             m = max(marks4)
-            logger.info(f"LLM score: {m/2}")
-            marks = marks/2 + m/2
+            logger.info(f"Max LLM score: {m}")
+            
+            # Final score calculation
+            final_score = marks/2 + m/2
+            logger.info(f"Final score calculation: (marks={marks}/2 + llm={m}/2) = {final_score}")
+            marks = final_score
             
+        logger.info(f"Final marks awarded: {marks}")
         return marks
         
     except Exception as e: