Update main.py

main.py

@@ -14,7 +14,7 @@ from pydantic import BaseModel
 from gradio_client import Client
 from google.cloud.firestore_v1.base_query import FieldFilter
 import edge_tts
-from typing import Optional
+from typing import Optional, List
 from dotenv import load_dotenv
 from contextlib import asynccontextmanager
 
@@ -67,44 +67,21 @@ class GenerateSessionRequest(BaseModel):
     trackName: Optional[int] = None 
 
 class CleanupRequest(BaseModel):
-    audioUrls: list[str]
+    audioUrls: List[str]
 
 # =========================================
-# 4. BACKGROUND TASKS (Auto-Cleaner)
-# =========================================
-async def auto_clean_invalid_questions():
-    """Background loop to remove questions with missing or broken audio."""
-    while True:
-        try:
-            print("[Auto-Cleaner] Scanning for broken questions...")
-            docs = db.collection("questions_pool").get()
-            deleted_count = 0
-            for doc in docs:
-                data = doc.to_dict()
-                if not data.get("audio_url"):
-                    db.collection("questions_pool").document(doc.id).delete()
-                    deleted_count += 1
-            if deleted_count > 0:
-                print(f"[Auto-Cleaner] Removed {deleted_count} broken questions.")
-        except Exception as e:
-            print(f"[Auto-Cleaner] Error: {e}")
-        await asyncio.sleep(600) # Scan every 10 minutes
-
-# =========================================
-# 5. LIFESPAN MANAGEMENT
+# 4. LIFESPAN MANAGEMENT
 # =========================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global client
-    print("Connecting to Hugging Face Space...")
+    print("Connecting to Hugging Face Model...")
     try:
         loop = asyncio.get_event_loop()
         client = await loop.run_in_executor(None, lambda: Client(HF_SPACE))
-        print("Connected Successfully!")
-        # Start the background cleaner
-        asyncio.create_task(auto_clean_invalid_questions())
+        print("Model Connected Successfully!")
     except Exception as e:
-        print(f"Startup Connection failed: {e}")
+        print(f"Model Connection Failed: {e}")
     
     yield
     print("Shutting down Intervision Service...")
@@ -112,7 +89,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(title="Intervision AI Question Service", lifespan=lifespan)
 
 # =========================================
-# 6. HELPERS
+# 5. CORE LOGIC HELPERS
 # =========================================
 async def generate_audio(text, filename):
     try:
@@ -124,12 +101,12 @@ async def generate_audio(text, filename):
         if os.path.exists(filename): os.remove(filename)
         return upload_result["secure_url"]
     except Exception as e:
-        print(f"Audio Error: {e}")
+        print(f"Audio Generation Error: {e}")
         if os.path.exists(filename): os.remove(filename)
         return None
 
 async def safe_generate(prompt, retries=3):
-    if client is None: raise Exception("Gradio Client not initialized")
+    if client is None: raise Exception("AI Client is not initialized.")
     for attempt in range(retries):
         try:
             loop = asyncio.get_running_loop()
@@ -150,46 +127,43 @@ def parse_question_output(raw_output: str):
         except: return None, None
     return None, None
 
-async def refill_specific_pool(track_id: int, difficulty: int, count: int, session_type: int = 1):
+async def refill_specific_pool(track_id: int, difficulty: int, count: int, session_type: int):
     while client is None: await asyncio.sleep(5)
     
     if session_type == 0:
-        prompt = ("Generate ONE simple Behavioral interview question for a fresh graduate. "
-                "Focus on soft skills like teamwork or leadership. Strictly NO technical questions. "
-                "Format: Q: [Question] A: [Answer]")
+        prompt = "Generate ONE unique simple behavioral interview question. Format: Q: [Question] A: [Answer]"
         track_text = "Behavioral"
     else:
         track_text = TECH_CATEGORIES.get(track_id)
         level_text = DIFFICULTY_MAP.get(difficulty)
-        prompt = f"Generate ONE unique {track_text} interview question for {level_text} level. Format: Q: [Question] A: [Answer]"
+        prompt = f"Generate ONE unique {track_text} question for {level_text} level. Format: Q: [Question] A: [Answer]"
 
     success_count = 0
     while success_count < count:
         try:
             raw_output = await safe_generate(prompt)
-            q_text, a_text = parse_question_output(raw_output)
-            if q_text and a_text:
-                filename = f"{uuid.uuid4()}.mp3"
-                audio_url = await generate_audio(q_text, filename)
+            q, a = parse_question_output(raw_output)
+            if q and a:
+                audio_url = await generate_audio(q, f"{uuid.uuid4()}.mp3")
                 if audio_url:
                     db.collection("questions_pool").add({
                         "session_type": session_type,
                         "track_id": track_id if session_type == 1 else -1,
                         "difficulty": difficulty if session_type == 1 else 0,
-                        "questionText": q_text,
-                        "questionIdealAnswer": a_text,
+                        "questionText": q,
+                        "questionIdealAnswer": a,
                         "audio_url": audio_url,
                         "created_at": firestore.SERVER_TIMESTAMP
                     })
                     success_count += 1
