app.py

import gradio as gr
import pandas as pd
import json
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
from tempfile import NamedTemporaryFile
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 quiz_to_excel(quiz_data):
    """Convert quiz data to Excel format"""
    if not quiz_data or not quiz_data.items:
        return None
    
    gr.Warning('Generating Excel file...', duration=10)
    data = []
    
    for i, item in enumerate(quiz_data.items, 1):
        # Get correct answer index
        correct_answer_index = int(item.correct_answer[1]) - 1  # 'C3' -> index 2
        
        # Prepare row data
        row = [
            item.question,                      # Question Text
            "Multiple Choice",                  # Question Type
            item.choices[0] if len(item.choices) > 0 else '',  # Option 1
            item.choices[1] if len(item.choices) > 1 else '',  # Option 2
            item.choices[2] if len(item.choices) > 2 else '',  # Option 3
            item.choices[3] if len(item.choices) > 3 else '',  # Option 4
            '',                                 # Option 5 (empty)
            str(correct_answer_index + 1),      # Correct Answer (1-4)
            30,                                 # Time in seconds
            ''                                  # Image Link
        ]
        data.append(row)
    
    # Create DataFrame
    df = pd.DataFrame(data, columns=[
        "Question Text",
        "Question Type", 
        "Option 1",
        "Option 2",
        "Option 3",
        "Option 4",
        "Option 5",
        "Correct Answer",
        "Time in seconds",
        "Image Link"
    ])
    
    # Save to temporary file
    temp_file = NamedTemporaryFile(delete=False, suffix=".xlsx")
    df.to_excel(temp_file.name, index=False)
    return temp_file.name

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), None]
    
    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)
    
    # Generate Excel file after successful quiz generation
    excel_file = quiz_to_excel(quiz_data)
    
    return radio_updates + [gr.update(value="Please select answers and click 'Check Score'.", visible=True), excel_file]

