Update app.py

app.py

@@ -4,15 +4,11 @@ import gradio as gr
 from pathlib import Path
 from pptx import Presentation
 from gradio_client import Client, handle_file
-from tempfile import NamedTemporaryFile
 import os
 import logging
 from phi.agent import Agent
 from phi.model.groq import Groq
 
-# Constants
-proj_dir = Path.cwd()
-
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -59,7 +55,7 @@ def extract_text_from_ppt(file_path):
     gr.Info("Extracting text from PPT/PPTX file...")
     presentation = Presentation(file_path)
     text_content = ""
-    for slide in presentation.slides:  # Fixed: Changed 'presentation' to 'presentation.slides'
+    for slide in presentation.slides:
         for shape in slide.shapes:
             if hasattr(shape, "text"):
                 text_content += shape.text + " "
@@ -72,36 +68,6 @@ def system_instructions(question_difficulty, topic, documents_str):
     return f"""You are a great teacher and your task is to create 10 questions with 4 multiple-choice options with {question_difficulty} difficulty about the topic "{topic}" only from the provided document: {documents_str}. 
 Then create answers. Output in JSON format, indexing 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'"""
 
-# Function to convert JSON to Excel
-def json_to_excel(output_json):
-    gr.Info("Converting JSON response to Excel format...")
-    data = []
-    for i in range(1, 11):
-        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].replace('C', '').strip() if correct_answer_key else ''
-        option_keys = [f"{question_key}:C{i}" for i in range(1, 5)]
-        options = [output_json.get(key, '') for key in option_keys]
-        
-        data.append([
-            question, "Multiple Choice",
-            options[0], options[1], options[2], options[3],
-            "", correct_answer, 30, ''
-        ])
-    
-    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)
-    gr.Info("Excel file generated successfully.")
-    return temp_file.name
-
 # Define theme
 colorful_theme = gr.themes.Default(primary_hue="cyan", secondary_hue="yellow", neutral_hue="purple")
 
