Create app.py

app.py

@@ -1,378 +1,161 @@
-"""
-Automatic Time Table Generation Agent (Improved)
-Professional Gradio app for Hugging Face Spaces.
-
-Features:
-- Multi-class timetable (e.g. 1,2,3,4,5)
-- Teacher names (cycles if fewer than subjects)
-- Sunday is holiday automatically
-- Export to PDF, DOCX, or TXT (downloadable)
-- Language options: English, Sindhi, Urdu (UI + headings)
-- Clean, professional PDF styling
-"""
-
-import io
-import os
-import random
-import tempfile
-from typing import Dict, List, Tuple
-
 import gradio as gr
-from fpdf import FPDF
 from docx import Document
+from openpyxl import Workbook
+from pptx import Presentation
+from pptx.util import Inches, Pt
+import tempfile
+import random
 
-# ---------------------------
-# Localization
-# ---------------------------
-LANG_MAP = {
-    "English": {
-        "title": "Automatic Time Table Generation (Improved)",
-        "subtitle": "Unique, professional timetables — Sunday is holiday by default.",
-        "days_label": "Days (comma-separated; omit Sunday; Sunday will be shown as holiday)",
-        "subjects_label": "Subjects (comma-separated)",
-        "teachers_label": "Teachers (comma-separated) — will cycle if fewer than subjects",
-        "classes_label": "Class list (comma-separated, e.g. 1,2,3,4,5)",
-        "start_hour": "Start hour (24h)",
-        "slot_duration": "Slot duration (hours)",
-        "slots_per_day": "Slots per day (0 = use subjects count)",
-        "export_format": "Export format",
-        "generate_btn": "Generate & Export",
-        "preview_title": "Preview (read-only)",
-        "holiday_text": "Holiday",
-        "time_col": "Time",
-        "subject_col": "Subject",
-        "teacher_col": "Teacher",
-        "download_label": "Download file"
-    },
-    "Sindhi": {
-        "title": "ٽائيم ٽيبل جنريٽر (بهتر ٿيل)",
-        "subtitle": "منفرد ۽ پيشه ور ٽائيم ٽيبل — آچر موڪت جو ڏينھن آهي.",
-        "days_label": "ڏينھن (ڪاما سان الڳ ڪريو، آچر پاڻ شامل ڪيو ويندو)",
-        "subjects_label": "مضمون (ڪاما سان الڳ ڪريو)",
-        "teachers_label": "استادن جا نالا (ڪاما سان) — مضمونن کان گهٽ هجن ته ورجايا ويندا",
-        "classes_label": "ڪلاس لسٽ (ڪاما سان، مثال: 1,2,3,4,5)",
-        "start_hour": "شروعاتي ڪلاڪ (24h)",
-        "slot_duration": "هر سيشن جو دورانيون (ڪلاڪ)",
-        "slots_per_day": "في روز سيشن (0 = مضمونن جي ڳڻپ استعمال)",
-        "export_format": "برآمد جو فارميٽ",
-        "generate_btn": "تيار ڪريو ۽ برآمد ڪريو",
-        "preview_title": "پريوئو (صرف پڙهڻ)",
-        "holiday_text": "موڪلون",
-        "time_col": "وقت",
-        "subject_col": "مضمون",
-        "teacher_col": "استاد",
-        "download_label": "فائل ڊائونلوڊ ڪريو"
-    },
-    "Urdu": {
-        "title": "خودکار وقتِ جدول جنریٹر (بہتر شدہ)",
-        "subtitle": "منفرد، پیشہ ورانہ جدول — اتوار تعطیل ہے۔",
-        "days_label": "دن (کاما سے جدا کریں، اتوار خود شامل کیا جائے گا)",
-        "subjects_label": "مضامین (کاما سے جدا کریں)",
-        "teachers_label": "اساتذہ (کاما سے جدا کریں) — تعداد کم ہو تو دہرائے جائیں گے",
-        "classes_label": "کلاس فہرست (مثال: 1,2,3,4,5)",
-        "start_hour": "شروعات کا وقت (24h)",
-        "slot_duration": "سیشن کا دورانیہ (گھنٹے)",
-        "slots_per_day": "روزانہ سیٹس (0 = مضامین کی گنتی)",
-        "export_format": "ایکسپورٹ فارمیٹ",
-        "generate_btn": "جنریٹ اور ایکسپورٹ کریں",
-        "preview_title": "پریویو (صرف پڑھیں)",
-        "holiday_text": "چھٹی",
-        "time_col": "وقت",
-        "subject_col": "مضمون",
-        "teacher_col": "استاد",
-        "download_label": "فائل ڈاؤن لوڈ کریں"
-    },
-}
-
-HOLIDAY = "Sunday"
-
-# ---------------------------
-# Core functions
-# ---------------------------
-def parse_csv_list(s: str) -> List[str]:
-    return [p.strip() for p in s.split(",") if p.strip()]
-
-def ensure_days(days: List[str]) -> List[str]:
-    # normalize and ensure Sunday is included at end
-    norm = [d.strip().capitalize() for d in days if d and d.strip()]
-    # remove duplicates preserving order
-    seen = set()
-    ordered = []
-    for d in norm:
-        if d.lower() not in seen:
-            seen.add(d.lower())
-            ordered.append(d)
-    # remove any 'Sunday' if present and re-add at end
-    ordered = [d for d in ordered if d.lower() != HOLIDAY.lower()]
-    ordered.append(HOLIDAY)
-    return ordered
-
-def build_teacher_map(subjects: List[str], teachers: List[str]) -> Dict[str, str]:
-    if not teachers:
-        return {subj: "TBD" for subj in subjects}
-    return {subj: teachers[i % len(teachers)] for i, subj in enumerate(subjects)}
-
-def generate_timetable_for_class(
-    days: List[str],
-    subjects: List[str],
-    teachers: List[str],
-    start_hour: int = 8,
-    slot_duration: int = 1,
-    slots_per_day: int = 0
-) -> Dict[str, List[Dict[str,str]]]:
-    if slots_per_day <= 0:
-        slots_per_day = len(subjects) if subjects else 0
-
-    teacher_map = build_teacher_map(subjects, teachers)
+# --------------------------------------------------
+# Helper Functions
+# --------------------------------------------------
+
+def generate_timetable(days, subjects, teachers, classes):
     timetable = {}
