Upload 7 files

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,29 @@
+---
+title: EduClone AI Portal
+emoji: 🎓
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# 🎓 EduClone AI — Exam Intelligence Portal
+
+## Default Admin Login
+- **Username:** `abdulqayyum`
+- **Password:** `Admin@EduClone2025`
+> ⚠️ Change `ADMIN_PASSWORD` in `auth.py` before going public.
+
+## Roles
+| Role | Access |
+|---|---|
+| **Admin** | Dashboard · User management · Activity log · Full MCQ tools |
+| **User** | Upload MCQs · Format · Download Word / PDF / Excel |
+
+## Files
+- `Dockerfile` — forces Python 3.11, avoids audioop/pydub conflict
+- `app.py` — Gradio portal
+- `auth.py` — SQLite + bcrypt auth
+- `mcq_engine.py` — MCQ parser and document builder

app.py

@@ -0,0 +1,489 @@
+"""
+EduClone AI Portal — Login / Register / Admin / User roles
+Tab 1: Generate MCQs from topic (AI, 4 options, answer always provided)
+Tab 2: Upload MCQs → smart answer detection → clone with 4 distractors
+Author: Abdulqayyum MBA
+"""
+import gradio as gr
+import pandas as pd
+import datetime
+from auth import (init_db, register_user, login_user, log_activity,
+                  get_all_users, toggle_user_active, change_user_role,
+                  delete_user, get_activity_log, get_stats)
+from mcq_engine import (
+    generate_from_topic, read_and_parse, clone_mcqs, preview_mcqs,
+    make_word, make_pdf, make_excel, BLOOMS
+)
+
+init_db()
+
+# ── CSS ───────────────────────────────────────────────────────────────────────
+CSS = """
+* { box-sizing: border-box; }
+body { font-family: 'Inter', sans-serif; margin: 0; }
+.portal-banner {
+  background: linear-gradient(135deg,#1e3a5f 0%,#1a56db 55%,#059669 100%);
+  padding: 20px 28px 18px; border-radius: 14px; color: white; margin-bottom: 18px;
+}
+.portal-banner h1 { margin:0; font-size:1.65rem; letter-spacing:-.3px; font-weight:600; }
+.portal-banner p  { margin:5px 0 0; opacity:.88; font-size:.88rem; }
+.auth-card {
+  background: var(--color-background-primary);
+  border: 1px solid var(--color-border-primary);
+  border-radius: 14px; padding: 28px 32px; max-width: 460px;
+  margin: 0 auto; box-shadow: 0 4px 24px rgba(0,0,0,.07);
+}
+.auth-card h2 { margin:0 0 18px; font-size:1.25rem; color:#1e3a5f; }
+.auth-divider { text-align:center; color:#9ca3af; margin:10px 0; font-size:.85rem; }
+.user-bar {
+  background: var(--color-background-secondary);
+  border: 1px solid var(--color-border-tertiary);
+  border-radius: 10px; padding: 12px 18px;
+  display: flex; align-items: center; justify-content: space-between;
+  margin-bottom: 14px; font-size: .9rem;
+}
+.role-badge { font-size:.78rem; font-weight:600; padding:3px 10px; border-radius:20px; }
+.role-admin { background:#dbeafe; color:#1e40af; }
+.role-user  { background:#dcfce7; color:#166534; }
+.hint-box {
+  background: #fefce8; border: 1px solid #fde68a;
+  border-radius: 8px; padding: 10px 14px; font-size:.85rem; line-height:1.7;
+  margin-bottom: 12px;
+}
+.detect-box {
+  background: #f0fdf4; border: 1px solid #a7f3d0;
+  border-radius: 8px; padding: 10px 14px; font-size:.85rem; line-height:1.7;
+  margin-bottom: 12px;
+}
+.dl-row { background:#f0fdf4; border:1px solid #a7f3d0; border-radius:8px; padding:12px; margin-top:8px; }
+footer { display:none !important; }
+"""
+
+BANNER_HTML = """
+<div class="portal-banner">
+  <h1>🎓 EduClone AI — Exam Intelligence Portal</h1>
+  <p>Generate · Upload · Clone MCQs · Download Word / PDF / Excel
+  &nbsp;|&nbsp; <strong>Abdulqayyum MBA</strong> — 18 yrs Academic Assessment · MBA · AI Governance · Azure AI</p>
+</div>
+"""
+
+TAB1_HINT = """<div class="hint-box">
+<b>📝 Tab 1 — Generate MCQs from a Topic:</b>
+Enter any subject → choose Bloom's level → AI generates fresh MCQs with
+<b>4 options (A B C D)</b> and a correct answer. Download as Word / PDF / Excel.
+</div>"""
+
+TAB2_HINT = """<div class="hint-box">
+<b>🔁 Tab 2 — Upload &amp; Clone your existing MCQs:</b><br>
+Upload <b>.docx / .pdf / .txt</b> file with your questions. The system detects the correct answer using:<br>
+&nbsp;&nbsp;<b>1.</b> Bold option text &nbsp;
+<b>2.</b> Underlined option text &nbsp;
+<b>3.</b> Coloured (non-black) option text &nbsp;
+<b>4.</b> Highlighted option text &nbsp;
+<b>5.</b> <code>Answer: X</code> line at the end<br>
+If none of these are found, the answer is left as <b>⚠️ Unknown</b> — no guess is made.
+Then the AI clones each question with <b>4 new distractors</b>.
+</div>"""
+
+SAMPLE_MCQS = """1. Your patient is a 44-year-old female, alert and oriented, in moderate distress, complaining of difficulty breathing. She has a 1-week history of fever and malaise, shortness of breath developing 3 days ago. Left-sided chest pain with deep inspiration and a cough with sputum. Examination: hot, pale, dry skin; rhonchi and rales throughout the left lung. Right lung clear.
+
+HR = 134, BP = 88/64, RR = 24, SpO2 = 92%.
+
+History of two previous myocardial infarctions. Takes nitroglycerin as needed. Which prehospital management is most appropriate?
+
+A. Oxygen via venturi mask 24-35%, nebulized albuterol and ipratropium, IV NS KVO, IV corticosteroids
+B. Endotracheal intubation, 100% oxygen, IV NS KVO, nebulized albuterol and Atrovent, IV corticosteroids
+C. Albuterol via nebulizer with 100% oxygen, IV NS KVO
+D. Oxygen via nonrebreathing mask 15 LPM, IV NS with fluid challenge
+
+Answer: D
+
+2. A 60-year-old male presents with sudden crushing chest pain radiating to left arm and jaw. Diaphoretic and pale. BP = 90/60, HR = 110, RR = 22, SpO2 = 94%. Most appropriate prehospital intervention?
+
+A. Aspirin 324 mg PO, nitroglycerin 0.4 mg SL, oxygen via NRB mask, IV access, transport immediately
+B. Morphine IV, 12-lead ECG, transport to nearest hospital without further intervention
+C. Apply CPAP at 10 cmH2O, furosemide IV, IV access
+D. Endotracheal intubation, lidocaine IV, transport Code 3
+
+Answer: A
+"""
+
+# ── session helpers ───────────────────────────────────────────────────────────
+def _logged_in(s): return s.get("logged_in", False)
+def _is_admin(s):  return s.get("role") == "admin"
+
+def _welcome_html(session):
+    role = session.get("role","user")
+    name = session.get("full_name") or session.get("username","")
+    bc   = "role-admin" if role=="admin" else "role-user"
+    bl   = "🔑 Admin"  if role=="admin" else "👤 User"
+    return (f'<div class="user-bar">'
+            f'<span>👋 Welcome, <strong>{name}</strong> &nbsp;|&nbsp;'
+            f'<span class="role-badge {bc}">{bl}</span></span>'
+            f'<span style="font-size:.82rem;color:#6b7280;">'
+            f'{datetime.datetime.now():%d %b %Y  %H:%M}</span></div>')
+
+
+# ── auth handlers ─────────────────────────────────────────────────────────────
+def do_login(username, password, session):
+    ok, msg, user = login_user(username, password)
+    if ok:
+        session.update({"logged_in": True, "username": user["username"],
+                        "role": user["role"], "full_name": user.get("full_name",""),
+                        "user_id": user["id"]})
+        return (msg, session,
+                gr.update(visible=False),
+                gr.update(visible=True),
+                _welcome_html(session),
+                gr.update(visible=_is_admin(session)),
+                gr.update(visible=True))
+    return msg, session, gr.update(visible=True), gr.update(visible=False), \
+           "", gr.update(visible=False), gr.update(visible=False)
+
+def do_register(username, email, password, confirm, full_name, institution, session):
+    if password != confirm:
+        return "❌ Passwords do not match.", session
+    ok, msg = register_user(username, email, password, full_name, institution)
+    return msg, session
+
+def do_logout(session):
+    if session.get("username"):
+        log_activity(session.get("user_id"), session.get("username"), "logout", "")
+    session.clear()
+    return (session, gr.update(visible=True), gr.update(visible=False),
+            "", gr.update(visible=False), gr.update(visible=False))
+
+
+# ── Tab 1: generate from topic ────────────────────────────────────────────────
+def handle_generate(topic, num_q, blooms, difficulty, want_word, want_pdf, want_excel, session):
+    if not _logged_in(session):
+        return "⚠️ Please log in first.", None, None, None, ""
+    if not topic.strip():
+        return "⚠️ Please enter a topic name.", None, None, None, ""
+
+    mcqs, source = generate_from_topic(topic, int(num_q), blooms, difficulty)
+    if not mcqs:
+        return "❌ Could not generate questions. Please try again.", None, None, None, ""
+
+    log_activity(session.get("user_id"), session.get("username"),
+                 "generate_topic", f"{len(mcqs)} Qs · {topic} · {blooms}")
+
+    note = ("⚡ AI was busy — template questions shown. Re-run for AI results.\n\n"
+            if source == "template" else "✅ AI-generated questions:\n\n")
+    preview = preview_mcqs(mcqs, f"Topic: {topic} | Bloom's: {blooms} | Difficulty: {difficulty}")
+
+    title = f"MCQs: {topic}"
+    w = make_word(mcqs, title)  if want_word  else None
+    p = make_pdf(mcqs,  title)  if want_pdf   else None
+    e = make_excel(mcqs, title) if want_excel else None
+
+    metrics = (f"📊 Questions: **{len(mcqs)}** · Bloom's: **{blooms}** · "
+               f"Difficulty: **{difficulty}** · Source: **{source}**")
+    return note + preview, w, p, e, metrics
+
+
+# ── Tab 2: upload + clone ─────────────────────────────────────────────────────
+def handle_upload_preview(file_obj, paste_text, session):
+    """Step 1: parse uploaded file, show what was detected."""
+    if not _logged_in(session):
+        return "⚠️ Please log in first.", session
+
+    mcqs, err = [], ""
+    if file_obj:
+        mcqs, err = read_and_parse(file_obj)
+    elif paste_text.strip():
+        from mcq_engine import _parse_plain
+        mcqs = _parse_plain(paste_text.strip())
+    else:
+        return "⚠️ Please upload a file or paste MCQs.", session
+
+    if err:
+        return f"❌ {err}", session
+    if not mcqs:
+        return ("❌ Could not detect MCQ structure.\n\n"
+                "Ensure questions start with `1.` or `Q1.` and options with `A.` / `A)`"), session
+
+    # Store in session for cloning step
+    session["_mcqs"] = mcqs
+    detected = sum(1 for m in mcqs if m.get("answer"))
+    unknown  = len(mcqs) - detected
+
+    summary  = f"✅ **{len(mcqs)} question(s) parsed**"
+    if detected:
+        summary += f" · **{detected}** answer(s) detected"
+    if unknown:
+        summary += f" · **{unknown}** answer(s) ⚠️ unknown (no formatting mark or key found)"
+    summary += "\n\n"
+    summary += preview_mcqs(mcqs)
+    return summary, session
+
+
+def handle_clone(num_clones, blooms, want_word, want_pdf, want_excel, exam_title, session):
+    """Step 2: clone the already-parsed MCQs."""
+    if not _logged_in(session):
+        return "⚠️ Please log in first.", None, None, None, ""
+    originals = session.get("_mcqs", [])
+    if not originals:
+        return "⚠️ Please parse/upload MCQs first (click Preview above).", None, None, None, ""
+
+    clones = clone_mcqs(originals, int(num_clones), blooms)
+    log_activity(session.get("user_id"), session.get("username"),
+                 "clone_mcqs", f"{len(originals)} orig → {len(clones)} clones")
+
+    title = exam_title.strip() or "Cloned MCQs"
+    w = make_word(clones, title)  if want_word  else None
+    p = make_pdf(clones,  title)  if want_pdf   else None
+    e = make_excel(clones, title) if want_excel else None
+
+    metrics = (f"📊 Original: **{len(originals)}** · "
+               f"Clones: **{len(clones)}** · "
+               f"Bloom's: **{blooms}**")
+    return preview_mcqs(clones, "Generated Clones"), w, p, e, metrics
+
+
+# ── admin handlers (unchanged) ────────────────────────────────────────────────
+def admin_get_stats(session):
+    if not _is_admin(session): return "❌ Admin only."
+    s = get_stats()
+    return (f"## 📊 Portal Statistics\n|Metric|Value|\n|---|---|\n"
+            f"|Total Users|**{s['total']}**|\n|Admins|**{s['admins']}**|\n"
+            f"|Active|**{s['active']}**|\n|New Today|**{s['new_today']}**|\n"
+            f"|Logins Today|**{s['logins_today']}**|")
+
+def admin_get_users(session):
+    if not _is_admin(session): return pd.DataFrame()
+    users = get_all_users()
+    if not users: return pd.DataFrame()
+    df = pd.DataFrame(users)[["id","username","email","full_name","institution",
+                               "role","is_active","created_at","last_login"]]
+    df.columns = ["ID","Username","Email","Full Name","Institution",
+                  "Role","Active","Registered","Last Login"]
+    df["Active"] = df["Active"].map({1:"✅ Yes", 0:"❌ No"})
+    df["Last Login"] = df["Last Login"].fillna("Never")
+    return df
+
+def admin_toggle(uid_str, activate, session):
+    if not _is_admin(session): return "❌ Admin only.", admin_get_users(session)
+    try:
+        msg = toggle_user_active(int(uid_str), activate)
+        return msg, admin_get_users(session)
+    except ValueError:
+        return "❌ Enter a numeric User ID.", admin_get_users(session)
+
+def admin_change_role(uid_str, role, session):
+    if not _is_admin(session): return "❌ Admin only.", admin_get_users(session)
+    try:
+        msg = change_user_role(int(uid_str), role)
+        return msg, admin_get_users(session)
+    except ValueError:
+        return "❌ Enter a numeric User ID.", admin_get_users(session)
+
+def admin_delete(uid_str, session):
+    if not _is_admin(session): return "❌ Admin only.", admin_get_users(session)
+    try:
+        msg = delete_user(int(uid_str))
+        return msg, admin_get_users(session)
+    except ValueError:
+        return "❌ Enter a numeric User ID.", admin_get_users(session)
+
+def admin_get_log(session):
+    if not _is_admin(session): return pd.DataFrame()
+    logs = get_activity_log(200)
+    if not logs: return pd.DataFrame()
+    df = pd.DataFrame(logs)[["timestamp","username","action","detail"]]
+    df.columns = ["Timestamp","User","Action","Detail"]
+    df["Timestamp"] = df["Timestamp"].str[:19].str.replace("T"," ")
+    return df
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  GRADIO UI
+# ══════════════════════════════════════════════════════════════════════════════
+def create_app():
+    with gr.Blocks(css=CSS, title="EduClone AI Portal") as demo:
+        session_state = gr.State({})
+        gr.HTML(BANNER_HTML)
+
+        # ── Login / Register ──────────────────────────────────────────────────
+        with gr.Column(visible=True) as login_panel:
+            with gr.Tabs():
+                with gr.TabItem("🔐 Login"):
+                    with gr.Column(elem_classes=["auth-card"]):
+                        gr.HTML("<h2>Sign in to EduClone AI</h2>")
+                        li_user = gr.Textbox(label="Username or Email")
+                        li_pass = gr.Textbox(label="Password", type="password")
+                        li_btn  = gr.Button("🔐 Login", variant="primary", size="lg")
+                        li_msg  = gr.Markdown()
+                with gr.TabItem("📝 Register"):
+                    with gr.Column(elem_classes=["auth-card"]):
+                        gr.HTML("<h2>Create your account</h2>")
+                        rg_name  = gr.Textbox(label="Full Name")
+                        rg_inst  = gr.Textbox(label="Institution / Organisation")
+                        rg_user  = gr.Textbox(label="Username (3–30 chars, no spaces)")
+                        rg_email = gr.Textbox(label="Email Address")
+                        rg_pass  = gr.Textbox(label="Password (8+ chars, 1 uppercase, 1 number)", type="password")
+                        rg_conf  = gr.Textbox(label="Confirm Password", type="password")
+                        rg_btn   = gr.Button("📝 Create Account", variant="primary", size="lg")
+                        rg_msg   = gr.Markdown()
+
+        # ── Main Portal ───────────────────────────────────────────────────────
+        with gr.Column(visible=False) as main_portal:
+            welcome_html = gr.HTML()
+            logout_btn   = gr.Button("🚪 Logout", size="sm", variant="secondary")
+
+            # ── Admin Panel ───────────────────────────────────────────────────
+            with gr.Column(visible=False) as admin_tabs:
+                gr.HTML("<h3 style='color:#1e3a5f;margin:8px 0 4px'>🔑 Admin Panel</h3>")
+                with gr.Tabs():
+                    with gr.TabItem("📊 Dashboard"):
+                        dash_btn = gr.Button("🔄 Refresh Stats", variant="secondary")
+                        dash_out = gr.Markdown()
+                    with gr.TabItem("👥 User Management"):
+                        refresh_users_btn = gr.Button("🔄 Refresh List", variant="secondary")
+                        users_table = gr.DataFrame(interactive=False, wrap=True)
+                        gr.Markdown("**Actions — enter User ID:**")
+                        with gr.Row():
+                            action_uid  = gr.Textbox(label="User ID", scale=1, placeholder="e.g. 3")
+                            action_role = gr.Dropdown(choices=["user","admin"], value="user",
+                                                      label="Set Role", scale=1)
+                        with gr.Row():
+                            btn_activate   = gr.Button("✅ Activate",   variant="secondary")
+                            btn_deactivate = gr.Button("❌ Deactivate", variant="secondary")
+                            btn_set_role   = gr.Button("🔄 Set Role",   variant="secondary")
+                            btn_del_user   = gr.Button("🗑️ Delete",    variant="stop")
+                        action_msg = gr.Markdown()
+                    with gr.TabItem("📋 Activity Log"):
+                        refresh_log_btn = gr.Button("🔄 Refresh", variant="secondary")
+                        log_table = gr.DataFrame(interactive=False, wrap=True)
+
+            # ── USER SECTION — Tab 1 & 2 ─────────────────────────────────────
+            with gr.Column(visible=False) as user_tabs:
+                with gr.Tabs():
+
+                    # ══ TAB 1: Generate from Topic ═══════════════════════════
+                    with gr.TabItem("📝 Generate from Topic"):
+                        gr.HTML(TAB1_HINT)
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                t1_topic = gr.Textbox(
+                                    label="Topic / Subject Name",
+                                    placeholder="e.g. Mitochondria · Supply Chain · Newton's Laws",
+                                    lines=2)
+                                t1_num = gr.Slider(1, 10, value=5, step=1,
+                                                   label="Number of Questions")
+                                t1_blooms = gr.Dropdown(
+                                    choices=list(BLOOMS.keys()),
+                                    value="Mixed (All)",
+                                    label="📚 Bloom's Taxonomy Level")
+                                t1_diff = gr.Radio(
+                                    choices=["Easy","Medium","Hard","Mixed"],
+                                    value="Mixed", label="Difficulty")
+                                gr.Markdown("**Download formats:**")
+                                with gr.Row():
+                                    t1_word  = gr.Checkbox(label="📄 Word",  value=True)
+                                    t1_pdf   = gr.Checkbox(label="📑 PDF",   value=True)
+                                    t1_excel = gr.Checkbox(label="📊 Excel", value=False)
+                                t1_btn = gr.Button("🚀 Generate MCQs",
+                                                   variant="primary", size="lg")
+                            with gr.Column(scale=2):
+                                t1_preview = gr.Markdown(label="Preview")
+                                with gr.Row(elem_classes=["dl-row"]):
+                                    t1_w = gr.File(label="📄 Word")
+                                    t1_p = gr.File(label="📑 PDF")
+                                    t1_e = gr.File(label="📊 Excel")
+                                t1_metrics = gr.Markdown()
+
+                    # ══ TAB 2: Upload & Clone ═════════════════════════════════
+                    with gr.TabItem("🔁 Upload & Clone"):
+                        gr.HTML(TAB2_HINT)
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Step 1 — Upload your MCQs")
+                                t2_file = gr.File(
+                                    label="Upload File (.docx / .pdf / .txt) — formatting detected from .docx",
+                                    file_types=[".docx",".doc",".pdf",".txt"])
+                                t2_paste = gr.Textbox(
+                                    label="Or paste plain-text MCQs here",
+                                    lines=10, value=SAMPLE_MCQS)
+                                t2_preview_btn = gr.Button("🔍 Parse & Preview",
+                                                           variant="secondary", size="lg")
+                                gr.Markdown("---\n### Step 2 — Clone settings")
+                                t2_clones = gr.Slider(1, 3, value=2, step=1,
+                                                      label="Clones per Question")
+                                t2_blooms = gr.Dropdown(
+                                    choices=list(BLOOMS.keys()),
+                                    value="Mixed (All)",
+                                    label="📚 Bloom's Level for Clones")
+                                t2_title = gr.Textbox(
+                                    label="Exam / Output Title",
+                                    value="Cloned MCQs")
+                                gr.Markdown("**Download formats:**")
+                                with gr.Row():
+                                    t2_word  = gr.Checkbox(label="📄 Word",  value=True)
+                                    t2_pdf   = gr.Checkbox(label="📑 PDF",   value=True)
+                                    t2_excel = gr.Checkbox(label="📊 Excel", value=False)
+                                t2_clone_btn = gr.Button("🔁 Generate Clones",
+                                                         variant="primary", size="lg")
+                            with gr.Column(scale=2):
+                                t2_preview = gr.Markdown(label="Parsed / Clone Preview")
+                                with gr.Row(elem_classes=["dl-row"]):
+                                    t2_w = gr.File(label="📄 Word")
+                                    t2_p = gr.File(label="📑 PDF")
+                                    t2_e = gr.File(label="📊 Excel")
+                                t2_metrics = gr.Markdown()
+
+        # ── Wire events ───────────────────────────────────────────────────────
+
+        # Auth
+        li_btn.click(fn=do_login,
+                     inputs=[li_user, li_pass, session_state],
+                     outputs=[li_msg, session_state, login_panel, main_portal,
+                              welcome_html, admin_tabs, user_tabs])
+        li_pass.submit(fn=do_login,
+                       inputs=[li_user, li_pass, session_state],
+                       outputs=[li_msg, session_state, login_panel, main_portal,
+                                welcome_html, admin_tabs, user_tabs])
+        rg_btn.click(fn=do_register,
+                     inputs=[rg_user, rg_email, rg_pass, rg_conf,
+                             rg_name, rg_inst, session_state],
+                     outputs=[rg_msg, session_state])
+        logout_btn.click(fn=do_logout,
+                         inputs=[session_state],
+                         outputs=[session_state, login_panel, main_portal,
+                                  welcome_html, admin_tabs, user_tabs])
+
+        # Admin
+        dash_btn.click(fn=admin_get_stats, inputs=[session_state], outputs=[dash_out])
+        refresh_users_btn.click(fn=admin_get_users, inputs=[session_state], outputs=[users_table])
+        btn_activate.click(fn=lambda u,s: admin_toggle(u,True,s),
+                           inputs=[action_uid,session_state], outputs=[action_msg,users_table])
+        btn_deactivate.click(fn=lambda u,s: admin_toggle(u,False,s),
+                             inputs=[action_uid,session_state], outputs=[action_msg,users_table])
+        btn_set_role.click(fn=admin_change_role,
+                           inputs=[action_uid,action_role,session_state],
+                           outputs=[action_msg,users_table])
+        btn_del_user.click(fn=admin_delete,
+                           inputs=[action_uid,session_state], outputs=[action_msg,users_table])
+        refresh_log_btn.click(fn=admin_get_log, inputs=[session_state], outputs=[log_table])
+
+        # Tab 1 — Generate
+        t1_btn.click(fn=handle_generate,
+                     inputs=[t1_topic, t1_num, t1_blooms, t1_diff,
+                             t1_word, t1_pdf, t1_excel, session_state],
+                     outputs=[t1_preview, t1_w, t1_p, t1_e, t1_metrics])
+
+        # Tab 2 — Parse then Clone (two separate buttons)
+        t2_preview_btn.click(fn=handle_upload_preview,
+                             inputs=[t2_file, t2_paste, session_state],
+                             outputs=[t2_preview, session_state])
+        t2_clone_btn.click(fn=handle_clone,
+                           inputs=[t2_clones, t2_blooms, t2_word, t2_pdf,
+                                   t2_excel, t2_title, session_state],
+                           outputs=[t2_preview, t2_w, t2_p, t2_e, t2_metrics])
+
+    return demo
+
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)

