Spaces:
Runtime error
Runtime error
| 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 | |
| ### LOAD PRIVATE SPACE ### | |
| url = "Juggling/Schedule_Buddy_Updated" | |
| token = os.environ['TOKEN'] | |
| generator = gr.load(url, src="spaces", token=token) | |
| ### 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 [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'] | |
| # TODO | |
| URL = 'https://ubngctgvhjgxkvimdmri.supabase.co' | |
| API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVibmdjdGd2aGpneGt2aW1kbXJpIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzQ5MjAwOTQsImV4cCI6MjA1MDQ5NjA5NH0.NtGdfP8GYNuYdPdsaLW5GjgfB0_7Q1kNBIDJtPhO8nY' | |
| 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 (\"Return\" if you're on mobile)!") | |
| # 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'].strip() 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: list, 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 (\"Return\" if you're on mobile)!") | |
| response = client.table('Forms').select('responses', 'slots').eq('form_name', standardize(schedule_name)).execute() | |
| data = response.data | |
| if len(data) > 0: | |
| form = json.loads(data[0]['responses']) | |
| og_slots = data[0]['slots'] | |
| # 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] | |
| # Put the checkboxes in order (rather than the order people click them!) | |
| final_checkboxes = [] | |
| for elem in og_slots: | |
| if elem in curr_availability: | |
| final_checkboxes.append(elem) | |
| curr_availability = f"{DELIMITER}".join(final_checkboxes) | |
| availabilities.extend([curr_availability]) | |
| # Format descriptions | |
| curr_descriptions = [elem['name'] for elem in curr_descriptions] | |
| new_str = '' | |
| if len(curr_descriptions) > 1: | |
| for i, elem in enumerate(curr_descriptions): | |
| new_str += f"{i + 1}. {elem.strip()}\n" | |
| new_str = new_str.strip() | |
| else: | |
| new_str += f"{curr_descriptions[0]}" | |
| descriptions = form[DESCRIP_COL] | |
| descriptions.extend([new_str]) | |
| # 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(), gr.Column | |
| 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), gr.Column(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), gr.Column(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 | |
| ''' | |
| 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 spaces | |
| 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=False), gr.File(path, visible=False) | |
| else: | |
| return gr.DataFrame(df, visible=True), gr.File(path, visible=True) | |
| ''' | |
| Calls private function to randomly generate 10 of the best schedules. | |
| Returns: DataFrame, filepath | |
| ''' | |
| def random_schedules_wrapper(schedule_name: str, password: str): | |
| gr.Info('', ALERT_TIME, title='Working on generating schedules! Please do NOT click anything on this page.') | |
| res = generator(schedule_name, password, api_name='generate_random_schedules') | |
| df = res[1]['value'] | |
| file = res[2]['value'] | |
| if len(df['data'][0]) == 0: | |
| gr.Warning('', ALERT_TIME, title='No one has filled out the form yet.') | |
| return gr.DataFrame(df, visible=False), gr.File(file, visible=False) | |
| else: | |
| gr.Info('', ALERT_TIME, title=res[0]['value']) | |
| return gr.DataFrame(df, visible=True), gr.File(file, visible=True) | |
| ''' | |
| Calls private function to generate all of the best schedules. | |
| (The same as random_schedules_wrapper) with a different argument for num_results when calling generator. | |
| Gradio requires these to be two separate functions. | |
| Returns: DataFrame, filepath | |
| ''' | |
| def all_schedules_wrapper(schedule_name: str, password: str): | |
| gr.Info('', ALERT_TIME, title='Working on generating schedules! Please do NOT click anything on this page.') | |
| res = generator(schedule_name, password, api_name='generate_all_schedules') | |
| df = res[1]['value'] | |
| file = res[2]['value'] | |
| if len(df['data'][0]) == 0: | |
| gr.Warning('', ALERT_TIME, title='No one has filled out the form yet.') | |
| return gr.DataFrame(df, visible=False), gr.File(file, visible=False) | |
| else: | |
| gr.Info('', ALERT_TIME, title=res[0]['value']) | |
| return gr.DataFrame(df, visible=True), gr.File(file, 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() | |
| ''' | |
| Delete a response | |
| Returns: None | |
| ''' | |
| def my_delete(schedule_name: str, curr_juggler_name: str): | |
| response = client.table('Forms').select('responses', 'slots').eq('form_name', standardize(schedule_name)).execute() | |
| data = response.data | |
| if len(data) > 0: | |
| form = json.loads(data[0]['responses']) | |
| # Get current lists | |
| curr_juggler_name = curr_juggler_name.strip() | |
| names = form[NAME_COL] | |
| emails = form[EMAIL_COL] | |
| bandwidths = form[NUM_WORKSHOPS_COL] | |
| availabilities = form[AVAIL_COL] | |
| descriptions = form[DESCRIP_COL] | |
| # Get index of the juggler's name | |
| try: | |
| index = names.index(curr_juggler_name) | |
| except: | |
| return gr.Warning('', ALERT_TIME, title=f"\"{curr_juggler_name}\" is not in the form responses. Please check the spelling and try again.") | |
| # Remove juggler's responses from the lists | |
| del names[index] | |
| del emails[index] | |
| del bandwidths[index] | |
| del availabilities[index] | |
| del descriptions[index] | |
| # 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='Response deleted 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.") | |
| ### MARKDOWN TEXT ### | |
| generate_markdown = f""" | |
| The app will attempt to create schedules where everyone is teaching their desired 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 | |
| If someone can teach at every possible timeslot, then they willl NOT be in any of the schedules (this helps the code run faster).\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. Include the title, prereqs, and difficulty level for each workshop. Hit "Enter" after each one ("Return" if you\'re on mobile).', visible=False) | |
| def add_descrip(descriptions, new_description): | |
| return descriptions + [{"name": new_description}], "" | |
| new_description.submit(add_descrip, [descriptions, new_description], [descriptions, new_description]) | |
| 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", type='email') | |
| 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.', type='password') | |
| password_2 = gr.Textbox(label='Password Again', info='Enter your password again', type='password') | |
| 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 ("Return" if you\'re on mobile). 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]) | |
| 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", type='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: | |
| 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=random_schedules_wrapper, inputs=[schedule_name, password], outputs=[generated_df_out, generated_file_out]) | |
| generate_all_results_btn.click(fn=all_schedules_wrapper, inputs=[schedule_name, password], outputs=[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]) | |
| # 4. Delete response | |
| with gr.Column(visible=False) as delete_btn_col: | |
| gr.Markdown('# Delete a Response') | |
| gr.Markdown('Pressing this button will delete the juggler\'s response entirely. Warning: this CANNOT be undone!!') | |
| juggler_name = gr.Textbox(label="Juggler's Name: Enter the name of the juggler's response that you want to delete") | |
| delete_btn = gr.Button('Delete Response') | |
| delete_btn.click(fn=my_delete, inputs=[schedule_name, juggler_name]) | |
| 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, delete_btn_col]) | |
| ### INFO ### | |
| with gr.Tab('About'): | |
| gr.Markdown(about_markdown) | |
| directory = os.path.abspath(os.getcwd()) | |
| allowed = directory #+ "/schedules" | |
| demo.launch(allowed_paths=[allowed]) |