@@ -119,12 +85,9 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
             </center>
             """)
     
-    topic = gr.Textbox(label="(Optional)Enter the Topic for Quiz", placeholder="Any specific area in ppt")
+    topic = gr.Textbox(label="Enter the Topic for Quiz (Optional)", placeholder="Any specific area in ppt")
     file_upload = gr.File(label="Upload PPT/PPTX or PDF File", type="filepath")
-    with gr.Row():
-        difficulty_radio = gr.Radio(["easy", "average", "hard"], value='easy', label="How difficult should the quiz be?")
-        model_radio = gr.Radio(choices=['(ACCURATE) BGE reranker', '(HIGH ACCURATE) ColBERT'],
-                               value='(ACCURATE) BGE reranker', label="Embeddings", visible=False)
+    difficulty_radio = gr.Radio(["easy", "average", "hard"], value='easy', label="How difficult should the quiz be?")
     
     # State to store output_json
     output_json_state = gr.State(value={})
@@ -132,11 +95,10 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
     generate_quiz_btn = gr.Button("Generate Quiz!🚀")
     quiz_msg = gr.Textbox()
     question_radios = [gr.Radio(visible=False) for _ in range(10)]
-    excel_output = gr.File(label="Download Excel")
 
-    def generate_quiz(question_difficulty, topic, cross_encoder, file_upload, output_json_state):
+    def generate_quiz(question_difficulty, topic, file_upload, output_json_state):
         if not file_upload:
-            return ["Error: No file uploaded. Please upload a valid PPT, PPTX, or PDF file."], output_json_state, [None] * 10, None
+            return ["Error: No file uploaded. Please upload a valid PPT, PPTX, or PDF file."], output_json_state, [None] * 10
         
         gr.Info("Detecting file type and extracting text...")
         if file_upload.lower().endswith('.pptx') or file_upload.lower().endswith('.ppt'):
@@ -144,7 +106,7 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
         elif file_upload.lower().endswith('.pdf'):
             text_from_file = extract_text_from_pdf(file_upload)
         else:
-            return ["Error: Unsupported file type. Please upload a PPT, PPTX, or PDF file."], output_json_state, [None] * 10, None
+            return ["Error: Unsupported file type. Please upload a PPT, PPTX, or PDF file."], output_json_state, [None] * 10
         
         gr.Info("Preparing documents for quiz generation...")
         documents = [text_from_file]
@@ -159,12 +121,11 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
             start_index = response_text.find('{')
             end_index = response_text.rfind('}')
             if start_index == -1 or end_index == -1:
-                return ["Error: Invalid JSON response from Groq Agent."], output_json_state, [None] * 10, None
+                return ["Error: Invalid JSON response from Groq Agent."], output_json_state, [None] * 10
             cleaned_response = response_text[start_index:end_index + 1]
             output_json = json.loads(cleaned_response)
             gr.Info("JSON response successfully processed.")
 
-            excel_file = json_to_excel(output_json)
             question_radio_list = []
             for question_num in range(1, 11):
                 question_key = f"Q{question_num}"
@@ -175,14 +136,14 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
                 question_radio_list.append(radio)
 
             gr.Info("Quiz generation completed successfully.")
-            return ['Quiz Generated!'], output_json, question_radio_list, excel_file
+            return ['Quiz Generated!'], output_json, question_radio_list
 
         except json.JSONDecodeError as e:
             gr.Info("Error in processing JSON response.")
-            return [f"Error: Failed to decode JSON response. {e}"], output_json_state, [None] * 10, None
+            return [f"Error: Failed to decode JSON response. {e}"], output_json_state, [None] * 10
         except Exception as e:
             gr.Info("Error in quiz generation.")
-            return [f"Error: {str(e)}"], output_json_state, [None] * 10, None
+            return [f"Error: {str(e)}"], output_json_state, [None] * 10
 
     def compare_answers(*user_answers, output_json_state):
         user_answer_list = list(user_answers)
@@ -194,9 +155,11 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
             answer = output_json_state.get(answer_key)
             if not answer:
                 break
-            answers_list.append(answer)
+            # Extract the choice text for comparison
+            choice_key = output_json_state.get(answer, "")
+            answers_list.append(choice_key)
 
-        score = sum(1 for item in user_answer_list if item in answers_list)
+        score = sum(1 for user, correct in zip(user_answer_list, answers_list) if user == correct)
 
         if score > 7:
             message = f"### Excellent! You got {score} out of 10!"
@@ -208,11 +171,11 @@ with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
         gr.Info("Score calculation completed.")
         return message
 
-    # Assign event handlers without decorators
+    # Assign event handlers
     generate_quiz_btn.click(
         fn=generate_quiz,
-        inputs=[difficulty_radio, topic, model_radio, file_upload, output_json_state],
-        outputs=[quiz_msg, output_json_state] + question_radios + [excel_output]
+        inputs=[difficulty_radio, topic, file_upload, output_json_state],
+        outputs=[quiz_msg, output_json_state] + question_radios
     )
 
     check_button = gr.Button("Check Score")
@@ -228,81 +191,75 @@ QUIZBOT.launch(debug=True)# import pandas as pd
 # import json
 # import gradio as gr
 # from pathlib import Path
-# from pptx import Presentation  # Library to handle PPTX files
-# import PyPDF2  # Library to handle PDF files
-# #from ragatouille import RAGPretrainedModel
-# from gradio_client import Client,handle_file
+# from pptx import Presentation
+# from gradio_client import Client, handle_file
 # from tempfile import NamedTemporaryFile
-# #from sentence_transformers import CrossEncoder
-# import numpy as np
-# #from backend.semantic_search import table, retriever
+# import os
+# import logging
+# from phi.agent import Agent
+# from phi.model.groq import Groq
 
 # # Constants
-# 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")
-
-# # # Function to extract text from PPT/PPTX
-# def extract_text_from_ppt(file_path):
-#     gr.Info("Extracting text from PPT/PPTX file...")
-#     presentation = Presentation(file_path)
-#     text_content = ""
-#     for slide in presentation.slides:
-#         for shape in slide.shapes:
-#             if hasattr(shape, "text"):
-#                 text_content += shape.text + " "
-#     gr.Info("Text extraction from PPT/PPTX completed.")
-#     return text_content.strip()
-# from gradio_client import Client, handle_file
-
+# # Groq 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.")
+#     api_key = ""
+# else:
+#     os.environ["GROQ_API_KEY"] = api_key
+
+# # Initialize Groq Agent
+# agent = Agent(
+#     name="Quiz Generator",
+#     role="You are an expert teacher creating quizzes for classroom evaluation.",
+#     instructions=[
+#         "You are a great teacher specializing in generating quizzes based on provided documents.",
+#         "Create accurate and relevant questions with four multiple-choice options.",
+#         "Ensure questions align with the specified difficulty level and topic.",
+#         "Provide responses in JSON format as specified in the prompt.",
+#         "Use only the provided document content for question generation."
+#     ],
+#     model=Groq(model_id="llama3-70b-8192", api_key=api_key),
+#     markdown=True
+# )
+
+# # Function to extract text from PDF using HuggingChat API
 # def extract_text_from_pdf(file_path):
-#     """
-#     Extracts text from a PDF using the HuggingChat API for PDF-to-Markdown conversion.
-    
-#     :param file_path: Path to the PDF file.
-#     :return: Extracted text from the PDF.
-#     """
+#     gr.Info("Extracting text from PDF file...")
 #     client = Client("huggingchat/pdf-to-markdown")