auth.py

@@ -0,0 +1,190 @@
+"""
+EduClone AI — Authentication & User Management
+SQLite WAL mode, bcrypt passwords, roles: admin / user
+"""
+import sqlite3, bcrypt, datetime, os, re, threading
+
+DB_PATH = os.environ.get("EDUCLONE_DB", "educlone_users.db")
+ADMIN_USERNAME = "admin"
+ADMIN_EMAIL    = "admin@educlone.ai"
+ADMIN_PASSWORD = "admin123"
+
+_lock = threading.Lock()
+
+def _conn():
+    """Return a fresh connection each call — WAL so reads never block."""
+    c = sqlite3.connect(DB_PATH, timeout=30)
+    c.row_factory  = sqlite3.Row
+    c.execute("PRAGMA journal_mode=WAL")
+    c.execute("PRAGMA busy_timeout=10000")
+    return c
+
+def init_db():
+    with _lock:
+        c = _conn()
+        c.execute("""CREATE TABLE IF NOT EXISTS users (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            username      TEXT UNIQUE NOT NULL,
+            email         TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
+            role          TEXT NOT NULL DEFAULT 'user',
+            full_name     TEXT DEFAULT '',
+            institution   TEXT DEFAULT '',
+            is_approved   INTEGER DEFAULT 1,
+            is_active     INTEGER DEFAULT 1,
+            created_at    TEXT NOT NULL,
+            last_login    TEXT)""")
+        c.execute("""CREATE TABLE IF NOT EXISTS activity_log (
+            id        INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id   INTEGER,
+            username  TEXT,
+            action    TEXT,
+            detail    TEXT,
+            timestamp TEXT)""")
+        # seed admin
+        if not c.execute("SELECT id FROM users WHERE username=?",
+                         (ADMIN_USERNAME,)).fetchone():
+            ph = bcrypt.hashpw(ADMIN_PASSWORD.encode(), bcrypt.gensalt()).decode()
+            c.execute("""INSERT INTO users
+                (username,email,password_hash,role,full_name,institution,is_approved,created_at)
+                VALUES(?,?,?,?,?,?,?,?)""",
+                (ADMIN_USERNAME, ADMIN_EMAIL, ph, "admin",
+                 "Abdulqayyum MBA", "EduClone AI", 1,
+                 datetime.datetime.now().isoformat()))
+        c.commit(); c.close()
+
+def _valid_email(e): return bool(re.match(r'^[^@\s]+@[^@\s]+\.[^@\s]+$', e))
+def _valid_user(u):  return bool(re.match(r'^[a-zA-Z0-9_]{3,30}$', u))
+def _valid_pass(p):  return len(p)>=8 and re.search(r'[A-Z]',p) and re.search(r'[0-9]',p)
+
+def register_user(username, email, password, full_name="", institution=""):
+    username = username.strip().lower(); email = email.strip().lower()
+    if not _valid_user(username): return False,"Username: 3–30 chars, letters/numbers/underscore only."
+    if not _valid_email(email):   return False,"Please enter a valid email address."
+    if not _valid_pass(password): return False,"Password: 8+ chars, 1 uppercase, 1 number."
+    with _lock:
+        c = _conn()
+        try:
+            if c.execute("SELECT id FROM users WHERE username=?",(username,)).fetchone():
+                return False,"Username already taken."
+            if c.execute("SELECT id FROM users WHERE email=?",(email,)).fetchone():
+                return False,"Email already registered."
+            ph = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+            c.execute("""INSERT INTO users
+                (username,email,password_hash,role,full_name,institution,is_approved,created_at)
+                VALUES(?,?,?,?,?,?,?,?)""",
+                (username,email,ph,"user",full_name.strip(),institution.strip(),1,
+                 datetime.datetime.now().isoformat()))
+            c.commit()
+            return True, f"✅ Account created! Welcome, {username}. You can now log in."
+        except Exception as ex:
+            return False, f"Registration error: {ex}"
+        finally:
+            c.close()
+
+def login_user(username, password):
+    username = username.strip().lower()
+    with _lock:
+        c = _conn()
+        try:
+            row = c.execute(
+                "SELECT * FROM users WHERE username=? OR email=?",
+                (username, username)).fetchone()
+            if not row:
+                return False, "❌ Username or password incorrect.", None
+            if not row["is_active"]:
+                return False, "❌ Account deactivated. Contact admin.", None
+            if not bcrypt.checkpw(password.encode(), row["password_hash"].encode()):
+                return False, "❌ Username or password incorrect.", None
+            c.execute("UPDATE users SET last_login=? WHERE id=?",
+                      (datetime.datetime.now().isoformat(), row["id"]))
+            c.commit()
+            user = {k: row[k] for k in row.keys() if k != "password_hash"}
+            return True, f"✅ Welcome back, {row['full_name'] or row['username']}!", user
+        except Exception as ex:
+            return False, f"Login error: {ex}", None
+        finally:
+            c.close()
+
+def log_activity(user_id, username, action, detail=""):
+    with _lock:
+        c = _conn()
+        try:
+            c.execute("""INSERT INTO activity_log(user_id,username,action,detail,timestamp)
+                         VALUES(?,?,?,?,?)""",
+                      (user_id, username, action, detail, datetime.datetime.now().isoformat()))
+            c.commit()
+        finally:
+            c.close()
+
+def get_all_users():
+    with _lock:
+        c = _conn()
+        try:
+            rows = c.execute("""SELECT id,username,email,role,full_name,institution,
+                                       is_approved,is_active,created_at,last_login
+                                FROM users ORDER BY created_at DESC""").fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            c.close()
+
+def toggle_user_active(user_id, active):
+    with _lock:
+        c = _conn()
+        try:
+            c.execute("UPDATE users SET is_active=? WHERE id=?", (1 if active else 0, user_id))
+            c.commit()
+            return "✅ User status updated."
+        finally:
+            c.close()
+
+def change_user_role(user_id, role):
+    if role not in ("admin","user"): return "❌ Invalid role."
+    with _lock:
+        c = _conn()
+        try:
+            c.execute("UPDATE users SET role=? WHERE id=?", (role, user_id))
+            c.commit()
+            return f"✅ Role updated to {role}."
+        finally:
+            c.close()
+
+def delete_user(user_id):
+    with _lock:
+        c = _conn()
+        try:
+            c.execute("DELETE FROM users WHERE id=? AND role != 'admin'", (user_id,))
+            c.commit()
+            return "✅ User deleted."
+        finally:
+            c.close()
+
+def get_activity_log(limit=200):
+    with _lock:
+        c = _conn()
+        try:
+            rows = c.execute(
+                "SELECT * FROM activity_log ORDER BY timestamp DESC LIMIT ?",
+                (limit,)).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            c.close()
+
+def get_stats():
+    with _lock:
+        c = _conn()
+        try:
+            today = datetime.date.today().isoformat()
+            return {
+                "total":        c.execute("SELECT COUNT(*) FROM users").fetchone()[0],
+                "admins":       c.execute("SELECT COUNT(*) FROM users WHERE role='admin'").fetchone()[0],
+                "active":       c.execute("SELECT COUNT(*) FROM users WHERE is_active=1").fetchone()[0],
+                "new_today":    c.execute("SELECT COUNT(*) FROM users WHERE created_at LIKE ?",
+                                         (today+"%",)).fetchone()[0],
+                "logins_today": c.execute("SELECT COUNT(*) FROM activity_log WHERE action='login' AND timestamp LIKE ?",
+                                         (today+"%",)).fetchone()[0],
+            }
+        finally:
+            c.close()
+
+init_db()

