updated

app.py

@@ -7,6 +7,7 @@ from math import ceil
 from fastapi import FastAPI, Query
 from contextlib import asynccontextmanager
 from datetime import datetime, timedelta
+from dateutil import parser
 from collections import defaultdict
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, SystemMessage
@@ -23,6 +24,7 @@ session_state = {
     "full_roadmap": None,
     "report_data": None,
     "final_report": None,
+    "dependencies": None,
     "updated_roadmap": None
 }
 
@@ -35,8 +37,10 @@ async def lifespan(app: FastAPI):
             session_state["data"] = json.load(f)
         with open("synthesized_full_roadmap.json", "r") as f:
             session_state["full_roadmap"] = json.load(f)
+        with open("dependencies.json", 'r') as file:
+            session_state["dependencies"] = json.load(file)
         # Process tasks as incomplete
-        process_task_completion_data()
+        process_task_data()
         print("✅ Roadmaps loaded successfully.")
     except Exception as e:
         print(f"❌ Error loading roadmaps: {e}")
@@ -53,29 +57,52 @@ app = FastAPI(
 )
 
 # Function to mark tasks as incomplete
-def process_task_completion_data():
-    data = session_state['data']
+def process_task_data():
+    data = session_state["data"]
     for day in data["schedule"]:
         for subject in day["subjects"]:
             for task in subject["tasks"]:
                 task["task_completed"] = False
                 task["completion_timestamp"] = None
-    session_state['data'] = data
-
-def check_tot_time(day, max_hours_per_day):
+                task["rescheduled"] = 0
+    session_state["data"] = data
+    print("Task data processed!")
+
+def add_test(roadmap, date, physics = [], chemistry = [], maths = []):
+    date = parser.parse(date).strftime("%Y-%m-%d")
+    for i, day in enumerate(roadmap["schedule"]):
+        if day["date"] == date:
+            roadmap["schedule"][i] = {
+                                      "dayNumber": day['dayNumber'],
+                                      "date": date,
+                                      "test_portion": [
+                                          {
+                                              "name": "Physics",
+                                              "chapters": physics
+                                          },
+                                          {
+                                              "name": "Chemistry",
+                                              "chapters": chemistry
+                                          },
+                                          {
+                                              "name": "Maths",
+                                              "chapters": maths
+                                          }
+                                      ],
+                                      "subjects": day['subjects']
+                                     }
+    return roadmap
+
+def check_tot_time(day):
   tot_time = 0
-  for subject in day:
+  for subject in day['subjects']:
     for task in subject["tasks"]:
       tot_time += float(task['time'].split(" ")[0])
+  return tot_time
 
-  if tot_time > max_hours_per_day:
-    return tot_time, True
-  else:
-    return tot_time, False
-
-def shift_roadmap(roadmap, max_hours_per_day):
-    roadmap = copy.deepcopy(roadmap)
+def extract_tasks(roadmap, test_portions=None, dependencies=None):
     incomplete_tasks_by_subject = defaultdict(list)
+    subjectwise_tasks = defaultdict(list)
 
     prev_day = roadmap[0]
     for subject in prev_day["subjects"]:
@@ -86,6 +113,8 @@ def shift_roadmap(roadmap, max_hours_per_day):
         incomplete_tasks = [task for task in tasks if task['task_completed'] == False]
         completed_tasks = [task for task in tasks if task['task_completed'] == True]
 
+        for task in incomplete_tasks:
+            task['rescheduled'] += 1
         # Store incomplete tasks per subject
         if incomplete_tasks:
             incomplete_tasks_by_subject[subject_name].extend(incomplete_tasks)
@@ -93,171 +122,517 @@ def shift_roadmap(roadmap, max_hours_per_day):
         # Keep only completed tasks in the previous day
         subject["tasks"] = completed_tasks
 
-
-    # Step 2: Redistribute tasks across the next 3 days
-    for i, next_day in enumerate(roadmap[1:]):  # Next 3 days (Day 2, Day 3, Day 4)
-        for subject in next_day["subjects"]:
+    for day_index, day in enumerate(roadmap[1:]):
+        for subject in day["subjects"]:
             subject_name = subject["name"]
