import gradio as gr
from pathlib import Path
from sentence_transformers import CrossEncoder
import numpy as np
from time import perf_counter
from pydantic import BaseModel, Field
from phi.agent import Agent
from phi.model.groq import Groq
import os
import logging
# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# API Key setup
api_key = os.getenv("GROQ_API_KEY")
if not api_key:
gr.Warning("GROQ_API_KEY not found. Set it in 'Repository secrets'.")
logger.error("GROQ_API_KEY not found.")
else:
os.environ["GROQ_API_KEY"] = api_key
# Pydantic Model for Quiz Structure
class QuizItem(BaseModel):
question: str = Field(..., description="The quiz question")
choices: list[str] = Field(..., description="List of 4 multiple-choice options")
correct_answer: str = Field(..., description="The correct choice (e.g., 'C1')")
class QuizOutput(BaseModel):
items: list[QuizItem] = Field(..., description="List of 10 quiz items")
# Initialize Agents
groq_agent = Agent(model=Groq(model="llama3-70b-8192", api_key=api_key), markdown=True)
quiz_generator = Agent(
name="Quiz Generator",
role="Generates structured quiz questions and answers",
instructions=[
"Create 10 questions with 4 choices each based on the provided topic and documents.",
"Use the specified difficulty level (easy, average, hard) to adjust question complexity.",
"Ensure questions are derived only from the provided documents.",
"Return the output in a structured format using the QuizOutput Pydantic model.",
"Each question should have a unique correct answer from the choices (labeled C1, C2, C3, C4)."
],
model=Groq(id="llama3-70b-8192", api_key=api_key),
response_model=QuizOutput,
markdown=True
)
VECTOR_COLUMN_NAME = "vector"
TEXT_COLUMN_NAME = "text"
proj_dir = Path.cwd()
# Calling functions from backend (assuming they exist)
from backend.semantic_search import table, retriever
def generate_quiz_data(question_difficulty, topic, documents_str):
prompt = f"""Generate a quiz with {question_difficulty} difficulty on topic '{topic}' using only the following documents:\n{documents_str}"""
try:
response = quiz_generator.run(prompt)
return response.content
except Exception as e:
logger.error(f"Failed to generate quiz: {e}")
return None
def retrieve_and_generate_quiz(question_difficulty, topic):
gr.Warning('Generating quiz may take 1-2 minutes. Please wait.', duration=60)
top_k_rank = 10
documents = []
document_start = perf_counter()
query_vec = retriever.encode(topic)
documents = [doc[TEXT_COLUMN_NAME] for doc in table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_k_rank).to_list()]
# Apply BGE reranker
cross_encoder = CrossEncoder('BAAI/bge-reranker-base')
query_doc_pair = [[topic, doc] for doc in documents]
cross_scores = cross_encoder.predict(query_doc_pair)
sim_scores_argsort = list(reversed(np.argsort(cross_scores)))
documents = [documents[idx] for idx in sim_scores_argsort[:top_k_rank]]
documents_str = '\n'.join(documents)
quiz_data = generate_quiz_data(question_difficulty, topic, documents_str)
return quiz_data
def update_quiz_components(quiz_data):
if not quiz_data or not quiz_data.items:
return [gr.update(visible=False) for _ in range(10)] + [gr.update(value="Error: Failed to generate quiz.", visible=True)]
radio_updates = []
for i, item in enumerate(quiz_data.items[:10]):
choices = item.choices
radio_update = gr.update(visible=True, choices=choices, label=item.question, value=None)
radio_updates.append(radio_update)
return radio_updates + [gr.update(value="Please select answers and click 'Check Score'.", visible=True)]
# FIXED FUNCTION: Changed parameter signature to accept all arguments positionally
def collect_answers_and_calculate(*all_inputs):
print(f"Total inputs received: {len(all_inputs)}") # Debug print
# The last input is quiz_data, the first 10 are radio values
radio_values = all_inputs[:10] # First 10 inputs are radio button values
quiz_data = all_inputs[10] # Last input is quiz_data
print(f"Received radio_values: {radio_values}") # Debug print
print(f"Received quiz_data: {quiz_data}") # Debug print
# Calculate score by comparing user answers with correct answers
score = 0
answered_questions = 0
for i, (user_answer, quiz_item) in enumerate(zip(radio_values, quiz_data.items[:10])):
if user_answer is not None: # Only count if user answered
answered_questions += 1
# Convert correct answer code (e.g., 'C3') to actual choice text
correct_answer_index = int(quiz_item.correct_answer[1]) - 1 # 'C3' -> index 2
correct_answer_text = quiz_item.choices[correct_answer_index]
print(f"Q{i+1}: User='{user_answer}' vs Correct='{correct_answer_text}'") # Debug
if user_answer == correct_answer_text:
score += 1
print(f"Calculated score: {score}/{answered_questions}") # Debug print
# Create colorful HTML message
if answered_questions == 0:
html_message = """
⚠️ Please answer at least one question!
"""
elif score == answered_questions:
html_message = f"""
🏆 PERFECT SCORE! 🏆
You got {score} out of {answered_questions} correct!
Outstanding performance! 🌟
"""
elif score > answered_questions * 0.7:
html_message = f"""
🎉 EXCELLENT! 🎉
You got {score} out of {answered_questions} correct!
Great job! Keep it up! 💪
"""
elif score > answered_questions * 0.5:
html_message = f"""
👍 GOOD JOB! 👍
You got {score} out of {answered_questions} correct!
Well done! Room for improvement! 📚
"""
else:
html_message = f"""
💪 KEEP TRYING! 💪
You got {score} out of {answered_questions} correct!
Don't worry! Practice makes perfect! 📖✨
"""
return html_message
# Define a colorful theme
colorful_theme = gr.themes.Default(primary_hue="cyan", secondary_hue="yellow", neutral_hue="purple")
with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
# Create a single row for the HTML and Image
with gr.Row():
with gr.Column(scale=2):
gr.Image(value='logo.png', height=200, width=200)
with gr.Column(scale=6):
gr.HTML("""
GOVERNMENT HIGH SCHOOL,SUTHUKENY STUDENTS QUIZBOT
Generative AI-powered Capacity building for STUDENTS
⚠️ Students can create quiz from any topic from 10th Science and evaluate themselves! ⚠️
""")
topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any CHAPTER NAME")
with gr.Row():
difficulty_radio = gr.Radio(["easy", "average", "hard"], label="How difficult should the quiz be?")
model_radio = gr.Radio(choices=['(ACCURATE) BGE reranker'], value='(ACCURATE) BGE reranker', label="Embeddings")
generate_quiz_btn = gr.Button("Generate Quiz!🚀")
quiz_msg = gr.Textbox(label="Status", interactive=False)
# Pre-defined radio buttons for 10 questions
question_radios = [gr.Radio(visible=False, label="", choices=[""], value=None) for _ in range(10)]
quiz_data_state = gr.State(value=None)
check_score_btn = gr.Button("Check Score", variant="primary", size="lg")
# HTML output for colorful score display at bottom
score_output = gr.HTML(visible=False, label="Your Results")
# Register the click event for Generate Quiz without @ decorator
generate_quiz_btn.click(
fn=retrieve_and_generate_quiz,
inputs=[difficulty_radio, topic],
outputs=[quiz_data_state]
).then(
fn=update_quiz_components,
inputs=[quiz_data_state],
outputs=question_radios + [quiz_msg]
)
# FIXED: Register the click event for Check Score with correct input handling
check_score_btn.click(
fn=collect_answers_and_calculate,
inputs=question_radios + [quiz_data_state], # This creates a list of 11 inputs
outputs=[score_output],
api_name="check_score"
).then(
fn=lambda: gr.update(visible=True), # Make score output visible after calculation
inputs=[],
outputs=[score_output]
)
if __name__ == "__main__":
QUIZBOT.queue().launch(server_name="0.0.0.0", server_port=7860)# import gradio as gr