-    for day in days:
-        if day.lower() == HOLIDAY.lower():
-            timetable[day] = []  # holiday
-            continue
-
-        order = subjects.copy()
-        random.shuffle(order)
-        day_slots = []
-        for i in range(slots_per_day):
-            subj = order[i % len(order)] if order else "Free"
-            teacher = teacher_map.get(subj, "TBD")
-            start = (start_hour + i * slot_duration) % 24
-            end = (start_hour + (i + 1) * slot_duration) % 24
-            time_str = f"{start:02d}:00 - {end:02d}:00"
-            day_slots.append({"time": time_str, "subject": subj, "teacher": teacher})
-        timetable[day] = day_slots
+    for cls in classes:
+        class_timetable = {}
+        for day in days:
+            if day.lower() == "sunday":
+                class_timetable[day] = ["Holiday"]
+                continue
+            daily_subjects = random.sample(subjects, len(subjects))
+            daily_teachers = random.sample(teachers, len(teachers))
+            class_timetable[day] = [f"{subj} — {teacher}" for subj, teacher in zip(daily_subjects, daily_teachers)]
+        timetable[cls] = class_timetable
     return timetable
 
-def generate_full_timetable(
-    class_list: List[str],
-    days: List[str],
-    subjects: List[str],
-    teachers: List[str],
-    start_hour: int,
-    slot_duration: int,
-    slots_per_day: int
-) -> Dict[str, Dict]:
-    return {cls: generate_timetable_for_class(days, subjects, teachers, start_hour, slot_duration, slots_per_day) for cls in class_list}
-
-# ---------------------------
-# Export helpers (create temp files and return path)
-# ---------------------------
-def export_pdf_file(full_tt: Dict[str, Dict], labels: Dict[str, str]) -> str:
-    pdf = FPDF(orientation="P", unit="mm", format="A4")
-    pdf.set_auto_page_break(auto=True, margin=12)
-    pdf.add_page()
-
-    # Title
-    pdf.set_font("Helvetica", "B", 18)
-    pdf.cell(0, 10, labels["title"], ln=True, align="C")
-    pdf.ln(2)
-    pdf.set_font("Helvetica", "", 11)
-    pdf.multi_cell(0, 6, labels["subtitle"])
-    pdf.ln(6)
-
-    for cls, tt in full_tt.items():
-        pdf.set_font("Helvetica", "B", 14)
-        pdf.cell(0, 8, f"Class {cls}", ln=True)
-        pdf.ln(1)
-
-        # table header
-        pdf.set_font("Helvetica", "B", 11)
-        w_time, w_subj, w_teacher = 35, 80, 60
-        pdf.cell(w_time, 8, labels["time_col"], border=1)
-        pdf.cell(w_subj, 8, labels["subject_col"], border=1)
-        pdf.cell(w_teacher, 8, labels["teacher_col"], border=1)
-        pdf.ln(8)
-
-        pdf.set_font("Helvetica", "", 10)
-        for day, slots in tt.items():
-            pdf.set_font("Helvetica", "B", 11)
-            pdf.cell(0, 7, f"{day}", ln=True)
-            pdf.set_font("Helvetica", "", 10)
-            if not slots:
-                pdf.cell(0, 7, f"  {labels['holiday_text']}", ln=True)
-            else:
-                for s in slots:
-                    pdf.cell(w_time, 7, s["time"], border=1)
-                    # subject cell may be long; use multi_cell trick within table by moving cursor
-                    x_before = pdf.get_x()
-                    y_before = pdf.get_y()
-                    pdf.multi_cell(w_subj, 7, s["subject"], border=1)
-                    # after multicell, set cursor for teacher column: move to right of time+subject
-                    pdf.set_xy(x_before + w_subj, y_before)
-                    pdf.cell(w_teacher, 7, s["teacher"], border=1)
-                    pdf.ln(7)
-            pdf.ln(1)
-        pdf.ln(6)
-
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
-    pdf.output(tmp.name)
-    tmp.close()
-    return tmp.name
-
-def export_docx_file(full_tt: Dict[str, Dict], labels: Dict[str,str]) -> str:
+
+def format_timetable_text(timetable):
+    output = ""
+    for cls, schedule in timetable.items():
+        output += f"\n===== Class {cls} =====\n"
+        for day, entries in schedule.items():
+            output += f"{day}:\n"
+            for entry in entries:
+                output += f"  - {entry}\n"
+            output += "\n"
+    return output
+
+
+# --------------------------------------------------
+# File Export Functions
+# --------------------------------------------------
+
+def save_to_word(text):
     doc = Document()