mcq_engine.py

@@ -0,0 +1,982 @@
+"""
+EduClone AI — MCQ Engine v7
+Gemini 2.5 Flash (google-genai SDK) for generation & AI fallback.
+API key via GOOGLE_API_KEY environment variable / HF Space Secret.
+
+Parse cascade (tried in order, first success wins):
+  1. Indent-bullet .docx     question=low-indent bullet, options=high-indent bullet
+  2. Classic prefix .docx    Q1. / A. / B. style
+  3. Flexible plain-text     handles: Q1. Q1- 1. 1- + A. A) A- a. a) a-
+  4. Paragraph-block .docx   question=bold/regular para, options=next 4 short paras
+  5. Any-bullet grouping     groups bullet lists: every 5 consecutive bullets = 1Q+4opts
+  6. Gemini AI fallback      semantic extraction when all structural parsers fail
+
+Answer detection (all parsers):
+  bold / underline / colour / highlight run  →  letter from formatting
+  "Answer: X" / "Key: X" explicit line       →  letter from text
+  Nothing                                    →  None (never guessed)
+"""
+
+import os, re, tempfile, datetime, json
+import openpyxl
+from openpyxl.styles import Font, PatternFill, Alignment
+from openpyxl.utils import get_column_letter
+from docx import Document as DocxDocument
+from docx.shared import Pt, RGBColor, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.colors import HexColor, black, white
+from reportlab.lib.units import cm
+from reportlab.platypus import (SimpleDocTemplate, Paragraph, Spacer,
+    HRFlowable, PageBreak, Table, TableStyle, KeepTogether)
+from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+
+try:
+    import pdfplumber; HAS_PDF = True
+except ImportError:
+    HAS_PDF = False
+
+DARK_BLUE = HexColor("#1e3a5f"); BLUE = HexColor("#1a56db")
+GREEN     = HexColor("#059669"); GRAY = HexColor("#6b7280")
+YELLOW_BG = HexColor("#fef9c3")
+
+# ── Gemini client (lazy init) ─────────────────────────────────────────────────
+_gemini_client = None
+
+def _get_gemini():
+    global _gemini_client
+    if _gemini_client is not None:
+        return _gemini_client
+    api_key = os.environ.get("GOOGLE_API_KEY", "")
+    if not api_key:
+        return None
+    try:
+        from google import genai
+        _gemini_client = genai.Client(api_key=api_key)
+        return _gemini_client
+    except Exception:
+        return None
+
+GEMINI_MODEL = "gemini-2.5-flash"
+
+def _gemini_call(prompt: str, max_tokens: int = 1200) -> str:
+    """Single Gemini call. Returns text or empty string on failure."""
+    client = _get_gemini()
+    if client is None:
+        return ""
+    try:
+        from google.genai import types
+        response = client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                max_output_tokens=max_tokens,
+                temperature=0.7,
+            ),
+        )
+        return response.text.strip() if response.text else ""
+    except Exception:
+        return ""
+
+def _gemini_available() -> bool:
+    return bool(os.environ.get("GOOGLE_API_KEY", ""))
+
+# ── Bloom's ───────────────────────────────────────────────────────────────────
+BLOOMS = {
+    "Mixed (All)": "Use a variety of cognitive levels.",
+    "Remember":    "Use verbs: recall, identify, list, name, define.",
+    "Understand":  "Use verbs: explain, describe, summarise, classify.",
+    "Apply":       "Use verbs: use, solve, demonstrate, apply.",
+    "Analyse":     "Use verbs: compare, contrast, distinguish, examine.",
+    "Evaluate":    "Use verbs: judge, assess, critique, justify.",
+    "Create":      "Use verbs: design, construct, formulate, propose.",
+}
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  GEMINI AI EXTRACTION (fallback for unparseable documents)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _gemini_extract_mcqs(raw_text: str) -> list:
+    """Gemini semantic extraction — last resort when all structural parsers fail."""
+    if not raw_text.strip() or not _gemini_available():
+        return []
+    chunk = raw_text[:6000]
+    prompt = (
+        "Extract all MCQs from the text below.\n"
+        "Return ONLY a valid JSON array with no markdown, no explanation, no preamble.\n"
+        "Each element: {\"question\":\"...\",\"A\":\"...\",\"B\":\"...\",\"C\":\"...\",\"D\":\"...\",\"answer\":null}\n"
+        "Set answer to the letter (A/B/C/D) only if clearly indicated in the source text.\n\n"
+        f"TEXT:\n{chunk}"
+    )
+    raw = _gemini_call(prompt, max_tokens=2000)
+    if not raw:
+        return []
+    # Strip markdown fences if present
+    raw = re.sub(r'^```(?:json)?\s*', '', raw.strip())
+    raw = re.sub(r'\s*```$', '', raw.strip())
+    m = re.search(r'\[.*\]', raw, re.DOTALL)
+    if not m:
+        return []
+    try:
+        items = json.loads(m.group())
+        result = []
+        for i, item in enumerate(items):
+            if not isinstance(item, dict) or not item.get("question"):
+                continue
+            result.append({
+                "number": i + 1,
+                "question": str(item.get("question", "")).strip(),
+                "A": str(item.get("A", "")).strip(),
+                "B": str(item.get("B", "")).strip(),
+                "C": str(item.get("C", "")).strip(),
+                "D": str(item.get("D", "")).strip(),
+                "answer": item.get("answer") or None,
+                "explanation": "", "blooms": "", "source": "gemini_ai",
+            })
+        return result
+    except Exception:
+        return []
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  FORMATTING HELPERS (for .docx run-level answer detection)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _run_is_bold(r):      return bool(r.bold)
+def _run_is_underline(r): return bool(r.underline)
+
+def _run_has_colour(r):
+    try:
+        c = r.font.color
+        if c.type is None: return False
+        rgb = c.rgb
+        if rgb is None: return False
+        rv, gv, bv = (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF
+        return not (rv < 50 and gv < 50 and bv < 50)
+    except Exception:
+        return False
+
+def _run_has_highlight(r):
+    try:
+        rPr = r._r.find(qn('w:rPr'))
+        if rPr is None: return False
+        return rPr.find(qn('w:highlight')) is not None
+    except Exception:
+        return False
+
+def _para_has_answer_fmt(para) -> bool:
+    runs = para.runs
+    if not runs: return False
+    total = sum(len(r.text.strip()) for r in runs)
+    if total == 0: return False
+    bold = sum(len(r.text.strip()) for r in runs if _run_is_bold(r))
+    ul   = sum(len(r.text.strip()) for r in runs if _run_is_underline(r))
+    col  = sum(len(r.text.strip()) for r in runs if _run_has_colour(r))
+    hl   = sum(len(r.text.strip()) for r in runs if _run_has_highlight(r))
+    return any(x / total >= 0.6 for x in [bold, ul, col, hl])
+
+_ANSWER_KEY_RE = re.compile(
+    r'(?:^|\n)\s*(?:answer|key|correct|ans)\s*[:.\)]\s*([A-Da-d])\b',
+    re.IGNORECASE)
+
+def _answer_from_text(txt: str):
+    m = _ANSWER_KEY_RE.search(txt)
+    return m.group(1).upper() if m else None
+
+_OPT_FLEX = re.compile(
+    r'^[ \t]*(?:\(([A-Da-d])\)|([A-Da-d])[.\)\-][ \t]|([a-d])[.\)\-][ \t])',
+    re.MULTILINE | re.IGNORECASE)
+
+_Q_FLEX = re.compile(
+    r'(?m)^[ \t]*(?:Q(?:uestion\s*)?)?(\d+)[.\)\-][ \t]')
+
+_SKIP_RE = re.compile(
+    r'^(Page\s+\d|\d+\s+of\s+\d|Assessment Unit|COAMS|Riyadh|EduClone|http)',
+    re.IGNORECASE)
+
+def _para_indent(p) -> int:
+    ind = p.paragraph_format.left_indent
+    return int(ind) if ind else 0
+
+def _para_is_list(p) -> bool:
+    pPr = p._p.find(qn('w:pPr'))
+    if pPr is None: return False
+    return pPr.find(qn('w:numPr')) is not None
+
+def _make_mcq(number, question, opts_text, opts_para, extra_text="", source=""):
+    answer = None
+    if opts_para:
+        for letter, para in zip("ABCD", opts_para):
+            if para and _para_has_answer_fmt(para):
+                answer = letter
+                break
+    if answer is None and extra_text:
+        answer = _answer_from_text(extra_text)
+    opts = list(opts_text) + [""] * 4
+    return {
+        "number": number, "question": question.strip(),
+        "A": opts[0], "B": opts[1], "C": opts[2], "D": opts[3],
+        "answer": answer, "explanation": "", "blooms": "", "source": source,
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PARSER 1 — INDENT-BULLET .docx
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _parse_indent_bullet(doc) -> list:
+    items = []
+    for p in doc.paragraphs:
+        txt = p.text.strip()
+        if not txt or _SKIP_RE.match(txt): continue
+        if _para_is_list(p):
+            items.append((p, txt, _para_indent(p)))
+    if len(items) < 3: return []
+    indents = sorted(set(x[2] for x in items))
+    if len(indents) < 2: return []
+    gap_idx = max(range(len(indents)-1), key=lambda i: indents[i+1]-indents[i])
+    q_set = set(indents[:gap_idx+1])
+    o_set = set(indents[gap_idx+1:])
+    mcqs, cur_q, cur_opts, cur_paras = [], None, [], []
+
+    def flush():
+        if cur_q and len(cur_opts) >= 2:
+            mcqs.append(_make_mcq(len(mcqs)+1, cur_q, cur_opts, cur_paras,
+                                  source="indent_bullets"))
+
+    for para, txt, indent in items:
+        if indent in q_set:
+            flush(); cur_q = txt; cur_opts = []; cur_paras = []
+        elif indent in o_set and cur_q:
+            cur_opts.append(txt); cur_paras.append(para)
+
+    flush()
+    return mcqs
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PARSER 2 — CLASSIC Q#. / A. PREFIX .docx
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _parse_classic_prefix(doc) -> list:
+    paras = doc.paragraphs
+    mcqs = []; i = 0
+    while i < len(paras):
+        txt = paras[i].text.strip()
+        qm  = re.match(r'^(?:Q(?:uestion\s*)?)?(\d+)[.\)]\s+(.+)', txt, re.IGNORECASE)
+        if not qm: i += 1; continue
+        q_num = int(qm.group(1))
+        q_lines = [qm.group(2).strip()]
+        i += 1
+        while i < len(paras):
+            t = paras[i].text.strip()
+            if _OPT_FLEX.match(t): break
+            if _Q_FLEX.match(t): break
+            if t: q_lines.append(t)
+            i += 1
+        opts_text = []; opts_para = []; answer = None
+        while i < len(paras) and len(opts_text) < 4:
+            t  = paras[i].text.strip()
+            om = _OPT_FLEX.match(t)
+            if not om: break
+            letter = (om.group(1) or om.group(2) or om.group(3) or "").upper()
+            if letter not in "ABCD": i += 1; continue
+            opts_text.append(t[om.end():].strip())
+            opts_para.append(paras[i]); i += 1
+        for _ in range(3):
+            if i >= len(paras): break
+            t = paras[i].text.strip()
+            if _Q_FLEX.match(t): break
+            a = _answer_from_text(t)
+            if a: answer = a; i += 1; break
+            i += 1
+        if answer is None:
+            for ltr, para in zip("ABCD", opts_para):
+                if _para_has_answer_fmt(para): answer = ltr; break
+        if q_lines and opts_text:
+            q = _make_mcq(q_num, "\n".join(q_lines), opts_text, opts_para,
+                          source="classic_prefix")
+            q["answer"] = answer
+            mcqs.append(q)
+    return mcqs
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PARSER 3 — FLEXIBLE PLAIN TEXT
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _parse_plain(raw: str) -> list:
+    return _parse_flexible_text(raw)
+
+def _parse_flexible_text(raw: str) -> list:
+    mcqs = []
+    splits = list(_Q_FLEX.finditer(raw))
+    if not splits: return []
+
+    for idx, sm in enumerate(splits):
+        block = raw[sm.start(): splits[idx+1].start() if idx+1 < len(splits) else len(raw)]
+        q_num = int(sm.group(1))
+        local_m = _Q_FLEX.match(block)
+        rest  = block[local_m.end():].strip() if local_m else block[sm.end()-sm.start():].strip()
+        opts_iter = list(_OPT_FLEX.finditer(rest))
+        if not opts_iter: continue
+        q_body = rest[:opts_iter[0].start()].strip()
+        opts_text = []
+        for j, om in enumerate(opts_iter[:4]):
+            end = opts_iter[j+1].start() if j+1 < len(opts_iter) else len(rest)
+            opt = rest[om.end():end]
+            cut = re.search(r'\n[ \t]*(?:answer|key|correct|explanation)\s*[:.\-]',
+                            opt, re.IGNORECASE)
+            if cut: opt = opt[:cut.start()]
+            opts_text.append(re.sub(r'\s+', ' ', opt.strip()))
+        answer = _answer_from_text(block)
+        if q_body and opts_text:
+            mcqs.append(_make_mcq(q_num, q_body, opts_text, None,
+                                  extra_text=block, source="flexible_text"))
+    return mcqs
+
+
+# ══════════════════════════════════════════════════════════════════════���═══════
+#  PARSER 4 — PARAGRAPH BLOCK .docx
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _para_looks_like_question(txt: str) -> bool:
+    txt = txt.strip()
+    if len(txt) < 20: return False
+    if _SKIP_RE.match(txt): return False
+    if txt.endswith('?'): return True
+    if re.search(r'\b(which|what|how|where|when|who|select|identify|choose)\b',
+                 txt, re.IGNORECASE): return True
+    return False
+
+def _para_looks_like_option(txt: str) -> bool:
+    txt = txt.strip()
+    if not txt or _SKIP_RE.match(txt): return False
+    if _OPT_FLEX.match(txt): return True
+    if len(txt) < 120 and '\n' not in txt: return True
+    return False
+
+def _parse_paragraph_blocks(doc) -> list:
+    paras = [p for p in doc.paragraphs if p.text.strip() and not _SKIP_RE.match(p.text.strip())]
+    mcqs = []; i = 0
+    while i < len(paras):
+        txt = paras[i].text.strip()
+        if not _para_looks_like_question(txt):
+            i += 1; continue
+        opts_text = []; opts_para = []
+        j = i + 1
+        while j < len(paras) and len(opts_text) < 4:
+            ot = paras[j].text.strip()
+            if _para_looks_like_question(ot) and not _OPT_FLEX.match(ot):
+                break
+            if _para_looks_like_option(ot):
+                cleaned = re.sub(r'^[ \t]*(?:\([A-Da-d]\)|[A-Da-d][.\)\-])\s*', '',
+                                 ot, flags=re.IGNORECASE).strip()
+                opts_text.append(cleaned or ot)
+                opts_para.append(paras[j])
+            j += 1
+        if len(opts_text) >= 2:
+            extra = paras[j].text if j < len(paras) else ""
+            mcqs.append(_make_mcq(len(mcqs)+1, txt, opts_text, opts_para,
+                                  extra_text=extra, source="para_blocks"))
+            i = j
+        else:
+            i += 1
+    return mcqs
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PARSER 5 — ANY-BULLET GROUPING
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _parse_any_bullet_groups(doc) -> list:
+    bullets = []
+    for p in doc.paragraphs:
+        txt = p.text.strip()
+        if not txt or _SKIP_RE.match(txt): continue
+        if _para_is_list(p):
+            bullets.append((txt, p))
+    if len(bullets) < 5: return []
+    mcqs = []
+    for i in range(0, len(bullets) - 4, 5):
+        q_txt, _    = bullets[i]
+        opts        = bullets[i+1:i+5]
+        opts_text   = [o[0] for o in opts]
+        opts_para   = [o[1] for o in opts]
+        mcqs.append(_make_mcq(len(mcqs)+1, q_txt, opts_text, opts_para,
+                              source="bullet_groups"))
+    return mcqs
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  MAIN READER
+# ══════════════════════════════════════════════════════════════════════════════
+
+def read_and_parse(file_obj) -> tuple:
+    if not file_obj: return [], ""
+    path = file_obj.name
+    name = path.lower()
+
+    # ── DOCX ─────────────────────────────────────────────────────────────────
+    if name.endswith((".docx", ".doc")):
+        try:
+            doc = DocxDocument(path)
+        except Exception as e:
+            return [], f"❌ Cannot open file: {e}"
+
+        mcqs = _parse_indent_bullet(doc)
+        if mcqs:
+            return mcqs, f"✅ **Indent-bullet format** · {len(mcqs)} questions"
+
+        mcqs = _parse_classic_prefix(doc)
+        if mcqs:
+            return mcqs, f"✅ **Numbered Q#./A. format** · {len(mcqs)} questions"
+
+        raw = "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+        mcqs = _parse_flexible_text(raw)
+        if mcqs:
+            return mcqs, f"✅ **Flexible text format** · {len(mcqs)} questions"
+
+        mcqs = _parse_paragraph_blocks(doc)
+        if mcqs:
+            return mcqs, f"✅ **Paragraph-block format** · {len(mcqs)} questions"
+
+        mcqs = _parse_any_bullet_groups(doc)
+        if mcqs:
+            return mcqs, f"✅ **Bullet-group format** · {len(mcqs)} questions"
+
+        # Gemini AI fallback
+        raw = "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+        if raw.strip():
+            mcqs = _gemini_extract_mcqs(raw)
+            if mcqs:
+                return mcqs, f"⚡ **AI extracted** · {len(mcqs)} questions"
+        return [], ("❌ Could not detect MCQ structure in this file.\n\n"
+                    "Supported .docx formats:\n"
+                    "- Bullet list (questions at one indent, options deeper)\n"
+                    "- Numbered Q1./A./B. prefixes\n"
+                    "- Plain paragraphs where each question is followed by 4 short options")
+
+    # ── PDF ───────────────────────────────────────────────────────────────────
+    elif name.endswith(".pdf"):
+        if not HAS_PDF: return [], "❌ pdfplumber not installed."
+        try:
+            parts = []
+            with pdfplumber.open(path) as pdf:
+                for pg in pdf.pages:
+                    t = pg.extract_text()
+                    if t: parts.append(t)
+            raw = "\n".join(parts)
+        except Exception as e:
+            return [], f"❌ PDF read error: {e}"
+        mcqs = _parse_flexible_text(raw)
+        if mcqs: return mcqs, f"✅ **PDF parsed** · {len(mcqs)} questions"
+        if raw.strip():
+            mcqs = _gemini_extract_mcqs(raw)
+            if mcqs: return mcqs, f"⚡ **AI extracted from PDF** · {len(mcqs)} questions"
+        return [], "❌ Could not detect MCQ structure in PDF."
+
+    # ── TXT ───────────────────────────────────────────────────────────────────
+    else:
+        try:
+            raw = open(path, encoding="utf-8", errors="ignore").read()
+        except Exception as e:
+            return [], f"❌ File read error: {e}"
+        mcqs = _parse_flexible_text(raw)
+        if mcqs: return mcqs, f"✅ **Plain-text parsed** · {len(mcqs)} questions"
+        if raw.strip():
+            mcqs = _gemini_extract_mcqs(raw)
+            if mcqs: return mcqs, f"⚡ **AI extracted** · {len(mcqs)} questions"
+        return [], "❌ Could not detect MCQ structure in text file."
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  TAB 1: GENERATE FROM TOPIC
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _topic_prompt(topic, num_q, blooms, difficulty):
+    bl = BLOOMS.get(blooms, BLOOMS["Mixed (All)"])
+    df = f"Difficulty: {difficulty}." if difficulty != "Mixed" else "Mix of difficulty levels."
+    return (
+        f"You are an academic MCQ author. Generate exactly {num_q} high-quality MCQs about \"{topic}\".\n"
+        f"Bloom's Taxonomy level: {blooms}. {bl}\n"
+        f"{df}\n\n"
+        "Rules:\n"
+        "- Each question must have exactly 4 options: A, B, C, D\n"
+        "- One clearly correct answer\n"
+        "- Three plausible distractors (no trick questions, no obviously wrong options)\n"
+        "- Clear, unambiguous academic language\n"
+        "- No duplicate questions\n\n"
+        "Use EXACTLY this format for every question:\n"
+        "Q1. [question text]\n"
+        "A. [option]\n"
+        "B. [option]\n"
+        "C. [option]\n"
+        "D. [option]\n"
+        "Answer: [A/B/C/D]\n"
+        "Explanation: [one clear sentence]\n\n"
+        f"Generate all {num_q} questions now:"
+    )
+
+def _parse_generated(text):
+    mcqs = []
+    for block in re.split(r'\n(?=Q\d+[\.\)])', text.strip()):
+        q  = re.search(r'Q\d+[\.\)]\s*(.+?)(?:\n|$)', block)
+        a  = re.search(r'^A[.)]\s*(.+?)(?:\n|$)', block, re.MULTILINE)
+        b  = re.search(r'^B[.)]\s*(.+?)(?:\n|$)', block, re.MULTILINE)
+        c  = re.search(r'^C[.)]\s*(.+?)(?:\n|$)', block, re.MULTILINE)
+        d  = re.search(r'^D[.)]\s*(.+?)(?:\n|$)', block, re.MULTILINE)
+        an = re.search(r'Answer:\s*([A-Da-d])', block, re.IGNORECASE)
+        ex = re.search(r'Explanation:\s*(.+?)(?:\n|$)', block)
+        if q and a and b and c and d and an:
+            mcqs.append({
+                "question": q.group(1).strip(),
+                "A": a.group(1).strip(), "B": b.group(1).strip(),
+                "C": c.group(1).strip(), "D": d.group(1).strip(),
+                "answer": an.group(1).upper(),
+                "explanation": ex.group(1).strip() if ex else "",
+                "blooms": "",
+            })
+    return mcqs
+
+def _fallback_mcqs(topic, num_q, blooms):
+    pool = [
+        {"question": f"Which statement BEST defines {topic}?",
+         "A": f"The core concept of {topic}", "B": "An unrelated concept",
+         "C": f"A partial aspect of {topic}", "D": "A common misconception",
+         "answer": "A", "blooms": "Remember",
+         "explanation": f"Option A correctly captures the essential definition of {topic}."},
+        {"question": f"How would you BEST explain {topic} in your own words?",
+         "A": "It is purely theoretical", "B": f"It describes core principles of {topic}",
+         "C": "It replaces all prior knowledge", "D": "It contradicts current research",
+         "answer": "B", "blooms": "Understand",
+         "explanation": "Explaining in your own words demonstrates understanding."},
+        {"question": f"A practitioner applies {topic}. What is MOST appropriate?",
+         "A": "Ignore contextual factors", "B": f"Apply structured methods from {topic}",
+         "C": "Rely on guesswork", "D": "Avoid established frameworks",
+         "answer": "B", "blooms": "Apply",
+         "explanation": "Applying domain knowledge systematically is correct."},
+        {"question": f"What is the KEY distinction of {topic} vs related concepts?",
+         "A": "They are identical", "B": f"{topic} has no practical dimension",
+         "C": f"{topic} has a distinct focus", "D": "No comparison exists",
+         "answer": "C", "blooms": "Analyse",
+         "explanation": "Identifying distinctions is an Analyse-level skill."},
+        {"question": f"What is the MOST significant limitation of {topic}?",
+         "A": "No limitations", "B": "Perfect for every situation",
+         "C": "Scope constrained by context", "D": "All practitioners agree it is irrelevant",
+         "answer": "C", "blooms": "Evaluate",
+         "explanation": "Judging limitations is Evaluate-level thinking."},
+        {"question": f"Design a framework integrating {topic}.",
+         "A": "Copy existing solution", "B": f"Develop original approach using {topic}",
+         "C": "Avoid established knowledge", "D": "Restrict to single stakeholder",
+         "answer": "B", "blooms": "Create",
+         "explanation": "Designing a new framework is Create-level thinking."},
+        {"question": f"Which resource BEST supports learning {topic}?",
+         "A": "Opinion blogs", "B": f"Peer-reviewed literature on {topic}",
+         "C": "Outdated manuals", "D": "Unrelated textbook",
+         "answer": "B", "blooms": "Evaluate",
+         "explanation": "Peer-reviewed sources are the gold standard."},
+        {"question": f"Which outcome occurs when {topic} is correctly applied?",
+         "A": "Increased confusion", "B": "No measurable impact",
+         "C": "Improved measurable results", "D": "Reduced accuracy",
+         "answer": "C", "blooms": "Apply",
+         "explanation": "Correct implementation yields measurable improvement."},
+        {"question": f"A student studying {topic} PRIMARILY focuses on?",
+         "A": "Unrelated procedures", "B": f"Core principles of {topic}",
+         "C": "Abstract mathematics", "D": "Historical unrelated events",
+         "answer": "B", "blooms": "Remember",
+         "explanation": f"Core principles are the foundation of {topic}."},
+        {"question": f"Which approach gives DEEPEST understanding of {topic}?",
+         "A": "Rote memorisation", "B": "Avoiding practical examples",
+         "C": "Combining theory with practice", "D": "Textbook theory only",
+         "answer": "C", "blooms": "Understand",
+         "explanation": "Combining theory and practice is most effective."},
+    ]
+    if blooms != "Mixed (All)":
+        matched = [p for p in pool if p.get("blooms") == blooms]
+        pool = (matched * 4 + [p for p in pool if p.get("blooms") != blooms])
+    out = []
+    for i, p in enumerate(pool[:min(num_q, len(pool))]):
+        p = dict(p); p["number"] = i + 1; out.append(p)
+    return out
+
+def generate_from_topic(topic, num_q, blooms="Mixed (All)", difficulty="Mixed"):
+    if not topic.strip(): return [], "no_topic"
+    if not _gemini_available():
+        mcqs = _fallback_mcqs(topic, int(num_q), blooms)
+        return mcqs, "template"
+    raw  = _gemini_call(_topic_prompt(topic.strip(), int(num_q), blooms, difficulty),
+                        max_tokens=1500)
+    mcqs = _parse_generated(raw) if raw else []
+    if not mcqs:
+        mcqs = _fallback_mcqs(topic, int(num_q), blooms)
+        source = "template"
+    else:
+        for i, m in enumerate(mcqs[:int(num_q)]): m["number"] = i + 1
+        mcqs = mcqs[:int(num_q)]
+        source = "ai"
+    return mcqs, source
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  CLONER — batch Gemini call for efficiency
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _clone_prompt_batch(originals, num_clones, blooms):
+    bl  = BLOOMS.get(blooms, BLOOMS["Mixed (All)"])
+    lines = [
+        f"You are an academic MCQ author. For each original question below, generate {num_clones} clone(s).",
+        f"Bloom's level: {blooms}. {bl}",
+        "Rules:",
+        "- Each clone must test the same concept with different wording",
+        "- Do NOT copy or paraphrase trivially — genuinely rewrite",
+        "- Keep 4 options (A B C D), one correct answer, three plausible distractors",
+        "- Preserve the correct answer letter where it is known",
+        "- Return ONLY a JSON array. No markdown, no explanation.",
+        "",
+        "JSON format (repeat for every clone):",
+        '[{"original_number":1,"clone_num":1,"question":"...","A":"...","B":"...","C":"...","D":"...","answer":"A","explanation":"..."}]',
+        "",
+        "ORIGINAL QUESTIONS:",
+    ]
+    for orig in originals:
+        ans = orig.get("answer") or "unknown"
+        lines.append(
+            f'Q{orig.get("number","?")}. {orig["question"]}\n'
+            f'A. {orig.get("A","")}  B. {orig.get("B","")}  '
+            f'C. {orig.get("C","")}  D. {orig.get("D","")}\n'
+            f'Answer: {ans}\n'
+        )
+    lines.append("\nGenerate all clones now:")
+    return "\n".join(lines)
+
+def _fallback_clone(orig, n):
+    pfx = ["Considering the scenario above,",
+           "In the clinical context described,",
+           "Based on the information provided,",
+           "From best-practice perspective,"][n % 4]
+    q = orig["question"]
+    return {"number": orig.get("number", 1),
+            "question": f"{pfx} {q[0].lower()+q[1:]}" if q else q,
+            "A": orig["A"], "B": orig["B"], "C": orig["C"], "D": orig["D"],
+            "answer": orig.get("answer"), "explanation": "Rephrased clone.",
+            "blooms": "", "source": "clone_fallback"}
+
+def clone_mcqs(originals, num_clones, blooms="Mixed (All)"):
+    if not originals: return []
+
+    # Use Gemini batch call if available
+    if _gemini_available():
+        prompt = _clone_prompt_batch(originals, int(num_clones), blooms)
+        raw = _gemini_call(prompt, max_tokens=min(4000, len(originals) * num_clones * 200 + 500))
+        if raw:
+            raw = re.sub(r'^```(?:json)?\s*', '', raw.strip())
+            raw = re.sub(r'\s*```$', '', raw.strip())
+            m = re.search(r'\[.*\]', raw, re.DOTALL)
+            if m:
+                try:
+                    items = json.loads(m.group())
+                    results = []
+                    for item in items:
+                        if not isinstance(item, dict) or not item.get("question"):
+                            continue
+                        orig_num = item.get("original_number", 1)
+                        orig = next((o for o in originals if o.get("number") == orig_num), originals[0])
+                        clone = {
+                            "number": orig_num,
+                            "question": str(item.get("question", "")).strip(),
+                            "A": str(item.get("A", "")).strip(),
+                            "B": str(item.get("B", "")).strip(),
+                            "C": str(item.get("C", "")).strip(),
+                            "D": str(item.get("D", "")).strip(),
+                            "answer": item.get("answer") or orig.get("answer"),
+                            "explanation": str(item.get("explanation", "")).strip(),
+                            "blooms": blooms,
+                            "source": "gemini_clone",
+                            "clone_num": item.get("clone_num", 1),
+                            "original_question": orig["question"],
+                        }
+                        results.append(clone)
+                    if results:
+                        return results
+                except Exception:
+                    pass
+
+    # Fallback: simple rephrasing without API
+    results = []
+    for orig in originals:
+        for c in range(int(num_clones)):
+            clone = _fallback_clone(orig, c)
+            clone.update({"original_question": orig["question"],
+                          "clone_num": c + 1, "number": orig.get("number", 1)})
+            results.append(clone)
+    return results
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PREVIEW
+# ══════════════════════════════════════════════════════════════════════════════
+
+def preview_mcqs(mcqs, title=""):
+    if not mcqs: return "No questions found."
+    lines = [f"### {title}\n"] if title else []
+    lines.append(f"✅ **{len(mcqs)} question(s)**\n")
+    for m in mcqs:
+        answer = m.get("answer"); q_num = m.get("number", "?")
+        bl = f" *[{m['blooms']}]*" if m.get("blooms") else ""
+        orig = m.get("original_question")
+        if orig:
+            lines.append(f"---\n**Original:** {orig}")
+            lines.append(f"**Clone {m.get('clone_num',1)}:{bl}** {m['question']}\n")
+        else:
+            lines.append(f"---\n**Q{q_num}.{bl}** {m['question']}\n")
+        for L in "ABCD":
+            opt = m.get(L, "")
+            if not opt: continue
+            lines.append(f"**{L}.** {opt}  ✅ **← CORRECT**" if answer and L == answer
+                         else f"**{L}.** {opt}")
+        if not answer: lines.append("⚠️ *Answer not detected*")
+        if m.get("explanation"): lines.append(f"\n💡 *{m['explanation']}*")
+        lines.append("")
+    return "\n".join(lines)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  EXPORTS — Word / PDF / Excel (unchanged)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _sc(cell, hx):
+    tc=cell._tc; p=tc.get_or_add_tcPr(); s=OxmlElement('w:shd')
+    s.set(qn('w:val'),'clear'); s.set(qn('w:color'),'auto')
+    s.set(qn('w:fill'), hx.lstrip('#')); p.append(s)
+
+def _hl(run, color='yellow'):
+    rPr=run._r.get_or_add_rPr(); hl=OxmlElement('w:highlight')
+    hl.set(qn('w:val'), color); rPr.append(hl)
+
+def make_word(mcqs, title):
+    doc = DocxDocument()
+    for sec in doc.sections:
+        sec.top_margin=Inches(1); sec.bottom_margin=Inches(1)
+        sec.left_margin=Inches(1.2); sec.right_margin=Inches(1)
+    hp=doc.sections[0].header.paragraphs[0]
+    hp.text=f"EduClone AI  ·  {title}  ·  Abdulqayyum MBA"; hp.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    for r in hp.runs: r.font.size=Pt(9); r.font.color.rgb=RGBColor(0x6b,0x72,0x80)
+    tp=doc.add_heading(title,level=0); tp.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    for r in tp.runs: r.font.color.rgb=RGBColor(0x1a,0x56,0xdb); r.font.size=Pt(20)
+    sub=doc.add_paragraph(); sub.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    sr=sub.add_run(f"Total: {len(mcqs)} Questions  ·  {datetime.date.today():%d %B %Y}  ·  EduClone AI")
+    sr.font.size=Pt(10); sr.italic=True; sr.font.color.rgb=RGBColor(0x6b,0x72,0x80)
+    doc.add_paragraph()
+    h1=doc.add_heading("EXAMINATION PAPER",level=1)
+    for r in h1.runs: r.font.color.rgb=RGBColor(0x1e,0x3a,0x5f)
+    ip=doc.add_paragraph("Instructions: Choose the BEST answer.")
+    ip.runs[0].italic=True; ip.runs[0].font.size=Pt(10)
+    doc.add_paragraph()
+    for m in mcqs:
+        qp=doc.add_paragraph(); qp.paragraph_format.space_before=Pt(12)
+        qr=qp.add_run(f"Q{m.get('number','')}.  ")
+        qr.bold=True; qr.font.size=Pt(12); qr.font.color.rgb=RGBColor(0x1a,0x56,0xdb)
+        if m.get("blooms"):
+            qp.add_run(f"[{m['blooms']}] ").font.color.rgb=RGBColor(0x93,0xc5,0xfd)
+        for i,line in enumerate(m["question"].split("\n")):
+            if not line.strip(): continue
+            if i>0: qp.add_run().add_break()
+            tr=qp.add_run(line.strip()); tr.bold=True; tr.font.size=Pt(12)
+        for L in "ABCD":
+            opt=m.get(L,"")
+            if not opt: continue
+            op=doc.add_paragraph(); op.paragraph_format.left_indent=Inches(0.45)
+            op.paragraph_format.space_before=Pt(3)
+            lr=op.add_run(f"{L}."); lr.bold=True; lr.font.size=Pt(11)
+            lr.font.color.rgb=RGBColor(0x1e,0x3a,0x5f)
+            op.add_run(f"  {opt}").font.size=Pt(11)
+        doc.add_paragraph()
+    has_answers=any(m.get("answer") for m in mcqs)
+    if has_answers:
+        doc.add_page_break()
+        h2=doc.add_heading("ANSWER KEY & EXPLANATIONS",level=1)
+        for r in h2.runs: r.font.color.rgb=RGBColor(0x05,0x96,0x69)
+        doc.add_paragraph("✓ Correct answers highlighted. ⚠️ = not detected.").runs[0].italic=True
+        doc.add_paragraph()
+        for m in mcqs:
+            answer=m.get("answer")
+            qp=doc.add_paragraph(); qp.paragraph_format.space_before=Pt(12)
+            qr=qp.add_run(f"Q{m.get('number','')}.  ")
+            qr.bold=True; qr.font.size=Pt(12); qr.font.color.rgb=RGBColor(0x1a,0x56,0xdb)
+            for i,line in enumerate(m["question"].split("\n")):
+                if not line.strip(): continue
+                if i>0: qp.add_run().add_break()
+                tr=qp.add_run(line.strip()); tr.bold=True; tr.font.size=Pt(12)
+            for L in "ABCD":
+                opt=m.get(L,"")
+                if not opt: continue
+                op=doc.add_paragraph(); op.paragraph_format.left_indent=Inches(0.45)
+                op.paragraph_format.space_before=Pt(3)
+                if answer and L==answer:
+                    tk=op.add_run("  ✓  "); tk.bold=True; tk.font.size=Pt(11)
+                    tk.font.color.rgb=RGBColor(0x05,0x96,0x69)
+                    lr=op.add_run(f"{L}."); lr.bold=True; lr.font.size=Pt(11)
+                    lr.font.color.rgb=RGBColor(0xd9,0x77,0x06); _hl(lr)
+                    tr=op.add_run(f"  {opt}"); tr.bold=True; tr.font.size=Pt(11)
+                    tr.font.color.rgb=RGBColor(0x05,0x96,0x69); _hl(tr)
+                else:
+                    lr=op.add_run(f"{L}."); lr.bold=True; lr.font.size=Pt(11)
+                    lr.font.color.rgb=RGBColor(0x9c,0xa3,0xaf)
+                    op.add_run(f"  {opt}").font.size=Pt(11)
+            if not answer:
+                wp=doc.add_paragraph(); wp.paragraph_format.left_indent=Inches(0.45)
+                wr=wp.add_run("⚠️  Answer not detected.")
+                wr.font.size=Pt(10); wr.italic=True; wr.font.color.rgb=RGBColor(0xd9,0x77,0x06)
+            if m.get("explanation"):
+                ep=doc.add_paragraph(); ep.paragraph_format.left_indent=Inches(0.45)
+                ep.paragraph_format.space_before=Pt(4)
+                er=ep.add_run(f"💡  {m['explanation']}"); er.font.size=Pt(10)
+                er.italic=True; er.font.color.rgb=RGBColor(0x37,0x41,0x51)
+            doc.add_paragraph()
+    answered=[m for m in mcqs if m.get("answer")]
+    if answered:
+        doc.add_page_break()
+        h3=doc.add_heading("QUICK ANSWER REFERENCE",level=1)
+        for r in h3.runs: r.font.color.rgb=RGBColor(0x1a,0x56,0xdb)
+        COLS=5; nr=-(-len(answered)//COLS)
+        tbl=doc.add_table(rows=nr+1,cols=COLS*2); tbl.style="Table Grid"
+        for ci in range(COLS*2):
+            cell=tbl.rows[0].cells[ci]; cell.text="Q #" if ci%2==0 else "Ans"
+            for r in cell.paragraphs[0].runs:
+                r.bold=True; r.font.size=Pt(10); r.font.color.rgb=RGBColor(0xFF,0xFF,0xFF)
+            _sc(cell,"#1a56db")
+        for qi,m in enumerate(answered):
+            ri=qi//COLS+1; cb=(qi%COLS)*2
+            qc=tbl.rows[ri].cells[cb]; ac=tbl.rows[ri].cells[cb+1]
+            qc.text=str(m.get("number",qi+1)); ac.text=m["answer"]
+            for r in ac.paragraphs[0].runs:
+                r.bold=True; r.font.color.rgb=RGBColor(0x05,0x96,0x69)
+            _sc(ac,"#f0fdf4")
+    doc.add_paragraph()
+    fp=doc.add_paragraph("EduClone AI  ·  Abdulqayyum MBA  ·  18 yrs Academic Assessment")
+    fp.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    for r in fp.runs: r.font.size=Pt(9); r.italic=True; r.font.color.rgb=RGBColor(0x9c,0xa3,0xaf)
+    path=tempfile.mktemp(suffix=".docx"); doc.save(path); return path
+
+def _pstyles():
+    s=getSampleStyleSheet()
+    s.add(ParagraphStyle("PT",parent=s["Title"],fontSize=20,textColor=DARK_BLUE,alignment=TA_CENTER,fontName="Helvetica-Bold",spaceAfter=4))
+    s.add(ParagraphStyle("PS",parent=s["Normal"],fontSize=10,textColor=GRAY,alignment=TA_CENTER,fontName="Helvetica-Oblique",spaceAfter=14))
+    s.add(ParagraphStyle("PH",parent=s["Normal"],fontSize=13,textColor=DARK_BLUE,fontName="Helvetica-Bold",spaceBefore=12,spaceAfter=8))
+    s.add(ParagraphStyle("PAH",parent=s["Normal"],fontSize=13,textColor=GREEN,fontName="Helvetica-Bold",spaceBefore=12,spaceAfter=8))
+    s.add(ParagraphStyle("PQN",parent=s["Normal"],fontSize=12,textColor=BLUE,fontName="Helvetica-Bold",spaceBefore=10,spaceAfter=2))
+    s.add(ParagraphStyle("PQB",parent=s["Normal"],fontSize=11,textColor=black,fontName="Helvetica-Bold",spaceAfter=3,leading=16,alignment=TA_JUSTIFY))
+    s.add(ParagraphStyle("PO",parent=s["Normal"],fontSize=11,textColor=HexColor("#374151"),leftIndent=18,fontName="Helvetica",spaceAfter=3,leading=15))
+    s.add(ParagraphStyle("POK",parent=s["Normal"],fontSize=11,textColor=GREEN,leftIndent=18,fontName="Helvetica-Bold",spaceAfter=3,leading=15))
+    s.add(ParagraphStyle("PX",parent=s["Normal"],fontSize=10,textColor=HexColor("#374151"),leftIndent=18,fontName="Helvetica-Oblique",spaceBefore=4,spaceAfter=8))
+    s.add(ParagraphStyle("PI",parent=s["Normal"],fontSize=10,textColor=GRAY,fontName="Helvetica-Oblique",spaceAfter=12))
+    s.add(ParagraphStyle("PW",parent=s["Normal"],fontSize=10,textColor=HexColor("#d97706"),leftIndent=18,fontName="Helvetica-Oblique",spaceAfter=8))
+    s.add(ParagraphStyle("PF",parent=s["Normal"],fontSize=8.5,textColor=GRAY,alignment=TA_CENTER,fontName="Helvetica-Oblique"))
+    return s
+
+def _pdeco(c,d,title):
+    c.saveState(); w,h=A4
+    c.setFillColor(DARK_BLUE); c.rect(0,h-32,w,32,fill=1,stroke=0)
+    c.setFillColor(white); c.setFont("Helvetica-Bold",9)
+    c.drawString(1.5*cm,h-20,f"EduClone AI  ·  {title}")
+    c.setFont("Helvetica",9)
+    c.drawRightString(w-1.5*cm,h-20,f"Abdulqayyum MBA  ·  {datetime.date.today():%d %b %Y}")
+    c.setFillColor(DARK_BLUE); c.rect(0,0,w,20,fill=1,stroke=0)
+    c.setFillColor(white); c.setFont("Helvetica",8)
+    c.drawCentredString(w/2,6,f"Page {d.page}"); c.restoreState()
+
+def make_pdf(mcqs, title):
+    path=tempfile.mktemp(suffix=".pdf")
+    doc=SimpleDocTemplate(path,pagesize=A4,topMargin=1.8*cm,bottomMargin=1.5*cm,
+                          leftMargin=2*cm,rightMargin=1.8*cm)
+    s=_pstyles(); story=[]; on_p=lambda c,d: _pdeco(c,d,title)
+    story+=[Spacer(1,0.5*cm),Paragraph(title,s["PT"]),
+            Paragraph(f"Questions: {len(mcqs)}  ·  {datetime.date.today():%d %B %Y}  ·  EduClone AI",s["PS"]),
+            HRFlowable(width="100%",thickness=1.5,color=BLUE,spaceAfter=14)]
+    story+=[Paragraph("EXAMINATION PAPER",s["PH"]),
+            Paragraph("Instructions: Choose the BEST answer.",s["PI"]),Spacer(1,0.3*cm)]
+    for m in mcqs:
+        bl=[Paragraph(f"Q{m.get('number','')}.",s["PQN"])]
+        for line in m["question"].split("\n"):
+            if line.strip(): bl.append(Paragraph(line.strip(),s["PQB"]))
+        bl.append(Spacer(1,0.12*cm))
+        for L in "ABCD":
+            opt=m.get(L,"")
+            if opt: bl.append(Paragraph(f"<b>{L}.</b>  {opt}",s["PO"]))
+        bl.append(Spacer(1,0.3*cm)); story.append(KeepTogether(bl))
+    if any(m.get("answer") for m in mcqs):
+        story.append(PageBreak())
+        story+=[Paragraph("ANSWER KEY &amp; EXPLANATIONS",s["PAH"]),
+                Paragraph("✓ Correct = highlighted. ⚠️ = not detected.",s["PI"]),Spacer(1,0.3*cm)]
+        for m in mcqs:
+            answer=m.get("answer")
+            bl=[Paragraph(f"Q{m.get('number','')}.",s["PQN"])]
+            for line in m["question"].split("\n"):
+                if line.strip(): bl.append(Paragraph(line.strip(),s["PQB"]))
+            bl.append(Spacer(1,0.1*cm))
+            for L in "ABCD":
+                opt=m.get(L,"")
+                if not opt: continue
+                if answer and L==answer:
+                    t=Table([[Paragraph(f'<font color="#059669"><b>✓  {L}.  {opt}</b></font>',s["POK"])]],colWidths=["100%"])
+                    t.setStyle(TableStyle([("BACKGROUND",(0,0),(-1,-1),YELLOW_BG),("ROWPADDING",(0,0),(-1,-1),5),("LEFTPADDING",(0,0),(-1,-1),18)]))
+                    bl.append(t)
+                else:
+                    bl.append(Paragraph(f'<font color="#9ca3af"><b>{L}.</b>  {opt}</font>',s["PO"]))
+            if not answer: bl.append(Paragraph("⚠️  Answer not detected.",s["PW"]))
+            if m.get("explanation"): bl.append(Paragraph(f'<i>💡  {m["explanation"]}</i>',s["PX"]))
+            bl.append(Spacer(1,0.28*cm)); story.append(KeepTogether(bl))
+    answered=[m for m in mcqs if m.get("answer")]
+    if answered:
+        story.append(PageBreak()); story.append(Paragraph("QUICK ANSWER REFERENCE",s["PH"])); story.append(Spacer(1,0.3*cm))
+        COLS=5; td=[["Q","Ans"]*COLS]; row=[]
+        for m in answered:
+            row+=[str(m.get("number","?")),m["answer"]]
+            if len(row)==COLS*2: td.append(row); row=[]
+        if row:
+            while len(row)<COLS*2: row+=["",""]
+            td.append(row)
+        rt=Table(td,colWidths=[1.1*cm,1.1*cm]*COLS,hAlign="LEFT")
+        rt.setStyle(TableStyle([
+            ("BACKGROUND",(0,0),(-1,0),DARK_BLUE),("TEXTCOLOR",(0,0),(-1,0),white),
+            ("FONTNAME",(0,0),(-1,0),"Helvetica-Bold"),("FONTSIZE",(0,0),(-1,-1),10),
+            ("ALIGN",(0,0),(-1,-1),"CENTER"),("VALIGN",(0,0),(-1,-1),"MIDDLE"),
+            ("ROWBACKGROUNDS",(0,1),(-1,-1),[HexColor("#f0fdf4"),white]),
+            ("GRID",(0,0),(-1,-1),0.5,HexColor("#d1fae5")),("ROWPADDING",(0,0),(-1,-1),5),
+            *[("TEXTCOLOR",(c,1),(c,-1),GREEN) for c in range(1,COLS*2,2)],
+            *[("FONTNAME",(c,1),(c,-1),"Helvetica-Bold") for c in range(1,COLS*2,2)],
+        ]))
+        story+=[rt,Spacer(1,1*cm),HRFlowable(width="100%",thickness=1,color=BLUE),
+                Paragraph("EduClone AI  ·  Abdulqayyum MBA  ·  18 yrs Academic Assessment",s["PF"])]
+    doc.build(story,onFirstPage=on_p,onLaterPages=on_p); return path
+
+def make_excel(mcqs, title):
+    wb=openpyxl.Workbook(); ws=wb.active; ws.title="MCQs"
+    headers=["#","Question","Option A","Option B","Option C","Option D",
+             "Correct Answer","Bloom's Level","Explanation","Source"]
+    hfill=PatternFill("solid",fgColor="1A56DB"); hfont=Font(bold=True,color="FFFFFF",size=11)
+    for col,h in enumerate(headers,1):
+        c=ws.cell(row=1,column=col,value=h); c.fill=hfill; c.font=hfont
+        c.alignment=Alignment(horizontal="center",vertical="center",wrap_text=True)
+    gfill=PatternFill("solid",fgColor="D1FAE5"); gfont=Font(bold=True,color="065F46",size=11)
+    wfill=PatternFill("solid",fgColor="FEF9C3"); afill=PatternFill("solid",fgColor="EFF6FF")
+    for i,m in enumerate(mcqs,1):
+        row=i+1; answer=m.get("answer") or ""; src=m.get("source","")
+        data=[m.get("number",i),m["question"],m.get("A",""),m.get("B",""),m.get("C",""),m.get("D",""),
+              answer,m.get("blooms",""),m.get("explanation",""),src]
+        for col,val in enumerate(data,1):
+            c=ws.cell(row=row,column=col,value=val); c.alignment=Alignment(wrap_text=True,vertical="top")
+            if i%2==0: c.fill=afill
+        ac=ws.cell(row=row,column=7)
+        if answer: ac.fill=gfill; ac.font=gfont
+        else: ac.fill=wfill; ac.value="⚠️ Unknown"
+        ac.alignment=Alignment(horizontal="center",vertical="center")
+    widths=[5,60,28,28,28,28,14,14,50,14]
+    for col,w in enumerate(widths,1): ws.column_dimensions[get_column_letter(col)].width=w
+    ws.row_dimensions[1].height=28; ws.freeze_panes="A2"
+    path=tempfile.mktemp(suffix=".xlsx"); wb.save(path); return path

python-version

@@ -0,0 +1 @@
+3.11

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=5.0,<6.0
+google-genai>=0.8.0
+bcrypt>=4.0.0
+pandas>=2.0.0
+python-docx>=0.8.11
+reportlab>=4.0.0
+openpyxl>=3.1.0
+pdfplumber>=0.9.0
+requests>=2.28.0