-                    print(f"Refilled {success_count}/{count} for {track_text}")
+                    print(f"Successfully added question {success_count}/{count}")
                     await asyncio.sleep(3)
         except Exception as e:
-            print(f"Refill error: {e}")
+            print(f"Refill logic error: {e}")
             await asyncio.sleep(5)
 
 # =========================================
-# 7. MAIN ENDPOINTS
+# 6. API ENDPOINTS
 # =========================================
 @app.post("/generate-session")
 async def generate_session(request: GenerateSessionRequest, background_tasks: BackgroundTasks):
@@ -197,12 +171,13 @@ async def generate_session(request: GenerateSessionRequest, background_tasks: Ba
     query = db.collection("questions_pool").where(filter=FieldFilter("session_type", "==", s_type))
     
     if s_type == 1: # Technical
-        if t_id is None: raise HTTPException(status_code=400, detail="trackName required for technical.")
+        if t_id is None: raise HTTPException(status_code=400, detail="trackName is required for technical sessions.")
         query = query.where(filter=FieldFilter("track_id", "==", t_id)).where(filter=FieldFilter("difficulty", "==", diff))
     
-    docs_query = query.limit(10).get()
+    docs = query.limit(10).get()
     final_questions = []
-    for index, doc in enumerate(docs_query, start=1):
+    
+    for index, doc in enumerate(docs, start=1):
         data = doc.to_dict()
         final_questions.append({
             "question_id": index, "text": data["questionText"],
@@ -210,15 +185,18 @@ async def generate_session(request: GenerateSessionRequest, background_tasks: Ba
         })
         db.collection("questions_pool").document(doc.id).delete()
 
-    async def maintain_stock():
+    async def check_and_refill_background():
         snap = query.count().get()
-        current = snap[0][0].value
-        if current < 50:
-            await refill_specific_pool(t_id if s_type == 1 else -1, diff, 50 - current, session_type=s_type)
+        current_count = snap[0][0].value
+        if current_count < 50:
+            print(f"Stock is low ({current_count}). Starting background refill...")
+            await refill_specific_pool(t_id if s_type == 1 else -1, diff, 50 - current_count, s_type)
 
-    background_tasks.add_task(maintain_stock)
+    background_tasks.add_task(check_and_refill_background)
+    
     if not final_questions:
-        raise HTTPException(status_code=503, detail="Question pool is currently empty.")
+        raise HTTPException(status_code=503, detail="The question pool is empty. Please try again in a few minutes.")
+    
     return {"session_id": request.sessionId, "questions": final_questions}
 
 @app.post("/cleanup-audio")
@@ -230,37 +208,31 @@ async def cleanup_audio(request: CleanupRequest, background_tasks: BackgroundTas
                 cloudinary.uploader.destroy(public_id, resource_type="video")
             except: pass
     background_tasks.add_task(delete_job, request.audioUrls)
-    return {"message": "Cleanup started"}
+    return {"message": "Cloudinary cleanup process initiated."}
 
 @app.get("/system-cleanup")
 async def system_cleanup(background_tasks: BackgroundTasks):
-    """Scan and delete all questions with missing or invalid audio URLs"""
+    """Manually trigger a cleanup for broken records in Firestore"""
     def run_cleanup():
-        print("Starting System Cleanup...")
-        # Get all documents in the pool
         docs = db.collection("questions_pool").get()
-        deleted_count = 0
-        
+        count = 0
         for doc in docs:
             data = doc.to_dict()
-            # Check if audio_url is missing, None, or empty string
-            if not data.get("audio_url") or data.get("audio_url") == "":
+            if not data.get("audio_url"):
                 db.collection("questions_pool").document(doc.id).delete()
-                deleted_count += 1
-        
-        print(f"Cleanup finished! Deleted {deleted_count} broken questions.")
+                count += 1
+        print(f"Manual cleanup finished. Removed {count} broken records.")
 
     background_tasks.add_task(run_cleanup)
-    return {"message": "Cleanup started in background. Check your console/logs."}
-
+    return {"message": "System cleanup task started in background."}
 
 @app.get("/health")
 async def health():
-    return {"status": "active", "hf_connected": client is not None}
+    return {"status": "active", "ai_model_connected": client is not None}
 
 @app.get("/")
 async def root():
-    return {"app": "Intervision AI Service","Status": "Running.."}
+    return {"app": "Intervision AI Engine", "status": "Running"}
 
 if __name__ == "__main__":
     import uvicorn