Spaces:
Running
Running
| 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) | |