Update timetable.py

timetable.py

@@ -2,80 +2,104 @@ import pandas as pd
 import random
 
 DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
+# Time slots with duration in hours
 TIME_SLOTS = ["9:00-10:00", "10:00-11:00", "11:00-12:30", "12:30-1:30", "1:30-3:00"]
+MAX_SLOT_DURATION = {"9:00-10:00": 1.0, "10:00-11:00":1.0, "11:00-12:30":1.5,
+                     "12:30-1:30":1.0, "1:30-3:00":1.5}
 
-def split_course_hours(courses_df):
-    """
-    Split total weekly hours into chunks of max 1.5 hours per day.
-    Returns a list of dicts with course, teacher, duration.
-    """
+def split_course_hours(hours):
+    """Split weekly hours into chunks <=1.5 per day"""
+    chunks = []
+    remaining = hours
+    while remaining > 0:
+        dur = 1.5 if remaining >= 1.5 else 1.0
+        chunks.append(dur)
+        remaining -= dur
+    return chunks
+
+def generate_class_timetable(class_courses, rooms, teacher_schedule, room_schedule):
+    """Generate timetable for a single class"""
+    timetable = {day: [None]*len(TIME_SLOTS) for day in DAYS}
+
+    # Prepare course blocks
     course_blocks = []
-    for _, row in courses_df.iterrows():
-        remaining = row['Hours']
-        while remaining > 0:
-            dur = 1.5 if remaining >= 1.5 else 1.0
+    for _, row in class_courses.iterrows():
+        chunks = split_course_hours(row['Hours'])
+        for dur in chunks:
             course_blocks.append({
                 "Course": row['Course'],
                 "Teacher": row['Teacher'],
                 "Duration": dur
             })
-            remaining -= dur
-    return course_blocks
 
+    random.shuffle(course_blocks)
 
-def generate_timetable(courses_path, rooms_path):
-    courses = pd.read_csv(courses_path)
-    rooms = pd.read_csv(rooms_path)["Room"].tolist()
+    for block in course_blocks:
+        allocated = False
+        random_days = DAYS.copy()
+        random.shuffle(random_days)
 
-    course_blocks = split_course_hours(courses)
+        for day in random_days:
+            for idx, slot in enumerate(TIME_SLOTS):
+                slot_max = MAX_SLOT_DURATION[slot]
+                if timetable[day][idx] is None and block['Duration'] <= slot_max:
+                    teacher = block['Teacher']
 
-    # Initialize timetable dictionary: one list per day
-    timetable = {day: [] for day in DAYS}
-    teacher_last_slot = {t: None for t in courses['Teacher'].unique()}
+                    # Check teacher availability
+                    if teacher_schedule.get((teacher, day, idx), False):
+                        continue
 
-    for day in DAYS:
-        available_slots = TIME_SLOTS.copy()
-        random.shuffle(course_blocks)  # Randomize to reduce conflicts
-        day_schedule = []
-
-        i = 0
-        while i < len(course_blocks) and available_slots:
-            block = course_blocks[i]
-            teacher = block['Teacher']
-
-            # Check teacher consecutive slot
-            if teacher_last_slot[teacher] == day and available_slots:
-                i += 1
-                continue
-
-            slot = available_slots.pop(0)
-            room = rooms[i % len(rooms)]
-
-            day_schedule.append({
-                "Time": slot,
-                "Course": block['Course'],
-                "Teacher": teacher,
-                "Room": room
-            })
+                    # Check room availability
+                    available_room = None
+                    for room in rooms:
+                        if not room_schedule.get((room, day, idx), False):
+                            available_room = room
+                            break
+                    if not available_room:
+                        continue
+
+                    # Assign course
+                    timetable[day][idx] = f"{block['Course']} ({teacher}) [{available_room}]"
+
+                    # Mark teacher and room as busy
+                    teacher_schedule[(teacher, day, idx)] = True
+                    room_schedule[(available_room, day, idx)] = True
 
-            teacher_last_slot[teacher] = day
-            # Remove block from list if allocated
-            course_blocks.pop(i)
-        timetable[day] = day_schedule
+                    allocated = True
+                    break
+            if allocated:
+                break
+        if not allocated:
+            print(f"⚠️ Could not allocate: {block['Course']} ({block['Teacher']})")
 
-    # Convert timetable dict to printable DataFrame
-    max_columns = max(len(v) for v in timetable.values())
-    table_data = []
+    return timetable
 
+def timetable_to_dataframe(timetable, class_name):
+    """Convert timetable dict to DataFrame"""
+    max_slots = len(TIME_SLOTS)
+    data = []
     for day in DAYS:
-        row = [day]
-        for cls in timetable[day]:
-            row.append(f"{cls['Course']} ({cls['Teacher']})\n{cls['Time']}")
-        # Fill remaining columns with empty
-        while len(row) <= max_columns:
-            row.append("")
-        table_data.append(row)
-
-    columns = ["Day"] + [f"Slot {i+1}" for i in range(max_columns)]
-    df = pd.DataFrame(table_data, columns=columns)
+        row = [day] + [timetable[day][i] if timetable[day][i] else "" for i in range(max_slots)]
+        data.append(row)
+
+    columns = ["Day"] + [f"Slot {i+1}" for i in range(max_slots)]
+    df = pd.DataFrame(data, columns=columns)
+    df.insert(0, "Class/Program", class_name)
     return df
+
+def generate_full_timetable(courses_path, rooms_path):
+    courses_df = pd.read_csv(courses_path)
+    rooms_df = pd.read_csv(rooms_path)
+    rooms = rooms_df['Room'].tolist()
+
+    full_df = pd.DataFrame()
+    teacher_schedule = {}  # Track teacher occupied slots across all classes
+    room_schedule = {}     # Track room occupied slots across all classes
+
+    for class_name in courses_df['Class'].unique():
+        class_courses = courses_df[courses_df['Class']==class_name]
+        timetable = generate_class_timetable(class_courses, rooms, teacher_schedule, room_schedule)
+        df = timetable_to_dataframe(timetable, class_name)
+        full_df = pd.concat([full_df, df], ignore_index=True)
+
+    return full_df