# 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 = """
        <div style="text-align: center; padding: 20px; border-radius: 10px; background: linear-gradient(135deg, #ff6b6b, #ee5a24);">
            <h2 style="color: white; margin: 0;">⚠️ Please answer at least one question!</h2>
        </div>
        """
    elif score == answered_questions:
        html_message = f"""
        <div style="text-align: center; padding: 20px; border-radius: 10px; background: linear-gradient(135deg, #00d2d3, #54a0ff); box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
            <h1 style="color: white; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🏆 PERFECT SCORE! 🏆</h1>
            <h2 style="color: #fff3cd; margin: 10px 0;">You got {score} out of {answered_questions} correct!</h2>
            <p style="color: white; font-size: 18px; margin: 0;">Outstanding performance! 🌟</p>
        </div>
        """
    elif score > answered_questions * 0.7:
        html_message = f"""
        <div style="text-align: center; padding: 20px; border-radius: 10px; background: linear-gradient(135deg, #2ed573, #7bed9f); box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
            <h1 style="color: white; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🎉 EXCELLENT! 🎉</h1>
            <h2 style="color: #fff3cd; margin: 10px 0;">You got {score} out of {answered_questions} correct!</h2>
            <p style="color: white; font-size: 18px; margin: 0;">Great job! Keep it up! 💪</p>
        </div>
        """
    elif score > answered_questions * 0.5:
        html_message = f"""
        <div style="text-align: center; padding: 20px; border-radius: 10px; background: linear-gradient(135deg, #ffa726, #ffcc02); box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
            <h1 style="color: white; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">👍 GOOD JOB! 👍</h1>
            <h2 style="color: #fff3cd; margin: 10px 0;">You got {score} out of {answered_questions} correct!</h2>
            <p style="color: white; font-size: 18px; margin: 0;">Well done! Room for improvement! 📚</p>
        </div>
        """
    else:
        html_message = f"""
        <div style="text-align: center; padding: 20px; border-radius: 10px; background: linear-gradient(135deg, #ff7675, #fd79a8); box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
            <h1 style="color: white; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">💪 KEEP TRYING! 💪</h1>
            <h2 style="color: #fff3cd; margin: 10px 0;">You got {score} out of {answered_questions} correct!</h2>
            <p style="color: white; font-size: 18px; margin: 0;">Don't worry! Practice makes perfect! 📖✨</p>
        </div>
        """
    
    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="CBSE Gyan Quiz Bot", 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("""
            <center>
                <h1><span style="color: purple;">CBSE GYAN</span> Quiz Bot</h1>
                <h2>Generative AI-powered Learning for CBSE Students</h2>
                <i>⚠️ Students can create quiz from any topic from CBSE curriculum and evaluate themselves! ⚠️</i>
            </center>
            """)

    topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any CHAPTER NAME from CBSE curriculum")

    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)
    
    # Excel download file
    excel_download = gr.File(label="Download Excel", visible=False)
    
    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, excel_download]
    ).then(
        fn=lambda: gr.update(visible=True),  # Make Excel download visible
        inputs=[],
        outputs=[excel_download]
    )

    # 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, share=True)
# import pandas as pd
# import json
# import gradio as gr
# from pathlib import Path
# from ragatouille import RAGPretrainedModel
# from gradio_client import Client
# from tempfile import NamedTemporaryFile
# from sentence_transformers import CrossEncoder
# import numpy as np
# from time import perf_counter
# from sentence_transformers import CrossEncoder
# from backend.semantic_search import table, retriever
# import os
# VECTOR_COLUMN_NAME = "vector"
# TEXT_COLUMN_NAME = "text"
# proj_dir = Path.cwd()

# # Set up logging
# import logging
# logging.basicConfig(level=logging.INFO)
# logger = logging.getLogger(__name__)

# # Replace Mixtral client with Qwen Client
# #client = Client("Qwen/Qwen1.5-110B-Chat-demo")
# # Step 2: Initialize the client for the Qwen3 Demo space
# hf_token=os.getenv('HUGGING_FACE_HUB_TOKEN')
# client = Client("Qwen/Qwen3-Demo",hf_token=hf_token)


# settings = {
#     "model": "qwen3-235b-a22b",
#     "sys_prompt": "You are a helpful and harmless assistant.",
#     "thinking_budget": 38
# }
# def system_instructions(question_difficulty, topic, documents_str):
#     return f"""<s> [INST] You are a great teacher and your task is to create 10 questions with 4 choices with {question_difficulty} difficulty about the topic request "{topic}" only from the below given documents, {documents_str}. Then create answers. Index in JSON format, the questions as "Q#":"" to "Q#":"", the four choices as "Q#:C1":"" to "Q#:C4":"", and the answers as "A#":"Q#:C#" to "A#":"Q#:C#". Example: 'A10':'Q10:C3' [/INST]"""

# # RA
# RAG_db = gr.State()
# quiz_data = None
# def json_to_excel(output_json):
#     # Initialize list for DataFrame
#     data = []
#     gr.Warning('Generating Shareable file link..', duration=30)
#     for i in range(1, 11):  # Assuming there are 10 questions
#         question_key = f"Q{i}"
#         answer_key = f"A{i}"

#         question = output_json.get(question_key, '')
#         correct_answer_key = output_json.get(answer_key, '')
#         #correct_answer = correct_answer_key.split(':')[-1] if correct_answer_key else ''
#         correct_answer = correct_answer_key.split(':')[-1].replace('C', '').strip() if correct_answer_key else ''

#         # Extract options
#         option_keys = [f"{question_key}:C{i}" for i in range(1, 6)]
#         options = [output_json.get(key, '') for key in option_keys]
        
#         # Add data row
#         data.append([
#             question,                     # Question Text
#             "Multiple Choice",            # Question Type
#             options[0],                   # Option 1
#             options[1],                   # Option 2
#             options[2] if len(options) > 2 else '',  # Option 3
#             options[3] if len(options) > 3 else '',  # Option 4
#             options[4] if len(options) > 4 else '',  # Option 5
#             correct_answer,               # Correct Answer
#             30,                           # Time in seconds
#             ''                            # Image Link
#         ])

#     # Create DataFrame
#     df = pd.DataFrame(data, columns=[
#         "Question Text",
#         "Question Type",
#         "Option 1",
#         "Option 2",
#         "Option 3",
#         "Option 4",
#         "Option 5",
#         "Correct Answer",
#         "Time in seconds",
#         "Image Link"
#     ])

#     temp_file = NamedTemporaryFile(delete=False, suffix=".xlsx")
#     df.to_excel(temp_file.name, index=False)
#     return temp_file.name
# # Define a colorful theme
# colorful_theme = gr.themes.Default(
#     primary_hue="cyan",      # Set a bright cyan as primary color
#     secondary_hue="yellow", # Set a bright magenta as secondary color
#     neutral_hue="purple"  # Optionally set a neutral color
        
# )
# #with gr.Blocks(title="Quiz Maker", theme=gr.themes.Default(primary_hue="green", secondary_hue="green")) as QUIZBOT:
# 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("""
#             <center>
#                 <h1><span style="color: purple;">ADWITIYA</span> Customs Manual Quizbot</h1>
#                 <h2>Generative AI-powered Capacity building for Training Officers</h2>
#                 <i>⚠️ NACIN Faculties create quiz from any topic dynamically for classroom evaluation after their sessions ! ⚠️</i>
#             </center>
#             """)
        


    
#     topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any topic/details from Customs Manual")

#     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', '(HIGH ACCURATE) ColBERT'], 
#                                value='(ACCURATE) BGE reranker', label="Embeddings", 
#                                info="First query to ColBERT may take a little time")

#     generate_quiz_btn = gr.Button("Generate Quiz!🚀")
#     quiz_msg = gr.Textbox()

#     question_radios = [gr.Radio(visible=False) for _ in range(10)]

