553 lines
22 KiB
Python
553 lines
22 KiB
Python
#!/usr/bin/env python3.11
|
|
import json
|
|
import random
|
|
from string import hexdigits
|
|
|
|
from app.util.globals import flex, Error
|
|
from app.util.estimateGrade import getGradeFromCourseCode
|
|
|
|
# Takes in information to create or add a new conflict
|
|
# Returns if the particular student has a previous error
|
|
def newConflict(pupilNum: str, email: str, conflictType: str, code: str, description: str, logs: dict) -> bool:
|
|
exists = True if pupilNum in logs else False
|
|
log = {
|
|
"Pupil #": pupilNum,
|
|
"Email": email,
|
|
"Type": conflictType,
|
|
"Code": code,
|
|
"Conflict": description
|
|
}
|
|
if exists: logs[pupilNum].append(log)
|
|
else: logs[pupilNum] = [log]
|
|
return exists if conflictType == "Critical" else False
|
|
|
|
def insertConflictSolutions(pupilNum: str, logs: dict, data: dict) -> None:
|
|
log = logs[pupilNum]
|
|
for conflict in log:
|
|
if conflict["Type"] == "Critical":
|
|
conflict["Missing"] = data
|
|
break
|
|
|
|
# V3 differs a lot by V1/2 as it does not focus on fitting the classes
|
|
# into the time table first.
|
|
# It starts by trying to get all classes full and give all students a full class list.
|
|
# Then it starts to attempt to fit all classes into a timetable, making corretions along
|
|
# the way. Corrections being moving a students class
|
|
def generateScheduleV3(
|
|
students: list, # Refer to /util/mockStudents.py to see the students list structure
|
|
courses: dict, # Reger to /util/generateCourses.py to see the courses dictionary structure
|
|
minReq: int=18, # minimum requests for a class to run
|
|
classCap: int=30, # maximum students per class
|
|
blockClassLimit: int=40, # Block class limit is the number of classrooms available per block. Default 40 classes per block
|
|
totalBlocks: int=10, # total blocks between two semesters -> default is 10 for 5 per semester... or this can be 8 for 4 blocks per semester
|
|
studentsDir: str="../output/raw/students.json",
|
|
conflictsDir: str="../output/raw/conflicts.json",
|
|
coursesDir: str="../output/raw/courses.json"
|
|
) -> tuple[dict, Error]: # Returns the completed 'running' dictionary from above
|
|
|
|
# Return error that totalBlocks is invalid
|
|
if totalBlocks not in (10, 8):
|
|
totalBlockError = Error('Invalid totalBlocks', 'An invalid \'totalBlocks\' value was provided -> must be 10 or 8')
|
|
return (None, totalBlockError) # return none an signal failure
|
|
|
|
# First we need to setup some values
|
|
median = (minReq + classCap) // 2
|
|
blockPerSem = int(totalBlocks / 2)
|
|
running = {}
|
|
for i in range(1, totalBlocks + 1):
|
|
running[f'block{i}'] = {}
|
|
|
|
|
|
def equal(l: list) -> list: # Used to equalize list of numbers
|
|
q,r = divmod(sum(l),len(l))
|
|
return [q+1]*r + [q]*(len(l)-r)
|
|
|
|
|
|
# Step 1 - Calculate which classes can run
|
|
activeCourses = {}
|
|
for student in students:
|
|
# Tally class request
|
|
for request in (request for request in student["requests"] if not request["alt"] and request["CrsNo"] not in flex):
|
|
code = request["CrsNo"]
|
|
courses[code]["Requests"] += 1
|
|
# Add course to active list if enough requests
|
|
if courses[code]["Requests"] > minReq and courses[code]["CrsNo"] not in activeCourses:
|
|
activeCourses[code] = courses[code]
|
|
|
|
|
|
# Step 2 - Generate empty classes
|
|
allClassRunCounts = []
|
|
courseRunInfo = {} # Generated now, used in step 4
|
|
emptyClasses = {} # List of all classes with how many students should be entered during step 3
|
|
# calculate number of times to run class
|
|
for i in range(len(activeCourses)):
|
|
index = list(activeCourses)[i]
|
|
if index not in emptyClasses: emptyClasses[index] = {}
|
|
classRunCount = activeCourses[index]["Requests"] // median
|
|
remaining = activeCourses[index]["Requests"] % median
|
|
|
|
# Put number of classRunCount classes in emptyClasses
|
|
for j in range(classRunCount):
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"] = {
|
|
"CrsNo": index,
|
|
"Description": activeCourses[index]["Description"],
|
|
"expectedLen": median # Number of students expected in this class / may be altered later
|
|
}
|
|
|
|
# If remaining fit in open slots in existing classes
|
|
if remaining <= classRunCount * (classCap - median):
|
|
# Equally disperse remaining into existing classes
|
|
for j in range(classRunCount):
|
|
if remaining == 0: break
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] += 1
|
|
remaining -= 1
|
|
|
|
# If we can create a class using remaining, create class
|
|
elif remaining >= minReq:
|
|
# Create a class using remaining
|
|
emptyClasses[index][f"{index}-{hexdigits[classRunCount]}"] = {
|
|
"CrsNo": index,
|
|
"Description": activeCourses[index]["Description"],
|
|
"expectedLen": remaining
|
|
}
|
|
|
|
classRunCount += 1
|
|
# If a class previously existed
|
|
if classRunCount >= 2:
|
|
# Equalize (level) class expectedLen's
|
|
expectedLengths = [emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] for j in range(classRunCount)]
|
|
newExpectedLens = equal(expectedLengths)
|
|
for j in range(len(newExpectedLens)):
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] = newExpectedLens[j]
|
|
|
|
# Else if we can't fit remaining into available slots in existing classes,
|
|
# and it's unable to create its own class,
|
|
# and the required amount (minReq - remaining) to make a class is less than
|
|
# the number that existing classes can provide (classRunCount * (median - minReq))
|
|
elif minReq - remaining < classRunCount * (median - minReq):
|
|
# Take 1 from each class till min requirment met
|
|
for j in range(classRunCount):
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] -= 1
|
|
remaining += 1
|
|
if remaining == minReq: break
|
|
|
|
# Create a class using remaining + required amount from existing classes
|
|
emptyClasses[index][f"{index}-{hexdigits[classRunCount]}"] = {
|
|
"CrsNo": index,
|
|
"Description": activeCourses[index]["Description"],
|
|
"expectedLen": remaining
|
|
}
|
|
|
|
classRunCount += 1
|
|
|
|
# Equalize (level) class expectedLen's
|
|
expectedLengths = [emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] for j in range(classRunCount)]
|
|
newExpectedLens = equal(expectedLengths)
|
|
for j in range(len(newExpectedLens)):
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] = newExpectedLens[j]
|
|
|
|
else:
|
|
# In the case that the remaining requests are unable to be resolved
|
|
# Fill as many requests into existing classes. Any left that can't fit,
|
|
# Will need to be ignored so later we can fold them into their alternative
|
|
# requests
|
|
for j in range(classRunCount):
|
|
if remaining == 0: break
|
|
if emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] < classCap:
|
|
emptyClasses[index][f"{index}-{hexdigits[j]}"]["expectedLen"] += 1
|
|
remaining -= 1
|
|
|
|
courseRunInfo[index] = {
|
|
"Total": classRunCount,
|
|
"CrsNo": index
|
|
}
|
|
allClassRunCounts.append(classRunCount)
|
|
|
|
|
|
# Step 3 - Fill 'emptyClasses' with Students
|
|
selectedCourses = {}
|
|
tempStudents = list(students)
|
|
|
|
while len(tempStudents) > 0:
|
|
# Choose random student to prevent any success
|
|
# bias to students at the top of the list
|
|
student = tempStudents[random.randint(0, len(tempStudents)-1)]
|
|
|
|
alternates = [request for request in student["requests"] if request["alt"]]
|
|
for request in (request for request in student["requests"] if not request["alt"] and request["CrsNo"] not in flex):
|
|
course = request["CrsNo"]
|
|
getAvailableCourse = True
|
|
isAlt = False
|
|
while getAvailableCourse:
|
|
if course in emptyClasses:
|
|
# if course exists, get first available class
|
|
for cname in emptyClasses[course]:
|
|
if cname in selectedCourses:
|
|
if isAlt and emptyClasses[course][cname]["expectedLen"] < classCap:
|
|
emptyClasses[course][cname]["expectedLen"] += 1
|
|
if len(selectedCourses[cname]["students"]) < emptyClasses[course][cname]["expectedLen"]:
|
|
# Class exists with room for student
|
|
selectedCourses[cname]["students"].append({
|
|
"Pupil #": student["Pupil #"],
|
|
"index": student["studentIndex"]
|
|
})
|
|
getAvailableCourse = False
|
|
break
|
|
elif len(selectedCourses[cname]["students"]) == emptyClasses[course][cname]["expectedLen"]:
|
|
# If class is full, and there's no more classes available for that course
|
|
if cname[len(cname)-1] == f"{len(emptyClasses[course])-1}":
|
|
if len(alternates) > 0:
|
|
# Use alternate
|
|
course = alternates[0]["CrsNo"]
|
|
alternates.remove(alternates[0])
|
|
isAlt = True
|
|
break
|
|
else:
|
|
# Force break loop, ignore and let an admin
|
|
# handle options to solve for missing class
|
|
getAvailableCourse = False
|
|
break
|
|
elif cname not in selectedCourses:
|
|
selectedCourses[cname] = {
|
|
"students": [{
|
|
"Pupil #": student["Pupil #"],
|
|
"index": student["studentIndex"]
|
|
}],
|
|
"CrsNo": course,
|
|
"Description": courses[course]["Description"]
|
|
}
|
|
getAvailableCourse = False
|
|
break
|
|
|
|
elif course not in emptyClasses:
|
|
if len(alternates) > 0:
|
|
# Use alternate
|
|
course = alternates[0]["CrsNo"]
|
|
alternates.remove(alternates[0])
|
|
isAlt = True
|
|
else:
|
|
# Force break loop, ignore and let an admin
|
|
# handle options to solve for missing class
|
|
getAvailableCourse = False
|
|
|
|
students[student["studentIndex"]]["remainingAlts"] = alternates
|
|
tempStudents.remove(student)
|
|
|
|
|
|
# Step 4 - Attempt to fit classes into timetable
|
|
def stepIndex(offset: int, stepType: int) -> int:
|
|
# ALl this logic handles taking the # of blocks per semester, 4 or 5 and calculating
|
|
# the number used to step between the index of the first or second semester
|
|
|
|
# stepType 0 is for stepping between first and second semester
|
|
if stepType == 0: return blockPerSem if offset in (0, (-1 * (blockPerSem - 1))) else (-1 * (blockPerSem - 1))
|
|
|
|
# stepType 1 is for stepping between second and first semester
|
|
elif stepType == 1: return (-1 * blockPerSem) if offset in (0, (blockPerSem + 1)) else (blockPerSem + 1)
|
|
|
|
# Return Error if code is altered to cause error
|
|
else:
|
|
invalidStepTypeError = Error('Invalid stepType', 'An invalid \'stepType\' was passed to func \'stepIndex\'')
|
|
return (None, invalidStepTypeError)
|
|
|
|
# Create copy for step 6
|
|
courseRunInfoCopy = dict(courseRunInfo)
|
|
|
|
while len(allClassRunCounts) > 0:
|
|
# Get highest resource class (most times run)
|
|
index = allClassRunCounts.index(max(allClassRunCounts))
|
|
course = list(courseRunInfo)[index]
|
|
|
|
# Tally first and second semester
|
|
allSemBlockLens = [len(running[f'block{i}']) for i in range(1, totalBlocks + 1)]
|
|
|
|
# If there is more than one class Running
|
|
if allClassRunCounts[index] > 1:
|
|
blockIndex = allSemBlockLens.index(min(allSemBlockLens))
|
|
stepType = 0 if blockIndex < blockPerSem else 1
|
|
offset = 0
|
|
|
|
# Spread classes throughout both semesters
|
|
for i in range(courseRunInfo[course]["Total"]):
|
|
cname = f"{course}-{hexdigits[i]}"
|
|
classInserted = False
|
|
while not classInserted:
|
|
blockIndex += offset
|
|
if len(running[f'block{blockIndex+1}']) < blockClassLimit:
|
|
running[list(running)[blockIndex]][cname] = {
|
|
"CrsNo": course,
|
|
"Description": emptyClasses[course][cname]["Description"],
|
|
"students": selectedCourses[cname]["students"]
|
|
}
|
|
allClassRunCounts[index] -= 1
|
|
classInserted = True
|
|
|
|
offset = stepIndex(offset, stepType)
|
|
|
|
if blockIndex >= (totalBlocks - 1):
|
|
blockIndex = 0 if stepType == 0 else blockPerSem
|
|
offset = 0
|
|
|
|
# If the class only runs once, place in semester with least classes
|
|
elif allClassRunCounts[index] == 1:
|
|
# Equally disperse into semesters classes
|
|
|
|
# Get block with least classes
|
|
leastBlock = allSemBlockLens.index(min(allSemBlockLens)) + 1
|
|
cname = f"{course}-0"
|
|
|
|
running[f"block{leastBlock}"][cname] = {
|
|
"CrsNo": course,
|
|
"Description": emptyClasses[course][cname]["Description"],
|
|
"students": selectedCourses[cname]["students"],
|
|
}
|
|
|
|
allClassRunCounts[index] -= 1
|
|
|
|
# Remove course when fully inserted
|
|
if allClassRunCounts[index] == 0:
|
|
allClassRunCounts.remove(allClassRunCounts[index])
|
|
courseRunInfo.pop(list(courseRunInfo)[index])
|
|
|
|
# Step 5 - Fill student schedule
|
|
for block in running:
|
|
for cname in running[block]:
|
|
for student in running[block][cname]["students"]:
|
|
students[student["index"]]["schedule"][block].append(cname)
|
|
students[student["index"]]["classes"] += 1
|
|
|
|
|
|
# Step 6 - Evaluate, move students to fix conflicts
|
|
conflictLogs = {}
|
|
criticalCount, acceptableCount = 0, 0
|
|
c_mc_count, c_cr_count, a_mc_count = 0, 0, 0
|
|
studentsCritical, studentsAcceptable = 0, 0
|
|
|
|
for student in students:
|
|
blocks = [student["schedule"][block] for block in student["schedule"]]
|
|
hasConflicts = True if sum(1 for b in blocks if len(b)>1) > 0 else False
|
|
|
|
# If there is no conflicts
|
|
# and classes inserted to is equal to expectedClasses
|
|
# or classes the student is inserted to is missing
|
|
# no more than two classes:
|
|
# continue to next student
|
|
if not hasConflicts and student["classes"] == student["expectedClasses"]: continue
|
|
elif not hasConflicts and (student["expectedClasses"]-2) <= student["classes"] < student["expectedClasses"]:
|
|
# TODO: Insert alternates if available?
|
|
a_mc_count += 1
|
|
acceptableCount += 1
|
|
if not newConflict(student["Pupil #"], "", "Acceptable", "A-MC", "Missing 1-2 Classses", conflictLogs): studentsAcceptable += 1
|
|
continue
|
|
|
|
studentData = {
|
|
"Pupil #": student["Pupil #"],
|
|
"index": student["studentIndex"]
|
|
}
|
|
|
|
if hasConflicts:
|
|
student["classes"] = 0
|
|
missing = []
|
|
# Clear student schedule to restructure
|
|
for block in student["schedule"]:
|
|
[running[block][cname]["students"].remove(studentData) for cname in student["schedule"][block]]
|
|
student["schedule"][block] = []
|
|
|
|
# Find class in student schedule that's run the least
|
|
classes, runCounts = [], []
|
|
for block in blocks:
|
|
for cname in block:
|
|
classes.append(cname[:-2])
|
|
runCounts.append(courseRunInfoCopy[cname[:-2]]["Total"])
|
|
|
|
# Rebuild student schedule
|
|
availableBlocks = [f'block{i}' for i in range(1, totalBlocks + 1)]
|
|
while len(classes) > 0:
|
|
index = runCounts.index(min(runCounts)) # Get class least run
|
|
found = False
|
|
|
|
# find slot for class
|
|
for block in availableBlocks:
|
|
if found: break
|
|
for cname in running[block]:
|
|
if cname[:-2] == classes[index] and len(running[block][cname]["students"]) < classCap:
|
|
running[block][cname]["students"].append(studentData)
|
|
student["schedule"][block].append(cname)
|
|
availableBlocks.remove(block)
|
|
student["classes"] += 1
|
|
found = True
|
|
break
|
|
|
|
if not found:
|
|
# Determine all places class exists
|
|
existsIn, existingClassNames = [], []
|
|
for block in running:
|
|
for cname in running[block]:
|
|
if cname[:-2] == classes[index] and len(running[block][cname]["students"]) < classCap:
|
|
existsIn.append(block)
|
|
existingClassNames.append(cname)
|
|
|
|
# Attempt to fix
|
|
solution = False
|
|
if len(existsIn) > 0:
|
|
for i, existing in enumerate(existsIn):
|
|
if solution: break
|
|
classOut = student["schedule"][existing][0]
|
|
for block in running:
|
|
if solution: break
|
|
if block == existing or block not in availableBlocks: continue
|
|
for cname in running[block]:
|
|
if cname[:-2] == classOut[:-2] and len(running[block][cname]["students"]) < classCap:
|
|
student["classes"] += 1
|
|
|
|
# Move to existing class elsewhere
|
|
student["schedule"][block].append(cname)
|
|
running[block][cname]["students"].append(studentData)
|
|
|
|
# Overwrite old class
|
|
running[existing][student["schedule"][existing][0]]["students"].remove(studentData)
|
|
student["schedule"][existing][0] = existingClassNames[i]
|
|
running[existing][existingClassNames[i]]["students"].append(studentData)
|
|
|
|
solution = True
|
|
break
|
|
|
|
if not solution:
|
|
# Try alternate
|
|
alternates = [alt["CrsNo"] for alt in students[student["studentIndex"]]["remainingAlts"] if alt["CrsNo"] not in flex and alt["CrsNo"] in courseRunInfoCopy]
|
|
if len(alternates) == 0: # If no alternates, create critical error
|
|
c_cr_count += 1
|
|
criticalCount += 1
|
|
|
|
missing.append({
|
|
"block": f'block{index + 1}',
|
|
"CrsNo": classes[index]
|
|
})
|
|
|
|
if not newConflict(
|
|
student["Pupil #"],
|
|
"", # Student Email
|
|
"Critical", # Err type
|
|
"C-CR", # Err code
|
|
"Couldn't Resolve", # Err msg
|
|
conflictLogs): # logs dir
|
|
studentsCritical += 1
|
|
|
|
else:
|
|
# Get alternate least run
|
|
altRunCounts = [courseRunInfoCopy[alt]["Total"] for alt in alternates]
|
|
altIndex = altRunCounts.index(min(altRunCounts))
|
|
|
|
# add alternate
|
|
classes.append(alternates[altIndex])
|
|
runCounts.append(altRunCounts[altIndex])
|
|
|
|
# Remove alternate from remaining alternates
|
|
for remaining in students[student["studentIndex"]]["remainingAlts"]:
|
|
if remaining["CrsNo"] == alternates[altIndex]:
|
|
students[student["studentIndex"]]["remainingAlts"].remove(remaining)
|
|
|
|
# Remove class after inserted or failed to insert
|
|
classes.remove(classes[index])
|
|
runCounts.remove(runCounts[index])
|
|
|
|
# Collect missing course data and solutions
|
|
|
|
if len(missing) > 0:
|
|
data = []
|
|
|
|
if student["gradelevel"] is None:
|
|
for obj in missing:
|
|
data["missing"].append({
|
|
"CrsNo": obj["CrsNo"],
|
|
"block": obj['block'],
|
|
"solutions": None,
|
|
"error": "Unable to find solutions, err no grade"
|
|
})
|
|
|
|
else:
|
|
for obj in missing:
|
|
blockSolution = { "CrsNo": obj["CrsNo"], "block": obj['block'], "solutions": [] }
|
|
for cname in running[obj['block']]:
|
|
courseGrade = getGradeFromCourseCode(cname[:-2])
|
|
if courseGrade is None: continue
|
|
if (student["gradelevel"] == courseGrade) or (student["gradelevel"] == 12 and courseGrade == 11):
|
|
if len(running[obj['block']][cname]["students"]) < classCap:
|
|
blockSolution["solutions"].append({
|
|
"CrsNo": cname,
|
|
"Description": running[obj['block']][cname]["Description"]
|
|
})
|
|
|
|
data.append(blockSolution)
|
|
|
|
insertConflictSolutions(student["Pupil #"], conflictLogs, data)
|
|
|
|
metSelfRequirements = True if student["classes"] == student["expectedClasses"] else False
|
|
if not metSelfRequirements:
|
|
|
|
if (student["expectedClasses"] - 2) <= student["classes"] < student["expectedClasses"]:
|
|
a_mc_count += 1
|
|
acceptableCount += 1
|
|
if not newConflict(student["Pupil #"], "", "Acceptable", "A-MC", "Missing 1-2 Classses", conflictLogs): studentsAcceptable += 1
|
|
|
|
elif student["classes"] < (student["expectedClasses"] - 2):
|
|
# Difference between classes inserted to and
|
|
# expected classes is too great
|
|
if student["Pupil #"] in conflictLogs:
|
|
c_mc_count += 1
|
|
criticalCount += 1
|
|
if not newConflict(student["Pupil #"], "", "Critical", "C-MC", "Missing too many Classses", conflictLogs): studentsCritical += 1
|
|
|
|
finalConflictLogs = {
|
|
"Conflicts": conflictLogs,
|
|
"Critical": {
|
|
"Total": criticalCount,
|
|
"Students": studentsCritical,
|
|
"Errors": [{
|
|
"Total": c_mc_count,
|
|
"Description": "Missing too many Classes",
|
|
"Code": "C-MC"
|
|
}, {
|
|
"Total": c_cr_count,
|
|
"Description": "Couldn't Resolve",
|
|
"Code": "C-CR"
|
|
}]
|
|
},
|
|
"Acceptable": {
|
|
"Total": acceptableCount,
|
|
"Students": studentsAcceptable,
|
|
"Errors": [{
|
|
"Total": a_mc_count,
|
|
"Description": "Missing 1-2 Classes",
|
|
"Code": "A-MC"
|
|
}]
|
|
}
|
|
}
|
|
|
|
# Log Conflict to records
|
|
with open(conflictsDir, "w") as outfile:
|
|
json.dump(finalConflictLogs, outfile, indent=2)
|
|
|
|
# Insert flex (spare) course codes to empty blocks
|
|
for student in students:
|
|
for block in student["schedule"]:
|
|
if len(student["schedule"][block]) == 0:
|
|
i = 0 if int(block[5:]) <= blockPerSem else 1
|
|
student["schedule"][block].append(flex[i])
|
|
|
|
# Read timetable and collect data on courses
|
|
for block in running:
|
|
for course in running[block]:
|
|
sem = "Sem1" if int(block[5:]) <= blockPerSem else "Sem2"
|
|
courses[running[block][course]["CrsNo"]][sem] += 1
|
|
|
|
# Update/log new student records
|
|
with open(studentsDir, "w") as outfile:
|
|
json.dump(students, outfile, indent=2)
|
|
|
|
# Update/log new course records
|
|
with open(coursesDir, "w") as outfile:
|
|
json.dump(courses, outfile, indent=2)
|
|
|
|
return (running, None)
|