update_

main.py

@@ -3,18 +3,37 @@ import tempfile
 import nltk
 import logging
 import sys
+from datetime import datetime
 
-# Set up logging at the start of your main.py
+# Create a logs directory in the temp folder
+log_dir = os.path.join(tempfile.gettempdir(), 'app_logs')
+os.makedirs(log_dir, exist_ok=True)
+
+# Create a log file with timestamp
+log_file = os.path.join(log_dir, f'app_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log')
+
+# Set up logging to both file and console
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
+        logging.FileHandler(log_file),
         logging.StreamHandler(sys.stdout)
     ]
 )
 
 logger = logging.getLogger(__name__)
 
+# Add a print function that also logs
+def log_print(message, level="INFO"):
+    print(message)  # This will show in Hugging Face logs
+    if level == "INFO":
+        logger.info(message)
+    elif level == "ERROR":
+        logger.error(message)
+    elif level == "WARNING":
+        logger.warning(message)
+
 # Set up all cache and data directories in /tmp
 cache_dir = tempfile.mkdtemp()
 nltk_data_dir = os.path.join(cache_dir, 'nltk_data')
@@ -135,30 +154,30 @@ def compute_marks():
         # Get and process answers
         a = request.form.get('answers')
         if not a:
-            logger.error("No answers provided")
+            log_print("No answers provided", "ERROR")
             return jsonify({"error": "No answers provided"}), 400
         
-        logger.info("=== Processing Answers ===")
-        logger.info(f"Received answers: {a}")
+        log_print("=== Processing Answers ===")
+        log_print(f"Received answers: {a}")
         a = json.loads(a)
         answers = []
         for i in a:
             ans = i.split('\n\n')
             answers.append(ans)
-        logger.info(f"Processed answers structure: {answers}")
+        log_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)
         
-        logger.info("=== Processing Uploaded Files ===")
+        log_print("=== Processing Uploaded Files ===")
         files = request.files.getlist('files[]')
         if not files:
-            logger.error("No files uploaded")
+            log_print("No files uploaded", "ERROR")
             return jsonify({"error": "No files uploaded"}), 400
 
-        logger.info(f"Number of files received: {len(files)}")
+        log_print(f"Number of files received: {len(files)}")
         
         # File processing with logging
         for file in files:
@@ -166,8 +185,8 @@ def compute_marks():
                 relative_path = file.filename.replace('\\', '/')
                 path_parts = relative_path.split('/')
                 
-                logger.info(f"Processing file: {file.filename}")
-                logger.info(f"Path parts: {path_parts}")
+                log_print(f"Processing file: {file.filename}")
+                log_print(f"Path parts: {path_parts}")
                 
                 if len(path_parts) >= 2:
                     student_folder = path_parts[1]
@@ -178,7 +197,7 @@ def compute_marks():
                     
                     save_path = os.path.join(student_dir, file_name)
                     file.save(save_path)
-                    logger.info(f"Saved file: {save_path}")
+                    log_print(f"Saved file: {save_path}")
                     
                     if student_folder not in data:
                         data[student_folder] = []
@@ -187,14 +206,14 @@ def compute_marks():
                         'name': os.path.splitext(file_name)[0]
                     })
                 else:
-                    logger.warning(f"File {file.filename} doesn't have expected structure")
+                    log_print(f"File {file.filename} doesn't have expected structure", "WARNING")
 
         # Log data structure
-        logger.info("=== Final Data Structure ===")
+        log_print("=== Final Data Structure ===")
         for student, images in data.items():
-            logger.info(f"Student: {student}")
+            log_print(f"Student: {student}")
             for img in sorted(images, key=lambda x: x['name']):
-                logger.info(f"  - {img['name']} ({img['path']})")
+                log_print(f"  - {img['name']} ({img['path']})")
 
         # Calculate marks with logging
         results = []
@@ -208,11 +227,11 @@ def compute_marks():
                 try:
                     image_path = image_info['path']
                     s_answer = extract_text_from_image(image_path)
-                    logger.info(f"\nProcessing {student_folder}/{image_info['name']}:")
-                    logger.info(f"Extracted answer: {s_answer}")
+                    log_print(f"\nProcessing {student_folder}/{image_info['name']}:")
+                    log_print(f"Extracted answer: {s_answer}")
                     
                     if s_answer and idx < len(answers):
