Update timetable.py

timetable.py

@@ -1,105 +1,64 @@
 import pandas as pd
+import numpy as np
 import random
 
+TIME_SLOTS = ["9:00-10:30", "10:30-12:00", "12:00-1:30", "1:30-3:00"]
 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(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 class_courses.iterrows():
-        chunks = split_course_hours(row['Hours'])
-        for dur in chunks:
-            course_blocks.append({
-                "Course": row['Course'],
-                "Teacher": row['Teacher'],
-                "Duration": dur
-            })
-
-    random.shuffle(course_blocks)
-
-    for block in course_blocks:
-        allocated = False
-        random_days = DAYS.copy()
-        random.shuffle(random_days)
-
-        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']
-
-                    # Check teacher availability
-                    if teacher_schedule.get((teacher, day, idx), False):
-                        continue
-
-                    # 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
-
-                    allocated = True
+def generate_timetable(courses_file, rooms_file):
+    courses_df = pd.read_csv(courses_file)
+    rooms = pd.read_csv(rooms_file)["Room"].tolist()
+
+    timetable_dict = {}
+
+    for cls in courses_df["Class"].unique():
+        cls_df = courses_df[courses_df["Class"] == cls].copy()
+        timetable = {day: [None]*len(TIME_SLOTS) for day in DAYS}
+        teacher_slots = {teacher: {day: [] for day in DAYS} for teacher in cls_df["Teacher"].unique()}
+        room_slots = {room: {day: [] for day in DAYS} for room in rooms}
+
+        # Split course hours into 1.5-hour blocks
+        course_blocks = []
+        for idx, row in cls_df.iterrows():
+            remaining_hours = row["Hours"]
+            while remaining_hours > 0:
+                block_hours = min(1.5, remaining_hours)
+                course_blocks.append({
+                    "Course": row["Course"],
+                    "Teacher": row["Teacher"],
+                    "Hours": block_hours,
+                    "Class": row["Class"]
+                })
+                remaining_hours -= block_hours
+
+        random.shuffle(course_blocks)
+
+        # Assign courses to slots
+        for block in course_blocks:
+            assigned = False
+            for day in DAYS:
+                for i, slot in enumerate(TIME_SLOTS):
+                    if timetable[day][i] is None:
+                        # Check teacher and room conflicts
+                        teacher = block["Teacher"]
+                        available_rooms = [r for r in rooms if i not in room_slots[r][day]]
+                        if i in teacher_slots[teacher][day]:
+                            continue
+                        if not available_rooms:
+                            continue
+                        room = random.choice(available_rooms)
+                        timetable[day][i] = f"{block['Course']}\n{block['Teacher']}\n{room}\n{block['Hours']}h"
+                        teacher_slots[teacher][day].append(i)
+                        room_slots[room][day].append(i)
+                        assigned = True
+                        break
+                if assigned:
                     break
-            if allocated:
-                break
-        if not allocated:
-            print(f"⚠️ Could not allocate: {block['Course']} ({block['Teacher']})")
-
-    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] + [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
+            if not assigned:
+                print(f"Could not assign {block['Course']} for {cls}")
 
-    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)
+        # Convert timetable to DataFrame
+        df = pd.DataFrame(timetable, index=TIME_SLOTS)
+        timetable_dict[cls] = df
 
-    return full_df
+    return timetable_dict