Create app.py

app.py

@@ -0,0 +1,634 @@
+import io
+import os
+import requests
+from PIL import Image
+from typing import Optional, Tuple, List, Dict
+import gradio as gr
+from dotenv import load_dotenv
+import google.generativeai as genai
+import pdfplumber
+import tempfile
+from fpdf import FPDF
+import re # Import regex for parsing quiz
+
+# ─────────────────────────────────────────────
+# Load environment variables & Constants
+# ─────────────────────────────────────────────
+load_dotenv()
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+MISTRAL_MODEL = "mistralai/mistral-7b-instruct"
+FLUX_MODEL_API = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions"
+GEMINI_MODEL_NAME = "gemini-1.5-flash"
+PDF_TEXT_LIMIT = 8000
+
+if not all([OPENROUTER_API_KEY, HF_TOKEN, GEMINI_API_KEY]):
+    raise ValueError("❌ Missing one or more required environment variables.")
+
+# ─────────────────────────────────────────────
+# Configure Gemini
+# ─────────────────────────────────────────────
+genai.configure(api_key=GEMINI_API_KEY)
+gemini_model = genai.GenerativeModel(GEMINI_MODEL_NAME)
+
+# ─────────────────────────────────────────────
+# Prompt Templates
+# ─────────────────────────────────────────────
+LEVEL_PROMPTS = {
+    "Kid": "Explain like I'm 7 years old: ",
+    "Beginner": "Explain in simple terms: ",
+    "Advanced": "Explain in technical detail: "
+}
+
+# ─────────────────────────────────────────────
+# UI HTML & CSS Styling
+# ─────────────────────────────────────────────
+LOTTIE_ANIMATION_HTML = """
+<div style="text-align: center; margin-bottom: 20px;">
+    <script src="https://unpkg.com/@lottiefiles/lottie-player@latest/dist/lottie-player.js"></script>
+    <lottie-player src="https://assets5.lottiefiles.com/packages/lf20_M9p23l.json"
+                   background="transparent" speed="1" style="width: 200px; height: 200px; margin: auto;"
+                   loop autoplay></lottie-player>
+</div>
+"""
+
+# Combined CSS for dark mode, hover effect, and accordion styling
+APP_CSS = """
+body.dark {
+    --body-background-fill: #121212;
+    --background-fill-primary: #1E1E1E;
+    --background-fill-secondary: #2C2C2C;
+    --text-color-primary: #FFFFFF;
+    --text-color-secondary: #E0E0E0;
+    --border-color-primary: #333333;
+    --input-background-fill: #2C2C2C;
+    --button-secondary-background-fill: #333333;
+    --button-secondary-text-color: #FFFFFF;
+    --button-primary-background-fill: #6d28d9; /* Purple */
+    --button-primary-border-color: #6d28d9; /* Purple */
+    --button-primary-text-color: #FFFFFF;
+}
+.dark .gradio-container { background: var(--body-background-fill); }
+.dark .gradio-tabs-nav { background: var(--background-fill-secondary); }
+
+/* Button Hover Effect */
+button:hover {
+    transition: all 0.3s ease;
+    transform: scale(1.01);
+    box-shadow: 0px 0px 8px rgba(255, 255, 255, 0.1);
+}
+
+/* Style for Accordions */
+/* Adjusting background and text color for accordions in both modes */
+.gradio-accordion.secondary > .label {
+    background-color: var(--background-fill-primary); /* Use primary background for label */
+    color: var(--text-color-primary);
+    border-color: var(--border-color-primary);
+}
+.gradio-accordion.secondary > .label:hover {
+     background-color: var(--background-fill-secondary); /* Slightly change on hover */
+}
+.gradio-accordion.secondary > .label > .icon {
+    color: var(--text-color-primary);
+}
+.gradio-accordion.secondary > .panel {
+    background-color: var(--background-fill-secondary); /* Secondary background for panel content */
+    border-color: var(--border-color-primary);
+}
+
+/* Style for Dropdowns inside Accordions */
+.gradio-accordion .gr-form { /* Target forms/inputs inside accordion panels */
+    background-color: var(--background-fill-secondary); /* Ensure consistent background */
+}
+.gradio-accordion .gr-dropdown-value {
+    color: var(--text-color-primary); /* Set text color for dropdown */
+}
+.gradio-accordion .gr-dropdown-options {
+     background-color: var(--background-fill-secondary); /* Options background */
+     border-color: var(--border-color-primary);
+}
+.gradio-accordion .gr-dropdown-options .gr-dropdown-option {
+     color: var(--text-color-primary); /* Options text color */
+}
+.gradio-accordion .gr-dropdown-options .gr-dropdown-option:hover {
+     background-color: var(--background-fill-primary); /* Option hover background */
+}
+
+/* Style for feedback text */
+#quiz_feedback_box {
+    margin-top: 15px; /* Add space above feedback */
+    padding: 10px;
+    border: 1px solid var(--border-color-primary);
+    border-radius: 5px;
+}
+#quiz_feedback_box.correct {
+    border-color: green;
+    color: green;
+}
+#quiz_feedback_box.incorrect {
+    border-color: red;
+    color: red;
+}
+
+
+"""
+
+
+# ─────────────────────────────────────────────
+# API Calls
+# ─────────────────────────────────────────────
+def generate_mistral_response(prompt: str, system_message: str) -> str:
+    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}"}
+    payload = {
+        "model": MISTRAL_MODEL,
+        "messages": [{"role": "system", "content": system_message}, {"role": "user", "content": prompt}],
+        "temperature": 0.7
+    }
+    try:
+        response = requests.post(OPENROUTER_API_URL, headers=headers, json=payload, timeout=45)
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"].strip()
+    except requests.exceptions.RequestException as e:
+        return f"❌ Mistral Network Error: {e}"
+    except (KeyError, IndexError):
+        return "❌ Mistral API Error: Unexpected response format."
+    except Exception as e:
+        return f"❌ Mistral Error: {e}"
+
+
+def generate_diagram_image(prompt: str) -> Optional[str]:
+    try:
+        response = requests.post(
+            FLUX_MODEL_API,
+            headers={"Authorization": f"Bearer {HF_TOKEN}"},
+            json={"inputs": prompt},
+            timeout=60
+        )
+        response.raise_for_status()
+        image = Image.open(io.BytesIO(response.content))
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
+            image.save(temp_file.name, "PNG")
+            return temp_file.name
+    except requests.exceptions.RequestException as e:
+        print(f"❌ FLUX Network Error: {e}")
+        return None
+    except Exception as e:
+        print(f"❌ FLUX Error: {e}")
+        return None
+
+
+def gemini_explain_file(file, question: Optional[str] = None) -> str:
+    if not file: return "⚠️ No file uploaded."
+    try:
+        file_path = file if isinstance(file, str) else file.name
+
+        if file_path.lower().endswith((".png", ".jpg", ".jpeg")):
+            img = Image.open(file_path)
+            prompt = f"Explain the science in this image. If there's a specific question, address it: {question}" if question else "Explain the science in this image."
+            response = gemini_model.generate_content([prompt, img])
+            return response.text
+        elif file_path.lower().endswith(".pdf"):
+            with pdfplumber.open(file_path) as pdf:
+                text = "\n".join(page.extract_text() or "" for page in pdf.pages)
+            prompt = f"Explain the science in this PDF, focusing on this question: {question}\n\nPDF Content:\n{text[:PDF_TEXT_LIMIT]}" if question else f"Summarize and explain the science in this PDF:\n\n{text[:PDF_TEXT_LIMIT]}"
+            response = gemini_model.generate_content(prompt)
+            return response.text
+        else:
+            return "⚠️ Unsupported file type."
+    except Exception as e:
+        return f"❌ Gemini Error: {e}"
+
+
+# ─────────────────────────────────────────────
+# Feature Functions
+# ─────────────────────────────────────────────
+def generate_quiz(explanation_text: str) -> str:
+    """Generates a 2-question quiz based on the explanation."""
+    if not explanation_text or "❌" in explanation_text or "⚠️" in explanation_text:
+        return "Quiz could not be generated based on the explanation."
+
+    # Prompt to ensure clear formatting for parsing, including the marker
+    system_message = "You are a quiz creator. Based on the provided text, create a simple 2-question multiple-choice quiz. For each question, provide 3-4 options. Clearly indicate the correct answer by putting '(Correct answer)' immediately after it. Format each question as follows: 'Question #: [Question Text]\nA) Option A\nB) Option B\nC) Option C (Correct answer)\nD) Option D'. Put a blank line between questions. Do not include introductory or concluding remarks or explanations for the answers."
+    prompt = f"Create a 2-question multiple-choice quiz from this explanation:\n\n{explanation_text[:PDF_TEXT_LIMIT*2]}"
+    quiz_result = generate_mistral_response(prompt, system_message)
+
+    if "❌" in quiz_result:
+         return f"Could not generate quiz: {quiz_result}"
+    return quiz_result
+
+
+def parse_quiz_text_for_dropdown(quiz_text: str) -> Tuple[List[Dict[str, any]], List[str]]:
+    """
+    Parses AI quiz text. Returns a list of question data (label, choices)
+    and a list of *clean* correct answers (without the marker) for state.
+    """
+    questions_data = []
+    correct_answers_clean = [] # To store correct answers without marker
+
+    question_blocks = quiz_text.strip().split('\n\n')
+
+    for raw_block in question_blocks[:2]: # Process up to 2 questions
+        if not raw_block.strip(): continue
+
+        lines = raw_block.strip().split('\n')
+        if not lines: continue
+
+        q_text_line = lines[0].strip()
+        q_text_match = re.match(r'^\s*Question\s*\d+:\s*(.*)$', q_text_line, flags=re.IGNORECASE)
+        q_text = q_text_match.group(1).strip() if q_text_match else q_text_line
+
+        options_for_dropdown = [] # Options without the marker
+        correct_option_clean = None # Clean correct answer for state
+
+        for line in lines[1:]:
+            line = line.strip()
+            if not line: continue
+            # Check if it looks like an option line (starts with A), capture text before marker
+            option_match = re.match(r'^[A-Z]\)\s*(.*?)(?:\s*\(Correct answer\))?\s*$', line, flags=re.IGNORECASE)
+            if option_match:
+                option_text_clean = option_match.group(1).strip()
+                options_for_dropdown.append(option_text_clean) # Add clean text to dropdown options
+
+                # Check if this is the correct answer
+                if "(Correct answer)" in line:
+                    correct_option_clean = option_text_clean # Store the clean correct answer
+
+        if q_text and options_for_dropdown:
+            questions_data.append({
+                "label": q_text,
+                "choices": options_for_dropdown # Use the cleaned options for dropdown
+            })
+            # Store the clean correct answer, ensure it corresponds to this question
+            correct_answers_clean.append(correct_option_clean if correct_option_clean else "No correct answer found")
+        else:
+             print(f"Warning: Could not fully parse quiz block for dropdowns: {raw_block[:100]}...")
+             correct_answers_clean.append("Error parsing question") # Add placeholder
+
+
+    # Ensure we always return exactly two correct answers (fill with None if fewer than 2 questions)
+    while len(correct_answers_clean) < 2:
+         correct_answers_clean.append(None)
+
+    return questions_data, correct_answers_clean[:2] # Return parsed data and the list of correct answers
+
+
+# CHANGED: Grade quiz function takes user answers and state values
+def grade_quiz(q1_answer_user: str, q2_answer_user: str, correct_q1_stored: str, correct_q2_stored: str) -> Tuple[str, gr.update]:
+    """Grades the user's answers based on the stored correct answers."""
+    feedback_lines = ["### Quiz Feedback"]
+    total_correct = 0
+    graded_count = 0
+
+    # Grade Question 1
+    if correct_q1_stored is not None and "Error" not in str(correct_q1_stored):
+        graded_count += 1
+        if q1_answer_user is None:
+            feedback_lines.append(f"⚠️ Question 1: No answer selected. Correct was: '{correct_q1_stored}'")
+        elif q1_answer_user == correct_q1_stored:
+            feedback_lines.append(f"✅ Question 1: Correct!")
+            total_correct += 1
+        else:
+            feedback_lines.append(f"❌ Question 1: Incorrect. Your answer: '{q1_answer_user}'. Correct was: '{correct_q1_stored}'")
+    elif q1_answer_user: # User selected an answer but question/correct answer wasn't parsed
+         feedback_lines.append(f"⚠️ Question 1: Answer selected, but correct answer could not be determined.")
+
+
+    # Grade Question 2
+    if correct_q2_stored is not None and "Error" not in str(correct_q2_stored):
+        graded_count += 1
+        if q2_answer_user is None:
+            feedback_lines.append(f"⚠️ Question 2: No answer selected. Correct was: '{correct_q2_stored}'")
+        elif q2_answer_user == correct_q2_stored:
+            feedback_lines.append(f"✅ Question 2: Correct!")
+            total_correct += 1
+        else:
+            feedback_lines.append(f"❌ Question 2: Incorrect. Your answer: '{q2_answer_user}'. Correct was: '{correct_q2_stored}'")
+    elif q2_answer_user: # User selected an answer but question/correct answer wasn't parsed
+         feedback_lines.append(f"⚠️ Question 2: Answer selected, but correct answer could not be determined.")
+
+    # Overall score
+    if graded_count > 0:
+         score_message = f"Overall Score: {total_correct}/{graded_count}."
+         feedback_lines.append(score_message)
+
+         # Determine feedback box class based on score
+         if total_correct == graded_count:
+             feedback_css_class = "correct"
+         elif total_correct > 0:
+             feedback_css_class = "partial" # Using 'partial' class if you add one in CSS
+         else:
+             feedback_css_class = "incorrect"
+    else:
+         feedback_lines.append("No quiz questions were available to grade.")
+         feedback_css_class = "" # No specific class if nothing graded
+
+
+    feedback_text = "\n".join(feedback_lines)
+
+    # Update feedback box visibility and value
+    feedback_update = gr.update(value=feedback_text, visible=True, elem_classes=[feedback_css_class])
+
+    return feedback_update
+
+
+def create_report(report_format: str, explanation: str, image_path: Optional[str], raw_quiz_text: str) -> Optional[str]:
+    """Creates a downloadable report in PDF or Markdown format."""
+    if not explanation:
+        return None
+
+    if report_format == "PDF":
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Helvetica", 'B', 16)
+        pdf.cell(0, 10, 'Science Report', 0, 1, 'C')
+        pdf.ln(10)
+
+        pdf.set_font("Helvetica", 'B', 14)
+        pdf.cell(0, 10, 'Explanation', 0, 1)
+        pdf.set_font("Helvetica", '', 12)
+        try:
+             pdf.multi_cell(0, 10, explanation.encode('latin-1', 'replace').decode('latin-1'))
+        except Exception as e:
+             print(f"PDF Explanation Encoding Error: {e}")
+             pdf.multi_cell(0, 10, "Error encoding explanation text for PDF.") # Fallback
+        pdf.ln(5)
+
+        if image_path and os.path.exists(image_path):
+            pdf.set_font("Helvetica", 'B', 14)
+            pdf.cell(0, 10, 'Generated Diagram', 0, 1)
+            pdf.ln(5)
+            try:
+                available_width = pdf.w - pdf.l_margin - pdf.r_margin
+                pdf.image(image_path, x=pdf.get_x(), y=pdf.get_y(), w=available_width)
+                # Move cursor down past where image would be (approximate height based on width)
+                try:
+                    img_w, img_h = Image.open(image_path).size
+                    img_display_height = (img_h / img_w) * available_width
+                    pdf.ln(min(img_display_height, pdf.h - pdf.get_y() - pdf.b_margin) + 5) # Add space after image, don't go past page bottom
+                except Exception as img_size_e:
+                     print(f"Could not get image size for PDF spacing: {img_size_e}")
+                     pdf.ln(100) # Fallback fixed spacing if size fails
+
+            except Exception as e:
+                 print(f"PDF Image Error: {e}")
+                 pdf.ln(15) # Add some space even if image failed
+
+
+        pdf.set_font("Helvetica", 'B', 14)
+        pdf.cell(0, 10, 'Quiz', 0, 1)
+        pdf.set_font("Helvetica", '', 12)
+        # Use the raw quiz text for the report as it contains correct answers
+        if raw_quiz_text and "Quiz could not be generated" not in raw_quiz_text and "❌" not in raw_quiz_text and "⚠️" not in raw_quiz_text:
+             try:
+                  pdf.multi_cell(0, 10, raw_quiz_text.encode('latin-1', 'replace').decode('latin-1'))
+             except Exception as e:
+                  print(f"PDF Quiz Encoding Error: {e}")
+                  pdf.multi_cell(0, 10, "Error encoding quiz text for PDF.")
+        else:
+            pdf.multi_cell(0, 10, "Quiz was not available.")
+        pdf.ln(5)
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file:
+            pdf.output(temp_file.name)
+            return temp_file.name
+
+    elif report_format == "Markdown":
+        content = f"# Science Report\n\n## Explanation\n\n{explanation}\n\n"
+        if image_path:
+            content += "## Diagram\n\n(Note: The diagram image is a separate file.)\n\n"
+        content += f"## Quiz\n\n{raw_quiz_text}\n" # Use raw text for Markdown too
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".md", mode='w', encoding='utf-8') as temp_file:
+            temp_file.write(content)
+            return temp_file.name
+    return None
+
+
+# ─────────────────────────────────────────────
+# Main Handler
+# ─────────────────────────────────────────────
+# This function updates ALL relevant output components and state variables.
+# The order of returned values MUST match the outputs list in submit_btn.click
+def handle_combined_input(question, level, uploaded_file):
+    explanation = ""
+    image_path = None # This holds the temporary file path
+    raw_quiz_text = "Your quiz will appear here..." # Store raw AI output for quiz
+    reasoning = ""
+    download_box_visible = gr.update(visible=False) # Assume hidden initially
+    diagram_visible = gr.update(visible=False) # Hide diagram by default
+
+    # --- Generation Logic ---
+    if uploaded_file:
+        explanation = gemini_explain_file(uploaded_file, question)
+        reasoning = "🧠 Analysis powered by Google Gemini."
+        image_path = None # No diagram for file upload
+        diagram_visible = gr.update(visible=False)
+    elif question and question.strip():
+        prompt = LEVEL_PROMPTS.get(level, "") + question
+        explanation = generate_mistral_response(prompt, "You are a helpful science explainer.")
+        reasoning = "🧠 Explanation powered by Mistral via OpenRouter."
+        if "❌" not in explanation and "⚠️" not in explanation: # Only try image if explanation worked
+            image_path = generate_diagram_image(question)
+            if image_path:
+                 reasoning += "\n🎨 Diagram generated by FLUX via Hugging Face."
+                 diagram_visible = gr.update(visible=True) # Show diagram if successful
+            else:
+                 reasoning += "\n❌ Diagram generation failed."
+                 diagram_visible = gr.update(visible=False) # Hide if failed
+        else:
+             image_path = None # If explanation failed, no image is generated
+             diagram_visible = gr.update(visible=False)
+    else:
+        explanation = "⚠️ Please ask a science question or upload a file."
+        reasoning = "" # Clear reasoning if no input
+        image_path = None
+        diagram_visible = gr.update(visible=False)
+
+    # Generate quiz only if explanation was successful and not empty/warning
+    parsed_quiz_data = [] # Initialize parsed data and correct answers
+    correct_answers = [None, None] # Initialize state values
+
+    if explanation.strip() and "❌" not in explanation and "⚠️" not in explanation:
+        raw_quiz_text = generate_quiz(explanation)
+        # Parse quiz text for dropdowns and get correct answers for state
+        parsed_quiz_data, correct_answers = parse_quiz_text_for_dropdown(raw_quiz_text)
+
+        # Only show download box if explanation AND quiz generation seem OK
+        if "❌" not in raw_quiz_text and "⚠️" not in raw_quiz_text and raw_quiz_text.strip() and "Quiz could not be generated" not in raw_quiz_text:
+             download_box_visible = gr.update(visible=True)
+        # If quiz generation failed, raw_quiz_text will contain the error message
+
+
+    # --- Prepare UI Updates ---
+
+    # Updates for Quiz Question 1 Dropdown
+    if len(parsed_quiz_data) > 0:
+         q1_label = parsed_quiz_data[0]["label"]
+         q1_choices = parsed_quiz_data[0]["choices"]
+         q1_update = gr.update(
+             label=f"Question 1: {q1_label}", # Add "Question 1:" prefix
+             choices=q1_choices,
+             value=None, # Reset value
+             visible=True # Make visible
+         )
+    else:
+         # If no Q1, hide the dropdown
+         q1_update = gr.update(label="Quiz Question 1", choices=[], value=None, visible=False)
+
+
+    # Updates for Quiz Question 2 Dropdown
+    if len(parsed_quiz_data) > 1:
+         q2_label = parsed_quiz_data[1]["label"]
+         q2_choices = parsed_quiz_data[1]["choices"]
+         q2_update = gr.update(
+             label=f"Question 2: {q2_label}", # Add "Question 2:" prefix
+             choices=q2_choices,
+             value=None, # Reset value
+             visible=True # Make visible
+         )
+    else:
+         # If no Q2, hide the dropdown
+         q2_update = gr.update(label="Quiz Question 2", choices=[], value=None, visible=False)
+
+    # Update the raw quiz markdown text display
+    # Only show the raw text if quiz generation provided some content
+    if raw_quiz_text.strip() and "Your quiz will appear here" not in raw_quiz_text:
+        raw_quiz_markdown_update = gr.update(value=f"**Raw Quiz Output:**\n\n{raw_quiz_text}", visible=True)
+    else:
+        raw_quiz_markdown_update = gr.update(value="", visible=False)
+
+    # Hide quiz feedback initially or if quiz generation failed
+    quiz_feedback_update = gr.update(value="", visible=False, elem_classes="") # Also clear feedback class
+    # Show submit button only if at least one question was parsed
+    submit_quiz_btn_update = gr.update(visible= True if len(parsed_quiz_data) > 0 else False)
+
+
+    # Return all the updated components' values/updates
+    # Order MUST match the outputs list in submit_btn.click
+    return (explanation,           # explanation_out
+            image_path,            # diagram_out (path to temp file)
+            diagram_visible,       # diagram_out visibility update
+            reasoning,             # reasoning_out
+            q1_update,             # quiz_q1 dropdown update
+            q2_update,             # quiz_q2 dropdown update
+            raw_quiz_markdown_update, # raw_quiz_markdown update
+            download_box_visible,  # download_box visibility update
+            submit_quiz_btn_update, # submit_quiz_btn visibility update
+            quiz_feedback_update,   # quiz_feedback visibility/value update
+            correct_answers[0],    # correct_q1_state (value update)
+            correct_answers[1]     # correct_q2_state (value update)
+            )
+
+
+# ─────────────────────────────────────────────
+# Launch Gradio App
+# ─────────────────────────────────────────────
+def launch_app():
+    # Use the combined CSS
+    with gr.Blocks(theme=gr.themes.Soft(), css=APP_CSS) as demo:
+        gr.HTML(LOTTIE_ANIMATION_HTML)
+        gr.Markdown("# 📚 ExplainAnything.AI\nYour personal AI-powered science tutor.")
+
+        # Hidden state variables to store correct answers
+        correct_q1_state = gr.State(value=None)
+        correct_q2_state = gr.State(value=None)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                question = gr.Textbox(label="Ask a science question", placeholder="e.g., How does photosynthesis work?", info="Ask any science-related question.")
+                level = gr.Radio(choices=["Kid", "Beginner", "Advanced"], value="Beginner", label="Explanation Level", info="Choose how detailed the explanation should be.")
+                uploaded_file = gr.File(label="Upload Image/PDF", file_types=["image", ".pdf"])
+
+                with gr.Row():
+                    toggle_theme_btn = gr.Button("Toggle Theme 🌒/☀️")
+                    submit_btn = gr.Button("Generate Explanation", variant="primary")
+
+            with gr.Column(scale=2):
+                # Use Accordions - added elem_classes for styling
+                with gr.Accordion("📘 Explanation", open=True, elem_classes="secondary"):
+                    explanation_out = gr.Textbox(lines=8, label="Explanation", interactive=False)
+                    reasoning_out = gr.Textbox(lines=2, label="🧠 Processing Details", interactive=False)
+
+                with gr.Accordion("🖼️ Diagram", open=False, elem_classes="secondary"):
+                    diagram_out = gr.Image(label="Generated Diagram", interactive=False, show_label=True, visible=False)
+
+                with gr.Accordion("🧪 Quiz", open=False, elem_classes="secondary") as quiz_accordion:
+                    gr.Markdown("Test Your Knowledge:")
+                    # Pre-defined Dropdown menus for Quiz Questions (up to 2 questions)
+                    quiz_q1 = gr.Dropdown(label="Quiz Question 1", choices=[], value=None, interactive=True, visible=False)
+                    quiz_q2 = gr.Dropdown(label="Quiz Question 2", choices=[], value=None, interactive=True, visible=False)
+                    # Raw quiz text output - changed from Markdown to Textbox as in your provided code
+                    raw_quiz_markdown = gr.Markdown(value="Your quiz will appear here...", label="Raw Quiz Data", visible=False) # Switched back to Markdown
+                    submit_quiz_btn = gr.Button("Submit Answers", variant="secondary", visible=False)
+                    # Feedback textbox - initially hidden, given an ID for CSS styling
+                    quiz_feedback = gr.Textbox(label="Quiz Feedback", lines=3, interactive=False, visible=False, elem_id="quiz_feedback_box")
+
+
+        with gr.Group(visible=False) as download_box:
+            gr.Markdown("### 📥 Download Report")
+            with gr.Row():
+                report_format = gr.Radio(["PDF", "Markdown"], label="Choose Format", value="PDF")
+                download_btn = gr.Button("Download")
+            download_file = gr.File(label="Your report is ready to download", interactive=False)
+
+        # --- Event Handlers ---
+        # Inputs for handle_combined_input: question, level, uploaded_file
+        # Outputs: explanation_out, diagram_out (value), diagram_out (visibility),
+        #          reasoning_out (value), quiz_q1 (update), quiz_q2 (update),
+        #          raw_quiz_markdown (update), download_box (visibility),
+        #          submit_quiz_btn (visibility), quiz_feedback (visibility),
+        #          correct_q1_state (update), correct_q2_state (update)
+        # The order here MUST match the return order in handle_combined_input
+        submit_btn.click(
+            fn=handle_combined_input,
+            inputs=[question, level, uploaded_file],
+            outputs=[explanation_out, diagram_out, diagram_out, # Diagram value and visibility
+                     reasoning_out,
+                     quiz_q1, quiz_q2, # Dropdown updates
+                     raw_quiz_markdown, # Raw text update
+                     download_box,     # Download box visibility
+                     submit_quiz_btn,  # Submit quiz button visibility
+                     quiz_feedback,    # Feedback box visibility/value
+                     correct_q1_state, # State update for correct answer 1
+                     correct_q2_state  # State update for correct answer 2
+                     ]
+        )
+
+        # Handle quiz submission
+        # Inputs: Current value of quiz_q1, quiz_q2, and the state variables holding correct answers
+        # Output: Update the quiz_feedback textbox
+        submit_quiz_btn.click(
+             fn=grade_quiz,
+             inputs=[quiz_q1, quiz_q2, correct_q1_state, correct_q2_state], # Get selected answers AND stored correct answers
+             outputs=[quiz_feedback] # Update the feedback textbox
+         )
+
+        toggle_theme_btn.click(
+            fn=None, inputs=None, outputs=None,
+            js="() => { document.body.classList.toggle('dark'); }"
+        )
+
+
+        # Inputs for create_report need the CURRENT values from the outputs AFTER submit is run
+        # Inputs: report_format (from radio), explanation (from explanation_out),
+        #         image_path (from diagram_out), raw_quiz_text (from raw_quiz_markdown)
+        # Output: download_file (the downloadable file)
+        # Note: We pass the component objects themselves, Gradio gets their current VALUE
+        download_btn.click(
+            fn=create_report,
+            inputs=[report_format, explanation_out, diagram_out, raw_quiz_markdown],
+            outputs=[download_file]
+        )
+
+    print("Launching Gradio app with a public link...")
+    demo.launch(share=True, debug=True)
+
+
+# ─────────────────────────────────────────────
+# Run App
+# ─────────────────────────────────────────────
+if __name__ == "__main__":
+    launch_app()