#     @generate_quiz_btn.click(inputs=[difficulty_radio, topic, model_radio], outputs=[quiz_msg] + question_radios + [gr.File(label="Download Excel")])
#     def generate_quiz(question_difficulty, topic, cross_encoder):
#         top_k_rank = 10
#         documents = []
#         gr.Warning('Generating Quiz may take 1-2 minutes. Please wait.', duration=60)

#         if cross_encoder == '(HIGH ACCURATE) ColBERT':
#             gr.Warning('Retrieving using ColBERT.. First-time query will take 2 minute for model to load.. please wait',duration=100)
#             RAG = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")
#             RAG_db.value = RAG.from_index('.ragatouille/colbert/indexes/cbseclass10index')
#             documents_full = RAG_db.value.search(topic, k=top_k_rank)
#             documents = [item['content'] for item in documents_full]
        
#         else:
#             document_start = perf_counter()
#             query_vec = retriever.encode(topic)
#             doc1 = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_k_rank)

#             documents = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_k_rank).to_list()
#             documents = [doc[TEXT_COLUMN_NAME] for doc in documents]

#             query_doc_pair = [[topic, doc] for doc in documents]

#             # if cross_encoder == '(FAST) MiniLM-L6v2':
#             #     cross_encoder1 = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
#             if cross_encoder == '(ACCURATE) BGE reranker':
#                 cross_encoder1 = CrossEncoder('BAAI/bge-reranker-base')
            
#             cross_scores = cross_encoder1.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]]
        
#         formatted_prompt = system_instructions(question_difficulty, topic, '\n'.join(documents))
#         print('                      Formatted Prompt : ' ,formatted_prompt)
#         try:
#             #response = client.predict(query=formatted_prompt, history=[], system="You are a helpful assistant.", api_name="/model_chat")
#             # Step 3: Define the input message and model settings
#             response = client.predict(
#                 input_value=formatted_prompt,
#                 settings_form_value=settings,
#                 api_name="/add_message"
#             )
            
#             # Step 5: Extract the assistant's final text response from the chat history
#             chat_history = response[1]  # response[1] contains the updated chat history
#             assistant_response = None
            
#             # Loop through the messages in reverse to find the most recent assistant message
#             for message in reversed(chat_history["value"]):
#                 if message["role"] == "assistant":
#                     # Find the text content part
#                     for content_item in message["content"]:
#                         if content_item["type"] == "text":
#                             assistant_response = content_item["content"]
#                             break
#                     if assistant_response:
#                         break
            
#             # Step 6: Print only the assistant's natural language response
#             if assistant_response:
#                 print("Assistant Response:")
#                 print(assistant_response)
#             else:
#                 print("No assistant response found in the chat history.")
#             #response1 = response[1][0][1]
#             response1=assistant_response
#             # Extract JSON
#             start_index = response1.find('{')
#             end_index = response1.rfind('}')
#             cleaned_response = response1[start_index:end_index + 1] if start_index != -1 and end_index != -1 else ''
#             print('Cleaned Response :',cleaned_response)
#             output_json = json.loads(cleaned_response)
#             # Assign the extracted JSON to quiz_data for use in the comparison function
#             global quiz_data
#             quiz_data = output_json
#             # Generate the Excel file
#             excel_file = json_to_excel(output_json)

#             question_radio_list = []
#             for question_num in range(1, 11):
#                 question_key = f"Q{question_num}"
#                 answer_key = f"A{question_num}"

#                 question = output_json.get(question_key)
#                 answer = output_json.get(output_json.get(answer_key))

#                 if not question or not answer:
#                     continue

#                 choice_keys = [f"{question_key}:C{i}" for i in range(1, 5)]
#                 choice_list = [output_json.get(choice_key, "Choice not found") for choice_key in choice_keys]

#                 radio = gr.Radio(choices=choice_list, label=question, visible=True, interactive=True)
#                 question_radio_list.append(radio)

#             return ['Quiz Generated!'] + question_radio_list + [excel_file]

#         except json.JSONDecodeError as e:
#             print(f"Failed to decode JSON: {e}")

#     check_button = gr.Button("Check Score")
#     score_textbox = gr.Markdown()

#     @check_button.click(inputs=question_radios, outputs=score_textbox)
#     def compare_answers(*user_answers):
#         user_answer_list = list(user_answers)
#         answers_list = []

#         for question_num in range(1, 20):
#             answer_key = f"A{question_num}"
#             answer = quiz_data.get(quiz_data.get(answer_key))
#             if not answer:
#                 break
#             answers_list.append(answer)

#         score = sum(1 for item in user_answer_list if item in answers_list)

#         if score > 7:
#             message = f"### Excellent! You got {score} out of 10!"
#         elif score > 5:
#             message = f"### Good! You got {score} out of 10!"
#         else:
#             message = f"### You got {score} out of 10! Don't worry. You can prepare well and try better next time!"

#         return message

# QUIZBOT.queue()
# QUIZBOT.launch(debug=True)