Upload 5 files

app.py

@@ -0,0 +1,18 @@
+import streamlit as st
+import bio
+import round1
+import display
+
+# Define pages here
+PAGES = {
+    "Candidate Bio": bio,
+    "Interview Round 1": round1,
+    "Display": display,
+    # Add more pages as needed
+}
+
+st.sidebar.title('Main Menu')
+selection = st.sidebar.radio("Go to", list(PAGES.keys()))
+
+page = PAGES[selection]
+page.app()

bio.py

@@ -0,0 +1,84 @@
+import shelve
+import streamlit as st
+import re  # For regex operations
+
+def validate_email(email):
+    """Validate the email format."""
+    pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+    return re.match(pattern, email) is not None
+
+def validate_mobile(mobile_number):
+    """Validate the mobile number format (Indian mobile numbers)."""
+    pattern = r"^[6-9]\d{9}$"
+    return re.match(pattern, mobile_number) is not None
+
+def analyze_text(text):
+    """Placeholder function for analyzing text to extract key points. In practice, use NLP techniques."""
+    # For demonstration, simply split the text and pick a few items.
+    words = text.split()
+    return ", ".join(words[:5]) + "..." if len(words) > 5 else ", ".join(words)
+
+def app():
+    st.title("Candidate Bio and Interview Details Form")
+
+    # Candidate Bio Section
+    st.header("Candidate Bio")
+    name = st.text_input("Name")
+    email = st.text_input("Email")
+    mobile_number = st.text_input("Mobile Number")
+    years_of_experience = st.number_input("Years of Experience", min_value=0, format="%d")
+    past_companies = st.text_area("Past Companies Worked At (separate by commas)")
+    past_roles = st.text_area("Past Roles and Responsibilities")
+
+    # Interview Details Section
+    st.header("Interview Details")
+    company_name = st.text_input("Company Name")
+    interviewing_department = st.text_input("Interviewing Department")
+    role_applied_for = st.text_input("Role Applied For")
+    job_description = st.text_area("Job Description")
+    interview_type = st.selectbox("Type of Interview", ["Technical", "HR", "Case Study", "Other"])
+    focus_areas = st.text_area("Key Areas for Preparation")
+
+    if st.button("Submit"):
+        # Validation
+        if not validate_email(email):
+            st.error("Please enter a valid email address.")
+            return
+        if not validate_mobile(mobile_number):
+            st.error("Please enter a valid mobile number.")
+            return
+        
+        with shelve.open("datastore") as db:
+            db["candidate_bio"] = {
+                "name": name,
+                "email": email,
+                "mobile_number": mobile_number,
+                "years_of_experience": years_of_experience,
+                "past_companies": past_companies,
+                "past_roles": past_roles,
+                "company_name": company_name,
+                "interviewing_department": interviewing_department,
+                "role_applied_for": role_applied_for,
+                "job_description": job_description,
+                "interview_type": interview_type,
+                "focus_areas": focus_areas
+            }
+
+
+        st.success("Form Submitted Successfully!")
+        st.write("## Summary")
+        st.write(f"Name: {name}")
+        st.write(f"Email: {email}")
+        st.write(f"Mobile Number: {mobile_number}")
+        st.write(f"Years of Experience: {years_of_experience}")
+        st.write(f"Past Companies: {past_companies}")
+        st.write(f"Past Roles: {analyze_text(past_roles)}")
+        st.write(f"Company Name: {company_name}")
+        st.write(f"Interviewing Department: {interviewing_department}")
+        st.write(f"Role Applied For: {role_applied_for}")
+        st.write(f"Job Description: {analyze_text(job_description)}")
+        st.write(f"Type of Interview: {interview_type}")
+        st.write(f"Key Areas for Preparation: {focus_areas}")
+
+if __name__ == "__main__":
+    app()

display.py

@@ -0,0 +1,19 @@
+import streamlit as st
+import shelve
+
+def app():
+    st.title("Display Candidate Bio and Interview Details")
+
+    # Use shelve to read saved data
+    with shelve.open("datastore") as db:
+        candidate_bio = db.get("candidate_bio", {})  # Default to empty dict if not found
+
+    if candidate_bio:
+        st.write("## Candidate Bio and Interview Details")
+        for key, value in candidate_bio.items():
+            st.text(f"{key.replace('_', ' ').capitalize()}: {value}")
+    else:
+        st.error("No data found. Please ensure the bio form has been submitted.")
+
+if __name__ == "__main__":
+    app()

evaluate.py