-    doc.add_heading(labels["title"], level=0)
-    doc.add_paragraph(labels["subtitle"])
-
-    for cls, tt in full_tt.items():
-        doc.add_heading(f"Class {cls}", level=1)
-        for day, slots in tt.items():
-            doc.add_heading(day, level=2)
-            if not slots:
-                doc.add_paragraph(labels["holiday_text"])
-            else:
-                table = doc.add_table(rows=1, cols=3)
-                hdr = table.rows[0].cells
-                hdr[0].text = labels["time_col"]
-                hdr[1].text = labels["subject_col"]
-                hdr[2].text = labels["teacher_col"]
-                for s in slots:
-                    row = table.add_row().cells
-                    row[0].text = s["time"]
-                    row[1].text = s["subject"]
-                    row[2].text = s["teacher"]
-                doc.add_paragraph("")
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".docx")
-    doc.save(tmp.name)
-    tmp.close()
-    return tmp.name
-
-def export_text_file(full_tt: Dict[str, Dict], labels: Dict[str,str]) -> str:
-    lines = []
-    for cls, tt in full_tt.items():
-        lines.append(f"Class {cls}")
-        lines.append("-" * (8 + len(str(cls))))
-        for day, slots in tt.items():
-            lines.append(f"{day}:")
-            if not slots:
-                lines.append(f"  {labels['holiday_text']}")
-            else:
-                for s in slots:
-                    lines.append(f"  {s['time']} | {s['subject']} (Teacher: {s['teacher']})")
-        lines.append("")
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".txt", mode="w", encoding="utf-8")
-    tmp.write("\n".join(lines))
-    tmp.close()
-    return tmp.name
-
-# ---------------------------
-# Main handler for Gradio
-# ---------------------------
-def build_and_export(
-    language: str,
-    days_input: str,
-    subjects_input: str,
-    teachers_input: str,
-    classes_input: str,
-    start_hour: int,
-    slot_duration: int,
-    slots_per_day: int,
-    export_format: str
-) -> Tuple[str, object]:
-    labels = LANG_MAP.get(language, LANG_MAP["English"])
-
-    days = parse_csv_list(days_input)
-    days = ensure_days(days)
-    subjects = [s.title() for s in parse_csv_list(subjects_input)]
-    teachers = [t.title() for t in parse_csv_list(teachers_input)]
-    class_list = parse_csv_list(classes_input)
-
-    if not days or not subjects or not class_list:
-        return ("Please enter Days, Subjects and Class list (comma-separated).", None)
-
-    full_tt = generate_full_timetable(class_list, days, subjects, teachers, start_hour, slot_duration, slots_per_day)
-
-    # Prepare preview text
-    lines = []
-    for cls, tt in full_tt.items():
-        lines.append(f"Class {cls}")
-        lines.append("-" * (8 + len(str(cls))))
-        for day, slots in tt.items():
-            lines.append(f"{day}:")
-            if not slots:
-                lines.append(f"  {labels['holiday_text']}")
-            else:
-                for s in slots:
-                    lines.append(f"  {s['time']} | {s['subject']} (Teacher: {s['teacher']})")
-        lines.append("")
-    preview_text = "\n".join(lines)
-
-    # Export file and return a path that Gradio can present as a File
-    if export_format == "PDF":
-        file_path = export_pdf_file(full_tt, labels)
-    elif export_format == "Word":
-        file_path = export_docx_file(full_tt, labels)
-    elif export_format == "Text":
-        file_path = export_text_file(full_tt, labels)
-    else:
-        file_path = None
-
-    return preview_text, file_path
-
-# ---------------------------
-# Gradio UI definition
-# ---------------------------
-css = """
-.gradio-container { max-width: 1100px; margin: auto; font-family: Arial, Helvetica, sans-serif; }
-.header-title { font-weight: 700; margin-left: 12px; }
-"""
-
-with gr.Blocks(title="Automatic Time Table Generation (Improved)", css=css) as demo:
+    doc.add_heading("Automatic Timetable", level=1)
+    doc.add_paragraph(text)
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".docx")
+    doc.save(temp.name)
+    return temp.name
+
+
+def save_to_text(text):
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".txt")
+    with open(temp.name, "w", encoding="utf-8") as f:
+        f.write(text)
+    return temp.name
+
+
+def save_to_excel(timetable):
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Timetable"
+
+    ws.append(["Class", "Day", "Schedule"])
+
+    for cls, schedule in timetable.items():
+        for day, entries in schedule.items():
+            ws.append([cls, day, ", ".join(entries)])
+
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
+    wb.save(temp.name)
+    return temp.name
+
+
+def save_to_ppt(timetable):
+    prs = Presentation()
+    title_slide_layout = prs.slide_layouts[1]
+
+    for cls, schedule in timetable.items():
+        slide = prs.slides.add_slide(title_slide_layout)
+        title = slide.shapes.title
+        body = slide.placeholders[1]
+
+        title.text = f"Class {cls} Timetable"
+        text_frame = body.text_frame
+
+        for day, entries in schedule.items():
+            text_frame.add_paragraph().text = f"{day}: {', '.join(entries)}"
+
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".pptx")
+    prs.save(temp.name)
+    return temp.name
+
+
+
+# --------------------------------------------------
+# Main Function
+# --------------------------------------------------
+
+def generate(days_input, subjects_input, teachers_input, classes_input, language):
+    days = [d.strip().capitalize() for d in days_input.split(",") if d.strip()]
+    subjects = [s.strip().capitalize() for s in subjects_input.split(",") if s.strip()]
+    teachers = [t.strip().capitalize() for t in teachers_input.split(",") if t.strip()]
+    classes = [c.strip() for c in classes_input.split(",") if c.strip()]
+
+    if not days or not subjects or not teachers or not classes:
+        return "⚠️ Please fill all fields.", None, None, None, None
+
+    timetable = generate_timetable(days, subjects, teachers, classes)
+    text_output = format_timetable_text(timetable)
+
+    # Save files
+    doc_file = save_to_word(text_output)
+    txt_file = save_to_text(text_output)
+    excel_file = save_to_excel(timetable)
+    ppt_file = save_to_ppt(timetable)
+
+    return text_output, doc_file, txt_file, excel_file, ppt_file
+
+
+
+# --------------------------------------------------
+# Gradio UI
+# --------------------------------------------------
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Automatic Time Table Generator (Improved)") as demo:
+    gr.Markdown("""
+    # 🗓️ Automatic Time Table Generation Agent (Improved)
+    **Generate easy, unique, and stylish timetables**  
+    Export to **Word, Excel, PowerPoint, and Text**  
+    Includes multi-language option, teacher names, class list, and Sunday holiday.
+    """)
+
     with gr.Row():
