Update app.py

app.py

@@ -1,101 +1,97 @@
-# 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
-
-#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
-
-VECTOR_COLUMN_NAME = "vector"
-TEXT_COLUMN_NAME = "text"
-proj_dir = Path.cwd()
+import pandas as pd
+from pydantic import BaseModel, Field
+from phi.agent import Agent
+from phi.model.groq import Groq
+import os
+import logging
 
 # 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")
+# 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
+)
 
-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]"""
+VECTOR_COLUMN_NAME = "vector"
+TEXT_COLUMN_NAME = "text"
+proj_dir = Path.cwd()
 
-# Ragatouille database for Colbert ie highly accurate mode
-RAG_db = gr.State()
-quiz_data = None
+# 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
 
-#defining a function to convert json file to excel file 
-def json_to_excel(output_json):
-    # Initialize list for DataFrame
+def json_to_excel(quiz_data):
     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
+    for i, item in enumerate(quiz_data.items, 1):
         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
+            item.question,
+            "Multiple Choice",
+            item.choices[0],
+            item.choices[1],
+            item.choices[2],
+            item.choices[3],
+            '',  # Option 5 (empty)
+            item.correct_answer.replace('C', ''),
+            30,
+            ''
         ])
-
-    # 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"
+        "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")
+    temp_file = NamedTemporaryFile(delete=True, 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
-        
-)
 
-#gradio app creation for a user interface 
+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)
@@ -104,127 +100,294 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
             <center>
                 <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 from any topic from 10 science and evaluate themselves! ⚠️</i>
+                <i>⚠️ Students can create quiz from any topic from 9th Science and evaluate themselves! ⚠️</i>
             </center>
             """)
-        
-
-
-    
-    topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any CHAPTER NAME")
 
+    topic = gr.Textbox(label="Enter the Topic for Quiz", placeholder="Write any topic/details from 9TH Science CBSE")
     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")  # Removed ColBERT option
 
     generate_quiz_btn = gr.Button("Generate Quiz!🚀")
-    quiz_msg = gr.Textbox()
-
-    question_radios = [gr.Radio(visible=False) for _ in range(10)]
+    quiz_msg = gr.Textbox(label="Status", interactive=False)
+    question_display = gr.HTML(visible=False)
+    download_excel = gr.File(label="Download Excel")
 
-    @generate_quiz_btn.click(inputs=[difficulty_radio, topic, model_radio], outputs=[quiz_msg] + question_radios + [gr.File(label="Download Excel")])
+    @generate_quiz_btn.click(inputs=[difficulty_radio, topic, model_radio], outputs=[quiz_msg, question_display, 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]
-
+        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()]
+        if cross_encoder == '(ACCURATE) BGE reranker':
+            cross_encoder1 = CrossEncoder('BAAI/bge-reranker-base')
             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]
+        documents_str = '\n'.join(documents)
+        quiz_data = generate_quiz_data(question_difficulty, topic, documents_str)
+        if not quiz_data or not quiz_data.items:
+            return ["Error: Failed to generate quiz.", gr.HTML(visible=False), None]
+
+        excel_file = json_to_excel(quiz_data)
+        html_content = "<div>" + "".join(f"<h3>{i}. {item.question}</h3><p>{'<br>'.join(item.choices)}</p>" for i, item in enumerate(quiz_data.items[:10], 1)) + "</div>"
+        return ["Quiz Generated!", gr.HTML(value=html_content, visible=True), excel_file]
+
+    check_button = gr.Button("Check Score")
+    score_textbox = gr.Markdown()
+
+    @check_button.click(inputs=question_display, outputs=score_textbox)
+    def compare_answers(html_content):
+        if not quiz_data or not quiz_data.items:
+            return "Please generate a quiz first."
+        # Placeholder for user answers (adjust based on actual UI implementation)
+        user_answers = []  # Implement parsing logic if using radio inputs
+        correct_answers = [item.correct_answer for item in quiz_data.items[:10]]
+        score = sum(1 for u, c in zip(user_answers, correct_answers) if u == c)
+        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
+
+if __name__ == "__main__":
+    QUIZBOT.queue().launch(debug=True)
+
+# # 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
+
+# #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
+
+# 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")
+
+# 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
+        
+# )
+
+# #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):
+#             gr.Image(value='logo.png', height=200, width=200)
+#         with gr.Column(scale=6):
+#             gr.HTML("""
+#             <center>
+#                 <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 from any topic from 10 science and evaluate themselves! ⚠️</i>
+#             </center>
+#             """)
+        
+
+
+    
+#     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")
+
+#     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')
             
-            # 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)
+#             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}"
+#             #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))
+#                 question = output_json.get(question_key)
+#                 answer = output_json.get(output_json.get(answer_key))
 
-                if not question or not answer:
-                    continue
+#                 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]
+#                 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)
+#                 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]
+#             return ['Quiz Generated!'] + question_radio_list + [excel_file]
 
-        except json.JSONDecodeError as e:
-            print(f"Failed to decode JSON: {e}")
+#         except json.JSONDecodeError as e:
+#             print(f"Failed to decode JSON: {e}")
 
-    check_button = gr.Button("Check Score")
-    score_textbox = gr.Markdown()
+#     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 = []
+#     @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, 11):
-            answer_key = f"A{question_num}"
-            answer = quiz_data.get(quiz_data.get(answer_key))
-            if not answer:
-                break
-            answers_list.append(answer)
+#         for question_num in range(1, 11):
+#             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)
+#         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!"
+#         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
+#         return message
 
-QUIZBOT.queue()
-QUIZBOT.launch(debug=True)
+# QUIZBOT.queue()
+# QUIZBOT.launch(debug=True)