app.py

import json
import gradio as gr
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
import torch
import os
import gradio_client.utils as client_utils
import sys


# ===============================
# Device and Model Setup
# ===============================
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
hf_token = os.environ["HF_TOKEN"]

#Load the model
model_path = "AI-Mock-Interviewer/T5"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForSeq2SeqLM.from_pretrained(model_path)
model.to(device)

model = torch.compile(model)

# ------------------- UPDATED SYSTEM PROMPT -------------------
system_prompt = """
You are conducting a mock technical interview. The candidate's experience level can be entry-level, mid-level, or senior-level. Generate questions and follow-up questions based on the domain and the candidate's experience level. Consider these aspects:
1. The question should be relevant to the domain (e.g., software engineering, machine learning) and appropriate for the candidate's experience level.
2. Ensure each question is unique and does not repeat previously asked questions.
3. Ensure each question covers a different sub-topic within the domain, avoiding redundancy.
4. If no clear follow-up can be derived, generate a fresh, related question from a different aspect of the domain.
Important: Ensure that each question is clear, concise, and allows the candidate to demonstrate their technical and communicative abilities effectively.
"""

# Define sub-topic categories for different domains
subtopic_keywords = {
    "data analysis": [
        "data cleaning", "missing data", "outliers",
        "feature engineering", "EDA", "trend analysis",
        "data visualization"
    ],
    "machine learning": [
        "supervised learning", "unsupervised learning",
        "model evaluation", "bias-variance tradeoff",
        "overfitting", "hyperparameter tuning"
    ],
    "software engineering": [
        "agile methodology", "code optimization",
        "design patterns", "database design",
        "testing strategies"
    ],
}

def identify_subtopic(question, domain):
    """Identify the sub-topic of a question using predefined keywords."""
    domain = domain.lower()
    if domain in subtopic_keywords:
        for subtopic in subtopic_keywords[domain]:
            if subtopic in question.lower():
                return subtopic
    return None

# We'll keep global sets here only if needed as a fallback:
asked_questions = set()
asked_subtopics = set()

def generate_question(prompt, domain, state=None):
    """
    Generates a unique question based on the prompt and domain.
    Uses 'state' to track uniqueness in the conversation session.
    """
    while True:
        full_prompt = system_prompt + "\n" + prompt
        inputs = tokenizer(full_prompt, return_tensors="pt").to(device)
        outputs = model.generate(
            inputs["input_ids"],
            max_new_tokens=50,
            num_return_sequences=1,
            no_repeat_ngram_size=2,
            top_k=30,
            top_p=0.9,
            temperature=0.7,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
        )
        question = tokenizer.decode(outputs[0], skip_special_tokens=True)
        question = question.replace(full_prompt, "").strip()

        # Ensure question ends with a question mark
        if not question.endswith("?"):
            question = question.split("?")[0] + "?"

        # Identify the subtopic
        subtopic = identify_subtopic(question, domain)

        if state is not None:
            # Use session-level sets to ensure uniqueness
            if (question not in state["asked_questions"] and
                (subtopic is None or subtopic not in state["asked_subtopics"])):
                state["asked_questions"].add(question)
                if subtopic:
                    state["asked_subtopics"].add(subtopic)
                return question
        else:
            # Fallback to global sets if no state is provided
            if question not in asked_questions and (subtopic is None or subtopic not in asked_subtopics):
                asked_questions.add(question)
                if subtopic:
                    asked_subtopics.add(subtopic)
                return question

def reset_state(domain, company, level):
    """
    Resets or initializes the session state.
    """
    return {
       "domain": domain,
       "company": company,
       "level": level,
       "asked_questions": set(),
       "asked_subtopics": set(),
       "conversation": []  # List of (speaker, message) tuples
    }

def start_interview(domain, company, level):
    """
    Initializes a new interactive interview session with the first question.
    """
    state = reset_state(domain, company, level)
    prompt = (f"Domain: {domain}. "
              + (f"Company: {company}. " if company else "")
              + f"Candidate experience level: {level}. "
                "Generate the first question:")

    question = generate_question(prompt, domain, state)
    state["conversation"].append(("Interviewer", question))
    return state["conversation"], state

def submit_response(candidate_response, state):
    """
    Accepts the candidate's response, updates conversation, generates the next question.
    Allows quitting the interview by typing 'quit'.
    """
    if candidate_response.strip().lower() == "quit":
        state["conversation"].append(("Candidate", candidate_response))
        state["conversation"].append(("Interviewer", "Interview session has ended. Thank you for participating!"))
        return state["conversation"], state

    state["conversation"].append(("Candidate", candidate_response))
    prompt = (f"Domain: {state['domain']}. "
              f"Candidate's experience level: {state['level']}. "
               "Generate the next interview question:")

    question = generate_question(prompt, state["domain"], state)
    state["conversation"].append(("Interviewer", question))
    return state["conversation"], state

# Build an interactive Gradio interface using Blocks
with gr.Blocks() as demo:
    gr.Markdown("# Interactive Mock Interview")
    with gr.Row():
        domain_input = gr.Textbox(label="Domain", placeholder="e.g. Software Engineering")
        company_input = gr.Textbox(label="Company (Optional)", placeholder="e.g. Google")
        level_input = gr.Dropdown(
            label="Experience Level",
            choices=["Entry-Level", "Mid-Level", "Senior-Level"],
            value="Entry-Level"
        )

    start_button = gr.Button("Start Interview")
    chatbot = gr.Chatbot(label="Interview Conversation", type="messages")

    with gr.Row():
        response_input = gr.Textbox(label="Your Response", placeholder="Type 'quit' to end the interview")
        submit_button = gr.Button("Submit")

    # State to hold session data
    state = gr.State()

    # Start interview
    start_button.click(
        start_interview,
        inputs=[domain_input, company_input, level_input],
        outputs=[chatbot, state]
    )

    # Submit response
    submit_button.click(
        submit_response,
        inputs=[response_input, state],
        outputs=[chatbot, state]
    ).then(
        lambda: "", None, response_input  # Clear input box after submission
    )


demo.launch()