Update app.py

app.py

@@ -7,19 +7,20 @@ from PyPDF2 import PdfReader
 import gtts
 import tempfile
 import warnings
-import threading  # For asynchronous feedback
+import threading
 import time
-import speech_recognition as sr # Speech to Text
-import cv2  # OpenCV
-import numpy as np  # NumPy
+import speech_recognition as sr
+import cv2
+import numpy as np
+import ast
+from moviepy.editor import VideoFileClip
 
-
-# Suppress gTTS warnings
+# Suppress warnings
 warnings.filterwarnings("ignore", category=UserWarning, module="gtts")
 
-
-# Initialize NLP model (You might want to use a smaller model for faster processing)
+# Initialize NLP models
 nlp = pipeline("text-generation", model="distilgpt2", tokenizer="distilgpt2", device=0 if torch.cuda.is_available() else -1)
+sentiment_analyzer = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
 
 # Speech recognizer setup
 r = sr.Recognizer()
@@ -27,7 +28,7 @@ r = sr.Recognizer()
 # Extract text from PDF resume
 def extract_text_from_pdf(pdf_file):
     try:
-        reader = PdfReader(pdf_file.name)  # Access file using pdf_file.name
+        reader = PdfReader(pdf_file.name)
         text = ""
         for page in reader.pages:
             text += page.extract_text() or ""
@@ -35,170 +36,190 @@ def extract_text_from_pdf(pdf_file):
     except Exception as e:
         return f"Error reading PDF: {str(e)}"
 
-# Analyze resume and generate questions (Same as before)
-def analyze_resume(resume_text):
-    if not resume_text:
-        return ["No resume content found. Please tell me about yourself."]
-
-    skills = re.findall(r"Skills:\s*(.*?)(?:\n|$)", resume_text, re.DOTALL | re.IGNORECASE)
-    experience = re.findall(r"Experience:\s*(.*?)(?:\n[A-Z]|\Z)", resume_text, re.DOTALL | re.IGNORECASE)
-    education = re.findall(r"Education:\s*(.*?)(?:\n|$)", resume_text, re.DOTALL | re.IGNORECASE)
+# Analyze resume and generate questions
+def analyze_resume(resume_text, custom_questions=None, difficulty=1):
+    generic_questions = [
+        "What’s your greatest strength?",
+        "Describe a challenge you overcame.",
+        "Why do you want this role?"
+    ]
+    if not resume_text and not custom_questions:
+        return generic_questions[:difficulty]
 
     questions = []
-
-    if skills:
-        first_skill = skills[0].split(',')[0].strip()  # Get first skill
-        questions.append(f"Tell me about a time you used {first_skill} in a project.")
-
-    if experience:
-        try:  # Add try-except block
-            experience_text = experience[0].strip()
-            company_name = re.search(r"at\s+([\w\s]+?)\s*\(", experience_text)  # improved regex
-            if company_name:
-              company_name = company_name.group(1).strip()
-            else:
-              company_name = "the company" # provide a default value if match is none.
-            questions.append(f"Can you describe a key contribution you made at {company_name}?")
-        except IndexError:
-            print("IndexError encountered while processing experience data.")  # print statement
-            pass  # Handle the exception gracefully
-
-    if education:
-        first_education = education[0].split('(')[0].strip()  # Get first education
-        questions.append(f"How did your education at {first_education} prepare you for this role?")
-
-    return questions if questions else ["Tell me about yourself."]
-
-
-# Provide feedback (Modified for real-time)
+    if resume_text:
+        skills = re.findall(r"Skills:\s*(.*?)(?:\n|$)", resume_text, re.DOTALL | re.IGNORECASE)
+        experience = re.findall(r"Experience:\s*(.*?)(?:\n[A-Z]|\Z)", resume_text, re.DOTALL | re.IGNORECASE)
+        education = re.findall(r"Education:\s*(.*?)(?:\n|$)", resume_text, re.DOTALL | re.IGNORECASE)
+
+        if skills:
+            first_skill = skills[0].split(',')[0].strip()
+            questions.append(f"Tell me about a time you used {first_skill} in a project.")
+        if experience:
+            try:
+                company_name = re.search(r"at\s+([\w\s]+?)\s*\(", experience[0]) or "the company"
+                if isinstance(company_name, str):
+                    company_name = company_name
+                else:
+                    company_name = company_name.group(1).strip()
+                questions.append(f"Can you describe a key contribution you made at {company_name}?")
+            except Exception:
+                pass
+        if education:
+            first_education = education[0].split('(')[0].strip()
+            questions.append(f"How did your education at {first_education} prepare you for this role?")
+
+    if custom_questions:
+        with open(custom_questions.name, "r") as f:
+            questions.extend(f.read().splitlines())
+
+    return (questions + generic_questions)[:max(1, difficulty)]
+
+# Enhanced feedback with sentiment analysis
 def provide_feedback(response):
     if not response:
         return "Please provide an answer."
