update_

main.py

@@ -5,6 +5,27 @@ import logging
 import sys
 from datetime import datetime
 
+# Set up logging to write to stdout
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(message)s',  # Simplified format for better readability
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+# Create a custom logger
+logger = logging.getLogger(__name__)
+
+# Override the print function to ensure visibility
+def custom_print(*args, **kwargs):
+    print(*args, **kwargs, flush=True)  # Force flush to ensure immediate output
+    logger.info(' '.join(str(arg) for arg in args))
+
+# Replace the standard print with our custom print
+import builtins
+builtins.print = custom_print
+
 # Create a logs directory in the temp folder
 log_dir = os.path.join(tempfile.gettempdir(), 'app_logs')
 os.makedirs(log_dir, exist_ok=True)
@@ -151,42 +172,44 @@ def compute_answers():
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
     try:
+        print("\n=== Starting Marks Computation ===")
+        
         # Get and process answers
         a = request.form.get('answers')
         if not a:
-            log_print("No answers provided", "ERROR")
+            print("ERROR: No answers provided")
             return jsonify({"error": "No answers provided"}), 400
         
-        log_print("=== Processing Answers ===")
-        log_print(f"Received answers: {a}")
+        print("=== Processing Answers ===")
+        print(f"Received answers: {a}")
         a = json.loads(a)
         answers = []
         for i in a:
             ans = i.split('\n\n')
             answers.append(ans)
-        log_print(f"Processed answers structure: {answers}")
+        print(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)
         
-        log_print("=== Processing Uploaded Files ===")
+        print("\n=== Processing Uploaded Files ===")
         files = request.files.getlist('files[]')
         if not files:
-            log_print("No files uploaded", "ERROR")
+            print("ERROR: No files uploaded")
             return jsonify({"error": "No files uploaded"}), 400
 
-        log_print(f"Number of files received: {len(files)}")
+        print(f"Number of files received: {len(files)}")
         
-        # File processing with logging
+        # 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"Processing file: {file.filename}")
-                log_print(f"Path parts: {path_parts}")
+                print(f"\nProcessing file: {file.filename}")
+                print(f"Path parts: {path_parts}")
                 
                 if len(path_parts) >= 2:
                     student_folder = path_parts[1]
@@ -197,7 +220,7 @@ def compute_marks():
                     
                     save_path = os.path.join(student_dir, file_name)
                     file.save(save_path)
-                    log_print(f"Saved file: {save_path}")
+                    print(f"Saved file: {save_path}")
                     
                     if student_folder not in data:
                         data[student_folder] = []
@@ -206,14 +229,14 @@ def compute_marks():
                         'name': os.path.splitext(file_name)[0]
                     })
                 else:
-                    log_print(f"File {file.filename} doesn't have expected structure", "WARNING")
+                    print(f"WARNING: File {file.filename} doesn't have expected structure")
 
         # Log data structure
-        log_print("=== Final Data Structure ===")
+        print("\n=== Final Data Structure ===")
         for student, images in data.items():
-            log_print(f"Student: {student}")
+            print(f"Student: {student}")
             for img in sorted(images, key=lambda x: x['name']):
-                log_print(f"  - {img['name']} ({img['path']})")
+                print(f"  - {img['name']} ({img['path']})")
 
         # Calculate marks with logging
         results = []
@@ -227,11 +250,11 @@ def compute_marks():
                 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"Extracted answer: {s_answer}")
+                    print(f"\nProcessing {student_folder}/{image_info['name']}:")
+                    print(f"Extracted answer: {s_answer}")
                     
                     if s_answer and idx < len(answers):
-                        log_print(f"Reference answer: {answers[idx]}")
+                        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])
@@ -241,10 +264,10 @@ def compute_marks():
                         mark_value = round(float(m), 2)
                         student_total += mark_value
                         student_count += 1
-                        log_print(f"Marks awarded: {mark_value}")
+                        print(f"Marks awarded: {mark_value}")
                     else:
                         mark_value = 0