@@ -0,0 +1,63 @@
+import pandas as pd
+import google.generativeai as genai
+import os
+
+# Load responses from a file
+def load_responses(filename="interview_responses_round_1.csv"):
+    try:
+        return pd.read_csv(filename)
+    except FileNotFoundError:
+        print("Response file not found. Please ensure that 'round1.py' has been run and responses have been saved.")
+        exit()
+
+# Configure and initialize Gemini
+def configure_gemini():
+    api_key = os.getenv("GOOGLE_GENERATIVE_AI_API_KEY")
+    if not api_key:
+        print("Google Generative AI API key not set. Please set your API key as an environment variable.")
+        exit()
+
+    genai.configure(api_key=api_key)
+
+    generation_config = {
+        "temperature": 0.9,
+        "top_p": 1,
+        "top_k": 50,
+        "max_output_tokens": 512,
+    }
+
+    safety_settings = [
+        {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    ]
+
+    return genai.GenerativeModel(model_name="gemini-1.0-pro",
+                                 generation_config=generation_config,
+                                 safety_settings=safety_settings)
+
+def evaluate_responses(model, responses):
+    evaluations = []
+    for index, row in responses.iterrows():
+        try:
+            response = model.generate_content([row['response']])
+            evaluations.append(response.text)
+        except Exception as e:
+            print(f"An error occurred while evaluating response {index+1}: {e}")
+            evaluations.append("Error during evaluation.")
+
+    return evaluations
+
+def print_evaluations(responses, evaluations):
+    for index, (response, evaluation) in enumerate(zip(responses['response'], evaluations), start=1):
+        print(f"Response {index}: {response}")
+        print(f"Evaluation: {evaluation}")
+        print("----------")
+
+if __name__ == "__main__":
+    responses = load_responses()
+    if not responses.empty:
+        model = configure_gemini()
+        evaluations = evaluate_responses(model, responses)
+        print_evaluations(responses, evaluations)

round1.py

@@ -0,0 +1,125 @@
+import json
+import streamlit as st
+import shelve
+# Import Google's Generative AI package
+import google.generativeai as genai
+
+# Configure the Gemini API with your API key
+genai.configure(api_key="AIzaSyCA4__JMC_ZIQ9xQegIj5LOMLhSSrn3pMw")
+
+def generate_questions(company_name, role_applied_for, job_description, interview_type, focus_areas):
+    """
+    Generates custom interview questions based on the provided details,
+    explicitly asking for the output in a list format.
+    """
+    generation_config = {
+        "temperature": 0.9,
+        "top_p": 1,
+        "top_k": 1,
+        "max_output_tokens": 2048,
+    }
+
+    safety_settings = [
+        {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    ]
+
+    model = genai.GenerativeModel(model_name="gemini-1.0-pro",
+                                  generation_config=generation_config,
+                                  safety_settings=safety_settings)
+    
+    # Adjust the prompt to explicitly request a list of questions
+    prompt_parts = [
+        f"Based on the following details, generate a list of interview questions:",
+        f"Company Name: {company_name}",
+        f"Role Applied For: {role_applied_for}",
+        f"Job Description: {job_description}",
+        f"Interview Type: {interview_type}",
+        f"Focus Areas: {focus_areas}",
+        "Format the questions as a bulleted list."
+    ]
+    
+    # Joining the prompt parts to form the complete prompt
+    complete_prompt = "\n".join(prompt_parts)
+    
+    # Call Gemini to generate content
+    response = model.generate_content(complete_prompt)
+    return response.text
+
+
+
+
+def parse_response_text(response_text):
+    """
+    Manually parse the structured response text into a dictionary.
+    This function assumes a very specific format and might need adjustments
+    based on actual response variations.
+    """
+    questions_dict = {}
+    current_section = ""
+    for line in response_text.split("\n"):
+        if line.strip().endswith(": {"):
+            # This is a section header
+            current_section = line.split(":")[0].strip()
+            questions_dict[current_section] = {}
+        elif line.strip().startswith('"Question'):
+            # This is a question within the current section
+            question_number, question_text = line.strip().split(":")
+            question_text = question_text.strip().strip('"').strip(",")
+            questions_dict[current_section][question_number.strip('"')] = question_text
+    return questions_dict
+
+
+def app():
+    st.title("Interview Round 1 Preparation")
+
+    # Load saved data from bio.py
+    with shelve.open("datastore") as db:
+        candidate_bio = db.get("candidate_bio", {})  
+
+    if candidate_bio:
+        # Displaying loaded information for verification
+        st.write("## Loaded Information for Interview Preparation")
+        # Extract necessary details
+        company_name = candidate_bio.get("company_name", "Not specified")
+        interviewing_department = candidate_bio.get("interviewing_department", "Not specified")
+        role_applied_for = candidate_bio.get("role_applied_for", "Not specified")
+        job_description = candidate_bio.get("job_description", "Not specified")
+        interview_type = candidate_bio.get("interview_type", "Not specified")
+        focus_areas = candidate_bio.get("focus_areas", "Not specified")
+
+        # Display the loaded information
+        st.write(f"**Company Name:** {company_name}")
+        st.write(f"**Interviewing Department:** {interviewing_department}")
+        st.write(f"**Role Applied For:** {role_applied_for}")
+        st.write(f"**Job Description:** {job_description}")
+        st.write(f"**Type of Interview:** {interview_type}")
+        st.write(f"**Focus Areas for Preparation:** {focus_areas}")
+
+        # Generate and display questions
+        if st.button("Generate Interview Questions"):
+            questions_text = generate_questions(company_name, role_applied_for, job_description, interview_type, focus_areas)
+            questions_list = questions_text.split('\n')  # Splitting the generated text into a list of questions
+            
+            # Initialize a place to store responses
+            responses = {}
+            for i, question in enumerate(questions_list, start=1):
+                st.write(f"**Question {i}:** {question}")
+                # Capture the user's response
+                response = st.text_input(f"Your answer to Question {i}", key=f"response_{i}")
+                responses[f"Question {i}"] = response
+            
+            # Optional: Display captured responses
+            if st.button("Submit Responses"):
+                st.write("## Your Responses")
+                for question, response in responses.items():
+                    st.write(f"{question}: {response}")
+
+         
+
+
+
+if __name__ == "__main__":
+    app()