-            if subject_name in incomplete_tasks_by_subject and incomplete_tasks_by_subject[subject_name]:
-                total_tasks = len(incomplete_tasks_by_subject[subject_name])
-
-                # Task distribution based on 1/6, 2/6, and remaining
-                if i == 0:  # First day gets 1/6 of total
-                    tasks_to_add = ceil(total_tasks * (1 / 6))
-                elif i == 1:  # Second day gets 2/6 of total
-                    tasks_to_add = ceil(total_tasks * (2 / 6))
-                else:  # Remaining tasks on the last day
-                    tasks_to_add = len(incomplete_tasks_by_subject[subject_name])
-
-                # Append tasks to the current day's subject
-                subject["tasks"].extend(incomplete_tasks_by_subject[subject_name][:tasks_to_add])
-
-                # Remove assigned tasks from backlog
-                incomplete_tasks_by_subject[subject_name] = incomplete_tasks_by_subject[subject_name][tasks_to_add:]
-
-        # Make sure the time limit doesn't exceed for any day
-        _, check_time = check_tot_time(next_day["subjects"], max_hours_per_day)
-        while check_time:
-            for subject in next_day["subjects"]:
-                subject_name = subject["name"]
-                if subject["tasks"]:
-                    task_to_add = subject["tasks"].pop()
-                    incomplete_tasks_by_subject[subject_name].append(task_to_add)
-                    _, check_time = check_tot_time(next_day["subjects"], max_hours_per_day)
-                    if not check_time:
-                        break
-
-    return roadmap, incomplete_tasks_by_subject
-
-def get_shifted_roadmap(roadmap, dayNumber, max_hours_per_day):
-  day_index = dayNumber-1
-  if day_index+4 <= len(roadmap['schedule']):
-    shifted_roadmap, incomplete_tasks_by_subject = shift_roadmap(roadmap['schedule'][day_index:day_index+4], max_hours_per_day)
-  else:
-    shifted_roadmap, incomplete_tasks_by_subject = shift_roadmap(roadmap['schedule'][day_index:], max_hours_per_day)
-  for day in shifted_roadmap:
-      new_date = day["date"]
-
-      for idx, existing_day in enumerate(roadmap['schedule']):
-          if existing_day['date'] == new_date:
-              roadmap['schedule'][idx] = day
-              break
-
-  if any(len(v) != 0 for v in incomplete_tasks_by_subject.values()):
-    next_date = (datetime.strptime(roadmap['schedule'][-1]['date'], "%Y-%m-%d") + timedelta(days=1)).strftime("%Y-%m-%d")
-    next_day = roadmap['schedule'][-1]['dayNumber'] + 1
-    subjects = [{"name": subject_name, "tasks": tasks} for subject_name, tasks in incomplete_tasks_by_subject.items()]
-    roadmap['schedule'].append({
-        "dayNumber": next_day,
-        "date": next_date,
-        "subjects": subjects
-        })
-  return roadmap
-
-# Step 0: Get Subjectwise Chapter and Topic order ready
-def get_subjectwise_tasks(roadmap):
-    sub_tasks = {
-        "Physics": defaultdict(list),
-        "Chemistry": defaultdict(list),
-        "Maths": defaultdict(list)
-    }
-
-    for day in roadmap["schedule"]:
-        for subject in day['subjects']:
-            sub = sub_tasks[subject['name']]
-            for task in subject['tasks']:
-                if task['subtopic'] not in sub[task['ChapterName']]:
-                  sub[task['ChapterName']].append(task['subtopic'])
-
-    return sub_tasks
+            subjectwise_tasks[subject_name].extend(subject["tasks"])
 
-# Step 1: Extract all tasks per subject and track time allocation per day
-def extract_tasks(roadmap):
-    subjectwise_tasks = defaultdict(list)
-    daily_subjectwise_time_allocation = defaultdict(lambda: defaultdict(float))
+    if test_portions and dependencies:
+        dependent_tasks_by_subject = defaultdict(list)
+        dependent_chapters = set()
+        for subject in test_portions:
+            sub_name = subject['name']
+            for chapter in subject['chapters']:
+                if chapter in dependencies[sub_name]:
+                    dependent_chapters.update(dependencies[sub_name][chapter])
+
+        for subject, tasks in subjectwise_tasks.items():
+            retained_tasks = []
+            for task in tasks:
+                if task.get("ChapterName") in dependent_chapters:
+                    dependent_tasks_by_subject[subject].append(task)
+                else:
+                    retained_tasks.append(task)
+            subjectwise_tasks[subject] = retained_tasks
+
+        for subject, tasks in incomplete_tasks_by_subject.items():
+            retained_tasks = []
+            for task in tasks:
+                if task.get("ChapterName") in dependent_chapters:
+                    dependent_tasks_by_subject[subject].append(task)
+                else:
+                    retained_tasks.append(task)
+            incomplete_tasks_by_subject[subject] = retained_tasks
+        return roadmap, subjectwise_tasks, incomplete_tasks_by_subject, dependent_tasks_by_subject
+    return roadmap, subjectwise_tasks, incomplete_tasks_by_subject
 
-    for day_index, day in enumerate(roadmap['schedule']):
+def get_task_time(task):
+    return round(float(task['time'].split(" ")[0]), 3)
+
+def calculate_time_distribution(roadmap, incomplete_tasks, incomplete_tasks_by_subject, max_hours_per_day):
+    total_hours = 0
+    num_days = len(roadmap[1:])
+    extra_day=False
+
+    extra_hours = 0
+    if incomplete_tasks_by_subject:
+        for subject in incomplete_tasks_by_subject:
+            for task in incomplete_tasks_by_subject[subject]:
+                extra_hours += get_task_time(task)
+        extra_day=True
+
+    for subject in incomplete_tasks:
+        for task in incomplete_tasks[subject]:
+            total_hours += get_task_time(task)
+
+    for day in roadmap[1:]:
+        if day['dayNumber'] >= 550:
+            max_hours_per_day = 16
         for subject in day["subjects"]:
