Create an algorithim to allocate time

[aellul27]

Inputs: subject tasks, due dates, unavaliablility and priorities of task
Outputs: list[studyperiod, time]. Aim to make day workloads as even as possible

[Lack-Of-Name]

Task Sorting Algorithm.txt
Volia!
It's in python. @aellul27

[Lack-Of-Name]

It might need some adjustments to leave unavailabilities alone. - will do now

[Lack-Of-Name]

Algorithm Draft.txt

# ========== CONFIGURABLE PARAMETERS ==========
WORK_BLOCK_MINUTES = 50
SHORT_BREAK_MINUTES = 10
LONG_BREAK_MINUTES = 30
LONG_BREAK_INTERVAL = 3  # hours

DAY_START_HOUR = 9
DAY_END_HOUR = 21

EARLY_START_URGENCY_THRESHOLD = 20
LATE_END_URGENCY_THRESHOLD = 25

K_URGENCY = 5  # urgency multiplier

TASKS_FILE = "tasks.json"
UNAVAILABILITY_FILE = "unavailability.json"
# =============================================

from datetime import datetime, timedelta
import json
import heapq

# Helper to calculate urgency
def calculate_urgency(priority, due_date_str):
    due_date = datetime.strptime(due_date_str, "%Y-%m-%d")
    days_until_due = (due_date - datetime.now()).days
    days_until_due = max(days_until_due, 0.1)
    return priority * (1 + K_URGENCY / days_until_due)

# Load tasks
with open(TASKS_FILE) as f:
    raw_tasks = json.load(f)

# Load unavailability
with open(UNAVAILABILITY_FILE) as f:
    raw_unavailability = json.load(f)

# Normalize unavailability to datetime ranges
unavailability_blocks = []
for _, entry in raw_unavailability.items():
    start_str, end_str = entry["Time"].split("–")
    start = datetime.fromisoformat(start_str.strip())
    end = datetime.fromisoformat(end_str.strip())
    unavailability_blocks.append((start, end))

def is_available(start_time, duration):
    end_time = start_time + timedelta(minutes=duration)
    for u_start, u_end in unavailability_blocks:
        if start_time < u_end and end_time > u_start:
            return False
    return True

# Flatten tasks and create a heap by urgency
tasks_heap = []
for subject, tasks in raw_tasks.items():
    for task_name, info in tasks.items():
        urgency = calculate_urgency(info["priority"], info["due date"])
        heapq.heappush(tasks_heap, (-urgency, {
            "name": task_name,
            "subject": subject,
            "urgency": urgency,
            "time_needed": info["time needed"],
            "due_date": info["due date"]
        }))

# Scheduler output
schedule = []
current_time = datetime.now().replace(hour=DAY_START_HOUR, minute=0, second=0, microsecond=0)

scheduled_minutes_today = 0
blocks_today = 0

while tasks_heap:
    urgency_neg, task = heapq.heappop(tasks_heap)
    time_left = task["time_needed"]

    while time_left > 0:
        # Check bounds and urgency override
        if current_time.hour < DAY_START_HOUR and task["urgency"] < EARLY_START_URGENCY_THRESHOLD:
            current_time = current_time.replace(hour=DAY_START_HOUR, minute=0)
        if current_time.hour >= DAY_END_HOUR and task["urgency"] < LATE_END_URGENCY_THRESHOLD:
            current_time = (current_time + timedelta(days=1)).replace(hour=DAY_START_HOUR, minute=0)
            scheduled_minutes_today = 0
            blocks_today = 0

        if not is_available(current_time, WORK_BLOCK_MINUTES):
            current_time += timedelta(minutes=10)
            continue

        block_duration = min(WORK_BLOCK_MINUTES, time_left)
        schedule.append([current_time.strftime("%Y-%m-%d %H:%M"), task["name"]])
        current_time += timedelta(minutes=block_duration)
        time_left -= block_duration
        scheduled_minutes_today += block_duration
        blocks_today += 1

        # Insert breaks
        if time_left > 0:
            if blocks_today % (LONG_BREAK_INTERVAL * 60 // WORK_BLOCK_MINUTES) == 0:
                current_time += timedelta(minutes=LONG_BREAK_MINUTES)
            else:
                current_time += timedelta(minutes=SHORT_BREAK_MINUTES)

# Final output
print(schedule)

[aellul27]

good database tables to support this?