app.py

<think>
We are building a comprehensive Gradio app. Due to the complexity, we'll structure the code in a modular way within a single script (app.py) and use SQLite for the database.

 Steps:
 1. Set up the database (SQLite) for users, progress, questions, etc.
 2. Implement user authentication (signup, login) with password hashing.
 3. Design the main dashboard with gamification elements (streaks, XP, badges, leaderboard).
 4. Create the course/lesson structure with interactive quizzes (using Gradio components).
 5. Implement adaptive difficulty and gamification logic (hearts, XP, streaks).
 6. Add additional features: practice mode, resources, community chat, enrollment form.
 7. Create an admin/teacher panel for uploading questions and viewing progress.
 8. Ensure the UI is responsive and visually appealing with themes and emojis.

 Note: We'll hardcode some questions and generate others using sympy for math.

 Due to the extensive requirements, we'll focus on core functionality and then build upon it.

 Important: We must use Gradio Blocks for complex layouts.

 We'll structure the app with multiple tabs and conditional rendering based on user role and login state.

 Let's break down:

 1. Database Setup:
    - Create tables: users, progress, questions, badges, streaks, etc.

 2. User Authentication:
    - Signup: username, password, role, grade, board/stream (if student)
    - Login: username and password, then set session.

 3. Main Dashboard:
    - After login, show: streak, XP, badges, daily goals, recommended lessons, leaderboard.

 4. Lessons:
    - Each lesson: short explanation and 5-10 questions (multiple choice, fill-in, drag-and-drop).
    - Adaptive: if wrong, next question easier; if correct, harder.

 5. Gamification:
    - XP: earn for correct answers, lose hearts for mistakes (3 hearts per lesson).
    - Badges: awarded on milestones.
    - Streaks: maintained by daily login and completing at least one lesson.

 6. Additional Features:
    - Practice Mode: random quizzes from past lessons.
    - Resources: static notes and past papers (PDFs).
    - Community: a simple chat interface (using Gradio ChatInterface) but note: we need persistence? We can use a global list for now, but for production a database is better. However, due to HF Spaces limitations, we'll use a list and it will reset on restart.
    - Enrollment: a form for joining classes.

 7. Admin/Teacher Panel:
    - Upload questions (via form) and view student progress (table).

 8. UI/UX:
    - Use Gradio themes and custom CSS for mobile responsiveness.
    - Add emojis and animations (CSS/JS) for correct answers (confetti).

 9. Security:
    - Hash passwords with hashlib (sha256).
    - Use parameterized queries to prevent SQL injection.

 10. Performance:
     - Cache heavy operations (like generating math problems) and limit database queries.

 Given the complexity, we'll start with the database and authentication, then build the dashboard and lessons.

 We'll use the following structure:

 - Define database functions (create_tables, add_user, authenticate_user, etc.)
 - Define classes for User, Lesson, Question (for in-memory representation)
 - Gradio app: 
     - State: to keep track of current user, progress, etc. (using gr.State)
     - Tabs: for Dashboard, Lessons, Practice, Resources, Community, Admin, Enrollment.

 However, note that Gradio doesn't have built-in tab navigation for multi-page, so we'll use gr.Tabs.

 Due to the extensive nature, we'll focus on the core and then add features incrementally.

 Important: We cannot implement everything in one go, so we'll create a minimal viable product and then extend.

 Let's outline the code:

 1. Imports
 2. Database setup and helper functions
 3. Define hardcoded questions and generate some (for math)
 4. Gradio app layout and logic

 We'll start with the authentication and dashboard.

 Note: We are constrained by Hugging Face Spaces, so we must avoid long-running processes and heavy memory usage.

 We'll use SQLite and store the database in the current directory (it will be ephemeral on HF Spaces unless we use the persistent storage, but note that free tier has 5GB and it's persistent across restarts? Actually, the space storage is persistent. So we can use a file.)

 Steps for the app:

  - On startup: create the database and tables if they don't exist.

 We'll create:

   users: id (integer primary key), username (text unique), password (text), role (text), grade (text, optional), board (text, optional), created_at (timestamp default current_timestamp)
   progress: id, user_id (foreign key), lesson_id, score (integer), xp_earned (integer), completed_at (timestamp)
   questions: id, subject, grade, board, type (mcq, fill, drag), difficulty (1-5), question_text, options (json for mcq), correct_answer, explanation
   badges: id, user_id, badge_name, earned_at
   streaks: user_id, current_streak, last_activity_date

  We'll also have a table for lessons: id, subject, grade, board, title, description, estimated_time, difficulty

  But for simplicity, we might hardcode lessons and questions in the code (or load from a JSON) for now.

  We'll create a function to populate initial questions.

  Due to the complexity, we'll focus on a few subjects and grades.

 Implementation:

  We'll create a Gradio Blocks app.

  The app will have:

   - A login/signup screen at the start.
   - After login, the main app with tabs.

  We'll use gr.State to store the current user and their state (like current lesson, hearts, etc.)

  We'll break the UI into components:

   - auth_ui: for login and signup
   - dashboard_ui: for the main dashboard
   - lessons_ui: for selecting and taking lessons
   - practice_ui: for practice mode
   - resources_ui: for resources
   - community_ui: for community chat
   - admin_ui: for admin panel
   - enrollment_ui: for enrollment form

  We'll use conditional visibility: if not logged in, show auth_ui; else show the main app.

  We'll use tabs for the main app.

  Let's code step by step.

  Note: This will be a long script. We'll try to keep it organized.

  We'll also add comments for clarity.

  IMPORTANT: We are required to output only the code in a code block.

  Let's begin.