-            subject_name = subject["name"]
-            total_time = sum(float(task['time'].split(" ")[0]) for task in subject["tasks"])
-
-            daily_subjectwise_time_allocation[day_index][subject_name] = total_time
-            subjectwise_tasks[subject_name].extend(subject["tasks"])
+            for task in subject["tasks"]:
+                total_hours += get_task_time(task)
+
+    if num_days <= 0:
+        return [], [total_hours + extra_hours] if total_hours+extra_hours > 0 else []
+    max_possible_hours = num_days * max_hours_per_day
+
+    if total_hours <= max_possible_hours and not extra_day:
+        # Calculate base hours per day (minimum)
+        base_hours = total_hours // num_days
+
+        # Calculate remaining hours
+        remaining_hours = total_hours - (base_hours * num_days)
+
+        # Start with all days having base hours
+        distribution = [base_hours] * num_days
+
+        # Distribute remaining hours starting from the last day
+        for i in range(num_days - 1, -1, -1):
+            if remaining_hours > 0:
+                additional = min(1, remaining_hours, max_hours_per_day - distribution[i])
+                distribution[i] += additional
+                remaining_hours -= additional
+
+        return distribution, []
+
+    # Otherwise, max out all current days and prepare for extra days
+    distribution = [max_hours_per_day] * num_days
+    remaining_hours = total_hours - max_possible_hours
+
+    if extra_day:
+        base_hours = total_hours // num_days
+        remaining_hours = total_hours - (base_hours * num_days)
+        distribution = [base_hours] * num_days
+        for i in range(num_days - 1, -1, -1):
+            if remaining_hours > 0:
+                additional = min(1, remaining_hours, max_hours_per_day - distribution[i])
+                distribution[i] += additional
+                remaining_hours -= additional
+        remaining_hours = extra_hours
+
+    extra_distribution = []
+    while remaining_hours > 0:
+        hours = min(max_hours_per_day, remaining_hours)
+        extra_distribution.append(hours)
+        remaining_hours -= hours
+
+    return distribution, extra_distribution
+
+def add_tasks_for_extra_days(subject_all_tasks, incomplete_tasks, extra_day_tasks, extra_distribution, ratio, max_hours_per_day):
+    subject_names = list(subject_all_tasks.keys()) or list(incomplete_tasks.keys())
+    has_incomplete_tasks = any(tasks for tasks in incomplete_tasks.values())
+    for i, target_time in enumerate(extra_distribution):
+        day_time = 0
+        if subject_all_tasks:
+            regular_task_limit = ceil(target_time * ratio[0] / 100) if has_incomplete_tasks else target_time
+            incomplete_task_limit = ceil(target_time * ratio[1] / 100) if has_incomplete_tasks else 0
+        else:
+            regular_task_limit = 0
+            incomplete_task_limit = target_time
+
+        # Create a new day with subjects
+        new_day = {"subjects": [{"name": n, "tasks": []} for n in subject_names]}
+
+        # Step 1: Allocate regular tasks up to their limit
+        regular_time = 0
+        while regular_time < regular_task_limit and day_time < max_hours_per_day:
+            added = False
+            for subject in new_day["subjects"]:
+                subject_name = subject["name"]
+                if not subject_all_tasks[subject_name]:
+                    continue
 
-    return subjectwise_tasks, daily_subjectwise_time_allocation
+                next_task = subject_all_tasks[subject_name][0]
+                task_time = get_task_time(next_task)
 
-# Step 2: Sort all tasks for each subject
-def sort_tasks(tasks, reference):
-    task_type_priority = {
-      "Concept Understanding": 0,
-      "Question Practice": 1,
-      "Revision": 2,
-      "Test": 3
-    }
-    chapter_order = list(reference.keys())
+                if regular_time + task_time <= regular_task_limit and day_time + task_time <= max_hours_per_day:
+                    subject["tasks"].append(subject_all_tasks[subject_name].pop(0))
+                    regular_time += task_time
+                    day_time += task_time
+                    added = True
+            if not added:
+                break
+
+        # Step 2: Allocate incomplete tasks up to their limit
+        incomplete_time = 0
+        while incomplete_time < incomplete_task_limit and day_time < max_hours_per_day:
+            added = False
+            for subject in new_day["subjects"]:
+                subject_name = subject["name"]
+                if not incomplete_tasks[subject_name]:
+                    continue
 
-    def task_sort_key(task):
-        chapter = task["ChapterName"]
-        subtopic = task["subtopic"]
-        type_priority = task_type_priority.get(task["type"], 99)
+                next_task = incomplete_tasks[subject_name][0]
+                task_time = get_task_time(next_task)
 
