Upload 4 files

README.md

@@ -1,13 +1,99 @@
----
-title: Virtual Interviewer
-emoji: 🐨
-colorFrom: blue
-colorTo: red
-sdk: streamlit
-sdk_version: 1.42.2
-app_file: app.py
-pinned: false
-short_description: A virtual interviewer powered by GPT 4o
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Virtual Interviewer
+emoji: 🎯
+colorFrom: indigo
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Virtual Interviewer
+
+[![Open in Spaces](https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-sm.svg)](https://huggingface.co/spaces/username/virtual-interviewer)
+[![GitHub](https://img.shields.io/badge/GitHub-Repository-blue?logo=github)](https://github.com/username/virtual-interviewer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![OpenAI](https://img.shields.io/badge/OpenAI-GPT--4o-green.svg)](https://openai.com/)
+
+A Streamlit application that simulates job interviews using OpenAI's GPT-4o model. This tool helps users practice for interviews by generating relevant questions based on job descriptions and providing feedback on their answers.
+
+![Virtual Interviewer Demo](https://your-image-url-here.png)
+
+## 🌟 Features
+
+- 💼 Generate interview questions based on job descriptions
+- 🎭 Support for both technical and non-technical interviews
+- 📊 Adjustable difficulty levels (Easy, Medium, Hard)
+- 🔍 Focus on specific key topics
+- 📝 Score interview responses with detailed feedback
+- 💡 Generate ideal answers for comparison
+- 🔊 Text-to-speech for questions with multiple voice options
+- 📈 Visual score summary with performance analytics
+- 🎨 Modern, responsive UI with intuitive controls
+
+## 🚀 Quick Start
+
+1. Enter your OpenAI API key
+2. Paste a job description or use the default Solution Architect example
+3. Configure your interview settings:
+   - Select interview type (Technical or Non-technical)
+   - Choose difficulty level (Easy, Medium, Hard)
+   - Customize key topics
+   - Enable/disable scoring and ideal answers
+   - Set the number of questions
+   - Enable text-to-speech and select a voice (optional)
+4. Click "Start Interview" to begin
+5. Answer each question and click "Next Question" to proceed
+6. Review your performance with the visual score summary and detailed feedback
+
+## 📋 Requirements
+
+- Python 3.8+
+- OpenAI API key
+- Required packages (installed automatically):
+  - streamlit
+  - openai
+  - pandas
+  - edge-tts
+
+## 💻 Installation for Local Development
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/username/virtual-interviewer.git
+   cd virtual-interviewer
+   ```
+
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Run the Streamlit application:
+   ```bash
+   streamlit run app.py
+   ```
+
+## 🔒 Privacy and Security
+
+- Your OpenAI API key is used only for making API calls and is not stored permanently
+- Interview data is stored only in your browser's session
+- All processing happens on your local machine or within the HuggingFace Space
+- No data is sent to external servers beyond the necessary API calls to OpenAI
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgements
+
+- Built with [Streamlit](https://streamlit.io/)
+- Powered by [OpenAI GPT-4o](https://openai.com/)
+- Text-to-speech provided by [Edge-TTS](https://github.com/rany2/edge-tts) 

app.py

@@ -0,0 +1,785 @@
+import streamlit as st
+import json
+import base64
+import os
+import time
+import uuid
+from backend import VirtualInterviewer
+import pandas as pd
+
+# Set page configuration
+st.set_page_config(
+    page_title="Virtual Interviewer",
+    page_icon="🎯",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Default job description and key topics for Solution Architect
+DEFAULT_JOB_DESCRIPTION = """
+Job Title: Enterprise Solution Architect
+
+Job Description:
+We are seeking an experienced Enterprise Solution Architect to design and implement innovative technology solutions that address complex business challenges. The ideal candidate will have a strong background in cloud architecture, enterprise integration, and modern application development.
+
+Responsibilities:
+- Design scalable, secure, and resilient enterprise solutions using cloud-native technologies
+- Create architectural blueprints and technical roadmaps aligned with business objectives
+- Evaluate and recommend appropriate technologies and frameworks for various business needs
+- Lead technical discussions with stakeholders and development teams
+- Ensure solutions adhere to architectural standards, best practices, and compliance requirements
+- Mentor junior architects and developers on architectural principles and patterns
+
+Requirements:
+- 8+ years of experience in IT with at least 5 years in solution architecture
+- Strong knowledge of Azure cloud services and architecture patterns
+- Experience with Java enterprise applications and microservices architecture
+- Familiarity with GraphQL API design and implementation
+- Experience integrating with Salesforce and other enterprise systems
+- Knowledge of Generative AI technologies and their practical applications
+- Excellent communication and presentation skills
+- Ability to translate business requirements into technical solutions
+"""
+
+DEFAULT_KEY_TOPICS = "Azure, GraphQL, Java, Salesforce, Generative AI, Cloud Architecture, Microservices, API Design"
+
+# Custom CSS for styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #4527A0;
+        font-weight: 700;
+        margin-bottom: 0;
+    }
+    .sub-header {
+        font-size: 1.1rem;
+        color: #5E35B1;
+        font-style: italic;
+        margin-top: 0;
+    }
+    .section-header {
+        font-size: 1.5rem;
+        color: #3949AB;
+        font-weight: 600;
+        border-bottom: 2px solid #3949AB;
+        padding-bottom: 0.3rem;
+        margin-top: 1rem;
+    }
+    .question-header {
+        font-size: 1.3rem;
+        color: #1E88E5;
+        font-weight: 600;
+    }
+    .question-number {
+        font-size: 1rem;
+        color: #0D47A1;
+        font-weight: 500;
+    }
+    .success-text {
+        color: #2E7D32;
+        font-weight: 500;
+    }
+    .warning-text {
+        color: #FF6F00;
+        font-weight: 500;
+    }
+    .score-header {
+        font-size: 1.4rem;
+        color: #00897B;
+        font-weight: 600;
+    }
+    .score-value {
+        font-size: 1.8rem;
+        color: #00695C;
+        font-weight: 700;
+    }
+    .feedback-text {
+        color: #455A64;
+        font-style: italic;
+    }
+    .ideal-answer-header {
+        color: #7B1FA2;
+        font-weight: 600;
+    }
+    .user-answer-header {
+        color: #0277BD;
+        font-weight: 600;
+    }
+    .footer {
+        text-align: center;
+        color: #78909C;
+        font-size: 0.8rem;
+        margin-top: 2rem;
+    }
+    .stButton>button {
+        background-color: #3949AB;
+        color: white;
+        font-weight: 500;
+    }
+    .stButton>button:hover {
+        background-color: #303F9F;
+        color: white;
+    }
+    .submit-button>button {
+        background-color: #00897B;
+        color: white;
+    }
+    .submit-button>button:hover {
+        background-color: #00796B;
+    }
+    .score-button>button {
+        background-color: #7B1FA2;
+        color: white;
+    }
+    .score-button>button:hover {
+        background-color: #6A1B9A;
+    }
+    .stExpander {
+        border: 1px solid #E0E0E0;
+        border-radius: 5px;
+        margin-bottom: 1rem;
+    }
+    /* Voice selection styling */
+    div[data-testid="stRadio"] > div {
+        background-color: #E8EAF6;
+        padding: 1rem;
+        border-radius: 5px;
+        margin-bottom: 1rem;
+    }
+    div[data-testid="stRadio"] label {
+        font-weight: 500;
+        color: #3949AB;
+    }
+    .audio-player {
+        margin-top: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    /* Score table styling */
+    .score-table {
+        width: 100%;
+        border-collapse: collapse;
+        margin-bottom: 2rem;
+        font-size: 1.1rem;
+        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        border-radius: 5px;
+        overflow: hidden;
+    }
+    .score-table th {
+        background-color: #3949AB;
+        color: white;
+        font-weight: 600;
+        text-align: left;
+        padding: 0.75rem 1rem;
+        border: none;
+    }
+    .score-table td {
+        padding: 0.75rem 1rem;
+        border-bottom: 1px solid #E0E0E0;
+        vertical-align: middle;
+    }
+    .score-table tr:last-child {
+        font-weight: bold;
+        background-color: #E8EAF6;
+    }
+    .score-table tr:last-child td {
+        border-top: 2px solid #3949AB;
+        border-bottom: none;
+        color: #3949AB;
+    }
+    .score-table tr:nth-child(even):not(:last-child) {
+        background-color: #F5F5F5;
+    }
+    .score-table tr:hover:not(:last-child) {
+        background-color: #EDE7F6;
+    }
+    /* Make the table responsive */
+    @media screen and (max-width: 600px) {
+        .score-table {
+            font-size: 0.9rem;
+        }
+        .score-table th, .score-table td {
+            padding: 0.5rem;
+        }
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Function to create an HTML audio player
+def get_audio_player_html(audio_path, autoplay=True, player_id=None):
+    if not audio_path or not os.path.exists(audio_path):
+        return ""
+    
+    # Generate a unique ID for this audio player if not provided
+    if player_id is None:
+        player_id = str(uuid.uuid4())
+    
+    # Read the audio file
+    with open(audio_path, 'rb') as f:
+        audio_bytes = f.read()
+    
+    audio_base64 = base64.b64encode(audio_bytes).decode()
+    
+    autoplay_attr = "autoplay" if autoplay else ""
+    
+    # Create HTML with JavaScript to ensure autoplay works
+    html = f"""
+    <div class="audio-player" id="audio-container-{player_id}">
+        <audio id="audio-{player_id}" controls {autoplay_attr}>
+            <source src="data:audio/mp3;base64,{audio_base64}" type="audio/mp3">
+            Your browser does not support the audio element.
+        </audio>
+    </div>
+    <script>
+        // Force play the audio after a short delay
+        setTimeout(function() {{
+            const audioElement = document.getElementById('audio-{player_id}');
+            if (audioElement) {{
+                audioElement.play().catch(e => console.log('Auto-play failed:', e));
+            }}
+        }}, 500);
+    </script>
+    """
+    return html
+
+# Initialize session state variables if they don't exist
+if 'interviewer' not in st.session_state:
+    st.session_state.interviewer = None
+if 'current_question_index' not in st.session_state:
+    st.session_state.current_question_index = 0
+if 'current_question' not in st.session_state:
+    st.session_state.current_question = ""
+if 'conversation_history' not in st.session_state:
+    st.session_state.conversation_history = []
+if 'interview_started' not in st.session_state:
+    st.session_state.interview_started = False
+if 'interview_setup_done' not in st.session_state:
+    st.session_state.interview_setup_done = False
+if 'questions_generated' not in st.session_state:
+    st.session_state.questions_generated = False
+if 'interview_completed' not in st.session_state:
+    st.session_state.interview_completed = False
+if 'interview_scored' not in st.session_state:
+    st.session_state.interview_scored = False
+if 'score_results' not in st.session_state:
+    st.session_state.score_results = None
+if 'answer_submitted' not in st.session_state:
+    st.session_state.answer_submitted = False
+if 'current_answer' not in st.session_state:
+    st.session_state.current_answer = ""
+if 'generate_ideal_answers' not in st.session_state:
+    st.session_state.generate_ideal_answers = True
+if 'voice_type' not in st.session_state:
+    st.session_state.voice_type = "female_casual"
+if 'use_tts' not in st.session_state:
+    st.session_state.use_tts = False
+if 'current_audio_path' not in st.session_state:
+    st.session_state.current_audio_path = ""
+if 'audio_key' not in st.session_state:
+    st.session_state.audio_key = str(uuid.uuid4())
+if 'should_play_audio' not in st.session_state:
+    st.session_state.should_play_audio = True
+
+# Define callback functions
+def reset_answer_input():
+    st.session_state.answer_submitted = False
+    st.session_state.current_answer = ""
+    # We don't modify st.session_state.user_answer directly
+
+# Function to generate audio for a question
+def ensure_audio_for_question(question, voice_type):
+    """Ensure audio exists for the given question and return the path."""
+    if not question:
+        return ""
+        
+    # Check if we already have audio for this question
+    audio_path = st.session_state.interviewer.get_question_audio_path(question)
+    
+    # If no audio exists, generate it
+    if not audio_path:
+        with st.spinner("Generating audio..."):
+            audio_path = st.session_state.interviewer.generate_question_audio(question, voice_type)
+    
+    # Update the current audio path in session state
+    st.session_state.current_audio_path = audio_path
+    
+    # Generate a new audio key to force refresh
+    st.session_state.audio_key = str(uuid.uuid4())
+    
+    return audio_path
+
+# Function to handle replay button click
+def replay_audio():
+    st.session_state.should_play_audio = True
+    st.session_state.audio_key = str(uuid.uuid4())
+
+# Title and description
+st.markdown("<h1 class='main-header'>🎯 Virtual Interviewer</h1>", unsafe_allow_html=True)
+st.markdown("<p class='sub-header'>An AI-powered interview simulator to help you prepare for your next job interview.</p>", unsafe_allow_html=True)
+
+# Create a two-column layout
+left_col, right_col = st.columns([1, 1])
+
+with left_col:
+    # Interview setup section
+    if not st.session_state.interview_setup_done:
+        st.markdown("<h2 class='section-header'>📋 Interview Setup</h2>", unsafe_allow_html=True)
+        
+        # 1a. Job requirement text box
+        job_description = st.text_area(
+            "💼 Job Description",
+            value=DEFAULT_JOB_DESCRIPTION,
+            height=200
+        )
+        
+        # 1b. OpenAI API Key
+        api_key = st.text_input(
+            "🔑 OpenAI API Key",
+            type="password",
+            placeholder="Enter your OpenAI API key"
+        )
+        
+        # 2. Interview type dropdown
+        interview_type = st.selectbox(
+            "🎭 Interview Type",
+            options=["Technical", "Non-technical"]
+        )
+        
+        # 3. Difficulty level dropdown
+        difficulty_level = st.selectbox(
+            "📊 Difficulty Level",
+            options=["Easy", "Medium", "Hard"]
+        )
+        
+        # 4. Key topics text box
+        key_topics = st.text_input(
+            "🔍 Key Topics",
+            value=DEFAULT_KEY_TOPICS
+        )
+        
+        # 5. Scoring option
+        enable_scoring = st.radio(
+            "📝 Enable Scoring?",
+            options=["Yes", "No"],
+            horizontal=True
+        )
+        
+        # New option for generating ideal answers
+        generate_ideal_answers = st.radio(
+            "💡 Generate Ideal Answers?",
+            options=["Yes", "No"],
+            horizontal=True
+        )
+        
+        # 6. Number of questions
+        num_questions = st.number_input(
+            "❓ Number of Questions",
+            min_value=1,
+            max_value=10,
+            value=5
+        )
+        
+        # Text-to-Speech options
+        st.markdown("<h3 class='section-header'>🔊 Text-to-Speech Options</h3>", unsafe_allow_html=True)
+        
+        use_tts = st.checkbox("Enable Text-to-Speech for questions", value=True)
+        
+        if use_tts:
+            # Voice type selection with a single radio button for all voices
+            st.markdown("<p style='margin-top: 1rem; font-weight: 500;'>Select a voice for the interviewer:</p>", unsafe_allow_html=True)
+            
+            # Create a single radio button with all voice options
+            voice_options = [
+                "👨 Male - Casual (Guy)",
+                "👨 Male - Formal (Christopher)",
+                "👨 Male - British (Ryan)",
+                "👩 Female - Casual (Jenny)",
+                "👩 Female - Formal (Aria)",
+                "👩 Female - British (Sonia)"
+            ]
+            
+            selected_voice = st.radio(
+                "Voice Selection",
+                options=voice_options,
+                index=3,  # Default to Female Casual
+                label_visibility="collapsed"  # Hide the label since we already have a header
+            )
+            
+            # Map the selected voice to the backend voice type
+            voice_mapping = {
+                "👨 Male - Casual (Guy)": "male_casual",
+                "👨 Male - Formal (Christopher)": "male_formal",
+                "👨 Male - British (Ryan)": "male_british",
+                "👩 Female - Casual (Jenny)": "female_casual",
+                "👩 Female - Formal (Aria)": "female_formal",
+                "👩 Female - British (Sonia)": "female_british"
+            }
+            
+            voice_type = voice_mapping.get(selected_voice, "female_casual")
+        else:
+            voice_type = "female_casual"
+        
+        # Start interview button
+        if st.button("🚀 Start Interview"):
+            if not api_key:
+                st.error("⚠️ Please enter your OpenAI API key.")
+            elif not job_description:
+                st.error("⚠️ Please enter a job description.")
+            else:
+                with st.spinner("Setting up your interview..."):
+                    try:
+                        # Initialize the interviewer
+                        st.session_state.interviewer = VirtualInterviewer(api_key)
+                        
+                        # Store whether to generate ideal answers
+                        should_generate_ideal_answers = (generate_ideal_answers == "Yes")
+                        st.session_state.generate_ideal_answers = should_generate_ideal_answers
+                        
+                        # Store TTS settings
+                        st.session_state.use_tts = use_tts
+                        st.session_state.voice_type = voice_type
+                        
+                        # Generate questions
+                        questions = st.session_state.interviewer.generate_interview_questions(
+                            job_description=job_description,
+                            interview_type=interview_type,
+                            difficulty_level=difficulty_level,
+                            key_topics=key_topics,
+                            num_questions=int(num_questions),
+                            generate_ideal_answers=should_generate_ideal_answers
+                        )
+                        
+                        # Generate audio for the first question if TTS is enabled
+                        if use_tts and questions:
+                            with st.spinner("Generating audio for first question..."):
+                                audio_path = st.session_state.interviewer.generate_question_audio(questions[0], voice_type)
+                                st.session_state.current_audio_path = audio_path
+                                st.session_state.audio_key = str(uuid.uuid4())
+                                st.session_state.should_play_audio = True
+                        
+                        # Store interview parameters for scoring later
+                        st.session_state.job_description = job_description
+                        st.session_state.interview_type = interview_type
+                        st.session_state.difficulty_level = difficulty_level
+                        st.session_state.enable_scoring = (enable_scoring == "Yes")
+                        st.session_state.num_questions = int(num_questions)
+                        
+                        # Set the first question
+                        st.session_state.current_question = questions[0]
+                        st.session_state.questions_generated = True
+                        st.session_state.interview_setup_done = True
+                        st.session_state.interview_started = True
+                        st.session_state.answer_submitted = False
+                        st.session_state.current_answer = ""
+                        
+                        # Rerun to update the UI
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"⚠️ Error setting up the interview: {str(e)}")
+    
+    # Interview in progress section
+    elif st.session_state.interview_started and not st.session_state.interview_completed:
+        st.markdown("<h2 class='section-header'>🎙️ Interview in Progress</h2>", unsafe_allow_html=True)
+        
+        # Display current question number
+        st.markdown(f"<p class='question-number'>Question {st.session_state.current_question_index + 1} of {len(st.session_state.interviewer.questions_asked)}</p>", unsafe_allow_html=True)
+        
+        # Display conversation history
+        if st.session_state.conversation_history:
+            st.markdown("<h3 class='section-header'>📜 Previous Questions and Answers</h3>", unsafe_allow_html=True)
+            for i, qa in enumerate(st.session_state.conversation_history):
+                if i % 2 == 0:  # Question (even index)
+                    st.markdown(f"<p><strong style='color: #3949AB;'>Q{i//2 + 1}:</strong> {qa}</p>", unsafe_allow_html=True)
+                else:  # Answer (odd index)
+                    st.markdown(f"<p><em style='color: #455A64;'>A: {qa}</em></p>", unsafe_allow_html=True)
+                    st.markdown("<hr style='margin: 0.5rem 0; border-color: #E0E0E0;'>", unsafe_allow_html=True)
+    
+    # Interview completed section
+    elif st.session_state.interview_completed:
+        st.markdown("<h2 class='section-header'>🏁 Interview Completed</h2>", unsafe_allow_html=True)
+        
+        # Display conversation history
+        if st.session_state.conversation_history:
+            st.markdown("<h3 class='section-header'>📋 Interview Summary</h3>", unsafe_allow_html=True)
+            for i, qa in enumerate(st.session_state.conversation_history):
+                if i % 2 == 0:  # Question (even index)
+                    st.markdown(f"<p><strong style='color: #3949AB;'>Q{i//2 + 1}:</strong> {qa}</p>", unsafe_allow_html=True)
+                else:  # Answer (odd index)
+                    st.markdown(f"<p><em style='color: #455A64;'>A: {qa}</em></p>", unsafe_allow_html=True)
+                    st.markdown("<hr style='margin: 0.5rem 0; border-color: #E0E0E0;'>", unsafe_allow_html=True)
+        
+        # Option to restart
+        if st.button("🔄 Start New Interview"):
+            # Reset all session state variables
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.rerun()
+
+# Right column for displaying the current question and answer input
+with right_col:
+    if st.session_state.interview_started and not st.session_state.interview_completed:
+        st.markdown("<h2 class='section-header'>❓ Current Question</h2>", unsafe_allow_html=True)
+        
+        # Display the current question
+        st.markdown(f"<p class='question-header'>{st.session_state.current_question}</p>", unsafe_allow_html=True)
+        
+        # Display audio player if TTS is enabled
+        if st.session_state.use_tts:
+            # Ensure we have audio for the current question
+            current_question = st.session_state.current_question
+            audio_path = ensure_audio_for_question(current_question, st.session_state.voice_type)
+            
+            # Display audio player with unique key to force refresh
+            if audio_path and os.path.exists(audio_path):
+                # Create a container for the audio player
+                audio_container = st.empty()
+                
+                # Display the audio player with the current audio key
+                audio_container.markdown(
+                    get_audio_player_html(
+                        audio_path, 
+                        autoplay=st.session_state.should_play_audio,
+                        player_id=st.session_state.audio_key
+                    ), 
+                    unsafe_allow_html=True
+                )
+                
+                # Reset the should_play_audio flag after displaying
+                if st.session_state.should_play_audio:
+                    st.session_state.should_play_audio = False
+                
+                # Add a button to replay the audio
+                if st.button("🔊 Replay Question Audio"):
+                    # Set flag to play audio and generate new key
+                    replay_audio()
+                    st.rerun()
+        
+        # Text area for the user's answer
+        user_answer = st.text_area(
+            "Your Answer",
+            key="user_answer",
+            height=300,
+            placeholder="Type your answer here..."
+        )
+        
+        # Submit button for the answer
+        submit_button_col1, submit_button_col2, submit_button_col3 = st.columns([1, 1, 1])
+        with submit_button_col2:
+            if st.button("✅ Submit Answer", key="submit_answer"):
+                if user_answer:  # Use the local variable, not session_state
+                    st.session_state.answer_submitted = True
+                    st.session_state.current_answer = user_answer  # Store the answer in a different session state variable
+                    st.markdown("<p class='success-text'>✅ Answer submitted! Click 'Next Question' to continue.</p>", unsafe_allow_html=True)
+                else:
+                    st.markdown("<p class='warning-text'>⚠️ Please provide an answer before submitting.</p>", unsafe_allow_html=True)
+    
+    # Display score results if interview is scored
+    elif st.session_state.interview_scored and st.session_state.score_results:
+        st.markdown("<h2 class='section-header'>📊 Interview Results</h2>", unsafe_allow_html=True)
+        
+        score_results = st.session_state.score_results
+        
+        # Display overall score with a visual indicator
+        if "overall_score" in score_results:
+            overall_score = score_results['overall_score']
+            
+            # Create a visual score indicator
+            score_color = "#4CAF50" if overall_score >= 4 else "#FF9800" if overall_score >= 3 else "#F44336"
+            
+            st.markdown(f"""
+            <div style="background-color: #F3F4F6; padding: 1.5rem; border-radius: 10px; margin: 1rem 0; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+                <h3 style="color: #3949AB; margin-top: 0;">Overall Performance</h3>
+                <div style="display: flex; align-items: center; margin-bottom: 1rem;">
+                    <div style="background-color: {score_color}; color: white; font-size: 2rem; font-weight: bold; width: 80px; height: 80px; border-radius: 50%; display: flex; align-items: center; justify-content: center; margin-right: 1.5rem;">
+                        {overall_score}/5
+                    </div>
+                    <div>
+                        <p style="font-size: 1.1rem; margin: 0; color: #333;">{score_results['overall_feedback']}</p>
+                    </div>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # Display score table
+        if "individual_scores" in score_results:
+            st.markdown("<h3 class='section-header'>📈 Score Summary</h3>", unsafe_allow_html=True)
+            
+            # Extract data for the table
+            questions = []
+            scores = []
+            
+            for i, score_item in enumerate(score_results["individual_scores"]):
+                # Truncate long questions for better display
+                question_text = score_item['question']
+                if len(question_text) > 80:
+                    question_text = question_text[:77] + "..."
+                
+                questions.append(f"Q{i+1}: {question_text}")
+                scores.append(score_item['score'])
+            
+            # Calculate average score
+            if scores:
+                avg_score = sum(scores) / len(scores)
+                questions.append("**Average Score**")
+                scores.append(f"**{avg_score:.2f}**")
+            
+            # Create DataFrame
+            df = pd.DataFrame({
+                "Question": questions,
+                "Score (out of 5)": scores
+            })
+            
+            # Convert DataFrame to HTML and display it
+            table_html = df.to_html(classes='score-table', escape=False, index=False)
+            st.markdown(f"""
+            <div style="overflow-x: auto;">
+                {table_html}
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # Display individual scores with ideal answers
+        if "individual_scores" in score_results:
+            st.markdown("<h3 class='section-header'>📝 Detailed Feedback</h3>", unsafe_allow_html=True)
+            
+            st.markdown("""
+            <p style="margin-bottom: 1rem;">Click on each question below to see detailed feedback and ideal answers.</p>
+            """, unsafe_allow_html=True)
+            
+            for i, score_item in enumerate(score_results["individual_scores"]):
+                # Determine score color
+                score_value = score_item['score']
+                score_color = "#4CAF50" if score_value >= 4 else "#FF9800" if score_value >= 3 else "#F44336"
+                
+                with st.expander(f"Question {i+1}: {score_item['question']}"):
+                    st.markdown(f"""
+                    <div style="display: flex; align-items: center; margin-bottom: 1rem;">
+                        <div style="background-color: {score_color}; color: white; font-size: 1.2rem; font-weight: bold; width: 50px; height: 50px; border-radius: 50%; display: flex; align-items: center; justify-content: center; margin-right: 1rem;">
+                            {score_value}/5
+                        </div>
+                        <div>
+                            <p style="font-size: 1.1rem; margin: 0; color: #333; font-weight: 500;">{score_item['feedback']}</p>
+                        </div>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    st.markdown("<h4 class='user-answer-header'>🧑‍💼 Your Answer:</h4>", unsafe_allow_html=True)
+                    st.markdown(f"{score_item['answer']}")
+                    
+                    # Only show ideal answers if they were generated
+                    if st.session_state.generate_ideal_answers:
+                        st.markdown("<h4 class='ideal-answer-header'>💡 Ideal Answer:</h4>", unsafe_allow_html=True)
+                        if "ideal_answer" in score_item:
+                            st.markdown(f"{score_item['ideal_answer']}")
+                        else:
+                            st.markdown("No ideal answer available.")
+    
+    # Display a welcome message if interview hasn't started
+    elif not st.session_state.interview_started:
+        st.markdown("<h2 class='section-header'>👋 Welcome to Virtual Interviewer</h2>", unsafe_allow_html=True)
+        st.markdown("""
+        <div style="background-color: #E8EAF6; padding: 1.5rem; border-radius: 10px; margin-top: 1rem;">
+            <h3 style="color: #3949AB; font-size: 1.3rem; margin-bottom: 1rem;">This tool will help you practice for your upcoming interviews by:</h3>
+            <ol style="color: #303F9F; font-size: 1.1rem;">
+                <li>Generating relevant interview questions based on a job description</li>
+                <li>Simulating a real interview experience</li>
+                <li>Providing feedback on your answers</li>
+            </ol>
+            <p style="color: #3949AB; font-size: 1.1rem; margin-top: 1rem;">To get started, fill out the interview setup form on the left and click "Start Interview".</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+# Bottom section for control buttons
+if st.session_state.interview_started and not st.session_state.interview_completed:
+    st.markdown("<hr style='margin: 2rem 0 1rem 0;'>", unsafe_allow_html=True)
+    
+    # Create a container for the buttons at the bottom
+    button_container = st.container()
+    
+    with button_container:
+        col1, col2, col3 = st.columns([1, 1, 1])
+        
+        with col1:
+            pass  # Empty column for spacing
+        
+        with col2:
+            next_button_disabled = not st.session_state.answer_submitted
+            if st.button("⏭️ Next Question", disabled=next_button_disabled, use_container_width=True):
+                # Store the current question and answer
+                if st.session_state.current_answer:  # Use current_answer instead of user_answer
+                    # Add to conversation history
+                    st.session_state.conversation_history.append(st.session_state.current_question)
+                    st.session_state.conversation_history.append(st.session_state.current_answer)
+                    
+                    # Store in the interviewer object
+                    st.session_state.interviewer.store_user_answer(
+                        st.session_state.current_question,
+                        st.session_state.current_answer
+                    )
+                    
+                    # Move to the next question
+                    st.session_state.current_question_index += 1
+                    
+                    # Check if we've reached the end of the questions
+                    if st.session_state.current_question_index >= len(st.session_state.interviewer.questions_asked):
+                        st.session_state.interview_completed = True
+                        
+                        # Automatically score the interview if scoring is enabled
+                        if st.session_state.enable_scoring:
+                            with st.spinner("Scoring your interview..."):
+                                try:
+                                    # Score the interview
+                                    score_results = st.session_state.interviewer.score_interview(
+                                        job_description=st.session_state.job_description,
+                                        interview_type=st.session_state.interview_type,
+                                        difficulty_level=st.session_state.difficulty_level
+                                    )
+                                    
+                                    st.session_state.score_results = score_results
+                                    st.session_state.interview_scored = True
+                                except Exception as e:
+                                    st.error(f"⚠️ Error scoring the interview: {str(e)}")
+                        
+                        st.rerun()
+                    else:
+                        # Get the next question
+                        next_question = st.session_state.interviewer.get_next_question(
+                            st.session_state.current_question_index
+                        )
+                        st.session_state.current_question = next_question
+                        
+                        # Reset submission status and current answer
+                        reset_answer_input()
+                        
+                        # Set flag to play audio for the new question
+                        st.session_state.should_play_audio = True
+                        st.session_state.audio_key = str(uuid.uuid4())
+                        
+                        st.rerun()
+                else:
+                    st.warning("⚠️ Please provide an answer before moving to the next question.")
+        
+        with col3:
+            if st.session_state.enable_scoring:
+                if st.button("📊 Score Interview", use_container_width=True, key="score_button"):
+                    if len(st.session_state.interviewer.user_answers) > 0:
+                        with st.spinner("Scoring your interview..."):
+                            try:
+                                # Score the interview
+                                score_results = st.session_state.interviewer.score_interview(
+                                    job_description=st.session_state.job_description,
+                                    interview_type=st.session_state.interview_type,
+                                    difficulty_level=st.session_state.difficulty_level
+                                )
+                                
+                                st.session_state.score_results = score_results
+                                st.session_state.interview_scored = True
+                                st.session_state.interview_completed = True
+                                st.rerun()
+                            except Exception as e:
+                                st.error(f"⚠️ Error scoring the interview: {str(e)}")
+                    else:
+                        st.warning("⚠️ Please answer at least one question before scoring.")
+
+# Footer
+st.markdown("<hr style='margin: 2rem 0 1rem 0;'>", unsafe_allow_html=True)
+st.markdown("<p class='footer'>🎯 Powered by OpenAI GPT-4o | Created with Streamlit</p>", unsafe_allow_html=True)

backend.py

@@ -0,0 +1,425 @@
+import openai
+import json
+import requests
+import base64
+import os
+import tempfile
+import asyncio
+import edge_tts
+import time
+import hashlib
+import shutil
+from typing import List, Dict, Any, Optional
+
+class VirtualInterviewer:
+    def __init__(self, api_key: str):
+        """Initialize the virtual interviewer with the OpenAI API key."""
+        self.api_key = api_key
+        self.questions_asked = []
+        self.user_answers = []
+        self.conversation_history = []
+        self.ideal_answers = {}
+        self.question_audio_paths = {}
+        
+        # Create audio directory
+        self.audio_dir = self._create_audio_directory()
+        
+        # Clean up any existing audio files
+        self._cleanup_audio_files()
+        
+        # Initialize OpenAI client
+        try:
+            self.client = openai.OpenAI(api_key=api_key)
+        except Exception as e:
+            raise Exception(f"Failed to initialize OpenAI client: {str(e)}")
+    
+    def _create_audio_directory(self) -> str:
+        """Create a directory to store audio files."""
+        audio_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "audio_files")
+        os.makedirs(audio_dir, exist_ok=True)
+        return audio_dir
+    
+    def _cleanup_audio_files(self):
+        """Delete all temporary audio files from previous sessions."""
+        try:
+            if os.path.exists(self.audio_dir):
+                # Delete all files in the directory
+                for filename in os.listdir(self.audio_dir):
+                    file_path = os.path.join(self.audio_dir, filename)
+                    if os.path.isfile(file_path):
+                        os.remove(file_path)
+                print(f"Cleaned up audio files in {self.audio_dir}")
+        except Exception as e:
+            print(f"Error cleaning up audio files: {str(e)}")
+    
+    def generate_interview_questions(
+        self,
+        job_description: str,
+        interview_type: str,
+        difficulty_level: str,
+        key_topics: str,
+        num_questions: int,
+        generate_ideal_answers: bool = True
+    ) -> List[str]:
+        """Generate interview questions based on the job description and other parameters."""
+        try:
+            # Construct the system prompt based on whether we want ideal answers or not
+            if generate_ideal_answers:
+                system_prompt = f"""You are an expert interviewer for {interview_type} interviews.
+                Generate {num_questions} {difficulty_level.lower()} difficulty interview questions for a {interview_type.lower()} interview based on the following job description:
+                
+                Job Description:
+                {job_description}
+                
+                Key Topics to Focus on:
+                {key_topics if key_topics else "No specific topics provided."}
+                
+                Please provide the questions and ideal answers in the following JSON format:
+                {{
+                    "questions": [
+                        {{
+                            "question": "Question 1",
+                            "ideal_answer": "Ideal answer for question 1"
+                        }},
+                        ...
+                    ]
+                }}
+                
+                Make sure the questions are challenging but appropriate for the {difficulty_level.lower()} difficulty level.
+                The ideal answers should be comprehensive and demonstrate expertise in the subject matter.
+                """
+            else:
+                system_prompt = f"""You are an expert interviewer for {interview_type} interviews.
+                Generate {num_questions} {difficulty_level.lower()} difficulty interview questions for a {interview_type.lower()} interview based on the following job description:
+                
+                Job Description:
+                {job_description}
+                
+                Key Topics to Focus on:
+                {key_topics if key_topics else "No specific topics provided."}
+                
+                Please provide the questions in a numbered list format.
+                Make sure the questions are challenging but appropriate for the {difficulty_level.lower()} difficulty level.
+                """
+            
+            # Make the API call to generate questions
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Generate {num_questions} {interview_type.lower()} interview questions for a {difficulty_level.lower()} difficulty level."}
+                ],
+                temperature=0.7,
+                max_tokens=2000
+            )
+            
+            # Extract the response content
+            response_content = response.choices[0].message.content
+            
+            # Process the response based on whether we're expecting JSON or a simple list
+            if generate_ideal_answers:
+                try:
+                    # Try to parse as JSON
+                    json_response = self._extract_json(response_content)
+                    
+                    # Extract questions and ideal answers
+                    questions = []
+                    for item in json_response.get("questions", []):
+                        question = item.get("question", "")
+                        ideal_answer = item.get("ideal_answer", "")
+                        
+                        if question:
+                            questions.append(question)
+                            if ideal_answer:
+                                self.ideal_answers[question] = ideal_answer
+                    
+                    # If we couldn't extract questions from JSON, fall back to parsing as text
+                    if not questions:
+                        questions = self._parse_questions(response_content, num_questions)
+                        # Generate ideal answers separately
+                        self._generate_ideal_answers(questions, job_description, interview_type, difficulty_level)
+                except Exception as e:
+                    # If JSON parsing fails, fall back to text parsing
+                    questions = self._parse_questions(response_content, num_questions)
+                    # Generate ideal answers separately
+                    self._generate_ideal_answers(questions, job_description, interview_type, difficulty_level)
+            else:
+                # Parse as simple text
+                questions = self._parse_questions(response_content, num_questions)
+            
+            # Store the generated questions
+            self.questions_asked = questions
+            
+            return questions
+        except Exception as e:
+            raise Exception(f"Failed to generate interview questions: {str(e)}")
+    
+    def generate_question_audio(self, question: str, voice_type: str) -> str:
+        """Generate audio for a question using edge-tts."""
+        try:
+            # Check if we already have audio for this question
+            if question in self.question_audio_paths and os.path.exists(self.question_audio_paths[question]):
+                print(f"Using existing audio for question: {question[:30]}...")
+                return self.question_audio_paths[question]
+            
+            # Create a unique filename based on the question content and timestamp
+            question_hash = hashlib.md5(question.encode()).hexdigest()
+            timestamp = int(time.time())
+            filename = f"question_{question_hash}_{timestamp}.mp3"
+            output_path = os.path.join(self.audio_dir, filename)
+            
+            # Map voice type to edge-tts voice
+            voice_mapping = {
+                "male_casual": "en-US-GuyNeural",
+                "male_formal": "en-US-ChristopherNeural",
+                "male_british": "en-GB-RyanNeural",
+                "female_casual": "en-US-JennyNeural",
+                "female_formal": "en-US-AriaNeural",
+                "female_british": "en-GB-SoniaNeural"
+            }
+            
+            # Get the voice name from the mapping, default to female casual
+            voice = voice_mapping.get(voice_type, "en-US-JennyNeural")
+            
+            # Generate audio using edge-tts
+            async def generate_audio():
+                communicate = edge_tts.Communicate(question, voice)
+                await communicate.save(output_path)
+            
+            # Run the async function
+            asyncio.run(generate_audio())
+            
+            print(f"Generated audio for question: {question[:30]}... at {output_path}")
+            
+            # Store the audio path for this question
+            self.question_audio_paths[question] = output_path
+            
+            return output_path
+        except Exception as e:
+            print(f"Error generating audio: {str(e)}")
+            return ""
+    
+    def get_question_audio_path(self, question: str) -> str:
+        """Get the audio path for a question."""
+        # Check if we have an audio path for this question
+        if question in self.question_audio_paths:
+            # Verify the file exists
+            if os.path.exists(self.question_audio_paths[question]):
+                return self.question_audio_paths[question]
+            else:
+                # File doesn't exist, remove from dictionary
+                del self.question_audio_paths[question]
+                return ""
+        return ""
+    
+    def _extract_json(self, text: str) -> Dict[str, Any]:
+        """Extract JSON from text."""
+        try:
+            # Try to parse the entire text as JSON
+            return json.loads(text)
+        except json.JSONDecodeError:
+            # If that fails, try to extract JSON from the text
+            import re
+            json_match = re.search(r'```json\n(.*?)\n```', text, re.DOTALL)
+            if json_match:
+                try:
+                    return json.loads(json_match.group(1))
+                except json.JSONDecodeError:
+                    pass
+            
+            # Try to find JSON between curly braces
+            json_match = re.search(r'({.*})', text, re.DOTALL)
+            if json_match:
+                try:
+                    return json.loads(json_match.group(1))
+                except json.JSONDecodeError:
+                    pass
+            
+            # If all else fails, return an empty dict
+            return {}
+    
+    def _generate_ideal_answers(self, questions: List[str], job_description: str, interview_type: str, difficulty_level: str):
+        """Generate ideal answers for the questions."""
+        try:
+            # Prepare the prompt for generating ideal answers
+            prompt = f"""You are an expert in {interview_type} interviews.
+            For each of the following interview questions, provide an ideal answer that would impress the interviewer.
+            The answers should be comprehensive, demonstrate expertise, and be appropriate for a {difficulty_level.lower()} difficulty level interview.
+            
+            Job Description:
+            {job_description}
+            
+            Questions:
+            {json.dumps(questions)}
+            
+            Please provide the answers in the following JSON format:
+            {{
+                "answers": [
+                    {{
+                        "question": "Question 1",
+                        "ideal_answer": "Ideal answer for question 1"
+                    }},
+                    ...
+                ]
+            }}
+            """
+            
+            # Make the API call to generate ideal answers
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": "You are an expert interviewer providing ideal answers to interview questions."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.7,
+                max_tokens=2000
+            )
+            
+            # Extract the response content
+            response_content = response.choices[0].message.content
+            
+            try:
+                # Try to parse as JSON
+                json_response = self._extract_json(response_content)
+                
+                # Extract ideal answers
+                for item in json_response.get("answers", []):
+                    question = item.get("question", "")
+                    ideal_answer = item.get("ideal_answer", "")
+                    
+                    if question and ideal_answer:
+                        # Find the matching question in our list
+                        for q in questions:
+                            if question.lower() in q.lower() or q.lower() in question.lower():
+                                self.ideal_answers[q] = ideal_answer
+                                break
+            except Exception as e:
+                # If batch processing fails, fall back to individual processing
+                for question in questions:
+                    if question not in self.ideal_answers:
+                        self.ideal_answers[question] = f"Unable to generate ideal answer: {str(e)}"
+        except Exception as e:
+            # Handle any errors in the overall ideal answer generation process
+            print(f"Error generating ideal answers: {str(e)}")
+            # Ensure all questions have a fallback ideal answer
+            for question in questions:
+                if question not in self.ideal_answers:
+                    self.ideal_answers[question] = "Unable to generate ideal answer due to an error."
+    
+    def _parse_questions(self, questions_text: str, expected_count: int) -> List[str]:
+        """Parse the questions from the text response."""
+        lines = questions_text.strip().split('\n')
+        questions = []
+        
+        for line in lines:
+            line = line.strip()
+            if line and (line[0].isdigit() or line.startswith('- ')):
+                # Remove numbering or bullet points
+                cleaned_line = line.lstrip('0123456789.- ').strip()
+                if cleaned_line:
+                    questions.append(cleaned_line)
+        
+        # If we couldn't parse the expected number of questions, try a simpler approach
+        if len(questions) != expected_count:
+            questions = [line.strip() for line in lines if line.strip()][:expected_count]
+            
+        return questions[:expected_count]  # Ensure we return exactly the expected number
+    
+    def get_next_question(self, question_index: int) -> str:
+        """Get the next question from the list of generated questions."""
+        if 0 <= question_index < len(self.questions_asked):
+            return self.questions_asked[question_index]
+        return "No more questions available."
+    
+    def store_user_answer(self, question: str, answer: str):
+        """Store the user's answer to a question."""
+        self.user_answers.append({"question": question, "answer": answer})
+        self.conversation_history.append({"role": "assistant", "content": question})
+        self.conversation_history.append({"role": "user", "content": answer})
+    
+    def get_ideal_answer(self, question: str) -> str:
+        """Get the ideal answer for a question."""
+        return self.ideal_answers.get(question, "No ideal answer available for this question.")
+    
+    def score_interview(self, job_description: str, interview_type: str, difficulty_level: str) -> Dict[str, Any]:
+        """Score the interview based on the user's answers."""
+        try:
+            # Prepare the data for scoring
+            questions_and_answers = []
+            for qa in self.user_answers:
+                question = qa["question"]
+                answer = qa["answer"]
+                ideal_answer = self.get_ideal_answer(question)
+                
+                questions_and_answers.append({
+                    "question": question,
+                    "answer": answer,
+                    "ideal_answer": ideal_answer
+                })
+            
+            # Prepare the prompt for scoring
+            prompt = f"""You are an expert interviewer for {interview_type} interviews.
+            Score the following interview answers based on the job description and difficulty level.
+            
+            Job Description:
+            {job_description}
+            
+            Difficulty Level: {difficulty_level}
+            
+            For each question and answer, provide:
+            1. A score from 0 to 5 (where 5 is excellent)
+            2. Feedback on the answer
+            3. Include the ideal answer for comparison. The ideal answer should be a comprehensive and detailed answer that would impress the interviewer with bullet points.
+            
+            Questions and Answers:
+            {json.dumps(questions_and_answers)}
+            
+            Please provide the scores in the following JSON format:
+            {{
+                "overall_score": 4.5,
+                "overall_feedback": "Overall feedback on the interview performance",
+                "individual_scores": [
+                    {{
+                        "question": "Question 1",
+                        "answer": "User's answer to question 1",
+                        "ideal_answer": "Ideal answer to question 1",
+                        "score": 4,
+                        "feedback": "Feedback on the answer to question 1"
+                    }},
+                    ...
+                ]
+            }}
+            """
+            
+            # Make the API call to score the interview
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": "You are an expert interviewer scoring interview answers."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.3,
+                max_tokens=2000
+            )
+            
+            # Extract the response content
+            response_content = response.choices[0].message.content
+            
+            try:
+                # Try to parse as JSON
+                json_response = self._extract_json(response_content)
+                return json_response
+            except Exception as e:
+                # If JSON parsing fails, return an error
+                return {
+                    "overall_score": 0,
+                    "overall_feedback": f"Failed to score the interview: {str(e)}",
+                    "individual_scores": []
+                }
+        except Exception as e:
+            # If scoring fails, return an error
+            return {
+                "overall_score": 0,
+                "overall_feedback": f"Failed to score the interview: {str(e)}",
+                "individual_scores": []
+            }

requirements.txt

@@ -0,0 +1,5 @@
+streamlit==1.32.0
+openai==1.12.0
+python-dotenv==1.0.0
+requests==2.31.0
+edge-tts==6.1.9