Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,16 +1,45 @@
 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
+try:
+    from PyPDF2 import PdfReader
+except Exception:
+    PdfReader = None
+
+# Optional AI SDKs - guarded imports so the app can still run without them
+try:
+    import google.generativeai as genai
+except Exception:
+    genai = None
+
+try:
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    from langchain_core.prompts import PromptTemplate
+except Exception:
+    ChatGoogleGenerativeAI = None
+    PromptTemplate = None
+
 from pydantic import BaseModel, Field
 from typing import Optional
-from gtts import gTTS
-import speech_recognition as sr
+
+# Optional TTS / speech libs
+try:
+    from gtts import gTTS
+except Exception:
+    gTTS = None
+
+try:
+    import speech_recognition as sr
+except Exception:
+    sr = None
+
 import os
 import io
 import tempfile
-from streamlit_mic_recorder import mic_recorder # Key component for browser audio
+try:
+    from streamlit_mic_recorder import mic_recorder # Key component for browser audio
+except Exception:
+    # Fallback dummy recorder function that always returns None
+    def mic_recorder(*args, **kwargs):
+        return None
 
 # --- Configuration & Secrets ---
 
@@ -54,6 +83,10 @@ def get_models(_llm_model):
 def read_resume(uploaded_file):
     """Reads a PDF file uploaded via Streamlit."""
     try:
+        if PdfReader is None:
+            st.warning("PyPDF2 is not installed; resume text extraction disabled.")
+            return None
+        # PdfReader accepts a file-like object
         reader = PdfReader(uploaded_file)
         text = ""
         for page in reader.pages:
@@ -65,18 +98,52 @@ def read_resume(uploaded_file):
 
 def generate_questions_from_resume(resume_text, model):
     """Generates interview questions from resume text."""
+    # If LangChain PromptTemplate or LLM wrapper is not available, return simple heuristic questions
+    if PromptTemplate is None or model is None:
+        # Simple fallback: create questions from lines with 'Project'/'Experience' keywords
+        lines = resume_text.splitlines()
+        candidates = [l.strip() for l in lines if l and ('project' in l.lower() or 'experience' in l.lower())]
+        questions = []
+        for c in candidates:
+            if len(questions) >= 6:
+                break
+            questions.append(f"Tell me more about: {c}")
+        if not questions:
+            questions = ["Tell me about your most significant project.", "Describe a challenging bug you fixed.", "How do you design for scalability?", "Which technologies are you most comfortable with?"]
+        return questions
+
     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
+    # Use the LangChain pipeline if available
+    try:
+        generate_question_from_resume_chain = parse_resume_prompt_template | model
+        output = generate_question_from_resume_chain.invoke({'text': resume_text})
+        # attempt to coerce into a list
+        return getattr(output, 'questions', output)
+    except Exception as e:
+        st.warning(f"LLM question generation failed, using fallback: {e}")
+        # fallback similar to above
+        lines = resume_text.splitlines()
+        candidates = [l.strip() for l in lines if l and ('project' in l.lower() or 'experience' in l.lower())]
+        questions = []
+        for c in candidates:
+            if len(questions) >= 6:
+                break
+            questions.append(f"Tell me more about: {c}")
+        if not questions:
+            questions = ["Tell me about your most significant project.", "Describe a challenging bug you fixed.", "How do you design for scalability?", "Which technologies are you most comfortable with?"]
+        return questions
 
 def get_introduction(model):
     """Gets the AI's intro and first question."""
+    if PromptTemplate is None or model is None:
+        # Return a simple dict-like fallback
+        return type('O', (), {'intro': "Hello, I'm Interviewer.AI. Please introduce yourself.", 'question': "Can you briefly introduce yourself?"})()
+
     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({})
@@ -84,14 +151,31 @@ def get_introduction(model):
 
 def ask_followup(user_intro, model):
     """Asks a followup to the user's intro."""
+    if PromptTemplate is None or model is None:
+        return "Thanks — could you tell me one achievement you're most proud of?"
+
     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
+    return getattr(output, 'followup', None)
 
 def evaluate_answer(question, answer, model):
     """Evaluates the user's answer."""