-        chapter_idx = chapter_order.index(chapter) if chapter in reference else float('inf')
-        subtopic_idx = reference[chapter].index(subtopic) if subtopic in reference.get(chapter, []) else float('inf')
+                if incomplete_time + task_time <= incomplete_task_limit and day_time + task_time <= max_hours_per_day:
+                    subject["tasks"].append(incomplete_tasks[subject_name].pop(0))
+                    incomplete_time += task_time
+                    day_time += task_time
+                    added = True
+            if not added:
+                break
+
+        # Step 3: Use remaining time for additional regular tasks if available
+        if day_time < target_time:
+            while day_time < target_time:
+                added = False
+                for subject in new_day["subjects"]:
+                    subject_name = subject["name"]
+                    if not subject_all_tasks[subject_name]:
+                        continue
+
+                    next_task = subject_all_tasks[subject_name][0]
+                    task_time = get_task_time(next_task)
+
+                    if day_time + task_time <= max_hours_per_day:
+                        subject["tasks"].append(subject_all_tasks[subject_name].pop(0))
+                        day_time += task_time
+                        added = True
+                    if day_time > target_time:
+                        break
+                if not added:
+                    break
+        if i == len(extra_distribution) - 1:
+            for subject in new_day["subjects"]:
+                subject_name = subject["name"]
 
-        return (chapter_idx, subtopic_idx, type_priority)
+                # Add remaining regular tasks
+                while subject_all_tasks[subject_name]:
+                    subject["tasks"].append(subject_all_tasks[subject_name].pop(0))
 
-    return sorted(tasks, key=task_sort_key)
+                # Add remaining incomplete tasks
+                while incomplete_tasks[subject_name]:
+                    subject["tasks"].append(incomplete_tasks[subject_name].pop(0))
 
-# Helper function to get task time in hours
-def get_task_time(task):
-    return float(task['time'].split(" ")[0])
+        extra_day_tasks.append(new_day)
+    return extra_day_tasks
 
-# Step 3: Sort the roadmap by arranging the sorted tasks, preserving original time allocation
-def shift_and_sort_the_roadmap(full_roadmap, roadmap, dayNumber, max_hours_per_day):
+def shift_the_roadmap(roadmap, max_hours_per_day, ratio=(80, 20), dependencies=None, test_portions=None):
     roadmap = copy.deepcopy(roadmap)
-    roadmap = get_shifted_roadmap(roadmap, dayNumber, max_hours_per_day)
-    subject_refs = get_subjectwise_tasks(full_roadmap) # Load the full roadmap to obtain the correct chapter orders
-    subject_all_tasks, subject_day_time_allocation = extract_tasks(roadmap)
+    # Extract tasks based on ratio mode
+    if ratio == (80, 20):
+        roadmap, subject_all_tasks, incomplete_tasks = extract_tasks(roadmap)
+        dependent_tasks = None
+        incomplete_tasks_by_subject = None
+    else:
+        roadmap, subject_all_tasks, incomplete_tasks_by_subject, dependent_tasks = extract_tasks(
+            roadmap, test_portions, dependencies
+        )
+        incomplete_tasks = dependent_tasks
+
+    # Distribute time across days
+    time_distribution, extra_distribution = calculate_time_distribution(roadmap, incomplete_tasks,
+                                                                        incomplete_tasks_by_subject,
+                                                                        max_hours_per_day)
+    # Check if there are any incomplete tasks
+    has_incomplete_tasks = any(tasks for tasks in incomplete_tasks.values())
+
+    # Prepare containers for task assignments
+    pending_regular_tasks = defaultdict(lambda: defaultdict(list))
+    pending_incomplete_tasks = defaultdict(lambda: defaultdict(list))
+
+    # Redistribute tasks for each day
+    for day_index, day in enumerate(roadmap[1:], 1):
+        target_time = time_distribution[day_index - 1]
+        day_time = 0
 
-    # Sort all tasks for each subject
-    for subject in subject_all_tasks:
-        subject_all_tasks[subject] = sort_tasks(subject_all_tasks[subject], subject_refs[subject])
+        # Set task limits based on whether incomplete tasks exist
+        regular_task_limit = ceil(target_time * ratio[0] / 100) if has_incomplete_tasks else target_time
+        incomplete_task_limit = ceil(target_time * ratio[1] / 100) if has_incomplete_tasks else 0
 
-    # Redistribute tasks based on time allocation, strictly maintaining sequence
-    for day_index, day in enumerate(roadmap['schedule']):
-        day_time = 0
-        for subject in day["subjects"]:
-            subject_name = subject["name"]
-            target_time = subject_day_time_allocation[day_index][subject_name]
+        # Step 1: Allocate regular tasks up to their limit (either 80% or 100%)
+        regular_time = 0
+        while regular_time < regular_task_limit and day_time < max_hours_per_day:
+            added = False
+            for subject in day["subjects"]:
+                subject_name = subject["name"]
+                if not subject_all_tasks[subject_name]:
+                    continue
 
-            selected_tasks = []
-            current_time = 0
-            tasks = subject_all_tasks[subject_name]
-            while tasks and current_time < target_time:
-                next_task = tasks[0]  # Take the next task from the sorted sequence
+                next_task = subject_all_tasks[subject_name][0]
                 task_time = get_task_time(next_task)
 
-                if day_time + task_time <= max_hours_per_day:  # Allow if its under the max limit
-                    selected_tasks.append(tasks.pop(0))
-                    current_time += task_time
+                if regular_time + task_time <= regular_task_limit and day_time + task_time <= max_hours_per_day:
+                    pending_regular_tasks[day_index][subject_name].append(subject_all_tasks[subject_name].pop(0))
+                    regular_time += task_time
                     day_time += task_time