</think>
```python
import gradio as gr
import sqlite3
import hashlib
import random
import datetime
import json
import sympy
from sympy.abc import x
import time
import os
from typing import List, Dict, Tuple

# Database setup
def init_db():
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    
    # Create tables
    c.execute('''CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT UNIQUE NOT NULL,
        password TEXT NOT NULL,
        role TEXT NOT NULL CHECK(role IN ('student', 'parent', 'teacher')),
        grade TEXT,
        board TEXT,
        stream TEXT,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS progress (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user_id INTEGER NOT NULL,
        subject TEXT NOT NULL,
        level INTEGER DEFAULT 1,
        xp INTEGER DEFAULT 0,
        streak INTEGER DEFAULT 0,
        last_active DATE,
        badges TEXT DEFAULT '[]',
        FOREIGN KEY(user_id) REFERENCES users(id)
    )''')
    
    c.execute('''CREATE TABLE IF NOT EXISTS questions (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        subject TEXT NOT NULL,
        grade TEXT NOT NULL,
        board TEXT NOT NULL,
        type TEXT NOT NULL,
        difficulty INTEGER DEFAULT 1,
        question TEXT NOT NULL,
        options TEXT,  # JSON for MCQ
        correct_answer TEXT NOT NULL,
        explanation TEXT
    )''')
    
    # Insert sample questions if empty
    c.execute("SELECT COUNT(*) FROM questions")
    if c.fetchone()[0] == 0:
        # Sample questions for Mathematics
        questions = [
            ("Mathematics", "9", "Sindh Board", "mcq", 1, 
             "What is the value of π (pi)?", 
             '["3.14", "2.71", "1.618", "4.669"]', 
             "3.14", "π is approximately 3.14"),
            ("Mathematics", "9", "Sindh Board", "fill", 2, 
             "Solve for x: 2x + 5 = 15", 
             None, 
             "5", "Subtract 5 from both sides: 2x = 10, then divide by 2"),
            ("Physics", "10", "Aga Khan", "mcq", 1, 
             "What is the unit of force?", 
             '["Newton", "Joule", "Watt", "Pascal"]', 
             "Newton", "Force is measured in Newtons"),
            ("Chemistry", "11", "Pre-Engineering", "mcq", 2, 
             "What is the atomic number of Oxygen?", 
             '["8", "16", "32", "64"]', 
             "8", "Oxygen has 8 protons")
        ]
        c.executemany('''INSERT INTO questions 
                      (subject, grade, board, type, difficulty, question, options, correct_answer, explanation)
                      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)''', questions)
    
    conn.commit()
    conn.close()

# Initialize database
init_db()

# Password hashing
def hash_password(password: str) -> str:
    return hashlib.sha256(password.encode()).hexdigest()

# User authentication
def authenticate_user(username: str, password: str) -> Tuple[bool, str, str]:
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    c.execute("SELECT id, password, role FROM users WHERE username=?", (username,))
    user = c.fetchone()
    conn.close()
    
    if user and user[1] == hash_password(password):
        return True, user[0], user[2]  # user_id, role
    return False, "", ""

# User registration
def register_user(username: str, password: str, role: str, grade: str = None, board: str = None, stream: str = None) -> bool:
    try:
        conn = sqlite3.connect('classes_education.db')
        c = conn.cursor()
        c.execute("INSERT INTO users (username, password, role, grade, board, stream) VALUES (?, ?, ?, ?, ?, ?)",
                  (username, hash_password(password), role, grade, board, stream))
        conn.commit()
        
        # Initialize progress
        if role == "student":
            subjects = ["Mathematics", "Physics", "Chemistry", "Biology", "General Science"]
            for subject in subjects:
                c.execute("INSERT INTO progress (user_id, subject) VALUES (?, ?)", (c.lastrowid, subject))
            conn.commit()
        conn.close()
        return True
    except sqlite3.IntegrityError:
        return False

# Gamification functions
def update_streak(user_id: int) -> int:
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    today = datetime.date.today().isoformat()
    
    c.execute("SELECT streak, last_active FROM progress WHERE user_id=?", (user_id,))
    progress = c.fetchone()
    
    if progress:
        streak = progress[0]
        last_active = progress[1]
        
        if last_active:
            last_date = datetime.date.fromisoformat(last_active)
            current_date = datetime.date.today()
            if (current_date - last_date).days == 1:
                streak += 1
            elif (current_date - last_active).days > 1:
                streak = 1
        else:
            streak = 1
        
        c.execute("UPDATE progress SET streak=?, last_active=? WHERE user_id=?", (streak, today, user_id))
        conn.commit()
        conn.close()
        return streak
    return 0

def add_xp(user_id: int, subject: str, amount: int) -> int:
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    c.execute("UPDATE progress SET xp = xp + ? WHERE user_id=? AND subject=?", (amount, user_id, subject))
    c.execute("SELECT xp FROM progress WHERE user_id=? AND subject=?", (user_id, subject))
    new_xp = c.fetchone()[0]
    conn.commit()
    conn.close()
    return new_xp

def get_leaderboard() -> List[Tuple[str, int]]:
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    c.execute("SELECT u.username, SUM(p.xp) as total_xp FROM progress p JOIN users u ON p.user_id = u.id GROUP BY u.id ORDER BY total_xp DESC LIMIT 10")
    leaderboard = c.fetchall()
    conn.close()
    return leaderboard

# Question handling
def get_questions(subject: str, grade: str, board: str, difficulty: int = 1, count: int = 5) -> List[Dict]:
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    c.execute("SELECT * FROM questions WHERE subject=? AND grade=? AND board=? AND difficulty=? ORDER BY RANDOM() LIMIT ?",
              (subject, grade, board, difficulty, count))
    questions = []
    for row in c.fetchall():
        questions.append({
            "id": row[0],
            "subject": row[1],
            "grade": row[2],
            "board": row[3],
            "type": row[4],
            "difficulty": row[5],
            "question": row[6],
            "options": json.loads(row[7]) if row[7] else None,
            "correct_answer": row[8],
            "explanation": row[9]
        })
    conn.close()
    return questions

def generate_math_question(grade: str, difficulty: int) -> Dict:
    if grade in ["9", "10"]:
        if difficulty == 1:
            a, b = random.randint(1, 10), random.randint(1, 10)
            question = f"What is {a} + {b}?"
            answer = str(a + b)
        elif difficulty == 2:
            a, b = random.randint(5, 15), random.randint(1, 5)
            question = f"Solve: {a}x - {b} = {a*2 - b}. Find x."
            answer = "2"
        else:
            expr = sympy.expand((x + random.randint(1, 5))**2)
            question = f"Expand: (x + {expr.args[1].args[0]})²"
            answer = str(expr)
    else:
        question = "What is the derivative of x²?"
        answer = "2x"
    
    return {
        "type": "fill",
        "question": question,
        "correct_answer": answer,
        "explanation": "Generated math problem"
    }

# Gradio UI Components
def login_ui():
    with gr.Row():
        with gr.Column(scale=1):
            username = gr.Textbox(label="Username", placeholder="Enter your username")
            password = gr.Textbox(label="Password", placeholder="Enter your password", type="password")
            login_btn = gr.Button("Login")
        with gr.Column(scale=1):
            role = gr.Radio(["student", "parent", "teacher"], label="Role")
            grade = gr.Dropdown(["1-5", "6-8", "9", "10", "11", "12"], label="Grade (for students)")
            board = gr.Dropdown(["Sindh Board", "Aga Khan Board", "O Levels"], label="Board (for students)")
            stream = gr.Dropdown(["Pre-Medical", "Pre-Engineering", "Computer Science"], label="Stream (for Intermediate)", visible=False)
            register_btn = gr.Button("Register")
    
    return username, password, role, grade, board, stream, login_btn, register_btn

def dashboard_ui(user_id: int, role: str):
    conn = sqlite3.connect('classes_education.db')
    c = conn.cursor()
    c.execute("SELECT streak, xp, subject FROM progress WHERE user_id=?", (user_id,))
    progress_data = c.fetchall()
    conn.close()
    
    streak = max([p[0] for p in progress_data]) if progress_data else 0
    total_xp = sum([p[1] for p in progress_data])
    
    with gr.Row():
        gr.Markdown(f"### 🔥 Streak: {streak} days | ⭐ Total XP: {total_xp}")
    
    with gr.Row():
        with gr.Column(scale=3):
            # Daily goals
            gr.Markdown("### 🎯 Daily Goals")
            gr.Markdown("- Complete 3 lessons\n- Maintain streak\n- Earn 100 XP")
            
            # Recommended lessons
            gr.Markdown("### 📚 Recommended Lessons")
            gr.Markdown("1. Mathematics: Algebra Basics\n2. Physics: Newton's Laws\n3. Chemistry: Atomic Structure")
            
        with gr.Column(scale=2):
            # Leaderboard
            gr.Markdown("### 🏆 Leaderboard")
            leaderboard = get_leaderboard()
            leaderboard_text = "\n".join([f"{i+1}. {user[0]} - {user[1]} XP" for i, user in enumerate(leaderboard)])
            gr.Textbox(leaderboard_text, interactive=False, label="Top 10 Students")
            
            # Badges
            gr.Markdown("### 🏅 Badges Earned")
            gr.Markdown("- Matric Master\n- Science Whiz")
    
    if role == "teacher":
        with gr.Row():
            gr.Markdown("### 👨‍🏫 Teacher Panel")
            with gr.Column():
                subject = gr.Dropdown(["Mathematics", "Physics", "Chemistry", "Biology", "General Science"], label="Subject")
                grade = gr.Dropdown(["1-5", "6-8", "9", "10", "11", "12"], label="Grade")
                board = gr.Dropdown(["Sindh Board", "Aga Khan Board", "O Levels"], label="Board")
                question = gr.Textbox(label="Question")
                options = gr.Textbox(label="Options (comma separated for MCQ)")
                correct_answer = gr.Textbox(label="Correct Answer")
                explanation = gr.Textbox(label="Explanation")
                add_question_btn = gr.Button("Add Question")
    
    return locals()

def lesson_ui(user_id: int, subject: str, grade: str, board: str):
    hearts = 3
    xp_earned = 0
    current_question = 0
    questions = get_questions(subject, grade, board, difficulty=1, count=5)
    
    if not questions:
        questions = [generate_math_question(grade, 1) for _ in range(5)]
    
    def display_question(index):
        q = questions[index]
        if q["type"] == "mcq":
            return gr.Radio(choices=q["options"], label=q["question"]), q["correct_answer"]
        else:  # fill-in
            return gr.Textbox(label=q["question"]), q["correct_answer"]
    
    question_display, correct_answer = display_question(current_question)
    
    with gr.Row():
        gr.Markdown(f"### 📖 {subject} Lesson | Grade {grade} | {board}")
    
    with gr.Row():
        hearts_display = gr.Markdown(f"❤️❤️❤️ (Lives: {hearts})")
        xp_display = gr.Markdown(f"⭐ XP: {xp_earned}")
    
    with gr.Row():
        question_ui = question_display
    
    with gr.Row():
        submit_btn = gr.Button("Submit Answer")
        next_btn = gr.Button("Next Question", visible=False)
    
    feedback = gr.Markdown("")
    
    def check_answer(answer):
        nonlocal hearts, xp_earned, current_question
        if answer == correct_answer:
            feedback = "✅ Correct! " + questions[current_question]["explanation"]
            xp_earned += 10
            add_xp(user_id, subject, 10)
        else:
            hearts -= 1
            feedback = f"❌ Incorrect. Correct answer: {correct_answer}. Explanation: {questions[current_question]['explanation']}"
        
        if hearts <= 0 or current_question >= len(questions) - 1:
            submit_btn.visible = False
            next_btn.visible = False
            feedback += "\n\n🎉 Lesson Completed!"
        else:
            next_btn.visible = True
        
        return (
            feedback,
            hearts_display.update(value=f"❤️ {'❤️' * (hearts-1)}" + "♡" * (3-hearts) + f" (Lives: {hearts})"),
            xp_display.update(value=f"⭐ XP: {xp_earned}"),
            submit_btn.update(visible=hearts>0 and current_question<len(questions)-1),