-    
 #     try:
-#         result = client.predict(
-#             pdf_file=handle_file(file_path),
-#             api_name="/predict"
-#         )
-        
-#         # The extracted text is in result[0], metadata is in result[1]
+#         result = client.predict(pdf_file=handle_file(file_path), api_name="/predict")
 #         extracted_text = result[0] if isinstance(result, (list, tuple)) and len(result) > 0 else ""
 #         print(extracted_text)
 #         return extracted_text.strip()
-    
 #     except Exception as e:
 #         print(f"Error extracting text from PDF: {e}")
 #         return ""
 
-# # # Function to extract text from PDF
-# # def extract_text_from_pdf(file_path):
-# #     gr.Info("Extracting text from PDF file...")
-# #     text_content = ""
-# #     with open(file_path, 'rb') as pdf_file:
-# #         pdf_reader = PyPDF2.PdfReader(pdf_file)
-# #         for page in pdf_reader.pages:
-# #             text_content += page.extract_text() or ""
-# #     gr.Info("Text extraction from PDF completed.")
-# #     return text_content.strip()
+# # Function to extract text from PPT/PPTX
+# def extract_text_from_ppt(file_path):
+#     gr.Info("Extracting text from PPT/PPTX file...")
+#     presentation = Presentation(file_path)
+#     text_content = ""
+#     for slide in presentation.slides:  # Fixed: Changed 'presentation' to 'presentation.slides'
+#         for shape in slide.shapes:
+#             if hasattr(shape, "text"):
+#                 text_content += shape.text + " "
+#     gr.Info("Text extraction from PPT/PPTX completed.")
+#     return text_content.strip()
 
 # # Function to define instructions for quiz generation
 # def system_instructions(question_difficulty, topic, documents_str):
-#     gr.Info("Preparing instructions for Qwen API...")
-#     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 \"{topic}\" only from the below 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]"""
+#     gr.Info("Preparing instructions for Groq Agent...")
+#     return f"""You are a great teacher and your task is to create 10 questions with 4 multiple-choice options with {question_difficulty} difficulty about the topic "{topic}" only from the provided document: {documents_str}. 
+# Then create answers. Output in JSON format, indexing 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'"""
 
 # # Function to convert JSON to Excel
 # def json_to_excel(output_json):
@@ -314,14 +271,13 @@ QUIZBOT.launch(debug=True)# import pandas as pd
 #         question = output_json.get(question_key, '')
 #         correct_answer_key = output_json.get(answer_key, '')
 #         correct_answer = correct_answer_key.split(':')[-1].replace('C', '').strip() if correct_answer_key else ''
-#         option_keys = [f"{question_key}:C{i}" for i in range(1, 6)]
+#         option_keys = [f"{question_key}:C{i}" for i in range(1, 5)]
 #         options = [output_json.get(key, '') for key in option_keys]
         
 #         data.append([
 #             question, "Multiple Choice",
-#             options[0], options[1], options[2] if len(options) > 2 else '',
-#             options[3] if len(options) > 3 else '', options[4] if len(options) > 4 else '',
-#             correct_answer, 30, ''
+#             options[0], options[1], options[2], options[3],
+#             "", correct_answer, 30, ''
 #         ])
     
 #     df = pd.DataFrame(data, columns=[
@@ -354,78 +310,77 @@ QUIZBOT.launch(debug=True)# import pandas as pd
     
 #     topic = gr.Textbox(label="(Optional)Enter the Topic for Quiz", placeholder="Any specific area in ppt")
 #     file_upload = gr.File(label="Upload PPT/PPTX or PDF File", type="filepath")