-                else:
-                    # If Task doesn't fit, save for next day
+                    added = True
+            if not added:
+                break
+
+        # Step 2: Allocate incomplete tasks if they exist
+        if has_incomplete_tasks and incomplete_task_limit > 0:
+            incomplete_time = 0
+            while incomplete_time < incomplete_task_limit and day_time < max_hours_per_day:
+                added = False
+                for subject in day["subjects"]:
+                    subject_name = subject["name"]
+                    if not incomplete_tasks[subject_name]:
+                        continue
+
+                    next_task = incomplete_tasks[subject_name][0]
+                    task_time = get_task_time(next_task)
+
+                    if incomplete_time + task_time <= incomplete_task_limit and day_time + task_time <= max_hours_per_day:
+                        pending_incomplete_tasks[day_index][subject_name].append(incomplete_tasks[subject_name].pop(0))
+                        incomplete_time += task_time
+                        day_time += task_time
+                        added = True
+
+                # Check if we've depleted all incomplete tasks
+                if not any(tasks for tasks in incomplete_tasks.values()):
+                    has_incomplete_tasks = False
+                    break
+                if not added:
                     break
 
-            if day_index == len(roadmap['schedule']) - 1:
-                if tasks:
-                    for task in tasks:
-                        selected_tasks.append(task)
+        # Step 3: Use remaining time for additional regular tasks if available
+        if day_time < target_time:
+            while day_time < target_time:
+                added = False
+                for subject in day["subjects"]:
+                    subject_name = subject["name"]
+                    if not subject_all_tasks[subject_name]:
+                        continue
+
+                    next_task = subject_all_tasks[subject_name][0]
+                    task_time = get_task_time(next_task)
+
+                    if day_time + task_time <= max_hours_per_day:
+                        pending_regular_tasks[day_index][subject_name].append(subject_all_tasks[subject_name].pop(0))
+                        day_time += task_time
+                        added = True
+                    if day_time > target_time:
+                        break
+                if not added:
+                    break
 
