Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,343 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from PyPDF2 import PdfReader
+import google.generativeai as genai
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from pydantic import BaseModel, Field
+from typing import Optional
+from gtts import gTTS
+import speech_recognition as sr
+import os
+import io
+import tempfile
+from streamlit_mic_recorder import mic_recorder # Key component for browser audio
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# --- Configuration & Secrets ---
+
+# Load API Key from Streamlit/Hugging Face Secrets
+# DO NOT hardcode your key. Add it to your HF Space's secrets.
+try:
+    GOOGLE_API_KEY = st.secrets["GOOGLE_API_KEY"]
+    genai.configure(api_key=GOOGLE_API_KEY)
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+except KeyError:
+    st.error("GOOGLE_API_KEY not found in Streamlit secrets. Please add it to your Hugging Face Space secrets.", icon="🚨")
+    st.stop()
+except Exception as e:
+    st.error(f"Error configuring Google API: {e}", icon="🚨")
+    st.stop()
+
+# --- Pydantic Models (from your code) ---
+
+class questions(BaseModel):
+    questions: list[str] = Field(description="List of questions")
+
+class introduction(BaseModel):
+    intro: Optional[str] = Field(description="Give AI agent's intro")
+    question: str = Field(description="Question asked by AI agent")
+    followup: Optional[str] = Field(description="The followup question to user's answer")
+
+class evaluation(BaseModel):
+    marks: int = Field(description="Marks out of 100")
+    followup: Optional[str] = Field(description="The followup question")
+    review: Optional[str] = Field(description="Short Review of the answer")
+
+# --- AI & Logic Functions (from your code, slightly modified) ---
+
+@st.cache_resource
+def get_llm():
+    """Cached function to initialize the LLM."""
+    return ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=1.0)
+
+@st.cache_resource
+def get_models(_llm):
+    """Cached function to get structured output models."""
+    generate_questions_resume_model = _llm.with_structured_output(questions)
+    intro_model = _llm.with_structured_output(introduction)
+    evaluate_answers_model = _llm.with_structured_output(evaluation)
+    return generate_questions_resume_model, intro_model, evaluate_answers_model
+
+def read_resume(uploaded_file):
+    """Reads a PDF file uploaded via Streamlit."""
+    try:
+        reader = PdfReader(uploaded_file)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text() or "" # Add check for None
+        return text
+    except Exception as e:
+        st.error(f"Error reading PDF: {e}")
+        return None
+
+def generate_questions_from_resume(resume_text, model):
+    """Generates interview questions from resume text."""
+    parse_resume_prompt_template = PromptTemplate(
+        template="""Generate 4-8 interview questions about the Experience and Projects section from this given text of from a resume.
+Try to cover all projects and experience. Generate some conceptual questions too. Don't generate unnecessary questions.
+Resume:\n{text}""",
+        input_variables=['text']
+    )
+    generate_question_from_resume_chain = parse_resume_prompt_template | model
+    output = generate_question_from_resume_chain.invoke({'text': resume_text})
+    return output.questions
+
+def get_introduction(model):
+    """Gets the AI's intro and first question."""
+    introduction_prompt = PromptTemplate(template="""Introduce yourself to the user telling the user that you are a AI agent. And ask the user to give introduction""")
+    intro_chain = introduction_prompt | model
+    output = intro_chain.invoke({})
+    return output
+
+def ask_followup(user_intro, model):
+    """Asks a followup to the user's intro."""
+    intro_followup = PromptTemplate(template="""The user has given the following introduction of himself/herself. Ask a followup about his intro to make the user comfortable. Intro given by the user: {intro}""",
+                                    input_variables=['intro'])
+    followup_chain = intro_followup | model
+    output = followup_chain.invoke({'intro': user_intro})
+    return output.followup
+
+def evaluate_answer(question, answer, model):
+    """Evaluates the user's answer."""
+    evaluate_answer_prompt = PromptTemplate(template="""You are given a question and an answer. Evaluate the answer honestly on the question out of 100.
+Also generate a very short review on the answer telling the candidate about his answer. If he is wrong but close to the correct answer, give subtle hints.
+If a good followup question can be asked generate it but only if it is a genuine question.\nQuestion: {question}\n\n Answer: {answer}""",
+                                            input_variables=['question', 'answer'])
+    evaluate_chain = evaluate_answer_prompt | model
+    output = evaluate_chain.invoke({'question': question, 'answer': answer})
+    return output
+
+# --- Streamlit Audio/Visual Functions ---
+
+def text_to_speech_and_display(text, autoplay=True):
+    """Converts text to speech, displays text, and plays audio."""
+    if not text:
+        return
+        
+    try:
+        # Display the caption
+        st.session_state.chat_history.append(f"**Interviewer:** {text}")
+        
+        # Generate audio
+        tts = gTTS(text=text, lang='en', slow=False)
+        audio_fp = io.BytesIO()
+        tts.write_to_fp(audio_fp)
+        audio_fp.seek(0)
+        
+        # Display audio player
+        st.audio(audio_fp, format='audio/mp3', autoplay=autoplay)
+        
+    except Exception as e:
+        st.error(f"Error in text-to-speech: {e}")
+
+def speech_to_text(audio_bytes):
+    """Converts recorded audio bytes to text using SpeechRecognition."""
+    if not audio_bytes:
+        return "No audio recorded."
+    
+    r = sr.Recognizer()
+    
+    # Need to save bytes to a temporary WAV file
+    # because recognizer.recognize_google requires a file path or AudioData
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_wav:
+            temp_wav.write(audio_bytes)
+            temp_wav_path = temp_wav.name
+        
+        # Use the temp file
+        with sr.AudioFile(temp_wav_path) as source:
+            audio_data = r.record(source)
+        
+        # Recognize speech
+        text = r.recognize_google(audio_data)
+        st.session_state.chat_history.append(f"**You:** {text}")
+        return text
+        
+    except sr.UnknownValueError:
+        st.warning("Could not understand audio.")
+        return None
+    except sr.RequestError as e:
+        st.error(f"Speech recognition service error: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Error processing audio: {e}")
+        return None
+    finally:
+        # Clean up the temp file
+        if 'temp_wav_path' in locals() and os.path.exists(temp_wav_path):
+            os.remove(temp_wav_path)
+
+# --- Main Streamlit App ---
+
+st.set_page_config(page_title="AI Interviewer", layout="wide")
+st.title("🤖 AI Interviewer")
+
+# Initialize LLM and models
+llm = get_llm()
+gen_q_model, intro_model, eval_model = get_models(llm)
+
+# --- Session State Initialization ---
+# This is crucial for making the app work step-by-step
+if 'stage' not in st.session_state:
+    st.session_state.stage = 'start'
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'questions' not in st.session_state:
+    st.session_state.questions = []
+if 'q_index' not in st.session_state:
+    st.session_state.q_index = 0
+if 'current_question' not in st.session_state:
+    st.session_state.current_question = ""
+if 'total_marks' not in st.session_state:
+    st.session_state.total_marks = 0
+if 'num_questions' not in st.session_state:
+    st.session_state.num_questions = 0
+
+# --- App Logic (State Machine) ---
+
+# --- STAGE 0: Start (File Upload) ---
+if st.session_state.stage == 'start':
+    st.info("Welcome! Please upload your resume (PDF) to begin the interview.")
+    uploaded_file = st.file_uploader("Upload your Resume (PDF)", type=["pdf"])
+    
+    if uploaded_file:
+        with st.spinner("Analyzing your resume... This may take a moment."):
+            resume_text = read_resume(uploaded_file)
+            if resume_text:
+                # 1. Generate Questions
+                st.session_state.questions = generate_questions_from_resume(resume_text, gen_q_model)
+                if not st.session_state.questions:
+                    st.error("Could not generate questions from the resume. Please try another file.")
+                    st.session_state.stage = 'start'
+                else:
+                    # 2. Get AI Introduction
+                    intro_output = get_introduction(intro_model)
+                    st.session_state.current_question = intro_output.question
+                    
+                    # 3. Move to next stage and display intro
+                    st.session_state.stage = 'awaiting_intro'
+                    text_to_speech_and_display(intro_output.intro)
+                    text_to_speech_and_display(intro_output.question)
+                    st.rerun() # Rerun to update the UI
+
+# --- Main Interview Area (Stages > 0) ---
+if st.session_state.stage != 'start':
+    
+    # --- Chat History Display ---
+    st.subheader("Interview Transcript")
+    chat_container = st.container(height=300, border=True)
+    with chat_container:
+        for entry in st.session_state.chat_history:
+            st.markdown(entry)
+            
+    st.divider()
+
+    # --- Audio Recorder ---
+    # This component returns audio bytes when the user stops recording
+    st.write("Your turn to speak:")
+    audio_bytes = mic_recorder(
+        start_prompt="Start Recording", 
+        stop_prompt="Stop Recording", 
+        key='recorder'
+    )
+
+    # --- End Interview Button ---
+    if st.button("End Interview", type="primary"):
+        st.session_state.stage = 'finished'
+        st.rerun()
+
+    # --- Process Recorded Audio ---
+    if audio_bytes:
+        with st.spinner("Transcribing your answer..."):
+            user_text = speech_to_text(audio_bytes['bytes'])
+        
+        if user_text:
+            # --- STAGE 1: Process User's Introduction ---
+            if st.session_state.stage == 'awaiting_intro':
+                with st.spinner("Thinking of a followup..."):
+                    followup = ask_followup(user_text, intro_model)
+                    st.session_state.current_question = followup
+                    text_to_speech_and_display(followup)
+                    st.session_state.stage = 'awaiting_intro_followup'
+                    st.rerun()
+            
+            # --- STAGE 2: Process Followup to Intro ---
+            elif st.session_state.stage == 'awaiting_intro_followup':
+                text_to_speech_and_display("OK, Great. Let's start the interview with questions from your resume.")
+                st.session_state.stage = 'asking_question' # Move to main questions
+                st.rerun()
+
+            # --- STAGE 4: Process Answer to a Main Question ---
+            elif st.session_state.stage == 'awaiting_answer':
+                with st.spinner("Evaluating your answer..."):
+                    question_asked = st.session_state.current_question
+                    output = evaluate_answer(question_asked, user_text, eval_model)
+                    
+                    st.session_state.total_marks += output.marks
+                    st.session_state.num_questions += 1
+                    
+                    if output.review:
+                        text_to_speech_and_display(output.review)
+                    
+                    if output.followup:
+                        # Ask followup question
+                        st.session_state.current_question = output.followup
+                        text_to_speech_and_display(output.followup)
+                        st.session_state.stage = 'awaiting_followup_answer'
+                    else:
+                        # Move to next question
+                        st.session_state.q_index += 1
+                        st.session_state.stage = 'asking_question'
+                    st.rerun()
+
+            # --- STAGE 5: Process Answer to a Followup Question ---
+            elif st.session_state.stage == 'awaiting_followup_answer':
+                 with st.spinner("Evaluating your answer..."):
+                    question_asked = st.session_state.current_question
+                    output = evaluate_answer(question_asked, user_text, eval_model)
+                    
+                    st.session_state.total_marks += output.marks
+                    st.session_state.num_questions += 1
+                    
+                    if output.review:
+                        text_to_speech_and_display(output.review)
+                    
+                    # Always move to the next main question after a followup
+                    st.session_state.q_index += 1
+                    st.session_state.stage = 'asking_question'
+                    st.rerun()
+
+    # --- STAGE 3: Ask a New Question ---
+    if st.session_state.stage == 'asking_question':
+        if st.session_state.q_index < len(st.session_state.questions):
+            # Ask the next question
+            question = st.session_state.questions[st.session_state.q_index]
+            st.session_state.current_question = question
+            text_to_speech_and_display(question)
+            st.session_state.stage = 'awaiting_answer'
+        else:
+            # No more questions
+            st.session_state.stage = 'finished'
+            st.rerun()
+
+    # --- STAGE 6: Finished ---
+    if st.session_state.stage == 'finished':
+        st.balloons()
+        st.success("Interview Complete!")
+        
+        final_score = 0
+        if st.session_state.num_questions > 0:
+            final_score = st.session_state.total_marks / st.session_state.num_questions
+        
+        st.subheader("Final Report")
+        st.markdown(f"**Total Questions Answered:** {st.session_state.num_questions}")
+        st.markdown(f"**Average Score:** {final_score:.2f} / 100")
+        
+        st.subheader("Full Transcript")
+        for entry in st.session_state.chat_history:
+            st.markdown(entry)
+            
+        if st.button("Start New Interview"):
+            # Clear all session state
+            for key in st.session_state.keys():
+                del st.session_state[key]
+            st.rerun()