Update app.py

app.py

@@ -1,13 +1,10 @@
 import gradio as gr
 import pandas as pd
-import numpy as np
-from PIL import Image
-import os
 import json
+import os
 from datetime import datetime
-import uuid
 
-print("🚀 Teacher Assistant Starting...")
+print("🚀 Teacher Assistant - Starting...")
 
 # ============ DATA STORAGE ============
 DATA_DIR = "data"
@@ -18,7 +15,6 @@ EXAMS_FILE = os.path.join(DATA_DIR, "exams.json")
 GRADES_FILE = os.path.join(DATA_DIR, "grades.json")
 
 def load_json(filepath):
-    """Load JSON data"""
     if os.path.exists(filepath):
         try:
             with open(filepath, 'r') as f:
@@ -28,98 +24,54 @@ def load_json(filepath):
     return {}
 
 def save_json(data, filepath):
-    """Save JSON data"""
     with open(filepath, 'w') as f:
         json.dump(data, f, indent=2)
 
-def init_data():
-    """Initialize data files"""
-    for filepath in [STUDENTS_FILE, EXAMS_FILE, GRADES_FILE]:
-        if not os.path.exists(filepath):
-            save_json({}, filepath)
-
-init_data()
+# Initialize files
+for file in [STUDENTS_FILE, EXAMS_FILE, GRADES_FILE]:
+    if not os.path.exists(file):
+        save_json({}, file)
 
 # ============ TAB 1: QUESTION GENERATOR ============
-def generate_questions(topic, num_questions, question_type):
-    """Generate sample questions"""
+def create_exam(topic, num_q, q_type):
     if not topic:
-        return "❌ Please enter a topic", "", ""
+        return "Enter a topic", "", ""
     
     questions = []
     answers = []
     
-    templates = {
-        "Multiple Choice": [
-            "What is the capital of {topic}?",
-            "Which of these is NOT related to {topic}?",
-            "Who discovered {topic}?",
-            "When was {topic} first studied?"
-        ],
-        "True or False": [
-            "{topic} is always true.",
-            "{topic} can be observed in nature.",
-            "{topic} was discovered in the 20th century.",
-            "{topic} has practical applications."
-        ],
-        "Identification": [
-            "Define {topic}.",
-            "Name the main component of {topic}.",
-            "What principle governs {topic}?",
-            "Identify the key characteristic of {topic}."
-        ],
-        "Essay": [
-            "Discuss the importance of {topic}.",
-            "Explain how {topic} functions.",
-            "Analyze the impact of {topic}.",
-            "Describe the historical development of {topic}."
-        ],
-        "Matching Type": [
-            "Match terms related to {topic}.",
-            "Connect concepts about {topic}.",
-            "Pair examples of {topic}.",
-            "Link definitions about {topic}."
-        ]
-    }
-    
-    question_list = templates.get(question_type, ["Question about {topic}"])
-    
-    for i in range(min(num_questions, len(question_list))):
-        q_template = question_list[i]
-        q = q_template.format(topic=topic)
-        
-        if question_type == "Multiple Choice":
-            question_text = f"Q{i+1}: {q}\nA) Option A\nB) Option B\nC) Option C\nD) Option D"
-            answer_text = f"A{i+1}: C"
-        elif question_type == "True or False":
-            question_text = f"Q{i+1}: {q} (True/False)"
-            answer_text = f"A{i+1}: True"
-        elif question_type == "Identification":
-            question_text = f"Q{i+1}: {q} __________"
-            answer_text = f"A{i+1}: Answer"
-        elif question_type == "Essay":
-            question_text = f"Q{i+1}: {q}\n\n[Write your essay here]"
-            answer_text = f"A{i+1}: [Grading rubric: Content 10, Structure 5, Grammar 5]"
-        elif question_type == "Matching Type":
-            question_text = f"Q{i+1}: {q}\n\n1. Term 1 → A. Definition 1\n2. Term 2 → B. Definition 2\n3. Term 3 → C. Definition 3"
-            answer_text = f"A{i+1}: 1-A, 2-B, 3-C"
-        else:
-            question_text = f"Q{i+1}: {q}"
-            answer_text = f"A{i+1}: Sample answer"
+    for i in range(num_q):
+        if q_type == "Multiple Choice":
+            q = f"Q{i+1}: What is important about {topic}?"
+            a = f"A) Option A\nB) Option B\nC) Option C\nD) Option D"
+            ans = f"Answer: C"
+        elif q_type == "True or False":
+            q = f"Q{i+1}: {topic} is important. (True/False)"
+            a = ""
+            ans = f"Answer: True"
+        elif q_type == "Identification":
+            q = f"Q{i+1}: Define {topic}."
+            a = ""
+            ans = f"Answer: [Definition]"
+        elif q_type == "Essay":
+            q = f"Q{i+1}: Discuss {topic}."
+            a = "\n[Essay space]"
+            ans = f"Answer: [Essay rubric]"
+        else:  # Matching Type
+            q = f"Q{i+1}: Match terms about {topic}."
+            a = "\n1. Term1 → A. Def1\n2. Term2 → B. Def2\n3. Term3 → C. Def3"
+            ans = f"Answer: 1-A, 2-B, 3-C"
         