-            # Update the subject's tasks
-            subject["tasks"] = selected_tasks
-            subject_all_tasks[subject_name] = tasks
+    extra_day_tasks = []
+    if extra_distribution:
+        if incomplete_tasks_by_subject:
+            for subject, tasks in incomplete_tasks_by_subject.items():
+                incomplete_tasks[subject].extend(tasks)
+        extra_day_tasks = add_tasks_for_extra_days(subject_all_tasks,
+                                                   incomplete_tasks,
+                                                   extra_day_tasks,
+                                                   extra_distribution,
+                                                   (80, 20),
+                                                   max_hours_per_day)
+        # Final appending of tasks
+        for day_index, day in enumerate(roadmap[1:], 1):
+            for subject in day["subjects"]:
+                subject_name = subject["name"]
+                subject["tasks"] = (
+                    pending_regular_tasks[day_index][subject_name] +
+                    pending_incomplete_tasks[day_index][subject_name]
+                    )
+    else:
+        for day_index, day in enumerate(roadmap[1:], 1):
+            if day_index == len(roadmap) - 1:
+                for subject in day["subjects"]:
+                    subject_name = subject["name"]
+
+                    # Add remaining regular tasks
+                    while subject_all_tasks[subject_name]:
+                        task = subject_all_tasks[subject_name].pop(0)
+                        pending_regular_tasks[day_index][subject_name].append(task)
+
+                    # Add remaining incomplete tasks
+                    while incomplete_tasks[subject_name]:
+                        task = incomplete_tasks[subject_name].pop(0)
+                        pending_incomplete_tasks[day_index][subject_name].append(task)
+
+            # Final appending of tasks
+            for subject in day["subjects"]:
+                subject_name = subject["name"]
+                subject["tasks"] = (
+                    pending_regular_tasks[day_index][subject_name] +
+                    pending_incomplete_tasks[day_index][subject_name]
+            )
+    return roadmap, extra_day_tasks
+
+def update_roadmap(current_roadmap, current_dayNumber, max_hours_per_day, dependencies, no_of_revision_days = 2):
+    if current_dayNumber == 1:
+        return current_roadmap
+    current_roadmap = copy.deepcopy(current_roadmap)
+    day_index = current_dayNumber-2
+
+    # Check if a test exists in any specified day
+    for day in current_roadmap['schedule']:
+        if 'test_portion' in day:
+            test_index = current_roadmap['schedule'].index(day)
+            if test_index > (current_dayNumber-1):
+                time_to_test = test_index - (current_dayNumber-1)
+                test_portions = day['test_portion']
+                break
+            else:
+                test_index = None
+                break
+
+
+    extra_rev_days = max(no_of_revision_days - 2, 0)
+
+    # Determine scheduling strategy based on time to test
+    if test_index is not None:
+        if 30 >= time_to_test > 25:
+            # Far from test: Normal scheduling with backlog reduction
+            before_checkpoint = current_roadmap['schedule'][day_index:day_index+(time_to_test-25)]
+            after_checkpoint = current_roadmap['schedule'][day_index+(time_to_test-25):]
+            max_hours_per_day = 16
+            ratio = (80, 20)
+            test_portions = None
+            dependencies = None
+        elif 25 >= time_to_test > (10 + extra_rev_days):
+            # Mid-range: focus on current coursework
+            before_checkpoint = current_roadmap['schedule'][day_index:day_index+(time_to_test-(10+extra_rev_days))]
+            after_checkpoint = current_roadmap['schedule'][day_index+(time_to_test-(10+extra_rev_days)):]
+            max_hours_per_day = 16
+            ratio = (80, 20)
+            test_portions = None
+            dependencies = None
+        elif (10 + extra_rev_days) >= time_to_test > no_of_revision_days:
+            # Approaching test: Balance current work with test preparation
+            before_checkpoint = current_roadmap['schedule'][day_index:day_index+(time_to_test-no_of_revision_days)]
+            after_checkpoint = current_roadmap['schedule'][day_index+(time_to_test-no_of_revision_days):]
+            max_hours_per_day = 16
+            ratio = (50, 50)
+        elif 0 < time_to_test <= no_of_revision_days:
+            # Final revision period: Focus entirely on test preparation
+            before_checkpoint = current_roadmap['schedule'][day_index:test_index]
+            after_checkpoint = current_roadmap['schedule'][test_index:]
+            max_hours_per_day = 16
+            ratio = (0, 100)
+    else:
+        # No upcoming test: Normal scheduling
+        if day_index + 4 <= len(current_roadmap['schedule']):
+            before_checkpoint = current_roadmap['schedule'][day_index:day_index+4]
+            after_checkpoint = current_roadmap['schedule'][day_index+4:]
+        else:
+            print("Helloo")
+            before_checkpoint = current_roadmap['schedule'][day_index:]
+            after_checkpoint = []
+        ratio = (80, 20)
+        test_portions = None
+        dependencies = None
+    new_roadmap, extra_day_tasks = shift_the_roadmap(before_checkpoint,
+                                                     max_hours_per_day,
+                                                     ratio,
+                                                     dependencies,
+                                                     test_portions)
+    for day in new_roadmap:
+        new_date = day["date"]
+
+        for idx, existing_day in enumerate(current_roadmap['schedule']):
+            if existing_day['date'] == new_date:
+                current_roadmap['schedule'][idx] = day
+                ckp_idx = idx
+                break
+    if extra_day_tasks:
+        for day in extra_day_tasks:
+            for subject in day["subjects"]:
+                for task in subject['tasks']:
+                    task["Critical_Notification"] = "Unable to schedule - Too many backlogs"
+
+        num_extra_days = len(extra_day_tasks)
+        if test_index is not None:
+            if 30 >= time_to_test > (10 + extra_rev_days):
+                new_checkpoint = copy.deepcopy(after_checkpoint)
+                day = copy.deepcopy(after_checkpoint[0])
+                for subject in day['subjects']:
+                    sub_name = subject["name"]
+                    subject['tasks'] = [
+                        task for day in extra_day_tasks
+                        for subj in day["subjects"]
+                        if subj["name"] == sub_name
+                        for task in subj["tasks"]
+                        ]
+                day["dayNumber"] = new_checkpoint[0]["dayNumber"] - 1
+                day["date"] = (datetime.strptime(new_checkpoint[0]["date"], "%Y-%m-%d")
+                                - timedelta(days=1)).strftime("%Y-%m-%d")
+                new_checkpoint.insert(0, day)
+                curr_roadmap, extra_days = shift_the_roadmap(roadmap=new_checkpoint,
+                                      max_hours_per_day = max_hours_per_day,
+                                      ratio = ratio,
+                                      dependencies = dependencies,
+                                      test_portions = test_portions)
+                new_roadmap = current_roadmap['schedule'][:ckp_idx+1]
+                new_roadmap.extend(curr_roadmap[1:])
+                current_roadmap['schedule'] = new_roadmap
+            elif 0 < time_to_test <= (10 + extra_rev_days):
+                # Step 1: Add empty days at the end
+                last_day = current_roadmap['schedule'][-1]
+                last_date = datetime.strptime(last_day["date"], "%Y-%m-%d")
+                last_day_number = last_day["dayNumber"]
+                for i in range(num_extra_days):
+                    new_day = {
+                        "dayNumber": last_day_number + i + 1,
+                        "date": (last_date + timedelta(days=i + 1)).strftime("%Y-%m-%d"),
+                        "subjects": []
+                    }
+                    current_roadmap['schedule'].append(new_day)
+
+                # Step 2: Shift 'subject' key from test_index to end in reverse order
+                total_days = len(current_roadmap['schedule'])
+                for i in range(total_days - num_extra_days - 1, test_index - 1, -1):
+                    from_day = current_roadmap['schedule'][i]
+                    to_day = current_roadmap['schedule'][i + num_extra_days]
+
+                    to_day["subjects"] = from_day["subjects"]
+
+                # Step 3: Insert the extra_day_tasks into the cleared slots starting at test_index
+                for i, new_task_day in enumerate(extra_day_tasks):
+                    target_day = current_roadmap['schedule'][test_index + i]
+                    target_day["subjects"] = new_task_day["subjects"]
+
+        else:
+            if day_index + 4 <= len(current_roadmap['schedule']):
+                new_checkpoint = copy.deepcopy(after_checkpoint)
+                day = copy.deepcopy(after_checkpoint[0])
+                for subject in day['subjects']:
+                    sub_name = subject["name"]
+                    subject['tasks'] = [
+                          task for day in extra_day_tasks
+                          for subj in day["subjects"]
+                          if subj["name"] == sub_name
+                          for task in subj["tasks"]
+                          ]
+
+                day["dayNumber"] = new_checkpoint[0]["dayNumber"] - 1
+                day["date"] = (datetime.strptime(new_checkpoint[0]["date"], "%Y-%m-%d")
+                                - timedelta(days=1)).strftime("%Y-%m-%d")
+                new_checkpoint.insert(0, day)
+                curr_roadmap, extra_days = shift_the_roadmap(roadmap=new_checkpoint,
+                                      max_hours_per_day = max_hours_per_day,
+                                      ratio = ratio,
+                                      dependencies = dependencies,
+                                      test_portions = test_portions)
+                new_roadmap = current_roadmap['schedule'][:ckp_idx+1]
+                new_roadmap.extend(curr_roadmap[1:])
+                current_roadmap['schedule'] = new_roadmap
+            else:
+                for tasks in extra_day_tasks:
+                    day = copy.deepcopy(new_roadmap[-1])
+                    day["dayNumber"] = current_roadmap['schedule'][-1]["dayNumber"] + 1
+                    day["date"] = (datetime.strptime(current_roadmap['schedule'][-1]["date"], "%Y-%m-%d")
+                                    + timedelta(days=1)).strftime("%Y-%m-%d")
+                    day['subjects'] = tasks['subjects']
+                    current_roadmap['schedule'].append(day)
 
     with open("current_roadmap.json", "w") as f:
