Bug fix

workshops.py

@@ -4,12 +4,7 @@ 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'
@@ -43,13 +38,6 @@ class Schedule:
     self.timeslots[time].remove(person)
 
 
-  def print(self): 
-      print(f"# timeslots filled: {self.num_timeslots_filled}")
-      print(f"# workshops: {self.total_num_workshops}")
-      for time,instructors in self.timeslots.items(): 
-          print(f"{time}: {', '.join(instructors)}")
-
-
 # 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: 
@@ -90,6 +78,17 @@ def convert_df(df):
     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.  
@@ -110,13 +109,10 @@ def initialize_timeslots(df) -> dict:
 
 
 # Recursive function that generates all possible schedules
-def find_all_schedules(people: list, availability: dict, schedule_obj: Schedule, capacity: int, schedules: list, max_timeslots_list: list, max_workshops_list: list) -> None: 
-    if schedule_obj.num_timeslots_filled > max_timeslots_list[0] or schedule_obj.num_timeslots_filled == max_timeslots_list[0]: 
+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_timeslots_list[0] = schedule_obj.num_timeslots_filled
-        # Keep track of total number of workshops taught
-        if schedule_obj.total_num_workshops > max_workshops_list[0] or schedule_obj.total_num_workshops == max_workshops_list[0]: 
-            max_workshops_list[0] = schedule_obj.total_num_workshops
+        max_list[0] = schedule_obj.num_timeslots_filled
     
     # Base case
     if len(people) == 0: 
