interview updated

backend/routes/interview_api.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 import json
-from flask import Blueprint, request, jsonify, url_for, current_app
+from flask import Blueprint, request, jsonify, send_file, url_for, current_app
 from flask_login import login_required, current_user
 from backend.models.database import db, Job, Application
 from backend.services.interview_engine import (
@@ -35,25 +35,20 @@ def start_interview():
     
     question = generate_first_question(profile, job)
     
-    # Determine the static folder from the current app context.  Flask serves
-    # files from ``current_app.static_folder`` and uses ``static_url_path``
-    # when generating URLs.  If audio generation fails (for example because
-    # network access is unavailable), we simply omit the audio file and allow
-    # the frontend to fall back to text‑only mode.
+    # Use /tmp directory which is writable in Hugging Face Spaces
     audio_dir = "/tmp/audio"
     os.makedirs(audio_dir, exist_ok=True)
 
     audio_filename = f"q_{uuid.uuid4().hex}.wav"
     audio_path = os.path.join(audio_dir, audio_filename)
 
-    # Generate audio synchronously.  The function returns None on error.
+    # Generate audio synchronously. The function returns None on error.
     audio_out = edge_tts_to_file_sync(question, audio_path)
 
-    from flask import send_file  # ⬅ add this at the top if not already imported
-
-    if audio_out:
-        return send_file(audio_path, mimetype="audio/wav")
+    if audio_out and os.path.exists(audio_path):
+        return send_file(audio_path, mimetype="audio/wav", as_attachment=False)
     else:
+        # Fallback to JSON response if audio generation fails
         return jsonify({"question": question})
 
 
@@ -64,11 +59,8 @@ def transcribe_audio():
     if not audio_file:
         return jsonify({"error": "No audio file received."}), 400
     
-    # Create a temporary directory inside Flask's instance path.  Using the
-    # instance path ensures that the folder is writable in environments like
-    # Hugging Face Spaces, where the working directory may be read‑only.  The
-    # instance path is configured in ``app.py`` to point at ``/tmp/flask_instance``.
-    temp_dir = os.path.join(current_app.instance_path, "interview_temp")
+    # Use /tmp directory which is writable in Hugging Face Spaces
+    temp_dir = "/tmp/interview_temp"
     os.makedirs(temp_dir, exist_ok=True)
 
     filename = f"user_audio_{uuid.uuid4().hex}.wav"
@@ -92,33 +84,34 @@ def process_answer():
     answer = data.get("answer", "")
     question_idx = data.get("questionIndex", 0)
     
-    # Generate next question (simplified for now).  In a full implementation this
+    # Generate next question (simplified for now). In a full implementation this
     # would call a model such as groq_llm to generate a follow‑up question based
     # on the candidate's answer.
     next_question = f"Follow‑up question {question_idx + 2}: Can you elaborate on your experience with relevant technologies?"
 
-    # Prepare audio output directory inside the app's static folder
+    # Use /tmp directory for audio files
     audio_dir = "/tmp/audio"
     os.makedirs(audio_dir, exist_ok=True)
 
     audio_filename = f"q_{uuid.uuid4().hex}.wav"
     audio_path = os.path.join(audio_dir, audio_filename)
 
-    # Attempt to generate speech for the next question.  If audio generation
-    # fails, ``audio_out`` will be None and we simply omit ``audioUrl`` in
-    # the JSON response.
+    # Attempt to generate speech for the next question. If audio generation
+    # fails, ``audio_out`` will be None and we return JSON response instead.
     audio_out = edge_tts_to_file_sync(next_question, audio_path)
 
-    response = {
-        "success": True,
-        "nextQuestion": next_question,
-        "evaluation": {
-            "score": "medium",
-            "feedback": "Good answer, but be more specific."
-        },
-        "isComplete": question_idx >= 2,
-        "summary": []
-    }
-    if audio_out:
-        response["audioUrl"] = url_for("static", filename=f"audio/{audio_filename}")
-    return jsonify(response)
+    if audio_out and os.path.exists(audio_path):
+        return send_file(audio_path, mimetype="audio/wav", as_attachment=False)
+    else:
+        # Fallback to JSON response
+        response = {
+            "success": True,
+            "nextQuestion": next_question,
+            "evaluation": {
+                "score": "medium",
+                "feedback": "Good answer, but be more specific."
+            },
+            "isComplete": question_idx >= 2,
+            "summary": []
+        }
+        return jsonify(response)

backend/services/interview_engine.py

@@ -7,7 +7,7 @@ from langchain_groq import ChatGroq
 import logging
 
 # Initialize models
-chat_groq_api = os.getenv("GROQ_API_KEY", "your-groq-api-key")
+chat_groq_api = os.getenv("GROQ_API_KEY", "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")
 groq_llm = ChatGroq(
     temperature=0.7,
     model_name="llama-3.3-70b-versatile",
@@ -48,20 +48,47 @@ def generate_first_question(profile, job):
 def edge_tts_to_file_sync(text, output_path, voice="en-US-AriaNeural"):
     """Synchronous wrapper for edge-tts"""
     try:
-        # Create directory if it doesn't exist
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        # Ensure the directory exists and is writable
+        directory = os.path.dirname(output_path)
+        if not directory:
+            directory = "/tmp"  # Fallback to /tmp if no directory specified
+            output_path = os.path.join(directory, os.path.basename(output_path))
+        
+        os.makedirs(directory, exist_ok=True)
+        
+        # Test write permissions
+        test_file = os.path.join(directory, f"test_{os.getpid()}.tmp")
+        try:
+            with open(test_file, 'w') as f:
+                f.write("test")
+            os.remove(test_file)
+        except (PermissionError, OSError) as e:
+            logging.error(f"Directory {directory} is not writable: {e}")
+            # Fallback to /tmp
+            directory = "/tmp"
+            output_path = os.path.join(directory, os.path.basename(output_path))
+            os.makedirs(directory, exist_ok=True)
         
         async def generate_audio():
             communicate = edge_tts.Communicate(text, voice)
             await communicate.save(output_path)
         
         # Run async function in sync context
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
         loop.run_until_complete(generate_audio())
-        loop.close()
         
-        return output_path
+        # Verify file was created and has content
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+            return output_path
+        else:
+            logging.error(f"Audio file was not created or is empty: {output_path}")
+            return None
+            
     except Exception as e:
         logging.error(f"Error in TTS generation: {e}")
         return None
@@ -70,6 +97,12 @@ def whisper_stt(audio_path):
     """Speech-to-text using Faster-Whisper"""
     try:
         if not audio_path or not os.path.exists(audio_path):
+            logging.error(f"Audio file does not exist: {audio_path}")
+            return ""
+        
+        # Check if file has content
+        if os.path.getsize(audio_path) == 0:
+            logging.error(f"Audio file is empty: {audio_path}")
             return ""
         
         model = load_whisper_model()
@@ -103,8 +136,11 @@ def evaluate_answer(question, answer, ref_answer, job_role, seniority):
         # Extract JSON from response
         start_idx = response.find("{")
         end_idx = response.rfind("}") + 1
-        json_str = response[start_idx:end_idx]
-        return json.loads(json_str)
+        if start_idx >= 0 and end_idx > start_idx:
+            json_str = response[start_idx:end_idx]
+            return json.loads(json_str)
+        else:
+            raise ValueError("No valid JSON found in response")
     except Exception as e:
         logging.error(f"Error evaluating answer: {e}")
         return {