Update app.py

app.py

@@ -7,25 +7,37 @@ import time
 import queue
 from nltk.tokenize import sent_tokenize
 import os
+import json
+import logging
 
 app = Flask(__name__)
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s %(threadName)s %(message)s'
+)
+logger = logging.getLogger(__name__)
+
 # Health check endpoint
 @app.route('/health')
 def health_check():
+    logger.info("Health check requested")
     return jsonify({"status": "healthy"}), 200
 
 # Initialize model only when needed
 def load_model():
     model_name = "priyabrat/AI.or.Human.text.classification"
-    tokenizer = AutoTokenizer.from_pretrained('priyabrat/AI.or.Human.text.classification', cache_dir='/app/hf_cache')
-    model = AutoModelForSequenceClassification.from_pretrained('priyabrat/AI.or.Human.text.classification', cache_dir='/app/hf_cache')
+    logger.info(f"Loading model and tokenizer from {model_name}")
+    tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir='/app/hf_cache')
+    model = AutoModelForSequenceClassification.from_pretrained(model_name, cache_dir='/app/hf_cache')
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model.to(device).eval()
-    return tokenizer, model
+    logger.info(f"Model loaded on device: {device}")
+    return tokenizer, model, device
 
 
-tokenizer, model = load_model()
+tokenizer, model, device = load_model()
 labels = ["AI-generated", "Human-written"]
 lock = threading.Lock()
 
@@ -34,7 +46,7 @@ queues = {}
 
 def classify_line(text):
     with lock, torch.no_grad():
-        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)  # Reduced max_length
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
         inputs = {k: v.to(device) for k, v in inputs.items()}
         outputs = model(**inputs)
         probs = F.softmax(outputs.logits, dim=-1)
@@ -47,25 +59,29 @@ def classify_line(text):
         }
 
 def background_worker(user_id, text):
+    logger.info(f"Processing started for user_id={user_id}")
     sessions[user_id]['status'] = "processing"
     
     try:
         if '\n' not in text:
-            lines = sent_tokenize(text)  
+            lines = sent_tokenize(text)
         else:
             lines = [line.strip() for line in text.strip().split('\n') if line.strip()]
 
         for i, line in enumerate(lines, 1):
             result = classify_line(line)
+            logger.info(f"user_id={user_id} line={i} classified as {result['label']} ({result['confidence']}%)")
             result["line"] = i
             queues[user_id].put(f"data: {json.dumps(result)}\n\n")
-            time.sleep(0.1)  # Reduced delay
+            time.sleep(0.1)
 
         queues[user_id].put("event: done\ndata: Session complete\n\n")
     except Exception as e:
+        logger.error(f"Error processing user_id={user_id}: {e}")
         queues[user_id].put(f"event: error\ndata: {str(e)}\n\n")
     finally:
         sessions[user_id]['status'] = "done"
+        logger.info(f"Processing finished for user_id={user_id}")
         time.sleep(1)
         if user_id in sessions:
             del sessions[user_id]
@@ -79,11 +95,14 @@ def start_session():
     text = data.get("text")
 
     if not user_id or not text:
+        logger.warning("Missing user_id or text in start-session request")
         return jsonify({"error": "user_id and text are required"}), 400
 
     if user_id in sessions:
+        logger.warning(f"Session already exists for user_id={user_id}")
         return jsonify({"message": "Session already exists", "status": sessions[user_id]["status"]}), 409
 
+    logger.info(f"Starting session for user_id={user_id}")
     sessions[user_id] = {"status": "pending"}
     queues[user_id] = queue.Queue()
     threading.Thread(target=background_worker, args=(user_id, text), daemon=True).start()
@@ -93,16 +112,19 @@ def start_session():
 @app.route('/stream/<user_id>')
 def stream(user_id):
     if user_id not in sessions:
+        logger.warning(f"No active session for user_id={user_id} in stream request")
         return jsonify({"error": "No active session for this user"}), 404
 
     def event_stream():
         while True:
             try:
-                message = queues[user_id].get(timeout=30)  # Reduced timeout
+                message = queues[user_id].get(timeout=30)
                 yield message
                 if "event: done" in message or "event: error" in message:
+                    logger.info(f"Stream ended for user_id={user_id} with message: {message.strip()}")
                     break
             except queue.Empty:
+                logger.warning(f"Stream timeout for user_id={user_id}")
                 yield "event: timeout\ndata: No activity\n\n"
                 break
 
@@ -110,11 +132,15 @@ def stream(user_id):
 
 @app.route('/status/<user_id>')
 def session_status(user_id):
-    return jsonify({"status": sessions.get(user_id, {}).get("status", "no_session")})
+    status = sessions.get(user_id, {}).get("status", "no_session")
+    logger.info(f"Status request for user_id={user_id}: {status}")
+    return jsonify({"status": status})
 
 @app.route('/')
 def index():
+    logger.info("Index page requested")
     return "Server is running!"
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))
+    logger.info("Starting Flask app")
+    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))