@@ -133,37 +129,26 @@ def find_all_schedules(people: list, availability: dict, schedule_obj: Schedule,
 
             # Explore (assign everyone else to timeslots based on that decision)
             if len(people) == 1: 
-                find_all_schedules([], availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
+                find_all_schedules([], availability, schedule_obj, capacity, schedules, max_list)
 
             else: 
-                find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
+                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_timeslots_list, max_workshops_list)
+                find_all_schedules([], availability, schedule_obj, capacity, schedules, max_list)
             else: 
-                find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
-    
-    return
-
+                find_all_schedules(people[1:len(people)], availability, schedule_obj, capacity, schedules, max_list)
+            
 
-# Puts the schedule in the correct order
-def my_sort(curr_sched: dict, og_slots: list): 
-    # example {'4 pm': ['logan', 'andrew'], '1 pm': ['graham', 'joyce'], '3 pm': ['logan', 'dan'], '2 pm': ['graham', 'dan']} 
-    to_return = {}
-    for elem in og_slots:
-        if elem in curr_sched: 
-            to_return[elem] = curr_sched[elem]
-        else: 
-            to_return[elem] = []
-    return to_return
+    return
 
 
 # Makes an organized DataFrame given a list of schedules
-def make_df(schedules: list, descrip_dict: dict, og_slots: list): 
+def make_df(schedules: list, descrip_dict: dict): 
     all_times = []
     all_instructors = []
     seen = []
@@ -178,8 +163,8 @@ def make_df(schedules: list, descrip_dict: dict, og_slots: list):
         else: 
             seen.append(curr_sched)
 
-        #sorted_dict = dict(sorted(curr_sched.items(), key=lambda item: item[0]))
-        sorted_dict = my_sort(curr_sched, og_slots)
+        # 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() 
 
@@ -188,7 +173,7 @@ def make_df(schedules: list, descrip_dict: dict, og_slots: list):
             all_times.append("")
             all_instructors.append("")
 
-        if len(schedules) > 1 or len(schedules) == 1: 
+        if len(schedules) > 0: 
             all_times.append(f"Schedule #{count}")
             all_instructors.append("")
             count += 1
@@ -200,41 +185,77 @@ def make_df(schedules: list, descrip_dict: dict, og_slots: list):
             if len(descrip_dict) == 0: 
                 all_instructors.append("; ". join(instructors))
 
+            # The format will be: Time: Instructor (Workshop); Instructor (Workshop)
             if len(descrip_dict) > 0: 
-                big_str = ""
-
+                string = ""
                 for person in instructors: 
                     if person in descrip_dict: 
                         descrip = descrip_dict[person]
                     else: 
                         descrip = "Workshop"
-                    
-                    # {descrip} is a list bc they want to teach multiple workshops
-                    if '\n' in descrip:
-                        new_str = f"\n\n- {person}:\n{descrip}"
+                    if len(descrip) > 0:
+                        descrip = descrip.replace(DELIMITER, f" OR ")
+                        string += f"{person} ({descrip}); "
                     else: 
-                        new_str = f"\n\n- {person}: {descrip}"
-
-                    big_str += new_str
-
-                all_instructors.append(big_str.strip())
-
-        if len(curr_instructors) == 0: 
-            all_instructors.append('N/A')
+                        string += f"{person}"
+                string = string.strip("; ")
+                all_instructors.append(string)
                     
         
     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
 
 
 
+# Returns the stripped version of the column name
+# or the default one if the user didn't input a column name
+def get_var_name(var, default): 
+    if var is None or len(var) == 0: 
+        return default
+    else: 
+        return var.strip()
 
 
+# Returns an error message, empty DataFrame, and blank csv file
+def error_msg(message: str): 
+    empty = pd.DataFrame({"Schedule": ["ERROR"], "Instructor": ["ERROR"]})
+    directory = os.path.abspath(os.getcwd())
+    path = directory + "/schedules/ERROR.csv" 
+    empty.to_csv(path, index=False)
+    return "ERROR: " + message, empty, path
+
+
+# Returns column names that aren't in the csv file
+def find_missing_cols(df_columns: list, names: list, file: str) -> str: 
+    missing = []
+    for elem in names: 
+        if elem not in df_columns: 
+            missing.append(elem)
+
+    double_check = f"""These are the columns in your file: {"; ".join(df_columns)}. Please double check your spelling/punctuation and try again."""
+
+    if len(missing) == 0: 
+        return ""
+    elif len(missing) == 1: 
+        return f'I cannot find this column in the {file} file you uploaded: {missing[0]}. {double_check}'
+    elif len(missing) == 2: 
+        return f'I cannot find these columns in the {file} file you uploaded: {missing[0]} and {missing[1]}. {double_check}'
+    else: 
+        message = f"I cannot find these columns in the {file} file you uploaded: "
+        for i in range(len(missing)):
+            col = missing[i]
+            if i != len(missing) - 1: 
+                message += col + ", "
+            else: 
+                message += "and " + col + ". "
+        message += double_check
+        return message
+    
+
 # 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): 
@@ -265,10 +286,8 @@ def classify_schedules(people: list, schedules: list, partial_names: list, total
     
     all_names = pref_dict.keys() 
     
-    
-    ## Evaluate each schedule ##
-    overall_max = 0 # changes throughout the function 
-
+    # Evaluate each schedule
+    overall_max = 0
     for sched in schedules: 
         if sched.num_timeslots_filled != max_timeslots_filled:
             continue
@@ -301,14 +320,12 @@ def classify_schedules(people: list, schedules: list, partial_names: list, total
             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 or 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 sched.num_timeslots_filled not in incomplete_schedules: 
+                incomplete_schedules[sched.num_timeslots_filled] = []
+            incomplete_schedules[sched.num_timeslots_filled].append(sched)
 
-            
+            if sched.num_timeslots_filled > overall_max: 
+                overall_max = sched.num_timeslots_filled 
     
     if len(valid_schedules) > 0: 
         return valid_schedules, []
@@ -318,36 +335,37 @@ def classify_schedules(people: list, schedules: list, partial_names: list, total
 
 
 # Parameters: schedules that have the max number of timeslots filled 
-# Max number of workshops taught in filled timeslots
 # 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, max_workshops: int) -> list: 
+def get_best_schedules(schedules: list, cutoff: str) -> list: 
     cutoff = int(cutoff)
-    best_schedules = []
+    overall_max = 0 
+    best_schedules = {}
     for sched in schedules: 
-        if sched.total_num_workshops != max_workshops: 
-            continue 
-        best_schedules.append(sched.timeslots)
-
+        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 best_schedules
+        return all_best_schedules
     else: 
-        if len(best_schedules) > cutoff: 
+        if len(all_best_schedules) > cutoff: 
             # Sample without replacement
-            return random.sample(best_schedules, cutoff)
+            return random.sample(all_best_schedules, cutoff)
         else:
-            return best_schedules
+            return all_best_schedules
 
 
 # Big wrapper function that calls the other functions
-def main(df, capacity:int, num_results: int, og_slots: list):     
+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]
-    print(availability)
 
     partial_names = []
 
@@ -355,366 +373,42 @@ def main(df, capacity:int, num_results: int, og_slots: list):
 
     schedules = []
     schedule_obj = Schedule(timeslots)
-    max_timeslots_list = [0]
-    max_workshops_list = [0]
+    max_list = [0]
  
-    find_all_schedules(people, availability, schedule_obj, capacity, schedules, max_timeslots_list, max_workshops_list)
+    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_timeslots_list[0])
+    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, max_workshops_list)
-        res = make_df(best_schedules, descrip_dict, og_slots)
+        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 complete schedule." 
+            results = "Good news! I was able to make a schedule." 
         else: 
-            results = "Good news! I was able to make multiple complete schedules."
+            results = "Good news! I was able to make multiple schedules."
         
     else:
-        best_schedules = get_best_schedules(decent_schedules, num_results, max_workshops_list)
-        res = make_df(best_schedules, descrip_dict, og_slots)
+        best_schedules = get_best_schedules(decent_schedules, num_results)
+        res = make_df(best_schedules, descrip_dict)
         new_df = res[0]
         count = res[1]
-        beginning = "Here"
+        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."
-        
-    #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" 
+    path = directory + "/schedules/schedule.csv" 
     new_df.to_csv(path, index=False)
-    return results, new_df, path
-
-
-
-
-##### ALL THE NEW STUFF WITH SUPABASE ETC. #####
-### CONSTANTS ###
-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 jugglinggym@gmail.com."
-NUM_ROWS = 1
-NUM_COLS_SCHEDULES = 2
-NUM_COLS_ALL_RESPONSES = 4
-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()
-
-
-
-    
-
-
-## 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 three keys: capacity (int), df (DataFrame), and slots (list)
-    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', 'slots').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, 'slots': my_dict['slots']}
-
-    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']
-        df[AVAIL_COL] = [elem.replace(DELIMITER, f"{DELIMITER} ") for elem in df[AVAIL_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.')
-            to_return = main(df, res['capacity'], NUM_RESULTS, res['slots'])
-            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.')
-            placeholder = -1
-            to_return = main(df, res['capacity'], placeholder, res['slots'])
-            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()
-    
-
-
-
-### GRADIO ###
-with gr.Blocks() as demo:
-    ### 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.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])
-
-
-
-
-directory = os.path.abspath(os.getcwd())
-allowed = directory #+ "/schedules"
-demo.launch(allowed_paths=[allowed], show_error=True) 
+    return results, new_df, path