Update app.py

app.py

@@ -471,11 +471,9 @@ def retrieve_interview_data(job_role, all_roles):
     """
     Retrieve all interview Q&A for a given job role.
     Falls back to similar roles if no data found.
-
     Args:
         job_role (str): Input job role (can be misspelled)
         all_roles (list): Full list of available job roles
-
     Returns:
         list: List of QA dicts with keys: 'question', 'answer', 'job_role'
     """
@@ -646,36 +644,28 @@ def evaluate_answer(
         # Enhanced prompt (your version)
         prompt = f"""
 You are an expert technical interviewer evaluating a candidate's response for a {job_role} position at the {seniority} level.
-
 You are provided with:
 - The question asked
 - The candidate's response
 - A reference answer that represents a high-quality expected answer
-
 Evaluate the candidate's response based on:
 - Technical correctness
 - Clarity and depth of explanation
 - Relevance to the job role and seniority
 - Completeness and structure
-
 Be objective, concise, and use professional language. Be fair but critical.
-
 --------------------------
 Question:
 {question}
-
 Candidate Answer:
 {answer}
-
 Reference Answer:
 {ref_answer}
 --------------------------
-
 Now return your evaluation as a valid JSON object using exactly these keys:
 - "Score": One of ["Poor", "Medium", "Good", "Excellent"]
 - "Reasoning": 2-3 sentence explanation justifying the score, covering clarity, accuracy, completeness, or relevance
 - "Improvements": A list of 2-3 specific and constructive suggestions to help the candidate improve this answer
-
 Example:
 {{
   "Score": "Good",
@@ -686,7 +676,6 @@ Example:
     "Clarify the specific business impact or outcome achieved"
   ]
 }}
-
 Respond only with the JSON:
 """
         for attempt in range(max_retries + 1):
@@ -746,19 +735,16 @@ Respond only with the JSON:
 def generate_reference_answer(question, job_role, seniority):
     """
     Generates a high-quality reference answer using Groq-hosted LLaMA model.
-
     Args:
         question (str): Interview question to answer.
         job_role (str): Target job role (e.g., "Frontend Developer").
         seniority (str): Experience level (e.g., "Mid-Level").
-
     Returns:
         str: Clean, generated reference answer or error message.
     """
     try:
         # Clean, role-specific prompt
         prompt = f"""You are a {seniority} {job_role}.
-
 Q: {question}
 A:"""
 
@@ -782,11 +768,8 @@ def build_interview_prompt(conversation_history, user_response, context, job_rol
     
     interview_template = """
     You are an AI interviewer conducting a real-time interview for a {job_role} position.
-
     Your objective is to thoroughly evaluate the candidate's suitability for the role using smart, structured, and adaptive questioning.
-
     ---
-
      Interview Rules and Principles:
     - The **baseline difficulty** of questions must match the candidate’s seniority level (e.g., junior, mid-level, senior).
     - Use your judgment to increase difficulty **slightly** if the candidate performs well, or simplify if they struggle — but never drop below the expected baseline for their level.
@@ -795,51 +778,36 @@ def build_interview_prompt(conversation_history, user_response, context, job_rol
     - Adapt your line of questioning gradually and logically based on the **overall flow**, not just the last answer.
     - Include real-world problem-solving scenarios to test how the candidate thinks and behaves practically.
     - You must **lead** the interview and make intelligent decisions about what to ask next.
-
     ---
-
      Context Use:
     {context_instruction}
     Note:
     If no relevant context was retrieved or the previous answer is unclear, you must still generate a thoughtful interview question using your own knowledge. Do not skip generation. Avoid default or fallback responses — always try to generate a meaningful and fair next question.
-
-
     ---
-
      Job Role: {job_role}
      Seniority Level: {seniority}
      Skills Focus: {skills}
      Difficulty Setting: {difficulty} (based on {difficulty_adjustment})
-
     ---
-
     Recent Conversation History:
     {history}
-
     Candidate's Last Response:
     "{user_response}"
-
     Evaluation of Last Response:
     {response_evaluation}
-
     Voice Tone: {voice_label}
-
     ---
     ---
-
     Important:
     If no relevant context was retrieved or the previous answer is unclear or off-topic,
     you must still generate a meaningful and fair interview question using your own knowledge and best practices.
     Do not skip question generation or fall back to default/filler responses.
-
     ---
-
     Guidelines for Next Question:
     - If this is the beginning of the interview, start with a question about the candidate’s background or experience.
     - Base the difficulty primarily on the seniority level, with light adjustment from recent performance.
     - Focus on core skills, real-world applications, and depth of reasoning.
     - Ask only one question. Be clear and concise.
-
     Generate the next interview question now:
     """
 
@@ -967,29 +935,22 @@ def generate_llm_interview_report(
 
     prompt = f"""
 You are a senior technical interviewer at a major tech company.
-
 Write a structured, realistic hiring report for this {seniority} {job_role} interview, using these section scores (scale 1–5, with 5 best):
-
 Section-wise Evaluation
 1. *Problem Solving & Critical Thinking*: {avg_problem}
 2. *Technical Depth & Knowledge*: {avg_tech}
 3. *Communication & Clarity*: {avg_comm}
 4. *Emotional Composure & Confidence*: {avg_emotion}
 5. *Role Relevance*: 5
-
 *Transcript*
 {transcript}
-
 Your report should have the following sections:
-
 1. *Executive Summary* (realistic, hiring-committee style)
 2. *Section-wise Comments* (for each numbered category above, with short paragraph citing specifics)
 3. *Strengths & Weaknesses* (list at least 2 for each)
 4. *Final Verdict*: {verdict}
 5. *Recommendations* (2–3 for future improvement)
-
 Use realistic language. If some sections are N/A or lower than others, comment honestly.
-
 Interview Report:
 """
     # LLM call, or just return prompt for review
@@ -1226,12 +1187,10 @@ def build_ground_truth(all_roles):
 def evaluate_retrieval(job_role, all_roles, k=10):
     """
     Evaluate retrieval quality using Precision@k, Recall@k, and F1@k.
-
     Args:
         job_role (str): The input job role to search for.
         all_roles (list): List of all available job roles in the system.
         k (int): Top-k retrieved questions to evaluate.
-
     Returns:
         dict: Evaluation metrics including precision, recall, and f1.
     """
@@ -1764,33 +1723,53 @@ if torch.cuda.is_available():
     torch.cuda.set_device(0)
 else:
     print("⚠️  CUDA not available, using CPU")
-from TTS.api import TTS
 
 def load_models_lazy():
     """Load models only when needed"""
-    global fast_tts, whisper_model
+    global model_bark, processor_bark, whisper_model
     
     device = "cuda" if torch.cuda.is_available() else "cpu"
     print(f"🔁 Using device: {device}")
     
-    global fast_tts
-    if fast_tts is None:
-        print("🔁 Loading Fast TTS model...")
-        fast_tts = TTS(model_name="tts_models/en/ljspeech/tacotron2-DDC", progress_bar=False)
-        print("✅ Fast TTS model loaded")
+    if model_bark is None:
+        print("🔁 Loading Bark model...")
+        model_bark = BarkModel.from_pretrained("suno/bark").to(device)
+        print(f"✅ Bark model loaded on {device}")
+        
+    if processor_bark is None:
+        print("🔁 Loading Bark processor...")
+        processor_bark = AutoProcessor.from_pretrained("suno/bark")
+        print("✅ Bark processor loaded")
         
     if whisper_model is None:
         print("🔁 Loading Whisper model...")
         whisper_model = whisper.load_model("base", device=device)
         print(f"✅ Whisper model loaded on {device}")
 
-
 def bark_tts_async(text):
-    load_models_lazy()
-    temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-    fast_tts.tts_to_file(text=text, file_path=temp_wav.name)
-    return executor.submit(lambda: temp_wav.name)
-
+    """Fully correct async TTS generation with Bark"""
+    def _generate():
+        load_models_lazy()
+        device = next(model_bark.parameters()).device
+        print(f"🔁 Bark model on: {device}")
+        print(f"🎙️ Speaking: {text}")
+
+        # 🧠 Prepare full input using processor (not just input_ids)
+        inputs = processor_bark(text, return_tensors="pt", voice_preset=bark_voice_preset)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        # ✅ Generate using unpacked args — this includes all required prompt tensors
+        with torch.no_grad():
+            speech_values = model_bark.generate(**inputs)
+
+        # ✅ Convert to audio
+        speech = speech_values.cpu().numpy().squeeze()
+        speech = (speech * 32767).astype(np.int16)
+        temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+        wavfile.write(temp_wav.name, 22050, speech)
+        return temp_wav.name
+
+    return executor.submit(_generate)
 
 
 def whisper_stt(audio_path):