Added time block class, worked on main algorithm, added tostring for sections, added bucket helpers, added constants for class times

Logan Endes · Logan Endes · commit dcbea18f9b9d · 2025-05-01T05:09:54.000-04:00
diff --git a/buckets.py b/buckets.py
@@ -1,5 +1,6 @@
 from student import Student
-from typing import List
+from typing import List, Dict
+import math
 
 class Buckets:
     """    
@@ -23,9 +24,11 @@ class Buckets:
     intermediateASL: list = []
     advancedASL: list = []
     
+    size_dict = {}
+    bucket_dict = {}
+    count_dict = {}
     
-    def sortcourses(self, students: List[Student]) -> None:
-        
+    def sort_courses(self, students: List[Student]) -> None:
         for student in students:    
             # Put into proper English bucket
             if student.english <= 3:
@@ -50,6 +53,29 @@ def sortcourses(self, students: List[Student]) -> None:
                 self.advancedASL.append(student)
             else:
                 self.intermediateASL.append(student)
+
+        self.bucket_dict = {
+            "beginningEnglish": self.beginningEnglish,
+            "intermediateEnglish": self.intermediateEnglish,
+            "advancedEnglish": self.advancedEnglish,
+            "beginningMath": self.beginningMath,
+            "intermediateMath": self.intermediateMath,
+            "advancedMath": self.advancedMath,
+            "beginningASL": self.beginningASL,
+            "intermediateASL": self.intermediateASL,
+            "advancedASL": self.advancedASL
+        }
+        self.size_dict = {
+            "beginningEnglish": len(self.beginningEnglish),
+            "intermediateEnglish": len(self.intermediateEnglish),
+            "advancedEnglish": len(self.advancedEnglish),
+            "beginningMath": len(self.beginningMath),
+            "intermediateMath": len(self.intermediateMath),
+            "advancedMath": len(self.advancedMath),
+            "beginningASL": len(self.beginningASL),
+            "intermediateASL": len(self.intermediateASL),
+            "advancedASL": len(self.advancedASL)
+        }
     
     def get_buckets(self) -> List[List[Student]]:
         return [
@@ -77,6 +103,25 @@ def get_bucket_sizes(self) -> List[int]:
             len(self.advancedASL)
         ]
     
+    def set_class_count(self, class_limit = 7) -> None:
+        """
+        Returns a list of tuples containing the course name and the number of sections.
+        """
+        for key, size in self.size_dict.items():
+            if size == 0:
+                self.count_dict[key] = 0
+            else:
+                self.count_dict[key] = math.ceil(size / class_limit)
+    
+    def get_class_count(self) -> Dict:
+        return self.count_dict
+    
+    def get_bucket_dict(self) -> Dict:
+        return self.bucket_dict
+    
+    def get_size_dict(self) -> Dict:
+        return self.size_dict
+    
     def __str__(self) -> str:
         sizes = self.get_bucket_sizes()
         return f"""
diff --git a/constants.py b/constants.py
@@ -1,3 +1,13 @@
-BEGGINER = 0
+from time_block import TimeBlock
+from datetime import time
+BEGINNER = 0
 INTERMEDIATE = 1
-ADAVANCED = 2
+ADVANCED = 2
+CLASS_LIMIT = 7
+BLOCK_ONE = TimeBlock(time(8, 0), time(9, 0))
+BLOCK_TWO = TimeBlock(time(9, 15), time(10, 15))
+BLOCK_THREE = TimeBlock(time(10, 45), time(11, 45))
+LUNCH_TIME = TimeBlock(time(11, 45), time(12, 45))
+BLOCK_FOUR = TimeBlock(time(12, 45), time(1, 45))
+BLOCK_FIVE = TimeBlock(time(2, 0), time(3, 0))
+BLOCK_SIX = TimeBlock(time(3, 30), time(4, 30))
diff --git a/main.py b/main.py
@@ -8,10 +8,14 @@
 
 A score of 0 means that no test score was received. In this instance, they will default to Beginner level.
 """
-from typing import List, Tuple
+from typing import List, Tuple, Dict, Union
 from student import Student
 from buckets import Buckets
 from teacher import Teacher
+from section import Section
+from constants import *
+import math
+
 
 def load_student_csv(file_name) -> List[Student]:
     """
@@ -51,7 +55,7 @@ def return_scores(students: List[Student]) -> List[Tuple[int, int, int]]:
 
 def make_buckets(students: List[Student]) -> Buckets:
     bucket = Buckets()
-    bucket.sortcourses(students)
+    bucket.sort_courses(students)
     return bucket
     
 def sort_students(students_to_score: List[Student]) -> List[Student]:
@@ -98,6 +102,94 @@ def load_instructor_csv(file_name) -> List[Teacher]:
             teachers.append(Teacher('Mentoring', mentor, 0, is_mentor=True))
     return teachers
 
+def create_sections_easy(class_count_dict: Dict) -> List[Section]:
+    """
+    Creates sections for each class assuming there is no issue with the number of students.
+    """
+    sections = []
+    for class_name, count in class_count_dict.items():
+        if count > 0:
+            for i in range(count):
+                level = 0
+                if "beginning" in class_name:
+                    level = BEGINNER
+                elif "intermediate" in class_name:
+                    level = INTERMEDIATE
+                elif "advanced" in class_name:
+                    level = ADVANCED
+
+                if "English" in class_name:
+                    name = "Essential Communication"
+                elif "Math" in class_name:
+                    name = "Technical Math"
+                elif "ASL" in class_name:
+                    name = "ASL"
+
+                sections.append(Section(name, None, CLASS_LIMIT, level, None))
+    return sections
+
+def create_sections_hard(class_count_dict: Dict, subject_availability_dict: Dict, subjects: Union[List, str]) -> Tuple[List[Section], Dict]:
+    """
+    Creates sections for each class assuming there is an issue with the number of students.
+    This function will create sections based on the availability of subjects.
+    If there are not enough sections available, it will prioritize lower level classes first, and then move higher classes to the overflow dictionary.
+    
+    IN FUTURE ITERATIONS, THIS SHOULD INSTEAD PRIORITIZE THE LARGER CLASS FIRST, THEN THE SMALLER CLASS.
+   
+    """
+    sections = []
+    overflow_dict = {}
+    class_counts = class_count_dict.items()
+
+    if isinstance(subjects, str):
+        subjects = [subjects]
+
+    # Loop through each class and add 1 sections until there are no more subjects available
+    subject_availability_dict = {key: value for key, value in subject_availability_dict.items() if key in subjects}  # Filter to only include relevant subjects
+
+    while any(subject_availability_dict.values()):  # Continue while there are available subjects
+        # print("Subject availability dict: ", subject_availability_dict)
+        for class_name, count in class_counts:
+            # print("Class name: ", class_name, "Count: ", count)
+            if count > 0:
+                # Determine the level based on the class name
+                level = 0
+                if "beginning" in class_name:
+                    level = BEGINNER
+                elif "intermediate" in class_name:
+                    level = INTERMEDIATE
+                elif "advanced" in class_name:
+                    level = ADVANCED
+
+                name = class_name
+                if "English" in class_name or "Communication" in class_name:
+                    name = "Essential Communication"
+                elif "Math" in class_name:
+                    name = "Technical Math"
+                elif "ASL" in class_name:
+                    name = "ASL"
+                
+                # Create a section and append it to the list
+                sections.append(Section(name, None, CLASS_LIMIT, level, None))
+                
+                # Decrement the count in subject_availability_dict
+                subject_availability_dict[name] -= 1
+                # Decrement the count in class_count_dict
+                class_count_dict[class_name] -= 1
+                # If the count reaches zero, remove it from the dictionary
+                if subject_availability_dict[name] <= 0:
+                    del subject_availability_dict[name]
+                    break
+                
+        # print(sections)
+    
+    # Add any remaining counts to overflow_dict
+    for class_name, count in class_count_dict.items():
+        if count > 0:
+            # print("Adding to overflow dict: ", class_name, count)
+            overflow_dict[class_name] = count
+    
+    return sections, overflow_dict
 
 
 def main():
@@ -107,15 +199,73 @@ def main():
     
     # Create buckets for each subject
     buckets = make_buckets(students)
+    buckets.set_class_count()
     
     # Print the students and their buckets
     print(len(students), "students loaded.")
     print(buckets)
     
     # Print instructors and classes
     print(len(instructors), "instructors loaded.")
+    subject_availability_dict = {}
     for instructor in instructors:
         print(instructor)
