Update app.py

app.py

@@ -1,100 +1,176 @@
-# Importing libraries
-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 pydantic import BaseModel, Field
+from phi.agent import Agent
+from phi.model.groq import Groq
+import os
+import logging
 
-#calling functions from other files - to call the knowledge database tables (lancedb for accurate mode) for creating quiz  
-from backend.semantic_search import table, retriever
+# 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()
 
-# Set up logging
-import logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# 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 = """
+        <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
 
-# Replace Mixtral client with Qwen Client
-client = Client("Qwen/Qwen1.5-110B-Chat-demo")
-
-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]"""
-
-# Ragatouille database for Colbert ie highly accurate mode
-RAG_db = gr.State()
-quiz_data = None
-
-
-#defining a function to convert json file to excel file 
-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
-        
-)
+colorful_theme = gr.themes.Default(primary_hue="cyan", secondary_hue="yellow", neutral_hue="purple")
 
-#gradio app creation for a user interface 
 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):
@@ -102,129 +178,51 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
         with gr.Column(scale=6):
             gr.HTML("""
             <center>
-                <h1><span style="color: purple;">GOVERNMENT HIGH SCHOOL,SUTHUKENY</span> STUDENTS QUIZBOT</h1>
+                <h1><span style="color: purple;">GOVERNMENT HIGH SCHOOL,SUTHUKENY</span> STUDENTS QUIZBOT </h1>
                 <h2>Generative AI-powered Capacity building for STUDENTS</h2>
-                <i>⚠️STUDENTS CAN CREATE QUIZ AND EVALUATE BY THEMSELVES ! ⚠️</i>
+                <i>⚠️ Students can create quiz from any topic from 10th Science and evaluate themselves! ⚠️</i>
             </center>
             """)
-        
-
 
-    
-    topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any topic/details from 10 social CBSE")
+    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', '(HIGH ACCURATE) ColBERT'], 
-                               value='(ACCURATE) BGE reranker', label="Embeddings", 
-                               info="First query to ColBERT may take a little time")
+        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()
-
-    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]]
-
-        #creating a text prompt to Qwen model combining the documents and system instruction 
-        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")
-            response1 = response[1][0][1]
-            
-            # 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)
-            
-
-            #Create a Quiz display in app
-            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)
+    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