-
 #     with gr.Row():
-#         difficulty_radio = gr.Radio(["easy", "average", "hard"],value='easy', label="How difficult should the quiz be?")#,visible=False)
+#         difficulty_radio = gr.Radio(["easy", "average", "hard"], value='easy', label="How difficult should the quiz be?")
 #         model_radio = gr.Radio(choices=['(ACCURATE) BGE reranker', '(HIGH ACCURATE) ColBERT'],
-#                                value='(ACCURATE) BGE reranker', label="Embeddings",visible=False)
+#                                value='(ACCURATE) BGE reranker', label="Embeddings", visible=False)
+    
+#     # State to store output_json
+#     output_json_state = gr.State(value={})
 
 #     generate_quiz_btn = gr.Button("Generate Quiz!🚀")
 #     quiz_msg = gr.Textbox()
 #     question_radios = [gr.Radio(visible=False) for _ in range(10)]
+#     excel_output = gr.File(label="Download Excel")
 
-#     @generate_quiz_btn.click(inputs=[difficulty_radio, topic, model_radio, file_upload], outputs=[quiz_msg] + question_radios + [gr.File(label="Download Excel")])
-#     def generate_quiz(question_difficulty, topic, cross_encoder, file_upload):
+#     def generate_quiz(question_difficulty, topic, cross_encoder, file_upload, output_json_state):
 #         if not file_upload:
-#             return ["Error: No file uploaded. Please upload a valid PPT, PPTX, or PDF file."]
+#             return ["Error: No file uploaded. Please upload a valid PPT, PPTX, or PDF file."], output_json_state, [None] * 10, None
         
-#         # Detect file type and extract text accordingly
 #         gr.Info("Detecting file type and extracting text...")
 #         if file_upload.lower().endswith('.pptx') or file_upload.lower().endswith('.ppt'):
 #             text_from_file = extract_text_from_ppt(file_upload)
 #         elif file_upload.lower().endswith('.pdf'):
 #             text_from_file = extract_text_from_pdf(file_upload)
 #         else:
-#             return ["Error: Unsupported file type. Please upload a PPT, PPTX, or PDF file."]
+#             return ["Error: Unsupported file type. Please upload a PPT, PPTX, or PDF file."], output_json_state, [None] * 10, None
         
 #         gr.Info("Preparing documents for quiz generation...")
 #         documents = [text_from_file]
-
 #         formatted_prompt = system_instructions(question_difficulty, topic, '\n'.join(documents))
         
 #         try:
-#             gr.Info("Sending request to Qwen API for quiz generation...")
-#             response = client.predict(query=formatted_prompt, history=[], system="You are a helpful assistant.", api_name="/model_chat")
-#             response1 = response[1][0][1]
-
-#             gr.Info("Processing response from Qwen API...")
-#             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 ''
+#             gr.Info("Sending request to Groq Agent for quiz generation...")
+#             response = agent.run(formatted_prompt)
+#             response_text = response.content if hasattr(response, 'content') else str(response)
+
+#             gr.Info("Processing response from Groq Agent...")
+#             start_index = response_text.find('{')
+#             end_index = response_text.rfind('}')
+#             if start_index == -1 or end_index == -1:
+#                 return ["Error: Invalid JSON response from Groq Agent."], output_json_state, [None] * 10, None
+#             cleaned_response = response_text[start_index:end_index + 1]
 #             output_json = json.loads(cleaned_response)
 #             gr.Info("JSON response successfully processed.")
 
 #             excel_file = json_to_excel(output_json)
-
 #             question_radio_list = []
 #             for question_num in range(1, 11):
 #                 question_key = f"Q{question_num}"
 #                 question = output_json.get(question_key)
 #                 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)
 
 #             gr.Info("Quiz generation completed successfully.")
-#             return ['Quiz Generated!'] + question_radio_list + [excel_file]
+#             return ['Quiz Generated!'], output_json, question_radio_list, excel_file
 
 #         except json.JSONDecodeError as e:
 #             gr.Info("Error in processing JSON response.")
-#             return [f"Error: Failed to decode JSON response. {e}"]
-
-#     check_button = gr.Button("Check Score")
-#     score_textbox = gr.Markdown()
+#             return [f"Error: Failed to decode JSON response. {e}"], output_json_state, [None] * 10, None
+#         except Exception as e:
+#             gr.Info("Error in quiz generation.")
+#             return [f"Error: {str(e)}"], output_json_state, [None] * 10, None
 