+        subject_availability_dict[instructor.subject] = instructor.sections if not subject_availability_dict.get(instructor.subject) else subject_availability_dict[instructor.subject] + instructor.sections
+
+    print(subject_availability_dict)
+
+    class_count_dict = buckets.get_class_count()
+
+    for class_name, count in class_count_dict.items():
+        print(f"{class_name}: {count} sections needed")
+
+    # Generate total counts of each class (both available and required)
+
+    english_required_dict = {key: value for key, value in class_count_dict.items() if "English" in key}
+    math_required_dict = {key: value for key, value in class_count_dict.items() if "Math" in key}
+    asl_required_dict = {key: value for key, value in class_count_dict.items() if "ASL" in key}
+
+    # Create section objects
+    print("Creating sections...")
+    if sum(english_required_dict.values()) <= subject_availability_dict.get("Essential Communication", 0):
+        english_sections = create_sections_easy(english_required_dict)
+        english_overflow = {}
+    else:
+        # print("Hard english")
+        english_sections, english_overflow = create_sections_hard(english_required_dict, subject_availability_dict, "Essential Communication")
+    if sum(math_required_dict.values()) <= subject_availability_dict.get("Technical Math", 0):
+        math_sections = create_sections_easy(math_required_dict)
+        math_overflow = {}
+    else:
+        # print("Hard math")
+        math_sections, math_overflow = create_sections_hard(math_required_dict, subject_availability_dict, "Technical Math")
+    if sum(asl_required_dict.values()) <= subject_availability_dict.get("ASL", 0):
+        asl_sections = create_sections_easy(asl_required_dict)
+        asl_overflow = {}
+    else:
+        # print("Hard asl")
+        asl_sections, asl_overflow = create_sections_hard(asl_required_dict, subject_availability_dict, "ASL")
+    
+    # Combine all sections into one list
+    all_sections = english_sections + math_sections + asl_sections
+    all_overflow = {**english_overflow, **math_overflow, **asl_overflow}
+    print(all_overflow)
+    # Print the sections
+    print("Sections created:")
+    for section in all_sections:
+        print(section)
+    
+
+    # Assign classes to the instructors
+    for instructor in instructors:
+        if instructor.sections > 0:
+            for class_name, count in class_count_dict.items():
+                if instructor.subject == class_name:
+
+                    instructor.sections -= count
+                    break
+
+    
     
 def test_instructors():
     instructors = load_instructor_csv('instructors.csv')
diff --git a/section.py b/section.py
@@ -1,11 +1,16 @@
+from typing import Tuple
+from time_block import TimeBlock
+from teacher import Teacher
+
+
 class Section:
     """ 
     Creates a section of a class that students will take
     Name: Name of the Class, could be seperated into 'name, difficulty'
-    Time: Available times of the class
+    Time: Time block of the class
     Capacity: How many students can take the class
     """
-    def __init__(self, subject, time, capacity, level, teacher):
+    def __init__(self, subject: str, time: TimeBlock, capacity: int, level: int, teacher: Teacher):
         self.__subject = subject
         self.__time = time
         self.__cap = capacity
@@ -49,5 +54,11 @@ def __eq__(self, other):
         if isinstance(other, Section):
             return self.__subject == other.__subject and self.__time == other.__time and self.__level == other.__level and self.__teacher == other.__teacher
         return False
+    
+    def __str__(self):
+        return f"Section({self.__subject}, {self.__time}, {self.__cap}, {self.__level}, {self.__teacher})"
+    
+    def __repr__(self):
+        return self.__str__()
         
     
diff --git a/students.csv b/students.csv
@@ -21,39 +21,4 @@ Lorenza Deckow,3,9,5
 Wellington Collier,3,4,9
 Derrick Glover V,8,9,4
 Quinton Lebsack,7,8,2
-Kaya Robel,1,7,6
-Lacy Metz,2,3,6
-Iliana Boehm,6,8,5
-Meaghan Hermann,3,3,9
-Kaden DuBuque,8,3,1
-Dr. Savion Dach,9,8,8
-Anderson Hessel,4,1,4
-Cordie Hyatt,2,3,4
-Miss Gay McDermott,8,5,3
-Fausto Lind,8,6,9
-Wilhelmine Pollich MD,8,7,9
-Lucinda Walter,7,8,2
-Mrs. Bruce Bailey,2,6,7
-Bernadine Bauch,8,7,8
-Jewell Blick,7,7,1
-Aida Kutch DDS,4,6,7
-Wiley Borer,4,5,7
-Domenick Reinger,5,3,3
-Jay Schmitt,6,2,4
-Xzavier Waelchi,8,2,1
-Viola Bogan,7,5,6
-Dr. Carlos Welch,2,7,7
-Hailey Borer DDS,2,6,6
-Franco Berge,7,9,9
-Albert Haag MD,1,4,6
-Kirsten Goldner,7,4,8
-Russ Herzog,5,4,3
-Dallas Kuhic,9,1,1
-Paul Beier,4,8,5
-Kellie Wuckert,8,6,1
-Bridgette Homenick,4,5,7
-Paula Graham,6,9,9
-Van Ratke PhD,1,1,4
-Theodore Maggio,3,2,4
-Crawford Casper,3,5,5
-Destiny Trantow,4,,8
+Kaya Robel,1,7,6
diff --git a/students_copy.csv b/students_copy.csv
diff --git a/time_block.py b/time_block.py
