Sorting availability dict by how available people are to teach

workshops.py

@@ -63,17 +63,50 @@ def can_teach(person: str, slot: list, capacity: int) -> bool:
 
 
 # Extracts relevant information from the df with availability and puts it into a useable format
-def convert_df(df):
-    people = []
+def convert_df(df, num_timeslots: int):
     # Key: person's name 
     # Value: a list of their availability 
     availability = {}
-    seen = set()
+
+
+    # Key: person's name 
+    # Value: how many workshops they want to teach
+    pref_dict = {}
+
+    # Instructors who can teach anytime
+    completely_available = []
+
     for row in range(len(df)): 
-        # TODO: make sure no people with the same name fill out the form 
         name = df.loc[row, NAME_COL]
+        curr_avail = df.loc[row, AVAIL_COL]
+        curr_avail = curr_avail.split(DELIMITER)
+
+        if len(curr_avail) == num_timeslots: 
+            completely_available.append(name)
             
-        number = df.loc[row, NUM_WORKSHOPS_COL]
+        else: 
+            curr_avail = [elem.strip() for elem in curr_avail]
+            availability[name] = curr_avail 
+            pref_dict[name] = df.loc[row, NUM_WORKSHOPS_COL]
+
+    
+    # Sorts a dictionary by length of the values such that the 
+    # key associated with the shortest value is first in the list {orders}
+    order = sorted(availability, key=lambda k: len(availability[k])) 
+
+    # The idea is start with people who are the LEAST available to teach, 
+    # then put the more available instructors into the available slots
+    new_avail_dict = {}
+
+    for instructor in order: 
+        new_avail_dict[instructor] = availability[instructor]
+        
+
+    # Sorts the dict such that people who want to teach less are first in the dict
+    pref_dict = {k: v for k, v in sorted(pref_dict.items(), key=lambda item: item[1])}
+
+    people = []
+    for name,number in pref_dict.items():             
         if number == 1: 
             people.append(name)
 
@@ -82,12 +115,8 @@ def convert_df(df):
             for i in range(number): 
                 people.append(name)
 
-        curr_avail = df.loc[row, AVAIL_COL]
-        curr_avail = curr_avail.split(DELIMITER)
-        curr_avail = [elem.strip() for elem in curr_avail]
-        availability[name] = curr_avail 
 
-    return people, availability 
+    return {'people': people, 'availability': new_avail_dict, 'completely_available': completely_available}
 
 
 
@@ -141,13 +170,12 @@ def find_all_schedules(people: list, availability: dict, schedule_obj: Schedule,
             # Unchoose (remove that person from the timeslot)
             schedule_obj.remove(person, time)
         # NOTE: this will not generate a full timeslot, but could still lead to a good schedule
-        '''
         else: 
             if len(people) == 1: 
                 find_all_schedules([], availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
             else: 
                 find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
-        '''
+        
     
     return
 
@@ -242,7 +270,7 @@ def get_description_dict(df):
 
 
 # Classifies schedules into two categories: complete and incomplete: 
-# Complete = everyone is teaching desired number of timeslots and each timeslot is filled 
+# Complete = everyone is teaching desired number of timeslots and each timeslot has at least one workshop
 # NOTE: I'm using "valid" instead of "complete" as a variable name so that I don't mix it up
 # Incomplete = not complete 
 def classify_schedules(people: list, schedules: list, partial_names: list, total_timeslots: int, max_timeslots_filled: int) -> tuple: 
@@ -345,43 +373,41 @@ def get_best_schedules(schedules: list, cutoff: str, max_workshops: int) -> list
 # Big wrapper function that calls the other functions
 def main(df, capacity:int, num_results: int, og_slots: list):     
     descrip_dict = get_description_dict(df)    
-    
-    # Convert the df with everyone's availability to a usable format
-    res = convert_df(df)
-    people = res[0]
-    availability = res[1]
-
-    # Sorts a dictionary by length of the values such that the 
-    # key associated with the shortest value is first in the list {orders}
-    order = sorted(availability, key=lambda k: len(availability[k])) 
-
-    # The idea is start with people who are the LEAST available to teach, 
-    # then put the more available instructors into the available slots
-    new_dict = {}
-    for instructor in order: 
-        new_dict[instructor] = availability[instructor]
-    availability = new_dict
 
     partial_names = []
 
     timeslots = initialize_timeslots(df) 
+    total_timeslots = len(timeslots)
+    print(total_timeslots)
     schedules = []
     schedule_obj = Schedule(timeslots)
+    
+    # Convert the df with everyone's availability to a usable format
+    res = convert_df(df, total_timeslots)
+    people = res['people']
+    availability = res['availability']
+    completely_available = res['completely_available']
+    print(', '.join(people))
+    print(availability)
+    print(f"These instructors are completely avaialable: {', '.join(completely_available)}")
+
+
 
     # Get the bare minimum of workshops that will be taught  
     distinct_slots = set()
-    for curr_list in availability.values(): 
-        for elem in curr_list:
+    for slots in availability.values(): 
+        for elem in slots:
             distinct_slots.add(elem)
     num_distinct_slots = len(distinct_slots)
+    print(num_distinct_slots)
 
 
     max_timeslots_list = [num_distinct_slots]
     max_workshops_list = [num_distinct_slots]
+
  
-    find_all_schedules(people, availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
 
-    total_timeslots = len(timeslots)
+    find_all_schedules(people, availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
 
 
     res = classify_schedules(people, schedules, partial_names, total_timeslots, max_timeslots_list[0])
@@ -411,8 +437,6 @@ def main(df, capacity:int, num_results: int, og_slots: list):
         else: 
             results = f"{beginning} are the best options."
         
-    #results += "(Remember that \"complete\" schedules are ones where everyone is teaching their desired number of workshops and every timeslot is filled.)"
-    
 
     directory = os.path.abspath(os.getcwd())
     path = directory + "/schedule.csv"