Super-squash branch 'main' using huggingface_hub

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all project files
+COPY . .
+
+# Expose both ports (7860 = FastAPI/public, 8501 = Streamlit/internal)
+EXPOSE 7860
+EXPOSE 8501
+
+# Start FastAPI on 7860 (public) + Streamlit on 8501 (internal/background)
+CMD streamlit run app.py --server.port 8501 --server.address 0.0.0.0 & \
+    uvicorn api:app --host 0.0.0.0 --port 7860

Procfile

@@ -0,0 +1 @@
+web: uvicorn api:app --host 0.0.0.0 --port 7861 & streamlit run app.py --server.port 7860 --server.address 0.0.0.0

README.md

@@ -0,0 +1,10 @@
+---
+title: Timetable Gen
+emoji: 🗓️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+---
+
+# Timetable Generator

api.py

@@ -0,0 +1,1866 @@
+from fastapi import FastAPI, HTTPException, File, UploadFile, Body
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+from collections import defaultdict
+import traceback
+from datetime import datetime
+
+from storage import (
+    load_data, save_data,
+    save_schedule, save_original_schedule,
+    schedule_exists, load_schedule,
+    original_schedule_exists, load_original_schedule,
+    load_history, add_history_entry, save_history,
+    clear_schedule, clear_history, clear_original_schedule,
+    save_version, load_versions, restore_version,
+)
+from models import Faculty, Subject, Section, Room, SubjectType
+from data_loader import Allocation, prepare_scheduling_tasks
+from solver import TimetableSolver
+from partial_optimizer import PartialOptimizer
+from slm_inference import get_constraints_batch, smart_parse, get_constraint, check_api_health
+from substitution_engine import (
+    process_leave_approval, handle_acceptance, handle_decline, check_timeouts
+)
+from storage import (
+    load_leave_requests, save_leave_requests, load_substitution_requests,
+    save_substitution_requests, load_cancellations, save_cancellations
+)
+from models import LeaveRequest, LeaveStatus
+import uuid
+import constants as const
+
+app = FastAPI(title="VTU Timetable Generator API", version="2.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# INTERNAL HELPERS
+# ═════════════════════════════════════════════════════════════════════════════
+
+def _subject_type(type_str: str) -> SubjectType:
+    return {
+        "THEORY": SubjectType.THEORY,
+        "LAB": SubjectType.LAB,
+        "SOFTSKILL": SubjectType.SOFTSKILL,
+        "FORUM": SubjectType.FORUM,
+    }.get(type_str.upper(), SubjectType.THEORY)
+
+
+def _build_objects(data: dict):
+    """Convert raw JSON data dicts into domain model objects."""
+    facs = [Faculty(f["id"], f["name"], f["designation"], f["max_hours"])
+            for f in data["faculties"]]
+    subs = [Subject(s["code"], s["name"], s["credits"],
+                    _subject_type(s["type"]),
+                    s.get("is_core", True), s.get("is_heavy", False))
+            for s in data["subjects"]]
+    secs = [Section(s["id"], s["semester"], s["strength"], s.get("home_room_id"))
+            for s in data["sections"]]
+    rooms = [Room(r["id"], r["capacity"], r["is_lab"], r["building"])
+             for r in data["rooms"]]
+    allocs = [Allocation(a["faculty_id"], a["subject_code"],
+                         a["section_id"], a.get("elective_group"))
+              for a in data["allocations"]]
+    return facs, subs, secs, rooms, allocs
+
+
+def _clean(solution: dict) -> dict:
+    """Remove non-serialisable task_obj from solution."""
+    return {k: {kk: vv for kk, vv in v.items() if kk != "task_obj"}
+            for k, v in solution.items()}
+
+def diff_schedules(old_sched: dict, new_sched: dict):
+    changes = []
+    affected_sections = set()
+    all_keys = set(old_sched.keys()) | set(new_sched.keys())
+    for k in all_keys:
+        old_val = old_sched.get(k)
+        new_val = new_sched.get(k)
+        if old_val != new_val:
+            changes.append({
+                "task_id": k,
+                "before": old_val,
+                "after": new_val
+            })
+            if old_val: affected_sections.add(old_val.get("section_id", "").split("-")[0].upper())
+            if new_val: affected_sections.add(new_val.get("section_id", "").split("-")[0].upper())
+    return changes, list(affected_sections)
+
+
+def _build_grid(solution: dict, allocations: list = None) -> dict:
+    """
+    Merge sub-sections (6a-E1, 6a-E2) into their parent (6A) —
+    exactly what render_timetable_html does in app.py.
+    
+    Now also enriches grid entries with:
+      - duration: from the schedule entry
+      - elective_group: from allocations data
+      - is_open_elective: true if elective_group contains 'oe'
+    """
+    if allocations is None:
+        allocations = load_data().get("allocations", [])
+
+    # Build allocation lookup: (section_id, subject_code, faculty_id) -> elective_group
+    alloc_lookup = {}
+    if allocations:
+        for a in allocations:
+            key = (
+                a.get("section_id", "").lower(),
+                a.get("subject_code", "").lower(),
+                a.get("faculty_id", "").lower(),
+            )
+            alloc_lookup[key] = a.get("elective_group")
+
+    # Build faculty_id reverse lookup from data
+    # The schedule stores faculty_name (e.g. "Prof. Anu") but allocations use faculty_id (e.g. "anu")
+    # We'll also try matching by section_id + subject_code only as fallback
+    alloc_by_sec_sub = {}
+    if allocations:
+        for a in allocations:
+            key2 = (a.get("section_id", "").lower(), a.get("subject_code", "").lower())
+            alloc_by_sec_sub[key2] = a.get("elective_group")
+
+    parent_sections = sorted(set(
+        info.get("section_id", "").split("-")[0].upper()
+        for info in solution.values()
+    ))
+
+    merged = {ps: defaultdict(lambda: defaultdict(list)) for ps in parent_sections}
+    days_seen = {ps: set() for ps in parent_sections}
+
+    for task_id, info in solution.items():
+        sec_id = info.get("section_id") or ""
+        ps = sec_id.split("-")[0].upper() if sec_id else ""
+        day = info.get("day_index", 0)
+        period = info.get("period_index", 0)
+        dur = info.get("duration", 1)
+        
+        subject_raw = info.get("subject_code") or "?"
+        subject = subject_raw.upper()
+        
+        faculty = info.get("faculty_name") or ""
+        short_fac = (faculty.replace("Prof. ", "").replace("Dr. ", "")
+                            .replace("Mr. ", "").replace("Ms. ", ""))
+
+        # Look up elective_group from allocations
+        eg = alloc_by_sec_sub.get((sec_id.lower(), subject_raw.lower()))
+        is_oe = bool(eg and "oe" in eg.lower())
+
+        days_seen[ps].add(day)
+
+        room_name = info.get("room_id") or info.get("room_name") or ""
+        for i in range(dur):
+            entry = {
+                "task_id": task_id,
+                "subject": subject,
+                "faculty": short_fac,
+                "room": room_name,
+                "room_id": info.get("room_id", ""),
+                "room_name": info.get("room_name", ""),
+                "duration": dur,
+                "elective_group": eg,
+                "is_open_elective": is_oe,
+            }
+            # Propagate substitution metadata so frontend can highlight
+            if info.get("is_substituted"):
+                entry["is_substituted"] = True
+                orig = info.get("original_faculty_name") or ""
+                entry["original_faculty"] = (orig.replace("Prof. ", "").replace("Dr. ", "")
+                                              .replace("Mr. ", "").replace("Ms. ", ""))
+            slot = merged[ps][day][period + i]
+            if not any(e["subject"] == entry["subject"] and e["faculty"] == entry["faculty"] for e in slot):
+                slot.append(entry)
+
+    grid = {}
+    for ps in parent_sections:
+        day_indices = list(range(len(const.DAYS)))   # always Mon–Fri
+        if 5 in days_seen[ps]:                       # Saturday only if needed
+            day_indices.append(5)
+
+        slots = {}
+        for day in day_indices:
+            slots[str(day)] = {
+                str(p): merged[ps][day].get(p, [])
+                for p in range(const.NUM_TEACHING_SLOTS_PER_DAY)
+            }
+
+        grid[ps] = {"days": day_indices, "slots": slots}
+
+    return grid
+
+
+def _timetable_constants() -> dict:
+    return {
+        "days": const.DAYS,
+        "headers": const.TIMETABLE_HEADERS,
+        "num_periods": const.NUM_TEACHING_SLOTS_PER_DAY,
+        "break_after_index": const.BREAK_AFTER_INDEX,
+        "lunch_after_index": const.LUNCH_AFTER_INDEX,
+    }
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# PYDANTIC SCHEMAS
+# ═════════════════════════════════════════════════════════════════════════════
+
+class FacultyIn(BaseModel):
+    id: str
+    name: str
+    designation: str
+    max_hours: int = 18
+
+class SubjectIn(BaseModel):
+    code: str
+    name: str
+    credits: int
+    type: str = "THEORY"   # THEORY | LAB | SOFTSKILL | FORUM
+    is_core: bool = True
+    is_heavy: bool = False
+
+class SectionIn(BaseModel):
+    id: str
+    semester: int
+    strength: int
+    home_room_id: Optional[str] = None
+
+class RoomIn(BaseModel):
+    id: str
+    capacity: int
+    is_lab: bool = False
+    building: str = "Main"
+
+class AllocationIn(BaseModel):
+    faculty_id: str
+    subject_code: str
+    section_id: str
+    elective_group: Optional[str] = None
+
+class GenerateRequest(BaseModel):
+    time_limit_seconds: int = 30
+    version_label: Optional[str] = None
+    semesters: Optional[List[int]] = None  # e.g. [5, 7] for odd sems only
+    locked_semesters: Optional[List[int]] = None
+
+class UpdateRequest(BaseModel):
+    prompt: str
+    preview_only: bool = False
+    propose_only: bool = False
+
+class OverwriteRequest(BaseModel):
+    schedule: dict
+
+class ProposeRequest(BaseModel):
+    schedule: dict
+    proposer: str
+    proposer_name: str
+    description: str = "Proposed timetable change"
+
+class InjectEntry(BaseModel):
+    section_id: str          # e.g. "6A" (parent section)
+    day_index: int           # 0-4 (Mon-Fri)
+    period_index: int        # 0-7 teaching period
+    subject_code: str        # e.g. "ml"
+    faculty_name: str        # e.g. "Dr. Kavitha"
+    duration: int = 1        # 1 for theory, 2 for lab
+    room_id: Optional[str] = None
+
+class InjectRequest(BaseModel):
+    entries: list[InjectEntry]
+
+class RemoveRequest(BaseModel):
+    task_id: str
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# HEALTH & CONSTANTS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/health")
+def health():
+    """API liveness check — also returns timetable constants for convenience."""
+    return {
+        "status": "ok",
+        "schedule_exists": schedule_exists(),
+        **_timetable_constants(),
+    }
+
+@app.get("/slm/health")
+def slm_health():
+    """Check whether the external flan-t5 SLM API is reachable."""
+    ok = check_api_health()
+    return {"slm_online": ok, "message": "SLM API is online" if ok else "SLM API is offline"}
+
+@app.get("/constants")
+def get_constants():
+    """Timetable rendering constants (days, time headers, period indices)."""
+    return _timetable_constants()
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# ALL DATA
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data")
+def get_all_data():
+    """Return all stored academic data in one call."""
+    return load_data()
+
+
+
+import pandas as pd
+import io
+
+@app.get("/data/template/excel")
+def get_excel_template():
+    from openpyxl.worksheet.datavalidation import DataValidation
+
+    df_faculties = pd.DataFrame(columns=["id", "name", "designation", "max_hours"])
+    df_subjects = pd.DataFrame(columns=["code", "name", "type", "credits", "is_core", "is_heavy"])
+    df_sections = pd.DataFrame(columns=["id", "semester", "strength", "home_room_id"])
+    df_rooms = pd.DataFrame(columns=["id", "capacity", "is_lab", "building"])
+    df_allocations = pd.DataFrame(columns=["faculty_id", "subject_code", "section_id", "elective_group"])
+    df_scheduling_rules = pd.DataFrame(columns=["rule_type", "faculty_id", "subject_codes", "subject_types", "period", "max_period", "days"])
+    
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df_faculties.to_excel(writer, sheet_name='Faculties', index=False)
+        df_subjects.to_excel(writer, sheet_name='Subjects', index=False)
+        df_sections.to_excel(writer, sheet_name='Sections', index=False)
+        df_rooms.to_excel(writer, sheet_name='Rooms', index=False)
+        df_allocations.to_excel(writer, sheet_name='Allocations', index=False)
+        df_scheduling_rules.to_excel(writer, sheet_name='Scheduling Rules', index=False)
+        
+        # Add dropdown validations to Scheduling Rules sheet
+        ws = writer.sheets['Scheduling Rules']
+        
+        # Rule Type dropdown (column A, rows 2-100)
+        dv_rule_type = DataValidation(type="list", formula1='"FIXED_PERIOD,BEFORE_TIME,FIXED_DAYS,FACULTY_UNAVAILABLE"', allow_blank=True)
+        dv_rule_type.prompt = "Select a rule type"
+        dv_rule_type.promptTitle = "Rule Type"
+        ws.add_data_validation(dv_rule_type)
+        dv_rule_type.add(f'A2:A100')
+        
+        # Subject Types dropdown (column D, rows 2-100)
+        dv_subject_types = DataValidation(type="list", formula1='"THEORY,LAB,SOFTSKILL,FORUM"', allow_blank=True)
+        dv_subject_types.prompt = "Select subject type(s) - comma-separate for multiple"
+        dv_subject_types.promptTitle = "Subject Types"
+        ws.add_data_validation(dv_subject_types)
+        dv_subject_types.add(f'D2:D100')
+        
+        # Period dropdown (column E, rows 2-100)
+        dv_period = DataValidation(type="list", formula1='"Period 1,Period 2,Period 3,Period 4,Period 5,Period 6,Period 7,Period 8"', allow_blank=True)
+        dv_period.prompt = "Select period (for FIXED_PERIOD rules)"
+        dv_period.promptTitle = "Period"
+        ws.add_data_validation(dv_period)
+        dv_period.add(f'E2:E100')
+        
+        # Max Period dropdown (column F, rows 2-100)
+        dv_max_period = DataValidation(type="list", formula1='"Period 1,Period 2,Period 3,Period 4,Period 5,Period 6,Period 7,Period 8"', allow_blank=True)
+        dv_max_period.prompt = "Select max period (for BEFORE_TIME rules)"
+        dv_max_period.promptTitle = "Max Period"
+        ws.add_data_validation(dv_max_period)
+        dv_max_period.add(f'F2:F100')
+        
+        # Days dropdown (column G, rows 2-100)
+        dv_days = DataValidation(type="list", formula1='"MON,TUE,WED,THU,FRI,SAT"', allow_blank=True)
+        dv_days.prompt = "Select day(s) - comma-separate for multiple (for FIXED_DAYS rules)"
+        dv_days.promptTitle = "Days"
+        ws.add_data_validation(dv_days)
+        dv_days.add(f'G2:G100')
+        
+        # Designation dropdown for Faculties sheet (column C, rows 2-100)
+        ws_fac = writer.sheets['Faculties']
+        dv_designation = DataValidation(type="list", formula1='"Professor,Assoc. Prof,Asst. Prof,Guest"', allow_blank=True)
+        dv_designation.prompt = "Select designation"
+        dv_designation.promptTitle = "Designation"
+        ws_fac.add_data_validation(dv_designation)
+        dv_designation.add(f'C2:C100')
+        
+        # Subject Type dropdown for Subjects sheet (column C, rows 2-100)
+        ws_sub = writer.sheets['Subjects']
+        dv_sub_type = DataValidation(type="list", formula1='"THEORY,LAB,SOFTSKILL,FORUM"', allow_blank=True)
+        dv_sub_type.prompt = "Select subject type"
+        dv_sub_type.promptTitle = "Type"
+        ws_sub.add_data_validation(dv_sub_type)
+        dv_sub_type.add(f'C2:C100')
+        
+        # Boolean dropdowns for Subjects (is_core col E, is_heavy col F)
+        dv_bool = DataValidation(type="list", formula1='"TRUE,FALSE"', allow_blank=True)
+        ws_sub.add_data_validation(dv_bool)
+        dv_bool.add(f'E2:F100')
+        
+        # Boolean dropdown for Rooms is_lab (column C, rows 2-100)
+        ws_rooms = writer.sheets['Rooms']
+        dv_lab = DataValidation(type="list", formula1='"TRUE,FALSE"', allow_blank=True)
+        ws_rooms.add_data_validation(dv_lab)
+        dv_lab.add(f'C2:C100')
+    
+    output.seek(0)
+    return StreamingResponse(
+        output, 
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
+        headers={"Content-Disposition": "attachment; filename=timetable_template.xlsx"}
+    )
+
+
+@app.get("/data/export/excel")
+def export_data_as_excel():
+    """Export all current data as an Excel file matching the template format."""
+    data = load_data()
+    
+    # Build DataFrames from existing data
+    df_faculties = pd.DataFrame(data.get("faculties", []))
+    df_subjects = pd.DataFrame(data.get("subjects", []))
+    df_sections = pd.DataFrame(data.get("sections", []))
+    df_rooms = pd.DataFrame(data.get("rooms", []))
+    df_allocations = pd.DataFrame(data.get("allocations", []))
+    
+    # Build scheduling rules DataFrame with human-readable columns
+    rules = data.get("scheduling_rules", [])
+    rules_rows = []
+    for rule in rules:
+        row = {
+            "rule_type": rule.get("rule_type", ""),
+            "faculty_id": rule.get("faculty_id", ""),
+            "subject_codes": ", ".join(rule.get("subject_codes", [])) if isinstance(rule.get("subject_codes"), list) else str(rule.get("subject_codes", "")),
+            "subject_types": ", ".join(rule.get("subject_types", [])) if isinstance(rule.get("subject_types"), list) else str(rule.get("subject_types", "")),
+            "period": f"Period {rule['period_index'] + 1}" if rule.get("period_index") is not None else "",
+            "max_period": f"Period {rule['max_period_index'] + 1}" if rule.get("max_period_index") is not None else "",
+            "days": ", ".join(rule.get("days", [])) if isinstance(rule.get("days"), list) else str(rule.get("days", "")),
+        }
+        rules_rows.append(row)
+    df_scheduling_rules = pd.DataFrame(rules_rows) if rules_rows else pd.DataFrame(columns=["rule_type", "subject_codes", "subject_types", "period", "max_period", "days"])
+    
+    # Ensure column order matches the template
+    fac_cols = ["id", "name", "designation", "max_hours"]
+    sub_cols = ["code", "name", "type", "credits", "is_core", "is_heavy"]
+    sec_cols = ["id", "semester", "strength", "home_room_id"]
+    room_cols = ["id", "capacity", "is_lab", "building"]
+    alloc_cols = ["faculty_id", "subject_code", "section_id", "elective_group"]
+    rule_cols = ["rule_type", "faculty_id", "subject_codes", "subject_types", "period", "max_period", "days"]
+    
+    for col in fac_cols:
+        if col not in df_faculties.columns:
+            df_faculties[col] = ""
+    for col in sub_cols:
+        if col not in df_subjects.columns:
+            df_subjects[col] = ""
+    for col in sec_cols:
+        if col not in df_sections.columns:
+            df_sections[col] = ""
+    for col in room_cols:
+        if col not in df_rooms.columns:
+            df_rooms[col] = ""
+    for col in alloc_cols:
+        if col not in df_allocations.columns:
+            df_allocations[col] = ""
+    
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df_faculties[fac_cols].to_excel(writer, sheet_name='Faculties', index=False)
+        df_subjects[sub_cols].to_excel(writer, sheet_name='Subjects', index=False)
+        df_sections[sec_cols].to_excel(writer, sheet_name='Sections', index=False)
+        df_rooms[room_cols].to_excel(writer, sheet_name='Rooms', index=False)
+        df_allocations[alloc_cols].to_excel(writer, sheet_name='Allocations', index=False)
+        df_scheduling_rules[rule_cols].to_excel(writer, sheet_name='Scheduling Rules', index=False)
+        
+        # Add dropdown validations (same as template)
+        from openpyxl.worksheet.datavalidation import DataValidation
+        
+        # Faculties - designation dropdown
+        ws_fac = writer.sheets['Faculties']
+        dv_desig = DataValidation(type="list", formula1='"Professor,Assoc. Prof,Asst. Prof,Guest"', allow_blank=True)
+        ws_fac.add_data_validation(dv_desig)
+        dv_desig.add('C2:C1000')
+        
+        # Subjects - type dropdown
+        ws_sub = writer.sheets['Subjects']
+        dv_stype = DataValidation(type="list", formula1='"THEORY,LAB,SOFTSKILL,FORUM"', allow_blank=True)
+        ws_sub.add_data_validation(dv_stype)
+        dv_stype.add('C2:C1000')
+        
+        # Subjects - is_core & is_heavy boolean dropdowns
+        dv_bool_sub = DataValidation(type="list", formula1='"TRUE,FALSE"', allow_blank=True)
+        ws_sub.add_data_validation(dv_bool_sub)
+        dv_bool_sub.add('E2:F1000')
+        
+        # Rooms - is_lab boolean dropdown
+        ws_rooms = writer.sheets['Rooms']
+        dv_lab = DataValidation(type="list", formula1='"TRUE,FALSE"', allow_blank=True)
+        ws_rooms.add_data_validation(dv_lab)
+        dv_lab.add('C2:C1000')
+        
+        # Scheduling Rules - all dropdowns
+        ws_rules = writer.sheets['Scheduling Rules']
+        
+        dv_rt = DataValidation(type="list", formula1='"FIXED_PERIOD,BEFORE_TIME,FIXED_DAYS"', allow_blank=True)
+        ws_rules.add_data_validation(dv_rt)
+        dv_rt.add('A2:A1000')
+        
+        dv_st = DataValidation(type="list", formula1='"THEORY,LAB,SOFTSKILL,FORUM"', allow_blank=True)
+        ws_rules.add_data_validation(dv_st)
+        dv_st.add('C2:C1000')
+        
+        dv_p = DataValidation(type="list", formula1='"Period 1,Period 2,Period 3,Period 4,Period 5,Period 6,Period 7,Period 8"', allow_blank=True)
+        ws_rules.add_data_validation(dv_p)
+        dv_p.add('D2:D1000')
+        
+        dv_mp = DataValidation(type="list", formula1='"Period 1,Period 2,Period 3,Period 4,Period 5,Period 6,Period 7,Period 8"', allow_blank=True)
+        ws_rules.add_data_validation(dv_mp)
+        dv_mp.add('E2:E1000')
+        
+        dv_d = DataValidation(type="list", formula1='"MON,TUE,WED,THU,FRI,SAT"', allow_blank=True)
+        ws_rules.add_data_validation(dv_d)
+        dv_d.add('F2:F1000')
+    
+    output.seek(0)
+    return StreamingResponse(
+        output,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": "attachment; filename=timetable_data_export.xlsx"}
+    )
+
+@app.post("/data/import/excel")
+async def import_excel(file: UploadFile = File(...)):
+    contents = await file.read()
+    try:
+        xls = pd.ExcelFile(io.BytesIO(contents))
+        data = {
+            "faculties": [],
+            "subjects": [],
+            "sections": [],
+            "rooms": [],
+            "allocations": [],
+            "scheduling_rules": []
+        }
+        
+        import re
+        def parse_int(val, default):
+            if pd.isna(val) or val == '': return default
+            try:
+                return int(val)
+            except (ValueError, TypeError):
+                m = re.search(r'\d+', str(val))
+                return int(m.group()) if m else default
+
+        if 'Faculties' in xls.sheet_names:
+            df = pd.read_excel(xls, 'Faculties').fillna('')
+            for _, row in df.iterrows():
+                if row.get('id'):
+                    data["faculties"].append({
+                        "id": str(row.get('id')),
+                        "name": str(row.get('name', '')),
+                        "designation": str(row.get('designation', 'Asst. Prof')),
+                        "max_hours": parse_int(row.get('max_hours', 18), 18)
+                    })
+                    
+        if 'Subjects' in xls.sheet_names:
+            df = pd.read_excel(xls, 'Subjects').fillna('')
+            for _, row in df.iterrows():
+                if row.get('code'):
+                    data["subjects"].append({
+                        "code": str(row.get('code')),
+                        "name": str(row.get('name', '')),
+                        "type": str(row.get('type', 'THEORY')),
+                        "credits": parse_int(row.get('credits', 3), 3),
+                        "is_core": bool(row.get('is_core', True)),
+                        "is_heavy": bool(row.get('is_heavy', False))
+                    })
+                    
+        if 'Sections' in xls.sheet_names:
+            df = pd.read_excel(xls, 'Sections').fillna('')
+            for _, row in df.iterrows():
+                if row.get('id'):
+                    hr_val = row.get('home_room_id') or row.get('home_room')
+                    data["sections"].append({
+                        "id": str(row.get('id')),
+                        "semester": parse_int(row.get('semester', 1), 1),
+                        "strength": parse_int(row.get('strength', 60), 60),
+                        "home_room_id": str(hr_val).strip() if hr_val and not pd.isna(hr_val) else None
+                    })
+                    
+        if 'Rooms' in xls.sheet_names:
+            df = pd.read_excel(xls, 'Rooms').fillna('')
+            for _, row in df.iterrows():
+                if row.get('id'):
+                    data["rooms"].append({
+                        "id": str(row.get('id')),
+                        "capacity": parse_int(row.get('capacity', 60), 60),
+                        "is_lab": bool(row.get('is_lab', False)),
+                        "building": str(row.get('building', 'Main'))
+                    })
+                    
+        if 'Allocations' in xls.sheet_names:
+            df = pd.read_excel(xls, 'Allocations').fillna('')
+            for _, row in df.iterrows():
+                if row.get('faculty_id') and row.get('subject_code') and row.get('section_id'):
+                    eg = row.get('elective_group')
+                    data["allocations"].append({
+                        "faculty_id": str(row.get('faculty_id')),
+                        "subject_code": str(row.get('subject_code')),
+                        "section_id": str(row.get('section_id')),
+                        "elective_group": str(eg) if eg else None
+                    })
+        
+        # Parse Scheduling Rules sheet if present, otherwise preserve existing rules
+        if 'Scheduling Rules' in xls.sheet_names:
+            import uuid as _uuid
+            df = pd.read_excel(xls, 'Scheduling Rules').fillna('')
+            for _, row in df.iterrows():
+                rule_type = str(row.get('rule_type', '')).strip()
+                if not rule_type:
+                    continue
+                rule = {"id": str(_uuid.uuid4()), "rule_type": rule_type}
+                
+                # Parse faculty_id
+                fid = str(row.get('faculty_id', '')).strip()
+                if fid:
+                    rule["faculty_id"] = fid
+                
+                # Parse subject_codes (comma-separated)
+                sc = str(row.get('subject_codes', '')).strip()
+                rule["subject_codes"] = [s.strip() for s in sc.split(',') if s.strip()] if sc else []
+                
+                # Parse subject_types (comma-separated)
+                st = str(row.get('subject_types', '')).strip()
+                rule["subject_types"] = [s.strip() for s in st.split(',') if s.strip()] if st else []
+                
+                # Parse period (e.g. "Period 3" -> 2)
+                period_str = str(row.get('period', '')).strip()
+                if period_str and 'Period' in period_str:
+                    try:
+                        rule["period_index"] = int(period_str.replace('Period ', '')) - 1
+                    except ValueError:
+                        pass
+                
+                # Parse max_period
+                max_period_str = str(row.get('max_period', '')).strip()
+                if max_period_str and 'Period' in max_period_str:
+                    try:
+                        rule["max_period_index"] = int(max_period_str.replace('Period ', '')) - 1
+                    except ValueError:
+                        pass
+                
+                # Parse days (comma-separated)
+                days_str = str(row.get('days', '')).strip()
+                if days_str:
+                    rule["days"] = [d.strip() for d in days_str.split(',') if d.strip()]
+                
+                data["scheduling_rules"].append(rule)
+        else:
+            # Preserve existing scheduling_rules if no sheet in upload
+            existing_data = load_data()
+            data["scheduling_rules"] = existing_data.get("scheduling_rules", [])
+        
+        save_data(data)
+        return {"message": "Data imported successfully", "imported": {k: len(v) for k, v in data.items()}}
+        
+    except Exception as e:
+        raise HTTPException(400, f"Failed to parse Excel file: {str(e)}")
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGE FACULTIES
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data/faculties")
+def list_faculties():
+    return {"faculties": load_data()["faculties"]}
+
+@app.post("/data/faculties", status_code=201)
+def add_faculty(faculty: FacultyIn):
+    data = load_data()
+    if any(f["id"] == faculty.id for f in data["faculties"]):
+        raise HTTPException(400, f"Faculty ID '{faculty.id}' already exists.")
+    data["faculties"].append(faculty.model_dump())
+    save_data(data)
+    return {"message": "Faculty added.", "faculty": faculty.model_dump()}
+
+
+@app.put("/data/faculties/{faculty_id}")
+def update_faculty(faculty_id: str, faculty: FacultyIn):
+    data = load_data()
+    for i, f in enumerate(data["faculties"]):
+        if f["id"] == faculty_id:
+            updated = faculty.model_dump()
+            data["faculties"][i] = updated
+            # Cascade to allocations and scheduling_rules if ID changed
+            if faculty_id != updated["id"]:
+                for a in data.get("allocations", []):
+                    if a.get("faculty_id") == faculty_id:
+                        a["faculty_id"] = updated["id"]
+                for r in data.get("scheduling_rules", []):
+                    if r.get("faculty_id") == faculty_id:
+                        r["faculty_id"] = updated["id"]
+            save_data(data)
+            return {"message": "Faculty updated.", "faculty": updated}
+    raise HTTPException(404, f"Faculty '{faculty_id}' not found.")
+
+@app.delete("/data/faculties")
+def clear_faculties():
+    data = load_data()
+    data["faculties"] = []
+    save_data(data)
+    return {"message": "All faculties cleared."}
+
+@app.delete("/data/faculties/{faculty_id}")
+def delete_faculty(faculty_id: str):
+    data = load_data()
+    before = len(data["faculties"])
+    data["faculties"] = [f for f in data["faculties"] if f["id"] != faculty_id]
+    if len(data["faculties"]) == before:
+        raise HTTPException(404, f"Faculty '{faculty_id}' not found.")
+    save_data(data)
+    return {"message": f"Faculty '{faculty_id}' deleted."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGE SUBJECTS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data/subjects")
+def list_subjects():
+    return {"subjects": load_data()["subjects"]}
+
+@app.post("/data/subjects", status_code=201)
+def add_subject(subject: SubjectIn):
+    data = load_data()
+    if any(s["code"] == subject.code for s in data["subjects"]):
+        raise HTTPException(400, f"Subject code '{subject.code}' already exists.")
+    data["subjects"].append(subject.model_dump())
+    save_data(data)
+    return {"message": "Subject added.", "subject": subject.model_dump()}
+
+
+@app.put("/data/subjects/{subject_code}")
+def update_subject(subject_code: str, subject: SubjectIn):
+    data = load_data()
+    for i, s in enumerate(data["subjects"]):
+        if s["code"] == subject_code:
+            updated = subject.model_dump()
+            data["subjects"][i] = updated
+            # Cascade to allocations and scheduling_rules if code changed
+            if subject_code != updated["code"]:
+                for a in data.get("allocations", []):
+                    if a.get("subject_code") == subject_code:
+                        a["subject_code"] = updated["code"]
+                for r in data.get("scheduling_rules", []):
+                    if subject_code in r.get("subject_codes", []):
+                        r["subject_codes"] = [updated["code"] if c == subject_code else c for c in r["subject_codes"]]
+            save_data(data)
+            return {"message": "Subject updated.", "subject": updated}
+    raise HTTPException(404, f"Subject '{subject_code}' not found.")
+
+@app.delete("/data/subjects")
+def clear_subjects():
+    data = load_data()
+    data["subjects"] = []
+    save_data(data)
+    return {"message": "All subjects cleared."}
+
+@app.delete("/data/subjects/{subject_code}")
+def delete_subject(subject_code: str):
+    data = load_data()
+    before = len(data["subjects"])
+    data["subjects"] = [s for s in data["subjects"] if s["code"] != subject_code]
+    if len(data["subjects"]) == before:
+        raise HTTPException(404, f"Subject '{subject_code}' not found.")
+    save_data(data)
+    return {"message": f"Subject '{subject_code}' deleted."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGE SECTIONS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data/sections")
+def list_sections():
+    return {"sections": load_data()["sections"]}
+
+@app.post("/data/sections", status_code=201)
+def add_section(section: SectionIn):
+    data = load_data()
+    if any(s["id"] == section.id for s in data["sections"]):
+        raise HTTPException(400, f"Section ID '{section.id}' already exists.")
+    data["sections"].append(section.model_dump())
+    save_data(data)
+    return {"message": "Section added.", "section": section.model_dump()}
+
+
+@app.put("/data/sections/{section_id}")
+def update_section(section_id: str, section: SectionIn):
+    data = load_data()
+    for i, s in enumerate(data["sections"]):
+        if s["id"] == section_id:
+            updated = section.model_dump()
+            data["sections"][i] = updated
+            # Cascade to allocations if ID changed
+            if section_id != updated["id"]:
+                for a in data.get("allocations", []):
+                    if a.get("section_id") == section_id:
+                        a["section_id"] = updated["id"]
+            save_data(data)
+            return {"message": "Section updated.", "section": updated}
+    raise HTTPException(404, f"Section '{section_id}' not found.")
+
+@app.delete("/data/sections")
+def clear_sections():
+    data = load_data()
+    data["sections"] = []
+    save_data(data)
+    return {"message": "All sections cleared."}
+
+@app.get("/data/semesters")
+def list_semesters():
+    """Return all unique semester numbers from sections data."""
+    data = load_data()
+    semesters = sorted(set(s["semester"] for s in data.get("sections", [])))
+    return {"semesters": semesters}
+
+
+@app.delete("/data/sections/{section_id}")
+def delete_section(section_id: str):
+    data = load_data()
+    before = len(data["sections"])
+    data["sections"] = [s for s in data["sections"] if s["id"] != section_id]
+    if len(data["sections"]) == before:
+        raise HTTPException(404, f"Section '{section_id}' not found.")
+    save_data(data)
+    return {"message": f"Section '{section_id}' deleted."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGE ROOMS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data/rooms")
+def list_rooms():
+    return {"rooms": load_data()["rooms"]}
+
+@app.post("/data/rooms", status_code=201)
+def add_room(room: RoomIn):
+    data = load_data()
+    if any(r["id"] == room.id for r in data["rooms"]):
+        raise HTTPException(400, f"Room ID '{room.id}' already exists.")
+    data["rooms"].append(room.model_dump())
+    save_data(data)
+    return {"message": "Room added.", "room": room.model_dump()}
+
+
+@app.put("/data/rooms/{room_id}")
+def update_room(room_id: str, room: RoomIn):
+    data = load_data()
+    for i, r in enumerate(data["rooms"]):
+        if r["id"] == room_id:
+            updated = room.model_dump()
+            data["rooms"][i] = updated
+            save_data(data)
+            return {"message": "Room updated.", "room": updated}
+    raise HTTPException(404, f"Room '{room_id}' not found.")
+
+@app.delete("/data/rooms")
+def clear_rooms():
+    data = load_data()
+    data["rooms"] = []
+    save_data(data)
+    return {"message": "All rooms cleared."}
+
+@app.delete("/data/rooms/{room_id}")
+def delete_room(room_id: str):
+    data = load_data()
+    before = len(data["rooms"])
+    data["rooms"] = [r for r in data["rooms"] if r["id"] != room_id]
+    if len(data["rooms"]) == before:
+        raise HTTPException(404, f"Room '{room_id}' not found.")
+    save_data(data)
+    return {"message": f"Room '{room_id}' deleted."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGE ALLOCATIONS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/data/allocations")
+def list_allocations():
+    return {"allocations": load_data()["allocations"]}
+
+@app.post("/data/allocations", status_code=201)
+def add_allocation(alloc: AllocationIn):
+    data = load_data()
+    data["allocations"].append(alloc.model_dump())
+    save_data(data)
+    return {"message": "Allocation added.", "allocation": alloc.model_dump()}
+
+
+@app.put("/data/allocations/{idx}")
+def update_allocation(idx: int, alloc: AllocationIn):
+    data = load_data()
+    if idx < 0 or idx >= len(data["allocations"]):
+        raise HTTPException(404, f"Allocation index {idx} out of range.")
+    data["allocations"][idx] = alloc.model_dump()
+    save_data(data)
+    return {"message": "Allocation updated.", "allocation": alloc.model_dump()}
+
+@app.delete("/data/allocations")
+def clear_allocations():
+    data = load_data()
+    data["allocations"] = []
+    save_data(data)
+    return {"message": "All allocations cleared."}
+
+@app.delete("/data/allocations/{idx}")
+def delete_allocation(idx: int):
+    """Delete allocation by its 0-based index in the list."""
+    data = load_data()
+    if idx < 0 or idx >= len(data["allocations"]):
+        raise HTTPException(404, f"Allocation index {idx} out of range.")
+    removed = data["allocations"].pop(idx)
+    save_data(data)
+    return {"message": "Allocation deleted.", "removed": removed}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# SCHEDULING RULES
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/scheduling-rules")
+def get_scheduling_rules():
+    data = load_data()
+    return {"rules": data.get("scheduling_rules", [])}
+
+@app.post("/scheduling-rules")
+def add_scheduling_rule(rule: dict):
+    import uuid as _uuid
+    data = load_data()
+    rules = data.get("scheduling_rules", [])
+    rule["id"] = str(_uuid.uuid4())
+    rules.append(rule)
+    data["scheduling_rules"] = rules
+    save_data(data)
+    return {"message": "Rule added.", "rule": rule}
+
+
+@app.put("/scheduling-rules/{rule_id}")
+def update_scheduling_rule(rule_id: str, rule: dict):
+    data = load_data()
+    rules = data.get("scheduling_rules", [])
+    for i, r in enumerate(rules):
+        if r.get("id") == rule_id:
+            rule["id"] = rule_id
+            rules[i] = rule
+            data["scheduling_rules"] = rules
+            save_data(data)
+            return {"message": "Rule updated.", "rule": rule}
+    raise HTTPException(404, "Rule not found.")
+
+@app.delete("/scheduling-rules/{rule_id}")
+def delete_scheduling_rule(rule_id: str):
+    data = load_data()
+    rules = data.get("scheduling_rules", [])
+    data["scheduling_rules"] = [r for r in rules if r.get("id") != rule_id]
+    save_data(data)
+    return {"message": "Rule deleted."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GENERATE TIMETABLE
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.post("/generate")
+def generate(req: GenerateRequest):
+    try:
+        data = load_data()
+
+        missing = [k for k in ("faculties", "subjects", "sections", "rooms", "allocations")
+                   if not data.get(k)]
+        if missing:
+            raise HTTPException(400, f"Missing data for: {', '.join(missing)}.")
+
+        # ── Semester filtering ────────────────────────────────────────────
+        has_sems = bool(req.semesters)
+        has_locked = bool(req.locked_semesters)
+        if has_sems or has_locked:
+            selected_sems = set(req.semesters or [])
+            locked_sems = set(req.locked_semesters or [])
+            combined_sems = selected_sems.union(locked_sems)
+            
+            if combined_sems:
+                # 1. Filter sections to only combined semesters
+                data["sections"] = [
+                    s for s in data["sections"] if s["semester"] in combined_sems
+                ]
+                if not data["sections"]:
+                    raise HTTPException(400, f"No sections found for semesters: {combined_sems}")
+
+                # 2. Filter allocations to only reference surviving sections
+                valid_section_ids = {s["id"] for s in data["sections"]}
+                data["allocations"] = [
+                    a for a in data["allocations"]
+                    if a["section_id"] in valid_section_ids
+                ]
+
+                # 3. Filter subjects to only those referenced by surviving allocations
+                used_subject_codes = {a["subject_code"] for a in data["allocations"]}
+                data["subjects"] = [
+                    s for s in data["subjects"] if s["code"] in used_subject_codes
+                ]
+
+                # 4. Filter faculties to only those referenced by surviving allocations
+                used_faculty_ids = {a["faculty_id"] for a in data["allocations"]}
+                data["faculties"] = [
+                    f for f in data["faculties"] if f["id"] in used_faculty_ids
+                ]
+
+                print(f"[generate] Filtered to combined semesters {combined_sems}: "
+                      f"{len(data['sections'])} sections, {len(data['allocations'])} allocations, "
+                      f"{len(data['subjects'])} subjects, {len(data['faculties'])} faculties")
+
+        facs, subs, secs, rooms, allocs = _build_objects(data)
+        tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+
+        if not tasks:
+            raise HTTPException(400, "No schedulable tasks found. Check your allocations.")
+
+        locked_schedule = {}
+        if req.locked_semesters:
+            if schedule_exists():
+                locked_schedule = load_schedule()
+            else:
+                raise HTTPException(400, "Cannot lock semesters: no existing schedule found.")
+
+        solver = TimetableSolver(tasks, facs, secs, rooms)
+        try:
+            status, solution = solver.solve(
+                time_limit_seconds=req.time_limit_seconds,
+                enable_soft_constraints=True,
+                scheduling_rules=data.get("scheduling_rules", []),
+                locked_schedule=locked_schedule,
+                locked_semesters=req.locked_semesters
+            )
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+        if status not in ("OPTIMAL", "FEASIBLE"):
+            diagnosis = solver.diagnose_infeasibility()
+            raise HTTPException(400, f"Timetable generation failed. {diagnosis}")
+
+        # Auto-save current schedule as a version before overwriting
+        if schedule_exists():
+            save_version(label=req.version_label)
+
+        save_schedule(solution)
+        save_original_schedule(solution)
+        clean = _clean(solution)
+
+        return {
+            "status": status,
+            "task_count": len(tasks),
+            "semesters_generated": req.semesters or "all",
+            "schedule": clean,
+            "grid": _build_grid(clean),
+            **_timetable_constants(),
+        }
+
+    except HTTPException:
+        raise
+    except Exception:
+        raise HTTPException(500, traceback.format_exc())
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# GET / DELETE TIMETABLE
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/schedule")
+def get_schedule():
+    if not schedule_exists():
+        return {"exists": False, "schedule": None, "grid": None}
+    data = load_schedule()
+    clean = _clean(data["schedule"])
+    return {
+        "exists": True,
+        "generated_at": data.get("generated_at"),
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+@app.get("/schedule/original")
+def get_original_schedule():
+    if not original_schedule_exists():
+        return {"exists": False, "grid": None}
+    data = load_original_schedule()
+    clean = _clean(data["schedule"])
+    return {
+        "exists": True,
+        "generated_at": data.get("generated_at"),
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+@app.delete("/schedule")
+def delete_schedule(version_label: Optional[str] = None):
+    # Auto-save as version before clearing
+    if schedule_exists():
+        save_version(label=version_label)
+    clear_schedule()
+    clear_original_schedule()
+    clear_history()
+    return {"message": "Schedule saved as version and cleared."}
+
+@app.post("/schedule/revert")
+def revert_schedule():
+    if not original_schedule_exists():
+        raise HTTPException(400, "No original schedule found to revert to.")
+    data = load_original_schedule()
+    save_schedule(data["schedule"])
+    clear_history()
+    clean = _clean(data["schedule"])
+    return {
+        "status": "SUCCESS",
+        "message": "Reverted to original schedule and cleared history.",
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+# ═════════════════════════════════════════════════════════════════════════════
+# SCHEDULE VERSIONS
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/schedule/versions")
+def get_versions():
+    versions = load_versions()
+    # Return summary only (not full schedule data) for the list view
+    return {
+        "versions": [
+            {
+                "id": v["id"],
+                "label": v.get("label", f"Version {i+1}"),
+                "timestamp": v.get("timestamp", ""),
+                "generated_at": v.get("generated_at", ""),
+                "history_count": len(v.get("history", [])),
+            }
+            for i, v in enumerate(versions)
+        ]
+    }
+
+@app.get("/schedule/versions/{version_id}")
+def get_version_details(version_id: str):
+    versions = load_versions()
+    target = next((v for v in versions if v["id"] == version_id), None)
+    if not target:
+        raise HTTPException(404, "Version not found.")
+    clean = _clean(target.get("schedule", {}))
+    return {
+        "status": "SUCCESS",
+        "version_id": version_id,
+        "label": target.get("label"),
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+@app.post("/schedule/versions/restore/{version_id}")
+def restore_version_endpoint(version_id: str):
+    # Auto-save current as a version before restoring
+    if schedule_exists():
+        save_version()
+    result = restore_version(version_id)
+    if not result:
+        raise HTTPException(404, "Version not found.")
+    clean = _clean(result["schedule"])
+    return {
+        "status": "SUCCESS",
+        "message": f"Restored version: {result.get('label', version_id)}",
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+@app.post("/schedule/overwrite")
+def overwrite_schedule(req: OverwriteRequest):
+    if not req.schedule:
+        raise HTTPException(400, "Schedule payload cannot be empty.")
+    
+    old_raw = load_schedule()
+    old_schedule = _clean(old_raw.get("schedule", {})) if old_raw else {}
+    clean_new = _clean(req.schedule)
+    
+    changes, affected = diff_schedules(old_schedule, clean_new)
+    
+    save_schedule(clean_new)
+    if changes:
+        add_history_entry(
+            operation_type="MANUAL_OVERWRITE",
+            description=f"Manual drag & drop modifications ({len(changes)} cells affected)",
+            affected_sections=affected,
+            changes=changes,
+            status="SUCCESS",
+            constraints=[]
+        )
+    return {
+        "status": "SUCCESS",
+        "message": "Schedule overwritten manually.",
+        "schedule": clean_new,
+        "grid": _build_grid(clean_new),
+        **_timetable_constants(),
+    }
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# SCHEDULE PROPOSALS (SUPER TEACHER WORKFLOW)
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/schedule/proposals")
+def get_proposals():
+    from storage import load_proposals
+    return {"proposals": load_proposals()}
+
+@app.post("/schedule/propose")
+def propose_schedule(req: ProposeRequest):
+    from storage import save_proposal
+    import uuid as _uuid
+    
+    old_raw = load_schedule()
+    old_schedule = _clean(old_raw.get("schedule", {})) if old_raw else {}
+    clean_new = _clean(req.schedule)
+    
+    changes, affected = diff_schedules(old_schedule, clean_new)
+    
+    proposal = {
+        "id": str(_uuid.uuid4()),
+        "proposer": req.proposer,
+        "proposer_name": req.proposer_name,
+        "description": req.description,
+        "timestamp": datetime.now().isoformat(),
+        "changes_count": len(changes),
+        "changes": changes,
+        "schedule": clean_new,
+        "status": "PENDING"
+    }
+    save_proposal(proposal)
+    return {"status": "SUCCESS", "message": "Proposal submitted.", "proposal": proposal}
+
+@app.post("/schedule/proposals/{proposal_id}/approve")
+def approve_proposal(proposal_id: str):
+    from storage import load_proposals, delete_proposal
+    proposals = load_proposals()
+    target = next((p for p in proposals if p.get("id") == proposal_id), None)
+    if not target:
+        raise HTTPException(404, "Proposal not found.")
+    
+    clean_new = target["schedule"]
+    save_schedule(clean_new)
+    if target.get("changes"):
+        add_history_entry(
+            operation_type="PROPOSAL_APPROVED",
+            description=f"Approved changes by {target.get('proposer_name')} ({len(target['changes'])} cells affected)",
+            affected_sections=[],
+            changes=target["changes"],
+            status="SUCCESS",
+            constraints=[]
+        )
+    
+    delete_proposal(proposal_id)
+    return {"status": "SUCCESS", "message": "Proposal approved and applied."}
+
+@app.delete("/schedule/proposals/{proposal_id}")
+def reject_proposal(proposal_id: str):
+    from storage import delete_proposal
+    delete_proposal(proposal_id)
+    return {"status": "SUCCESS", "message": "Proposal rejected."}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# INJECT SUBJECT (ADD TO TIMETABLE)
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.post("/schedule/inject")
+def inject_subject(req: InjectRequest):
+    """Insert one or more new class entries into the current schedule."""
+    if not schedule_exists():
+        raise HTTPException(400, "No timetable generated yet. Call POST /generate first.")
+
+    if not req.entries:
+        raise HTTPException(400, "No entries provided.")
+
+    data = load_data()
+    sched_data = load_schedule()
+    current = sched_data["schedule"]
+    old_schedule = _clean(dict(current))  # snapshot before mutation
+
+    # Build a set of existing task IDs to avoid collisions
+    existing_ids = set(current.keys())
+
+    # Build a lookup of faculty_name -> faculty for room assignment
+    rooms = data.get("rooms", [])
+    subjects_lookup = {s["code"].lower(): s for s in data.get("subjects", [])}
+
+    injected_entries = []
+
+    for entry in req.entries:
+        # Check for section collisions first
+        for t_id, info in current.items():
+            if info.get("section_id") == entry.section_id and info.get("day_index") == entry.day_index:
+                c_start = info.get("period_index", 0)
+                c_dur = info.get("duration", 1)
+                c_end = c_start + c_dur
+                
+                e_start = entry.period_index
+                e_dur = entry.duration
+                e_end = e_start + e_dur
+                
+                if max(c_start, e_start) < min(c_end, e_end):
+                    raise HTTPException(400, f"Section {entry.section_id} already has a class scheduled at {const.DAYS[entry.day_index]} Period {e_start + 1}.")
+
+        # Determine room: use provided room_id, or auto-pick first available
+        room_id = entry.room_id or ""
+        room_name = ""
+        if room_id:
+            for r in rooms:
+                if r["id"] == room_id:
+                    room_name = f"{r['id']} ({'Lab' if r.get('is_lab') else r.get('building', 'Main')})"
+                    break
+        elif rooms:
+            # Auto-assign: pick a room not occupied at this slot
+            occupied_rooms = set()
+            for info in current.values():
+                if info.get("day_index") == entry.day_index and info.get("period_index") == entry.period_index:
+                    occupied_rooms.add(info.get("room_id", ""))
+                # For multi-period blocks, also check period_index + 1
+                dur = info.get("duration", 1)
+                if dur > 1:
+                    for di in range(dur):
+                        if info.get("day_index") == entry.day_index and info.get("period_index") + di == entry.period_index:
+                            occupied_rooms.add(info.get("room_id", ""))
+
+            # Prefer labs for lab subjects, regular rooms for theory
+            sub_info = subjects_lookup.get(entry.subject_code.lower(), {})
+            is_lab_subject = sub_info.get("type", "THEORY").upper() == "LAB"
+
+            for r in rooms:
+                if r["id"] not in occupied_rooms:
+                    if is_lab_subject and r.get("is_lab"):
+                        room_id = r["id"]
+                        room_name = f"{r['id']} (Lab)"
+                        break
+                    elif not is_lab_subject and not r.get("is_lab"):
+                        room_id = r["id"]
+                        room_name = f"{r['id']} ({r.get('building', 'Main')})"
+                        break
+            # Fallback: just pick the first available
+            if not room_id:
+                for r in rooms:
+                    if r["id"] not in occupied_rooms:
+                        room_id = r["id"]
+                        room_name = f"{r['id']} ({r.get('building', 'Main')})"
+                        break
+
+        # Generate a unique task ID
+        base_id = f"{entry.subject_code.lower()}-{entry.section_id.lower()}-INJECT"
+        task_id = base_id
+        counter = 0
+        while task_id in existing_ids:
+            counter += 1
+            task_id = f"{base_id}-{counter}"
+        existing_ids.add(task_id)
+
+        # Compute start_slot for compatibility
+        start_slot = entry.day_index * const.NUM_TEACHING_SLOTS_PER_DAY + entry.period_index
+
+        schedule_entry = {
+            "start_slot": start_slot,
+            "day_index": entry.day_index,
+            "day_name": const.DAYS[entry.day_index] if entry.day_index < len(const.DAYS) else f"Day{entry.day_index}",
+            "period_index": entry.period_index,
+            "room_id": room_id,
+            "room_name": room_name,
+            "faculty_name": entry.faculty_name,
+            "subject_code": entry.subject_code.lower(),
+            "section_id": entry.section_id,
+            "duration": entry.duration,
+        }
+
+        current[task_id] = schedule_entry
+        injected_entries.append({"task_id": task_id, **schedule_entry})
+
+    # Save updated schedule
+    save_schedule(current)
+    # Log history
+    clean = _clean(current)
+    changes, affected = diff_schedules(old_schedule, clean)
+    if changes:
+        add_history_entry(
+            operation_type="INJECT_SUBJECT",
+            description=f"Injected {len(injected_entries)} class(es) (e.g. {injected_entries[0].get('subject_code') if injected_entries else 'subject'})",
+            affected_sections=affected,
+            changes=changes,
+            status="SUCCESS",
+            constraints=[]
+        )
+
+    return {
+        "status": "SUCCESS",
+        "message": f"Injected {len(injected_entries)} class(es) into the timetable.",
+        "injected": injected_entries,
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+@app.post("/schedule/remove")
+def remove_class(req: RemoveRequest):
+    """Remove a specific class from the timetable manually."""
+    if not schedule_exists():
+        raise HTTPException(400, "No timetable generated yet.")
+
+    sched_data = load_schedule()
+    current = sched_data["schedule"]
+    old_schedule = _clean(dict(current))  # snapshot before mutation
+
+    if req.task_id not in current:
+        raise HTTPException(404, f"Class with ID {req.task_id} not found.")
+
+    removed_entry = current.pop(req.task_id)
+
+    # Save updated schedule
+    save_schedule(current)
+    clean = _clean(current)
+    changes, affected = diff_schedules(old_schedule, clean)
+    if changes:
+        add_history_entry(
+            operation_type="REMOVE_SUBJECT",
+            description=f"Removed class: {removed_entry.get('subject_code')} from {removed_entry.get('section_id')}",
+            affected_sections=affected,
+            changes=changes,
+            status="SUCCESS",
+            constraints=[]
+        )
+
+    clean = _clean(current)
+    return {
+        "status": "SUCCESS",
+        "message": "Class removed successfully.",
+        "removed": req.task_id,
+        "schedule": clean,
+        "grid": _build_grid(clean),
+        **_timetable_constants(),
+    }
+
+
+@app.get("/schedule/free-teachers")
+def get_free_teachers(day_index: int, period_index: int):
+    """Return teachers who have NO class at the given (day, period) slot."""
+    if not schedule_exists():
+        raise HTTPException(400, "No timetable generated yet.")
+
+    data = load_data()
+    sched_data = load_schedule()
+    current = sched_data["schedule"]
+    faculties = data.get("faculties", [])
+
+    # Find all faculty names busy at this slot
+    busy_names = set()
+    for info in current.values():
+        d = info.get("day_index")
+        p = info.get("period_index")
+        dur = info.get("duration", 1)
+        if d == day_index:
+            for i in range(dur):
+                if p + i == period_index:
+                    busy_names.add(info.get("faculty_name", "").strip().lower())
+
+    # Return faculties NOT busy
+    free = []
+    busy = []
+    for fac in faculties:
+        fac_name = fac.get("name", "").strip()
+        if fac_name.lower() in busy_names:
+            busy.append({
+                "id": fac["id"],
+                "name": fac_name,
+                "designation": fac.get("designation", ""),
+                "max_hours": fac.get("max_hours", 18),
+                "status": "busy",
+            })
+        else:
+            free.append({
+                "id": fac["id"],
+                "name": fac_name,
+                "designation": fac.get("designation", ""),
+                "max_hours": fac.get("max_hours", 18),
+                "status": "free",
+            })
+
+    return {
+        "day_index": day_index,
+        "period_index": period_index,
+        "free_count": len(free),
+        "busy_count": len(busy),
+        "free_teachers": free,
+        "busy_teachers": busy,
+    }
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# UPDATE TIMETABLE
+# ═════════════════════════════════════════════════════════════════════════════
+
+_PRIORITY_KEYWORDS = [
+    "replace", "substitute", "take over", "will take", "on leave", "cover",
+    "permanently", "change faculty", "hand over", "assign all",
+    "cancel", "no class", "holiday", "off day",
+    "no toc", "no nlp", "no ml", "no cn", "no sepm", "no nosql",
+    "move", "shift", "reschedule", "transfer", "relocate",
+    "change room", "to lab", "to room", "assign room",
+    "extra class", "makeup", "compensatory", "schedule extra",
+    "swap", "exchange", "freeze", "lock slot",
+    "should not be free", "must not be free", "cannot be free",
+    "must have a class", "should have a class", "no free period",
+    "first hour", "first period", "last period", "last hour",
+]
+
+@app.post("/update")
+def update(req: UpdateRequest):
+    if not schedule_exists():
+        raise HTTPException(400, "No timetable generated yet. Call POST /generate first.")
+
+    prompt = req.prompt.strip()
+    if not prompt:
+        raise HTTPException(400, "Prompt cannot be empty.")
+
+    try:
+        data = load_data()
+        constraints = []
+
+        use_local = any(kw in prompt.lower() for kw in _PRIORITY_KEYWORDS)
+        if use_local:
+            local = smart_parse(prompt, data["faculties"],
+                                data.get("subjects", []), data.get("sections", []))
+            if local:
+                constraints = [local]
+
+        if not constraints:
+            result = get_constraint(prompt)
+            if not result.get("success"):
+                raise HTTPException(400, result.get("error", "Constraint parse failed."))
+            constraints = result.get("constraints", [])
+
+        if not constraints:
+            raise HTTPException(422, "Could not parse any constraint from the instruction.")
+
+        if req.preview_only:
+            return {
+                "preview": True,
+                "parsed_constraints": constraints,
+                "constraint_type": constraints[0].get("type", "?"),
+            }
+
+        sched = load_schedule()
+        current_solution = sched["schedule"]
+        previous_schedule_clean = _clean(current_solution)
+
+        facs, subs, secs, rooms, allocs = _build_objects(data)
+        tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+        tasks_by_id = {t.task_id: t for t in tasks}
+
+        for tid, info in current_solution.items():
+            if tid in tasks_by_id:
+                info["task_obj"] = tasks_by_id[tid]
+
+        final_solution = current_solution
+        all_changes = []
+
+        for constraint in constraints:
+            optimizer = PartialOptimizer(tasks, facs, secs, rooms, final_solution)
+            op_status, new_solution, _, summary = \
+                optimizer.apply_constraint_and_reoptimize(constraint)
+
+            if op_status in ("OPTIMAL", "FEASIBLE", "NO_CHANGE"):
+                final_solution = new_solution
+                all_changes.append(summary)
+            else:
+                all_changes.append(f"⚠️ {summary}")
+
+        if req.propose_only:
+            # Compute but don't save — return schedule for the frontend to propose
+            clean = _clean(final_solution)
+            return {
+                "status": "PROPOSED",
+                "parsed_constraints": constraints,
+                "changes": all_changes,
+                "schedule": clean,
+            }
+
+        save_schedule(final_solution)
+        clean = _clean(final_solution)
+        changes, affected = diff_schedules(previous_schedule_clean, clean)
+        
+        add_history_entry(
+            operation_type="SLM_UPDATE",
+            description=f"AI Update: {prompt}",
+            affected_sections=affected,
+            changes=changes,
+            status="SUCCESS",
+            constraints=constraints
+        )
+
+        clean = _clean(final_solution)
+        return {
+            "status": "SUCCESS",
+            "parsed_constraints": constraints,
+            "constraint_type": constraints[0].get("type", "?"),
+            "changes": all_changes,
+            "previous_schedule": previous_schedule_clean,
+            "updated_schedule": clean,
+            "grid": _build_grid(clean),
+            **_timetable_constants(),
+        }
+
+    except HTTPException:
+        raise
+    except Exception:
+        raise HTTPException(500, traceback.format_exc())
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# LEAVES & SUBSTITUTIONS
+# ═════════════════════════════════════════════════════════════════════════════
+
+class LeaveRequestIn(BaseModel):
+    faculty_id: str
+    days: list[str]
+    reason: str
+
+@app.get("/leave")
+def get_leaves():
+    return {"leaves": load_leave_requests()}
+
+@app.post("/leave", status_code=201)
+def create_leave(req: LeaveRequestIn):
+    leaves = load_leave_requests()
+    leave_id = str(uuid.uuid4())
+    new_leave = {
+        "leave_id": leave_id,
+        "faculty_id": req.faculty_id,
+        "days": req.days,
+        "reason": req.reason,
+        "status": "PENDING"
+    }
+    leaves.append(new_leave)
+    save_leave_requests(leaves)
+    return {"message": "Leave request created", "leave": new_leave}
+
+@app.post("/leave/approve/{leave_id}")
+def approve_leave(leave_id: str):
+    leaves = load_leave_requests()
+    target_leave: dict | None = next((l for l in leaves if l.get("leave_id") == leave_id), None)
+            
+    if not target_leave:
+        raise HTTPException(404, "Leave request not found")
+        
+    if target_leave.get("status") != "PENDING":
+        raise HTTPException(400, f"Leave is already {target_leave.get('status')}")
+        
+    target_leave["status"] = "APPROVED"
+    save_leave_requests(leaves)
+    
+    # Convert dict to namedtuple or dataclass instance expected by engine
+    from models import LeaveRequest as LRModel
+    lr_obj = LRModel(**target_leave)
+    
+    # Trigger substitution finder
+    process_leave_approval(lr_obj)
+    
+    return {"message": "Leave approved and substitution process started."}
+
+@app.post("/leave/reject/{leave_id}")
+def reject_leave(leave_id: str):
+    leaves = load_leave_requests()
+    target = next((l for l in leaves if l["leave_id"] == leave_id), None)
+    if not target: raise HTTPException(404, "Leave request not found")
+    target["status"] = "REJECTED"
+    save_leave_requests(leaves)
+    return {"message": "Leave request rejected."}
+
+@app.get("/substitution")
+@app.get("/substitution/pending")
+def get_pending_substitutions(faculty_id: str | None = None):
+    check_timeouts()
+    reqs = load_substitution_requests()
+    
+    if faculty_id:
+        reqs = [r for r in reqs if r["candidate_faculty_id"] == faculty_id and r["status"] == "PENDING"]
+    else:
+        reqs = [r for r in reqs if r["status"] == "PENDING"]
+        
+    return {"substitutions": reqs}
+
+@app.post("/substitution/{request_id}/accept")
+def accept_substitution(request_id: str):
+    success, msg = handle_acceptance(request_id)
+    if not success:
+        raise HTTPException(400, msg)
+    return {"message": msg}
+
+@app.post("/substitution/{request_id}/decline")
+def decline_substitution(request_id: str):
+    success, msg = handle_decline(request_id)
+    if not success:
+        raise HTTPException(400, msg)
+    return {"message": msg}
+
+@app.get("/substitution/unresolved")
+def get_unresolved_substitutions():
+    check_timeouts()
+    # A slot is unresolved if all requests for it are DECLINED/TIMEOUT, and no ACCEPTED exists
+    # Or if no requests were generated at all (handled separately or indicated by lack of requests)
+    reqs = load_substitution_requests()
+    leaves = load_leave_requests()
+    
+    unresolved_slots = []
+    # simplified logic: find slots where all reqs are not PENDING/ACCEPTED
+    # A true implementation would group by leave_id + slot
+    
+    return {"unresolved": unresolved_slots, "message": "Not fully implemented for MVP"}
+
+# ═════════════════════════════════════════════════════════════════════════════
+# CANCELLATION REQUESTS
+# ═════════════════════════════════════════════════════════════════════════════
+
+class CancellationRequestIn(BaseModel):
+    section_id: str
+    day: str
+    period: int
+    subject: str
+    reason: str
+    faculty_id: str
+
+@app.post("/cancellations/request", status_code=201)
+def create_cancellation_request(req: CancellationRequestIn):
+    cancellations = load_cancellations()
+    cancel_id = str(uuid.uuid4())
+    new_cancel = {
+        "id": cancel_id,
+        "section_id": req.section_id,
+        "day": req.day,
+        "period": req.period,
+        "subject": req.subject,
+        "reason": req.reason,
+        "faculty_id": req.faculty_id,
+        "status": "PENDING",
+        "created_at": datetime.now().isoformat()
+    }
+    cancellations.append(new_cancel)
+    save_cancellations(cancellations)
+    return {"message": "Cancellation request submitted", "cancellation": new_cancel}
+
+@app.get("/cancellations")
+def get_cancellations():
+    return {"cancellations": load_cancellations()}
+
+@app.post("/cancellations/{cancel_id}/status")
+def update_cancellation_status(cancel_id: str, payload: dict = Body(...)):
+    status = payload.get("status")
+    if not status:
+        raise HTTPException(400, "Missing status")
+        
+    cancellations = load_cancellations()
+    target = next((c for c in cancellations if c["id"] == cancel_id), None)
+    if not target:
+        raise HTTPException(404, "Cancellation not found")
+    
+    target["status"] = status
+    save_cancellations(cancellations)
+    return {"message": f"Cancellation marked as {status}", "cancellation": target}
+
+# ═════════════════════════════════════════════════════════════════════════════
+# CHANGE HISTORY
+# ═════════════════════════════════════════════════════════════════════════════
+
+@app.get("/history")
+def get_history():
+    history = load_history()
+    return {
+        "count": len(history),
+        "history": list(reversed(history)),
+    }
+
+@app.post("/history/revert/{history_id}")
+def revert_history(history_id: str, force: bool = False):
+    history = load_history()
+    entry = next((e for e in history if e.get("id") == history_id), None)
+    if not entry:
+        raise HTTPException(404, "History entry not found.")
+    
+    sched_raw = load_schedule() or {}
+    current_sched = sched_raw.get("schedule", {}) if isinstance(sched_raw, dict) else {}
+    changes = entry.get("changes", [])
+    
+    if not force:
+        # Check for conflicts
+        conflicts = []
+        for c in changes:
+            tid = c["task_id"]
+            curr_val = _clean({tid: current_sched[tid]}).get(tid) if tid in current_sched else None
+            after_val = c["after"]
+            if curr_val != after_val:
+                conflicts.append(tid)
+        
+        if conflicts:
+            raise HTTPException(409, {
+                "message": "Conflict detected: The timetable has been modified since this change was made. Reverting will overwrite those newer modifications. Do you want to force revert?",
+                "conflicts": conflicts
+            })
+    
+    # Apply revert
+    new_sched = dict(current_sched)
+    for c in changes:
+        tid = c["task_id"]
+        before_val = c["before"]
+        if before_val is None:
+            if tid in new_sched:
+                del new_sched[tid]
+        else:
+            new_sched[tid] = dict(before_val)
+            
+    clean_new = _clean(new_sched)
+    save_schedule(clean_new)
+    
+    # Mark the original entry as REVERTED (keep it visible)
+    entry["status"] = "REVERTED"
+    save_history(history)
+    
+    # Log the revert itself as a new entry
+    rev_changes, rev_affected = diff_schedules(_clean(current_sched), clean_new)
+    if rev_changes:
+        add_history_entry(
+            operation_type="REVERT",
+            description=f"Reverted: {entry.get('description', history_id)}",
+            affected_sections=rev_affected,
+            changes=rev_changes,
+            status="SUCCESS"
+        )
+        
+    return {
+        "status": "SUCCESS",
+        "message": "Revert successful.",
+        "schedule": clean_new,
+        "grid": _build_grid(clean_new),
+        **_timetable_constants(),
+    }
+
+@app.delete("/history")
+def delete_history():
+    clear_history()
+    return {"message": "History cleared."}

app.py

@@ -0,0 +1,639 @@
+# app.py
+
+import streamlit as st
+import pandas as pd
+from collections import defaultdict
+from datetime import datetime
+
+from storage import (load_data, save_data, save_schedule, load_schedule,
+                     schedule_exists, clear_schedule, load_history,
+                     add_history_entry, clear_history,
+                     save_original_schedule, load_original_schedule,
+                     original_schedule_exists, clear_original_schedule)
+from models import Faculty, Subject, Section, Room, SubjectType
+from data_loader import Allocation, prepare_scheduling_tasks
+from solver import TimetableSolver
+from slm_inference import get_constraint, check_api_health
+from partial_optimizer import PartialOptimizer
+import constants as const
+
+st.set_page_config(page_title="VTU Timetable Generator", layout="wide")
+
+# ── Helpers ───────────────────────────────────────────────────────────────
+def get_subject_type_enum(type_str):
+    return {
+        "THEORY": SubjectType.THEORY, "LAB": SubjectType.LAB,
+        "SOFTSKILL": SubjectType.SOFTSKILL, "FORUM": SubjectType.FORUM
+    }.get(type_str.upper(), SubjectType.THEORY)
+
+def convert_json_to_objects(data):
+    fac_objs  = [Faculty(f['id'], f['name'], f['designation'], f['max_hours'])
+                 for f in data['faculties']]
+    sub_objs  = [Subject(s['code'], s['name'], s['credits'],
+                         get_subject_type_enum(s['type']),
+                         s.get('is_core', True), s.get('is_heavy', False))
+                 for s in data['subjects']]
+    sec_objs  = [Section(s['id'], s['semester'], s['strength'])
+                 for s in data['sections']]
+    room_objs = [Room(r['id'], r['capacity'], r['is_lab'], r['building'])
+                 for r in data['rooms']]
+    alloc_objs = [Allocation(a['faculty_id'], a['subject_code'],
+                             a['section_id'], a.get('elective_group'))
+                  for a in data['allocations']]
+    return fac_objs, sub_objs, sec_objs, room_objs, alloc_objs
+
+def rebuild_objects(data):
+    """Rebuild all domain objects from stored data."""
+    return convert_json_to_objects(data)
+
+def render_timetable_html(solution, sections):
+    """Render the timetable as an HTML table."""
+    parent_sections = sorted(list(set(
+        s.section_id.split('-')[0].upper() for s in sections)))
+
+    # Grid stores list of (subject_code, faculty_name) per slot
+    merged_grid = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
+    for task_id, info in solution.items():
+        sec_id     = info.get('section_id', '')
+        parent_sec = sec_id.split('-')[0].upper()
+        day        = info.get('day_index', 0)
+        period     = info.get('period_index', 0)
+        dur        = info.get('duration', 1)
+        subject    = info.get('subject_code', '?').upper()
+        faculty    = info.get('faculty_name', '')
+        short_fac  = (faculty.replace('Prof. ','').replace('Dr. ','')
+                      .replace('Mr. ','').replace('Ms. ',''))
+        for i in range(dur):
+            entry = (subject, short_fac)
+            if entry not in merged_grid[parent_sec][day][period + i]:
+                merged_grid[parent_sec][day][period + i].append(entry)
+
+    st.markdown("""
+    <style>
+    table.tt { width:100%; border-collapse:collapse; font-size:0.82em; }
+    table.tt th, table.tt td {
+        border:2px solid #555; padding:5px 4px;
+        text-align:center; vertical-align:middle; min-width:80px;
+    }
+    table.tt th { background:#2b2b2b; color:#fff; font-weight:bold; }
+    .vt  { writing-mode:vertical-rl; transform:rotate(180deg);
+           font-weight:bold; background:#1e1e1e; color:#ccc; }
+    .dh  { font-weight:bold; background:#1a1a2e; color:#fff; }
+    .subj { font-weight:bold; font-size:0.95em; color:#4fc3f7; }
+    .fac  { font-size:0.78em; color:#aaa; margin-top:2px; }
+    .multi-subj { border-top:1px dashed #555; margin-top:3px; padding-top:3px; }
+    </style>""", unsafe_allow_html=True)
+
+    for p_sec in parent_sections:
+        st.markdown(f"### Section: {p_sec}")
+        html = '<table class="tt"><tr><th>Day \\ Time</th>'
+        for h in const.TIMETABLE_HEADERS:
+            html += f'<th>{h}</th>'
+        html += '</tr>'
+
+        # Detect all days that have classes (including Saturday from extra classes)
+        days_in_solution = set()
+        for task_id, info in solution.items():
+            sec = info.get('section_id','')
+            if sec.split('-')[0].upper() == p_sec or sec.upper() == p_sec:
+                days_in_solution.add(info['day_index'])
+
+        # Always show Mon-Fri; add Saturday only if it has classes
+        all_day_indices = list(range(len(const.DAYS)))
+        sat_index = 5  # Saturday index
+        if sat_index in days_in_solution and sat_index not in all_day_indices:
+            all_day_indices.append(sat_index)
+
+        # Day name lookup including Saturday
+        all_day_names = list(const.DAYS) + (['SAT'] if len(const.DAYS) <= 5 else [])
+
+        total_days = len(all_day_indices)
+
+        for row_num, day_idx in enumerate(all_day_indices):
+            day_name = all_day_names[day_idx] if day_idx < len(all_day_names) else f'Day{day_idx}'
+            html += f'<tr><td class="dh">{day_name}</td>'
+            period_counter = 0
+            for header_text in const.TIMETABLE_HEADERS:
+                is_break = (header_text == "10:35-10:50")
+                is_lunch = (header_text == "12:40-1:40")
+                if is_break:
+                    if row_num == 0:
+                        html += f'<td rowspan="{total_days}" class="vt">Tea Break</td>'
+                elif is_lunch:
+                    if row_num == 0:
+                        html += f'<td rowspan="{total_days}" class="vt">Lunch Break</td>'
+                else:
+                    entries = merged_grid[p_sec][day_idx].get(period_counter, [])
+                    if entries:
+                        cell = ''
+                        for idx, (subj, fac) in enumerate(entries):
+                            div_cls = 'multi-subj' if idx > 0 else ''
+                            cell += (f'<div class="{div_cls}">'
+                                     f'<div class="subj">{subj}</div>'
+                                     f'<div class="fac">{fac}</div>'
+                                     f'</div>')
+                        html += f'<td>{cell}</td>'
+                    else:
+                        html += '<td></td>'
+                    period_counter += 1
+            html += '</tr>'
+        html += '</table><br>'
+        st.markdown(html, unsafe_allow_html=True)
+
+# ── Sidebar ───────────────────────────────────────────────────────────────
+st.sidebar.title("🎓 VTU Timetable System")
+
+# Show schedule status in sidebar
+if schedule_exists():
+    sched = load_schedule()
+    gen_at = sched.get('generated_at', '')[:16].replace('T', ' ')
+    st.sidebar.success(f"📅 Schedule active\nGenerated: {gen_at}")
+else:
+    st.sidebar.warning("No schedule generated yet")
+
+page = st.sidebar.radio("Navigate", [
+    "🗓️ Generate Timetable",
+    "✏️ Update Timetable",
+    "📊 Original vs Current",
+    "📋 Change History",
+    "👥 Manage Faculties",
+    "📚 Manage Subjects",
+    "🏛️ Manage Sections",
+    "🚪 Manage Rooms",
+    "🔗 Manage Allocations",
+])
+
+data = load_data()
+
+# ═════════════════════════════════════════════════════════════════════════════
+# PAGE: GENERATE TIMETABLE
+# ═════════════════════════════════════════════════════════════════════════════
+if page == "🗓️ Generate Timetable":
+    st.header("🗓️ Generate Semester Timetable")
+
+    if schedule_exists():
+        st.warning("⚠️ A timetable is already active for this semester.")
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("📄 View Current Timetable"):
+                st.session_state['show_current'] = True
+        with col2:
+            if st.button("🔄 Generate New Timetable (replaces current)", type="secondary"):
+                clear_schedule()
+                clear_history()
+                clear_original_schedule()
+                st.rerun()
+
+        if st.session_state.get('show_current'):
+            sched = load_schedule()
+            if sched:
+                solution = sched['schedule']
+                _, _, secs, _, _ = rebuild_objects(data)
+                render_timetable_html(solution, secs)
+
+    else:
+        st.info("Generate the timetable once — it will be fixed for the semester. "
+                "Use 'Update Timetable' to make changes later via prompts.")
+
+        time_limit = st.slider("Solver time limit (seconds)", 10, 240, 120)
+
+        st.markdown("### 📝 Add Constraints Before Generating (Optional)")
+        st.caption("These rules will be baked into the timetable from the start.")
+
+        # Constraint input area
+        if 'pre_constraints' not in st.session_state:
+            st.session_state['pre_constraints'] = []
+
+        col1, col2 = st.columns([4, 1])
+        with col1:
+            new_prompt = st.text_input(
+                "Type a constraint:",
+                placeholder="e.g. Prof. Anu is not available on Friday",
+                key="pre_constraint_input"
+            )
+        with col2:
+            st.markdown("<br>", unsafe_allow_html=True)
+            if st.button("➕ Add") and new_prompt.strip():
+                st.session_state['pre_constraints'].append(new_prompt.strip())
+                st.rerun()
+
+        # Show added constraints
+        if st.session_state['pre_constraints']:
+            st.markdown("**Constraints to apply:**")
+            for i, c in enumerate(st.session_state['pre_constraints']):
+                col1, col2 = st.columns([5, 1])
+                col1.markdown(f"• {c}")
+                if col2.button("❌", key=f"del_{i}"):
+                    st.session_state['pre_constraints'].pop(i)
+                    st.rerun()
+        else:
+            st.info("No constraints added — timetable will be generated with default rules only.")
+
+        st.divider()
+
+        if st.button("🚀 Generate Timetable", type="primary"):
+            try:
+                facs, subs, secs, rooms, allocs = convert_json_to_objects(data)
+                tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+                st.write(f"Scheduling {len(tasks)} tasks...")
+
+                # Convert pre-constraints via SLM
+                pre_slm_constraints = []
+                if st.session_state.get('pre_constraints'):
+                    with st.spinner("Converting constraints via SLM API..."):
+                        from slm_inference import get_constraints_batch
+                        pre_slm_constraints = get_constraints_batch(
+                            st.session_state['pre_constraints'])
+                    st.write(f"✅ {len(pre_slm_constraints)} constraint(s) parsed")
+
+                solver = TimetableSolver(tasks, facs, secs, rooms)
+                with st.spinner("Optimizing schedule..."):
+                    status, solution = solver.solve(
+                        time_limit_seconds=time_limit,
+                        enable_soft_constraints=True,
+                        slm_constraints=pre_slm_constraints)
+
+                if status in ("OPTIMAL", "FEASIBLE"):
+                    save_schedule(solution)
+                    save_original_schedule(solution)  # permanent snapshot
+                    st.success(f"✅ Timetable Generated! Status: {status}")
+                    st.balloons()
+                    render_timetable_html(solution, secs)
+                else:
+                    st.error(f"❌ Solver failed: {status}")
+            except Exception as e:
+                st.error(f"Error: {e}")
+                import traceback; st.code(traceback.format_exc())
+
+# ═════════════════════════════════════════════════════════════════════════════
+# PAGE: UPDATE TIMETABLE
+# ═════════════════════════════════════════════════════════════════════════════
+elif page == "✏️ Update Timetable":
+    st.header("✏️ Update Timetable with Natural Language")
+
+    if not schedule_exists():
+        st.error("❌ No timetable generated yet. Go to 'Generate Timetable' first.")
+        st.stop()
+
+    # API Health Check
+    with st.spinner("Checking SLM API..."):
+        api_ok = check_api_health()
+    if api_ok:
+        st.success("✅ SLM API is online")
+    else:
+        st.error("❌ SLM API is offline. Check HuggingFace Space.")
+        st.stop()
+
+    st.markdown("""
+    **How it works:** Type a natural language instruction. Only the affected 
+    slots will be rescheduled — the rest of the timetable stays unchanged.
+    
+    **Examples:**
+    - `Prof. Anu is not available on Friday`
+    - `NLP Lab must be in consecutive slots`  
+    - `ML should be scheduled in the morning`
+    - `Slot 5 is the lunch break`
+    - `Limit Sanjay to 3 hours per day`
+    - `Prof. Kavitha should have Wednesday free`
+    """)
+
+    st.divider()
+
+    prompt = st.text_input("💬 Enter your instruction:",
+                           placeholder="e.g. Prof. Anu is not available on Friday")
+
+    col1, col2 = st.columns([1, 3])
+    with col1:
+        apply = st.button("✅ Apply Change", type="primary",
+                          disabled=not prompt.strip())
+    with col2:
+        preview = st.button("👁️ Preview Constraint Only",
+                            disabled=not prompt.strip())
+
+    # Preview mode — just show the constraint without applying
+    if preview and prompt.strip():
+        from slm_inference import smart_parse
+        local = smart_parse(prompt, data['faculties'],
+                            data.get('subjects',[]), data.get('sections',[]))
+        if local:
+            st.subheader("Constraint that would be applied (local parser):")
+            st.json(local)
+        else:
+            with st.spinner("Calling SLM API..."):
+                result = get_constraint(prompt)
+            if result.get('success'):
+                st.subheader("Constraint that would be applied (SLM API):")
+                for c in result['constraints']:
+                    st.json(c)
+            else:
+                st.error(f"Failed to parse: {result.get('error')}")
+                st.code(result.get('raw', ''))
+
+    # Apply mode — actually update the timetable
+    if apply and prompt.strip():
+        from slm_inference import smart_parse
+
+        # ── Step 1: Try smart_parse FIRST for high-confidence direct operations ──
+        # These patterns are reliably detected locally without needing the SLM
+        priority_keywords = [
+            # Faculty operations
+            'replace','substitute','take over','will take','on leave','cover',
+            'permanently','change faculty','hand over','assign all',
+            # Cancel / holiday
+            'cancel','no class','holiday','off day',
+            'no toc','no nlp','no ml','no cn','no sepm','no nosql',
+            'no rmipr','no dvlab','no cnlab','no nlplab','no mllab',
+            'no iks','no evs','no genai','no devops','no hcai',
+            # Move / reschedule
+            'move','shift','reschedule','transfer','relocate',
+            # Room
+            'change room','to lab','to room','assign room',
+            # Extra class
+            'extra class','makeup','compensatory','schedule extra',
+            'add extra','add makeup','additional session','extra session',
+            'extra ml','extra nlp','extra toc','extra cn','extra sepm',
+            'schedule.*class','add.*class',
+            # Swap / freeze
+            'swap','exchange','freeze','lock slot',
+            # NO_FREE_PERIOD — must be here so smart_parse runs first
+            'should not be free','must not be free','cannot be free',
+            'must have a class','should have a class','always occupied',
+            'no free period','no free slot','must be filled',
+            'first hour','first period','last period','last hour',
+        ]
+        use_smart_parse_first = any(kw in prompt.lower() for kw in priority_keywords)
+        constraints = []
+
+        if use_smart_parse_first:
+            local = smart_parse(prompt, data['faculties'],
+                                data.get('subjects',[]), data.get('sections',[]))
+            if local:
+                constraints = [local]
+                st.info(f"🔄 Operation detected: `{local['type']}`")
+
+        # ── Step 2: Fall back to SLM API if smart_parse couldn't handle it ──
+        if not constraints:
+            with st.spinner("🤖 Converting instruction to constraint..."):
+                result = get_constraint(prompt)
+            if not result.get('success'):
+                st.error(f"❌ Could not parse instruction: {result.get('error')}")
+                st.code(result.get('raw', ''))
+                st.stop()
+            constraints = result.get('constraints', [])
+            if constraints:
+                st.info(f"Parsed constraint: `{constraints[0].get('type','?')}`")
+
+        if not constraints:
+            st.error("No constraints parsed."); st.stop()
+
+        st.info(f"Parsed constraint: `{constraints[0]['type'] if constraints else 'none'}`")
+
+        # Load current schedule and rebuild objects
+        sched = load_schedule()
+        current_solution = sched['schedule']
+        facs, subs, secs, rooms, allocs = rebuild_objects(data)
+        tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+
+        # Rebuild task objects into solution (attach task_obj)
+        tasks_by_id = {t.task_id: t for t in tasks}
+        for tid, info in current_solution.items():
+            if tid in tasks_by_id:
+                info['task_obj'] = tasks_by_id[tid]
+
+        # Run partial optimizer for each constraint
+        all_changes = []
+        final_solution = current_solution
+
+        for constraint in constraints:
+            with st.spinner(f"Rescheduling tasks for: {constraint['type']}..."):
+                optimizer = PartialOptimizer(
+                    tasks, facs, secs, rooms, final_solution)
+                status, new_solution, affected, summary = \
+                    optimizer.apply_constraint_and_reoptimize(constraint)
+
+            if status in ('OPTIMAL', 'FEASIBLE', 'NO_CHANGE'):
+                final_solution = new_solution
+                all_changes.append(summary)
+            else:
+                st.warning(f"⚠️ {summary}")
+
+        # Save updated schedule
+        save_schedule(final_solution)
+        add_history_entry(
+            operation_type="LLM_UPDATE",
+            description=f"AI Update: {prompt}",
+            affected_sections=[],
+            changes=[],
+            status='SUCCESS',
+            constraints=constraints
+        )
+
+        # Show results
+        st.success("✅ Timetable updated!")
+        for change in all_changes:
+            st.markdown(change)
+
+        st.divider()
+
+        # ── Side-by-side: Original vs Updated ────────────────────────────
+        col_orig, col_new = st.columns(2)
+        with col_orig:
+            st.subheader("📋 Original Timetable")
+            render_timetable_html(current_solution, secs)
+        with col_new:
+            st.subheader("📅 Updated Timetable")
+            render_timetable_html(final_solution, secs)
+
+    # ── Show current timetable below ──────────────────────────────────────
+    st.divider()
+    with st.expander("📄 View Current Full Timetable"):
+        sched = load_schedule()
+        if sched:
+            _, _, secs, _, _ = rebuild_objects(data)
+            render_timetable_html(sched['schedule'], secs)
+
+# ═════════════════════════════════════════════════════════════════════════════
+# PAGE: ORIGINAL VS CURRENT
+# ═════════════════════════════════════════════════════════════════════════════
+elif page == "📊 Original vs Current":
+    st.header("📊 Original vs Current Timetable")
+
+    if not schedule_exists():
+        st.error("❌ No timetable generated yet.")
+        st.stop()
+
+    _, _, secs, _, _ = rebuild_objects(data)
+
+    has_orig = original_schedule_exists()
+    orig     = load_original_schedule() if has_orig else None
+    current  = load_schedule()
+
+    if orig:
+        orig_at = orig.get('generated_at', '')[:16].replace('T', ' ')
+    curr_at = current.get('generated_at', '')[:16].replace('T', ' ') if current else ''
+
+    # Summary badge
+    history = load_history()
+    n_changes = len(history)
+    col1, col2, col3 = st.columns(3)
+    col1.metric("Original Generated", orig_at if orig else "N/A")
+    col2.metric("Last Updated", curr_at)
+    col3.metric("Total Changes Applied", n_changes)
+
+    st.divider()
+
+    if orig:
+        tab1, tab2 = st.tabs(["🗂️ Original Timetable", "📅 Current Timetable"])
+        with tab1:
+            st.caption(f"Generated on {orig_at} — never modified")
+            render_timetable_html(orig['schedule'], secs)
+        with tab2:
+            st.caption(f"Last updated: {curr_at} — {n_changes} change(s) applied")
+            render_timetable_html(current['schedule'], secs)
+    else:
+        st.info("Original snapshot not available. "
+                "Regenerate the timetable to create one.")
+        st.subheader("Current Timetable")
+        render_timetable_html(current['schedule'], secs)
+
+# ═════════════════════════════════════════════════════════════════════════════
+# PAGE: CHANGE HISTORY
+# ═════════════════════════════════════════════════════════════════════════════
+elif page == "📋 Change History":
+    st.header("📋 Change History")
+
+    history = load_history()
+    if not history:
+        st.info("No changes have been made yet.")
+    else:
+        st.write(f"**{len(history)} change(s) recorded**")
+        for i, entry in enumerate(reversed(history)):
+            ts = entry['timestamp'][:16].replace('T', ' ')
+            desc = entry.get('description', entry.get('prompt', ''))
+            op_type = entry.get('operation_type', 'UPDATE')
+            with st.expander(f"#{len(history)-i} — {ts} — [{op_type}] {desc}"):
+                st.markdown(f"**Description:** {desc}")
+                st.markdown(f"**Operation:** {op_type}")
+                st.markdown(f"**Status:** {entry.get('status', 'UNKNOWN')}")
+                sections = entry.get('affected_sections', [])
+                if sections:
+                    st.markdown(f"**Affected Sections:** {', '.join(sections)}")
+                changes = entry.get('changes', [])
+                if changes:
+                    st.subheader(f"Detailed Changes ({len(changes)} cells)")
+                    for c in changes[:20]:
+                        st.json(c)
+                if entry.get('constraints'):
+                    st.subheader("Constraint applied:")
+                    st.json(entry['constraints'])
+
+        if st.button("🗑️ Clear History"):
+            clear_history()
+            st.rerun()
+
+# ═════════════════════════════════════════════════════════════════════════════
+# MANAGEMENT PAGES (unchanged from original)
+# ═════════════════════════════════════════════════════════════════════════════
+elif page == "👥 Manage Faculties":
+    st.header("Manage Faculties")
+    with st.form("add_faculty"):
+        col1, col2 = st.columns(2)
+        f_id   = col1.text_input("ID (e.g., 'F001')")
+        f_name = col2.text_input("Name")
+        f_desig = col1.selectbox("Designation",
+                                  ["Professor","Assoc. Prof","Asst. Prof","Guest"])
+        f_max  = col2.number_input("Max Hours/Week", min_value=1, value=18)
+        if st.form_submit_button("Add Faculty"):
+            if f_id and f_name:
+                data['faculties'].append({"id": f_id, "name": f_name,
+                                          "designation": f_desig, "max_hours": f_max})
+                save_data(data); st.success("Added!"); st.rerun()
+            else:
+                st.error("ID and Name are required.")
+    if data['faculties']:
+        st.dataframe(pd.DataFrame(data['faculties']))
+        if st.button("Clear All Faculties"):
+            data['faculties'] = []; save_data(data); st.rerun()
+
+elif page == "📚 Manage Subjects":
+    st.header("Manage Subjects")
+    with st.form("add_subject"):
+        col1, col2 = st.columns(2)
+        s_code  = col1.text_input("Code")
+        s_name  = col2.text_input("Name")
+        s_type  = col1.selectbox("Type", ["THEORY","LAB","SOFTSKILL","FORUM"])
+        s_cred  = col2.number_input("Credits", min_value=0, value=3)
+        s_core  = col1.checkbox("Is Core?", value=True)
+        s_heavy = col2.checkbox("Is Heavy?", value=False)
+        if st.form_submit_button("Add Subject"):
+            if s_code:
+                data['subjects'].append({"code": s_code, "name": s_name,
+                    "type": s_type, "credits": s_cred,
+                    "is_core": s_core, "is_heavy": s_heavy})
+                save_data(data); st.success("Added!"); st.rerun()
+    if data['subjects']:
+        st.dataframe(pd.DataFrame(data['subjects']))
+        if st.button("Clear All Subjects"):
+            data['subjects'] = []; save_data(data); st.rerun()
+
+elif page == "🏛️ Manage Sections":
+    st.header("Manage Sections")
+    with st.form("add_section"):
+        col1, col2 = st.columns(2)
+        sec_id   = col1.text_input("Section ID (e.g., '6A')")
+        sem      = col2.number_input("Semester", min_value=1, value=6)
+        strength = col1.number_input("Student Strength", min_value=1, value=60)
+        if st.form_submit_button("Add Section"):
+            if sec_id:
+                data['sections'].append({"id": sec_id, "semester": sem,
+                                         "strength": strength})
+                save_data(data); st.success("Added!"); st.rerun()
+    if data['sections']:
+        st.dataframe(pd.DataFrame(data['sections']))
+        if st.button("Clear All Sections"):
+            data['sections'] = []; save_data(data); st.rerun()
+
+elif page == "🚪 Manage Rooms":
+    st.header("Manage Rooms")
+    with st.form("add_room"):
+        col1, col2 = st.columns(2)
+        r_id  = col1.text_input("Room ID")
+        cap   = col2.number_input("Capacity", min_value=1, value=80)
+        is_lab = col1.checkbox("Is Lab?", value=False)
+        bld   = col2.text_input("Building", value="Main")
+        if st.form_submit_button("Add Room"):
+            if r_id:
+                data['rooms'].append({"id": r_id, "capacity": cap,
+                                      "is_lab": is_lab, "building": bld})
+                save_data(data); st.success("Added!"); st.rerun()
+    if data['rooms']:
+        st.dataframe(pd.DataFrame(data['rooms']))
+        if st.button("Clear All Rooms"):
+            data['rooms'] = []; save_data(data); st.rerun()
+
+elif page == "🔗 Manage Allocations":
+    st.header("Manage Allocations")
+    if not (data['faculties'] and data['subjects'] and data['sections']):
+        st.warning("Add Faculties, Subjects, and Sections first.")
+    else:
+        fac_opts = {f['name']: f['id'] for f in data['faculties']}
+        sub_opts = {s['name']: s['code'] for s in data['subjects']}
+        sec_opts = [s['id'] for s in data['sections']]
+        with st.form("add_alloc"):
+            col1, col2 = st.columns(2)
+            f   = col1.selectbox("Faculty", list(fac_opts.keys()))
+            s   = col2.selectbox("Subject", list(sub_opts.keys()))
+            sec = col1.selectbox("Section", sec_opts)
+            grp = col2.text_input("Elective Group ID (Optional)")
+            if st.form_submit_button("Add Allocation"):
+                data['allocations'].append({
+                    "faculty_id":    fac_opts[f],
+                    "subject_code":  sub_opts[s],
+                    "section_id":    sec,
+                    "elective_group": grp if grp else None
+                })
+                save_data(data); st.success("Allocation Added!"); st.rerun()
+        if data['allocations']:
+            st.dataframe(pd.DataFrame(data['allocations']))
+            if st.button("Clear Allocations"):
+                data['allocations'] = []; save_data(data); st.rerun()

cancellations.json

@@ -0,0 +1,24 @@
+[
+  {
+    "id": "39048066-0726-4954-9e15-19d3810944fd",
+    "section_id": "7A",
+    "day": "Monday",
+    "period": 0,
+    "subject": "SOFT SKILLS",
+    "reason": "Slots not allocated yet",
+    "faculty_id": "Prof. Surbhi",
+    "status": "PENDING",
+    "created_at": "2026-06-30T09:59:46.230330"
+  },
+  {
+    "id": "e4e42303-3a01-4e50-8cb2-77a64f6e63dc",
+    "section_id": "7A",
+    "day": "Monday",
+    "period": 0,
+    "subject": "SOFT SKILLS",
+    "reason": "Slot not allocated",
+    "faculty_id": "Test Admin",
+    "status": "PENDING",
+    "created_at": "2026-06-30T10:01:39.988185"
+  }
+]

constants.py

@@ -0,0 +1,30 @@
+# constants.py
+
+NUM_WORKING_DAYS = 5
+DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
+
+# 8 Teaching slots per day
+NUM_TEACHING_SLOTS_PER_DAY = 8
+TOTAL_TEACHING_SLOTS_PER_WEEK = NUM_TEACHING_SLOTS_PER_DAY * NUM_WORKING_DAYS
+
+# INDICES (0-based) AFTER WHICH BREAKS OCCUR
+# P1(0), P2(1) -> BREAK -> P3(2), P4(3) -> LUNCH -> P5(4)...
+BREAK_AFTER_INDEX = 1
+LUNCH_AFTER_INDEX = 3
+
+# Valid Lab Start Indices (Computed to ensure labs don't cross breaks)
+ALLOWED_LAB_START_INDICES = [0, 2, 4, 5, 6]
+
+# Column Headers for Streamlit to match the reference image
+TIMETABLE_HEADERS = [
+    "8:45-9:40",      # P1
+    "9:40-10:35",     # P2
+    "10:35-10:50",    # BREAK
+    "10:50-11:45",    # P3
+    "11:45-12:40",    # P4
+    "12:40-1:40",     # LUNCH
+    "1:40-2:35",      # P5
+    "2:35-3:30",      # P6
+    "3:30-4:25",      # P7
+    "4:25-5:20"       # P8
+]

constraint_engine.py

@@ -0,0 +1,377 @@
+# constraint_engine.py
+
+from collections import defaultdict
+from typing import List, Dict, Any, Tuple
+from ortools.sat.python import cp_model
+from models import Task, Faculty, Section, Room, SubjectType
+import constants as const
+
+TaskVariables = Tuple[cp_model.IntVar, cp_model.IntVar, cp_model.IntervalVar, cp_model.IntVar]
+
+class ConstraintEngine:
+    def __init__(
+        self,
+        model: cp_model.CpModel,
+        tasks: List[Task],
+        faculties: List[Faculty],
+        sections: List[Section],
+        rooms: List[Room],
+        max_continuous_stretch: int = 3,
+        slm_constraints: List[Dict[str, Any]] = None,
+        scheduling_rules: List[Dict[str, Any]] = None,
+        locked_schedule: Dict[str, Any] = None,
+        locked_semesters: List[int] = None
+    ):
+        self.model = model
+        self.tasks = tasks
+        self.faculties = faculties
+        self.sections = sections
+        self.rooms = rooms
+        self.max_continuous_stretch = max_continuous_stretch
+        self.slm_constraints = slm_constraints or []
+        self.scheduling_rules = scheduling_rules or []
+        self.locked_schedule = locked_schedule or {}
+        self.locked_semesters = set(locked_semesters or [])
+        self.room_map = {room.room_id: i for i, room in enumerate(self.rooms)}
+        self.task_vars: Dict[str, TaskVariables] = {}
+
+    def apply_all_constraints(self):
+        self._create_task_variables()
+        self._apply_clash_constraints()
+        self._apply_stretch_constraints()
+        self._apply_grouping_constraints()
+        self._apply_daily_subject_limit()
+        self._apply_fixed_section_classroom_constraints()
+
+    def _create_task_variables(self):
+        for task in self.tasks:
+            is_locked = task.section.semester in self.locked_semesters
+            
+            if is_locked and task.task_id in self.locked_schedule:
+                # Force the task to the exact slot and room from the existing schedule
+                locked_info = self.locked_schedule[task.task_id]
+                start_slot = locked_info["start_slot"]
+                room_id = locked_info["room_id"]
+                room_index = self.room_map.get(room_id, 0) # Fallback to 0 if missing
+
+                start_domain = cp_model.Domain.FromValues([start_slot])
+                start_var = self.model.NewIntVarFromDomain(start_domain, name=f"{task.task_id}_start")
+                
+                room_domain = cp_model.Domain.FromValues([room_index])
+                room_var = self.model.NewIntVarFromDomain(room_domain, name=f"{task.task_id}_room")
+            else:
+                allowed_starts = self._get_allowed_start_slots(task)
+                start_domain = cp_model.Domain.FromValues(allowed_starts)
+                start_var = self.model.NewIntVarFromDomain(start_domain, name=f"{task.task_id}_start")
+
+                allowed_room_indices = self._get_allowed_rooms(task)
+                room_domain = cp_model.Domain.FromValues(allowed_room_indices)
+                room_var = self.model.NewIntVarFromDomain(room_domain, name=f"{task.task_id}_room")
+
+            end_var = self.model.NewIntVar(0, const.TOTAL_TEACHING_SLOTS_PER_WEEK, name=f"{task.task_id}_end")
+            interval_var = self.model.NewIntervalVar(start_var, task.duration, end_var, name=f"{task.task_id}_interval")
+
+            self.task_vars[task.task_id] = (start_var, end_var, interval_var, room_var)
+
+    def _apply_clash_constraints(self):
+        # 1. Faculty Clash Prevention (MODIFIED FOR COMBINED ELECTIVES)
+        intervals_by_faculty = defaultdict(list)
+        processed_groups_per_faculty = defaultdict(set)
+
+        faculty_ids_set = {f.id for f in self.faculties}
+        for task in self.tasks:
+            parts = task.faculty.id.split('_')
+            fids = parts if len(parts) > 1 and all(p in faculty_ids_set for p in parts) else [task.faculty.id]
+            gid = task.elective_group_id
+            interval = self.task_vars[task.task_id][2]
+
+            for fid in fids:
+                if gid:
+                    # If this faculty is teaching a group, only add the interval ONCE for that group
+                    if gid not in processed_groups_per_faculty[fid]:
+                        intervals_by_faculty[fid].append(interval)
+                        processed_groups_per_faculty[fid].add(gid)
+                else:
+                    intervals_by_faculty[fid].append(interval)
+        
+        for faculty_id in intervals_by_faculty:
+            if faculty_id == "DUMMY_STAFF":
+                continue
+            self.model.AddNoOverlap(intervals_by_faculty[faculty_id])
+
+        # 2. Section Clash Prevention (MODIFIED FOR ELECTIVES AND BATCHES)
+        intervals_by_section = defaultdict(list)
+        processed_groups_per_section = defaultdict(set)
+        
+        # We also need to keep track of parent sections dynamically in case they are missing from self.sections
+        parent_sections_dynamic = set()
+
+        for task in self.tasks:
+            sid = task.section.section_id
+            gid = task.elective_group_id
+            interval = self.task_vars[task.task_id][2]
+
+            if gid:
+                if gid not in processed_groups_per_section[sid]:
+                    intervals_by_section[sid].append(interval)
+                    processed_groups_per_section[sid].add(gid)
+            else:
+                intervals_by_section[sid].append(interval)
+                
+            # Add to parent_sections_dynamic if it's a parent section
+            if '-' not in sid:
+                parent_sections_dynamic.add(sid)
+            else:
+                parent_sections_dynamic.add(sid.split('-')[0])
+
+        for section_id in intervals_by_section:
+            self.model.AddNoOverlap(intervals_by_section[section_id])
+
+        # Enforce NoOverlap between Parent and ALL its Batches (including between batches)
+        for parent_sid in parent_sections_dynamic:
+            parent_intervals = list(intervals_by_section.get(parent_sid, []))
+
+            # Parent can't overlap with any batch task (grouped or not)
+            for batch_suffix in ['-B1', '-B2', '-B3']:
+                batch_id = f"{parent_sid}{batch_suffix}"
+                if batch_id in intervals_by_section:
+                    self.model.AddNoOverlap(parent_intervals + intervals_by_section[batch_id])
+
+            # Non-grouped batch tasks across different batches can't overlap.
+            # (Grouped tasks are allowed to overlap — the grouping constraint
+            #  forces them to the same start time intentionally.)
+            non_grouped_cross_batch = []
+            for task in self.tasks:
+                sid = task.section.section_id
+                if '-' in sid and sid.split('-')[0] == parent_sid and not task.elective_group_id:
+                    non_grouped_cross_batch.append(self.task_vars[task.task_id][2])
+
+            if len(non_grouped_cross_batch) > 1:
+                self.model.AddNoOverlap(non_grouped_cross_batch)
+
+        # 3. Room Clash Prevention
+        for i, room in enumerate(self.rooms):
+            optional_intervals = []
+            for task in self.tasks:
+                if i in self._get_allowed_rooms(task):
+                    interval, room_var = self.task_vars[task.task_id][2], self.task_vars[task.task_id][3]
+                    is_in_room = self.model.NewBoolVar(f"{task.task_id}_in_room_{room.room_id}")
+                    self.model.Add(room_var == i).OnlyEnforceIf(is_in_room)
+                    self.model.Add(room_var != i).OnlyEnforceIf(is_in_room.Not())
+                    opt_interval = self.model.NewOptionalIntervalVar(
+                        interval.StartExpr(), interval.SizeExpr(), interval.EndExpr(), is_in_room, name=f"opt_{task.task_id}_{room.room_id}"
+                    )
+                    optional_intervals.append(opt_interval)
+            if optional_intervals:
+                self.model.AddNoOverlap(optional_intervals)
+
+    def _apply_stretch_constraints(self):
+        tasks_by_entity = defaultdict(list)
+        for task in self.tasks:
+            if task.faculty.id != "DUMMY_STAFF":
+                for fid in task.faculty.id.split('_'):  # Handle composite co-teaching faculties
+                    tasks_by_entity[f"fac_{fid}"].append(task)
+            tasks_by_entity[f"sec_{task.section.section_id}"].append(task)
+        for name, tasks in tasks_by_entity.items():
+            self._add_stretch_constraint_for_entity(tasks, name)
+
+    def _apply_grouping_constraints(self):
+        tasks_by_group = defaultdict(list)
+        for task in self.tasks:
+            if task.elective_group_id:
+                tasks_by_group[task.elective_group_id].append(task)
+        for group_tasks in tasks_by_group.values():
+            if len(group_tasks) > 1:
+                first_start = self.task_vars[group_tasks[0].task_id][0]
+                for i in range(1, len(group_tasks)):
+                    self.model.Add(self.task_vars[group_tasks[i].task_id][0] == first_start)
+
+    def _apply_daily_subject_limit(self):
+        tasks_by_sec_sub = defaultdict(list)
+        for task in self.tasks:
+            if task.subject.subject_type == SubjectType.THEORY:
+                tasks_by_sec_sub[(task.section.section_id, task.subject.subject_code)].append(task)
+        for tasks in tasks_by_sec_sub.values():
+            for day in range(const.NUM_WORKING_DAYS):
+                literals = []
+                for task in tasks:
+                    start_var = self.task_vars[task.task_id][0]
+                    is_on_day = self.model.NewBoolVar(f"{task.task_id}_on_day_{day}")
+                    day_idx = self.model.NewIntVar(0, const.NUM_WORKING_DAYS-1, f"day_{task.task_id}_{day}")
+                    self.model.AddDivisionEquality(day_idx, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+                    self.model.Add(day_idx == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(day_idx != day).OnlyEnforceIf(is_on_day.Not())
+                    literals.append(is_on_day)
+                if literals: self.model.Add(sum(literals) <= 1)
+
+    def _get_allowed_start_slots(self, task: Task) -> List[int]:
+        full_range = set(range(const.TOTAL_TEACHING_SLOTS_PER_WEEK))
+        if task.duration > 1:
+            allowed_lab_slots = set()
+            for day in range(const.NUM_WORKING_DAYS):
+                day_offset = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                for pos in const.ALLOWED_LAB_START_INDICES:
+                    allowed_lab_slots.add(day_offset + pos)
+            full_range.intersection_update(allowed_lab_slots)
+
+        # ── Configurable scheduling rules (data-driven) ─────────────────
+        DAY_MAP = {'MON':0,'TUE':1,'WED':2,'THU':3,'FRI':4,'SAT':5}
+        for rule in self.scheduling_rules:
+            rtype = rule.get('rule_type', '').upper()
+            
+            if rtype == 'FACULTY_UNAVAILABLE':
+                rule_fid = rule.get('faculty_id')
+                if rule_fid and rule_fid != task.faculty.id:
+                    continue
+                
+                days = [DAY_MAP[d.upper()] for d in (rule.get('days') or []) if d.upper() in DAY_MAP]
+                period_idx = rule.get('period_index')
+                
+                for day in days:
+                    off = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                    if period_idx is not None:
+                        for o in range(task.duration):
+                            full_range.discard(off + period_idx - o)
+                    else:
+                        for p in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                            for o in range(task.duration):
+                                full_range.discard(off + p - o)
+                continue
+
+            rule_subjects = [s.lower() for s in (rule.get('subject_codes') or [])]
+            rule_types = [t.upper() for t in (rule.get('subject_types') or [])]
+            # Check if this rule applies to the current task
+            matches_subject = task.subject.subject_code.lower() in rule_subjects if rule_subjects else False
+            matches_type = task.subject.subject_type.name in rule_types if rule_types else False
+            if not matches_subject and not matches_type:
+                continue
+
+            if rtype == 'FIXED_PERIOD':
+                # Force tasks to a specific period index
+                period_idx = rule.get('period_index', 0)
+                full_range = {s for s in full_range
+                              if (s % const.NUM_TEACHING_SLOTS_PER_DAY) == period_idx}
+
+            elif rtype == 'BEFORE_TIME':
+                # Tasks must start at or before a max period index
+                max_p = rule.get('max_period_index', 4)
+                full_range = {s for s in full_range
+                              if (s % const.NUM_TEACHING_SLOTS_PER_DAY) <= max_p}
+
+            elif rtype == 'FIXED_DAYS':
+                # Tasks must only be on specific days
+                allowed_days = {DAY_MAP[d.upper()] for d in (rule.get('days') or []) if d.upper() in DAY_MAP}
+                if allowed_days:
+                    full_range = {s for s in full_range
+                                  if (s // const.NUM_TEACHING_SLOTS_PER_DAY) in allowed_days}
+
+        if self.slm_constraints:
+            DAY_INDEX = {'MON':0,'TUE':1,'WED':2,'THU':3,'FRI':4,'SAT':5}
+            MORNING_PERIODS = list(range(0, const.NUM_TEACHING_SLOTS_PER_DAY // 2))
+            AFTERNOON_PERIODS = list(range(const.NUM_TEACHING_SLOTS_PER_DAY // 2, const.NUM_TEACHING_SLOTS_PER_DAY))
+            for c in self.slm_constraints:
+                ctype = c.get('type', '').upper()
+                if ctype == 'FACULTY_UNAVAILABLE' and c.get('faculty_id') == task.faculty.id:
+                    days = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+                    for day in days:
+                        off = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                        for p in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                            for o in range(task.duration):
+                                full_range.discard(off + p - o)
+                elif ctype == 'SUBJECT_PREFERRED_TIME':
+                    if c.get('subject_code') == task.subject.subject_code:
+                        period = str(c.get('period','')).upper()
+                        target = MORNING_PERIODS if 'MORNING' in period else AFTERNOON_PERIODS
+                        if target:
+                            full_range = {s for s in full_range if (s % const.NUM_TEACHING_SLOTS_PER_DAY) in target}
+                elif ctype == 'WORKING_DAYS':
+                    allowed_days = {DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX}
+                    if allowed_days:
+                        full_range = {s for s in full_range if (s // const.NUM_TEACHING_SLOTS_PER_DAY) in allowed_days}
+                elif ctype == 'SECTION_FREE_SLOT' and c.get('section_id') == task.section.section_id:
+                    slot_index = c.get('slot')
+                    days = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+                    if not days:
+                        days = list(range(const.NUM_WORKING_DAYS))
+                    if slot_index is not None:
+                        for day in days:
+                            off = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                            for o in range(task.duration):
+                                full_range.discard(off + slot_index - 1 - o)
+                                
+        return sorted(list(full_range))
+
+    def _get_allowed_rooms(self, task: Task) -> List[int]:
+        if task.subject.subject_code in ["LIB_HR", "STU_HR", "FAC_HR", "STDY_HR"]:
+            return [-1]
+            
+        allowed = []
+        for i, room in enumerate(self.rooms):
+            type_match = (task.subject.subject_type == SubjectType.LAB) == room.is_lab
+            cap_match = room.capacity >= task.section.student_strength
+            if type_match and cap_match: allowed.append(i)
+        if not allowed:
+            req_type = 'Computer Lab' if task.subject.subject_type == SubjectType.LAB else 'Standard Classroom'
+            raise ValueError(f"Shortage of suitable class rooms! Could not find any {req_type} with a minimum capacity of {task.section.student_strength} students for the subject '{task.subject.name}' (Section {task.section.section_id}). Please add a larger room to the template.")
+        return allowed
+
+    def _add_stretch_constraint_for_entity(self, tasks: List[Task], entity_name: str):
+        if not tasks: return
+        for day in range(const.NUM_WORKING_DAYS):
+            for i in range(const.NUM_TEACHING_SLOTS_PER_DAY - self.max_continuous_stretch):
+                window_start = day * const.NUM_TEACHING_SLOTS_PER_DAY + i
+                window_slots = range(window_start, window_start + self.max_continuous_stretch + 1)
+                literals = []
+                for slot in window_slots:
+                    is_active = self.model.NewBoolVar(f"{entity_name}_act_{slot}")
+                    at_slot = []
+                    for t in tasks:
+                        start, dur = self.task_vars[t.task_id][0], t.duration
+                        cov = self.model.NewBoolVar(f"{t.task_id}_cov_{slot}")
+                        self.model.Add(start <= slot).OnlyEnforceIf(cov)
+                        self.model.Add(start + dur > slot).OnlyEnforceIf(cov)
+                        at_slot.append(cov)
+                    self.model.AddBoolOr(at_slot).OnlyEnforceIf(is_active)
+                    for lit in at_slot: self.model.AddImplication(is_active.Not(), lit.Not())
+                    literals.append(is_active)
+                self.model.Add(sum(literals) <= self.max_continuous_stretch)
+
+    def _apply_fixed_section_classroom_constraints(self):
+        """
+        Enforce that all regular (non-lab, non-elective) theory classes of each parent section
+        are held in the same fixed 'Home Classroom'.
+        Rooms only change for Labs (computer/hardware labs) and Open Electives.
+        """
+        from collections import defaultdict
+        regular_tasks_by_parent = defaultdict(list)
+        
+        for task in self.tasks:
+            # Skip locked tasks
+            if task.section.semester in self.locked_semesters and task.task_id in self.locked_schedule:
+                continue
+                
+            # Only theory classes stay in the home classroom
+            if task.subject.subject_type == SubjectType.THEORY:
+                # Do not constrain split electives where students divide across multiple rooms
+                gid = task.elective_group_id or ""
+                if not gid or gid.startswith("CORE_"):
+                    sid = task.section.section_id
+                    # Skip sub-batches (e.g. 5A-B1)
+                    if "-B" not in sid:
+                        parent_sec = sid.split("-")[0]
+                        regular_tasks_by_parent[parent_sec].append(task)
+                        
+        for parent_sec, tasks in regular_tasks_by_parent.items():
+            if len(tasks) == 0:
+                continue
+            first_room_var = self.task_vars[tasks[0].task_id][3]
+            
+            # Check if this section has an explicit home_room_id specified
+            home_room_id = getattr(tasks[0].section, 'home_room_id', None)
+            if home_room_id and home_room_id in self.room_map:
+                target_room_index = self.room_map[home_room_id]
+                self.model.Add(first_room_var == target_room_index)
+                
+            for other_task in tasks[1:]:
+                other_room_var = self.task_vars[other_task.task_id][3]
+                self.model.Add(other_room_var == first_room_var)

data_loader.py

@@ -0,0 +1,232 @@
+# data_loader.py
+
+"""
+This module is responsible for converting raw input data into a list of
+atomic 'Task' objects that the solver can schedule.
+
+Responsibilities:
+- Ingest lists of faculties, subjects, sections, and their allocations.
+- Convert subject credits into the correct number of weekly Task instances.
+- Ensure THEORY subjects create 1-hour tasks per credit.
+- Ensure LAB, SOFTSKILL, and FORUM subjects create a single 2-hour task.
+- Assign a unique ID to each task.
+- Populate each task with its corresponding faculty, subject, and section.
+- Correctly handle elective groups for multi-hour subjects.
+
+This module performs NO scheduling logic, constraint creation, or optimization.
+It is purely a data transformation and preparation layer.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+# Import the core data models
+from models import Faculty, Subject, Section, Task, SubjectType
+from constants import TOTAL_TEACHING_SLOTS_PER_WEEK
+
+@dataclass(frozen=True)
+class Allocation:
+    """
+    A simple dataclass to represent the raw input mapping of who teaches what
+    to whom. This is a cleaner alternative to using tuples or dicts.
+    """
+    faculty_id: str
+    subject_code: str
+    section_id: str
+    elective_group_id: Optional[str] = None
+
+
+def prepare_scheduling_tasks(
+    allocations: List[Allocation],
+    faculties: List[Faculty],
+    subjects: List[Subject],
+    sections: List[Section]
+) -> List[Task]:
+    """
+    Processes raw allocation data and generates a flat list of atomic Task
+    objects ready for the solver.
+
+    Args:
+        allocations: A list of Allocation objects defining the teaching load.
+        faculties: A list of all available Faculty objects.
+        subjects: A list of all available Subject objects.
+        sections: A list of all available Section objects.
+
+    Returns:
+        A list of Task objects, where each task is an atomic unit to be scheduled.
+    """
+    # Create lookup dictionaries for efficient access
+    faculties_by_id = {f.id: f for f in faculties}
+    subjects_by_code = {s.subject_code: s for s in subjects}
+    sections_by_id = {s.section_id: s for s in sections}
+
+    all_tasks: List[Task] = []
+    section_duration_sums = {s.section_id: 0 for s in sections}
+
+    # Group allocations for co-teaching support
+    from collections import defaultdict
+    grouped_allocs = defaultdict(list)
+    for alloc in allocations:
+        key = (alloc.subject_code, alloc.section_id, alloc.elective_group_id)
+        grouped_allocs[key].append(alloc)
+
+    for key, alloc_group in grouped_allocs.items():
+        subject_code, section_id, alloc_elective_group_id = key
+        
+        try:
+            subject = subjects_by_code[subject_code]
+            section = sections_by_id[section_id]
+            facs = [faculties_by_id[a.faculty_id] for a in alloc_group]
+        except KeyError as e:
+            print(f"Error: Invalid ID in allocation group {key}. Missing key: {e}")
+            continue
+            
+        if len(facs) == 1:
+            faculty = facs[0]
+        else:
+            # Create composite faculty to avoid generating duplicate tasks
+            comp_id = "_".join(f.id for f in facs)
+            comp_name = " / ".join(f.name.replace("Prof. ", "").replace("Dr. ", "").replace("Mr. ", "").replace("Ms. ", "").strip() for f in facs)
+            faculty = Faculty(id=comp_id, name=comp_name, designation="Co-Teaching", max_hours_per_week=99)
+
+        # --- Task Generation Logic ---
+
+        if subject.subject_type == SubjectType.THEORY:
+            # For a theory subject, create one 1-hour task for each credit.
+            for i in range(subject.credits):
+                # *** CRITICAL FIX FOR ELECTIVES ***
+                # For a 3-credit elective, we need groups like 'group_0', 'group_1', 'group_2'
+                # to pair the correct hours across different sections.
+                
+                group_id = None
+                if alloc_elective_group_id:
+                    group_id = f"{alloc_elective_group_id}_{i}"
+                elif subject.is_core:
+                    # Treat Core Theory as a "Joint Class" for all batches in the section (e.g. 6a-E1 + 6a-E2)
+                    # We generate a synthetic group ID: CORE_CS101_6A_0
+                    parent_sec = section.section_id.split('-')[0]
+                    group_id = f"CORE_{subject.subject_code}_{parent_sec}_{i}"
+
+                task = Task(
+                    task_id=f"{subject.subject_code}-{section.section_id}-{i}",
+                    faculty=faculty,
+                    subject=subject,
+                    section=section,
+                    duration=1,
+                    elective_group_id=group_id
+                )
+                all_tasks.append(task)
+                section_duration_sums[section.section_id] += task.duration
+        
+        elif subject.subject_type in [SubjectType.LAB, SubjectType.SOFTSKILL, SubjectType.FORUM]:
+            # For labs and other block sessions, create exactly ONE 2-hour task.
+            # The elective group applies to the entire 2-hour block as a single unit.
+            task = Task(
+                task_id=f"{subject.subject_code}-{section.section_id}-BLOCK",
+                faculty=faculty,
+                subject=subject,
+                section=section,
+                duration=2,
+                elective_group_id=alloc_elective_group_id
+            )
+            all_tasks.append(task)
+            section_duration_sums[section.section_id] += task.duration
+    # --- Gap Filler Logic ---
+    try:
+        if "DUMMY_STAFF" in faculties_by_id and "LIB_HR" in subjects_by_code:
+            dummy_fac = faculties_by_id["DUMMY_STAFF"]
+            dummy_subjects_pool = [
+                subjects_by_code["LIB_HR"],
+                subjects_by_code["STU_HR"],
+                subjects_by_code["FAC_HR"],
+                subjects_by_code["STDY_HR"]
+            ]
+            
+            for section in sections:
+                if '-' in section.section_id or section.section_id == 'OE_AI':
+                    continue
+                batch_durations = [
+                    section_duration_sums.get(b.section_id, 0)
+                    for b in sections if b.section_id.startswith(f"{section.section_id}-")
+                ]
+                max_batch_duration = max(batch_durations) if batch_durations else 0
+                current_duration = section_duration_sums.get(section.section_id, 0) + max_batch_duration
+                
+                # Dynamically adjust filler buffer based on problem size (massive math = lower fillers)
+                num_allocations = len(allocations)
+                if num_allocations > 100:
+                    buffer = 8  # Massive math: keep 8 hours free to reduce dummy tasks
+                elif num_allocations > 50:
+                    buffer = 4  # Moderate math: keep 4 hours free
+                else:
+                    buffer = 2  # Normal math: keep 2 hours free
+                    
+                gaps = max(0, TOTAL_TEACHING_SLOTS_PER_WEEK - current_duration - buffer)
+                
+                if gaps > 0:
+                    for i in range(gaps):
+                        subj = dummy_subjects_pool[i % len(dummy_subjects_pool)]
+                        task = Task(
+                            task_id=f"FILLER-{subj.subject_code}-{section.section_id}-{i}",
+                            faculty=dummy_fac,
+                            subject=subj,
+                            section=section,
+                            duration=1,
+                            elective_group_id=None
+                        )
+                        all_tasks.append(task)
+                        # No need to update duration_sums since we are done
+    except KeyError as e:
+        print(f"Skipping gap filling, missing dummy setup: {e}")
+
+    return all_tasks
+
+
+# --- Example Usage ---
+if __name__ == '__main__':
+    # This block demonstrates how to use the prepare_scheduling_tasks function.
+    # It will only run when this file is executed directly.
+
+    # 1. Define sample data using the core models
+    faculty1 = Faculty(id="F001", name="Dr. Smith", designation="Professor", max_hours_per_week=10)
+    faculty2 = Faculty(id="F002", name="Dr. Jones", designation="Asst. Professor", max_hours_per_week=12)
+
+    subject_theory = Subject(subject_code="CS101", name="Intro to CS", credits=4, subject_type=SubjectType.THEORY)
+    subject_lab = Subject(subject_code="CS101L", name="CS Lab", credits=1, subject_type=SubjectType.LAB)
+    subject_elective = Subject(subject_code="CS555", name="Advanced AI", credits=3, subject_type=SubjectType.THEORY)
+
+
+    section_a = Section(section_id="5A", semester=5, student_strength=60)
+    section_b = Section(section_id="5B", semester=5, student_strength=62)
+
+    # 2. Define the teaching allocations
+    sample_allocations = [
+        Allocation(faculty_id="F001", subject_code="CS101", section_id="5A"),
+        Allocation(faculty_id="F002", subject_code="CS101L", section_id="5A"),
+        # Elective subject taught by the same faculty to both sections
+        Allocation(faculty_id="F001", subject_code="CS555", section_id="5A", elective_group_id="ELEC01"),
+        Allocation(faculty_id="F001", subject_code="CS555", section_id="5B", elective_group_id="ELEC01"),
+    ]
+
+    # 3. Call the data loader function
+    generated_tasks = prepare_scheduling_tasks(
+        allocations=sample_allocations,
+        faculties=[faculty1, faculty2],
+        subjects=[subject_theory, subject_lab, subject_elective],
+        sections=[section_a, section_b]
+    )
+
+    # 4. Print the results to verify
+    print(f"--- Generated {len(generated_tasks)} Tasks ---\n")
+    for task in generated_tasks:
+        print(f"Task ID: {task.task_id}")
+        print(f"  Subject: {task.subject.name} ({task.subject.subject_type.name})")
+        print(f"  Faculty: {task.faculty.name}")
+        print(f"  Section: {task.section.section_id}")
+        print(f"  Duration: {task.duration} hour(s)")
+        if task.elective_group_id:
+            print(f"  Elective Group: {task.elective_group_id}")
+        print("-" * 20)
+
+    # Expected Output:
+    # Elective tasks for CS555 will now have group IDs like "ELEC01_0", "ELEC01_1", "ELEC01_2"

debug_counts.py

@@ -0,0 +1,37 @@
+
+import json
+
+def check_counts():
+    try:
+        with open('master_dataset.json', 'r') as f:
+            content = f.read().strip()
+            if not content:
+                print("master_dataset.json is empty")
+                return
+
+            try:
+                # Try JSON Lines
+                lines = content.split('\n')
+                master_data = [json.loads(line) for line in lines if line.strip()]
+                print(f"master_dataset.json (JSON Lines): {len(master_data)} entries")
+            except json.JSONDecodeError:
+                # Try standard JSON
+                master_data = json.loads(content)
+                print(f"master_dataset.json (JSON List): {len(master_data)} entries")
+            
+            # Check internal duplicates in master
+            unique_master = len(set(json.dumps(d, sort_keys=True) for d in master_data))
+            print(f"Unique entries in master_dataset.json: {unique_master}")
+
+    except Exception as e:
+        print(f"Error checking master: {e}")
+
+    try:
+        with open('data.json', 'r') as f:
+            data = json.load(f)
+            print(f"data.json: {len(data)} entries")
+    except Exception as e:
+        print(f"Error checking data.json: {e}")
+
+if __name__ == "__main__":
+    check_counts()

debug_display.py

@@ -0,0 +1,95 @@
+
+import json
+from collections import defaultdict
+from models import Faculty, Subject, Section, Room, SubjectType
+from data_loader import Allocation, prepare_scheduling_tasks
+from solver import TimetableSolver
+import constants as const
+
+# --- Models Helpers ---
+def get_subject_type_enum(type_str):
+    mapping = {
+        "THEORY": SubjectType.THEORY,
+        "LAB": SubjectType.LAB,
+        "SOFTSKILL": SubjectType.SOFTSKILL,
+        "FORUM": SubjectType.FORUM
+    }
+    return mapping.get(type_str.upper(), SubjectType.THEORY)
+
+def convert_json_to_objects(data):
+    fac_objs = [Faculty(f['id'], f['name'], f['designation'], f['max_hours']) for f in data['faculties']]
+    
+    sub_objs = [Subject(
+        s['code'], s['name'], s['credits'], 
+        get_subject_type_enum(s['type']), 
+        s.get('is_core', True), s.get('is_heavy', False)
+    ) for s in data['subjects']]
+    
+    sec_objs = [Section(s['id'], s['semester'], s['strength']) for s in data['sections']]
+    
+    room_objs = [Room(r['id'], r['capacity'], r['is_lab'], r['building']) for r in data['rooms']]
+    
+    alloc_objs = [Allocation(
+        a['faculty_id'], a['subject_code'], a['section_id'], a.get('elective_group')
+    ) for a in data['allocations']]
+    
+    return fac_objs, sub_objs, sec_objs, room_objs, alloc_objs
+
+def main():
+    print("Loading data...")
+    with open("timetable_data.json", "r") as f:
+        data = json.load(f)
+
+    facs, subs, secs, rooms, allocs = convert_json_to_objects(data)
+    tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+    
+    print(f"Scheduling {len(tasks)} tasks...")
+    
+    solver = TimetableSolver(tasks, facs, secs, rooms)
+    status, solution = solver.solve(time_limit_seconds=60)
+    
+    if status not in ["OPTIMAL", "FEASIBLE"]:
+        print(f"Solver failed: {status}")
+        return
+
+    print("\n--- Display Logic Simulation ---")
+    
+    # 1. Identify Parent Sections
+    parent_sections = sorted(list(set(s.section_id.split('-')[0].upper() for s in secs)))
+    print(f"Parent Sections Found: {parent_sections}")
+    
+    # 2. Build Grid: merged_grid[parent_sec][day][period] = set of contents
+    merged_grid = defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
+
+    for task_id, info in solution.items():
+        task_obj = info.get('task_obj')
+        sec_id = info['section_id']
+        parent_sec = sec_id.split('-')[0].upper()
+        
+        day, period, dur = info['day_index'], info['period_index'], info['duration']
+        
+        cell_content = info['subject_code'].upper()
+
+        # Fill grid slots
+        for i in range(dur):
+            merged_grid[parent_sec][day][period + i].add(cell_content)
+
+    # 3. Print Grid as Dict
+    import pprint
+    for p_sec, days in merged_grid.items():
+        print(f"\nSECTION: {p_sec}")
+        for day, periods in days.items():
+            print(f"  Day {day}:")
+            # The instruction implies a change from 'in' to '==' for a check.
+            # The provided snippet introduces new lines with '==' but no 'in' to replace.
+            # Assuming 'header_text' would be defined in a more complete context,
+            # and applying the '==' as shown in the snippet.
+            # For this specific context, 'header_text' is undefined, so these lines are commented out
+            # or would require further context to be functional.
+            # is_break = (header_text == "10:35-10:50")
+            # is_lunch = (header_text == "12:40-1:40")
+            for period, contents in sorted(periods.items()):
+                print(f"    Period {period}: {contents}")
+
+if __name__ == "__main__":
+    main()

leave_requests.json

@@ -0,0 +1 @@
+[]

main.py

@@ -0,0 +1,254 @@
+# main.py
+
+"""
+This is the main entry point for the VTU Automated Timetable Generator.
+
+It performs the following steps:
+1. Defines sample academic data (Faculties, Subjects, Sections, Rooms).
+2. Uses the data_loader to convert this data into atomic 'Task' objects.
+3. Initializes the TimetableSolver.
+4. Runs the solver to generate a valid timetable.
+5. Prints the resulting schedule in a human-readable grid format.
+6. (Optional) Demonstrates the Emergency Re-optimizer functionality.
+
+This file is a standalone script and can be replaced by a UI or API layer.
+"""
+
+import sys
+from typing import List, Dict, Any
+
+# Import project modules
+from models import Faculty, Subject, Section, Room, SubjectType
+from data_loader import Allocation, prepare_scheduling_tasks
+from solver import TimetableSolver
+from reoptimizer import EmergencyReoptimizer
+import constants as const
+
+def create_sample_data():
+    """
+    Creates mock data for a Computer Science department (3rd & 5th Semester).
+    """
+    print("Creating sample data...")
+
+    # --- 1. Faculties ---
+    # Define a mix of senior and junior faculties
+    faculties = [
+        Faculty("F01", "Dr. Alice", "Professor", max_hours_per_week=12),
+        Faculty("F02", "Prof. Bob", "Assoc. Prof", max_hours_per_week=16),
+        Faculty("F03", "Prof. Charlie", "Asst. Prof", max_hours_per_week=18),
+        Faculty("F04", "Prof. Dave", "Asst. Prof", max_hours_per_week=18),
+        Faculty("F05", "Prof. Eve", "Asst. Prof", max_hours_per_week=18),
+        Faculty("F06", "Guest Fac", "Guest", max_hours_per_week=8),
+    ]
+
+    # --- 2. Subjects ---
+    # Core Subjects, Labs, and Electives
+    subjects = [
+        # 5th Sem
+        Subject("CS51", "Mgmt & Entrepren", 3, SubjectType.THEORY),
+        Subject("CS52", "Computer Networks", 4, SubjectType.THEORY, is_core=True, is_heavy=True),
+        Subject("CS53", "Database Mgmt", 4, SubjectType.THEORY, is_core=True, is_heavy=True),
+        Subject("CS54", "Automata Theory", 3, SubjectType.THEORY, is_core=True),
+        Subject("CS55", "Python Elective", 3, SubjectType.THEORY), # Elective
+        Subject("CS56", "Java Elective", 3, SubjectType.THEORY),   # Elective
+        Subject("CSL57", "Networks Lab", 1, SubjectType.LAB),      # 2-hour block
+        Subject("CSL58", "DBMS Lab", 1, SubjectType.LAB),          # 2-hour block
+        
+        # 3rd Sem
+        Subject("CS31", "Maths III", 3, SubjectType.THEORY, is_core=True),
+        Subject("CS32", "Data Structures", 4, SubjectType.THEORY, is_core=True, is_heavy=True),
+        Subject("CS33", "Analog Digital", 3, SubjectType.THEORY),
+        Subject("CS34", "COA", 3, SubjectType.THEORY),
+        Subject("CSL37", "DS Lab", 1, SubjectType.LAB),
+        Subject("CSL38", "AD Lab", 1, SubjectType.LAB),
+    ]
+
+    # --- 3. Sections ---
+    sections = [
+        Section("5A", 5, 60),
+        Section("5B", 5, 60),
+        Section("3A", 3, 65),
+    ]
+
+    # --- 4. Rooms ---
+    rooms = [
+        # Classrooms
+        Room("R101", 70, is_lab=False, building="Main Block"),
+        Room("R102", 70, is_lab=False, building="Main Block"),
+        Room("R103", 70, is_lab=False, building="Main Block"),
+        # Labs
+        Room("LAB1", 30, is_lab=True, building="Lab Block"), # Small lab
+        Room("LAB2", 70, is_lab=True, building="Lab Block"), # Big lab
+    ]
+
+    # --- 5. Allocations (Who teaches what to whom) ---
+    allocations = [
+        # --- 5th Sem Section A ---
+        Allocation("F01", "CS51", "5A"),
+        Allocation("F02", "CS52", "5A"),
+        Allocation("F03", "CS53", "5A"),
+        Allocation("F04", "CS54", "5A"),
+        # Elective: Group 1 (Split class)
+        Allocation("F05", "CS55", "5A", elective_group_id="ELEC_5_GRP1"), 
+        # Labs
+        Allocation("F02", "CSL57", "5A"),
+        Allocation("F03", "CSL58", "5A"),
+
+        # --- 5th Sem Section B ---
+        Allocation("F01", "CS51", "5B"),
+        Allocation("F02", "CS52", "5B"),
+        Allocation("F03", "CS53", "5B"),
+        Allocation("F04", "CS54", "5B"),
+        # Elective: Same Group ID to align slot (if cross-section) or different if purely parallel
+        # Here we assume 5A and 5B might have electives at same time
+        Allocation("F06", "CS56", "5B", elective_group_id="ELEC_5_GRP1"),
+        # Labs
+        Allocation("F02", "CSL57", "5B"),
+        Allocation("F03", "CSL58", "5B"),
+
+        # --- 3rd Sem Section A ---
+        Allocation("F04", "CS31", "3A"),
+        Allocation("F05", "CS32", "3A"),
+        Allocation("F06", "CS33", "3A"),
+        Allocation("F01", "CS34", "3A"),
+        Allocation("F05", "CSL37", "3A"),
+        Allocation("F06", "CSL38", "3A"),
+    ]
+
+    return faculties, subjects, sections, rooms, allocations
+
+
+def print_timetable_grid(solution: Dict[str, Any], sections: List[Section]):
+    """
+    Prints the generated timetable with explicit Break and Lunch columns.
+    """
+    if not solution:
+        print("No solution to display.")
+        return
+
+    # 1. Organize data into a nested dictionary
+    # Structure: grid[section_id][day_index][period_index] = "Subject (Faculty)"
+    grid = {sec.section_id: {d: {} for d in range(const.NUM_WORKING_DAYS)} for sec in sections}
+
+    for task_id, info in solution.items():
+        sec_id = info['section_id']
+        day = info['day_index']
+        start_period = info['period_index']
+        duration = info['duration']
+        
+        # Format the label
+        # e.g., "NLP (Anu) [R1]"
+        label = f"{info['subject_code']} ({info['faculty_name']}) [{info['room_id']}]"
+        
+        for i in range(duration):
+            current_period = start_period + i
+            if current_period < const.NUM_TEACHING_SLOTS_PER_DAY:
+                grid[sec_id][day][current_period] = label
+
+    # 2. Print the Grid
+    for sec in sections:
+        print(f"\n{'='*100}")
+        print(f"TIMETABLE FOR SECTION: {sec.section_id}")
+        print(f"{'='*100}")
+
+        # --- Build Header Row ---
+        header = f"{'DAY':<10} |"
+        separator = f"{'-'*10}-+"
+        
+        for i in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+            # Print Period Number
+            header += f" P{i+1:<13} |"
+            separator += f"{'-'*15}-+"
+            
+            # Inject Break Header
+            if i == const.BREAK_AFTER_INDEX:
+                header += " BREAK (15m) |"
+                separator += f"{'-'*13}-+"
+            # Inject Lunch Header
+            elif i == const.LUNCH_AFTER_INDEX:
+                header += " LUNCH (1h)  |"
+                separator += f"{'-'*13}-+"
+                
+        print(header)
+        print(separator)
+
+        # --- Build Data Rows ---
+        for d_idx, day_name in enumerate(const.DAYS):
+            row = f"{day_name:<10} |"
+            
+            for p_idx in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                # Get the class info, default to empty
+                cell_data = grid[sec.section_id][d_idx].get(p_idx, "")
+                
+                # Truncate to fit column
+                row += f" {cell_data[:13]:<13} |"
+                
+                # Inject Break Column
+                if p_idx == const.BREAK_AFTER_INDEX:
+                    row += f" {'***':<11} |"
+                # Inject Lunch Column
+                elif p_idx == const.LUNCH_AFTER_INDEX:
+                    row += f" {'---':<11} |"
+            
+            print(row)
+        print(separator)
+
+
+def main():
+    # 1. Load Data
+    faculties, subjects, sections, rooms, allocations = create_sample_data()
+
+    # 2. Prepare Tasks
+    print(f"Generating tasks from {len(allocations)} allocations...")
+    tasks = prepare_scheduling_tasks(allocations, faculties, subjects, sections)
+    print(f"Total atomic tasks to schedule: {len(tasks)}")
+
+    # 3. Initialize Solver
+    solver = TimetableSolver(tasks, faculties, sections, rooms)
+
+    # 4. Solve
+    print("\nRunning Solver...")
+    status, solution = solver.solve(
+        time_limit_seconds=10,
+        enable_soft_constraints=True,
+        soft_constraint_weights={
+            "subject_repetition": 10,
+            "morning_core": 5,
+            "late_heavy": 10,
+            "faculty_gaps": 2,
+            "campus_movement": 5,
+            "pack_morning": 500,
+            "student_gaps": 500
+        }
+    )
+
+    if status in ["OPTIMAL", "FEASIBLE"]:
+        # 5. Display Results
+        print_timetable_grid(solution, sections)
+        
+        # 6. Emergency Re-optimization Demo
+        print("\n" + "!"*80)
+        print("SIMULATING EMERGENCY: Faculty 'Prof. Bob' (F02) takes leave on Tuesday.")
+        print("!"*80)
+        
+        reoptimizer = EmergencyReoptimizer(tasks, faculties, sections, rooms)
+        
+        # Tuesday is index 1
+        reopt_status, new_solution = reoptimizer.reoptimize_for_faculty_leave(
+            current_schedule=solution,
+            faculty_id="F02",
+            leave_day_index=1, 
+            time_limit_seconds=10
+        )
+        
+        if reopt_status in ["OPTIMAL", "FEASIBLE"]:
+            print("\nRe-optimized Timetable (Changes minimized):")
+            print_timetable_grid(new_solution, sections)
+        else:
+            print("Failed to re-optimize.")
+            
+    else:
+        print(f"Solver failed to find a solution. Status: {status}")
+
+if __name__ == "__main__":
+    main()

merge_datasets.py

@@ -0,0 +1,75 @@
+
+import json
+
+def load_data(filename):
+    data = []
+    try:
+        with open(filename, 'r') as f:
+            content = f.read().strip()
+            if not content:
+                print(f"Warning: {filename} is empty.")
+                return []
+            
+            # Try parsing as standard JSON list
+            try:
+                data = json.loads(content)
+                if isinstance(data, list):
+                    print(f"Successfully loaded {filename} as JSON list.")
+                    return data
+                else:
+                    print(f"Warning: {filename} is valid JSON but not a list (got {type(data)}). Wrapping in list.")
+                    return [data]
+            except json.JSONDecodeError:
+                # Try parsing as JSON Lines (one JSON object per line)
+                try:
+                    lines = content.split('\n')
+                    data = [json.loads(line) for line in lines if line.strip()]
+                    print(f"Successfully loaded {filename} as JSON Lines ({len(data)} entries).")
+                    return data
+                except json.JSONDecodeError as e:
+                    print(f"Error: Failed to parse {filename} as JSON or JSON Lines. Error: {e}")
+                    return []
+    except FileNotFoundError:
+        print(f"Error: {filename} not found.")
+        return []
+
+def merge_datasets():
+    master_data = load_data('master_dataset.json')
+    new_data = load_data('data.json')
+
+    print(f"Entries from master_dataset.json: {len(master_data)}")
+    print(f"Entries from data.json: {len(new_data)}")
+
+    if not master_data and not new_data:
+        print("No data loaded. Exiting.")
+        return
+
+    # Combine lists
+    combined_data = master_data + new_data
+    
+    # Remove duplicates
+    unique_data = []
+    seen = set()
+    
+    for entry in combined_data:
+        # Sort keys to ensure consistent string representation
+        # Use simple string checks to avoid complex object issues
+        try:
+            entry_str = json.dumps(entry, sort_keys=True)
+            if entry_str not in seen:
+                seen.add(entry_str)
+                unique_data.append(entry)
+        except TypeError:
+            print(f"Warning: Skipping non-serializable entry: {entry}")
+    
+    print(f"Total entries after merge (removing duplicates): {len(unique_data)}")
+    
+    # Write to new file as JSON List (standard format for most tools)
+    output_filename = 'merged_dataset.json'
+    with open(output_filename, 'w') as f:
+        json.dump(unique_data, f, indent=2)
+    
+    print(f"Merged data saved to {output_filename}")
+
+if __name__ == "__main__":
+    merge_datasets()

models.py

@@ -0,0 +1,145 @@
+# models.py
+
+"""
+This file defines all core data models for the VTU Automated Timetable Generator.
+
+These models are solver-agnostic and serve as the standard data structures
+used throughout the application, from data loading to constraint modeling.
+
+No OR-Tools or other solver-specific imports are allowed in this file.
+"""
+
+from enum import Enum, auto
+from dataclasses import dataclass, field
+from typing import List, Optional, Set
+
+# --- Enumerations ---
+
+class SubjectType(Enum):
+    """
+    Enumeration for the type of a subject.
+    This helps in applying specific constraints, like duration.
+    """
+    THEORY = auto()
+    LAB = auto()
+    SOFTSKILL = auto()
+    FORUM = auto()
+
+# --- Core Data Models ---
+
+@dataclass(frozen=True)
+class Faculty:
+    """
+    Represents a faculty member.
+    'frozen=True' makes instances of this class immutable, which is a good
+    practice for data models to prevent accidental modification.
+    """
+    id: str
+    name: str
+    designation: str
+    max_hours_per_week: int
+    # Availability is a set of compressed slot indices (0-39) where the faculty
+    # IS available. If None, the faculty is assumed to be available always.
+    availability_slots: Optional[Set[int]] = None
+
+@dataclass(frozen=True)
+class Subject:
+    """
+    Represents a subject or a course.
+    """
+    subject_code: str
+    name: str
+    credits: int  # 1 credit = 1 hour/week. Determines the number of classes.
+    subject_type: SubjectType
+    is_core: bool = True  # Flag for core subjects
+    is_heavy: bool = False # Flag for computationally/conceptually heavy subjects
+
+@dataclass(frozen=True)
+class Section:
+    """
+    Represents a class section (e.g., '5th Sem A').
+    """
+    section_id: str
+    semester: int
+    student_strength: int
+    home_room_id: Optional[str] = None
+
+@dataclass(frozen=True)
+class Room:
+    """
+    Represents a physical room, either a classroom or a lab.
+    """
+    room_id: str
+    capacity: int
+    is_lab: bool = False
+    building: str = "Main" # Used for campus movement optimization
+
+@dataclass(frozen=True)
+class Task:
+    """
+    Represents an atomic, schedulable unit.
+    This is the fundamental element the CP-SAT solver will schedule.
+    It connects a faculty, a subject, and a section for a specific duration.
+    """
+    # A unique identifier for the task, e.g., f"{subject_code}-{section_id}-{instance_num}"
+    task_id: str
+    faculty: Faculty
+    subject: Subject
+    section: Section
+    # Duration in terms of number of continuous teaching slots.
+    # Labs, Soft Skills, and Forums are 2-hour blocks. Theory is 1 hour.
+    duration: int
+    # Optional ID to group tasks that must be scheduled at the same time.
+    # e.g., All tasks for a specific elective across different sections.
+    elective_group_id: Optional[str] = None
+
+# --- Leave & Substitution Models ---
+
+class LeaveStatus(str, Enum):
+    PENDING = "PENDING"
+    APPROVED = "APPROVED"
+    REJECTED = "REJECTED"
+
+class SubstitutionStatus(str, Enum):
+    PENDING = "PENDING"
+    ACCEPTED = "ACCEPTED"
+    DECLINED = "DECLINED"
+    TIMEOUT = "TIMEOUT"
+    WITHDRAWN = "WITHDRAWN"
+
+@dataclass
+class AffectedSlot:
+    subject_code: str
+    section_id: str
+    day: str
+    period: int
+    room_id: str
+
+@dataclass
+class LeaveRequest:
+    leave_id: str
+    faculty_id: str
+    days: List[str]  # e.g. ["Monday", "Tuesday"]
+    reason: str
+    status: LeaveStatus
+
+@dataclass
+class ProposedSwap:
+    subject_code: str
+    day: str
+    original_period: int
+    new_period: int
+
+@dataclass
+class SubstitutionRequest:
+    request_id: str
+    leave_id: str
+    affected_slot: AffectedSlot
+    original_faculty_id: str
+    candidate_faculty_id: str
+    priority_level: int
+    status: SubstitutionStatus
+    sent_at: str  # ISO format datetime
+    expires_at: str  # ISO format datetime
+    proposed_swap: Optional[ProposedSwap] = None
+    responded_at: Optional[str] = None

objective_engine.py

@@ -0,0 +1,407 @@
+# objective_engine.py
+
+from collections import defaultdict
+from typing import List, Dict, Any
+from ortools.sat.python import cp_model
+from models import Task, Faculty, Section, SubjectType
+from constraint_engine import ConstraintEngine
+import constants as const
+
+class ObjectiveEngine:
+    def __init__(
+        self,
+        model: cp_model.CpModel,
+        ce: ConstraintEngine,
+        tasks: List[Task],
+        faculties: List[Faculty],
+        sections: List[Section],
+        weights: Dict[str, int] = None
+    ):
+        self.model = model
+        self.ce = ce
+        self.tasks = tasks
+        self.faculties = faculties
+        self.sections = sections
+        
+        self.weights = weights or {
+            "subject_repetition": 100,
+            "morning_core": 50,
+            "late_heavy": 50,
+            "faculty_gaps": 5000,
+            "student_gaps": 10000,
+            "isolated_afternoon": 1000,
+            "campus_movement": 30,
+            "faculty_load_balance": 10,
+            "no_first_hour_free": 5000,
+            "pack_morning": 200,
+            "avoid_late_afternoon": 200
+        }
+        
+        self.penalties: List[cp_model.IntVar] = []
+        
+        # Precompute common variables for extreme efficiency
+        self.t_day = {}
+        self.t_dstart = {}
+        self.t_dend = {}
+        
+        for task in self.tasks:
+            start_var = self.ce.task_vars[task.task_id][0]
+            
+            day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"t_{task.task_id}_day")
+            self.model.AddDivisionEquality(day, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+            self.t_day[task.task_id] = day
+            
+            d_start = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"t_{task.task_id}_dstart")
+            self.model.AddModuloEquality(d_start, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
+            self.t_dstart[task.task_id] = d_start
+            
+            # Note: End slot could reach NUM_TEACHING_SLOTS_PER_DAY (which means it ends at the very end of the day)
+            d_end = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"t_{task.task_id}_dend")
+            self.model.Add(d_end == d_start + task.duration)
+            self.t_dend[task.task_id] = d_end
+
+    def build_objective(self):
+        """
+        Applies all configured soft constraints and sets the minimization objective.
+        """
+        print("Building Objective Function...")
+        
+        self._minimize_subject_repetition()
+        self._prioritize_morning_core_subjects()
+        self._avoid_late_heavy_subjects()
+        
+        self._minimize_faculty_gaps()
+        self._minimize_student_gaps()
+        self._penalize_isolated_afternoon_classes()
+        self._minimize_campus_movement()
+        self._penalize_first_hour_free()
+        
+        self._penalize_empty_morning_slots()
+        self._penalize_late_afternoon_slots()
+
+        # Summation of all penalties
+        if self.penalties:
+            total_cost = sum(self.penalties)
+            self.model.Minimize(total_cost)
+        else:
+            self.model.Minimize(0)
+
+    def _minimize_subject_repetition(self):
+        weight = self.weights.get("subject_repetition", 0)
+        if weight == 0: return
+
+        tasks_by_sec_sub = {}
+        for task in self.tasks:
+            if task.subject.subject_type == SubjectType.THEORY:
+                key = (task.section.section_id, task.subject.subject_code)
+                if key not in tasks_by_sec_sub:
+                    tasks_by_sec_sub[key] = []
+                tasks_by_sec_sub[key].append(task)
+
+        for (sec_id, sub_code), subject_tasks in tasks_by_sec_sub.items():
+            if len(subject_tasks) < 2: continue
+
+            for i in range(len(subject_tasks)):
+                for j in range(i + 1, len(subject_tasks)):
+                    t1 = subject_tasks[i]
+                    t2 = subject_tasks[j]
+                    
+                    day_1 = self.t_day[t1.task_id]
+                    day_2 = self.t_day[t2.task_id]
+
+                    same_day = self.model.NewBoolVar(f"same_day_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(day_1 == day_2).OnlyEnforceIf(same_day)
+                    self.model.Add(day_1 != day_2).OnlyEnforceIf(same_day.Not())
+
+                    self.penalties.append(same_day * weight)
+
+    def _prioritize_morning_core_subjects(self):
+        weight = self.weights.get("morning_core", 0)
+        if weight == 0: return
+
+        afternoon_start_index = 4 
+
+        for task in self.tasks:
+            if task.subject.is_core and task.subject.subject_type == SubjectType.THEORY:
+                daily_slot = self.t_dstart[task.task_id]
+
+                is_afternoon = self.model.NewBoolVar(f"is_afternoon_{task.task_id}")
+                self.model.Add(daily_slot >= afternoon_start_index).OnlyEnforceIf(is_afternoon)
+                self.model.Add(daily_slot < afternoon_start_index).OnlyEnforceIf(is_afternoon.Not())
+
+                self.penalties.append(is_afternoon * weight)
+
+    def _avoid_late_heavy_subjects(self):
+        weight = self.weights.get("late_heavy", 0)
+        if weight == 0: return
+
+        last_slot_index = const.NUM_TEACHING_SLOTS_PER_DAY - 1
+
+        for task in self.tasks:
+            if task.subject.is_heavy:
+                daily_slot = self.t_dstart[task.task_id]
+                
+                is_last_slot = self.model.NewBoolVar(f"is_last_slot_{task.task_id}")
+                self.model.Add(daily_slot == last_slot_index).OnlyEnforceIf(is_last_slot)
+                self.model.Add(daily_slot != last_slot_index).OnlyEnforceIf(is_last_slot.Not())
+
+                self.penalties.append(is_last_slot * weight)
+
+    def _minimize_faculty_gaps(self):
+        weight = self.weights.get("faculty_gaps", 30)
+        if weight == 0: return
+
+        tasks_by_faculty = {f.id: [] for f in self.faculties}
+        faculty_ids_set = {f.id for f in self.faculties}
+        for task in self.tasks:
+            parts = task.faculty.id.split('_')
+            fids = parts if len(parts) > 1 and all(p in faculty_ids_set for p in parts) else [task.faculty.id]
+            for fid in fids:
+                if fid in tasks_by_faculty:
+                    tasks_by_faculty[fid].append(task)
+
+        for faculty_id, f_tasks in tasks_by_faculty.items():
+            if not f_tasks: continue
+
+            for day in range(const.NUM_WORKING_DAYS):
+                min_start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_min_s_d{day}")
+                max_end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_max_e_d{day}")
+                
+                start_vars = [const.NUM_TEACHING_SLOTS_PER_DAY]
+                end_vars = [0]
+                total_duration = 0
+                
+                for task in f_tasks:
+                    is_on_day = self.model.NewBoolVar(f"fac_{faculty_id}_on_d{day}_t{task.task_id}")
+                    t_day = self.t_day[task.task_id]
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
+                    
+                    start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(start_on_day == self.t_dstart[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(start_on_day == const.NUM_TEACHING_SLOTS_PER_DAY).OnlyEnforceIf(is_on_day.Not())
+                    start_vars.append(start_on_day)
+                    
+                    end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(end_on_day == self.t_dend[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(end_on_day == 0).OnlyEnforceIf(is_on_day.Not())
+                    end_vars.append(end_on_day)
+                    
+                    total_duration += task.duration * is_on_day
+                    
+                self.model.AddMinEquality(min_start_on_day, start_vars)
+                self.model.AddMaxEquality(max_end_on_day, end_vars)
+                
+                gap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"fac_{faculty_id}_gap_d{day}")
+                self.model.AddMaxEquality(gap, [0, max_end_on_day - min_start_on_day - total_duration])
+                self.penalties.append(gap * weight)
+
+    def _minimize_student_gaps(self):
+        weight = self.weights.get("student_gaps", 100)
+        if weight == 0: return
+
+        tasks_by_section = defaultdict(list)
+        for task in self.tasks:
+            tasks_by_section[task.section.section_id].append(task)
+
+        for sec_id, s_tasks in tasks_by_section.items():
+            if not s_tasks: continue
+
+            for day in range(const.NUM_WORKING_DAYS):
+                min_start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_min_s_d{day}")
+                max_end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_max_e_d{day}")
+                
+                start_vars = [const.NUM_TEACHING_SLOTS_PER_DAY]
+                end_vars = [0]
+                total_duration = 0
+                
+                for task in s_tasks:
+                    is_on_day = self.model.NewBoolVar(f"sec_{sec_id}_on_d{day}_t{task.task_id}")
+                    t_day = self.t_day[task.task_id]
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
+                    
+                    start_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(start_on_day == self.t_dstart[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(start_on_day == const.NUM_TEACHING_SLOTS_PER_DAY).OnlyEnforceIf(is_on_day.Not())
+                    start_vars.append(start_on_day)
+                    
+                    end_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+                    self.model.Add(end_on_day == self.t_dend[task.task_id]).OnlyEnforceIf(is_on_day)
+                    self.model.Add(end_on_day == 0).OnlyEnforceIf(is_on_day.Not())
+                    end_vars.append(end_on_day)
+                    
+                    total_duration += task.duration * is_on_day
+                    
+                self.model.AddMinEquality(min_start_on_day, start_vars)
+                self.model.AddMaxEquality(max_end_on_day, end_vars)
+                
+                late_start_weight = self.weights.get("no_first_hour_free", 5000)
+                
+                if weight > 0:
+                    gap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_gap_d{day}")
+                    self.model.AddMaxEquality(gap, [0, max_end_on_day - min_start_on_day - total_duration])
+                    self.penalties.append(gap * weight)
+                    
+                if late_start_weight > 0:
+                    is_free_day = self.model.NewBoolVar(f"sec_{sec_id}_free_d{day}")
+                    self.model.Add(total_duration == 0).OnlyEnforceIf(is_free_day)
+                    self.model.Add(total_duration > 0).OnlyEnforceIf(is_free_day.Not())
+                    
+                    late_start_penalty = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"sec_{sec_id}_late_d{day}")
+                    self.model.Add(late_start_penalty == 0).OnlyEnforceIf(is_free_day)
+                    self.model.Add(late_start_penalty == min_start_on_day).OnlyEnforceIf(is_free_day.Not())
+                    
+                    self.penalties.append(late_start_penalty * late_start_weight)
+
+    def _penalize_isolated_afternoon_classes(self):
+        weight = self.weights.get("isolated_afternoon", 10)
+        if weight == 0: return
+
+        afternoon_start_index = 4 
+        
+        tasks_by_section = defaultdict(list)
+        for task in self.tasks:
+            tasks_by_section[task.section.section_id].append(task)
+            
+        for sec_id, s_tasks in tasks_by_section.items():
+            for day in range(const.NUM_WORKING_DAYS):
+                afternoon_duration_sum = []
+                
+                for task in s_tasks:
+                    daily_slot = self.t_dstart[task.task_id]
+                    t_day = self.t_day[task.task_id]
+                    
+                    is_on_day = self.model.NewBoolVar(f"is_on_day_{task.task_id}_{day}_aft")
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
+
+                    is_afternoon = self.model.NewBoolVar(f"is_afternoon_{task.task_id}_{day}_aft")
+                    self.model.Add(daily_slot >= afternoon_start_index).OnlyEnforceIf(is_afternoon)
+                    self.model.Add(daily_slot < afternoon_start_index).OnlyEnforceIf(is_afternoon.Not())
+
+                    is_on_day_and_afternoon = self.model.NewBoolVar(f"is_on_day_and_afternoon_{task.task_id}_{day}")
+                    self.model.AddBoolAnd([is_on_day, is_afternoon]).OnlyEnforceIf(is_on_day_and_afternoon)
+                    
+                    dur_term = self.model.NewIntVar(0, task.duration, f"aft_dur_{task.task_id}_{day}")
+                    self.model.Add(dur_term == task.duration).OnlyEnforceIf(is_on_day_and_afternoon)
+                    self.model.Add(dur_term == 0).OnlyEnforceIf(is_on_day_and_afternoon.Not())
+                    
+                    afternoon_duration_sum.append(dur_term)
+
+                total_aft_duration = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"total_aft_dur_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration == sum(afternoon_duration_sum))
+
+                is_isolated = self.model.NewBoolVar(f"is_isolated_aft_sec{sec_id}_d{day}")
+                
+                is_gt_0 = self.model.NewBoolVar(f"aft_gt_0_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration > 0).OnlyEnforceIf(is_gt_0)
+                self.model.Add(total_aft_duration == 0).OnlyEnforceIf(is_gt_0.Not())
+                
+                is_le_2 = self.model.NewBoolVar(f"aft_le_2_sec{sec_id}_d{day}")
+                self.model.Add(total_aft_duration <= 2).OnlyEnforceIf(is_le_2)
+                self.model.Add(total_aft_duration > 2).OnlyEnforceIf(is_le_2.Not())
+
+                self.model.AddBoolAnd([is_gt_0, is_le_2]).OnlyEnforceIf(is_isolated)
+                
+                self.penalties.append(is_isolated * weight)
+
+    def _minimize_campus_movement(self):
+        weight = self.weights.get("campus_movement", 3)
+        if weight == 0: return
+
+        tasks_by_section = defaultdict(list)
+        for task in self.tasks:
+            tasks_by_section[task.section.section_id].append(task)
+            
+        for sec_id, s_tasks in tasks_by_section.items():
+            if len(s_tasks) < 2: continue
+            
+            for i in range(len(s_tasks)):
+                for j in range(i + 1, len(s_tasks)):
+                    t1 = s_tasks[i]
+                    t2 = s_tasks[j]
+                    
+                    start1 = self.ce.task_vars[t1.task_id][0]
+                    end1 = self.ce.task_vars[t1.task_id][1]
+                    room1 = self.ce.task_vars[t1.task_id][3]
+                    
+                    start2 = self.ce.task_vars[t2.task_id][0]
+                    end2 = self.ce.task_vars[t2.task_id][1]
+                    room2 = self.ce.task_vars[t2.task_id][3]
+                    
+                    is_consecutive_1_2 = self.model.NewBoolVar(f"cons_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(end1 == start2).OnlyEnforceIf(is_consecutive_1_2)
+                    self.model.Add(end1 != start2).OnlyEnforceIf(is_consecutive_1_2.Not())
+                    
+                    is_consecutive_2_1 = self.model.NewBoolVar(f"cons_{t2.task_id}_{t1.task_id}")
+                    self.model.Add(end2 == start1).OnlyEnforceIf(is_consecutive_2_1)
+                    self.model.Add(end2 != start1).OnlyEnforceIf(is_consecutive_2_1.Not())
+                    
+                    are_consecutive = self.model.NewBoolVar(f"are_cons_{t1.task_id}_{t2.task_id}")
+                    self.model.AddBoolOr([is_consecutive_1_2, is_consecutive_2_1]).OnlyEnforceIf(are_consecutive)
+                    self.model.AddBoolAnd([is_consecutive_1_2.Not(), is_consecutive_2_1.Not()]).OnlyEnforceIf(are_consecutive.Not())
+                    
+                    same_room = self.model.NewBoolVar(f"same_room_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(room1 == room2).OnlyEnforceIf(same_room)
+                    self.model.Add(room1 != room2).OnlyEnforceIf(same_room.Not())
+                    
+                    move_penalty = self.model.NewBoolVar(f"move_{t1.task_id}_{t2.task_id}")
+                    self.model.AddBoolAnd([are_consecutive, same_room.Not()]).OnlyEnforceIf(move_penalty)
+                    
+                    self.penalties.append(move_penalty * weight)
+
+    def _penalize_first_hour_free(self):
+        pass
+
+    def _penalize_empty_morning_slots(self):
+        weight = self.weights.get("pack_morning", 50)
+        if weight == 0: return
+
+        tasks_by_section = defaultdict(list)
+        for task in self.tasks:
+            tasks_by_section[task.section.section_id].append(task)
+
+        for sec_id, s_tasks in tasks_by_section.items():
+            if not s_tasks: continue
+
+            morning_overlaps = []
+            for task in s_tasks:
+                d_start = self.t_dstart[task.task_id]
+                d_end = self.t_dend[task.task_id]
+                
+                capped_start = self.model.NewIntVar(0, 4, "")
+                self.model.AddMinEquality(capped_start, [d_start, 4])
+                
+                capped_end = self.model.NewIntVar(0, 4, "")
+                self.model.AddMinEquality(capped_end, [d_end, 4])
+                
+                overlap = self.model.NewIntVar(0, 4, "")
+                self.model.Add(overlap == capped_end - capped_start)
+                morning_overlaps.append(overlap)
+                
+            # Total morning slots are 20 (5 days * 4 slots)
+            total_slots = const.NUM_WORKING_DAYS * 4
+            empty_slots = self.model.NewIntVar(0, total_slots, f"sec_{sec_id}_empty_morning")
+            self.model.Add(empty_slots == total_slots - sum(morning_overlaps))
+            
+            self.penalties.append(empty_slots * weight)
+
+    def _penalize_late_afternoon_slots(self):
+        weight = self.weights.get("avoid_late_afternoon", 40)
+        if weight == 0: return
+
+        for task in self.tasks:
+            d_start = self.t_dstart[task.task_id]
+            d_end = self.t_dend[task.task_id]
+            
+            capped_start = self.model.NewIntVar(6, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+            self.model.AddMaxEquality(capped_start, [d_start, 6])
+            
+            capped_end = self.model.NewIntVar(6, const.NUM_TEACHING_SLOTS_PER_DAY, "")
+            self.model.AddMaxEquality(capped_end, [d_end, 6])
+            
+            overlap = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 6, "")
+            self.model.Add(overlap == capped_end - capped_start)
+            
+            self.penalties.append(overlap * weight)

original_schedule.json

@@ -0,0 +1,2597 @@
+{
+  "generated_at": "2026-07-08T03:56:08.146939",
+  "schedule": {
+    "DL&RL-7A-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7A-1": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7A-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7B-0": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL-7B-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL-7B-2": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL Lab-7A-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B1",
+      "duration": 2
+    },
+    "DL&RL Lab-7A-B2-BLOCK": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B2",
+      "duration": 2
+    },
+    "DL&RL Lab-7B-B1-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Praveen Arokia Raj",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B1",
+      "duration": 2
+    },
+    "DL&RL Lab-7B-B2-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Praveen Arokia Raj",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B2",
+      "duration": 2
+    },
+    "ML II-7A-0": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7A-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7A-2": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7B-0": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II-7B-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II-7B-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II Lab-7A-B1-BLOCK": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B1",
+      "duration": 2
+    },
+    "ML II Lab-7A-B2-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B2",
+      "duration": 2
+    },
+    "ML II Lab-7B-B1-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B1",
+      "duration": 2
+    },
+    "ML II Lab-7B-B2-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B2",
+      "duration": 2
+    },
+    "DS&P-7A-0": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-1": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-2": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-3": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7B-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-1": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-3": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7A-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7A-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7B-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7DS-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BA-7DS-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BA-7DS-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BDA-7A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7A-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7A-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7B-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BDA-7B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BDA-7B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL-7DS-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "DL-7DS-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "DL-7DS-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-0": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-2": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-1": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-2": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP Lab-7DS-B1-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B1",
+      "duration": 2
+    },
+    "PP Lab-7DS-B2-BLOCK": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B2",
+      "duration": 2
+    },
+    "SML for DS-7DS-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS-7DS-1": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS-7DS-2": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS Lab-7DS-B1-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B1",
+      "duration": 2
+    },
+    "SML for DS Lab-7DS-B2-BLOCK": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B2",
+      "duration": 2
+    },
+    "CNS-7DS-0": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-3": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SEPM-5A-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-1": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-3": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5B-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-3": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5A-0": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5A-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5A-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5B-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5B-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5B-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN Lab-5A-B1-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B1",
+      "duration": 2
+    },
+    "CN Lab-5A-B2-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B2",
+      "duration": 2
+    },
+    "CN Lab-5B-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B1",
+      "duration": 2
+    },
+    "CN Lab-5B-B2-BLOCK": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B2",
+      "duration": 2
+    },
+    "TOC-5A-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-2": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-3": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-4": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5B-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-1": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-3": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "DV Lab-5B-B1-BLOCK": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Jovin Deglus / Ranjan Kumar",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B1",
+      "duration": 2
+    },
+    "DV Lab-5B-B2-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Jovin Deglus / Ranjan Kumar",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B2",
+      "duration": 2
+    },
+    "CV-5A-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5A-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5A-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5B-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CV-5B-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CV-5B-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "RM&IPR-5A-0": {
+      "start_slot": 37,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 5,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "RM&IPR-5B-0": {
+      "start_slot": 28,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EVS-5A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EVS-5A-1": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EVS-5B-0": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EVS-5B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5DS-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-2": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-3": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN Lab-5DS-B1-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B1",
+      "duration": 2
+    },
+    "CN Lab-5DS-B2-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B2",
+      "duration": 2
+    },
+    "TOC-5DS-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-2": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-4": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DV Lab-5DS-B1-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Syed Musadiq Illahi / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B1",
+      "duration": 2
+    },
+    "DV Lab-5DS-B2-BLOCK": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Praveen Arokia Raj / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B2",
+      "duration": 2
+    },
+    "NoSQL DB-5DS-0": {
+      "start_slot": 13,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 5,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "NoSQL DB-5DS-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "NoSQL DB-5DS-2": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-0": {
+      "start_slot": 13,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-2": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "RM&IPR-5DS-0": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "EVS-5DS-0": {
+      "start_slot": 7,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 7,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "EVS-5DS-1": {
+      "start_slot": 30,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-1": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-3": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-0": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-2": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-3": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-4": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3A-0": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-2": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-3": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-4": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3B-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-1": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-2": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3A-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3A-1": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3A-2": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3B-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3B-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3A-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3A-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3A-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3B-0": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3B-1": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3B-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA Lab-3A-B1-BLOCK": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Surbhi / Nanda Kumar N",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B1",
+      "duration": 2
+    },
+    "DSA Lab-3A-B2-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Nanda Kumar N / Surbhi",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B2",
+      "duration": 2
+    },
+    "DSA Lab-3B-B1-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Surbhi / Mhd Tahir Mirji",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B1",
+      "duration": 2
+    },
+    "OOP with Java-3A-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OOP with Java-3B-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "EDA Lab-3A-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "EDA Lab-3B-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "PM with Git-3A-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "PM with Git-3B-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "Maths LE-3A-0": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths LE-3B-0": {
+      "start_slot": 21,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 5,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-1": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-2": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-4": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-3": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-4": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-0": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA Lab-3DS-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Nanda Kumar N / Sanjay P",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B1",
+      "duration": 2
+    },
+    "OOP with Java-3DS-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "EDA Lab-3DS-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "Maths LE-3DS-0": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DV Lab-5A-B1-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "S Anu Pallavi / Jovin Deglus",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B1",
+      "duration": 2
+    },
+    "DV Lab-5A-B2-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Abhijith S / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B2",
+      "duration": 2
+    },
+    "DSA Lab-3B-B2-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Mhd Tahir Mirji / Surbhi",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B2",
+      "duration": 2
+    },
+    "DSA Lab-3DS-B2-BLOCK": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Mhd Tahir Mirji / Nanda Kumar N",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B2",
+      "duration": 2
+    },
+    "PM with Git-3DS-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "EDA Lab 2-3A-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "EDA Lab 2-3B-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "EDA Lab 2-3DS-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "PM with Git 2-3A-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "PM with Git 2-3B-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "PM with Git 2-3DS-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3DS",
+      "duration": 2
+    }
+  }
+}

partial_optimizer.py

@@ -0,0 +1,1126 @@
+# partial_optimizer.py
+# Comprehensive timetable operations engine.
+# Handles ALL types of changes — not just rescheduling.
+
+from typing import List, Dict, Any, Tuple, Optional
+from collections import defaultdict
+from ortools.sat.python import cp_model
+from copy import deepcopy
+
+from models import Task, Faculty, Section, Room, SubjectType
+import constants as const
+
+DAY_INDEX = {'MON':0,'TUE':1,'WED':2,'THU':3,'FRI':4,'SAT':5}
+DAY_NAME  = {v: k for k, v in DAY_INDEX.items()}
+
+def _slot(day, period): return day * const.NUM_TEACHING_SLOTS_PER_DAY + period
+def _day(slot):         return slot // const.NUM_TEACHING_SLOTS_PER_DAY
+def _period(slot):      return slot  % const.NUM_TEACHING_SLOTS_PER_DAY
+
+MORNING_PERIODS   = list(range(0, const.NUM_TEACHING_SLOTS_PER_DAY // 2))
+AFTERNOON_PERIODS = list(range(const.NUM_TEACHING_SLOTS_PER_DAY // 2,
+                                const.NUM_TEACHING_SLOTS_PER_DAY))
+
+
+class PartialOptimizer:
+    """
+    Handles every possible timetable operation via natural language → JSON constraint.
+
+    Supported operations:
+    ┌─────────────────────────────────────────────────────────────────┐
+    │ SCHEDULING                                                      │
+    │  FACULTY_UNAVAILABLE      — block faculty on day/slot          │
+    │  FACULTY_FREE_DAY         — give faculty a free day            │
+    │  FACULTY_MAX_DAILY_HOURS  — limit daily hours                  │
+    │  SECTION_FREE_SLOT        — block a slot for a section         │
+    │  WORKING_DAYS             — restrict to certain days           │
+    │  SUBJECT_PREFERRED_TIME   — move subject to morning/afternoon  │
+    │  HEAVY_SUBJECT_MORNING    — heavy subjects in morning          │
+    │  LAB_MUST_CONSECUTIVE     — labs in consecutive slots          │
+    │                                                                 │
+    │ DIRECT CHANGES (no re-solve needed)                            │
+    │  FACULTY_SUBSTITUTION     — replace faculty for a day/subject  │
+    │  MOVE_CLASS               — move specific class to new slot    │
+    │  SWAP_CLASSES             — swap two classes with each other   │
+    │  CANCEL_CLASS             — remove a class from timetable      │
+    │  CHANGE_ROOM              — assign different room to a class   │
+    │  ADD_EXTRA_CLASS          — add a makeup/extra class           │
+    │  MARK_HOLIDAY             — clear all classes on a day         │
+    │  RESCHEDULE_LAB           — move lab to a new day              │
+    │  CHANGE_FACULTY           — permanently change who teaches     │
+    │  FREEZE_SLOT              — lock a slot so it never changes    │
+    └─────────────────────────────────────────────────────────────────┘
+    """
+
+    def __init__(self, tasks, faculties, sections, rooms, current_solution):
+        self.tasks            = tasks
+        self.faculties        = faculties
+        self.sections         = sections
+        self.rooms            = rooms
+        self.current_solution = current_solution
+
+        self.tasks_by_id      = {t.task_id: t for t in tasks}
+        self.fac_by_id        = {f.id: f for f in faculties}
+        self.room_by_id       = {r.room_id: r for r in rooms}
+        self.tasks_by_faculty = defaultdict(list)
+        self.tasks_by_section = defaultdict(list)
+        self.tasks_by_subject = defaultdict(list)
+        for t in tasks:
+            self.tasks_by_faculty[t.faculty.id].append(t)
+            self.tasks_by_section[t.section.section_id].append(t)
+            self.tasks_by_subject[t.subject.subject_code].append(t)
+
+    # ═════════════════════════════════════════════════════════════════
+    # PUBLIC ENTRY POINT
+    # ═════════════════════════════════════════════════════════════════
+
+    def apply_constraint_and_reoptimize(
+        self,
+        slm_constraint: Dict[str, Any],
+        time_limit: int = 30
+    ) -> Tuple[str, Dict[str, Any], List[str], str]:
+        """
+        Route to the correct handler based on constraint type.
+        Returns: (status, new_solution, affected_task_ids, summary)
+        """
+        ctype = slm_constraint.get('type', '').upper()
+
+        # Direct mutation handlers (no CP-SAT needed)
+        direct_handlers = {
+            'FACULTY_SUBSTITUTION':  self._op_faculty_substitution,
+            'MOVE_CLASS':            self._op_move_class,
+            'SWAP_CLASSES':          self._op_swap_classes,
+            'CANCEL_CLASS':          self._op_cancel_class,
+            'CHANGE_ROOM':           self._op_change_room,
+            'ADD_EXTRA_CLASS':       self._op_add_extra_class,
+            'MARK_HOLIDAY':          self._op_mark_holiday,
+            'RESCHEDULE_LAB':        self._op_reschedule_lab,
+            'CHANGE_FACULTY':        self._op_change_faculty,
+            'FREEZE_SLOT':           self._op_freeze_slot,
+        }
+
+        # Re-optimization handlers (CP-SAT partial solve)
+        reopt_handlers = {
+            'FACULTY_UNAVAILABLE':        True,
+            'FACULTY_FREE_DAY':           True,
+            'FACULTY_MAX_DAILY_HOURS':    True,
+            'FACULTY_NO_CONSECUTIVE':     True,
+            'SECTION_FREE_SLOT':          True,
+            'WORKING_DAYS':               True,
+            'SUBJECT_PREFERRED_TIME':     True,
+            'HEAVY_SUBJECT_MORNING':      True,
+            'LAB_MUST_CONSECUTIVE':       True,
+            'NO_BACK_TO_BACK_SUBJECTS':   True,
+            'DISTRIBUTE_SUBJECTS_EVENLY': True,
+            'SUBJECT_SPACING':            True,
+            'NO_FREE_PERIOD':             True,
+        }
+
+        # ── Type aliases — map SLM variants to canonical types ──────────
+        aliases = {
+            'SUBJECT_FREE_DAY':         'CANCEL_CLASS',
+            'FACULTY_LEAVE':            'FACULTY_SUBSTITUTION',
+            'BLOCK_SLOT':               'SECTION_FREE_SLOT',
+            'REMOVE_CLASS':             'CANCEL_CLASS',
+            'DELETE_CLASS':             'CANCEL_CLASS',
+            'CLASS_CANCELLED':          'CANCEL_CLASS',
+            'SHIFT_CLASS':              'MOVE_CLASS',
+            'RELOCATE_CLASS':           'MOVE_CLASS',
+            'TEACHER_SUBSTITUTION':     'FACULTY_SUBSTITUTION',
+            'REPLACE_FACULTY':          'FACULTY_SUBSTITUTION',
+            'SWAP_FACULTY':             'FACULTY_SUBSTITUTION',
+            'SUBJECT_UNAVAILABLE':      'CANCEL_CLASS',
+            'NO_CLASS':                 'CANCEL_CLASS',
+            'HOLIDAY':                  'MARK_HOLIDAY',
+            'MOVE_LAB':                 'RESCHEDULE_LAB',
+            'SHIFT_LAB':                'RESCHEDULE_LAB',
+            'LOCK_SLOT':                'FREEZE_SLOT',
+            'PIN_SLOT':                 'FREEZE_SLOT',
+        }
+        if ctype in aliases:
+            slm_constraint = dict(slm_constraint)
+            slm_constraint['type'] = aliases[ctype]
+            ctype = aliases[ctype]
+
+        if ctype in direct_handlers:
+            return direct_handlers[ctype](slm_constraint)
+        elif ctype in reopt_handlers:
+            return self._reoptimize(slm_constraint, time_limit)
+        else:
+            return ('NO_CHANGE', self.current_solution, [],
+                    f'⚠️ Unknown constraint type: {ctype}')
+
+    # ═════════════════════════════════════════════════════════════════
+    # DIRECT MUTATION OPERATIONS
+    # ═════════════════════════════════════════════════════════════════
+
+    def _op_faculty_substitution(self, c):
+        """
+        Replace from_faculty with to_faculty.
+        Optionally filter by days and/or subjects.
+        Prompt examples:
+          "Replace Prof. Anu's classes on Friday with Prof. Syed"
+          "Prof. Kavitha is on leave Monday, Praveen will cover"
+          "Syed will take all of Anu's NLP classes"
+        """
+        from_id  = c.get('from_faculty_id') or c.get('from_faculty')
+        to_id    = c.get('to_faculty_id')   or c.get('to_faculty')
+        days     = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+        scodes   = set(c.get('subject_codes') or [])
+        sections = set(c.get('section_ids')   or [])
+
+        if not from_id or not to_id:
+            return self._fail('FACULTY_SUBSTITUTION needs from_faculty_id and to_faculty_id')
+
+        to_fac = self.fac_by_id.get(to_id)
+        if not to_fac:
+            return self._fail(f'Faculty not found: {to_id}')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task or task.faculty.id != from_id: continue
+            if days     and info['day_index']              not in days:    continue
+            if scodes   and task.subject.subject_code      not in scodes:  continue
+            if sections and not any(self._sec_matches(task.section.section_id, s) for s in sections): continue
+
+            updated = dict(info)
+            updated['faculty_name'] = to_fac.name
+            new_sol[task_id] = updated
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"{const.DAYS[info['day_index']]} P{info['period_index']+1}: "
+                f"{task.faculty.name} → {to_fac.name}"
+            )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [],
+                    f'No matching classes found for substitution.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ {len(changes)} class(es) reassigned:\n" + "\n".join(changes))
+
+    def _op_move_class(self, c):
+        """
+        Move a specific class to a new day/period.
+        Prompt examples:
+          "Move Monday's NLP class of 6A to Wednesday period 3"
+          "Shift Anu's Tuesday class to Thursday"
+          "Move section 5A's TOC from Monday to Friday"
+        """
+        from_day    = DAY_INDEX.get((c.get('from_day') or '').upper())
+        to_day      = DAY_INDEX.get((c.get('to_day')   or '').upper())
+        from_period = c.get('from_period')   # 1-based
+        to_period   = c.get('to_period')     # 1-based
+        scode       = c.get('subject_code')
+        sid         = c.get('section_id')
+        fid         = c.get('faculty_id')
+
+        if from_day is None or to_day is None:
+            return self._fail('MOVE_CLASS needs from_day and to_day')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if info['day_index'] != from_day: continue
+            if scode    and task.subject.subject_code != scode:   continue
+            if sid      and not self._sec_matches(task.section.section_id, sid): continue
+            if fid      and task.faculty.id            != fid:    continue
+            if from_period and info['period_index'] != from_period - 1: continue
+
+            # Build candidate periods to try: specified first, then all others
+            preferred = (to_period - 1) if to_period else info['period_index']
+            candidates = [preferred] + [
+                p for p in range(const.NUM_TEACHING_SLOTS_PER_DAY)
+                if p != preferred
+            ]
+
+            placed = False
+            fac_id = task.faculty.id if task else None
+            sec_id = task.section.section_id if task else None
+            for try_period in candidates:
+                if try_period + task.duration > const.NUM_TEACHING_SLOTS_PER_DAY:
+                    continue
+                # Check faculty conflict
+                fac_conflict = self._check_conflict(
+                    task_id, to_day, try_period, task.duration, fid=fac_id)
+                # Check section conflict
+                sec_conflict = self._check_conflict(
+                    task_id, to_day, try_period, task.duration, sid=sec_id)
+                if fac_conflict or sec_conflict:
+                    continue
+                updated = dict(info)
+                updated['day_index']    = to_day
+                updated['day_name']     = const.DAYS[to_day]
+                updated['period_index'] = try_period
+                updated['start_slot']   = _slot(to_day, try_period)
+                new_sol[task_id] = updated
+                changes.append(
+                    f"• {info['subject_code'].upper()} ({info['section_id']}): "
+                    f"{const.DAYS[from_day]} P{info['period_index']+1} → "
+                    f"{const.DAYS[to_day]} P{try_period+1}"
+                    + (f" (requested P{to_period}, auto-placed)" if to_period and try_period != to_period-1 else "")
+                )
+                placed = True
+                break
+
+            if not placed:
+                changes.append(
+                    f"⚠️ No free slot on {const.DAYS[to_day]} for "
+                    f"{info['subject_code'].upper()} ({info['section_id']}) "
+                    f"— all periods occupied"
+                )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], 'No matching class found to move.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ Move operation:\n" + "\n".join(changes))
+
+    def _op_swap_classes(self, c):
+        """
+        Swap two classes with each other.
+        Prompt examples:
+          "Swap Monday P1 NLP with Wednesday P3 ML for section 6A"
+          "Swap Anu's Monday class with Syed's Wednesday class"
+        """
+        task1_id = c.get('task1_id')
+        task2_id = c.get('task2_id')
+        day1     = DAY_INDEX.get((c.get('day1') or '').upper())
+        day2     = DAY_INDEX.get((c.get('day2') or '').upper())
+        period1  = c.get('period1')
+        period2  = c.get('period2')
+        sid      = c.get('section_id')
+
+        # Extract subject codes for subject-based lookup
+        scode1 = c.get('subject_code1') or c.get('subject_code')
+        scode2 = c.get('subject_code2')
+        scodes = c.get('subject_codes') or []
+        if scodes and len(scodes) >= 2:
+            scode1, scode2 = scodes[0], scodes[1]
+        elif scodes and len(scodes) == 1 and not scode1:
+            scode1 = scodes[0]
+
+        fid1 = c.get('faculty_id1')
+        fid2 = c.get('faculty_id2')
+
+        # Find tasks: try period → subject → faculty (in priority order)
+        if not task1_id and day1 is not None:
+            if period1 is not None:
+                task1_id = self._find_task_at(day1, period1-1, sid)
+            if not task1_id and scode1:
+                task1_id = self._find_task_by_subject(day1, scode1, sid)
+            if not task1_id and fid1:
+                task1_id = self._find_task_by_faculty(day1, fid1, sid)
+        if not task2_id and day2 is not None:
+            if period2 is not None:
+                task2_id = self._find_task_at(day2, period2-1, sid)
+            if not task2_id and scode2:
+                task2_id = self._find_task_by_subject(day2, scode2, sid)
+            if not task2_id and fid2:
+                task2_id = self._find_task_by_faculty(day2, fid2, sid)
+
+        if not task1_id or not task2_id:
+            d1 = const.DAYS[day1] if day1 is not None else '?'
+            d2 = const.DAYS[day2] if day2 is not None else '?'
+            return self._fail(
+                f'SWAP_CLASSES: could not find both classes. '
+                f'Looking for {scode1 or "?"} on {d1} and {scode2 or "?"} on {d2} '
+                f'for section {sid or "all"}')
+
+        info1 = dict(self.current_solution.get(task1_id, {}))
+        info2 = dict(self.current_solution.get(task2_id, {}))
+
+        if not info1 or not info2:
+            return self._fail('One or both tasks not found in current schedule.')
+
+        new_sol = dict(self.current_solution)
+
+        # Swap day + period + start_slot
+        for key in ('day_index','day_name','period_index','start_slot'):
+            info1[key], info2[key] = info2[key], info1[key]
+
+        new_sol[task1_id] = info1
+        new_sol[task2_id] = info2
+
+        t1 = self.tasks_by_id.get(task1_id)
+        t2 = self.tasks_by_id.get(task2_id)
+        summary = (
+            f"✅ Swapped:\n"
+            f"• {t1.subject.subject_code.upper() if t1 else task1_id} ↔ "
+            f"{t2.subject.subject_code.upper() if t2 else task2_id}"
+        )
+        return ('FEASIBLE', new_sol, [task1_id, task2_id], summary)
+
+    def _op_cancel_class(self, c):
+        """
+        Remove a class from the timetable (e.g. cancelled due to event).
+        Prompt examples:
+          "Cancel NLP class on Friday for section 6A"
+          "No class for 5A on Monday period 2"
+          "Cancel all classes on Thursday for Anu"
+        """
+        day    = DAY_INDEX.get((c.get('day') or '').upper())
+        period = c.get('period')
+        scode  = c.get('subject_code')
+        sid    = c.get('section_id')
+        fid    = c.get('faculty_id')
+
+        new_sol, changes = dict(self.current_solution), []
+        # sid may be a full section id ("6a-E1") or a parent prefix ("6A")
+        sid_is_prefix = sid and '-' not in sid
+
+        for task_id, info in list(self.current_solution.items()):
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if day    is not None and info['day_index']    != day:        continue
+            if period is not None and info['period_index'] != period - 1: continue
+            if scode  and task.subject.subject_code        != scode:      continue
+            if fid    and task.faculty.id                  != fid:        continue
+            # Section filter: exact match OR parent prefix match
+            if sid:
+                sec = task.section.section_id
+                if sid_is_prefix:
+                    # "6A" matches "6a-E1", "6a-E2" but NOT "6b-E1"
+                    if not sec.lower().startswith(sid.lower()):
+                        continue
+                else:
+                    if sec != sid:
+                        continue
+
+            del new_sol[task_id]
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"{const.DAYS[info['day_index']]} P{info['period_index']+1} — CANCELLED"
+            )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], 'No matching class found to cancel.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ {len(changes)} class(es) cancelled:\n" + "\n".join(changes))
+
+    def _op_change_room(self, c):
+        """
+        Assign a different room to a class.
+        Prompt examples:
+          "Move NLP class on Monday to Lab 2"
+          "Change room for 6A's ML on Tuesday to R3"
+          "Shift all of section 5A's labs to L2"
+        """
+        new_room_id = c.get('room_id') or c.get('new_room_id')
+        scode       = c.get('subject_code')
+        sid         = c.get('section_id')
+        day         = DAY_INDEX.get((c.get('day') or '').upper())
+        period      = c.get('period')
+
+        if not new_room_id:
+            return self._fail('CHANGE_ROOM needs room_id')
+
+        new_room = self.room_by_id.get(new_room_id)
+        if not new_room:
+            return self._fail(f'Room not found: {new_room_id}')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if scode  and task.subject.subject_code != scode:  continue
+            if sid    and not self._sec_matches(task.section.section_id, sid): continue
+            if day    is not None and info['day_index']    != day:      continue
+            if period is not None and info['period_index'] != period-1: continue
+
+            updated = dict(info)
+            updated['room_id']   = new_room.room_id
+            updated['room_name'] = f"{new_room.room_id} ({new_room.building})"
+            new_sol[task_id] = updated
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"{const.DAYS[info['day_index']]} P{info['period_index']+1}: "
+                f"Room → {new_room.room_id}"
+            )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], 'No matching class found.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ {len(changes)} room change(s):\n" + "\n".join(changes))
+
+    def _op_add_extra_class(self, c):
+        """
+        Add a makeup/extra class to the timetable.
+        Prompt examples:
+          "Add a makeup NLP class on Saturday period 1 for 6A by Anu"
+          "Schedule extra ML session for 5B on Friday afternoon"
+        """
+        scode  = c.get('subject_code')
+        sid    = c.get('section_id')
+        fid    = c.get('faculty_id')
+        day_raw = (c.get('day') or '').upper()
+        # day may be a string key like "SAT" or already an int index
+        if isinstance(day_raw, int):
+            day = day_raw
+        else:
+            day = DAY_INDEX.get(day_raw)
+        period  = c.get('period')
+        room_id = c.get('room_id')
+
+        if day is None or not scode or not sid or not fid:
+            return self._fail(
+                'ADD_EXTRA_CLASS needs subject_code, section_id, faculty_id, and day')
+
+        fac  = self.fac_by_id.get(fid)
+        room = self.room_by_id.get(room_id) if room_id else next(
+            (r for r in self.rooms if not r.is_lab), self.rooms[0])
+
+        if not fac:
+            return self._fail(f'Faculty not found: {fid}')
+
+        day_name = const.DAYS[day] if day < len(const.DAYS) else day_raw
+
+        # Auto-find free period if not specified
+        if not period:
+            for try_p in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                fc = self._check_conflict(None, day, try_p, 1, fid=fid)
+                sc = self._check_conflict(None, day, try_p, 1, sid=sid)
+                if not fc and not sc:
+                    period = try_p + 1  # 1-indexed
+                    break
+            if not period:
+                return self._fail(
+                    f'No free slot on {day_name} for {scode.upper()} ({sid})')
+
+        # Check conflict at chosen period
+        conflict = (self._check_conflict(None, day, period-1, 1, fid=fid) or
+                    self._check_conflict(None, day, period-1, 1, sid=sid))
+        if conflict:
+            return self._fail(f'Slot conflict at P{period}: {conflict}')
+
+        task_id  = f"EXTRA-{scode}-{sid}-{day_name}-P{period}"
+        new_sol = dict(self.current_solution)
+        new_sol[task_id] = {
+            'start_slot':   _slot(day, period-1),
+            'day_index':    day,
+            'day_name':     day_name,
+            'period_index': period - 1,
+            'room_id':      room.room_id,
+            'room_name':    f"{room.room_id} ({room.building})",
+            'faculty_name': fac.name,
+            'subject_code': scode,
+            'section_id':   sid,
+            'duration':     1,
+            'is_extra':     True,
+        }
+        return ('FEASIBLE', new_sol, [task_id],
+                f"✅ Extra class added: {scode.upper()} ({sid}) "
+                f"{day_name} P{period} by {fac.name}")
+
+    def _op_mark_holiday(self, c):
+        """
+        Clear all classes on a specific day (holiday/event).
+        Prompt examples:
+          "Mark Friday as holiday"
+          "No classes on Monday for all sections"
+          "Cancel all Thursday classes for section 6A"
+        """
+        days    = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+        sid     = c.get('section_id')
+
+        if not days:
+            return self._fail('MARK_HOLIDAY needs at least one day')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in list(self.current_solution.items()):
+            if info['day_index'] not in days: continue
+            if sid and info['section_id'] != sid: continue
+            del new_sol[task_id]
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"P{info['period_index']+1}"
+            )
+
+        day_names = [const.DAYS[d] for d in days]
+        return ('FEASIBLE', new_sol, [],
+                f"✅ Holiday on {', '.join(day_names)}: "
+                f"{len(changes)} class(es) cleared")
+
+    def _op_reschedule_lab(self, c):
+        """
+        Move a lab session to a different day (keeps it as 2-hour block).
+        Prompt examples:
+          "Move NLP Lab from Wednesday to Thursday"
+          "Reschedule ML Lab for section 6A to Friday"
+        """
+        scode     = c.get('subject_code')
+        sid       = c.get('section_id')
+        from_day  = DAY_INDEX.get((c.get('from_day') or '').upper())
+        to_day    = DAY_INDEX.get((c.get('to_day') or '').upper())
+        to_period = c.get('to_period', 1)
+
+        if to_day is None:
+            return self._fail('RESCHEDULE_LAB needs to_day')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task or task.duration < 2: continue
+
+            # Match by subject code OR by partial name match (nlp matches nlplab)
+            code_match = (scode and (
+                task.subject.subject_code == scode or
+                task.subject.subject_code.startswith(scode) or
+                scode.startswith(task.subject.subject_code)
+            ))
+            if not code_match: continue
+            if sid and not self._sec_matches(task.section.section_id, sid): continue
+            # If from_day specified, only move labs on that day
+            if from_day is not None and info['day_index'] != from_day: continue
+
+            # Auto-find a free lab slot on to_day if specified period conflicts
+            # Try: specified period first, then all ALLOWED_LAB_START_INDICES
+            candidates = []
+            if to_period:
+                candidates.append(to_period - 1)
+            for p in const.ALLOWED_LAB_START_INDICES:
+                if p not in candidates:
+                    candidates.append(p)
+
+            placed = False
+            fac_id2 = task.faculty.id if task else None
+            sec_id2 = task.section.section_id if task else None
+            for try_period in candidates:
+                # Make sure the 2-hour block doesn't cross day boundary
+                if try_period + task.duration > const.NUM_TEACHING_SLOTS_PER_DAY:
+                    continue
+                fac_conflict = self._check_conflict(
+                    task_id, to_day, try_period, task.duration, fid=fac_id2)
+                sec_conflict = self._check_conflict(
+                    task_id, to_day, try_period, task.duration, sid=sec_id2)
+                if fac_conflict or sec_conflict:
+                    continue
+                # Free slot found — place it
+                updated = dict(info)
+                updated['day_index']    = to_day
+                updated['day_name']     = const.DAYS[to_day]
+                updated['period_index'] = try_period
+                updated['start_slot']   = _slot(to_day, try_period)
+                new_sol[task_id] = updated
+                changes.append(
+                    f"• {scode.upper()} Lab ({info['section_id']}): "
+                    f"{const.DAYS[info['day_index']]} P{info['period_index']+1} → "
+                    f"{const.DAYS[to_day]} P{try_period+1}"
+                )
+                placed = True
+                break
+
+            if not placed:
+                changes.append(
+                    f"⚠️ No free lab slot found on {const.DAYS[to_day]} "
+                    f"for {scode.upper()} ({info['section_id']}) — "
+                    f"all slots are occupied"
+                )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], f'Lab {scode} not found.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ Lab rescheduled:\n" + "\n".join(changes))
+
+    def _op_change_faculty(self, c):
+        """
+        Permanently change faculty for a subject/section (all occurrences).
+        Prompt examples:
+          "Assign all NLP classes of 6A to Prof. Syed instead of Anu"
+          "Transfer Anu's 5B classes to Kavitha permanently"
+        """
+        from_id = c.get('from_faculty_id') or c.get('from_faculty')
+        to_id   = c.get('to_faculty_id')   or c.get('to_faculty')
+        scode   = c.get('subject_code')
+        sid     = c.get('section_id')
+
+        if not to_id:
+            return self._fail('CHANGE_FACULTY needs to_faculty_id')
+
+        to_fac = self.fac_by_id.get(to_id)
+        if not to_fac:
+            return self._fail(f'Faculty not found: {to_id}')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if from_id and task.faculty.id != from_id:              continue
+            if scode   and task.subject.subject_code != scode:       continue
+            if sid     and not self._sec_matches(task.section.section_id, sid): continue
+
+            updated = dict(info)
+            updated['faculty_name'] = to_fac.name
+            new_sol[task_id] = updated
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"ALL slots: faculty → {to_fac.name}"
+            )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], 'No matching classes found.')
+        # Deduplicate summary
+        unique = list(dict.fromkeys(changes))
+        return ('FEASIBLE', new_sol, [],
+                f"✅ Faculty changed for {len(changes)} slot(s):\n" + "\n".join(unique[:10]))
+
+    def _op_freeze_slot(self, c):
+        """
+        Mark a slot as frozen (metadata only — solver will skip it in future updates).
+        Prompt examples:
+          "Lock Monday P1 NLP for section 6A"
+          "Freeze Anu's Wednesday slots"
+        """
+        # Freeze is stored as metadata in the info dict
+        day    = DAY_INDEX.get((c.get('day') or '').upper())
+        period = c.get('period')
+        sid    = c.get('section_id')
+        scode  = c.get('subject_code')
+
+        new_sol, changes = dict(self.current_solution), []
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if day    is not None and info['day_index']              != day:       continue
+            if period is not None and info['period_index']           != period-1:  continue
+            if sid    and not self._sec_matches(task.section.section_id, sid):     continue
+            if scode  and task.subject.subject_code                  != scode:     continue
+
+            updated = dict(info)
+            updated['frozen'] = True
+            new_sol[task_id]  = updated
+            changes.append(
+                f"• {info['subject_code'].upper()} ({info['section_id']}) "
+                f"{const.DAYS[info['day_index']]} P{info['period_index']+1} — FROZEN"
+            )
+
+        if not changes:
+            return ('NO_CHANGE', self.current_solution, [], 'No matching slot to freeze.')
+        return ('FEASIBLE', new_sol, [],
+                f"✅ {len(changes)} slot(s) frozen:\n" + "\n".join(changes))
+
+    # ═════════════════════════════════════════════════════════════════
+    # CP-SAT RE-OPTIMIZATION (for scheduling constraint types)
+    # ═════════════════════════════════════════════════════════════════
+
+    def _reoptimize(self, slm_constraint, time_limit):
+        ctype = slm_constraint.get('type', '').upper()
+        affected_ids = self._find_affected_tasks(slm_constraint)
+
+        if not affected_ids:
+            return ('NO_CHANGE', self.current_solution, [],
+                    f'No tasks affected by: {ctype}')
+
+        status, partial = self._solve_partial(affected_ids, [slm_constraint], time_limit)
+
+        if status not in ('OPTIMAL', 'FEASIBLE'):
+            return (status, self.current_solution, affected_ids,
+                    f'❌ Could not reschedule {len(affected_ids)} task(s). '
+                    f'Constraint may be too restrictive.')
+
+        new_sol = dict(self.current_solution)
+        new_sol.update(partial)
+
+        changes = []
+        for tid in affected_ids:
+            old = self.current_solution.get(tid, {})
+            new = new_sol.get(tid, {})
+            if old and new:
+                old_slot = f"{const.DAYS[old['day_index']]} P{old['period_index']+1}"
+                new_slot = f"{const.DAYS[new['day_index']]} P{new['period_index']+1}"
+                if old_slot != new_slot:
+                    changes.append(
+                        f"• {new.get('subject_code','?').upper()} "
+                        f"({new.get('section_id','?')}): "
+                        f"{old_slot} → {new_slot}"
+                    )
+
+        summary = (f"✅ {len(changes)} slot(s) moved:\n" + "\n".join(changes)
+                   if changes else "✅ Constraint applied — no slot changes needed.")
+        return (status, new_sol, affected_ids, summary)
+
+    def _find_affected_tasks(self, c):
+        ctype = c.get('type', '').upper()
+        affected = set()
+
+        if ctype == 'FACULTY_UNAVAILABLE':
+            fid   = c.get('faculty_id')
+            days  = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+            slots = c.get('slots') or []
+            for task in self.tasks_by_faculty.get(fid, []):
+                info = self.current_solution.get(task.task_id, {})
+                if not info: continue
+                if not days or info['day_index'] in days:
+                    if not slots or info['period_index'] in slots:
+                        affected.add(task.task_id)
+
+        elif ctype == 'FACULTY_FREE_DAY':
+            fid  = c.get('faculty_id')
+            pday = c.get('preferred_day')
+            if pday and pday in DAY_INDEX:
+                for task in self.tasks_by_faculty.get(fid, []):
+                    info = self.current_solution.get(task.task_id, {})
+                    if info and info['day_index'] == DAY_INDEX[pday]:
+                        affected.add(task.task_id)
+
+        elif ctype == 'FACULTY_MAX_DAILY_HOURS':
+            fid     = c.get('faculty_id')
+            max_hrs = c.get('max_hours') or 999
+            by_day  = defaultdict(list)
+            for task in self.tasks_by_faculty.get(fid, []):
+                info = self.current_solution.get(task.task_id, {})
+                if info: by_day[info['day_index']].append(task.task_id)
+            for day, tids in by_day.items():
+                total = sum(self.tasks_by_id[t].duration for t in tids)
+                if total > max_hrs: affected.update(tids)
+
+        elif ctype in ('SUBJECT_PREFERRED_TIME', 'HEAVY_SUBJECT_MORNING'):
+            scode  = c.get('subject_code')
+            sid    = c.get('section_id')
+            period = str(c.get('period', '')).upper()
+            target = MORNING_PERIODS if 'MORNING' in period else AFTERNOON_PERIODS
+            src    = self.tasks_by_subject.get(scode, []) if scode else self.tasks
+            for task in src:
+                if sid and task.section.section_id != sid: continue
+                info = self.current_solution.get(task.task_id, {})
+                if info and target and info['period_index'] not in target:
+                    affected.add(task.task_id)
+
+        elif ctype == 'SECTION_FREE_SLOT':
+            sid   = c.get('section_id')
+            slot  = c.get('slot')
+            days  = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+            for task in self.tasks_by_section.get(sid, []):
+                info = self.current_solution.get(task.task_id, {})
+                if not info: continue
+                if slot is not None and info['period_index'] == slot - 1:
+                    if not days or info['day_index'] in days:
+                        affected.add(task.task_id)
+
+        elif ctype == 'LAB_MUST_CONSECUTIVE':
+            scode = c.get('subject_code')
+            for task in self.tasks_by_subject.get(scode, []):
+                affected.add(task.task_id)
+
+        elif ctype == 'WORKING_DAYS':
+            allowed = {DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX}
+            if allowed:
+                for task in self.tasks:
+                    info = self.current_solution.get(task.task_id, {})
+                    if info and info['day_index'] not in allowed:
+                        affected.add(task.task_id)
+
+        elif ctype in ('NO_BACK_TO_BACK_SUBJECTS', 'DISTRIBUTE_SUBJECTS_EVENLY',
+                       'SUBJECT_SPACING'):
+            scode = c.get('subject_code')
+            codes = c.get('subject_codes') or ([scode] if scode else [])
+            sid   = c.get('section_id')
+            for code in codes:
+                for task in self.tasks_by_subject.get(code, []):
+                    if sid and task.section.section_id != sid: continue
+                    affected.add(task.task_id)
+
+        elif ctype == 'NO_FREE_PERIOD':
+            # Find tasks that are NOT in the required period on any day
+            # so we can move them there, OR find tasks blocking required period
+            # Strategy: collect all tasks that need to shift to fill the required period
+            raw_periods = c.get('periods') or []
+            # Resolve -1 to last teaching period
+            required_periods = [
+                const.NUM_TEACHING_SLOTS_PER_DAY - 1 if p == -1 else p
+                for p in raw_periods
+            ]   # e.g. [0] for P1, [7] for last
+            sids = [s.section_id for s in self.sections]
+            # Find sections that have a free slot in required period on any day
+            # We need to reschedule tasks to fill those gaps
+            # Collect all tasks — let solver figure out placement
+            for task in self.tasks:
+                info = self.current_solution.get(task.task_id, {})
+                if info and required_periods:
+                    # Add tasks not currently in the required period
+                    if info.get('period_index') not in required_periods:
+                        affected.add(task.task_id)
+            # If no periods specified, affect nothing
+            if not required_periods:
+                affected = set()
+
+        else:
+            affected.update(t.task_id for t in self.tasks)
+
+        # Never move frozen slots
+        frozen = {tid for tid, info in self.current_solution.items()
+                  if info.get('frozen')}
+        return list(affected - frozen)
+
+    def _solve_partial(self, affected_ids, constraints, time_limit):
+        model  = cp_model.CpModel()
+        solver = cp_model.CpSolver()
+
+        affected_tasks = [self.tasks_by_id[tid] for tid in affected_ids
+                          if tid in self.tasks_by_id]
+
+        locked_fac = defaultdict(set)
+        locked_sec = defaultdict(set)
+        locked_room = defaultdict(set)
+
+        for task_id, info in self.current_solution.items():
+            if task_id in affected_ids: continue
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            for offset in range(task.duration):
+                s = _slot(info['day_index'], info['period_index']) + offset
+                locked_fac[task.faculty.id].add(s)
+                locked_sec[task.section.section_id].add(s)
+
+        task_vars = {}
+        for task in affected_tasks:
+            allowed = self._compute_allowed(task, constraints, locked_fac, locked_sec)
+            if not allowed: allowed = self._all_starts(task)
+
+            sv = model.NewIntVarFromDomain(
+                cp_model.Domain.FromValues(sorted(allowed)), f'{task.task_id}_s')
+            ev = model.NewIntVar(0, const.TOTAL_TEACHING_SLOTS_PER_WEEK, f'{task.task_id}_e')
+            iv = model.NewIntervalVar(sv, task.duration, ev, f'{task.task_id}_i')
+
+            ri = model.NewIntVarFromDomain(
+                cp_model.Domain.FromValues(self._allowed_rooms(task)), f'{task.task_id}_r')
+
+            task_vars[task.task_id] = (sv, ev, iv, ri)
+
+        # No-overlap faculty
+        ivs_fac = defaultdict(list)
+        for t in affected_tasks:
+            ivs_fac[t.faculty.id].append(task_vars[t.task_id][2])
+        for ivs in ivs_fac.values():
+            if len(ivs) > 1: model.AddNoOverlap(ivs)
+
+        # No-overlap section
+        ivs_sec = defaultdict(list)
+        for t in affected_tasks:
+            ivs_sec[t.section.section_id].append(task_vars[t.task_id][2])
+        for ivs in ivs_sec.values():
+            if len(ivs) > 1: model.AddNoOverlap(ivs)
+
+        content_solution_ref = self.current_solution  # used in NO_FREE_PERIOD
+
+        # ── NO_FREE_PERIOD enforcement ─────────────────────────────────────
+        # For each section and each working day, ensure at least one task
+        # is assigned to the required period(s).
+        for c in constraints:
+            if c.get('type','').upper() != 'NO_FREE_PERIOD':
+                continue
+            required_periods = c.get('periods') or []
+            filter_sid       = c.get('section_id')       # None = all sections
+            filter_days      = c.get('days') or list(range(const.NUM_WORKING_DAYS))
+
+            for day in filter_days:
+                # Group affected tasks by section
+                tasks_by_sec = defaultdict(list)
+                for task in affected_tasks:
+                    if filter_sid and task.section.section_id != filter_sid:
+                        continue
+                    tasks_by_sec[task.section.section_id].append(task)
+
+                for sec_id, sec_tasks in tasks_by_sec.items():
+                    for req_period in required_periods:
+                        target_slot = _slot(day, req_period)
+                        # Create boolean: is_in_slot[task] = 1 if task covers target_slot
+                        in_slot_vars = []
+                        for task in sec_tasks:
+                            if task.task_id not in task_vars:
+                                continue
+                            sv = task_vars[task.task_id][0]
+                            b  = model.NewBoolVar(
+                                f'{task.task_id}_covers_d{day}_p{req_period}')
+                            # task covers target_slot if sv <= target_slot < sv + duration
+                            model.Add(sv <= target_slot).OnlyEnforceIf(b)
+                            model.Add(sv + task.duration > target_slot).OnlyEnforceIf(b)
+                            model.Add(sv > target_slot).OnlyEnforceIf(b.Not())
+                            in_slot_vars.append(b)
+
+                        # Also check non-affected (locked) tasks for this section+day+period
+                        locked_covers = False
+                        for tid, info in content_solution_ref.items():
+                            if tid in affected_ids: continue
+                            t = self.tasks_by_id.get(tid)
+                            if not t or t.section.section_id != sec_id: continue
+                            if info['day_index'] != day: continue
+                            t_start = _slot(info['day_index'], info['period_index'])
+                            if t_start <= target_slot < t_start + t.duration:
+                                locked_covers = True
+                                break
+
+                        # Only add constraint if locked tasks don't already cover it
+                        if not locked_covers and in_slot_vars:
+                            model.AddAtLeastOne(in_slot_vars)
+
+        # Minimize changes from original
+        penalties = []
+        for task in affected_tasks:
+            orig = self.current_solution.get(task.task_id, {})
+            if orig:
+                orig_slot = _slot(orig['day_index'], orig['period_index'])
+                sv = task_vars[task.task_id][0]
+                changed = model.NewBoolVar(f'{task.task_id}_chg')
+                model.Add(sv != orig_slot).OnlyEnforceIf(changed)
+                model.Add(sv == orig_slot).OnlyEnforceIf(changed.Not())
+                penalties.append(changed)
+        if penalties: model.Minimize(sum(penalties))
+
+        solver.parameters.max_time_in_seconds = time_limit
+        solver.parameters.log_search_progress = False
+        sv_val = solver.Solve(model)
+
+        if sv_val not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+            return ('INFEASIBLE', {})
+
+        result = {}
+        for task in affected_tasks:
+            sv, _, _, rv = task_vars[task.task_id]
+            start = solver.Value(sv)
+            room  = self.rooms[solver.Value(rv)]
+            result[task.task_id] = {
+                'start_slot':   start,
+                'day_index':    _day(start),
+                'day_name':     const.DAYS[_day(start)],
+                'period_index': _period(start),
+                'room_id':      room.room_id,
+                'room_name':    f'{room.room_id} ({room.building})',
+                'faculty_name': task.faculty.name,
+                'subject_code': task.subject.subject_code,
+                'section_id':   task.section.section_id,
+                'duration':     task.duration,
+            }
+
+        status = 'OPTIMAL' if sv_val == cp_model.OPTIMAL else 'FEASIBLE'
+        return (status, result)
+
+    # ═════════════════════════════════════════════════════════════════
+    # HELPERS
+    # ═════════════════════════════════════════════════════════════════
+
+    def _sec_matches(self, task_section_id: str, sid_filter: str) -> bool:
+        """
+        Returns True if task_section_id matches sid_filter.
+        sid_filter can be:
+          - exact id:      "6a-E1" -> only matches "6a-E1"
+          - parent prefix: "6A"    -> matches "6a-E1", "6a-E2" but not "6b-E1"
+          - None:          matches everything
+        """
+        if not sid_filter:
+            return True
+        if '-' not in sid_filter:
+            # prefix match
+            return task_section_id.lower().startswith(sid_filter.lower())
+        return task_section_id == sid_filter
+
+    def _check_conflict(self, skip_task_id, day, period, duration,
+                        fid=None, sid=None):
+        """Returns conflict description if slot is taken, else None."""
+        target_slots = set(range(_slot(day, period),
+                                  _slot(day, period) + duration))
+        for task_id, info in self.current_solution.items():
+            if task_id == skip_task_id: continue
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            task_slots = set(range(
+                _slot(info['day_index'], info['period_index']),
+                _slot(info['day_index'], info['period_index']) + info['duration']
+            ))
+            if not target_slots.isdisjoint(task_slots):
+                if fid and task.faculty.id == fid:
+                    return f"{task.faculty.name} busy"
+                if sid and task.section.section_id == sid:
+                    return f"Section {info['section_id']} busy"
+                if not fid and not sid:
+                    return f"{info['subject_code']} at that slot"
+        return None
+
+    def _find_task_at(self, day, period, sid=None):
+        for task_id, info in self.current_solution.items():
+            if info['day_index'] != day: continue
+            if info['period_index'] != period: continue
+            if sid and not self._sec_matches(info['section_id'], sid): continue
+            return task_id
+        return None
+
+    def _find_task_by_subject(self, day, scode, sid=None):
+        """Find first task matching subject code on a given day."""
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if info['day_index'] != day: continue
+            tc = task.subject.subject_code.lower()
+            sc = scode.lower()
+            if tc != sc and not tc.startswith(sc) and not sc.startswith(tc):
+                continue
+            if sid and not self._sec_matches(info['section_id'], sid): continue
+            return task_id
+        return None
+
+    def _find_task_by_faculty(self, day, fid, sid=None):
+        """Find first task by faculty on a given day."""
+        for task_id, info in self.current_solution.items():
+            task = self.tasks_by_id.get(task_id)
+            if not task: continue
+            if info['day_index'] != day: continue
+            if task.faculty.id != fid: continue
+            if sid and not self._sec_matches(info['section_id'], sid): continue
+            return task_id
+        return None
+
+    def _all_starts(self, task):
+        if task.duration > 1:
+            result = []
+            for day in range(const.NUM_WORKING_DAYS):
+                for pos in const.ALLOWED_LAB_START_INDICES:
+                    result.append(day * const.NUM_TEACHING_SLOTS_PER_DAY + pos)
+            return result
+        return list(range(const.TOTAL_TEACHING_SLOTS_PER_WEEK))
+
+    def _compute_allowed(self, task, constraints, locked_fac, locked_sec):
+        base = set(self._all_starts(task))
+        for offset in range(task.duration):
+            for s in locked_fac.get(task.faculty.id, set()):
+                base.discard(s - offset)
+            for s in locked_sec.get(task.section.section_id, set()):
+                base.discard(s - offset)
+
+        for c in constraints:
+            ctype = c.get('type', '').upper()
+            if ctype == 'FACULTY_UNAVAILABLE' and c.get('faculty_id') == task.faculty.id:
+                days = [DAY_INDEX[d] for d in (c.get('days') or []) if d in DAY_INDEX]
+                for day in days:
+                    off = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                    for p in range(const.NUM_TEACHING_SLOTS_PER_DAY):
+                        for o in range(task.duration): base.discard(off + p - o)
+            elif ctype == 'SUBJECT_PREFERRED_TIME':
+                if c.get('subject_code') == task.subject.subject_code:
+                    period = str(c.get('period','')).upper()
+                    target = MORNING_PERIODS if 'MORNING' in period else AFTERNOON_PERIODS
+                    if target:
+                        base = {s for s in base if _period(s) in target}
+            elif ctype == 'NO_FREE_PERIOD':
+                required_periods = c.get('periods') or []
+                sid = c.get('section_id')
+                # Only enforce for this task's section if section filter set
+                if required_periods and (not sid or task.section.section_id == sid):
+                    # Prefer slots in required period — don't fully restrict
+                    # (hard enforcement done via AddAtLeastOne in solver)
+                    pass
+
+            elif ctype == 'WORKING_DAYS':
+                allowed_days = {DAY_INDEX[d] for d in (c.get('days') or [])
+                                if d in DAY_INDEX}
+                if allowed_days:
+                    base = {s for s in base if _day(s) in allowed_days}
+        return list(base)
+
+    def _allowed_rooms(self, task):
+        allowed = [i for i, r in enumerate(self.rooms)
+                   if ((task.subject.subject_type == SubjectType.LAB) == r.is_lab
+                       and r.capacity >= task.section.student_strength)]
+        return allowed if allowed else [0]
+
+    def _fail(self, msg):
+        return ('NO_CHANGE', self.current_solution, [], f'❌ {msg}')

reoptimizer.py

@@ -0,0 +1,238 @@
+# reoptimizer.py
+
+"""
+This module handles emergency re-optimization of an existing timetable.
+It is used when a disruption occurs (e.g., Faculty Leave) and the schedule
+must be adjusted with minimal changes to the rest of the institution.
+
+Strategy:
+1. Accept the original solution.
+2. Identify which Sections are directly affected by the disruption.
+3. "Freeze" (Fixed Constraint) all tasks belonging to unaffected sections.
+4. "Relax" (Variable) tasks belonging to affected sections, allowing them to swap slots.
+5. Add a penalty for every task that changes from its original slot to minimize disruption.
+"""
+
+from typing import List, Dict, Any, Tuple, Set
+from ortools.sat.python import cp_model
+
+# Import project components
+from models import Task, Faculty, Section, Room
+from constraint_engine import ConstraintEngine
+import constants as const
+
+class EmergencyReoptimizer:
+    """
+    Specialized solver for adjusting existing timetables under new constraints.
+    """
+
+    def __init__(
+        self,
+        tasks: List[Task],
+        faculties: List[Faculty],
+        sections: List[Section],
+        rooms: List[Room]
+    ):
+        self.tasks = tasks
+        self.faculties = faculties
+        self.sections = sections
+        self.rooms = rooms
+        
+        # Internal lookups
+        self.tasks_by_id = {t.task_id: t for t in tasks}
+
+    def reoptimize_for_faculty_leave(
+        self,
+        current_schedule: Dict[str, Dict[str, Any]],
+        faculty_id: str,
+        leave_day_index: int,
+        time_limit_seconds: int = 30
+    ) -> Tuple[str, Dict[str, Any]]:
+        """
+        Adjusts the schedule to accommodate a faculty member being unavailable on a specific day.
+        
+        Args:
+            current_schedule: The output dictionary from the original Solver.
+            faculty_id: The ID of the faculty on leave.
+            leave_day_index: The day index (0=Mon, 4=Fri) of the leave.
+            time_limit_seconds: Max time for re-solving.
+
+        Returns:
+            Tuple (status, new_schedule)
+        """
+        print(f"--- Starting Emergency Re-optimization: Faculty {faculty_id} on Day {leave_day_index} ---")
+
+        # 1. Initialize a fresh model
+        model = cp_model.CpModel()
+        
+        # 2. Initialize Constraint Engine (applies all HARD constraints: limits, rooms, etc.)
+        # We assume the Faculty object's availability hasn't been permanently changed in the DB,
+        # so we will add the leave constraint manually below.
+        ce = ConstraintEngine(model, self.tasks, self.faculties, self.sections, self.rooms)
+        ce.apply_all_constraints()
+
+        # 3. Apply the Emergency Constraint: Faculty Unavailable on Leave Day
+        self._apply_leave_constraint(model, ce, faculty_id, leave_day_index)
+
+        # 4. Identify Affected Sections
+        # We need to unfreeze any section that has a class with this faculty on that day,
+        # so the solver can swap that class with another class from a different day.
+        affected_section_ids = self._identify_affected_sections(current_schedule, faculty_id, leave_day_index)
+        print(f"Affected Sections (Schedule will be relaxed): {affected_section_ids}")
+
+        # 5. Apply Freezing and Change Penalties
+        self._freeze_and_relax_variables(model, ce, current_schedule, affected_section_ids)
+
+        # 6. Solve
+        solver = cp_model.CpSolver()
+        solver.parameters.max_time_in_seconds = time_limit_seconds
+        solver.parameters.num_search_workers = 8
+        
+        status_val = solver.Solve(model)
+        
+        status_map = {
+            cp_model.OPTIMAL: "OPTIMAL",
+            cp_model.FEASIBLE: "FEASIBLE",
+            cp_model.INFEASIBLE: "INFEASIBLE",
+            cp_model.MODEL_INVALID: "MODEL_INVALID",
+            cp_model.UNKNOWN: "UNKNOWN"
+        }
+        status_str = status_map.get(status_val, "UNKNOWN")
+        print(f"Re-optimization finished: {status_str}")
+
+        if status_val in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            return status_str, self._extract_solution(solver, ce)
+        else:
+            print("Could not find a valid solution for the emergency constraint.")
+            return status_str, None
+
+    def _apply_leave_constraint(self, model: cp_model.CpModel, ce: ConstraintEngine, faculty_id: str, day_index: int):
+        """
+        Hard constraint: The specific faculty cannot teach on the specific day.
+        """
+        day_start_slot = day_index * const.NUM_TEACHING_SLOTS_PER_DAY
+        day_end_slot = (day_index + 1) * const.NUM_TEACHING_SLOTS_PER_DAY
+        
+        # Iterate over all tasks taught by this faculty
+        for task in self.tasks:
+            if task.faculty.id == faculty_id:
+                start_var = ce.task_vars[task.task_id][0]
+                
+                # Logic: Task cannot start within the day's range.
+                # Since tasks are interval vars, we technically check overlap, 
+                # but start_time check is usually sufficient for single-day constraint 
+                # if duration doesn't span days (which it doesn't).
+                
+                # We enforce: start_var < day_start OR start_var >= day_end
+                # This effectively bans the task from that day.
+                
+                # Using boolean indicators to enforce the "OR" logic
+                before_day = model.NewBoolVar(f"{task.task_id}_before_leave")
+                after_day = model.NewBoolVar(f"{task.task_id}_after_leave")
+                
+                model.Add(start_var < day_start_slot).OnlyEnforceIf(before_day)
+                model.Add(start_var >= day_end_slot).OnlyEnforceIf(after_day)
+                
+                # Must be either before OR after (cannot be during)
+                model.AddBoolOr([before_day, after_day])
+
+    def _identify_affected_sections(self, schedule: Dict, faculty_id: str, day_index: int) -> Set[str]:
+        """
+        Identifies which sections have a class with the faculty on the leave day.
+        These are the sections that need their schedules relaxed to allow swapping.
+        """
+        affected_sections = set()
+        
+        for task_id, data in schedule.items():
+            # Check if this task is taught by the faculty on the specific day
+            if data['faculty_name'] == self.tasks_by_id[task_id].faculty.name: # Ideally match ID
+                # We use the faculty object from the task list to be safe
+                task_fac_id = self.tasks_by_id[task_id].faculty.id
+                
+                if task_fac_id == faculty_id and data['day_index'] == day_index:
+                    affected_sections.add(data['section_id'])
+                    
+        return affected_sections
+
+    def _freeze_and_relax_variables(
+        self,
+        model: cp_model.CpModel,
+        ce: ConstraintEngine,
+        current_schedule: Dict,
+        affected_section_ids: Set[str]
+    ):
+        """
+        Freezes tasks for unaffected sections.
+        Adds penalties for changing tasks for affected sections.
+        """
+        change_vars = []
+
+        for task in self.tasks:
+            # Get the CP variables for this task
+            start_var, _, _, room_var = ce.task_vars[task.task_id]
+            
+            # Get original values
+            if task.task_id in current_schedule:
+                original_start = current_schedule[task.task_id]['start_slot']
+                original_room_id = current_schedule[task.task_id]['room_id']
+                # Map room ID back to index
+                original_room_idx = ce.room_map[original_room_id]
+            else:
+                # Should not happen in a valid existing schedule, but safe fallback
+                continue
+
+            if task.section.section_id not in affected_section_ids:
+                # --- STRATEGY A: FREEZE UNAFFECTED ---
+                # This task belongs to a section that is NOT affected by the leave.
+                # Its schedule should remain exactly the same to preserve stability.
+                model.Add(start_var == original_start)
+                model.Add(room_var == original_room_idx)
+            else:
+                # --- STRATEGY B: RELAX AND PENALIZE AFFECTED ---
+                # This task belongs to a section that needs to reshuffle.
+                # We allow it to move, but we penalize it if it does.
+                
+                # Boolean: Is the new start time different from the old start time?
+                is_changed = model.NewBoolVar(f"changed_{task.task_id}")
+                model.Add(start_var != original_start).OnlyEnforceIf(is_changed)
+                model.Add(start_var == original_start).OnlyEnforceIf(is_changed.Not())
+                
+                # Weight the penalty.
+                # If this specific task is the one causing the conflict (taught by absent faculty),
+                # it MUST change, so the penalty is inevitable (and ignored by solver logic essentially).
+                # For other tasks (swapping candidates), the penalty discourages unnecessary moves.
+                change_vars.append(is_changed)
+
+        # Minimize the total number of tasks moved
+        if change_vars:
+            model.Minimize(sum(change_vars))
+
+    def _extract_solution(self, solver: cp_model.CpSolver, ce: ConstraintEngine) -> Dict:
+        """
+        Extracts the new schedule similar to the main solver.
+        """
+        schedule = {}
+        for task in self.tasks:
+            start_var, _, _, room_var = ce.task_vars[task.task_id]
+            
+            start_slot = solver.Value(start_var)
+            room_index = solver.Value(room_var)
+            assigned_room = self.rooms[room_index]
+            
+            day_index = start_slot // const.NUM_TEACHING_SLOTS_PER_DAY
+            daily_slot_index = start_slot % const.NUM_TEACHING_SLOTS_PER_DAY
+
+            schedule[task.task_id] = {
+                "task_obj": task,
+                "start_slot": start_slot,
+                "day_index": day_index,
+                "day_name": const.DAYS[day_index],
+                "period_index": daily_slot_index,
+                "room_id": assigned_room.room_id,
+                "room_name": f"{assigned_room.room_id} ({assigned_room.building})",
+                "faculty_name": task.faculty.name,
+                "subject_code": task.subject.subject_code,
+                "section_id": task.section.section_id,
+                "duration": task.duration
+            }
+        return schedule

requirements.txt

@@ -0,0 +1,11 @@
+streamlit
+fastapi
+uvicorn[standard]
+ortools
+pandas
+requests
+pydantic
+huggingface_hub
+
+python-multipart
+openpyxl

saved_schedule.json

@@ -0,0 +1,2585 @@
+{
+  "generated_at": "2026-11-04T18:30:49.974816",
+  "schedule": {
+    "DL&RL-7A-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7A-1": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7A-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DL&RL-7B-0": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL-7B-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL-7B-2": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Vijayashekar S S / Nandita Tarikeri",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL&RL Lab-7A-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B1",
+      "duration": 2
+    },
+    "DL&RL Lab-7A-B2-BLOCK": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B2",
+      "duration": 2
+    },
+    "DL&RL Lab-7B-B1-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Praveen Arokia Raj",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B1",
+      "duration": 2
+    },
+    "DL&RL Lab-7B-B2-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Praveen Arokia Raj",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B2",
+      "duration": 2
+    },
+    "ML II-7A-0": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7A-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7A-2": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "ML II-7B-0": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II-7B-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II-7B-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "ML II Lab-7A-B1-BLOCK": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B1",
+      "duration": 2
+    },
+    "ML II Lab-7A-B2-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B2",
+      "duration": 2
+    },
+    "ML II Lab-7B-B1-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B1",
+      "duration": 2
+    },
+    "ML II Lab-7B-B2-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B2",
+      "duration": 2
+    },
+    "DS&P-7A-0": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-1": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-2": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7A-3": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "DS&P-7B-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-1": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DS&P-7B-3": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7A-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7A-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BA-7B-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "MBA Faculty",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BA-7DS-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BA-7DS-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BA-7DS-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Yogesh Dixith",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "BDA-7A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7A-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7A-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "BDA-7B-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BDA-7B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "BDA-7B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "DL-7DS-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "DL-7DS-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "DL-7DS-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-0": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7A-2": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-1": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7B-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "OE (Sem 7)-7DS-2": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "OE Teacher 3 (Sem 7)",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP-7DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "PP Lab-7DS-B1-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B1",
+      "duration": 2
+    },
+    "PP Lab-7DS-B2-BLOCK": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B2",
+      "duration": 2
+    },
+    "SML for DS-7DS-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS-7DS-1": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS-7DS-2": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SML for DS Lab-7DS-B1-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B1",
+      "duration": 2
+    },
+    "SML for DS Lab-7DS-B2-BLOCK": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B2",
+      "duration": 2
+    },
+    "CNS-7DS-0": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "CNS-7DS-3": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Jovin Deglus",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "duration": 1
+    },
+    "SEPM-5A-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-1": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5A-3": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "SEPM-5B-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5B-3": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5A-0": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5A-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5A-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CN-5B-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5B-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN-5B-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CN Lab-5A-B1-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B1",
+      "duration": 2
+    },
+    "CN Lab-5A-B2-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B2",
+      "duration": 2
+    },
+    "CN Lab-5B-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B1",
+      "duration": 2
+    },
+    "CN Lab-5B-B2-BLOCK": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Dr. S Anu Pallavi",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B2",
+      "duration": 2
+    },
+    "TOC-5A-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-2": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-3": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5A-4": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "TOC-5B-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-1": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-2": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-3": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "TOC-5B-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "DV Lab-5B-B1-BLOCK": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Jovin Deglus / Ranjan Kumar",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B1",
+      "duration": 2
+    },
+    "DV Lab-5B-B2-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Jovin Deglus / Ranjan Kumar",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B2",
+      "duration": 2
+    },
+    "CV-5A-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5A-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5A-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EDA-5A-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "CV-5B-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CV-5B-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "CV-5B-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Syed Musadiq Illahi",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-0": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EDA-5B-2": {
+      "start_slot": 23,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 7,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "RM&IPR-5A-0": {
+      "start_slot": 37,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 5,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "RM&IPR-5B-0": {
+      "start_slot": 28,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EVS-5A-0": {
+      "start_slot": 5,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 5,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EVS-5A-1": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5A",
+      "duration": 1
+    },
+    "EVS-5B-0": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "EVS-5B-1": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5B",
+      "duration": 1
+    },
+    "SEPM-5DS-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-2": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "SEPM-5DS-3": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-1": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN-5DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "CN Lab-5DS-B1-BLOCK": {
+      "start_slot": 22,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B1",
+      "duration": 2
+    },
+    "CN Lab-5DS-B2-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Nanda Kumar N",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B2",
+      "duration": 2
+    },
+    "TOC-5DS-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-2": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "TOC-5DS-4": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DV Lab-5DS-B1-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Syed Musadiq Illahi / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B1",
+      "duration": 2
+    },
+    "DV Lab-5DS-B2-BLOCK": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Praveen Arokia Raj / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B2",
+      "duration": 2
+    },
+    "NoSQL DB-5DS-0": {
+      "start_slot": 13,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 5,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "NoSQL DB-5DS-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "NoSQL DB-5DS-2": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-0": {
+      "start_slot": 13,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 5,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-1": {
+      "start_slot": 4,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "DW-5DS-2": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Abhijith S",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "RM&IPR-5DS-0": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Basavaraj",
+      "subject_code": "RM&IPR",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "EVS-5DS-0": {
+      "start_slot": 7,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 7,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "EVS-5DS-1": {
+      "start_slot": 30,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 6,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "CIVIL_1",
+      "subject_code": "EVS",
+      "section_id": "5DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-1": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-2": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-3": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3A-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-0": {
+      "start_slot": 26,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-2": {
+      "start_slot": 9,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-3": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3B-4": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3A-0": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-1": {
+      "start_slot": 19,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-2": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3A-4": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DDCO-3B-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-1": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-2": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DDCO-3B-4": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Ranjan Kumar",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3A-0": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3A-1": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3A-2": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OS-3B-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3B-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "OS-3B-2": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Ms. Vinutha M",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3A-0": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3A-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3A-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Ms. Surbhi",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "DSA-3B-0": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3B-1": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA-3B-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "DSA Lab-3A-B1-BLOCK": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Surbhi / Nanda Kumar N",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B1",
+      "duration": 2
+    },
+    "DSA Lab-3A-B2-BLOCK": {
+      "start_slot": 20,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 4,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Nanda Kumar N / Surbhi",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B2",
+      "duration": 2
+    },
+    "DSA Lab-3B-B1-BLOCK": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Surbhi / Mhd Tahir Mirji",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B1",
+      "duration": 2
+    },
+    "OOP with Java-3A-0": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "OOP with Java-3B-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "EDA Lab-3A-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "EDA Lab-3B-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "PM with Git-3A-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "PM with Git-3B-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "Maths LE-3A-0": {
+      "start_slot": 36,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 4,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3A",
+      "duration": 1
+    },
+    "Maths LE-3B-0": {
+      "start_slot": 21,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 5,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3B",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-0": {
+      "start_slot": 32,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 0,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-1": {
+      "start_slot": 18,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 2,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-2": {
+      "start_slot": 11,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 3,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-3": {
+      "start_slot": 0,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 0,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "Maths (Prob & Stats)-3DS-4": {
+      "start_slot": 27,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 3,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-0": {
+      "start_slot": 24,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-1": {
+      "start_slot": 8,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 0,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-2": {
+      "start_slot": 17,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 1,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-3": {
+      "start_slot": 2,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 2,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DDCO-3DS-4": {
+      "start_slot": 33,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Chalasani Jayanth",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-0": {
+      "start_slot": 10,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 2,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-1": {
+      "start_slot": 3,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 3,
+      "room_id": "AI09 1F 25",
+      "room_name": "AI09 1F 25 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "OS-3DS-2": {
+      "start_slot": 34,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 2,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-0": {
+      "start_slot": 16,
+      "day_index": 2,
+      "day_name": "Wednesday",
+      "period_index": 0,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-1": {
+      "start_slot": 1,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 1,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA-3DS-2": {
+      "start_slot": 35,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 3,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Mhd Tahir Mirji",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DSA Lab-3DS-B1-BLOCK": {
+      "start_slot": 6,
+      "day_index": 0,
+      "day_name": "Monday",
+      "period_index": 6,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Nanda Kumar N / Sanjay P",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B1",
+      "duration": 2
+    },
+    "OOP with Java-3DS-0": {
+      "start_slot": 25,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 1,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Nandita Tarikeri",
+      "subject_code": "OOP with Java",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "EDA Lab-3DS-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 3F 01",
+      "room_name": "AI09 3F 01 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "Maths LE-3DS-0": {
+      "start_slot": 31,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 7,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Maths Department",
+      "subject_code": "Maths LE",
+      "section_id": "3DS",
+      "duration": 1
+    },
+    "DV Lab-5A-B1-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "S Anu Pallavi / Jovin Deglus",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B1",
+      "duration": 2
+    },
+    "DV Lab-5A-B2-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI03 2F 01",
+      "room_name": "AI03 2F 01 (ASD BLOCK)",
+      "faculty_name": "Abhijith S / Chalasani Jayanth",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B2",
+      "duration": 2
+    },
+    "DSA Lab-3B-B2-BLOCK": {
+      "start_slot": 29,
+      "day_index": 3,
+      "day_name": "Thursday",
+      "period_index": 5,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Mhd Tahir Mirji / Surbhi",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B2",
+      "duration": 2
+    },
+    "DSA Lab-3DS-B2-BLOCK": {
+      "start_slot": 14,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 6,
+      "room_id": "AI03 2F 02",
+      "room_name": "AI03 2F 02 (ASD BLOCK)",
+      "faculty_name": "Mhd Tahir Mirji / Nanda Kumar N",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B2",
+      "duration": 2
+    },
+    "PM with Git-3DS-BLOCK": {
+      "start_slot": 12,
+      "day_index": 1,
+      "day_name": "Tuesday",
+      "period_index": 4,
+      "room_id": "AI09 1F26",
+      "room_name": "AI09 1F26 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "EDA Lab 2-3A-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 14",
+      "room_name": "AI09 2F 14 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "EDA Lab 2-3B-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 13",
+      "room_name": "AI09 2F 13 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "EDA Lab 2-3DS-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 08",
+      "room_name": "AI09 3F 08 (ECE BLOCK)",
+      "faculty_name": "Dr. Kavitha Nair R",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3DS",
+      "duration": 2
+    },
+    "PM with Git 2-3A-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 08",
+      "room_name": "AI09 2F 08 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3A",
+      "duration": 2
+    },
+    "PM with Git 2-3B-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 3F 03",
+      "room_name": "AI09 3F 03 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3B",
+      "duration": 2
+    },
+    "PM with Git 2-3DS-BLOCK": {
+      "start_slot": 38,
+      "day_index": 4,
+      "day_name": "Friday",
+      "period_index": 6,
+      "room_id": "AI09 2F 12",
+      "room_name": "AI09 2F 12 (ECE BLOCK)",
+      "faculty_name": "Mr. Sanjay P",
+      "subject_code": "PM with Git 2",
+      "section_id": "3DS",
+      "duration": 2
+    }
+  }
+}

slm_inference.py

@@ -0,0 +1,384 @@
+# slm_inference.py
+import re, requests
+from typing import List, Dict, Any, Optional
+
+API_URL = 'https://vishwasmsme-timetable-slm-api.hf.space'
+DAY_WORDS = {
+    'monday':'MON','tuesday':'TUE','wednesday':'WED',
+    'thursday':'THU','friday':'FRI','saturday':'SAT',
+    'mon':'MON','tue':'TUE','wed':'WED',
+    'thu':'THU','fri':'FRI','sat':'SAT',
+}
+
+def get_constraint(instruction):
+    try:
+        r = requests.post(f'{API_URL}/constraint',json={'instruction':instruction},timeout=60)
+        r.raise_for_status(); return r.json()
+    except Exception as e:
+        return {'success':False,'error':str(e),'constraints':[]}
+
+def get_constraints_batch(instructions):
+    try:
+        r = requests.post(f'{API_URL}/constraints/batch',json={'instructions':instructions},timeout=120)
+        r.raise_for_status(); return r.json().get('all_constraints',[])
+    except Exception as e:
+        print(f'API Error: {e}'); return []
+
+def check_api_health():
+    try:
+        return requests.get(f'{API_URL}/health',timeout=10).json().get('model_loaded',False)
+    except: return False
+
+def smart_parse(prompt, faculties_data, subjects_data=None, sections_data=None):
+    p = prompt.lower().strip()
+    fac_map = _build_fac_map(faculties_data)
+    sub_map = _build_sub_map(subjects_data or [])
+    days    = _extract_all_days(p)
+    period  = _extract_period(p)
+
+    # NO FREE PERIOD — "first hour should not be free", "period 1 must have a class"
+    no_free_kw = ['should not be free', 'must not be free', 'cannot be free',
+                  'should always be occupied', 'always be occupied', 'always occupied',
+                  'no free slot in', 'free slot in period', 'no free in',
+                  'must have a class', 'should have a class', 'always occupied',
+                  'no free period', 'no free slot', 'must be filled',
+                  'first hour should not', 'last period should not']
+    if any(kw in p for kw in no_free_kw):
+        # Detect which period(s) are required
+        periods = []
+        if any(w in p for w in ['first hour', 'period 1', 'p1', 'first period', 'slot 1']):
+            periods = [0]   # 0-indexed: P1
+        elif any(w in p for w in ['last hour', 'last period', 'last slot']):
+            periods = [-1]  # will resolve to last period dynamically
+        elif any(w in p for w in ['second period', 'period 2', 'p2']):
+            periods = [1]
+        elif any(w in p for w in ['third period', 'period 3', 'p3']):
+            periods = [2]
+        else:
+            # Try to extract any period number mentioned
+            nums = re.findall(r'period\s*(\d+)|p\s*(\d+)|slot\s*(\d+)', p)
+            for g in nums:
+                n = next((int(x) for x in g if x), None)
+                if n: periods.append(n - 1)
+        if not periods:
+            periods = [0]  # default: first period
+        return {
+            'type':      'NO_FREE_PERIOD',
+            'periods':   periods,
+            'section_id': _extract_section(p, sections_data),
+        }
+
+    # FACULTY SUBSTITUTION
+    if any(kw in p for kw in ['replace','substitute','take over','will take','on leave',
+                                'covering','cover for','instead of','will cover','deputed']):
+        facs = _find_two_faculties(p, fac_map)
+        if facs:
+            return {'type':'FACULTY_SUBSTITUTION','from_faculty_id':facs[0],
+                    'to_faculty_id':facs[1],'days':days,
+                    'subject_codes':_extract_subjects(p,sub_map)}
+
+    # FACULTY UNAVAILABLE / LEAVE (Single faculty)
+    if any(kw in p for kw in ['not available', 'unavailable', 'on leave', 'free on', 'day off', 'absent']):
+        single_fac = _extract_one_faculty(p, fac_map)
+        if single_fac and days:
+            return {
+                'type': 'CANCEL_CLASS',
+                'day': days[0],
+                'period': period,
+                'subject_code': None,
+                'section_id': _extract_section(p, sections_data),
+                'faculty_id': single_fac,
+            }
+
+    # NO SUBJECT ON DAY — "No TOC on Thursday", "No NLP class on Friday for 5A"
+    no_subj_kw = ['no toc', 'no nlp', 'no ml', 'no cn', 'no sepm', 'no nosql',
+                  'no rmipr', 'no iks', 'no evs', 'no dvlab', 'no cnlab',
+                  'no nlplab', 'no mllab', 'no miniproj', 'no major', 'no genai',
+                  'no devops', 'no hcai', 'no cc ', 'no forum', 'no softskill']
+    has_no_subj = any(kw in p for kw in no_subj_kw)
+    # Also catch "no [subject_name] class/on/for"
+    has_no_class = bool(re.search(r'no\s+\w+\s+(class|on|for)', p))
+    if has_no_subj or has_no_class:
+        subs = _extract_subjects(p, sub_map)
+        if subs and days:
+            return {
+                'type':         'CANCEL_CLASS',
+                'subject_code': subs[0],
+                'day':          days[0],
+                'section_id':   _extract_section(p, sections_data),
+                'faculty_id':   None,
+                'period':       None,
+            }
+
+    # CANCEL / HOLIDAY
+    holiday_kws = ['holiday','off day','public holiday','is a holiday','college is closed',
+                   'closed on','college closed','no classes on','no classes for all',
+                   'is holiday']
+    cancel_kws2 = ['cancel','no class','no lecture','cancelled','remove','delete','drop']
+    is_holiday = any(kw in p for kw in holiday_kws)
+    is_cancel  = any(kw in p for kw in cancel_kws2)
+
+    # Whole-day clear: holiday OR (cancel/no classes with NO subject mentioned)
+    subs_found = _extract_subjects(p, sub_map)
+    fid_found  = _extract_one_faculty(p, fac_map)
+    whole_day  = is_holiday or (is_cancel and not subs_found and not fid_found and not period)
+
+    if (is_holiday or is_cancel) and days:
+        if whole_day:
+            return {'type':'MARK_HOLIDAY', 'days':days,
+                    'section_id':_extract_section(p, sections_data)}
+        return {'type':'CANCEL_CLASS', 'day':days[0], 'period':period,
+                'subject_code': subs_found[0] if subs_found else None,
+                'section_id':   _extract_section(p, sections_data),
+                'faculty_id':   fid_found}
+
+    # CHANGE ROOM — detect "to Lab 2", "to R3", "shift all labs to L3"
+    # Must run BEFORE move/reschedule to prevent "Move NLPLAB to Lab 2" → RESCHEDULE_LAB
+    room_match = re.search(r'\b(lab\s*\d+|l\d+|r\d+|room\s*\d+)\b', p)
+    room_val = room_match.group(1).replace(' ','').upper() if room_match else None
+    room_dest_kws = ['to lab ', 'to l', 'to r', 'to room', 'change room',
+                     'assign room', 'move to lab', 'move to room', 'labs to']
+    has_room_dest = any(kw in p for kw in room_dest_kws) and room_val
+    if has_room_dest:
+        subs_r = _extract_subjects(p, sub_map)
+        return {'type':         'CHANGE_ROOM',
+                'new_room_id':  room_val,
+                'room_id':      room_val,
+                'subject_code': subs_r[0] if subs_r else None,
+                'section_id':   _extract_section(p, sections_data),
+                'day':          days[0] if days else None,
+                'all_labs':     'all' in p and 'lab' in p}
+
+    # MOVE / RESCHEDULE — only if NOT a cancel/remove keyword
+    move_kws = ['move','shift','reschedule','transfer','relocate']
+    cancel_kws = ['cancel','remove','delete','drop','no class','holiday']
+    is_move   = any(kw in p for kw in move_kws)
+    is_cancel = any(kw in p for kw in cancel_kws)
+    if is_move and not is_cancel:
+        subs = _extract_subjects(p, sub_map)
+        is_lab = ('lab' in p or (subs and any(s.lower().endswith('lab') for s in subs)))
+        if is_lab and subs:
+            # "from X to Y" → days[0]=from, days[1]=to
+            # "to Y" only   → days[0]=to, from_day=None
+            from_day = days[0] if len(days) >= 2 else None
+            to_day   = days[1] if len(days) >= 2 else (days[0] if days else None)
+            return {'type':'RESCHEDULE_LAB',
+                    'subject_code': subs[0],
+                    'section_id':   _extract_section(p, sections_data),
+                    'from_day':     from_day,
+                    'to_day':       to_day,
+                    'to_period':    period or 1}
+        if len(days) >= 2:
+            subs = _extract_subjects(p, sub_map)
+            return {'type':'MOVE_CLASS',
+                    'from_day':     days[0],
+                    'to_day':       days[1],
+                    'subject_code': subs[0] if subs else None,
+                    'section_id':   _extract_section(p, sections_data),
+                    'faculty_id':   _extract_one_faculty(p, fac_map)}
+
+    # CHANGE ROOM
+    if any(kw in p for kw in ['change room','move to room','to lab','to room','assign room']):
+        rm = re.search(r'\b([rl]\d+|lab\s*\d*|room\s*\d+)\b', p)
+        return {'type':'CHANGE_ROOM',
+                'room_id':rm.group(1).replace(' ','') if rm else None,
+                'subject_code':(_extract_subjects(p,sub_map) or [None])[0],
+                'section_id':_extract_section(p,sections_data),
+                'day':days[0] if days else None}
+
+    # ADD EXTRA / MAKEUP
+    # Check for "schedule [subject] session/class" pattern like "Schedule extra ML session"
+    import re as _re
+    has_schedule_class = bool(_re.search(
+        r'(schedule|add)\s+(extra|additional|makeup|compensatory)?\s*\w+\s*(class|session)', p))
+    extra_keywords = ['extra class','makeup','additional class','make up',
+                      'compensatory','add class','schedule extra','extra session',
+                      'additional session','schedule.*class','add.*session']
+    if has_schedule_class or any(kw in p for kw in extra_keywords):
+        subs = _extract_subjects(p, sub_map)
+        return {'type':'ADD_EXTRA_CLASS',
+                'subject_code':subs[0] if subs else None,
+                'section_id':_extract_section(p,sections_data),
+                'faculty_id':_extract_one_faculty(p,fac_map),
+                'day':days[0] if days else None,
+                'period': period or (5 if 'afternoon' in p else
+                                     1 if 'morning' in p else None)}
+
+    # CHANGE FACULTY (permanent)
+    perm_kws = ['permanently','all classes','change faculty','hand over',
+                'assign all','transfer all']
+    if any(kw in p for kw in perm_kws):
+        facs  = _find_two_faculties(p, fac_map) or []
+        scodes = _extract_subjects(p, sub_map)
+        # "Assign all X to Y" / "Transfer A's classes to B" → to_fac = LAST mentioned
+        # "Change faculty from A to B" → from=A (first), to=B (second)
+        if len(facs) >= 2:
+            # "from A to B" order → from=facs[0], to=facs[1]
+            if 'from' in p and 'to' in p:
+                from_fac, to_fac = facs[0], facs[1]
+            else:
+                # "assign all ... to Syed" → to_fac is the one after "to"
+                to_idx = p.rfind(' to ')
+                if to_idx > 0:
+                    after_to = p[to_idx+4:]
+                    to_fac   = next((fi for n,fi in fac_map.items() if n and n in after_to), facs[-1])
+                    from_fac = next((fi for fi in facs if fi != to_fac), facs[0])
+                else:
+                    from_fac, to_fac = facs[0], facs[1]
+        elif len(facs) == 0:
+            # Try single faculty extraction
+            single = _extract_one_faculty(p, fac_map)
+            from_fac, to_fac = None, single
+        elif len(facs) == 1:
+            # Only one faculty mentioned — they're the target (to_fac)
+            from_fac, to_fac = None, facs[0]
+        else:
+            from_fac, to_fac = None, None
+        if to_fac or (scodes and not facs):
+            # If no faculty found but subject found, still create constraint
+            # (partial — will match by subject code only)
+            return {'type':'CHANGE_FACULTY',
+                    'from_faculty_id': from_fac,
+                    'to_faculty_id':   to_fac,
+                    'subject_codes':   scodes,
+                    'subject_code':    scodes[0] if scodes else None,
+                    'section_id':_extract_section(p,sections_data)}
+
+    # SWAP
+    if any(kw in p for kw in ['swap','exchange']):
+        import re as _re
+        periods = _re.findall(r'p(?:eriod)?\s*(\d+)', p)
+        subs    = _extract_subjects(p, sub_map)
+        # Extract faculty ids in order of appearance in prompt
+        fac_found = sorted(
+            [(name, fid, p.index(name)) for name, fid in fac_map.items()
+             if name and name in p],
+            key=lambda x: x[2]
+        )
+        # Deduplicate by fid keeping first occurrence
+        seen, fac_ids = set(), []
+        for _, fid, _ in fac_found:
+            if fid not in seen:
+                fac_ids.append(fid); seen.add(fid)
+        return {'type':          'SWAP_CLASSES',
+                'day1':          days[0] if len(days) > 0 else None,
+                'day2':          days[1] if len(days) > 1 else None,
+                'period1':       int(periods[0]) if len(periods) > 0 else None,
+                'period2':       int(periods[1]) if len(periods) > 1 else None,
+                'subject_code1': subs[0]    if len(subs)    > 0 else None,
+                'subject_code2': subs[1]    if len(subs)    > 1 else None,
+                'subject_codes': subs,
+                'faculty_id1':   fac_ids[0] if len(fac_ids) > 0 else None,
+                'faculty_id2':   fac_ids[1] if len(fac_ids) > 1 else None,
+                'section_id':    _extract_section(p, sections_data)}
+
+    # FREEZE
+    if any(kw in p for kw in ['freeze','lock slot','fix this slot','keep this',
+                                'lock ','don\'t move','do not move','should not change',
+                                'it should not change','fix mllab','fix nlplab',
+                                'fix cnlab','fix dvlab']):
+        subs = _extract_subjects(p, sub_map)
+        return {'type':'FREEZE_SLOT','day':days[0] if days else None,'period':period,
+                'subject_code':subs[0] if subs else None,
+                'section_id':_extract_section(p,sections_data)}
+
+    return None
+
+def _build_fac_map(fds):
+    m = {}
+    for f in fds:
+        m[f['name'].lower()] = f['id']
+        short = re.sub(r'(prof\.|dr\.|mr\.|ms\.)\s*','',f['name'],flags=re.I).strip()
+        m[short.lower()] = f['id']
+        m[f['id'].lower()] = f['id']
+    return m
+
+def _build_sub_map(sds):
+    m = {}
+    for s in sds:
+        m[s['name'].lower()] = s['code']
+        m[s['code'].lower()]  = s['code']
+    return m
+
+def _extract_all_days(text):
+    found, seen = [], set()
+    for w, d in DAY_WORDS.items():
+        idx = text.find(w)
+        if idx >= 0 and d not in seen:
+            found.append((idx,d)); seen.add(d)
+    found.sort(); return [d for _,d in found]
+
+def _extract_period(text):
+    m = re.search(r'p(?:eriod)?\s*(\d+)', text)
+    return int(m.group(1)) if m else None
+
+def _extract_subjects(text, sub_map):
+    # Sort by name length descending so "nlplab" matches before "nlp"
+    sorted_items = sorted(sub_map.items(), key=lambda x: -len(x[0]))
+    seen_codes, seen_names, results = set(), set(), []
+    for name, code in sorted_items:
+        if not name or name not in text: continue
+        if code in seen_codes: continue
+        # Skip if a longer name already matched that contains this name
+        # e.g. skip "nlp" if "nlplab" already matched
+        already_covered = any(matched for matched in seen_names if name in matched)
+        if already_covered: continue
+        results.append(code)
+        seen_codes.add(code)
+        seen_names.add(name)
+    return results
+
+def _extract_one_faculty(text, fac_map):
+    for name,fid in fac_map.items():
+        if name and name in text: return fid
+    return None
+
+def _find_two_faculties(text, fac_map):
+    found = []
+    for name,fid in sorted(fac_map.items(), key=lambda x:-len(x[0])):
+        if name and name in text and fid not in found:
+            found.append(fid)
+        if len(found)==2: break
+    return found if len(found)==2 else None
+
+def _extract_section(text, sections_data):
+    if not sections_data: return None
+    # Sort by length descending so "6a-e1" matches before "6a"
+    for s in sorted(sections_data, key=lambda x: -len(x['id'])):
+        if s['id'].lower() in text:
+            return s['id']
+    # Match shorthand like "6a" -> return prefix as parent filter
+    # e.g. "6a" matches 6a-E1 AND 6a-E2 -> return "6A" (prefix)
+    # caller uses this to filter all sub-sections of 6A
+    prefixes = {}
+    for s in sections_data:
+        prefix = s['id'].split('-')[0].lower()
+        prefixes.setdefault(prefix, []).append(s['id'])
+    for prefix, ids in sorted(prefixes.items(), key=lambda x: -len(x[0])):
+        pattern = r'(?<![a-z0-9])' + re.escape(prefix) + r'(?![a-z0-9])'
+        if re.search(pattern, text):
+            if len(ids) == 1:
+                return ids[0]        # unique — return full id
+            else:
+                return prefix.upper()  # ambiguous — return parent "6A", "5A" etc.
+    return None
+    # Sort by length descending so "6a-e1" matches before "6a"
+    for s in sorted(sections_data, key=lambda x: -len(x['id'])):
+        if s['id'].lower() in text:
+            return s['id']
+    # Match shorthand like "6a" -> returns None if multiple sections share prefix
+    # e.g. "6a" matches 6a-E1 AND 6a-E2, so return None (move all of them)
+    prefixes = {}
+    for s in sections_data:
+        prefix = s['id'].split('-')[0].lower()
+        prefixes.setdefault(prefix, []).append(s['id'])
+    for prefix, ids in prefixes.items():
+        if re.search(r'' + prefix + r'', text):
+            if len(ids) == 1:
+                return ids[0]  # unique match
+            # multiple sections with same prefix — return None (affects all)
+    return None
+
+def parse_substitution_prompt(prompt, faculties_data):
+    result = smart_parse(prompt, faculties_data)
+    return result if result and result.get('type')=='FACULTY_SUBSTITUTION' else {}

solver.py

@@ -0,0 +1,149 @@
+# solver.py
+
+from typing import List, Dict, Optional, Any, Tuple
+from ortools.sat.python import cp_model
+import os
+
+from models import Task, Faculty, Section, Room
+from constraint_engine import ConstraintEngine
+
+class TimetableSolver:
+
+    def __init__(self, tasks, faculties, sections, rooms):
+        self.tasks     = tasks
+        self.faculties = faculties
+        self.sections  = sections
+        self.rooms     = rooms
+        self.model     = cp_model.CpModel()
+        self.solver    = cp_model.CpSolver()
+        self.constraint_engine = None
+        self.objective_engine  = None
+
+    def solve(
+        self,
+        time_limit_seconds: int = 60,
+        enable_soft_constraints: bool = True,
+        soft_constraint_weights: Dict[str, int] = None,
+        log_search_progress: bool = True,
+        num_workers: int = None,
+        slm_constraints: List[Dict[str, Any]] = None,
+        scheduling_rules: List[Dict[str, Any]] = None,
+        locked_schedule: Dict[str, Any] = None,
+        locked_semesters: List[int] = None,
+    ) -> Tuple[str, Optional[Dict[str, Any]]]:
+        if num_workers is None:
+            num_workers = os.cpu_count() or 8
+
+        # 1. Hard constraints
+        print("Initializing Constraint Engine...")
+        self.constraint_engine = ConstraintEngine(
+            model=self.model, tasks=self.tasks, faculties=self.faculties,
+            sections=self.sections, rooms=self.rooms,
+            slm_constraints=slm_constraints, scheduling_rules=scheduling_rules,
+            locked_schedule=locked_schedule, locked_semesters=locked_semesters
+        )
+        self.constraint_engine.apply_all_constraints()
+
+        # 2. Soft constraints
+        if enable_soft_constraints:
+            print("Initializing Objective Engine...")
+            from objective_engine import ObjectiveEngine
+            self.objective_engine = ObjectiveEngine(
+                model=self.model,
+                ce=self.constraint_engine,
+                tasks=self.tasks, faculties=self.faculties,
+                sections=self.sections,
+                weights=soft_constraint_weights
+            )
+            self.objective_engine.build_objective()
+
+        # 4. Configure solver
+        self.solver.parameters.max_time_in_seconds  = time_limit_seconds
+        self.solver.parameters.log_search_progress  = log_search_progress
+        self.solver.parameters.num_search_workers   = num_workers
+
+        # 5. Solve
+        print(f"Starting solver (Limit: {time_limit_seconds}s)...")
+        status_val = self.solver.Solve(self.model)
+
+        status_map = {
+            cp_model.OPTIMAL:       "OPTIMAL",
+            cp_model.FEASIBLE:      "FEASIBLE",
+            cp_model.INFEASIBLE:    "INFEASIBLE",
+            cp_model.MODEL_INVALID: "MODEL_INVALID",
+            cp_model.UNKNOWN:       "UNKNOWN"
+        }
+        status_str = status_map.get(status_val, "UNKNOWN")
+        print(f"Solver finished: {status_str}")
+
+        solution = None
+        if status_val in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+            solution = self._extract_solution()
+            print(f"Solution found! Objective: {self.solver.ObjectiveValue()}")
+        else:
+            print("No solution found.")
+
+        return status_str, solution
+
+    def _extract_solution(self):
+        import constants as const
+        schedule = {}
+        for task in self.tasks:
+            start_var, _, _, room_var = self.constraint_engine.task_vars[task.task_id]
+            start_slot   = self.solver.Value(start_var)
+            room_index   = self.solver.Value(room_var)
+            assigned_room = self.rooms[room_index]
+            day_index    = start_slot // const.NUM_TEACHING_SLOTS_PER_DAY
+            period_index = start_slot  % const.NUM_TEACHING_SLOTS_PER_DAY
+            schedule[task.task_id] = {
+                "task_obj":     task,
+                "start_slot":   start_slot,
+                "day_index":    day_index,
+                "day_name":     const.DAYS[day_index],
+                "period_index": period_index,
+                "room_id":      assigned_room.room_id,
+                "room_name":    f"{assigned_room.room_id} ({assigned_room.building})",
+                "faculty_name": task.faculty.name,
+                "subject_code": task.subject.subject_code,
+                "section_id":   task.section.section_id,
+                "duration":     task.duration
+            }
+        return schedule
+
+    def diagnose_infeasibility(self) -> str:
+        """Heuristic checks to explain common reasons for INFEASIBLE models."""
+        import constants as const
+        # 1. Check Faculty Overload
+        fac_hours = {}
+        for t in self.tasks:
+            if 'DUMMY' in t.faculty.id: continue
+            for fid in t.faculty.id.split('_'):
+                fac_hours[fid] = fac_hours.get(fid, 0) + t.duration
+        
+        for fid, hrs in fac_hours.items():
+            if hrs > const.TOTAL_TEACHING_SLOTS_PER_WEEK:
+                fac = next((f.name for f in self.faculties if f.id == fid), fid)
+                return f"Faculty overload: {fac} ({fid}) is assigned {hrs} hours of classes, but there are only {const.TOTAL_TEACHING_SLOTS_PER_WEEK} total slots available in the week."
+        
+        # 2. Check Section Overload
+        sec_parent_hours = {}
+        sec_batch_hours = {}
+        for t in self.tasks:
+            sec = t.section.section_id
+            if '-' in sec:
+                parent = sec.split('-')[0]
+                if parent not in sec_batch_hours:
+                    sec_batch_hours[parent] = {}
+                sec_batch_hours[parent][sec] = sec_batch_hours[parent].get(sec, 0) + t.duration
+            else:
+                sec_parent_hours[sec] = sec_parent_hours.get(sec, 0) + t.duration
+                
+        for sid, hrs in sec_parent_hours.items():
+            max_batch = 0
+            if sid in sec_batch_hours:
+                max_batch = max(sec_batch_hours[sid].values())
+            total = hrs + max_batch
+            if total > const.TOTAL_TEACHING_SLOTS_PER_WEEK:
+                return f"Section overload: Section {sid} (including its batches) requires {total} hours of classes, but there are only {const.TOTAL_TEACHING_SLOTS_PER_WEEK} slots available in the week."
+
+        return "The constraint engine could not find a solution due to conflicting constraints. This typically happens if multiple subjects are forced to occur at the same time, or if teachers/rooms are double-booked by rigid scheduling rules."

storage.py

@@ -0,0 +1,273 @@
+# storage.py
+# Handles all persistent storage: timetable data, saved schedules, change history
+# Uses HuggingFace Hub CommitScheduler to persist data across Space restarts.
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional
+from pathlib import Path
+import threading
+import uuid
+
+# ── HuggingFace Persistent Storage Setup ─────────────────────────────────
+# On HuggingFace Spaces, files written at runtime are EPHEMERAL.
+# CommitScheduler auto-commits changed files back to the repo periodically.
+
+_scheduler = None
+_scheduler_lock = threading.Lock()
+
+# Directory where persistent JSON files are stored
+DATA_DIR = Path(__file__).resolve().parent  # Always use the directory where storage.py is located
+
+DATA_FILE     = str(DATA_DIR / 'timetable_data.json')
+SCHEDULE_FILE = str(DATA_DIR / 'saved_schedule.json')
+HISTORY_FILE  = str(DATA_DIR / 'change_history.json')
+LEAVE_FILE    = str(DATA_DIR / 'leave_requests.json')
+SUB_REQ_FILE  = str(DATA_DIR / 'substitution_requests.json')
+ORIGINAL_FILE = str(DATA_DIR / 'original_schedule.json')
+VERSIONS_FILE = str(DATA_DIR / 'schedule_versions.json')
+PENDING_FILE  = str(DATA_DIR / 'pending_timetables.json')
+CANCELLATION_FILE = str(DATA_DIR / 'cancellations.json')
+
+def _get_scheduler():
+    """Lazily initialize the CommitScheduler (only on HuggingFace Spaces)."""
+    global _scheduler
+    if _scheduler is not None:
+        return _scheduler
+    
+    with _scheduler_lock:
+        if _scheduler is not None:
+            return _scheduler
+        
+        # Only enable on HuggingFace Spaces (SPACE_ID env var is set)
+        space_id = os.environ.get("SPACE_ID")
+        if not space_id:
+            return None  # Running locally, no scheduler needed
+        
+        try:
+            from huggingface_hub import CommitScheduler, HfApi
+
+            # Workaround: CommitScheduler internally calls create_repo()
+            # which requires space_sdk for Spaces, but CommitScheduler
+            # doesn't accept/forward that parameter. Temporarily patch
+            # create_repo to inject space_sdk='docker' as a default.
+            _orig_create = HfApi.create_repo
+
+            def _patched_create(self, *args, **kwargs):
+                kwargs.setdefault("space_sdk", "docker")
+                return _orig_create(self, *args, **kwargs)
+
+            HfApi.create_repo = _patched_create
+
+            _scheduler = CommitScheduler(
+                repo_id=space_id,
+                repo_type="space",
+                folder_path=str(DATA_DIR),
+                path_in_repo=".",
+                every=2,  # Commit every 2 minutes
+                allow_patterns=[
+                    "*.json",       # All JSON data files
+                ],
+                squash_history=True,  # Keep repo history clean
+            )
+
+            # Restore original create_repo
+            HfApi.create_repo = _orig_create
+
+            print(f"[storage] CommitScheduler initialized for {space_id}")
+        except Exception as e:
+            print(f"[storage] CommitScheduler failed to initialize: {e}")
+            _scheduler = None
+        
+        return _scheduler
+
+
+def _safe_write_json(filepath: str, data):
+    """Write JSON to file. The CommitScheduler will auto-commit changes."""
+    # Get scheduler to ensure it's initialized (will auto-detect file changes)
+    _get_scheduler()
+    
+    with open(filepath, 'w') as f:
+        json.dump(data, f, indent=2)
+
+
+def _safe_read_json(filepath: str, default=None):
+    """Read JSON from file with error handling."""
+    if not os.path.exists(filepath):
+        return default
+    try:
+        with open(filepath, 'r') as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return default
+
+
+# ── Timetable Data (faculties, subjects, sections etc.) ──────────────────
+def load_data() -> Dict:
+    result = _safe_read_json(DATA_FILE)
+    if result:
+        return result
+    return {'faculties': [], 'subjects': [], 'sections': [],
+            'rooms': [], 'allocations': []}
+
+def save_data(data: Dict):
+    _safe_write_json(DATA_FILE, data)
+
+# ── Saved Schedule (the fixed semester timetable) ────────────────────────
+def save_schedule(solution: Dict[str, Any]):
+    """Save the generated timetable as the fixed semester schedule."""
+    serializable = {}
+    for task_id, info in solution.items():
+        serializable[task_id] = {k: v for k, v in info.items() if k != 'task_obj'}
+    
+    payload = {
+        'generated_at': datetime.now().isoformat(),
+        'schedule': serializable
+    }
+    _safe_write_json(SCHEDULE_FILE, payload)
+
+def load_schedule() -> Optional[Dict]:
+    """Load the saved semester schedule."""
+    return _safe_read_json(SCHEDULE_FILE)
+
+def schedule_exists() -> bool:
+    return os.path.exists(SCHEDULE_FILE)
+
+def clear_schedule():
+    if os.path.exists(SCHEDULE_FILE):
+        os.remove(SCHEDULE_FILE)
+
+# ── Original Schedule (snapshot taken at generation time) ───────────────
+
+def save_original_schedule(solution: Dict[str, Any]):
+    """Save a permanent snapshot of the originally generated timetable."""
+    serializable = {}
+    for task_id, info in solution.items():
+        serializable[task_id] = {k: v for k, v in info.items() if k != 'task_obj'}
+    payload = {
+        'generated_at': datetime.now().isoformat(),
+        'schedule': serializable
+    }
+    _safe_write_json(ORIGINAL_FILE, payload)
+
+def load_original_schedule() -> Optional[Dict]:
+    """Load the original (never-modified) timetable snapshot."""
+    return _safe_read_json(ORIGINAL_FILE)
+
+def original_schedule_exists() -> bool:
+    return os.path.exists(ORIGINAL_FILE)
+
+def clear_original_schedule():
+    if os.path.exists(ORIGINAL_FILE):
+        os.remove(ORIGINAL_FILE)
+
+# ── Change History ────────────────────────────────────────────────────────
+def load_history() -> list:
+    return _safe_read_json(HISTORY_FILE, default=[])
+
+def add_history_entry(operation_type: str, description: str, affected_sections: list, changes: list, status: str = "SUCCESS", constraints: list = None):
+    history = load_history()
+    history.append({
+        'id': str(uuid.uuid4()),
+        'timestamp': datetime.now().isoformat(),
+        'operation_type': operation_type,
+        'description': description,
+        'affected_sections': affected_sections or [],
+        'changes': changes or [],
+        'status': status,
+        'constraints': constraints or [],
+    })
+    _safe_write_json(HISTORY_FILE, history)
+
+def save_history(history: list):
+    _safe_write_json(HISTORY_FILE, history)
+
+def clear_history():
+    if os.path.exists(HISTORY_FILE):
+        os.remove(HISTORY_FILE)
+
+# ── Schedule Versions ─────────────────────────────────────────────────────
+
+def load_versions() -> list:
+    return _safe_read_json(VERSIONS_FILE, default=[])
+
+def save_version(label: str = None):
+    """Snapshot the current schedule + history as a version before clearing."""
+    if not schedule_exists():
+        return None
+    sched = load_schedule()
+    if not sched:
+        return None
+    history = load_history()
+    versions = load_versions()
+    version_id = str(uuid.uuid4())
+    version_num = len(versions) + 1
+    auto_label = label or f"Version {version_num}"
+    versions.append({
+        'id': version_id,
+        'label': auto_label,
+        'timestamp': datetime.now().isoformat(),
+        'generated_at': sched.get('generated_at', ''),
+        'schedule': sched.get('schedule', {}),
+        'history': history,
+    })
+    _safe_write_json(VERSIONS_FILE, versions)
+    return version_id
+
+def restore_version(version_id: str):
+    """Restore a saved version as the active schedule."""
+    versions = load_versions()
+    target = next((v for v in versions if v['id'] == version_id), None)
+    if not target:
+        return None
+    # Save the schedule (the raw dict, not the wrapper)
+    save_schedule(target['schedule'])
+    # Restore history
+    _safe_write_json(HISTORY_FILE, target.get('history', []))
+    return target
+
+# ── Pending Proposals ─────────────────────────────────────────────────────
+
+def load_proposals() -> list:
+    return _safe_read_json(PENDING_FILE, default=[])
+
+def save_proposal(proposal: dict):
+    proposals = load_proposals()
+    proposals.append(proposal)
+    _safe_write_json(PENDING_FILE, proposals)
+
+def delete_proposal(proposal_id: str):
+    proposals = load_proposals()
+    proposals = [p for p in proposals if p.get('id') != proposal_id]
+    _safe_write_json(PENDING_FILE, proposals)
+
+# ── Leave Requests ────────────────────────────────────────────────────────
+
+def load_leave_requests() -> list:
+    return _safe_read_json(LEAVE_FILE, default=[])
+
+def save_leave_requests(requests: list):
+    _safe_write_json(LEAVE_FILE, requests)
+
+def clear_leave_requests():
+    if os.path.exists(LEAVE_FILE): os.remove(LEAVE_FILE)
+
+# ── Substitution Requests ─────────────────────────────────────────────────
+
+def load_substitution_requests() -> list:
+    return _safe_read_json(SUB_REQ_FILE, default=[])
+
+def save_substitution_requests(requests: list):
+    _safe_write_json(SUB_REQ_FILE, requests)
+
+def clear_substitution_requests():
+    if os.path.exists(SUB_REQ_FILE): os.remove(SUB_REQ_FILE)
+
+# ── Cancellation Requests ─────────────────────────────────────────────────
+
+def load_cancellations() -> list:
+    return _safe_read_json(CANCELLATION_FILE, default=[])
+
+def save_cancellations(requests: list):
+    _safe_write_json(CANCELLATION_FILE, requests)

substitution_engine.py

@@ -0,0 +1,362 @@
+import uuid
+from datetime import datetime, timedelta
+import json
+from typing import List, Optional, Dict, Any
+
+from models import (
+    LeaveRequest, LeaveStatus, SubstitutionRequest, SubstitutionStatus,
+    AffectedSlot, ProposedSwap
+)
+from storage import (
+    load_schedule, load_data, save_schedule, add_history_entry,
+    load_substitution_requests, save_substitution_requests,
+    load_leave_requests, save_leave_requests
+)
+import constants as const
+
+def _get_faculty_id_by_name(name: str, faculties: list) -> Optional[str]:
+    """Resolve a faculty display name (e.g. 'Prof. Anu') to its internal ID ('anu')."""
+    name_clean = name.replace("Prof. ", "").replace("Dr. ", "").replace("Mr. ", "").replace("Ms. ", "").strip().lower()
+    # Exact ID match first
+    for f in faculties:
+        if name_clean == f["id"].lower():
+            return f["id"]
+    # Substring / partial match
+    for f in faculties:
+        if name_clean in f["id"].lower() or name_clean in f["name"].lower():
+            return f["id"]
+        # Also check the other direction
+        if f["id"].lower() in name_clean or f["name"].replace("Prof. ", "").replace("Dr. ", "").replace("Mr. ", "").replace("Ms. ", "").strip().lower() in name_clean:
+            return f["id"]
+    # Word-level match: check if any word in the input matches a faculty ID
+    for word in name_clean.split():
+        for f in faculties:
+            if word == f["id"].lower():
+                return f["id"]
+    return None
+
+def _get_faculty_name_by_id(fac_id: str, faculties: list) -> str:
+    for f in faculties:
+        if f["id"] == fac_id:
+            return f["name"]
+    return fac_id
+
+def _resolve_faculty_id(raw_id: str, faculties: list) -> Optional[str]:
+    """
+    Given a raw faculty identifier (could be an internal ID like 'anu',
+    a display name like 'Prof. Anu', or a user full name like 'Anu Sharma'),
+    resolve it to the canonical internal faculty ID.
+    """
+    # 1. Direct match on ID
+    for f in faculties:
+        if f["id"].lower() == raw_id.lower():
+            return f["id"]
+    # 2. Direct match on name
+    for f in faculties:
+        if f["name"].lower() == raw_id.lower():
+            return f["id"]
+    # 3. Try _get_faculty_id_by_name (handles prefix stripping)
+    result = _get_faculty_id_by_name(raw_id, faculties)
+    if result:
+        return result
+    # 4. Word-level: check each word of raw_id against faculty IDs
+    words = raw_id.replace("Prof. ", "").replace("Dr. ", "").replace("Mr. ", "").replace("Ms. ", "").strip().lower().split()
+    for word in words:
+        if len(word) < 2:  # skip very short words
+            continue
+        for f in faculties:
+            if word == f["id"].lower():
+                return f["id"]
+            fname_clean = f["name"].replace("Prof. ", "").replace("Dr. ", "").replace("Mr. ", "").replace("Ms. ", "").strip().lower()
+            if word == fname_clean or word in fname_clean.split():
+                return f["id"]
+    return None
+
+def _parent_section(section_id: str) -> str:
+    """Merge sub-sections like '6b-E1', '6b-E2' into parent '6b'."""
+    return section_id.split("-")[0] if "-" in section_id else section_id
+
+def process_leave_approval(leave: LeaveRequest):
+    """Entry point when a leave is approved. Finds affected slots and starts substitution process."""
+    schedule_data = load_schedule()
+    if not schedule_data or not schedule_data.get("schedule"):
+        return
+
+    data = load_data()
+    faculties = data.get("faculties", [])
+    allocations = data.get("allocations", [])
+
+    # Resolve the leave's faculty_id to the canonical internal ID.
+    # The frontend may send a display name like "Anu Sharma" instead of "anu".
+    resolved_fac_id = _resolve_faculty_id(leave.faculty_id, faculties)
+    if not resolved_fac_id:
+        # Fallback: try using the raw value
+        resolved_fac_id = leave.faculty_id
+
+    leave_fac_name = _get_faculty_name_by_id(resolved_fac_id, faculties)
+
+    affected_tasks = []
+    current_solution = schedule_data["schedule"]
+    
+    # Track which (parent_section, subject, day, period) combos we've already added
+    # to avoid duplicate requests for E1/E2 batches of the same class
+    seen_slots = set()
+    
+    # Identify affected classes for the given days
+    for task_id, info in current_solution.items():
+        faculty_name = info.get("faculty_name", "")
+        # Resolve this task's faculty to an internal ID for reliable comparison
+        task_fac_id = _get_faculty_id_by_name(faculty_name, faculties)
+        
+        day_index = info.get("day_index", 0)
+        day_name = const.DAYS[day_index] if day_index < len(const.DAYS) else f"Day {day_index}"
+        
+        # Check if the task belongs to the leaving faculty and on one of their leave days
+        if task_fac_id and task_fac_id == resolved_fac_id and day_name in leave.days:
+            # Handle duration (labs are 2 hours, theory 1 hour)
+            duration = info.get("duration", 1)
+            period = info.get("period_index", 0)
+            subject = info.get("subject_code", "")
+            parent_sec = _parent_section(info.get("section_id", ""))
+            
+            for i in range(duration):
+                slot_key = (subject, parent_sec, day_name, period + i)
+                if slot_key in seen_slots:
+                    continue  # Skip E2 if E1 already added for same class
+                seen_slots.add(slot_key)
+                
+                affected_tasks.append(AffectedSlot(
+                    subject_code=subject,
+                    section_id=parent_sec,  # Use parent section (e.g., '6b' not '6b-E1')
+                    day=day_name,
+                    period=period + i,
+                    room_id=info.get("room_id", "")
+                ))
+
+    # For each affected slot, find substitutes
+    for slot in affected_tasks:
+        find_substitutes_for_slot(slot, resolved_fac_id, leave.leave_id, current_solution, data)
+
+def find_substitutes_for_slot(slot: AffectedSlot, leave_faculty_id: str, leave_id: str, current_solution: dict, data: dict):
+    """Applies the Priority Ladder to find substitutes."""
+    faculties = data.get("faculties", [])
+    
+    # Find all faculties teaching the same subject anywhere
+    teach_same_subject = set()
+    for task_id, info in current_solution.items():
+        if info.get("subject_code") == slot.subject_code:
+            fac_id = _get_faculty_id_by_name(info.get("faculty_name", ""), faculties)
+            if fac_id and fac_id != leave_faculty_id:
+                teach_same_subject.add(fac_id)
+                
+    # Build a map of faculty busyness
+    busyness = {f["id"]: [] for f in faculties}
+    day_idx = const.DAYS.index(slot.day) if slot.day in const.DAYS else -1
+    for task_id, info in current_solution.items():
+        if info.get("day_index") == day_idx:
+            fac_id = _get_faculty_id_by_name(info.get("faculty_name", ""), faculties)
+            if fac_id:
+                duration = info.get("duration", 1)
+                start_p = info.get("period_index", 0)
+                for i in range(duration):
+                    busyness[fac_id].append(start_p + i)
+                    
+    # Also exclude anyone who is currently on an approved leave for this day
+    leave_requests = load_leave_requests()
+    on_leave_today = set()
+    # Always include the leaving faculty
+    on_leave_today.add(leave_faculty_id)
+    for lr in leave_requests:
+        if lr.get("status") == "APPROVED" and slot.day in lr.get("days", []):
+            # Resolve the raw faculty_id to internal ID so it matches
+            resolved = _resolve_faculty_id(lr.get("faculty_id", ""), faculties)
+            if resolved:
+                on_leave_today.add(resolved)
+            on_leave_today.add(lr.get("faculty_id"))  # keep raw value too
+
+    candidates_p1 = []  # Same subject, free
+    candidates_p2 = []  # Same subject, busy
+    candidates_p3 = []  # Free, any subject
+
+    # Priority 1 & 2
+    for fac_id in teach_same_subject:
+        if fac_id in on_leave_today: continue
+        if slot.period not in busyness.get(fac_id, []):
+            candidates_p1.append(fac_id)
+        else:
+            candidates_p2.append(fac_id)
+
+    # Priority 3
+    for fac in faculties:
+        fac_id = fac["id"]
+        if fac_id == leave_faculty_id or fac_id in on_leave_today: continue
+        if slot.period not in busyness.get(fac_id, []) and fac_id not in candidates_p1:
+            candidates_p3.append(fac_id)
+
+    # Dispatch logic
+    if candidates_p1:
+        _dispatch_requests(candidates_p1, slot, leave_faculty_id, leave_id, 1)
+    elif candidates_p2:
+        # P2 needs a swap. For simplicity, just pick a random free slot of the candidate
+        # that the leaving teacher is not using. This requires a bit more logic.
+        # For MVP, we'll try to find any free slot for candidate `f` and propose a swap.
+        for fac_id in candidates_p2:
+             free_slots = [p for p in range(const.NUM_TEACHING_SLOTS_PER_DAY) if p not in busyness[fac_id] and p not in busyness.get(leave_faculty_id, [])]
+             if free_slots:
+                 swap = ProposedSwap(
+                     subject_code=slot.subject_code,
+                     day=slot.day,
+                     original_period=slot.period,
+                     new_period=free_slots[0]
+                 )
+                 _dispatch_requests([fac_id], slot, leave_faculty_id, leave_id, 2, swap)
+                 return # Just propose one for now
+        
+        # Fallback to P3 if no swaps found
+        if candidates_p3:
+             _dispatch_requests(candidates_p3, slot, leave_faculty_id, leave_id, 3)
+    elif candidates_p3:
+        _dispatch_requests(candidates_p3, slot, leave_faculty_id, leave_id, 3)
+    else:
+        # Priority 4: Nobody available, escalate to Admin.
+        pass
+
+def _dispatch_requests(candidates: list, slot: AffectedSlot, original_fac_id: str, leave_id: str, priority: int, swap: Optional[ProposedSwap] = None):
+    requests = load_substitution_requests()
+    now = datetime.now()
+    expires = now + timedelta(hours=24)
+    
+    for fac_id in candidates:
+        # NEVER send a substitute request to the original faculty
+        if fac_id == original_fac_id:
+            continue
+        # don't send duplicates
+        existing = [r for r in requests if r["leave_id"] == leave_id and r["affected_slot"]["period"] == slot.period and r["affected_slot"]["section_id"] == slot.section_id and r["candidate_faculty_id"] == fac_id and r["status"] == "PENDING"]
+        if existing: continue
+
+        req = SubstitutionRequest(
+            request_id=str(uuid.uuid4()),
+            leave_id=leave_id,
+            affected_slot=slot,
+            original_faculty_id=original_fac_id,
+            candidate_faculty_id=fac_id,
+            priority_level=priority,
+            status=SubstitutionStatus.PENDING,
+            sent_at=now.isoformat(),
+            expires_at=expires.isoformat(),
+            proposed_swap=swap
+        )
+        import dataclasses
+        requests.append(dataclasses.asdict(req))
+    
+    save_substitution_requests(requests)
+
+def handle_acceptance(request_id: str):
+    requests = load_substitution_requests()
+    target_req = next((r for r in requests if r["request_id"] == request_id), None)
+    if not target_req or target_req["status"] != "PENDING":
+        return False, "Request not found or not pending."
+        
+    target_req["status"] = "ACCEPTED"
+    target_req["responded_at"] = datetime.now().isoformat()
+    
+    # Withdraw others for the same slot+day combination
+    for r in requests:
+        if (r["leave_id"] == target_req["leave_id"] 
+            and r["affected_slot"]["period"] == target_req["affected_slot"]["period"]
+            and r["affected_slot"]["day"] == target_req["affected_slot"]["day"]
+            and r["request_id"] != request_id):
+            if r["status"] == "PENDING":
+                 r["status"] = "WITHDRAWN"
+                 
+    save_substitution_requests(requests)
+    
+    # Update Timetable
+    schedule_data = load_schedule()
+    if not schedule_data or not schedule_data.get("schedule"):
+        return True, "Substitution accepted but no schedule to update."
+
+    current_solution = schedule_data.get("schedule", {})
+    data = load_data()
+    faculties = data.get("faculties", [])
+    
+    # Resolve faculty IDs reliably
+    original_fac_id = _resolve_faculty_id(target_req["original_faculty_id"], faculties) or target_req["original_faculty_id"]
+    sub_fac_id = _resolve_faculty_id(target_req["candidate_faculty_id"], faculties) or target_req["candidate_faculty_id"]
+    
+    leave_fac_name = _get_faculty_name_by_id(original_fac_id, faculties)
+    sub_fac_name = _get_faculty_name_by_id(sub_fac_id, faculties)
+                            
+    day_idx = const.DAYS.index(target_req["affected_slot"]["day"]) if target_req["affected_slot"]["day"] in const.DAYS else -1
+    
+    # The affected_slot section_id is a parent section (e.g., '6b').
+    # We must update ALL sub-sections (6b-E1, 6b-E2, etc.) that match.
+    parent_sec = target_req["affected_slot"]["section_id"]
+    
+    updated = False
+    for task_id, info in current_solution.items():
+         faculty_name = info.get("faculty_name", "")
+         # Use ID-based matching instead of fragile name stripping
+         task_fac_id = _get_faculty_id_by_name(faculty_name, faculties)
+         
+         # Match by parent section (e.g., task '6b-E1' matches parent '6b')
+         task_parent_sec = info.get("section_id", "").split("-")[0] if "-" in info.get("section_id", "") else info.get("section_id", "")
+         
+         if (task_fac_id and task_fac_id == original_fac_id 
+             and info.get("day_index") == day_idx
+             and task_parent_sec == parent_sec):
+              # Match period
+              duration = info.get("duration", 1)
+              start_p = info.get("period_index", 0)
+              if start_p <= target_req["affected_slot"]["period"] < start_p + duration:
+                   # Update to the substitute teacher
+                   info["faculty_name"] = sub_fac_name
+                   info["is_substituted"] = True
+                   info["original_faculty_name"] = leave_fac_name
+                   updated = True
+                   # DON'T break — update ALL sub-sections (E1, E2, etc.)
+                   
+    # If swap involved, swap the slots
+    if target_req.get("proposed_swap"):
+         swap = target_req["proposed_swap"]
+         # Not fully implemented atomic swap for brevity, but this is where it'd go
+         pass
+
+    # Save the updated schedule using the storage module (supports CommitScheduler)
+    save_schedule(current_solution)
+    
+    add_history_entry(
+        operation_type="SUBSTITUTION",
+        description=f"Substituted {leave_fac_name} with {sub_fac_name} for {target_req['affected_slot']['subject_code']} on {target_req['affected_slot']['day']} P{target_req['affected_slot']['period']+1}",
+        affected_sections=[target_req['affected_slot'].get('section_id', '')],
+        changes=[],
+        status="SUCCESS",
+    )
+    
+    return True, "Substitution accepted and timetable updated."
+
+def handle_decline(request_id: str):
+    requests = load_substitution_requests()
+    target_req = next((r for r in requests if r["request_id"] == request_id), None)
+    if not target_req or target_req["status"] != "PENDING":
+        return False, "Request not found or not pending."
+        
+    target_req["status"] = "DECLINED"
+    target_req["responded_at"] = datetime.now().isoformat()
+    save_substitution_requests(requests)
+    
+    # Ideally, trigger find_substitutes_for_slot again here or move to next priority level.
+    # We would need to keep track of which priority level we are currently exploring for this slot.
+    
+    return True, "Substitution declined."
+
+def check_timeouts():
+    requests = load_substitution_requests()
+    changed = False
+    now = datetime.now()
+    for r in requests:
+        if r["status"] == "PENDING" and datetime.fromisoformat(r["expires_at"]) < now:
+            r["status"] = "TIMEOUT"
+            changed = True
+    if changed:
+        save_substitution_requests(requests)

substitution_requests.json

@@ -0,0 +1 @@
+[]

test_solver.py

@@ -0,0 +1,55 @@
+
+import json
+from models import Faculty, Subject, Section, Room, SubjectType
+from data_loader import Allocation, prepare_scheduling_tasks
+from solver import TimetableSolver
+import constants as const
+
+def get_subject_type_enum(type_str):
+    mapping = {
+        "THEORY": SubjectType.THEORY,
+        "LAB": SubjectType.LAB,
+        "SOFTSKILL": SubjectType.SOFTSKILL,
+        "FORUM": SubjectType.FORUM
+    }
+    return mapping.get(type_str.upper(), SubjectType.THEORY)
+
+def convert_json_to_objects(data):
+    fac_objs = [Faculty(f['id'], f['name'], f['designation'], f['max_hours']) for f in data['faculties']]
+    
+    sub_objs = [Subject(
+        s['code'], s['name'], s['credits'], 
+        get_subject_type_enum(s['type']), 
+        s.get('is_core', True), s.get('is_heavy', False)
+    ) for s in data['subjects']]
+    
+    sec_objs = [Section(s['id'], s['semester'], s['strength']) for s in data['sections']]
+    
+    room_objs = [Room(r['id'], r['capacity'], r['is_lab'], r['building']) for r in data['rooms']]
+    
+    alloc_objs = [Allocation(
+        a['faculty_id'], a['subject_code'], a['section_id'], a.get('elective_group')
+    ) for a in data['allocations']]
+    
+    return fac_objs, sub_objs, sec_objs, room_objs, alloc_objs
+
+def main():
+    with open("timetable_data.json", "r") as f:
+        data = json.load(f)
+
+    facs, subs, secs, rooms, allocs = convert_json_to_objects(data)
+    tasks = prepare_scheduling_tasks(allocs, facs, subs, secs)
+    
+    print(f"Scheduling {len(tasks)} tasks...")
+    
+    solver = TimetableSolver(tasks, facs, secs, rooms)
+    status, solution = solver.solve(time_limit_seconds=30)
+    
+    print(f"Status: {status}")
+    if status in ["OPTIMAL", "FEASIBLE"]:
+        print("Success!")
+    else:
+        print("Failed.")
+
+if __name__ == "__main__":
+    main()

timetable_data.json

@@ -0,0 +1,1462 @@
+{
+  "faculties": [
+    {
+      "id": "AI00355",
+      "name": "Dr. Vijayashekar S S",
+      "designation": "Professor",
+      "max_hours": 6
+    },
+    {
+      "id": "AI00378",
+      "name": "Dr. Kavitha Nair R",
+      "designation": "Assoc. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00755",
+      "name": "Dr. S Anu Pallavi",
+      "designation": "Assoc. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00425",
+      "name": "Mr. Jovin Deglus",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00604",
+      "name": "Mr. Syed Musadiq Illahi",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00893",
+      "name": "Mr. Nanda Kumar N",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00822",
+      "name": "Ms. Surbhi",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI01146",
+      "name": "Ms. Vinutha M",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00825",
+      "name": "Mr. Mhd Tahir Mirji",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI00917",
+      "name": "Mr. Sanjay P",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI01204",
+      "name": "Mr. Abhijith S",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI01093",
+      "name": "Mr. Praveen Arokia Raj",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "NTA1",
+      "name": "Nandita Tarikeri",
+      "designation": "TA",
+      "max_hours": 50
+    },
+    {
+      "id": "AI01515",
+      "name": "Mr. Ranjan Kumar",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "AI01514",
+      "name": "Mr. Chalasani Jayanth",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "NF3",
+      "name": "NF3",
+      "designation": "Asst. Prof",
+      "max_hours": 20
+    },
+    {
+      "id": "BASAV",
+      "name": "Basavaraj",
+      "designation": "Instructor",
+      "max_hours": 50
+    },
+    {
+      "id": "soft",
+      "name": "Soft Skills Trainer",
+      "designation": "Trainer",
+      "max_hours": 50
+    },
+    {
+      "id": "MBA1",
+      "name": "Mr. Yogesh Dixith",
+      "designation": "Asst. Prof",
+      "max_hours": 18
+    },
+    {
+      "id": "CIVIL",
+      "name": "CIVIL_1",
+      "designation": "Asst. Prof",
+      "max_hours": 18
+    },
+    {
+      "id": "MATHS",
+      "name": "Maths Department",
+      "designation": "External",
+      "max_hours": 18
+    },
+    {
+      "id": "oe_fac_1",
+      "name": "OE Teacher 1",
+      "designation": "Guest",
+      "max_hours": 18
+    },
+    {
+      "id": "oe_fac_2",
+      "name": "OE Teacher 2",
+      "designation": "Guest",
+      "max_hours": 18
+    },
+    {
+      "id": "oe_fac_3",
+      "name": "OE Teacher 3 (Sem 7)",
+      "designation": "Guest",
+      "max_hours": 18
+    },
+    {
+      "id": "MBA",
+      "name": "MBA Faculty",
+      "designation": "Asst. Prof",
+      "max_hours": 18
+    }
+  ],
+  "subjects": [
+    {
+      "code": "DL&RL",
+      "name": "DL& RL",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DL&RL Lab",
+      "name": "DL&RL Lab",
+      "type": "FORUM",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "ML II",
+      "name": "Machine Learning-II",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "ML II Lab",
+      "name": "ML-II Lab",
+      "type": "FORUM",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "DS&P",
+      "name": "Data Security & Privacy",
+      "type": "THEORY",
+      "credits": 4,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "BA",
+      "name": "Business Analytics",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "BDA",
+      "name": "Big Data Analytics",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "OE (Sem 7)",
+      "name": "Open Elective (Sem 7)",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "PP",
+      "name": "Parallel Programming",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "PP Lab",
+      "name": "PP Lab",
+      "type": "FORUM",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "SML for DS",
+      "name": "Statistical ML for DS",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "SML for DS Lab",
+      "name": "Statistical ML for DS Lab",
+      "type": "FORUM",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "CNS",
+      "name": "Cryptography and Network Security",
+      "type": "THEORY",
+      "credits": 4,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DL",
+      "name": "Deep Learning",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "SEPM",
+      "name": "Software Engg & Project Management",
+      "type": "THEORY",
+      "credits": 4,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "CN",
+      "name": "Computer Networks",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "CN Lab",
+      "name": "CN Lab",
+      "type": "FORUM",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "TOC",
+      "name": "Theory of Computation",
+      "type": "THEORY",
+      "credits": 5,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DV Lab",
+      "name": "Data Visualization Lab",
+      "type": "LAB",
+      "credits": 1,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "RM&IPR",
+      "name": "Research Methodology & IPR",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "EVS",
+      "name": "Environmental Studies",
+      "type": "THEORY",
+      "credits": 2,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "CV",
+      "name": "Computer Vision",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "EDA",
+      "name": "Exploratory Data Analysis",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "NoSQL DB",
+      "name": "NoSQL Databases",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "DW",
+      "name": "Data Warehousing",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "Maths (Prob & Stats)",
+      "name": "Probability, Distributions and Statistics",
+      "type": "THEORY",
+      "credits": 5,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DDCO",
+      "name": "Digital Design & Computer Organization",
+      "type": "THEORY",
+      "credits": 5,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "OS",
+      "name": "Operating Systems",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DSA",
+      "name": "Data Structures and Applications",
+      "type": "THEORY",
+      "credits": 3,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "DSA Lab",
+      "name": "DSA Lab",
+      "type": "LAB",
+      "credits": 1,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "OOP with Java",
+      "name": "OOP with JAVA",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "EDA Lab",
+      "name": "Exploratory Data Analysis Lab",
+      "type": "FORUM",
+      "credits": 2,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "PM with Git",
+      "name": "Project Management with GIT Lab",
+      "type": "FORUM",
+      "credits": 2,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "Maths LE",
+      "name": "Mathematics for Lateral Entry Students",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "LIB_HR",
+      "name": "Library Hour",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "STU_HR",
+      "name": "Student Hour",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "FAC_HR",
+      "name": "Faculty Hour",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "STDY_HR",
+      "name": "Study Hour",
+      "type": "THEORY",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "Soft Skills",
+      "name": "Soft Skills",
+      "type": "SOFTSKILL",
+      "credits": 1,
+      "is_core": false,
+      "is_heavy": false
+    },
+    {
+      "code": "EDA Lab 2",
+      "name": "Exploratory Data Analysis Lab 2",
+      "type": "FORUM",
+      "credits": 2,
+      "is_core": true,
+      "is_heavy": true
+    },
+    {
+      "code": "PM with Git 2",
+      "name": "Project Management with GIT Lab 2",
+      "type": "FORUM",
+      "credits": 2,
+      "is_core": true,
+      "is_heavy": true
+    }
+  ],
+  "sections": [
+    {
+      "id": "7A",
+      "semester": 7,
+      "strength": 70
+    },
+    {
+      "id": "7B",
+      "semester": 7,
+      "strength": 70
+    },
+    {
+      "id": "5A",
+      "semester": 5,
+      "strength": 70
+    },
+    {
+      "id": "5B",
+      "semester": 5,
+      "strength": 70
+    },
+    {
+      "id": "3A",
+      "semester": 3,
+      "strength": 70
+    },
+    {
+      "id": "3B",
+      "semester": 3,
+      "strength": 70
+    },
+    {
+      "id": "7DS",
+      "semester": 7,
+      "strength": 70
+    },
+    {
+      "id": "5DS",
+      "semester": 5,
+      "strength": 70
+    },
+    {
+      "id": "3DS",
+      "semester": 3,
+      "strength": 70
+    },
+    {
+      "id": "OE_AI",
+      "semester": 7,
+      "strength": 70
+    },
+    {
+      "id": "7A-B1",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "7A-B2",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "7B-B1",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "7B-B2",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "7DS-B1",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "7DS-B2",
+      "semester": 7,
+      "strength": 35
+    },
+    {
+      "id": "5A-B1",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "5A-B2",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "5B-B1",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "5B-B2",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "5DS-B1",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "5DS-B2",
+      "semester": 5,
+      "strength": 35
+    },
+    {
+      "id": "3A-B1",
+      "semester": 3,
+      "strength": 35
+    },
+    {
+      "id": "3A-B2",
+      "semester": 3,
+      "strength": 35
+    },
+    {
+      "id": "3B-B1",
+      "semester": 3,
+      "strength": 35
+    },
+    {
+      "id": "3B-B2",
+      "semester": 3,
+      "strength": 35
+    },
+    {
+      "id": "3DS-B1",
+      "semester": 3,
+      "strength": 35
+    },
+    {
+      "id": "3DS-B2",
+      "semester": 3,
+      "strength": 35
+    }
+  ],
+  "rooms": [
+    {
+      "id": "AI09 3F 01",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 3F 03",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 3F 08",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 2F 12",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 2F 13",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 2F 14",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 2F 08",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 1F 25",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI09 1F26",
+      "capacity": 75,
+      "is_lab": false,
+      "building": "ECE BLOCK"
+    },
+    {
+      "id": "AI03 2F 01",
+      "capacity": 40,
+      "is_lab": true,
+      "building": "ASD BLOCK"
+    },
+    {
+      "id": "AI03 2F 02",
+      "capacity": 40,
+      "is_lab": true,
+      "building": "ASD BLOCK"
+    }
+  ],
+  "allocations": [
+    {
+      "faculty_id": "AI00355",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00355",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B1",
+      "elective_group": "lab_pair_7A_2"
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7A-B2",
+      "elective_group": "lab_pair_7A_1"
+    },
+    {
+      "faculty_id": "AI01093",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B1",
+      "elective_group": "lab_pair_7B_2"
+    },
+    {
+      "faculty_id": "AI01093",
+      "subject_code": "DL&RL Lab",
+      "section_id": "7B-B2",
+      "elective_group": "lab_pair_7B_1"
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "ML II",
+      "section_id": "7A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01204",
+      "subject_code": "ML II",
+      "section_id": "7B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B1",
+      "elective_group": "lab_pair_7A_1"
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "ML II Lab",
+      "section_id": "7A-B2",
+      "elective_group": "lab_pair_7A_2"
+    },
+    {
+      "faculty_id": "AI01204",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B1",
+      "elective_group": "lab_pair_7B_1"
+    },
+    {
+      "faculty_id": "AI01204",
+      "subject_code": "ML II Lab",
+      "section_id": "7B-B2",
+      "elective_group": "lab_pair_7B_2"
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "DS&P",
+      "section_id": "7A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "DS&P",
+      "section_id": "7B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "MBA",
+      "subject_code": "BA",
+      "section_id": "7A",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "MBA",
+      "subject_code": "BA",
+      "section_id": "7B",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "MBA1",
+      "subject_code": "BA",
+      "section_id": "7DS",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "BDA",
+      "section_id": "7A",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "BDA",
+      "section_id": "7B",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "DL",
+      "section_id": "7DS",
+      "elective_group": "ELEC_7"
+    },
+    {
+      "faculty_id": "oe_fac_1",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "oe_fac_2",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "oe_fac_3",
+      "subject_code": "OE (Sem 7)",
+      "section_id": "7DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "PP",
+      "section_id": "7DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "PP Lab",
+      "section_id": "7DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "SML for DS",
+      "section_id": "7DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "SML for DS Lab",
+      "section_id": "7DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "CNS",
+      "section_id": "7DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NF3",
+      "subject_code": "SEPM",
+      "section_id": "5B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN",
+      "section_id": "5A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN",
+      "section_id": "5B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN Lab",
+      "section_id": "5A-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "CN Lab",
+      "section_id": "5B-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01146",
+      "subject_code": "TOC",
+      "section_id": "5A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01146",
+      "subject_code": "TOC",
+      "section_id": "5B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "CV",
+      "section_id": "5A",
+      "elective_group": "ELEC_5_AIML"
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "EDA",
+      "section_id": "5A",
+      "elective_group": "ELEC_5_AIML"
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "CV",
+      "section_id": "5B",
+      "elective_group": "ELEC_5_AIML"
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "EDA",
+      "section_id": "5B",
+      "elective_group": "ELEC_5_AIML"
+    },
+    {
+      "faculty_id": "BASAV",
+      "subject_code": "RM&IPR",
+      "section_id": "5A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "BASAV",
+      "subject_code": "RM&IPR",
+      "section_id": "5B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "CIVIL",
+      "subject_code": "EVS",
+      "section_id": "5A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "CIVIL",
+      "subject_code": "EVS",
+      "section_id": "5B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01515",
+      "subject_code": "SEPM",
+      "section_id": "5DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "CN",
+      "section_id": "5DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "CN Lab",
+      "section_id": "5DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01146",
+      "subject_code": "TOC",
+      "section_id": "5DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00604",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01093",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "NoSQL DB",
+      "section_id": "5DS",
+      "elective_group": "ELEC_5_DS"
+    },
+    {
+      "faculty_id": "AI01204",
+      "subject_code": "DW",
+      "section_id": "5DS",
+      "elective_group": "ELEC_5_DS"
+    },
+    {
+      "faculty_id": "BASAV",
+      "subject_code": "RM&IPR",
+      "section_id": "5DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "CIVIL",
+      "subject_code": "EVS",
+      "section_id": "5DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01515",
+      "subject_code": "DDCO",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01515",
+      "subject_code": "DDCO",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "OS",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01146",
+      "subject_code": "OS",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "DSA",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "DSA",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NTA1",
+      "subject_code": "OOP with Java",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NTA1",
+      "subject_code": "OOP with Java",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab",
+      "section_id": "3A",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab",
+      "section_id": "3B",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git",
+      "section_id": "3A",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git",
+      "section_id": "3B",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths LE",
+      "section_id": "3A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths LE",
+      "section_id": "3B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths (Prob & Stats)",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "DDCO",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "OS",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "DSA",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NTA1",
+      "subject_code": "OOP with Java",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab",
+      "section_id": "3DS",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "MATHS",
+      "subject_code": "Maths LE",
+      "section_id": "3DS",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NTA1",
+      "subject_code": "DL&RL",
+      "section_id": "7A",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "NTA1",
+      "subject_code": "DL&RL",
+      "section_id": "7B",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00755",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00425",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01204",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "DV Lab",
+      "section_id": "5A-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00825",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "DSA Lab",
+      "section_id": "3A-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00822",
+      "subject_code": "DSA Lab",
+      "section_id": "3B-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01515",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01515",
+      "subject_code": "DV Lab",
+      "section_id": "5B-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B1",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git",
+      "section_id": "3DS",
+      "elective_group": "ELEC_3_LAB"
+    },
+    {
+      "faculty_id": "AI00893",
+      "subject_code": "DSA Lab",
+      "section_id": "3DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI01514",
+      "subject_code": "DV Lab",
+      "section_id": "5DS-B2",
+      "elective_group": null
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3A",
+      "elective_group": "ELEC_3_LAB_2"
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3B",
+      "elective_group": "ELEC_3_LAB_2"
+    },
+    {
+      "faculty_id": "AI00378",
+      "subject_code": "EDA Lab 2",
+      "section_id": "3DS",
+      "elective_group": "ELEC_3_LAB_2"
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git 2",
+      "section_id": "3A",
+      "elective_group": "ELEC_3_LAB_2"
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git 2",
+      "section_id": "3B",
+      "elective_group": "ELEC_3_LAB_2"
+    },
+    {
+      "faculty_id": "AI00917",
+      "subject_code": "PM with Git 2",
+      "section_id": "3DS",
+      "elective_group": "ELEC_3_LAB_2"
+    }
+  ],
+  "scheduling_rules": [
+    {
+      "id": "50480578-d82b-4f28-9ebf-416f46e9773b",
+      "rule_type": "FIXED_PERIOD",
+      "subject_codes": [
+        "OE (Sem 7)"
+      ],
+      "subject_types": [],
+      "period_index": 2
+    },
+    {
+      "id": "5f6a4afd-9fd4-4930-835e-c8a387bb8c76",
+      "rule_type": "FIXED_DAYS",
+      "subject_codes": [
+        "OE (Sem 7)"
+      ],
+      "subject_types": [],
+      "days": [
+        "MON",
+        "TUE",
+        "WED"
+      ]
+    },
+    {
+      "id": "bc2547c3-1511-46ae-a71b-580d576e2633",
+      "rule_type": "FACULTY_UNAVAILABLE",
+      "faculty_id": "AI00822",
+      "subject_codes": [],
+      "subject_types": [],
+      "period_index": 0,
+      "days": [
+        "MON",
+        "TUE",
+        "WED",
+        "THU",
+        "FRI"
+      ]
+    },
+    {
+      "id": "eb002c24-3ebd-460b-9571-6bf21163cfcc",
+      "rule_type": "FACULTY_UNAVAILABLE",
+      "faculty_id": "AI00604",
+      "subject_codes": [],
+      "subject_types": [],
+      "period_index": 2,
+      "days": [
+        "MON",
+        "TUE",
+        "WED"
+      ]
+    },
+    {
+      "id": "ba936692-8887-440e-ab6a-a95cce177241",
+      "rule_type": "FACULTY_UNAVAILABLE",
+      "faculty_id": "AI00604",
+      "subject_codes": [],
+      "subject_types": [],
+      "period_index": 1,
+      "days": [
+        "WED",
+        "FRI"
+      ]
+    },
+    {
+      "id": "48c1d6b3-4002-4d97-afa1-1964a7be668e",
+      "rule_type": "FACULTY_UNAVAILABLE",
+      "faculty_id": "AI00604",
+      "subject_codes": [],
+      "subject_types": [],
+      "period_index": 2,
+      "days": [
+        "THU"
+      ]
+    },
+    {
+      "id": "a44c5fdc-c6a0-4f8c-bcfa-dd1375ad7eb0",
+      "rule_type": "FACULTY_UNAVAILABLE",
+      "faculty_id": "AI00825",
+      "subject_codes": [],
+      "subject_types": [],
+      "period_index": 2,
+      "days": [
+        "MON",
+        "TUE",
+        "WED"
+      ]
+    }
+  ]
+}