-        questions.append(question_text)
-        answers.append(answer_text)
+        questions.append(q + a)
+        answers.append(ans)
     
-    # Save exam
-    exam_id = f"EXAM-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    exam_id = f"EXAM-{datetime.now().strftime('%H%M%S')}"
     exam_data = {
         "id": exam_id,
         "topic": topic,
-        "type": question_type,
         "questions": questions,
         "answers": answers,
-        "created": datetime.now().isoformat(),
-        "num_questions": num_questions
+        "date": datetime.now().isoformat()
     }
     
     exams = load_json(EXAMS_FILE)
@@ -128,133 +80,91 @@ def generate_questions(topic, num_questions, question_type):
     
     return "\n\n".join(questions), "\n\n".join(answers), exam_id
 
-def save_exam_file(questions, exam_id):
-    """Save exam as text file"""
-    if not questions or not exam_id:
+def download_exam(questions, exam_id):
+    if not questions:
         return None
     
     filename = f"{exam_id}.txt"
-    content = f"""EXAMINATION PAPER
-{'=' * 50}
-Exam ID: {exam_id}
-Date: {datetime.now().strftime('%B %d, %Y')}
-Time Allowed: 60 minutes
-
-INSTRUCTIONS:
-1. Write your name and student ID
-2. Answer all questions
-3. No external help allowed
-
-QUESTIONS:
-{'=' * 50}
-{questions}
-
-END OF EXAM
-"""
-    
     with open(filename, 'w') as f:
-        f.write(content)
-    
+        f.write(f"EXAM: {exam_id}\n\n{questions}")
     return filename
 
 # ============ TAB 2: STUDENT MANAGEMENT ============
-def add_student(student_id, first_name, last_name, class_name):
-    """Add a new student"""
-    if not student_id or not first_name or not last_name:
-        return "❌ Please fill all required fields"
+def add_student(s_id, f_name, l_name, s_class):
+    if not s_id or not f_name:
+        return "Fill required fields"
     
     students = load_json(STUDENTS_FILE)
     