-    response_length = len(response.split()) # count the words instead of chars
-    if response_length < 20:
-        return "Your answer is short. Please elaborate."
-    elif "I don’t know" in response.lower():
-        return "Try sharing a related experience instead."
-    else:
-        return "Great answer! Well detailed."
-
+    word_count = len(response.split())
+    sentiment = sentiment_analyzer(response)[0]
+    feedback = []
+    if word_count < 20:
+        feedback.append("Your answer is short. Please elaborate.")
+    if "I don’t know" in response.lower():
+        feedback.append("Try sharing a related experience instead.")
+    if sentiment["label"] == "NEGATIVE":
+        feedback.append("Try to sound more positive and confident!")
+    return " ".join(feedback) or "Great answer! Well detailed and positive."
+
+# Analyze code input
+def analyze_code(code):
+    if not code:
+        return "No code provided."
+    try:
+        ast.parse(code)
+        return "Code syntax is valid! Consider adding comments for clarity."
+    except SyntaxError as e:
+        return f"Code error: {str(e)}"
 
+# Create interview video
 def create_interview_video(questions, responses, output_path="interview_simulation.mp4"):
-    """Creates a simple video with questions and responses using OpenCV."""
     try:
-        frame_rate = 1  # Frames per second
-        resolution = (1280, 720)  # Video resolution
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Codec for MP4
-        out = cv2.VideoWriter(output_path, fourcc, int(frame_rate), resolution)
+        frame_rate = 1
+        resolution = (1280, 720)
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, frame_rate, resolution)
 
         for i, (question, response) in enumerate(zip(questions, responses)):