+    if PromptTemplate is None or model is None:
+        # Simple heuristic evaluator
+        score = 50
+        review = "Thank you for your answer. Provide more details next time."
+        followup = None
+        # small heuristic: longer answers get better score
+        if answer and len(answer.split()) > 50:
+            score = 80
+            review = "Good answer — you covered several points."
+        elif answer and len(answer.split()) > 20:
+            score = 65
+            review = "Decent answer; add more concrete examples."
+        return type('O', (), {'marks': score, 'review': review, 'followup': followup})()
+
     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}""",
@@ -109,14 +193,20 @@ def text_to_speech_and_display(text, autoplay=True):
         
     try:
         # Display the caption
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
         st.session_state.chat_history.append(f"**Interviewer:** {text}")
-        
-        # Generate audio
+
+        # Generate audio if gTTS available
+        if gTTS is None:
+            # No TTS available; just show text
+            return
+
         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)
         
@@ -128,24 +218,27 @@ def speech_to_text(audio_bytes):
     if not audio_bytes:
         return "No audio recorded."
     
+    if sr is None:
+        st.warning("speech_recognition is not installed; microphone input unavailable.")
+        return None
+
     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)
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
         st.session_state.chat_history.append(f"**You:** {text}")
         return text
-        
+
     except sr.UnknownValueError:
         st.warning("Could not understand audio.")
         return None
@@ -156,9 +249,11 @@ def speech_to_text(audio_bytes):
         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)
+            try:
+                os.remove(temp_wav_path)
+            except Exception:
+                pass
 
 # --- Main Streamlit App ---
 
@@ -166,20 +261,26 @@ st.set_page_config(page_title="AI Interviewer", layout="wide")
 st.title("Interviewer.AI")
 
 # Initialize LLM and models
-# First, load the key from the environment variable
-try:
-    GOOGLE_API_KEY = os.environ["GOOGLE_API_KEY"] 
-    genai.configure(api_key=GOOGLE_API_KEY)
-except KeyError:
-    st.error("GOOGLE_API_KEY not found in Hugging Face secrets. Please go to your Space's 'Settings' tab and add it.", icon="🚨")
-    st.stop()
-except Exception as e:
-    st.error(f"Error configuring Google API: {e}", icon="🚨")
-    st.stop()
-
-# Now, pass the key to the cached function
-llm = get_llm(GOOGLE_API_KEY) 
-gen_q_model, intro_model, eval_model = get_models(llm)
+llm = None
+gen_q_model = None
+intro_model = None
+eval_model = None
+
+# First, load the key from the environment variable if genai is available
+if genai is None or ChatGoogleGenerativeAI is None:
+    st.warning("Google GenAI or LangChain wrappers not available. App will use deterministic fallbacks.")
+else:
+    try:
+        GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+        if not GOOGLE_API_KEY:
+            st.warning("GOOGLE_API_KEY not set; using fallbacks for LLM features.")
+        else:
+            genai.configure(api_key=GOOGLE_API_KEY)
+            # Initialize LLM and model wrappers
+            llm = get_llm(GOOGLE_API_KEY)
+            gen_q_model, intro_model, eval_model = get_models(llm)
+    except Exception as e:
+        st.warning(f"Could not initialize LLM: {e}. Using fallbacks.")
 
 # --- Session State Initialization ---
 # This is crucial for making the app work step-by-step
@@ -217,12 +318,12 @@ if st.session_state.stage == 'start':
                 else:
                     # 2. Get AI Introduction
                     intro_output = get_introduction(intro_model)
-                    st.session_state.current_question = intro_output.question
+                    st.session_state.current_question = getattr(intro_output, 'question', "Can you introduce yourself?")
                     
                     # 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)
+                    text_to_speech_and_display(getattr(intro_output, 'intro', "Hello, I'm Interviewer.AI. Please introduce yourself."))
+                    text_to_speech_and_display(getattr(intro_output, 'question', "Can you introduce yourself?"))
                     st.rerun() # Rerun to update the UI
 
 # --- Main Interview Area (Stages > 0) ---
@@ -230,19 +331,23 @@ if st.session_state.stage != 'start':
     
     # --- Chat History Display ---
     st.subheader("Interview Transcript")
-    chat_container = st.container(height=300, border=True)
+    chat_container = st.container()
     with chat_container:
         for entry in st.session_state.chat_history:
             st.markdown(entry)
-            
-    st.divider()
+
+    # visual divider
+    try:
+        st.divider()
+    except Exception:
+        st.markdown('---')
 
     # --- 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", 
+        start_prompt="Start Recording",
+        stop_prompt="Stop Recording",
         key='recorder'
     )
 
@@ -252,9 +357,21 @@ if st.session_state.stage != 'start':
         st.rerun()
 
     # --- Process Recorded Audio ---
-    if audio_bytes:
+    # mic_recorder may return None, bytes, or a dict with a 'bytes' key depending on implementation
+    def _extract_audio_bytes(rec):
+        if rec is None:
+            return None
+        if isinstance(rec, dict):
+            # some implementations return {'bytes': b'...', 'start':..., ...}
+            return rec.get('bytes') or rec.get('audio') or None
+        if isinstance(rec, (bytes, bytearray)):
+            return bytes(rec)
+        return None
+
+    extracted_audio = _extract_audio_bytes(audio_bytes)
+    if extracted_audio:
         with st.spinner("Transcribing your answer..."):
-            user_text = speech_to_text(audio_bytes['bytes'])
+            user_text = speech_to_text(extracted_audio)
         
         if user_text:
             # --- STAGE 1: Process User's Introduction ---