-#     @check_button.click(inputs=question_radios, outputs=score_textbox)
-#     def compare_answers(*user_answers):
+#     def compare_answers(*user_answers, output_json_state):
 #         user_answer_list = list(user_answers)
 #         answers_list = []
 
 #         gr.Info("Comparing user answers with correct answers...")
 #         for question_num in range(1, 11):
 #             answer_key = f"A{question_num}"
-#             answer = quiz_data.get(quiz_data.get(answer_key))
+#             answer = output_json_state.get(answer_key)
 #             if not answer:
 #                 break
 #             answers_list.append(answer)
@@ -442,5 +397,239 @@ QUIZBOT.launch(debug=True)# import pandas as pd
 #         gr.Info("Score calculation completed.")
 #         return message
 
+#     # Assign event handlers without decorators
+#     generate_quiz_btn.click(
+#         fn=generate_quiz,
+#         inputs=[difficulty_radio, topic, model_radio, file_upload, output_json_state],
+#         outputs=[quiz_msg, output_json_state] + question_radios + [excel_output]
+#     )
+
+#     check_button = gr.Button("Check Score")
+#     score_textbox = gr.Markdown()
+#     check_button.click(
+#         fn=compare_answers,
+#         inputs=question_radios + [output_json_state],
+#         outputs=score_textbox
+#     )
+
 # QUIZBOT.queue()
