More formatting changes

workshops.py

@@ -0,0 +1,978 @@
+import pandas as pd 
+import copy
+import os 
+import gradio as gr
+from collections import Counter
+import random
+import re
+from datetime import date
+import supabase
+import json
+
+###### OG FUNCTIONS TO GENERATE SCHEDULES ######
+# CONSTANTS
+NAME_COL = 'Juggler_Name'
+NUM_WORKSHOPS_COL = 'Num_Workshops'
+AVAIL_COL = 'Availability'
+DESCRIP_COL = 'Workshop_Descriptions'
+DELIMITER = ';'
+
+class Schedule:
+  def __init__(self, timeslots: dict):
+    self.num_timeslots_filled = 0
+    self.total_num_workshops = 0 
+
+    for time,instructors in timeslots.items(): 
+        curr_len = len(instructors)
+        if curr_len > 0:
+            self.num_timeslots_filled += 1 
+            self.total_num_workshops += curr_len
+     
+    self.timeslots = timeslots
+
+  def add(self, person: str, time: str):
+    self.total_num_workshops += 1 
+    if len(self.timeslots[time]) == 0: 
+        self.num_timeslots_filled += 1
+    self.timeslots[time].append(person)
+
+  def remove(self, person: str, time: str): 
+    self.total_num_workshops -= 1 
+    if len(self.timeslots[time]) == 1: 
+        self.num_timeslots_filled -= 1 
+    self.timeslots[time].remove(person)
+
+
+# Returns True if the person can teach during the slot, and False otherwise
+def can_teach(person: str, slot: list, capacity: int) -> bool: 
+    if len(slot) == capacity or len(slot) > capacity: 
+        return False 
+    
+    # No one can teach two workshops at once
+    if person in slot: 
+        return False 
+    
+    return True 
+
+
+# Extracts relevant information from the df with availability and puts it into a useable format
+def convert_df(df):
+    people = []
+    # Key: person's name 
+    # Value: a list of their availability 
+    availability = {}
+    seen = set()
+    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]
+            
+        number = df.loc[row, NUM_WORKSHOPS_COL]
+        if number == 1: 
+            people.append(name)
+
+        # Add people who are teaching multiple workshops to the list more than once 
+        else: 
+            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 
+
+
+# Returns False if curr is NaN, and True otherwise
+def is_defined(curr): 
+    # if curr != curr, then curr is NaN for some reason
+    if curr != curr: 
+        return False 
+    else: 
+        return True
+    
+# Returns True if curr is defined and its length is greater than 0
+def is_valid(curr): 
+    return (is_defined(curr) and len(curr) > 0)
+
+# Makes a dictionary where each key is a timeslot and each value is a list. 
+# If there's no partial schedule, each list will be empty.  
+# If there's a partial schedule, each list will include the people teaching during that slot.
+def initialize_timeslots(df) -> dict: 
+    all_timeslots = set()
+    availability = df[AVAIL_COL]
+    for elem in availability: 
+        curr_list = elem.split(DELIMITER)
+        for inner in curr_list: 
+            all_timeslots.add(inner.strip())
+
+    to_return = {}
+    for slot in all_timeslots: 
+        to_return[slot] = []
+
+    return to_return
+
+
+# Recursive function that generates all possible schedules
+def find_all_schedules(people: list, availability: dict, schedule_obj: Schedule, capacity: int, schedules: list, max_list: list) -> None: 
+    if schedule_obj.num_timeslots_filled > max_list[0] or schedule_obj.num_timeslots_filled == max_list[0]: 
+        schedules.append(copy.deepcopy(schedule_obj))
+        max_list[0] = schedule_obj.num_timeslots_filled
+    
+    # Base case
+    if len(people) == 0: 
+        return 
+    
+    
+    # Recursive cases 
+    person = people[0]
+    
+    for time in availability[person]:
+        if can_teach(person, schedule_obj.timeslots[time], capacity): 
+            # Choose (put that person in that timeslot)
+            schedule_obj.add(person, time)
+
+            # Explore (assign everyone else to timeslots based on that decision)
+            if len(people) == 1: 
+                find_all_schedules([], availability, schedule_obj, capacity, schedules, max_list)
+
+            else: 
+                find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_list)
+
+            # 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_list)
+            else: 
+                find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_list)
+            
+
+    return
+
+
+# Makes an organized DataFrame given a list of schedules
+def make_df(schedules: list, descrip_dict: dict): 
+    all_times = []
+    all_instructors = []
+    seen = []
+
+    count = 1
+
+    for i in range (len(schedules)): 
+        curr_sched = schedules[i]
+
+        if curr_sched in seen: 
+            continue 
+        else: 
+            seen.append(curr_sched)
+
+        # Sort dictionary by keys
+        sorted_dict = dict(sorted(curr_sched.items(), key=lambda item: item[0]))
+        curr_times = sorted_dict.keys() 
+        curr_instructors = sorted_dict.values() 
+
+        # Include an empty row between schedules
+        if count != 1: 
+            all_times.append("")
+            all_instructors.append("")
+
+        if len(schedules) > 1: 
+            all_times.append(f"Schedule #{count}")
+            all_instructors.append("")
+            count += 1
+
+        for slot in curr_times: 
+            all_times.append(slot)
+
+        for instructors in curr_instructors: 
+            if len(descrip_dict) == 0: 
+                all_instructors.append("; ". join(instructors))
+
+            if len(descrip_dict) > 0: 
+                big_str = ""
+
+                for person in instructors: 
+                    if person in descrip_dict: 
+                        descrip = descrip_dict[person]
+                    else: 
+                        descrip = "Workshop"
+                    
+                    new_str = ''
+                    separated = descrip.split(DELIMITER)
+                    for elem in separated: 
+                        new_str += f"- {elem.strip()} OR\n"
+                    big_str += f"\n\n- {person}:\n" + new_str.strip(' OR\n')
+
+                all_instructors.append(big_str.strip())
+                    
+        
+    new_df = pd.DataFrame({
+        "Schedule": all_times, 
+        "Instructor(s)": all_instructors
+    })
+    new_df['Instructor(s)'] = new_df['Instructor(s)'].astype(str)
+
+    return new_df, count - 1
+
+
+
+
+
+# Makes a dictionary where each key is the instructor's name and 
+# the value is the workshop(s) they're teaching
+def get_description_dict(df): 
+    new_dict = {}
+    for row in range(len(df)): 
+        name = df.loc[row, NAME_COL]
+        new_dict[name] = df.loc[row, DESCRIP_COL]
+    return new_dict
+
+
+# Classifies schedules into two categories: complete and incomplete: 
+# Complete = everyone is teaching desired number of timeslots and each timeslot is filled 
+# 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: 
+    valid_schedules = []
+
+    # Key: score 
+    # Value: schedules with that score
+    incomplete_schedules = {}
+
+    # Get frequency of items in the list 
+    # Key: person 
+    # Value: number of workshops they WANT to teach
+    pref_dict = Counter(people)
+
+    pref_dict.update(Counter(partial_names))
+    
+    all_names = pref_dict.keys() 
+    
+    # Evaluate each schedule
+    overall_max = 0
+    for sched in schedules: 
+        if sched.num_timeslots_filled != max_timeslots_filled:
+            continue
+        # Key: person 
+        # Value: how many workshops they're ACTUALLY teaching in this schedule
+        freq_dict = {}
+        for name in all_names: 
+            freq_dict[name] = 0
+        
+        for timeslot, instructor_list in sched.timeslots.items(): 
+            for instructor in instructor_list: 
+                if instructor in freq_dict: 
+                    freq_dict[instructor] += 1 
+                else: 
+                    print("there is a serious issue!!!!")
+
+        # See if everyone is teaching their desired number of workshops 
+        everyone_is_teaching = True
+        for teacher, freq in freq_dict.items(): 
+            if freq != pref_dict[teacher]: 
+                #print(f"teacher: {teacher}. preference: {pref_dict[teacher]}. actual frequency: {freq}")
+                everyone_is_teaching = False 
+                break 
+
+        filled_all_timeslots = (sched.num_timeslots_filled == total_timeslots) 
+        if everyone_is_teaching and filled_all_timeslots: 
+            valid_schedules.append(sched)
+        else: 
+            # No need to add to incomplete_schedules if there's at least one valid schedule 
+            if len(valid_schedules) > 0: 
+                continue 
+            #print(f"teaching desired number of timeslots: {everyone_is_teaching}. At least one workshop per slot: {filled_all_timeslots}.\n{sched}\n")
+            if sched.num_timeslots_filled > overall_max: 
+                overall_max = sched.num_timeslots_filled 
+
+                if sched.num_timeslots_filled not in incomplete_schedules: 
+                    incomplete_schedules[sched.num_timeslots_filled] = []
+                incomplete_schedules[sched.num_timeslots_filled].append(sched)
+
+            
+    
+    if len(valid_schedules) > 0: 
+        return valid_schedules, []
+    else: 
+        return [], incomplete_schedules[overall_max]
+
+
+
+# Parameters: schedules that have the max number of timeslots filled 
+# Returns: a list of all schedules that have the max number of workshops
+    # To make it less overwhelming, it will return {cutoff} randomly 
+def get_best_schedules(schedules: list, cutoff: str) -> list: 
+    cutoff = int(cutoff)
+    overall_max = 0 
+    best_schedules = {}
+    for sched in schedules: 
+        if sched.total_num_workshops not in best_schedules: 
+            best_schedules[sched.total_num_workshops] = []
+        best_schedules[sched.total_num_workshops].append(sched.timeslots)
+        if sched.total_num_workshops > overall_max: 
+            overall_max = sched.total_num_workshops
+    all_best_schedules = best_schedules[overall_max]
+    if cutoff == -1: 
+        return all_best_schedules
+    else: 
+        if len(all_best_schedules) > cutoff: 
+            # Sample without replacement
+            return random.sample(all_best_schedules, cutoff)
+        else:
+            return all_best_schedules
+
+
+# Big wrapper function that calls the other functions
+def main(df, capacity:int, num_results: int):     
+    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]
+
+    partial_names = []
+
+    timeslots = initialize_timeslots(df) 
+
+    schedules = []
+    schedule_obj = Schedule(timeslots)
+    max_list = [0]
+ 
+    find_all_schedules(people, availability, schedule_obj, capacity, schedules, max_list)
+
+    total_timeslots = len(timeslots)
+
+
+    res = classify_schedules(people, schedules, partial_names, total_timeslots, max_list[0])
+    valid_schedules = res[0]
+    decent_schedules = res[1]
+
+    
+    # Return schedules
+    if len(valid_schedules) > 0: 
+        best_schedules = get_best_schedules(valid_schedules, num_results)
+        res = make_df(best_schedules, descrip_dict)
+        new_df = res[0]
+        count = res[1]
+        if count == 1: 
+            results = "Good news! I was able to make a schedule." 
+        else: 
+            results = "Good news! I was able to make multiple schedules."
+        
+    else:
+        best_schedules = get_best_schedules(decent_schedules, num_results)
+        res = make_df(best_schedules, descrip_dict)
+        new_df = res[0]
+        count = res[1]
+        beginning = "Unfortunately, I wasn't able to make a complete schedule, but here"
+        if count == 1: 
+            results = f"{beginning} is the best option."
+        else: 
+            results = f"{beginning} are the best options."
+    
+
+    directory = os.path.abspath(os.getcwd())
+    path = directory + "/schedule.csv" 
+    new_df.to_csv(path, index=False)
+    return results, new_df, path
+
+    
+
+
+
+##### ALL THE NEW STUFF WITH SUPABASE ETC. #####
+### CONSTANTS ###
+SIGN_IN_SUCCESS = 'Sign-In Successful!'
+NAME_COL = 'Juggler_Name'
+NUM_WORKSHOPS_COL = 'Num_Workshops'
+AVAIL_COL = 'Availability'
+DESCRIP_COL = 'Workshop_Descriptions'
+EMAIL_COL = 'Email'
+DELIMITER = ';'
+ALERT_TIME = None # leave warnings on screen indefinitely
+FORM_NOT_FOUND = 'Form not found'
+INCORRECT_PASSWORD = "The password is incorrect. Please check the password and try again. If you don't remember your password, please email [email protected]."
+NUM_ROWS = 1
+NUM_COLS_SCHEDULES = 2
+NUM_COLS_ALL_RESPONSES = 4
+MIN_LENGTH = 6
+NUM_RESULTS = 10 # randomly get {NUM_RESULTS} results
+
+
+theme = gr.themes.Soft(
+    primary_hue="cyan",
+    secondary_hue="pink",
+    font=[gr.themes.GoogleFont('sans-serif'), 'ui-sans-serif', 'system-ui', 'Montserrat'],
+)
+
+### Connect to Supabase ###
+URL = os.environ['URL']
+API_KEY = os.environ['API_KEY']
+client = supabase.create_client(URL, API_KEY)
+
+
+
+
+### DEFINE FUNCTIONS ###
+## Multi-purpose function ##
+'''
+Returns a lowercased and stripped version of the schedule name. 
+Returns: str
+'''
+def standardize(schedule_name: str): 
+    return schedule_name.lower().strip()
+
+
+## Function to make a form ##
+'''
+Makes a form and pushes it to Supabase. 
+Returns: None
+'''
+def make_form(email: str, schedule_name: str, password_1: str, password_2: str, capacity: int, slots: list) -> str:
+    # Error handling
+    if len(email) == 0: 
+        return gr.Warning('', ALERT_TIME, title="Please enter an email address")
+    
+    if len(schedule_name) == 0: 
+        return gr.Warning('', ALERT_TIME, title=f"Please enter the form name.")
+    
+    if password_1 != password_2: 
+        return gr.Warning('', ALERT_TIME, title=f"The passwords don't match. Password 1 is \"{password_1}\" and Password 2 is \"{password_2}\".")
+    
+    if len(password_1) < MIN_LENGTH: 
+        return gr.Warning('', ALERT_TIME, title=f"Please make a password that is at least {MIN_LENGTH} characters.")
+    
+    if capacity == 0: 
+        return gr.Warning('', ALERT_TIME, title=f"Please enter the capacity (how many people can teach per timeslot). It must be greater than zero.")
+    
+    if capacity < 0: 
+        return gr.Warning('', ALERT_TIME, title=f"The capacity (number of people who can teach per timeslot) must be greater than zero.")
+
+    if len(slots) == 0: 
+        return gr.Warning('', ALERT_TIME, title="Please enter at least one timeslot. Make sure to press \"Enter\" after each one!")
+
+
+    # Check if schedule name already exists 
+    existing_forms = []
+    response = client.table('Forms').select('form_name').execute()
+    for elem in response.data: 
+        existing_forms.append(elem['form_name'])
+
+    if schedule_name in existing_forms:
+        return gr.Warning('', ALERT_TIME, title=f"The form name \"{schedule_name}\" already exists. Please choose a different name.")
+
+    
+    # Push to Supabase
+    new_slots = [elem['name'] for elem in slots]
+    
+    my_obj = {
+        'form_name': standardize(schedule_name),
+        'password': password_1,
+        'email': email,
+        'capacity': capacity, 
+        'slots': new_slots,
+        'status': 'open', 
+        'date_created': str(date.today()), 
+        'responses': json.dumps({
+            NAME_COL: [], 
+            EMAIL_COL: [],
+            NUM_WORKSHOPS_COL: [], 
+            AVAIL_COL: [],
+            DESCRIP_COL: [],
+        }),
+    }
+
+    client.table('Forms').insert(my_obj).execute()
+    gr.Info('', ALERT_TIME, title="Form made successfully!")
+    
+
+
+## Functions to fill out a form @@
+'''
+Gets the timeslots for a given schedule and makes form elements visible.
+Returns: 
+    gr.Button: corresponds to schedule_name_btn
+    gr.CheckboxGroup: corresponds to checkboxes
+    gr.Column: corresponds to main_col
+    gr.Button: corresponds to submit_preferences_btn
+    gr.Textbox: corresponds to new_description
+'''
+def get_timeslots(schedule_name: str):
+    # Leave everything as it was
+    skip_output = gr.Button(), gr.CheckboxGroup(),gr.Column(), gr.Button(), gr.Textbox()
+
+    if len(schedule_name) == 0: 
+        gr.Warning('', ALERT_TIME, title='Please type a form name.')
+        return skip_output
+
+    response = client.table('Forms').select('status', 'slots').eq('form_name', standardize(schedule_name)).execute()
+    data = response.data
+
+    if len(data) > 0: 
+        my_dict = data[0]
+        if my_dict['status'] == 'closed':
+            gr.Warning('', ALERT_TIME, title="This form is closed. Please contact the form administrator.")
+            return skip_output
+        else: 
+            return gr.Button(variant='secondary'), gr.CheckboxGroup(my_dict['slots'], label="Timeslots", info="Check the time(s) you can teach", visible=True), gr.Column(visible=True), gr.Button(visible=True), gr.Textbox(visible=True)
+    else: 
+        gr.Warning('', ALERT_TIME, title=f"There was no form called \"{schedule_name}\". Please check the spelling and try again.")
+        return skip_output
+    
+
+'''
+Submits the form that the person filled out to Supabase. 
+Returns: None
+'''
+def submit_preferences(schedule_name: str, curr_juggler_name: str, curr_email: str, curr_num_workshops: int, curr_availability: str, curr_descriptions: list): 
+    # Error handling
+    if len(curr_juggler_name) == 0: 
+        return gr.Warning('', ALERT_TIME, title="Please enter your name.")
+    
+    if len(curr_email) == 0: 
+        return gr.Warning('', ALERT_TIME, title="Please enter your email address.")
+    
+    if curr_num_workshops == 0: 
+        return gr.Warning('', ALERT_TIME, title=f"Please enter how many workshops you want to teach.")
+
+    elif curr_num_workshops < 0: 
+        return gr.Warning('', ALERT_TIME, title="The number of workshops you want to teach must be positive.")
+    
+    if len(curr_availability) == 0: 
+        return gr.Warning('', ALERT_TIME, title="Please select at least one timeslot when you are able to teach.")
+    
+    if curr_num_workshops > len(curr_availability): 
+        return gr.Warning('', ALERT_TIME, title=f"You only selected {len(curr_availability)} timeslots. However, you said you wanted to teach {curr_num_workshops} workshops. Please make sure that you are available to teach during at least {curr_num_workshops} timeslots.")
+    
+    if len(curr_descriptions) == 0: 
+        return gr.Warning('', ALERT_TIME, title=f"Please describe at least one workshop that you want to teach. You must hit \"Enter\" after each one!")
+
+    response = client.table('Forms').select('responses').eq('form_name', standardize(schedule_name)).execute()
+    data = response.data
+
+    if len(data) > 0: 
+        form = json.loads(data[0]['responses'])
+
+        # Add current preferences to dictionary lists
+        curr_juggler_name = curr_juggler_name.strip()
+        names = form[NAME_COL]
+        if curr_juggler_name in names: 
+            return gr.Warning('', ALERT_TIME, title=f"Someone already named \"{curr_juggler_name}\" filled out the form. Please use your last name or middle initial.")
+        names.extend([curr_juggler_name])
+
+        emails = form[EMAIL_COL]
+        emails.extend([curr_email])
+
+        bandwidths = form[NUM_WORKSHOPS_COL]
+        bandwidths.extend([curr_num_workshops])
+
+        availabilities = form[AVAIL_COL]
+        curr_availability = f"{DELIMITER}".join(curr_availability)
+        availabilities.extend([curr_availability])
+
+        curr_descriptions = [elem['name'] for elem in curr_descriptions]
+        curr_descriptions = f"{DELIMITER}".join(curr_descriptions)
+        descriptions = form[DESCRIP_COL]
+        descriptions.extend([curr_descriptions])
+
+        # Update Supabase
+        my_obj = json.dumps({
+            NAME_COL: names, 
+            EMAIL_COL: emails, 
+            NUM_WORKSHOPS_COL: bandwidths, 
+            AVAIL_COL: availabilities, 
+            DESCRIP_COL: descriptions
+        })
+        client.table('Forms').update({'responses': my_obj}).eq('form_name', standardize(schedule_name)).execute()
+        return gr.Info('', ALERT_TIME, title='Form submitted successfully!')
+
+    # I don't think it's possible to get here because I checked the schedule name earlier
+    else:
+        return gr.Warning('', ALERT_TIME, title=f"There was no form called \"{schedule_name}\". Please check the spelling and try again.")
+    
+
+## Functions to manage/generate schedules ## 
+'''
+Uses the name and password to get the form. 
+Makes the buttons and other elements visible on the page. 
+Returns: 
+    gr.Button: corresponds to find_form_btn
+    gr.Column: corresponds to all_responses_group
+    gr.Column: generate_schedules_explanation
+    gr.Row: corresponds to generate_btns
+    gr.Column: corresponds to open_close_btn_col
+    gr.Button: corresponds to open_close_btn
+'''
+def make_visible(schedule_name:str, password: str):
+    skip_output = gr.Button(), gr.Column(), gr.Column(), gr.Row(), gr.Column(), gr.Button()
+    
+    if len(schedule_name) == 0: 
+        gr.Warning('Please enter the form name.', ALERT_TIME)
+        return skip_output
+    if len(password) == 0: 
+        gr.Warning('Please enter the password.', ALERT_TIME)
+        return skip_output
+
+
+    response = client.table('Forms').select('password', 'status').eq('form_name', standardize(schedule_name)).execute()
+    data = response.data
+
+    if len(data) > 0: 
+        my_dict = data[0]
+        if password != my_dict['password']: 
+            gr.Warning(INCORRECT_PASSWORD, ALERT_TIME)
+            return skip_output
+        else: 
+            if my_dict['status'] == 'open':
+                gr.Info('', ALERT_TIME, title='Btw, the form is currently OPEN.')
+                return gr.Button(variant='secondary'), gr.Column(visible=True), gr.Column(visible=True), gr.Row(visible=True), gr.Column(visible=True), gr.Button("Close Form", visible=True)
+            
+            elif my_dict['status'] == 'closed':
+                gr.Info('', ALERT_TIME, title='Btw, the form is currently CLOSED.')
+                return gr.Button(variant='secondary'), gr.Column(visible=True), gr.Column(visible=True), gr.Row(visible=True),gr.Column(visible=True), gr.Button("Open Form", visible=True)
+
+    else: 
+        gr.Warning(f"There is no form called \"{schedule_name}\". Please check the spelling and try again.", ALERT_TIME)
+        return skip_output
+
+
+
+
+'''
+Makes a blank schedule that we can return to prevent things from breaking.
+Returns: tuple with 3 elements:
+    0: str indicating that the form wasn't found 
+    1: the DataFrame 
+    2: the path to the DataFrame
+'''
+def make_blank_schedule(): 
+    df = pd.DataFrame({
+            'Schedule': [], 
+            'Instructors': []
+        })
+
+    directory = os.path.abspath(os.getcwd())
+    path = directory + "/schedule.csv" 
+    df.to_csv(path, index=False)
+    return FORM_NOT_FOUND, df, path
+
+
+'''
+Gets a the form responses from Supabase and converts them to a DataFrame
+Returns: 
+    if found: a dictionary with two keys, capacity (int) and df (DataFrame)
+    if not found: a string indicating the form was not found
+'''
+def get_df_from_db(schedule_name: str, password: str): 
+    response = client.table('Forms').select('password', 'capacity', 'responses').eq('form_name', standardize(schedule_name)).execute()
+    data = response.data
+
+    if len(data) > 0: 
+        my_dict = data[0]
+        if password != my_dict['password']: 
+            gr.Warning(INCORRECT_PASSWORD, ALERT_TIME)
+            return FORM_NOT_FOUND
+        
+        # Convert to df
+        df = pd.DataFrame(json.loads(my_dict['responses']))
+        return {'capacity': my_dict['capacity'], 'df': df}
+
+    else: 
+        gr.Warning(f"There is no form called \"{schedule_name}\". Please check the spelling and try again.", ALERT_TIME)
+        return FORM_NOT_FOUND
+    
+
+'''
+Puts all of the form responses into a DataFrame. 
+Returns this DF along with the filepath. 
+'''
+def get_all_responses(schedule_name:str, password:str): 
+    res = get_df_from_db(schedule_name, password)
+
+    if res == FORM_NOT_FOUND: 
+        df = pd.DataFrame({
+            NAME_COL: [], 
+            EMAIL_COL: [],
+            NUM_WORKSHOPS_COL: [], 
+            AVAIL_COL: [],
+            DESCRIP_COL: []
+        })
+
+    else:
+        df = res['df']
+        # Add commas
+        for col in [AVAIL_COL, DESCRIP_COL]:
+            df[col] = [elem.replace(DELIMITER, f"{DELIMITER} ") for elem in df[col].to_list()]
+
+    directory = os.path.abspath(os.getcwd())
+    path = directory + "/all responses.csv" 
+    df.to_csv(path, index=False)
+
+    if len(df) == 0: 
+        gr.Warning('', ALERT_TIME, title='No one has filled out the form yet.')
+    return gr.DataFrame(df, visible=True), gr.File(path, visible=True)
+
+
+'''
+Calls the algorithm to generate the best possible schedules, 
+and returns a random subset of the results. 
+(The same as generate_schedules_wrapper_all_results, except that this function only returns a subset of them.
+I had to make it into two separate functions in order to work with Gradio). 
+Returns: 
+    DataFrame 
+    Filepath to DF (str)
+'''
+def generate_schedules_wrapper_subset_results(schedule_name: str, password: str): 
+    res = get_df_from_db(schedule_name, password)
+    # Return blank schedule (should be impossible to get to this condition btw)
+    if res == FORM_NOT_FOUND:
+        to_return = make_blank_schedule()
+        gr.Warning(FORM_NOT_FOUND, ALERT_TIME)
+    
+    else: 
+        df = res['df']
+        if len(df) == 0: 
+            gr.Warning('', ALERT_TIME, title='No one has filled out the form yet.')
+            to_return = make_blank_schedule()
+        else: 
+            gr.Info('', ALERT_TIME, title='Working on generating schedules! Please DO NOT click anything on this page.')
+            capacity = res['capacity']
+            to_return = main(df, capacity, NUM_RESULTS)
+            gr.Info('', ALERT_TIME, title=to_return[0])
+            
+
+    return gr.Textbox(to_return[0]), gr.DataFrame(to_return[1], visible=True), gr.File(to_return[2], visible=True)
+
+
+'''
+Calls the algorithm to generate the best possible schedules, 
+and returns ALL of the results. 
+(The same as generate_schedules_wrapper_subset_results, except that this function returns all of them.
+I had to make it into two separate functions in order to work with Gradio). 
+Returns: 
+    DataFrame 
+    Filepath to DF (str)
+'''
+def generate_schedules_wrapper_all_results(schedule_name: str, password: str): 
+    res = get_df_from_db(schedule_name, password)
+    # Return blank schedule (should be impossible to get to this condition btw)
+    if res == FORM_NOT_FOUND:
+        to_return = make_blank_schedule()
+        gr.Warning(FORM_NOT_FOUND, ALERT_TIME)
+    
+    else: 
+        df = res['df']
+        if len(df) == 0: 
+            gr.Warning('', ALERT_TIME, title='No one has filled out the form yet.')
+            to_return = make_blank_schedule()
+        else: 
+            gr.Info('', ALERT_TIME, title='Working on generating schedules! Please DO NOT click anything on this page.')
+            capacity = res['capacity']
+            placeholder = -1
+            to_return = main(df, capacity, placeholder)
+            gr.Info('', ALERT_TIME, title=to_return[0])
+            
+    return gr.Textbox(to_return[0]), gr.DataFrame(to_return[1], visible=True), gr.File(to_return[2], visible=True)
+
+
+
+
+'''
+Opens/closes a form and changes the button after opening/closing the form.
+Returns: gr.Button
+'''
+def toggle_btn(schedule_name:str, password:str): 
+    response = client.table('Forms').select('password', 'capacity', 'status').eq('form_name', standardize(schedule_name)).execute()
+    data = response.data
+
+    if len(data) > 0:
+        my_dict = data[0]
+        if password != my_dict['password']: 
+            gr.Warning(INCORRECT_PASSWORD, ALERT_TIME)
+            return FORM_NOT_FOUND
+        
+        curr_status = my_dict['status']
+        if curr_status == 'open': 
+            client.table('Forms').update({'status': 'closed'}).eq('form_name', standardize(schedule_name)).execute()
+            gr.Info('', ALERT_TIME, title="The form was closed successfully!")
+            return gr.Button('Open Form')
+        
+        elif curr_status == 'closed': 
+            client.table('Forms').update({'status': 'open'}).eq('form_name', standardize(schedule_name)).execute()
+            gr.Info('', ALERT_TIME, title="The form was opened successfully!")
+            return gr.Button('Close Form')
+        
+        else: 
+            gr.Error('', ALERT_TIME, 'An unexpected error has ocurred.')
+            return gr.Button()
+
+    else: 
+        gr.Warning('', ALERT_TIME, title=f"There was no form called \"{schedule_name}\". Please check the spelling and try again.") 
+        return gr.Button()
+    
+
+### MARKDOWN TEXT ### 
+generate_markdown = f"""
+The app will attempt to create schedules where everyone is teaching their descired number of workshops AND all timeslots are filled.\n
+If that is impossible, then the app will create schedules that maximize the number of timeslots that are filled.\n 
+You can either get a random selection of the best schedules (recommended), or ALL of the best schedules.\n 
+WARNING: It can sometimes take a LONG time to get all the best schedules!
+"""
+
+about_markdown = f"""
+# About the App\n
+Hi! My name is Logan, and I created Schedule Buddy to be the one-stop-shop for making juggling workshop schedules.\n
+Making a juggling workshop schedule involves 3 parts: making the form, having people fill it out, and putting the schedule together. Schedule Buddy supports all three of these aspects!\n
+
+Schedule Buddy streamlines the process of the creating and filling out the forms, essentially replacing Google Forms. 
+In terms of putting the schedule togther, Schedule Buddy will attempt to create schedules where everyone is teaching their desired number of workshops AND all timeslots are filled.
+If that is impossible, then the app will create schedules that maximize the number of workshops that are taught. 
+Essentially, Schedule Buddy removes the headache of trying to fit everyone into a timeslot. \n
+For those who are curious and still reading, Schedule Buddy uses a recursive backtracking algorithm to make schedules.
+
+
+# About Me
+I've been juggling for the past 8 years, and 4 years ago I created a YouTube channel called Juggling Gym.\n
+I love going to juggling festivals and attending workshops. When I was planning the workshops for the Atlanta Juggling Festival, I noticed how hard it was to plan the workshops
+and make sure that everyone was teaching their desired number of workshops.\n
+Since workshops are entirely run by volunteers, I wanted to make the process easier for everyone! Thus, I created Schedule Buddy as a free resource for jugglers to plan workshops.\n
+"""
+
+
+### GRADIO ###
+with gr.Blocks() as demo:
+    ### FILL OUT  FORM ###
+    with gr.Tab('Fill Out Form'): 
+        schedule_name = gr.Textbox(label="Form Name", info="What is the name of the form you want to fill out?")
+        schedule_name_btn = gr.Button('Submit', variant='primary')
+        
+        with gr.Column(visible=False) as main_col:
+            juggler_name = gr.Textbox(label='Name (first and last)', visible=True)
+            email = gr.Textbox(label='Email Address', visible=True)
+            num_workshops = gr.Number(label="Number of Workshops", info="Enter how many workshops you want to teach, e.g., \"1\", \"2\", etc.", interactive=True, visible=True)
+              
+        checkboxes = gr.CheckboxGroup([], label="Timeslots", info="Check the time(s) you can teach.", visible=False)
+
+        # Let the user dynamically describe their workshops
+        descriptions = gr.State([])
+        new_description = gr.Textbox(label='Workshop Descriptions', info='Describe the workshop(s) you want to teach. Hit "Enter" after each one.', visible=False)
+
+        def add_descrip(descriptions, new_description):
+            return descriptions + [{"name": new_description}], ""
+
+        new_description.submit(add_descrip, [descriptions, new_description], [descriptions, new_description])
+
+        @gr.render(inputs=descriptions)
+        def render_descriptions(descrip_list):
+            for elem in descrip_list:        
+                with gr.Row():
+                        gr.Textbox(elem['name'], show_label=False, container=False)
+                        delete_btn = gr.Button("Delete", scale=0, variant="stop")
+                        def delete(elem=elem):
+                            descrip_list.remove(elem)
+                            return descrip_list
+                        delete_btn.click(delete, None, [descriptions])
+
+        
+        submit_preferences_btn = gr.Button('Submit', variant='primary', visible=False) 
+        schedule_name_btn.click(fn=get_timeslots, inputs=[schedule_name], outputs=[schedule_name_btn, checkboxes, main_col, submit_preferences_btn, new_description])
+        submit_preferences_btn.click(fn=submit_preferences, inputs=[schedule_name, juggler_name, email, num_workshops, checkboxes, descriptions])
+
+
+    ### MAKE FORM ###
+    with gr.Tab('Make Form'):
+        email =  gr.Textbox(label="Email Adress")
+        schedule_name = gr.Textbox(label="Form Name", info='Keep it simple! Each person will have to type the form name to fill it out.')
+        password_1 = gr.Textbox(label='Password', info='You MUST remember your password to access the schedule results. There is currently no way to reset your password.')
+        password_2 = gr.Textbox(label='Password Again', info='Enter your password again')
+        capacity = gr.Number(label="Capacity", info="Enter the maximum number of people who can teach per timeslot.")
+
+        # Dynamically render timeslots
+        # Based on: https://www.gradio.app/guides/dynamic-apps-with-render-decorator
+        slots = gr.State([])
+        new_slot = gr.Textbox(label='Enter Timeslots People Can Teach', info='Ex: Friday 7 pm, Saturday 11 am. Hit "Enter" after each one. Make sure to put them in CHRONOLOGICAL ORDER!')
+
+        def add_slot(slots, new_slot_name):
+            return slots + [{"name": new_slot_name}], ""
+
+        new_slot.submit(add_slot, [slots, new_slot], [slots, new_slot])
+
+        @gr.render(inputs=slots)
+        def render_slots(slot_list):
+            gr.Markdown(f"### Timeslots")
+            for slot in slot_list:        
+                with gr.Row():
+                        gr.Textbox(slot['name'], show_label=False, container=False)
+                        delete_btn = gr.Button("Delete", scale=0, variant="stop")
+                        def delete(slot=slot):
+                            slot_list.remove(slot)
+                            return slot_list
+                        delete_btn.click(delete, None, [slots])
+
+
+        btn = gr.Button('Submit', variant='primary')
+        btn.click(
+            fn=make_form,
+            inputs=[email, schedule_name, password_1, password_2, capacity, slots],
+        )
+
+    
+    ### VIEW FORM RESULTS ### 
+    with gr.Tab('View Form Results'):
+        with gr.Column() as btn_group:
+            schedule_name = gr.Textbox(label="Form Name")
+            password = gr.Textbox(label="Password")
+            find_form_btn = gr.Button('Find Form', variant='primary')
+
+        # 1. Get all responses
+        with gr.Column(visible=False) as all_responses_col: 
+            gr.Markdown('# Download All Form Responses')
+            gr.Markdown("Download everyone's responses to the form.")
+            all_responses_btn = gr.Button('Download All Form Responses', variant='primary')
+
+        with gr.Row() as all_responses_output_row:
+            df_out = gr.DataFrame(row_count = (NUM_ROWS, "dynamic"),col_count = (NUM_COLS_ALL_RESPONSES, "dynamic"),headers=[NAME_COL, NUM_WORKSHOPS_COL, AVAIL_COL, DESCRIP_COL],wrap=True,scale=4,visible=False)
+            file_out = gr.File(label = "Downloadable file", scale=1, visible=False)
+
+        all_responses_btn.click(fn=get_all_responses, inputs=[schedule_name, password], outputs=[df_out, file_out])
+
+        
+        # 2. Generate schedules
+        with gr.Column(visible=False) as generate_schedules_explanation_col:
+            gr.Markdown('# Create Schedules based on Everyone\'s Preferences.') 
+            with gr.Accordion('Details'):
+                gr.Markdown(generate_markdown)
+ 
+        with gr.Row(visible=False) as generate_btns_row:
+            generate_ten_results_btn = gr.Button('Generate a Subset of Schedules', variant='primary', visible=True) 
+            generate_all_results_btn = gr.Button('Generate All Possible Schedules', visible=True)
+        
+        with gr.Row(visible=True) as generated_schedules_output:
+            text_out = gr.Textbox(label='Results')
+            generated_df_out = gr.DataFrame(row_count = (NUM_ROWS, "dynamic"),col_count = (NUM_COLS_SCHEDULES, "dynamic"),headers=["Schedule", "Instructors"],wrap=True,scale=3, visible=False)
+            generated_file_out = gr.File(label = "Downloadable schedule file", scale=1, visible=False)
+
+        generate_ten_results_btn.click(fn=generate_schedules_wrapper_subset_results, inputs=[schedule_name, password], outputs=[text_out, generated_df_out, generated_file_out], api_name='generate_random_schedules')
+        generate_all_results_btn.click(fn=generate_schedules_wrapper_all_results, inputs=[schedule_name, password], outputs=[text_out, generated_df_out, generated_file_out], api_name='generate_all_schedules')
+
+
+        # 3. Open/close button 
+        with gr.Column(visible=False) as open_close_btn_col: 
+            gr.Markdown('# Open or Close Form')
+            open_close_btn = gr.Button(variant='primary')
+            open_close_btn.click(fn=toggle_btn, inputs=[schedule_name, password], outputs=[open_close_btn])
+
+        
+        find_form_btn.click(fn=make_visible, inputs=[schedule_name, password], outputs=[find_form_btn, all_responses_col, generate_schedules_explanation_col, generate_btns_row, open_close_btn_col, open_close_btn])
+
+
+    ### INFO ### 
+    with gr.Tab('About'): 
+        gr.Markdown(about_markdown)
+
+directory = os.path.abspath(os.getcwd())
+allowed = directory #+ "/schedules"
+demo.launch(allowed_paths=[allowed], show_error=True)