-        language = gr.Dropdown(list(LANG_MAP.keys()), value="English", label="Language /  ٻولي / زبان")
-        gr.Markdown("<h2 class='header-title'>Automatic Time Table Generation Agent (Improved)</h2>")
+        language = gr.Dropdown(["English", "Sindhi", "Urdu", "Other"], label="Select Language", value="English")
 
     with gr.Row():
-        with gr.Column(scale=2):
-            days_input = gr.Textbox(label=LANG_MAP["English"]["days_label"], value="Monday, Tuesday, Wednesday, Thursday, Friday, Saturday")
-            subjects_input = gr.Textbox(label=LANG_MAP["English"]["subjects_label"], value="Math, English, Science, History, Art")
-            teachers_input = gr.Textbox(label=LANG_MAP["English"]["teachers_label"], value="Mr. Khan, Ms. Ali, Mr. Iqbal")
-            classes_input = gr.Textbox(label=LANG_MAP["English"]["classes_label"], value="1,2,3,4,5")
-
-            with gr.Row():
-                start_hour = gr.Slider(6, 10, value=8, step=1, label=LANG_MAP["English"]["start_hour"])
-                slot_duration = gr.Slider(1, 3, value=1, step=1, label=LANG_MAP["English"]["slot_duration"])
-
-            slots_per_day = gr.Number(label=LANG_MAP["English"]["slots_per_day"], value=0)
-            export_format = gr.Dropdown(["None", "PDF", "Word", "Text"], value="PDF", label=LANG_MAP["English"]["export_format"])
-            generate_btn = gr.Button(LANG_MAP["English"]["generate_btn"], variant="primary")
-
-        with gr.Column(scale=1):
-            preview = gr.Textbox(label=LANG_MAP["English"]["preview_title"], lines=20, interactive=False)
-            download = gr.File(label=LANG_MAP["English"]["download_label"])
-
-    # Update labels when language changes
-    def update_labels(selected_lang):
-        labels = LANG_MAP.get(selected_lang, LANG_MAP["English"])
-        return (
-            gr.update(label=labels["days_label"]),
-            gr.update(label=labels["subjects_label"]),
-            gr.update(label=labels["teachers_label"]),
-            gr.update(label=labels["classes_label"]),
-            gr.update(label=labels["start_hour"]),
-            gr.update(label=labels["slot_duration"]),
-            gr.update(label=labels["slots_per_day"]),
-            gr.update(label=labels["export_format"]),
-            gr.update(value=labels["generate_btn"]),
-            gr.update(label=labels["download_label"]),
-            gr.update(label=labels["preview_title"])
-        )
-
-    language.change(
-        fn=update_labels,
-        inputs=[language],
-        outputs=[
-            days_input, subjects_input, teachers_input, classes_input,
-            start_hour, slot_duration, slots_per_day, export_format, generate_btn,
-            download, preview
-        ],
-    )
+        days_input = gr.Textbox(label="Days (comma-separated)",
+                                value="Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday")
+        classes_input = gr.Textbox(label="Class List", value="1, 2, 3, 4, 5")
+
+    subjects_input = gr.Textbox(label="Subjects", value="Math, English, Science, History, Art")
+    teachers_input = gr.Textbox(label="Teacher Names", value="Mr. Ali, Ms. Fatima, Mr. Khan, Ms. Sara, Mr. Ahmed")
+
+    generate_btn = gr.Button("✨ Generate Timetable")
+
+    output_text = gr.Textbox(label="Generated Timetable", lines=15)
+    doc_output = gr.File(label="📝 Download Word (.docx)")
+    txt_output = gr.File(label="📃 Download Text (.txt)")
+    excel_output = gr.File(label="📊 Download Excel (.xlsx)")
+    ppt_output = gr.File(label="📽️ Download PowerPoint (.pptx)")
 
     generate_btn.click(
-        fn=build_and_export,
-        inputs=[language, days_input, subjects_input, teachers_input, classes_input, start_hour, slot_duration, slots_per_day, export_format],
-        outputs=[preview, download]
+        fn=generate,
+        inputs=[days_input, subjects_input, teachers_input, classes_input, language],
+        outputs=[output_text, doc_output, txt_output, excel_output, ppt_output]
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", share=False)
+    demo.launch(server_name="0.0.0.0", share=True)