-                        log_print(f"No text extracted or no reference answer for index {idx}", "WARNING")
+                        print(f"No text extracted or no reference answer for index {idx}", "WARNING")
                     
                     results.append({
                         'student': student_folder,
@@ -253,7 +276,7 @@ def compute_marks():
                     })
                     
                 except Exception as e:
-                    log_print(f"Error processing {image_path}: {str(e)}", "ERROR")
+                    print(f"Error processing {image_path}: {str(e)}", "ERROR")
                     results.append({
                         'student': student_folder,
                         'image_name': image_info['name'],
@@ -263,17 +286,17 @@ def compute_marks():
         # Sort results
         results.sort(key=lambda x: (x['student'], x['image_name']))
 
-        log_print("\nFinal Results:")
+        print("\nFinal Results:")
         for r in results:
-            log_print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
+            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}")
+            print(f"Cleaned up temporary directory: {parent_folder}")
         except Exception as e:
-            log_print(f"Warning: Could not clean up temporary directory: {e}", "WARNING")
+            print(f"Warning: Could not clean up temporary directory: {e}", "WARNING")
 
         return jsonify({
             "message": results,
@@ -281,7 +304,7 @@ def compute_marks():
         }), 200
 
     except Exception as e:
-        log_print(f"Error in compute_marks: {str(e)}", "ERROR")
+        print(f"Error in compute_marks: {str(e)}", "ERROR")
         try:
             import shutil
             shutil.rmtree(parent_folder)
@@ -293,19 +316,19 @@ def compute_marks():
 
 def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfidf, correct_answers):
     marks = 0
-    log_print("=== Marks Calculation ===")
-    log_print(f"Processing answer: {answer[:100]}...")  # Log first 100 chars
+    print("\n=== Marks Calculation ===")
+    print(f"Processing answer: {answer[:100]}...")
     
     marks1 = tfidf_answer_score(answer, tf_idf_word_values, max_tfidf, marks=10)
-    log_print(f"TFIDF Score: {marks1}")
+    print(f"TFIDF Score: {marks1}")
     
     if marks1 > 3:
         marks += new_value(marks1, old_min=3, old_max=10, new_min=0, new_max=5)
-        log_print(f"After TFIDF adjustment: {marks}")
+        print(f"After TFIDF adjustment: {marks}")
         
     if marks1 > 2:
         marks2 = similarity_model_score(sen_vec_answers, answer)
-        log_print(f"Sentence Similarity Score: {marks2}")
+        print(f"Sentence Similarity Score: {marks2}")
         
         if marks2 > 0.95:
             marks += 3
@@ -313,7 +336,7 @@ def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfi
             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)
-        log_print(f"Word Similarity Score: {marks3}")
+        print(f"Word Similarity Score: {marks3}")
         
         if marks3 > 0.9:
             marks += 2
@@ -321,18 +344,18 @@ def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfi
             marks += new_value(marks3, old_min=0.4, old_max=0.9, new_min=0, new_max=2)
         
         marks4 = llm_score(correct_answers, answer)
-        log_print(f"LLM Scores: {marks4}")
+        print(f"LLM Scores: {marks4}")
         
         for i in range(len(marks4)):
             marks4[i] = float(marks4[i])
         
         m = max(marks4)
-        log_print(f"Max LLM Score: {m}")
+        print(f"Max LLM Score: {m}")
         
         marks = marks/2 + m/2
-        log_print(f"Final marks: {marks}")
+        print(f"Final marks: {marks}")
     else:
-        log_print("TFIDF score too low, returning 0", "WARNING")
+        print("WARNING: TFIDF score too low, returning 0")
     
     return marks
 
@@ -340,5 +363,14 @@ def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfi
   
 
 
+@app.route('/check_logs')
+def check_logs():
+    try:
+        with open(log_file, 'r') as f:
+            logs = f.read()
+        return jsonify({"logs": logs})
+    except Exception as e:
+        return jsonify({"error": str(e)})
+
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)