Create app.py

app.py

@@ -1,27 +1,34 @@
 """
 Automatic Time Table Generation Agent (Improved)
-- Gradio app for Hugging Face Spaces
-- Features: multi-class, teacher names, Sunday holiday, PDF/DOCX/TXT exports, language selection
-- Save as app.py in your Space
+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 datetime
-from typing import List, Dict, Tuple
+import tempfile
+from typing import Dict, List, Tuple
 
 import gradio as gr
 from fpdf import FPDF
 from docx import Document
 
 # ---------------------------
-# Localization (UI + headings)
+# 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 added automatically)",
+        "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)",
@@ -30,17 +37,17 @@ LANG_MAP = {
         "slots_per_day": "Slots per day (0 = use subjects count)",
         "export_format": "Export format",
         "generate_btn": "Generate & Export",
-        "preview_title": "Preview",
+        "preview_title": "Preview (read-only)",
         "holiday_text": "Holiday",
         "time_col": "Time",
         "subject_col": "Subject",
         "teacher_col": "Teacher",
+        "download_label": "Download file"
     },
     "Sindhi": {
-        # Sindhi translations (basic, short labels). Adjust phrasing as needed.
         "title": "ٽائيم ٽيبل جنريٽر (بهتر ٿيل)",
-        "subtitle": "منفرد ٽائيم ٽيبل — آچر آرام جو ڏينھن آهي.",
-        "days_label": "ڏينھن (ڪاما سان الڳ ڪريو، آچر پاڻمرادو شامل ڪيو ويندو)",
+        "subtitle": "منفرد ۽ پيشه ور ٽائيم ٽيبل — آچر موڪت جو ڏينھن آهي.",
+        "days_label": "ڏينھن (ڪاما سان الڳ ڪريو، آچر پاڻ شامل ڪيو ويندو)",
         "subjects_label": "مضمون (ڪاما سان الڳ ڪريو)",
         "teachers_label": "استادن جا نالا (ڪاما سان) — مضمونن کان گهٽ هجن ته ورجايا ويندا",
         "classes_label": "ڪلاس لسٽ (ڪاما سان، مثال: 1,2,3,4,5)",
@@ -49,50 +56,56 @@ LANG_MAP = {
         "slots_per_day": "في روز سيشن (0 = مضمونن جي ڳڻپ استعمال)",
         "export_format": "برآمد جو فارميٽ",
         "generate_btn": "تيار ڪريو ۽ برآمد ڪريو",
-        "preview_title": "پريوئو",
+        "preview_title": "پريوئو (صرف پڙهڻ)",
         "holiday_text": "موڪلون",
         "time_col": "وقت",
         "subject_col": "مضمون",
         "teacher_col": "استاد",
+        "download_label": "فائل ڊائونلوڊ ڪريو"
     },
     "Urdu": {
         "title": "خودکار وقتِ جدول جنریٹر (بہتر شدہ)",
-        "subtitle": "منفرد، پیشہ ورانہ جدول — اتوار بطور تعطیل شامل ہے۔",
-        "days_label": "دن (کاما سے جدا کریں، اتوار خود شامل ہوگا)",
+        "subtitle": "منفرد، پیشہ ورانہ جدول — اتوار تعطیل ہے۔",
+        "days_label": "دن (کاما سے جدا کریں، اتوار خود شامل کیا جائے گا)",
         "subjects_label": "مضامین (کاما سے جدا کریں)",
-        "teachers_label": "اساتذہ (کاما سے جدا کریں) — اگر کم ہوں گے تو دہرائے جائیں گے",
-        "classes_label": "کلاس فہرست (کاما سے، مثال: 1,2,3,4,5)",
-        "start_hour": "شروع کا وقت (24h)",
+        "teachers_label": "اساتذہ (کاما سے جدا کریں) — تعداد کم ہو تو دہرائے جائیں گے",
+        "classes_label": "کلاس فہرست (مثال: 1,2,3,4,5)",
+        "start_hour": "شروعات کا وقت (24h)",
         "slot_duration": "سیشن کا دورانیہ (گھنٹے)",
         "slots_per_day": "روزانہ سیٹس (0 = مضامین کی گنتی)",
         "export_format": "ایکسپورٹ فارمیٹ",
         "generate_btn": "جنریٹ اور ایکسپورٹ کریں",
-        "preview_title": "پریویو",
+        "preview_title": "پریویو (صرف پڑھیں)",
         "holiday_text": "چھٹی",
         "time_col": "وقت",
         "subject_col": "مضمون",
         "teacher_col": "استاد",
+        "download_label": "فائل ڈاؤن لوڈ کریں"
     },
 }
 
-# ---------------------------
-# Core timetable logic
-# ---------------------------
 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: capitalize each day
-    days = [d.strip().capitalize() for d in days if d and d.strip()]
-    # If user omitted Sunday, we will add it for display/honoring holiday
-    if HOLIDAY not in days:
-        # Keep working order Mon..Sat then Sunday last
-        base = [d for d in days if d.lower() != HOLIDAY.lower()]
-        base.append(HOLIDAY)
-        days = base
-    return days
+    # 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:
@@ -105,12 +118,8 @@ def generate_timetable_for_class(
     teachers: List[str],
     start_hour: int = 8,
     slot_duration: int = 1,
-    slots_per_day: int = 0,
+    slots_per_day: int = 0
 ) -> Dict[str, List[Dict[str,str]]]:
-    """
-    Returns: {day: [ {time, subject, teacher}, ... ], ... }
-    Sunday returns empty list to mark holiday.
-    """
     if slots_per_day <= 0:
         slots_per_day = len(subjects) if subjects else 0
 
@@ -118,10 +127,9 @@ def generate_timetable_for_class(
     timetable = {}
     for day in days:
         if day.lower() == HOLIDAY.lower():
-            timetable[day] = []  # holiday marker
+            timetable[day] = []  # holiday
             continue
 
-        # create a copy and shuffle for uniqueness
         order = subjects.copy()
         random.shuffle(order)
         day_slots = []
@@ -142,121 +150,113 @@ def generate_full_timetable(
     teachers: List[str],
     start_hour: int,
     slot_duration: int,
-    slots_per_day: int,
+    slots_per_day: int
 ) -> Dict[str, Dict]:
-    output = {}
-    for cls in class_list:
-        output[cls] = generate_timetable_for_class(days, subjects, teachers, start_hour, slot_duration, slots_per_day)
-    return output
+    return {cls: generate_timetable_for_class(days, subjects, teachers, start_hour, slot_duration, slots_per_day) for cls in class_list}
 
 # ---------------------------
-# Export helpers (return BytesIO)
+# Export helpers (create temp files and return path)
 # ---------------------------
-
-class StyledPDF(FPDF):
-    def header(self):
-        # small header spacing
-        self.set_font("Helvetica", "", 9)
-        self.cell(0, 6, "", ln=True)
-
-def export_pdf_bytes(full_tt: Dict[str, Dict], lang_labels: Dict[str,str]) -> io.BytesIO:
-    pdf = StyledPDF(orientation="P", unit="mm", format="A4")
+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, lang_labels["title"], ln=True, align="C")
+    pdf.cell(0, 10, labels["title"], ln=True, align="C")
     pdf.ln(2)
     pdf.set_font("Helvetica", "", 11)
-    pdf.multi_cell(0, 6, lang_labels["subtitle"])
-    pdf.ln(4)
+    pdf.multi_cell(0, 6, labels["subtitle"])
+    pdf.ln(6)
 
-    # Per class tables
-    for class_name, tt in full_tt.items():
+    for cls, tt in full_tt.items():
         pdf.set_font("Helvetica", "B", 14)
-        pdf.cell(0, 8, f"Class {class_name}", ln=True)
+        pdf.cell(0, 8, f"Class {cls}", ln=True)
         pdf.ln(1)
 
-        # Table header
+        # table header
         pdf.set_font("Helvetica", "B", 11)
         w_time, w_subj, w_teacher = 35, 80, 60
-        pdf.cell(w_time, 8, lang_labels["time_col"], border=1)
-        pdf.cell(w_subj, 8, lang_labels["subject_col"], border=1)
-        pdf.cell(w_teacher, 8, lang_labels["teacher_col"], border=1)
+        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():
-            # Day row
             pdf.set_font("Helvetica", "B", 11)
             pdf.cell(0, 7, f"{day}", ln=True)
             pdf.set_font("Helvetica", "", 10)
             if not slots:
-                # holiday
-                pdf.cell(0, 7, f"  {lang_labels['holiday_text']}", ln=True)
+                pdf.cell(0, 7, f"  {labels['holiday_text']}", ln=True)
             else:
                 for s in slots:
                     pdf.cell(w_time, 7, s["time"], border=1)
-                    pdf.cell(w_subj, 7, s["subject"], 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(4)
+        pdf.ln(6)
 
-    bio = io.BytesIO()
-    pdf.output(bio)
-    bio.seek(0)
-    return bio
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+    pdf.output(tmp.name)
+    tmp.close()
+    return tmp.name
 
-def export_docx_bytes(full_tt: Dict[str, Dict], lang_labels: Dict[str,str]) -> io.BytesIO:
+def export_docx_file(full_tt: Dict[str, Dict], labels: Dict[str,str]) -> str:
     doc = Document()
-    doc.add_heading(lang_labels["title"], level=0)
-    doc.add_paragraph(lang_labels["subtitle"])
+    doc.add_heading(labels["title"], level=0)
+    doc.add_paragraph(labels["subtitle"])
 
-    for class_name, tt in full_tt.items():
-        doc.add_heading(f"Class {class_name}", level=1)
+    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(f"{lang_labels['holiday_text']}")
+                doc.add_paragraph(labels["holiday_text"])
             else:
                 table = doc.add_table(rows=1, cols=3)
                 hdr = table.rows[0].cells
-                hdr[0].text = lang_labels["time_col"]
-                hdr[1].text = lang_labels["subject_col"]
-                hdr[2].text = lang_labels["teacher_col"]
+                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("")  # small space
-    bio = io.BytesIO()
-    doc.save(bio)
-    bio.seek(0)
-    return bio
+                doc.add_paragraph("")
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".docx")
+    doc.save(tmp.name)
+    tmp.close()
+    return tmp.name
 
-def export_text_bytes(full_tt: Dict[str, Dict], lang_labels: Dict[str,str]) -> io.BytesIO:
+def export_text_file(full_tt: Dict[str, Dict], labels: Dict[str,str]) -> str:
     lines = []
-    for class_name, tt in full_tt.items():
-        lines.append(f"Class {class_name}")
-        lines.append("-" * (8 + len(str(class_name))))
+    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"  {lang_labels['holiday_text']}")
+                lines.append(f"  {labels['holiday_text']}")
             else:
                 for s in slots:
                     lines.append(f"  {s['time']} | {s['subject']} (Teacher: {s['teacher']})")
-        lines.append("")  # blank line between classes
-    txt = "\n".join(lines)
-    bio = io.BytesIO()
-    bio.write(txt.encode("utf-8"))
-    bio.seek(0)
-    return bio
+        lines.append("")
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".txt", mode="w", encoding="utf-8")
+    tmp.write("\n".join(lines))
+    tmp.close()
+    return tmp.name
 
 # ---------------------------
-# Gradio app function
+# Main handler for Gradio
 # ---------------------------
 def build_and_export(
     language: str,
@@ -267,66 +267,60 @@ def build_and_export(
     start_hour: int,
     slot_duration: int,
     slots_per_day: int,
-    export_format: str,
-) -> Tuple[str, Tuple]:
+    export_format: str
+) -> Tuple[str, object]:
     labels = LANG_MAP.get(language, LANG_MAP["English"])
 
-    # parse inputs
     days = parse_csv_list(days_input)
-    days = ensure_days(days)  # ensures Sunday included last
+    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)
 
-    # Basic validation
     if not days or not subjects or not class_list:
-        return ("Please enter Days, Subjects and Classes (comma-separated).", None)
+        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)
 
-    # Create a human readable preview
-    preview_lines = []
+    # Prepare preview text
+    lines = []
     for cls, tt in full_tt.items():
-        preview_lines.append(f"Class {cls}")
-        preview_lines.append("-" * (8 + len(str(cls))))
+        lines.append(f"Class {cls}")
+        lines.append("-" * (8 + len(str(cls))))
         for day, slots in tt.items():
-            preview_lines.append(f"{day}:")
+            lines.append(f"{day}:")
             if not slots:
-                preview_lines.append(f"  {labels['holiday_text']}")
+                lines.append(f"  {labels['holiday_text']}")
             else:
                 for s in slots:
-                    preview_lines.append(f"  {s['time']} | {s['subject']} (Teacher: {s['teacher']})")
-        preview_lines.append("")
-    preview_text = "\n".join(preview_lines)
+                    lines.append(f"  {s['time']} | {s['subject']} (Teacher: {s['teacher']})")
+        lines.append("")
+    preview_text = "\n".join(lines)
 
-    # Export
-    file_tuple = None
+    # Export file and return a path that Gradio can present as a File
     if export_format == "PDF":
-        bio = export_pdf_bytes(full_tt, labels)
-        file_tuple = ("timetable.pdf", bio, "application/pdf")
+        file_path = export_pdf_file(full_tt, labels)
     elif export_format == "Word":
-        bio = export_docx_bytes(full_tt, labels)
-        file_tuple = ("timetable.docx", bio, "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+        file_path = export_docx_file(full_tt, labels)
     elif export_format == "Text":
-        bio = export_text_bytes(full_tt, labels)
-        file_tuple = ("timetable.txt", bio, "text/plain")
+        file_path = export_text_file(full_tt, labels)
     else:
-        file_tuple = None
+        file_path = None
 
-    return preview_text, file_tuple
+    return preview_text, file_path
 
 # ---------------------------
-# Gradio UI
+# Gradio UI definition
 # ---------------------------
-with gr.Blocks(title="Automatic Time Table Generation (Improved)", css="""
-    .gradio-container { max-width: 1100px; margin: auto; }
-    .title { font-family: 'Helvetica'; }
-""") as demo:
+css = """
+.gradio-container { max-width: 1100px; margin: auto; font-family: Arial, Helvetica, sans-serif; }
+.header-title { font-weight: 700; margin-left: 12px; }
+"""
 
-    # Top row: language + title
+with gr.Blocks(title="Automatic Time Table Generation (Improved)", css=css) as demo:
     with gr.Row():
-        language = gr.Dropdown(list(LANG_MAP.keys()), value="English", label="Language / ٻولي / زبان")
-        gr.Markdown("<h2 style='margin-left:16px'>Automatic Time Table Generation Agent (Improved)</h2>")
+        language = gr.Dropdown(list(LANG_MAP.keys()), value="English", label="Language /  ٻولي / زبان")
+        gr.Markdown("<h2 class='header-title'>Automatic Time Table Generation Agent (Improved)</h2>")
 
     with gr.Row():
         with gr.Column(scale=2):
@@ -338,16 +332,16 @@ with gr.Blocks(title="Automatic Time Table Generation (Improved)", css="""
             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)
 
+            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="Download file")
+            download = gr.File(label=LANG_MAP["English"]["download_label"])
 
-    # Update label language when dropdown changes (client-side)
+    # Update labels when language changes
     def update_labels(selected_lang):
         labels = LANG_MAP.get(selected_lang, LANG_MAP["English"])
         return (
@@ -359,7 +353,9 @@ with gr.Blocks(title="Automatic Time Table Generation (Improved)", css="""
             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(value=labels["generate_btn"]),
+            gr.update(label=labels["download_label"]),
+            gr.update(label=labels["preview_title"])
         )
 
     language.change(
@@ -367,14 +363,15 @@ with gr.Blocks(title="Automatic Time Table Generation (Improved)", css="""
         inputs=[language],
         outputs=[
             days_input, subjects_input, teachers_input, classes_input,
-            start_hour, slot_duration, slots_per_day, export_format, generate_btn
-        ]
+            start_hour, slot_duration, slots_per_day, export_format, generate_btn,
+            download, preview
+        ],
     )
 
     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],
+        outputs=[preview, download]
     )
 
 if __name__ == "__main__":