-                        logger.info(f"Reference answer: {answers[idx]}")
+                        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])
@@ -222,10 +241,10 @@ def compute_marks():
                         mark_value = round(float(m), 2)
                         student_total += mark_value
                         student_count += 1
-                        logger.info(f"Marks awarded: {mark_value}")
+                        log_print(f"Marks awarded: {mark_value}")
                     else:
                         mark_value = 0
-                        logger.warning(f"No text extracted or no reference answer for index {idx}")
+                        log_print(f"No text extracted or no reference answer for index {idx}", "WARNING")
                     
                     results.append({
                         'student': student_folder,
@@ -234,7 +253,7 @@ def compute_marks():
                     })
                     
                 except Exception as e:
-                    logger.error(f"Error processing {image_path}: {str(e)}")
+                    log_print(f"Error processing {image_path}: {str(e)}", "ERROR")
                     results.append({
                         'student': student_folder,
                         'image_name': image_info['name'],
@@ -244,17 +263,17 @@ def compute_marks():
         # Sort results
         results.sort(key=lambda x: (x['student'], x['image_name']))
 
-        logger.info("\nFinal Results:")
+        log_print("\nFinal Results:")
         for r in results:
-            logger.info(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
+            log_print(f"{r['student']}\t{r['image_name']}\t{r['marks']}")
 
         # Clean up temporary directory
         try:
             import shutil
             shutil.rmtree(parent_folder)
-            logger.info(f"Cleaned up temporary directory: {parent_folder}")
+            log_print(f"Cleaned up temporary directory: {parent_folder}")
         except Exception as e:
-            logger.warning(f"Warning: Could not clean up temporary directory: {e}")
+            log_print(f"Warning: Could not clean up temporary directory: {e}", "WARNING")
 
         return jsonify({
             "message": results,
@@ -262,7 +281,7 @@ def compute_marks():
         }), 200
 
     except Exception as e:
-        logger.error("Error in compute_marks:", str(e))
+        log_print(f"Error in compute_marks: {str(e)}", "ERROR")
         try:
             import shutil
             shutil.rmtree(parent_folder)
@@ -274,19 +293,19 @@ def compute_marks():
 
 def marks(answer, sen_vec_answers, word_vec_answers, tf_idf_word_values, max_tfidf, correct_answers):
     marks = 0
-    logger.info("=== Marks Calculation ===")
-    logger.info(f"Processing answer: {answer[:100]}...")  # Log first 100 chars
+    log_print("=== Marks Calculation ===")
+    log_print(f"Processing answer: {answer[:100]}...")  # Log first 100 chars
     
     marks1 = tfidf_answer_score(answer, tf_idf_word_values, max_tfidf, marks=10)
-    logger.info(f"TFIDF Score: {marks1}")
+    log_print(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}")
+        log_print(f"After TFIDF adjustment: {marks}")
         
     if marks1 > 2:
         marks2 = similarity_model_score(sen_vec_answers, answer)
-        logger.info(f"Sentence Similarity Score: {marks2}")
+        log_print(f"Sentence Similarity Score: {marks2}")
         
         if marks2 > 0.95:
             marks += 3
@@ -294,26 +313,26 @@ 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)
-        logger.info(f"Word Similarity Score: {marks3}")
+        log_print(f"Word Similarity Score: {marks3}")
         
-        if marks3 > 0.9:  # Fixed the condition to use marks3 instead of marks2
+        if marks3 > 0.9:
             marks += 2
         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}")
+        log_print(f"LLM Scores: {marks4}")
         
         for i in range(len(marks4)):
             marks4[i] = float(marks4[i])
         
         m = max(marks4)
-        logger.info(f"Max LLM Score: {m}")
+        log_print(f"Max LLM Score: {m}")
         
         marks = marks/2 + m/2
-        logger.info(f"Final marks: {marks}")
+        log_print(f"Final marks: {marks}")
     else:
-        logger.warning("TFIDF score too low, returning 0")
+        log_print("TFIDF score too low, returning 0", "WARNING")
     
     return marks