Upload 2 files

requirements.txt

@@ -0,0 +1,4 @@
+gTTS==2.3.2
+openai==0.28.0
+pygame==2.5.1
+SpeechRecognition==3.10.0

streamlit.py

@@ -0,0 +1,217 @@
+import openai
+from gtts import gTTS
+import speech_recognition as sr
+import streamlit as st
+import random
+import time
+import pygame
+import io
+
+# Set up your OpenAI API key
+openai.api_key = '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'
+
+# Function to get technical keywords using OpenAI
+def get_technical_keywords(job_description, skills):
+    conversation = [
+        {"role": "system", "content": "You are a helpful assistant that extracts technical keywords."},
+        {"role": "user", "content": f"Extract technical keywords from job description: {job_description}\nSkills: {skills}"}
+    ]
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo-0613",
+        messages=conversation
+    )
+
+    extracted_keywords = response.choices[0].message.content.strip()
+    return extracted_keywords
+
+# Function to format and display keywords
+def display_keywords(keywords):
+    st.subheader("Extracted Keywords:")
+    st.write(keywords)
+
+# Function to generate a single technical question based on a keyword and job role
+def generate_question(keyword, job_role):
+    conversation = [
+        {"role": "system", "content": "You are a helpful assistant that generates technical questions."},
+        {"role": "user", "content": f"Generate a technical question for the job role of {job_role} based on the keyword: {keyword}"}
+    ]
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo-16k-0613",
+        messages=conversation,
+        max_tokens=1000  # Adjust the token limit as needed
+    )
+
+    generated_question = response.choices[0].message.content.strip()
+    return generated_question
+
+# Function to format and display feedback
+def display_feedback(feedback):
+    st.subheader("Feedback:")
+    st.write(feedback)
+
+# Function to generate a follow-up question based on the user's answer using ChatGPT
+def get_follow_up_question(user_answer):
+    conversation = [
+        {"role": "system", "content": "You are a helpful assistant that generates follow-up questions."},
+        {"role": "user", "content": f"Generate a follow-up question based on the user's answer: {user_answer}"}
+    ]
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo-0613",
+        messages=conversation,
+        max_tokens=1000  # Adjust the token limit as needed
+    )
+
+    follow_up_question = response.choices[0].message.content.strip()
+    return follow_up_question
+
+# Modify the ask_question function to save the audio in memory
+def ask_question(question):
+    mp3_data = io.BytesIO()  # Create an in-memory stream
+    tts = gTTS(text=question, lang='en')
+    tts.write_to_fp(mp3_data)
+    mp3_data.seek(0)  # Rewind the stream to the beginning
+
+    pygame.mixer.init()
+    pygame.mixer.music.load(mp3_data)
+    pygame.mixer.music.play()
+
+    # Wait for the audio to finish playing
+    while pygame.mixer.music.get_busy():
+        pygame.time.Clock().tick(10)  # Adjust the tick rate as needed
+
+# Function to get user's answer via speech-to-text
+def get_user_answer():
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        st.text("Please answer the question:")
+        audio = recognizer.listen(source, timeout=None)  # No timeout, wait until user finishes speaking
+        try:
+            answer = recognizer.recognize_google(audio, show_all=True)
+            if 'alternative' in answer:
+                answer = answer['alternative'][0]['transcript']
+            return answer
+        except Exception as e:
+            st.error(f"Error: {str(e)}")
+            return None
+
+# Function to get feedback on the user's answer
+def get_feedback(user_answer):
+    conversation = [
+        {"role": "system", "content": "You are a helpful assistant that provides feedback on user answers."},
+        {"role": "user", "content": f"Provide feedback on the user's answer based on clarity, confidence, content, effectiveness, quantification, and usage of STAR framework: {user_answer}"}
+    ]
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo-0613",
+        messages=conversation,
+        max_tokens=1000  # Adjust the token limit as needed
+    )
+
+    feedback = response.choices[0].message.content.strip()
+    return feedback
+
+# Function to evaluate whether the answer is technically correct using ChatGPT
+def evaluate_answer(answer):
+    conversation = [
+        {"role": "system", "content": "You are a helpful assistant that evaluates the technical correctness of the answer."},
+        {"role": "user", "content": f"Evaluate whether the following answer is technically correct: {answer}"}
+    ]
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo-0613",
+        messages=conversation,
+        max_tokens=1000  # Adjust the token limit as needed
+    )
+
+    evaluation_result = response.choices[0].message.content.strip()
+    return evaluation_result
+
+# Function to conduct the interview in an infinite loop
+def conduct_interview_loop(keywords_list, job_role):
+    while True:
+        random.shuffle(keywords_list)  # Shuffle the keywords
+
+        for keyword in keywords_list:
+            # Generate a question for the keyword and job role
+            question = generate_question(keyword, job_role)
+
+            # Display the question in the GUI
+            st.subheader("Question:")
+            st.write(question)
+
+            # Ask the question via audio with medium speed
+            ask_question(question)
+
+            # Get the user's answer
+            user_answer = get_user_answer()
+            if user_answer is not None:
+                # Display the user's answer in the GUI
+                st.subheader("User's Answer:")
+                st.write(user_answer)
+
+                # Provide feedback on the user's answer
+                feedback = get_feedback(user_answer)
+
+                # Display the feedback in the GUI
+                display_feedback(feedback)
+
+                # Evaluate whether the answer is technically correct
+                evaluation_result = evaluate_answer(user_answer)
+
+                # Display the evaluation result in the GUI
+                st.subheader("Evaluation Result:")
+                st.write(evaluation_result)
+
+                # Wait for the user to read feedback
+                time.sleep(5)  # Adjust the delay time (in seconds) as needed
+
+                # Process user's answer using OpenAI
+                follow_up_question = get_follow_up_question(user_answer)
+
+                if follow_up_question:
+                    # Display and ask the follow-up question
+                    st.subheader("Follow-up Question:")
+                    st.write(follow_up_question)
+                    ask_question(follow_up_question)
+
+                    # Get the user's answer to the follow-up question
+                    user_follow_up_answer = get_user_answer()
+                    if user_follow_up_answer is not None:
+                        # Display the user's answer in the GUI
+                        st.subheader("User's Follow-up Answer:")
+                        st.write(user_follow_up_answer)
+
+                        # Allow some time for the user to finish their answer (optional)
+                        time.sleep(5)  # Adjust the delay time (in seconds) as needed
+
+# Define Streamlit app
+def main():
+    st.title("Interview Chatbot")
+
+    # Create job description input
+    job_description = st.text_area("Job Description:")
+
+    # Create technical skills input
+    skills = st.text_area("Technical Skills:")
+
+    # Create job role input
+    job_role = st.text_input("Job Role:")
+
+    # Create submit button
+    if st.button("Submit"):
+        # Step 2: Extract technical keywords
+        keywords = get_technical_keywords(job_description, skills)
+
+        # Display extracted technical keywords
+        display_keywords(keywords)
+
+        # Split keywords and conduct the interview
+        keywords_list = keywords.split(", ")
+        conduct_interview_loop(keywords_list, job_role)
+
+# Define Streamlit app
+if __name__ == '__main__':
+    main()