-        json.dump(roadmap, f, indent=4)
+        json.dump(current_roadmap, f, indent=4)
 
-    session_state['updated_roadmap'] = roadmap
+    session_state['updated_roadmap'] = current_roadmap
 
 # AGENT 2
 def generate_sql_for_report(llm, prompt):
@@ -813,11 +1188,27 @@ def agent1(choice: Optional[str] = Query("Four Day Roadmap", description="Choose
     return {"message": "No report data available."}
 
 
+@app.get("/testscheduler")
+def testscheduler(
+    date : str = Query("2025-02-23", description="Enter the date to schedule the test"),
+    physics : list = Query(["Properties of Solids and Liquids"], description="Enter the chapters for test in physics as a list"),
+    chemistry : list = Query(["Equilibrium"], description="Enter the chapters for test in chemistry as a list"),
+    maths : list = Query(["Limits,Continuity and Differentiability"], description="Enter the chapters for test in maths as a list"),
+):
+    """
+    Helps in Scheduling of Tests in the roadmap
+    """
+
+    session_state["data"] = add_test(session_state["data"], date, physics, chemistry, maths)
+
+    return {"sucessful": "Test Succesfully Scheduled in the roadmap"}
+
 # --- AGENT 2: Roadmap Manager (Roadmap Manager Page) ---
 @app.get("/agent2")
 def agent2(
-    dayNumber: int = Query(1, description="Today's day number for rescheduling tasks"),
-    max_hours_per_day: int = Query(8, description="Maximum number of hours per day")
+    current_dayNumber: int = Query(2, description="Today's day number for rescheduling tasks"),
+    max_hours_per_day: int = Query(8, description="Maximum number of hours per day"),
+    no_of_revision_days: int = Query(2, description="Number of days needed for revision in case of a test")
 ):
     """
     Agent 2 - Roadmap Manager: Processes tasks and optimizes the roadmap based on user input.
@@ -827,12 +1218,11 @@ def agent2(
         return {"error": "Roadmap data not loaded. Load data first."}
 
     # Optimize task distribution with user input
-    shift_and_sort_the_roadmap(
-        session_state["full_roadmap"], 
-        session_state["data"], 
-        dayNumber=dayNumber, 
-        max_hours_per_day=max_hours_per_day
-    )
+    update_roadmap(current_roadmap = session_state["data"],
+                    current_dayNumber = current_dayNumber,
+                    max_hours_per_day = max_hours_per_day,
+                    dependencies = session_state["dependencies"],
+                    no_of_revision_days = no_of_revision_days)
 
     # Return full updated roadmap
     if session_state["data"] and session_state["updated_roadmap"]:

dependencies.json

@@ -0,0 +1,178 @@
+{
+    "Physics": {
+        "Physics and Measurement": [],
+        "Kinematics": [
+            "Physics and Measurement"
+        ],
+        "Laws of Motion": [
+            "Kinematics"
+        ],
+        "Work, Energy and Power": [
+            "Laws of Motion",
+            "Kinematics"
+        ],
+        "Rotational Motion": [
+            "Work, Energy and Power",
+            "Laws of Motion",
+            "Kinematics"
+        ],
+        "Gravitation": [
+            "Laws of Motion",
+            "Work, Energy and Power"
+        ],
+        "Properties of Solids and Liquids": [
+            "Rotational Motion"
+        ],
+        "Thermodynamics": [
+            "Properties of Solids and Liquids"
+        ],
+        "Kinetic Theory of Gases": [
+            "Thermodynamics"
+        ],
+        "Oscillations and Waves": [
+            "Work, Energy and Power",
+            "Kinematics"
+        ],
+        "Electrostatics": [
+            "Physics and Measurement",
+            "Vector Algebra"
+        ],
+        "Current Electricity": [
+            "Electrostatics"
+        ],
+        "Magnetic Effects of Current and Magnetism": [
+            "Current Electricity"
+        ],
+        "Electromagnetic Induction and Alternating Currents": [
+            "Magnetic Effects of Current and Magnetism",
+            "Current Electricity"
+        ],
+        "Optics": [
+            "Electrostatics",
+            "Wave Optics Basics"
+        ],
+        "Dual Nature of Matter and Radiation": [
+            "Optics",
+            "Kinetic Theory of Gases"
+        ],
+        "Atoms and Nuclei": [
+            "Physics and Measurement"
+        ],
+        "Electronic Devices": [
+            "Current Electricity",
+            "Electromagnetic Induction and Alternating Currents"
+        ],
+        "Communication Systems": [
+            "Electronic Devices"
+        ]
+    },
+    "Chemistry": {
+        "Some Basic Concepts in Chemistry": [],
+        "Atomic Structure": [
+            "Some Basic Concepts in Chemistry"
+        ],
+        "Chemical Bonding and Molecular Structure": [
+            "Atomic Structure"
+        ],
+        "Chemical Thermodynamics": [
+            "Some Basic Concepts in Chemistry",
+            "Atomic Structure"
+        ],
+        "Solutions": [
+            "Some Basic Concepts in Chemistry",
+            "Chemical Thermodynamics"
+        ],
+        "Equilibrium": [
+            "Chemical Thermodynamics",
+            "Solutions"
+        ],
+        "Redox Reactions and Electrochemistry": [
+            "Chemical Thermodynamics",
+            "Equilibrium"
+        ],
+        "Chemical Kinetics": [
+            "Chemical Thermodynamics",
+            "Equilibrium"
+        ],
+        "Classification of Elements and Periodicity in Properties": [
+            "Atomic Structure"
+        ],
+        "P Block Elements": [
+            "Classification of Elements and Periodicity in Properties"
+        ],
+        "D and F Block Elements": [
+            "Classification of Elements and Periodicity in Properties"
+        ],
+        "Coordination Compounds": [
+            "Chemical Bonding and Molecular Structure",
+            "P Block Elements",
+            "D and F Block Elements"
+        ],
+        "Purification and Characteristics of Organic Compounds": [],
+        "Some Basic Principles of Organic Chemistry": [],
+        "Hydrocarbons": [
+            "Some Basic Principles of Organic Chemistry"
+        ],
+        "Organic Compounds Containing Halogens": [
+            "Some Basic Principles of Organic Chemistry",
+            "Hydrocarbons"
+        ],
+        "Organic Compounds Containing Oxygen": [
+            "Some Basic Principles of Organic Chemistry",
+            "Hydrocarbons"
+        ],
+        "Organic Compounds Containing Nitrogen": [
+            "Some Basic Principles of Organic Chemistry",
+            "Hydrocarbons"
+        ],
+        "Biomolecules": [
+            "Organic Compounds Containing Oxygen",
+            "Organic Compounds Containing Nitrogen"
+        ]
+    },
+    "Maths": {
+        "Sets, Relations and Functions": [],
+        "Complex Numbers and Quadratic Equations": [
+            "Sets, Relations and Functions"
+        ],
+        "Matrices and Determinants": [
+            "Sets, Relations and Functions"
+        ],
+        "Permutations and Combinations": [
+            "Sets, Relations and Functions"
+        ],
+        "Binomial Theorem and its Simple Application": [
+            "Sets, Relations and Functions"
+        ],
+        "Sequence and Series": [
+            "Sets, Relations and Functions"
+        ],
+        "Limits, Continuity and Differentiability": [
+            "Sets, Relations and Functions",
+            "Binomial Theorem and its Simple Application"
+        ],
+        "Integral Calculus": [
+            "Limits, Continuity and Differentiability"
+        ],
+        "Differential Equations": [
+            "Integral Calculus",
+            "Limits, Continuity and Differentiability"
+        ],
+        "Co-ordinate Geometry": [
+            "Sets, Relations and Functions"
+        ],
+        "Three Dimensional Geometry": [
+            "Co-ordinate Geometry"
+        ],
+        "Vector Algebra": [
+            "Co-ordinate Geometry"
+        ],
+        "Statistics and Probability": [
+            "Sets, Relations and Functions"
+        ],
+        "Trigonometry": [
+            "Sets, Relations and Functions",
+            "Limits, Continuity and Differentiability"
+        ]
+    }
+}