-            # --- Question Frames ---
-            question_text = f"Question {i+1}: {question}"
-            for j in range(int(5 * frame_rate)):  # 5 seconds per question
-                frame = np.zeros((resolution[1], resolution[0], 3), dtype=np.uint8)
-                cv2.putText(frame, question_text, (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)  # White text
+            frame = np.zeros((resolution[1], resolution[0], 3), dtype=np.uint8)
+            cv2.putText(frame, f"Question {i+1}: {question}", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+            for _ in range(5 * frame_rate):
                 out.write(frame)
 
-            # --- Response Frames ---
             if response:
-                response_text = f"Response: {response}"
-                for j in range(int(5 * frame_rate)):  # 5 seconds per response
-                    frame = np.zeros((resolution[1], resolution[0], 3), dtype=np.uint8)
-                    cv2.putText(frame, response_text, (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)  # Yellow text
+                frame = np.zeros((resolution[1], resolution[0], 3), dtype=np.uint8)
+                cv2.putText(frame, f"Response: {response}", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
+                for _ in range(5 * frame_rate):
                     out.write(frame)
 
-        out.release()  # Release the video writer
-        cv2.destroyAllWindows()
-        print(f"Video saved to {output_path}")
+        out.release()
         return output_path
     except Exception as e:
         return f"Video creation failed: {str(e)}"
 
-def transcribe_audio(audio_file):
-    """Transcribes audio to text using SpeechRecognition."""
+# Transcribe audio from video or audio file
+def transcribe_audio(file_path):
     try:
-        with sr.AudioFile(audio_file) as source:
+        if file_path.endswith(".mp4"):  # Handle video input
+            video = VideoFileClip(file_path)
+            audio_path = tempfile.NamedTemporaryFile(suffix=".wav").name
+            video.audio.write_audiofile(audio_path)
+        else:
+            audio_path = file_path
+
+        with sr.AudioFile(audio_path) as source:
             audio = r.record(source)
-        return r.recognize_google(audio)  # Use Google Web Speech API
+        return r.recognize_google(audio)
     except Exception as e:
-        print(f"Transcribe audio error: {e}")
-        return f"Error transcribing audio: {str(e)}" # Important - MUST return something.
+        return f"Error transcribing: {str(e)}"
 
-# Main interview function (Modified for audio input)
-def run_interview(pdf_file, audio_file, user_response, question_index, questions_state, responses_state):
+# Main interview function
+def run_interview(pdf_file, video_file, code_input, mc_input, user_response, question_index, questions_state, responses_state, timer_state, custom_questions, difficulty):
     try:
-        if pdf_file is None:
-            return "Please upload a PDF resume.", "No feedback yet.", None, [], [], 0
-
-        # Extract resume text
-        resume_text = extract_text_from_pdf(pdf_file)
+        # Initialize questions if not set
         if not questions_state:
-            questions_state = analyze_resume(resume_text)
-
-        # Manage responses
-        if not responses_state:
+            resume_text = extract_text_from_pdf(pdf_file) if pdf_file else ""
+            questions_state = analyze_resume(resume_text, custom_questions, difficulty)
             responses_state = [""] * len(questions_state)
-
-        # Process audio if provided
-        if audio_file:
-            transcription = transcribe_audio(audio_file)
-            user_response = transcription  # Use the transcribed text
+            timer_state = 60  # Reset timer
+
+        # Process video/audio input
+        if video_file:
+            user_response = transcribe_audio(video_file)
+
+        # Handle multiple-choice or code input if provided
+        if mc_input:
+            user_response = f"Selected: {mc_input}"
+        elif code_input:
+            user_response = code_input
+            code_feedback = analyze_code(code_input)
         else:
-            transcription = ""  # Ensure transcription is defined even if no audio
-        # Save the transcribed response
+            code_feedback = ""
+
+        # Save response
         if user_response and 0 <= question_index < len(questions_state):
             responses_state[question_index] = user_response
 
         # Check if interview is complete
         if question_index >= len(questions_state):
             video_path = create_interview_video(questions_state, responses_state)
-            return "Interview complete!", "Thank you!", video_path, questions_state, responses_state, question_index  # Add None for video
+            return "Interview complete!", "Thank you!", video_path, questions_state, responses_state, question_index, 0, None
 
         # Current question and feedback
         current_question = questions_state[question_index]
-        feedback = provide_feedback(user_response) if user_response else "Please answer."
+        feedback = provide_feedback(user_response) + (f" {code_feedback}" if code_feedback else "")
 
-        return current_question, feedback, None, questions_state, responses_state, question_index + 1# Add None for video
+        # Update timer (simplified for demo)
+        timer_state = max(0, timer_state - 10)  # Decrement by 10 seconds per submission
+
+        return current_question, feedback, None, questions_state, responses_state, question_index + 1, timer_state, str(timer_state)
 
     except Exception as e:
-         print(f"Run interview error: {e}")
-         return f"Error: {str(e)}", "Something went wrong.", None, [], [], 0
+        return f"Error: {str(e)}", "Something went wrong.", None, [], [], 0, 60, "60"
 
 # Gradio interface
 with gr.Blocks(title="Nancy AI - Advanced Interview Simulator") as demo:
-    try:  # Add a try-except block around the entire Gradio interface
-        gr.Markdown("# Nancy AI - Advanced Interview Simulator")
-        gr.Markdown("Upload your PDF resume and participate in a voice-based interview!")
-
-        question_state = gr.State(value=0)
-        questions_state = gr.State(value=[])
-        responses_state = gr.State(value=[])
-
-        with gr.Row():
-            pdf_input = gr.File(label="Upload PDF Resume", file_types=[".pdf"])
-
-        with gr.Row():
-            audio_input = gr.Audio(sources=["microphone"], label="Record Your Response") # Audio input
-            response_input = gr.Textbox(label="Your Response (Optional)", placeholder="Type your answer here...")
-
-
-        with gr.Row():
-            question_output = gr.Textbox(label="Current Question", interactive=False)
-            feedback_output = gr.Textbox(label="Feedback", interactive=False)
-
-        video_output = gr.Video(label="Interview Simulation (MP4)", visible=False) # initially hidden
-
-
-        submit_btn = gr.Button("Submit Response & Next Question")
-
-        submit_btn.click(
-            fn=run_interview,
-            inputs=[pdf_input, audio_input, response_input, question_state, questions_state, responses_state],
-            outputs=[question_output, feedback_output, video_output, questions_state, responses_state, question_state]
-        )
-    except Exception as e:
-        print(f"Error in Gradio interface: {e}")  # Print the error
-    finally:
-        pass  # Add a finally block (optional, but good practice)
+    gr.Markdown("# Nancy AI - Advanced Interview Simulator")
+    gr.Markdown("Upload your resume and a video response (Note: Webcam recording not supported in Colab; upload pre-recorded videos instead).")
+
+    question_state = gr.State(value=0)
+    questions_state = gr.State(value=[])
+    responses_state = gr.State(value=[])
+    timer_state = gr.State(value=60)
+
+    with gr.Row():
+        pdf_input = gr.File(label="Upload PDF Resume", file_types=[".pdf"])
+        custom_questions = gr.File(label="Upload Custom Questions (TXT)", file_types=[".txt"])
+        difficulty = gr.Slider(1, 5, step=1, label="Difficulty Level", value=1)
+
+    with gr.Row():
+        # Updated: No 'source' parameter; use interactive=True for recording in non-Colab environments
+        video_input = gr.Video(label="Upload or Record Video Response", interactive=True)
+        code_input = gr.Code(language="python", label="Write Your Code (if applicable)")
+        mc_input = gr.Radio(["Option A", "Option B", "Option C"], label="Multiple Choice (if applicable)")
+        text_input = gr.Textbox(label="Your Response (Optional)", placeholder="Type your answer here...")
+
+    with gr.Row():
+        question_output = gr.Textbox(label="Current Question", interactive=False)
+        feedback_output = gr.Textbox(label="Feedback", interactive=False)
+        timer_display = gr.Textbox(label="Time Left (seconds)", interactive=False, value="60")
+
+    video_output = gr.Video(label="Interview Simulation", visible=False)
+
+    submit_btn = gr.Button("Submit Response & Next Question")
+
+    submit_btn.click(
+        fn=run_interview,
+        inputs=[pdf_input, video_input, code_input, mc_input, text_input, question_state, questions_state, responses_state, timer_state, custom_questions, difficulty],
+        outputs=[question_output, feedback_output, video_output, questions_state, responses_state, question_state, timer_state, timer_display]
+    )
 
 demo.launch()