Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,486 @@
+<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),