-# QUIZBOT.launch(debug=True)
+# QUIZBOT.launch(debug=True)# import pandas as pd
+# # import json
+# # import gradio as gr
+# # from pathlib import Path
+# # from pptx import Presentation  # Library to handle PPTX files
+# # import PyPDF2  # Library to handle PDF files
+# # #from ragatouille import RAGPretrainedModel
+# # from gradio_client import Client,handle_file
+# # from tempfile import NamedTemporaryFile
+# # #from sentence_transformers import CrossEncoder
+# # import numpy as np
+# # #from backend.semantic_search import table, retriever
+
+# # # Constants
+# # 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")
+
+# # # # Function to extract text from PPT/PPTX
+# # def extract_text_from_ppt(file_path):
+# #     gr.Info("Extracting text from PPT/PPTX file...")
+# #     presentation = Presentation(file_path)
+# #     text_content = ""
+# #     for slide in presentation.slides:
+# #         for shape in slide.shapes:
+# #             if hasattr(shape, "text"):
+# #                 text_content += shape.text + " "
+# #     gr.Info("Text extraction from PPT/PPTX completed.")
+# #     return text_content.strip()
+# # from gradio_client import Client, handle_file
+
+# # def extract_text_from_pdf(file_path):
+# #     """
+# #     Extracts text from a PDF using the HuggingChat API for PDF-to-Markdown conversion.
+    
+# #     :param file_path: Path to the PDF file.
+# #     :return: Extracted text from the PDF.
+# #     """
+# #     client = Client("huggingchat/pdf-to-markdown")
+    
+# #     try:
+# #         result = client.predict(
+# #             pdf_file=handle_file(file_path),
+# #             api_name="/predict"
+# #         )
+        
+# #         # The extracted text is in result[0], metadata is in result[1]
+# #         extracted_text = result[0] if isinstance(result, (list, tuple)) and len(result) > 0 else ""
+# #         print(extracted_text)
+# #         return extracted_text.strip()
+    
+# #     except Exception as e:
+# #         print(f"Error extracting text from PDF: {e}")
+# #         return ""
+
+# # # # Function to extract text from PDF
+# # # def extract_text_from_pdf(file_path):
+# # #     gr.Info("Extracting text from PDF file...")
+# # #     text_content = ""
+# # #     with open(file_path, 'rb') as pdf_file:
+# # #         pdf_reader = PyPDF2.PdfReader(pdf_file)
+# # #         for page in pdf_reader.pages:
+# # #             text_content += page.extract_text() or ""
+# # #     gr.Info("Text extraction from PDF completed.")
+# # #     return text_content.strip()
+
+# # # Function to define instructions for quiz generation
+# # def system_instructions(question_difficulty, topic, documents_str):
+# #     gr.Info("Preparing instructions for Qwen API...")
+# #     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 \"{topic}\" only from the below 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]"""
+
+# # # Function to convert JSON to Excel
+# # def json_to_excel(output_json):
+# #     gr.Info("Converting JSON response to Excel format...")
+# #     data = []
+# #     for i in range(1, 11):
+# #         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].replace('C', '').strip() if correct_answer_key else ''
+# #         option_keys = [f"{question_key}:C{i}" for i in range(1, 6)]
+# #         options = [output_json.get(key, '') for key in option_keys]
+        
+# #         data.append([
+# #             question, "Multiple Choice",
+# #             options[0], options[1], options[2] if len(options) > 2 else '',
+# #             options[3] if len(options) > 3 else '', options[4] if len(options) > 4 else '',
+# #             correct_answer, 30, ''
+# #         ])
+    
+# #     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)
+# #     gr.Info("Excel file generated successfully.")
+# #     return temp_file.name
+
+# # # Define theme
+# # colorful_theme = gr.themes.Default(primary_hue="cyan", secondary_hue="yellow", neutral_hue="purple")
+
+# # # Define the Gradio interface
+# # with gr.Blocks(title="Quiz Maker", theme=colorful_theme) as QUIZBOT:
+# #     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> NACIN PPT Quizbot</h1>
+# #                 <h2>Generative AI-powered Capacity building for Training Officers</h2>
+# #                 <i>⚠️ NACIN Faculties create quiz dynamically for classroom evaluation! ⚠️</i>
+# #             </center>
+# #             """)
+    
+# #     topic = gr.Textbox(label="(Optional)Enter the Topic for Quiz", placeholder="Any specific area in ppt")
+# #     file_upload = gr.File(label="Upload PPT/PPTX or PDF File", type="filepath")
+
+# #     with gr.Row():
+# #         difficulty_radio = gr.Radio(["easy", "average", "hard"],value='easy', label="How difficult should the quiz be?")#,visible=False)
+# #         model_radio = gr.Radio(choices=['(ACCURATE) BGE reranker', '(HIGH ACCURATE) ColBERT'],
+# #                                value='(ACCURATE) BGE reranker', label="Embeddings",visible=False)
+
+# #     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, file_upload], outputs=[quiz_msg] + question_radios + [gr.File(label="Download Excel")])
+# #     def generate_quiz(question_difficulty, topic, cross_encoder, file_upload):
+# #         if not file_upload:
+# #             return ["Error: No file uploaded. Please upload a valid PPT, PPTX, or PDF file."]
+        
+# #         # Detect file type and extract text accordingly
+# #         gr.Info("Detecting file type and extracting text...")
+# #         if file_upload.lower().endswith('.pptx') or file_upload.lower().endswith('.ppt'):
+# #             text_from_file = extract_text_from_ppt(file_upload)
+# #         elif file_upload.lower().endswith('.pdf'):
+# #             text_from_file = extract_text_from_pdf(file_upload)
+# #         else:
+# #             return ["Error: Unsupported file type. Please upload a PPT, PPTX, or PDF file."]
+        
+# #         gr.Info("Preparing documents for quiz generation...")
+# #         documents = [text_from_file]
+
+# #         formatted_prompt = system_instructions(question_difficulty, topic, '\n'.join(documents))
+        
+# #         try:
+# #             gr.Info("Sending request to Qwen API for quiz generation...")
+# #             response = client.predict(query=formatted_prompt, history=[], system="You are a helpful assistant.", api_name="/model_chat")
+# #             response1 = response[1][0][1]
+
+# #             gr.Info("Processing response from Qwen API...")
+# #             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 ''
+# #             output_json = json.loads(cleaned_response)
+# #             gr.Info("JSON response successfully processed.")
+
+# #             excel_file = json_to_excel(output_json)
+
+# #             question_radio_list = []
+# #             for question_num in range(1, 11):
+# #                 question_key = f"Q{question_num}"
+# #                 question = output_json.get(question_key)
+# #                 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)
+
+# #             gr.Info("Quiz generation completed successfully.")
+# #             return ['Quiz Generated!'] + question_radio_list + [excel_file]
+
+# #         except json.JSONDecodeError as e:
+# #             gr.Info("Error in processing JSON response.")
+# #             return [f"Error: Failed to decode JSON response. {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 = []
+
+# #         gr.Info("Comparing user answers with correct answers...")
+# #         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)
+
+# #         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!"
+
+# #         gr.Info("Score calculation completed.")
+# #         return message
+
+# # QUIZBOT.queue()
+# # QUIZBOT.launch(debug=True)