-    if student_id in students:
-        return f"⚠ Student {student_id} already exists"
-    
-    student_data = {
-        "id": student_id,
-        "first_name": first_name,
-        "last_name": last_name,
-        "full_name": f"{first_name} {last_name}",
-        "class": class_name,
-        "date_added": datetime.now().isoformat(),
-        "exams_taken": 0,
-        "average_score": 0
+    if s_id in students:
+        return "Student exists"
+    
+    student = {
+        "id": s_id,
+        "name": f"{f_name} {l_name}",
+        "class": s_class,
+        "added": datetime.now().isoformat(),
+        "exams": 0,
+        "avg": 0
     }
     
-    students[student_id] = student_data
+    students[s_id] = student
     save_json(students, STUDENTS_FILE)
-    
-    return f"✅ Added: {first_name} {last_name} ({student_id})"
+    return f"Added {f_name} {l_name}"
 
-def get_all_students():
-    """Get all students as DataFrame"""
+def get_students():
     students = load_json(STUDENTS_FILE)
     if not students:
-        return pd.DataFrame(columns=["ID", "Name", "Class", "Exams", "Avg Score"])
+        return pd.DataFrame(columns=["ID", "Name", "Class", "Exams", "Avg"])
     
     rows = []
     for sid, data in students.items():
-        rows.append([
-            sid,
-            data["full_name"],
-            data["class"],
-            data["exams_taken"],
-            f"{data['average_score']:.1f}%" if data["average_score"] > 0 else "N/A"
-        ])
-    
-    return pd.DataFrame(rows, columns=["ID", "Name", "Class", "Exams", "Avg Score"])
+        rows.append([sid, data["name"], data["class"], data["exams"], f"{data['avg']:.1f}%"])
+    
+    return pd.DataFrame(rows, columns=["ID", "Name", "Class", "Exams", "Avg"])
 
-def delete_student(student_id):
-    """Delete a student"""
+def remove_student(s_id):
     students = load_json(STUDENTS_FILE)
     
-    if student_id in students:
-        name = students[student_id]["full_name"]
-        del students[student_id]
+    if s_id in students:
+        name = students[s_id]["name"]
+        del students[s_id]
         save_json(students, STUDENTS_FILE)
-        return f"✅ Deleted: {name}"
+        return f"Removed {name}"
     
-    return f"❌ Student {student_id} not found"
+    return "Student not found"
 
-# ============ TAB 3: GRADING SYSTEM ============
-def record_grade(student_id, exam_id, score):
-    """Record a student's grade"""
-    if not student_id or not exam_id or score is None:
-        return "❌ Please fill all fields", 0, "N/A"
+# ============ TAB 3: GRADING ============
+def add_grade(s_id, e_id, score):
+    if not s_id or not e_id:
+        return "Fill all fields", 0, "N/A"
     
     students = load_json(STUDENTS_FILE)
-    if student_id not in students:
-        return f"❌ Student {student_id} not found", 0, "N/A"
-    
-    # Calculate letter grade
-    if score >= 90:
-        grade = "A"
-    elif score >= 80:
-        grade = "B"
-    elif score >= 70:
-        grade = "C"
-    elif score >= 60:
-        grade = "D"
-    else:
-        grade = "F"
-    
-    # Update student record
-    student = students[student_id]
-    student["exams_taken"] += 1
-    
-    # Update average
-    if student["average_score"] == 0:
-        student["average_score"] = score
+    if s_id not in students:
+        return "Student not found", 0, "N/A"
+    
+    # Calculate grade
+    if score >= 90: grade = "A"
+    elif score >= 80: grade = "B"
+    elif score >= 70: grade = "C"
+    elif score >= 60: grade = "D"
+    else: grade = "F"
+    
+    # Update student
+    student = students[s_id]
+    student["exams"] += 1
+    if student["avg"] == 0:
+        student["avg"] = score
     else:
-        student["average_score"] = (student["average_score"] + score) / 2
-    
+        student["avg"] = (student["avg"] + score) / 2
     save_json(students, STUDENTS_FILE)
     
-    # Save grade record
-    grade_id = f"GRADE-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    # Save grade
+    grade_id = f"GRADE-{datetime.now().strftime('%H%M%S')}"
     grade_data = {
         "id": grade_id,
-        "student_id": student_id,
-        "student_name": student["full_name"],
-        "exam_id": exam_id,
+        "student": student["name"],
+        "exam": e_id,
         "score": score,
         "grade": grade,
         "date": datetime.now().isoformat()
@@ -264,368 +174,193 @@ def record_grade(student_id, exam_id, score):
     grades[grade_id] = grade_data
     save_json(grades, GRADES_FILE)
     
-    return f"✅ Grade recorded for {student['full_name']}", score, grade
+    return f"Grade saved for {student['name']}", score, grade
 
-def get_all_grades():
-    """Get all grades as DataFrame"""
+def get_grades():
     grades = load_json(GRADES_FILE)
     if not grades:
         return pd.DataFrame(columns=["Student", "Exam", "Score", "Grade", "Date"])
     
     rows = []
     for gid, data in grades.items():
-        rows.append([
-            data["student_name"],
-            data["exam_id"],
-            f"{data['score']:.1f}%",
-            data["grade"],
-            data["date"][:10]
-        ])
+        rows.append([data["student"], data["exam"], f"{data['score']}%", data["grade"], data["date"][:10]])
     
     return pd.DataFrame(rows, columns=["Student", "Exam", "Score", "Grade", "Date"])
 
 # ============ TAB 4: ANALYTICS ============
-def get_analytics():
-    """Generate analytics report"""
+def get_report():
     students = load_json(STUDENTS_FILE)
     grades = load_json(GRADES_FILE)
     
     if not students:
-        return "📊 No student data available", pd.DataFrame()
+        return "No data", pd.DataFrame()
     
     total_students = len(students)
     total_grades = len(grades)
     
-    # Calculate class averages
-    class_stats = {}
-    for sid, student in students.items():
-        class_name = student["class"]
-        if class_name not in class_stats:
-            class_stats[class_name] = {
-                "students": [],
-                "total_score": 0,
-                "count": 0
-            }
-        
-        class_stats[class_name]["students"].append(student["full_name"])
-        if student["average_score"] > 0:
-            class_stats[class_name]["total_score"] += student["average_score"]
-            class_stats[class_name]["count"] += 1
-    
-    # Create report
+    # Simple report
     report = f"""
-    📊 TEACHER ASSISTANT ANALYTICS
-    {'=' * 50}
-    👥 Total Students: {total_students}
-    📝 Exams Graded: {total_grades}
-    
-    📚 CLASS PERFORMANCE:
+    Students: {total_students}
+    Grades: {total_grades}
     """
     
+    # Create simple table
     rows = []
-    for class_name, stats in class_stats.items():
-        if stats["count"] > 0:
-            average = stats["total_score"] / stats["count"]
-            report += f"\n    🏫 {class_name}: {average:.1f}% average ({stats['count']} students)"
-            rows.append([
-                class_name,
-                f"{average:.1f}%",
-                stats["count"],
-                ", ".join(stats["students"][:3]) + ("..." if len(stats["students"]) > 3 else "")
-            ])
-    
-    df = pd.DataFrame(rows, columns=["Class", "Average", "Students", "Sample Names"])
+    for sid, data in students.items():
+        rows.append([sid, data["name"], data["class"], data["exams"], f"{data['avg']:.1f}%"])
+    
+    df = pd.DataFrame(rows, columns=["ID", "Name", "Class", "Exams", "Average"])
     return report, df
 
 # ============ TAB 5: SETTINGS ============
-def save_settings(school_name, default_questions):
-    """Save application settings"""
-    settings = {
-        "school": school_name,
-        "default_questions": default_questions,
-        "last_updated": datetime.now().isoformat()
+def save_setting(school, default_q):
+    setting = {
+        "school": school,
+        "questions": default_q,
+        "updated": datetime.now().isoformat()
     }
     
-    settings_file = os.path.join(DATA_DIR, "settings.json")
-    save_json(settings, settings_file)
-    
-    return f"✅ Settings saved for {school_name}"
+    setting_file = os.path.join(DATA_DIR, "settings.json")
+    save_json(setting, setting_file)
+    return f"Saved settings for {school}"
 
-def export_backup():
-    """Export all data as backup"""
-    backup_data = {
+def create_backup():
+    backup = {
         "students": load_json(STUDENTS_FILE),
         "exams": load_json(EXAMS_FILE),
         "grades": load_json(GRADES_FILE),
-        "export_date": datetime.now().isoformat()
+        "date": datetime.now().isoformat()
     }
     
-    filename = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    filename = f"backup_{datetime.now().strftime('%H%M%S')}.json"
     with open(filename, 'w') as f:
-        json.dump(backup_data, f, indent=2)
+        json.dump(backup, f, indent=2)
     
-    return f"✅ Backup created: {filename}", filename
+    return f"Backup created", filename
 
-# ============ CREATE INTERFACE ============
-def create_interface():
-    """Create the Gradio interface"""
-    
-    # Custom CSS for better appearance
-    custom_css = """
-    .gradio-container {
-        max-width: 1200px !important;
-        margin: 0 auto !important;
-    }
-    .tab-nav {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        padding: 20px;
-        border-radius: 10px;
-        margin-bottom: 20px;
-        color: white;
-    }
-    .success {
-        background-color: #d4edda;
-        color: #155724;
-        padding: 10px;
-        border-radius: 5px;
-        margin: 10px 0;
-    }
-    .warning {
-        background-color: #fff3cd;
-        color: #856404;
-        padding: 10px;
-        border-radius: 5px;
-        margin: 10px 0;
-    }
-    """
+# ============ CREATE APP ============
+def create_app():
+    """Create the Gradio app - SIMPLE VERSION"""
     
-    # Create the app
-    with gr.Blocks(css=custom_css) as app:
+    with gr.Blocks() as app:
         
         # Header
-        gr.HTML("""
-        <div class="tab-nav">
-            <h1 style="margin: 0; font-size: 28px;">🍎 Teacher Assistant</h1>
-            <p style="margin: 5px 0 0 0; font-size: 16px; opacity: 0.9;">
-                Simplify Your Teaching Workflow • All Data Saved Locally
-            </p>
-        </div>
-        """)
+        gr.Markdown("# 🍎 Teacher Assistant")
+        gr.Markdown("Simple tool for teachers")
         
-        # Main Tabs
         with gr.Tabs():
             
-            # ===== TAB 1: Question Generator =====
+            # TAB 1: Create Exam
             with gr.TabItem("📝 Create Exam"):
                 with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Generate Questions")
-                        topic_input = gr.Textbox(label="Topic/Subject", placeholder="e.g., Mathematics, Science, History")
-                        num_q_input = gr.Slider(minimum=1, maximum=20, value=5, label="Number of Questions")
-                        q_type_input = gr.Dropdown(
-                            choices=["Multiple Choice", "True or False", "Identification", "Essay", "Matching Type"],
-                            value="Multiple Choice",
-                            label="Question Type"
-                        )
-                        generate_btn = gr.Button("Generate Questions", variant="primary")
-                    
-                    with gr.Column():
-                        gr.Markdown("### Generated Exam")
-                        questions_output = gr.Textbox(label="Questions", lines=12)
-                        answers_output = gr.Textbox(label="Answer Key", lines=8)
-                        exam_id_output = gr.Textbox(label="Exam ID", interactive=False)
-                        
-                        with gr.Row():
-                            download_btn = gr.Button("📥 Download Exam")
-                            clear_btn = gr.Button("🗑️ Clear All")
+                    col1 = gr.Column()
+                    col2 = gr.Column()
                 
-                # Connect buttons
-                generate_btn.click(
-                    generate_questions,
-                    [topic_input, num_q_input, q_type_input],
-                    [questions_output, answers_output, exam_id_output]
-                )
+                with col1:
+                    topic = gr.Textbox(label="Topic")
+                    num_q = gr.Slider(1, 20, value=5, label="Questions")
+                    q_type = gr.Dropdown(["Multiple Choice", "True or False", "Identification", "Essay", "Matching Type"], label="Type")
+                    btn = gr.Button("Create")
                 
-                download_btn.click(
-                    save_exam_file,
-                    [questions_output, exam_id_output],
-                    outputs=gr.File(label="Download")
-                )
+                with col2:
+                    questions = gr.Textbox(label="Questions", lines=10)
+                    answers = gr.Textbox(label="Answers", lines=5)
+                    exam_id = gr.Textbox(label="Exam ID")
+                    download = gr.Button("Download")
                 
-                clear_btn.click(
-                    lambda: ("", 5, "Multiple Choice", "", "", ""),
-                    [topic_input, num_q_input, q_type_input, questions_output, answers_output, exam_id_output]
-                )
+                btn.click(create_exam, [topic, num_q, q_type], [questions, answers, exam_id])
+                download.click(download_exam, [questions, exam_id], gr.File(label="File"))
             
-            # ===== TAB 2: Student Management =====
-            with gr.TabItem("👥 Manage Students"):
+            # TAB 2: Students
+            with gr.TabItem("👥 Students"):
                 with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Add New Student")
-                        s_id_input = gr.Textbox(label="Student ID*", placeholder="STU001")
-                        s_first_input = gr.Textbox(label="First Name*", placeholder="John")
-                        s_last_input = gr.Textbox(label="Last Name*", placeholder="Doe")
-                        s_class_input = gr.Textbox(label="Class*", placeholder="Grade 10")
-                        add_s_btn = gr.Button("➕ Add Student", variant="primary")
-                        add_status = gr.Markdown("")
-                    
-                    with gr.Column():
-                        gr.Markdown("### Student Database")
-                        students_table = gr.Dataframe(
-                            headers=["ID", "Name", "Class", "Exams", "Avg Score"],
-                            interactive=False
-                        )
-                        refresh_btn = gr.Button("🔄 Refresh")
-                        
-                        gr.Markdown("### Delete Student")
-                        del_id_input = gr.Textbox(label="Student ID to Delete")
-                        del_btn = gr.Button("🗑️ Delete Student", variant="stop")
-                        del_status = gr.Markdown("")
+                    col1 = gr.Column()
+                    col2 = gr.Column()
                 
-                # Connect buttons
-                add_s_btn.click(
-                    add_student,
-                    [s_id_input, s_first_input, s_last_input, s_class_input],
-                    add_status
-                ).then(
-                    get_all_students,
-                    None,
-                    students_table
-                )
+                with col1:
+                    s_id = gr.Textbox(label="Student ID")
+                    f_name = gr.Textbox(label="First Name")
+                    l_name = gr.Textbox(label="Last Name")
+                    s_class = gr.Textbox(label="Class")
+                    add_btn = gr.Button("Add Student")
+                    status = gr.Markdown("")
                 
-                refresh_btn.click(
-                    get_all_students,
-                    None,
-                    students_table
-                )
+                with col2:
+                    table = gr.Dataframe(headers=["ID", "Name", "Class", "Exams", "Avg"])
+                    refresh = gr.Button("Refresh")
+                    del_id = gr.Textbox(label="Delete ID")
+                    del_btn = gr.Button("Delete")
+                    del_status = gr.Markdown("")
                 
-                del_btn.click(
-                    delete_student,
-                    del_id_input,
-                    del_status
-                ).then(
-                    get_all_students,
-                    None,
-                    students_table
-                )
+                add_btn.click(add_student, [s_id, f_name, l_name, s_class], status).then(get_students, None, table)
+                refresh.click(get_students, None, table)
+                del_btn.click(remove_student, del_id, del_status).then(get_students, None, table)
             
-            # ===== TAB 3: Grading =====
-            with gr.TabItem("✅ Record Grades"):
+            # TAB 3: Grades
+            with gr.TabItem("✅ Grades"):
                 with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Enter Grade")
-                        g_student_id = gr.Textbox(label="Student ID*", placeholder="STU001")
-                        g_exam_id = gr.Textbox(label="Exam ID*", placeholder="EXAM-20241204000000")
-                        g_score = gr.Slider(minimum=0, maximum=100, label="Score (%)")
-                        grade_btn = gr.Button("📝 Record Grade", variant="primary")
-                        grade_status = gr.Markdown("")
-                        
-                        with gr.Row():
-                            score_display = gr.Number(label="Score", interactive=False)
-                            grade_display = gr.Textbox(label="Grade", interactive=False)
-                    
-                    with gr.Column():
-                        gr.Markdown("### Gradebook")
-                        grades_table = gr.Dataframe(
-                            headers=["Student", "Exam", "Score", "Grade", "Date"],
-                            interactive=False
-                        )
-                        refresh_grades_btn = gr.Button("🔄 Refresh Grades")
+                    col1 = gr.Column()
+                    col2 = gr.Column()
                 
-                # Connect buttons
-                grade_btn.click(
-                    record_grade,
-                    [g_student_id, g_exam_id, g_score],
-                    [grade_status, score_display, grade_display]
-                ).then(
-                    get_all_grades,
-                    None,
-                    grades_table
-                )
+                with col1:
+                    g_sid = gr.Textbox(label="Student ID")
+                    g_eid = gr.Textbox(label="Exam ID")
+                    g_score = gr.Slider(0, 100, label="Score")
+                    g_btn = gr.Button("Add Grade")
+                    g_status = gr.Markdown("")
+                    score_disp = gr.Number(label="Score")
+                    grade_disp = gr.Textbox(label="Grade")
                 
-                refresh_grades_btn.click(
-                    get_all_grades,
-                    None,
-                    grades_table
-                )
+                with col2:
+                    grades_table = gr.Dataframe(headers=["Student", "Exam", "Score", "Grade", "Date"])
+                    g_refresh = gr.Button("Refresh")
+                
+                g_btn.click(add_grade, [g_sid, g_eid, g_score], [g_status, score_disp, grade_disp]).then(get_grades, None, grades_table)
+                g_refresh.click(get_grades, None, grades_table)
             
-            # ===== TAB 4: Analytics =====
+            # TAB 4: Analytics
             with gr.TabItem("📊 Analytics"):
                 with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Generate Report")
-                        analytics_btn = gr.Button("📈 Generate Analytics", variant="primary")
-                        report_output = gr.Markdown("")
-                    
-                    with gr.Column():
-                        gr.Markdown("### Class Statistics")
-                        stats_table = gr.Dataframe(
-                            headers=["Class", "Average", "Students", "Sample Names"],
-                            interactive=False
-                        )
+                    col1 = gr.Column()
+                    col2 = gr.Column()
+                
+                with col1:
+                    report_btn = gr.Button("Generate Report")
+                    report_text = gr.Markdown("")
                 
-                analytics_btn.click(
-                    get_analytics,
-                    None,
-                    [report_output, stats_table]
-                )
+                with col2:
+                    report_table = gr.Dataframe(headers=["ID", "Name", "Class", "Exams", "Average"])
+                
+                report_btn.click(get_report, None, [report_text, report_table])
             
-            # ===== TAB 5: Settings =====
+            # TAB 5: Settings
             with gr.TabItem("⚙️ Settings"):
                 with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Application Settings")
-                        school_input = gr.Textbox(label="School Name", value="My School")
-                        default_q_input = gr.Slider(minimum=1, maximum=20, value=10, label="Default Questions")
-                        save_settings_btn = gr.Button("💾 Save Settings", variant="primary")
-                        settings_status = gr.Markdown("")
-                    
-                    with gr.Column():
-                        gr.Markdown("### Data Management")
-                        export_btn = gr.Button("💾 Create Backup", variant="secondary")
-                        export_status = gr.Markdown("")
-                        backup_file = gr.File(label="Download Backup", interactive=False)
+                    col1 = gr.Column()
+                    col2 = gr.Column()
                 
-                # Connect buttons
-                save_settings_btn.click(
-                    save_settings,
-                    [school_input, default_q_input],
-                    settings_status
-                )
+                with col1:
+                    school_name = gr.Textbox(label="School", value="My School")
+                    default_q = gr.Slider(1, 20, value=10, label="Default Questions")
+                    save_btn = gr.Button("Save")
+                    save_status = gr.Markdown("")
                 
-                export_btn.click(
-                    export_backup,
-                    None,
-                    [export_status, backup_file]
-                )
-        
-        # Footer
-        gr.HTML("""
-        <div style="text-align: center; margin-top: 30px; padding: 20px; border-top: 1px solid #e0e0e0;">
-            <p style="color: #666; font-size: 14px;">
-                <b>Teacher Assistant</b> • All data stored locally in your browser • 
-                No external dependencies • Simple & Effective
-            </p>
-        </div>
-        """)
+                with col2:
+                    backup_btn = gr.Button("Create Backup")
+                    backup_status = gr.Markdown("")
+                    backup_file = gr.File(label="Download")
+                
+                save_btn.click(save_setting, [school_name, default_q], save_status)
+                backup_btn.click(create_backup, None, [backup_status, backup_file])
     
     return app
 
-# ============ MAIN APPLICATION ============
+# ============ MAIN ============
 if __name__ == "__main__":
-    print("=" * 50)
-    print("🚀 Launching Teacher Assistant")
-    print("=" * 50)
-    print(f"📁 Students: {len(load_json(STUDENTS_FILE))}")
-    print(f"📝 Exams: {len(load_json(EXAMS_FILE))}")
-    print(f"✅ Grades: {len(load_json(GRADES_FILE))}")
-    print("=" * 50)
-    
-    # Create and launch app
-    app = create_interface()
-    app.launch(
-        debug=True,
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    print("App starting...")
+    print(f"Students: {len(load_json(STUDENTS_FILE))}")
+    print(f"Exams: {len(load_json(EXAMS_FILE))}")
+    print(f"Grades: {len(load_json(GRADES_FILE))}")
+    
+    app = create_app()
+    app.launch(server_name="0.0.0.0", server_port=7860)