Spaces:
Build error
Build error
import pandas as pd | |
from transformers import AutoTokenizer | |
from transformers import RobertaTokenizer, EncoderDecoderModel | |
import gradio as gr | |
import string | |
from utils import (get_metadata, | |
append_prefix, | |
append_suffix, | |
process_field) | |
metadata = "metadata.csv" | |
channel_dict, function_dict_trigger, function_dict_action, field_mapping, valid_field, channel_to_function_dict = get_metadata(path=metadata) | |
tokenizer = RobertaTokenizer.from_pretrained("imamnurby/rob2rand_merged_w_prefix_c_fc_field") | |
model_oneshot = EncoderDecoderModel.from_pretrained("imamnurby/rob2rand_merged_w_prefix_c_fc_field") | |
model_interactive = EncoderDecoderModel.from_pretrained("imamnurby/rob2rand_merged_w_prefix_c_fc_interactive") | |
### | |
# INTERACTIVE GENERATION FUNCTIONS | |
### | |
def return_same(input_desc): | |
return input_desc | |
def update_dropdown_trig_ch(df_result): | |
list_result = [] | |
answer = '' | |
for ind in df_result.index: | |
if str(df_result['No.'][ind]) != '': | |
answer = str(df_result['No.'][ind])+ ' - '+ str(df_result['Trigger Channel'][ind]) | |
list_result.append(answer) | |
return gr.Dropdown.update(choices=list_result) | |
def update_dropdown_trig_func(df_result): | |
list_result = [] | |
answer = '' | |
for ind in df_result.index: | |
if str(df_result['No.'][ind]) != '': | |
answer = str(df_result['No.'][ind])+ ' - '+ str(df_result['Trigger Function'][ind]) | |
list_result.append(answer) | |
return gr.Dropdown.update(choices=list_result) | |
def update_dropdown_action_ch(df_result): | |
list_result = [] | |
answer = '' | |
for ind in df_result.index: | |
if str(df_result['No.'][ind]) != '': | |
answer = str(df_result['No.'][ind])+ ' - '+ str(df_result['Action Channel'][ind]) | |
list_result.append(answer) | |
return gr.Dropdown.update(choices=list_result) | |
def update_dropdown_action_func(df_result): | |
list_result = [] | |
answer = '' | |
for ind in df_result.index: | |
if str(df_result['No.'][ind]) != '': | |
answer = str(df_result['No.'][ind])+ ' - '+ str(df_result['Action Function'][ind]) | |
list_result.append(answer) | |
return gr.Dropdown.update(choices=list_result) | |
def set_trigger_ch(df_result, string_chosen): | |
index_chosen = string_chosen[0:1] | |
index_chosen = int(index_chosen) | |
return gr.Textbox.update(value = df_result.iloc[index_chosen-1]["Trigger Channel"]) | |
def set_trig_func(df_result, string_chosen): | |
index_chosen = string_chosen[0:1] | |
index_chosen = int(index_chosen) | |
return gr.Textbox.update(value = df_result.iloc[index_chosen-1]["Trigger Function"]) | |
def set_action_ch(df_result, string_chosen): | |
index_chosen = string_chosen[0:1] | |
index_chosen = int(index_chosen) | |
return gr.Textbox.update(value = df_result.iloc[index_chosen-1]["Action Channel"]) | |
def set_final_result(tf, df_result, string_chosen): | |
index_chosen = string_chosen[0:1] | |
index_chosen = int(index_chosen) | |
af = df_result.iloc[index_chosen-1]["Action Function"] | |
tf_field = field_mapping.get(tf, "()") | |
tf = tf + tf_field | |
af_field = field_mapping.get(af, "()") | |
af = af + af_field | |
df_dict = {"Trigger": [tf], | |
"Action": [af]} | |
return pd.DataFrame(df_dict) | |
def generate_preds_tc(input_desc, n_beams_interactive): | |
count_arr = [] | |
decoded_preds=[] | |
descriptions=[] | |
if input_desc!='': | |
desc = input_desc.lower() | |
desc = append_prefix(desc=desc, | |
prefix= "GENERATE TRIGGER CHANNEL <pf> ") | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
preds = model_interactive.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_interactive, | |
num_return_sequences=n_beams_interactive, | |
early_stopping=True) | |
count = 0 | |
for item in preds: | |
temp_pred = (tokenizer.decode(item, skip_special_tokens=True)) | |
if temp_pred in channel_dict.keys(): | |
count = count + 1 | |
count_arr.append(count) | |
decoded_preds.append(temp_pred) | |
temp_desc = channel_dict.get(temp_pred, "null") | |
descriptions.append(temp_desc) | |
df = {'No.':count_arr, | |
'Trigger Channel': decoded_preds, | |
'Description': descriptions} | |
return pd.DataFrame(df) | |
def generate_preds_tf(input_desc, n_beams_interactive, selected_tc): | |
count_arr = [] | |
decoded_preds=[] | |
descriptions=[] | |
if input_desc!='' and selected_tc!='': | |
desc = input_desc.lower() | |
desc = append_prefix(desc=desc, | |
prefix="GENERATE TRIGGER FUNCTION <pf> ") | |
desc = append_suffix(desc=desc, | |
suffix=f" <out> {selected_tc}") | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
preds = model_interactive.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_interactive, | |
num_return_sequences=n_beams_interactive, | |
early_stopping=True) | |
count = 0 | |
for item in preds: | |
temp_pred = (tokenizer.decode(item, skip_special_tokens=True)) | |
if temp_pred in function_dict_trigger.keys(): | |
temp_desc = function_dict_trigger.get(temp_pred, "null") | |
if selected_tc in temp_pred: | |
count = count + 1 | |
count_arr.append(count) | |
decoded_preds.append(temp_pred) | |
descriptions.append(temp_desc) | |
df = {'No.': count_arr, | |
'Trigger Function': decoded_preds, | |
'Description': descriptions} | |
return pd.DataFrame(df) | |
def generate_preds_ac(input_desc, n_beams_interactive, selected_tc, selected_tf): | |
count_arr = [] | |
decoded_preds=[] | |
descriptions=[] | |
if input_desc!='' and selected_tf!='': | |
desc = input_desc.lower() | |
desc = append_prefix(desc=desc, | |
prefix= "GENERATE ACTION CHANNEL <pf> ") | |
desc = append_suffix(desc=desc, | |
suffix=f" <out> {selected_tc} {selected_tf}") | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
preds = model_interactive.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_interactive, | |
num_return_sequences=n_beams_interactive, | |
early_stopping=True) | |
count = 0 | |
for item in preds: | |
temp_pred = (tokenizer.decode(item, skip_special_tokens=True)) | |
if temp_pred in channel_dict.keys(): | |
count = count + 1 | |
count_arr.append(count) | |
decoded_preds.append(temp_pred) | |
temp_desc = channel_dict.get(temp_pred, "null") | |
descriptions.append(temp_desc) | |
df = {'No.':count_arr, | |
'Action Channel': decoded_preds, | |
'Description': descriptions} | |
return pd.DataFrame(df) | |
def generate_preds_af(input_desc, n_beams_interactive, selected_tc, selected_tf, selected_ac): | |
count_arr = [] | |
decoded_preds=[] | |
descriptions=[] | |
if input_desc!='' and selected_ac!='': | |
desc = input_desc.lower() | |
desc = append_prefix(desc=desc, | |
prefix="GENERATE TRIGGER FUNCTION <pf> ") | |
desc = append_suffix(desc=desc, | |
suffix=f" <out> {selected_tc} {selected_tf} {selected_ac}") | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
preds = model_interactive.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_interactive, | |
num_return_sequences=n_beams_interactive, | |
early_stopping=True) | |
count = 0 | |
for item in preds: | |
temp_pred = (tokenizer.decode(item, skip_special_tokens=True)) | |
if temp_pred in function_dict_action.keys(): | |
temp_desc = function_dict_action.get(temp_pred, "null") | |
if selected_ac in temp_pred: | |
count = count + 1 | |
count_arr.append(count) | |
decoded_preds.append(temp_pred) | |
descriptions.append(temp_desc) | |
df = {'No.':count_arr, | |
'Action Function': decoded_preds, | |
'Description': descriptions} | |
df = pd.DataFrame(df) | |
df.index.names = ['Ranking'] | |
return df | |
### | |
### | |
# ONESHOT GENERATION FUNCTIONS | |
### | |
def generate_oneshot(input_desc, n_beams_oneshot): | |
trigger = [] | |
trigger_desc = [] | |
action = [] | |
action_desc = [] | |
if input_desc!='': | |
desc = input_desc.lower() | |
prefix="GENERATE ON THE FIELD-LEVEL GRANULARITY <pf> " | |
desc = append_prefix(desc=desc, | |
prefix=prefix) | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
# activate beam search and early_stopping | |
preds = model_oneshot.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_oneshot, | |
num_return_sequences=n_beams_oneshot, | |
early_stopping=True) | |
decoded_preds = [] | |
for item in preds: | |
decoded_preds.append(tokenizer.decode(item, skip_special_tokens=True)) | |
for item in decoded_preds: | |
invalid_field = False | |
splitted_items = item.split("<sep>") | |
processed = [] | |
if len(splitted_items)==6: | |
for idx, subitem in enumerate(splitted_items): | |
if idx!=2 or idx!=4: | |
subitem = subitem.strip() | |
processed.append(subitem) | |
assert(len(processed)==6) | |
temp_tf = processed[1] | |
temp_af = processed[4] | |
temp_tf_field = process_field(processed[2]) | |
for field in temp_tf_field: | |
if field not in valid_field: | |
invalid_field = True | |
break | |
if invalid_field: | |
continue | |
temp_tf_field = "(" + ", ".join(temp_tf_field) + ")" | |
temp_af_field = process_field(processed[-1]) | |
for field in temp_af_field: | |
if field not in valid_field: | |
invalid_field = True | |
break | |
if invalid_field: | |
continue | |
temp_af_field = "(" + ", ".join(temp_af_field) + ")" | |
if temp_tf in function_dict_trigger.keys() and temp_af in function_dict_action.keys(): | |
temp_tf_desc = function_dict_trigger.get(temp_tf) | |
temp_af_desc = function_dict_action.get(temp_af) | |
temp_tf = temp_tf + temp_tf_field | |
temp_af = temp_af + temp_af_field | |
trigger.append(temp_tf) | |
trigger_desc.append(temp_tf_desc) | |
action.append(temp_af) | |
action_desc.append(temp_af_desc) | |
df = {"Trigger": trigger, | |
"Action": action, | |
"Trigger Description": trigger_desc, | |
"Action Description": action_desc} | |
return pd.DataFrame(df) | |
### | |
### | |
# DISCOVER FUNCTIONS | |
### | |
def generate_channel(input_desc, n_beams_discover): | |
trigger = [] | |
trigger_func = [] | |
trigger_desc = [] | |
action = [] | |
action_func = [] | |
action_desc = [] | |
if input_desc!='': | |
desc = input_desc.lower() | |
prefix="GENERATE CHANNEL ONLY WITHOUT FUNCTION <pf> " | |
desc = append_prefix(desc=desc, | |
prefix=prefix) | |
input_ids = tokenizer.encode(desc, return_tensors='pt') | |
# activate beam search and early_stopping | |
preds = model_oneshot.generate(input_ids, | |
max_length=200, | |
num_beams=n_beams_discover, | |
num_return_sequences=n_beams_discover, | |
early_stopping=True) | |
decoded_preds = [] | |
for item in preds: | |
decoded_preds.append(tokenizer.decode(item, skip_special_tokens=True)) | |
for item in decoded_preds: | |
channels = item.split("<sep>") | |
channels = [ch.strip() for ch in channels] | |
if len(channels)==2: | |
if channels[0] in channel_dict.keys() and channels[1] in channel_dict.keys() and channels[0] in channel_to_function_dict.keys() and channels[1] in channel_to_function_dict.keys(): | |
temp_tc_desc = channel_dict.get(channels[0]) | |
trigger_desc.append(temp_tc_desc) | |
trigger.append(channels[0]) | |
trigger_func.append(channel_to_function_dict.get(channels[0])) | |
temp_ac_desc = channel_dict.get(channels[1]) | |
action_desc.append(temp_ac_desc) | |
action.append(channels[1]) | |
action_func.append(channel_to_function_dict.get(channels[1])) | |
df_trigger = pd.DataFrame({"Trigger": trigger, | |
"Available Functions": trigger_func, | |
"Trigger Description": trigger_desc}) | |
df_action = pd.DataFrame({"Action": action, | |
"Available Functions": action_func, | |
"Action Description": action_desc}) | |
df_trigger.drop_duplicates(inplace=True) | |
df_action.drop_duplicates(inplace=True) | |
return pd.DataFrame(df_trigger), pd.DataFrame(df_action) | |
### | |
# MAIN GRADIO APP | |
### | |
demo = gr.Blocks() | |
with demo: | |
gr.Markdown("<h1><center><em>RecipeGen++</em>: An Automated Trigger Action Programs (TAPs) Generator</center></h1>") | |
# gr.Markdown("This demo allows you to generate TAPs using functionality description described in English. You can learn the working detail of our tool from our paper") | |
gr.Markdown("<h3>What is TAP?</h3>") | |
gr.Markdown(""" | |
TAPs or Trigger Action Programs are event-driven rules used to automate smart devices and/or internet services. | |
TAPs are written in the form of "IF a {trigger} is satisfied then execute an {action}, where the {trigger} and the {action} correspond to API calls. | |
TAPs have been used in various use cases, ranging from the home monitoring system to business workflow automation. | |
""") | |
gr.Markdown("<h3>What is <em>RecipeGen++</em>?</h3>") | |
gr.Markdown(""" | |
*RecipeGen++* is a deep learning-based tool that can assist end-users to generate TAPs using natural language description. | |
End-users can describe the functionality of the intended TAP, then *RecipeGen++* will generate the TAP candidates based on the given description. | |
""") | |
gr.Markdown("<h3>Working Mode</h3>") | |
gr.Markdown(""" | |
- Interactive: generate a TAP using a step-by-step wizard | |
- One-Click: generate a TAP using the one-click button | |
- Functionality Discovery: discover relevant functionalities from channels with similar functionalities | |
""") | |
with gr.Tabs(): | |
with gr.TabItem("Interactive"): | |
gr.Markdown("<h3><center>Instructions for Interactive Mode</center></h3>") | |
gr.Markdown("""1. There are 5 generation steps, i.e., generating trigger channel, trigger function, action channel, action function, and the final TAP. | |
2. **[STEP 1]** Describe the functionality in the `Functionality Description` text box. Click the `Generate Trigger Channel` button. The channel candidates and their descriptions will show up in the `Trigger Channel Results` table. | |
3. **[STEP 2]** Select a trigger channel from the dropdown `Select the Trigger Channel`. Click the `Generate Trigger Function` button. The function candidates and their descriptions will show up in the `Trigger Function Results` table. | |
4. **[STEP 3]** Select a trigger function from the dropdown `Select the Trigger Function`. Click the `Generate Action Channel` button. The channel candidates and their descriptions will show up in the `Action Channel Results` table. | |
5. **[STEP 4]** Select an action channel from the dropdown `Select the Action Channel`. Click the `Generate Action Function` button. The function candidates and their descriptions will show up in the `Action Function Results` table. | |
6. **[STEP 5]** Select an action function from the `Select the Action Function` to generate the final TAP.""") | |
gr.Markdown(""" NOTE: You can control how many sequences are returned by tuning the `Beam Width` slider. A larger value will cause a longer generation time. | |
""") | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("You can describe your own functionality directly in the `Functionality Description` text box or try a description sample from the dropdown below:") | |
dropdown_example = gr.Dropdown(type ="value", | |
choices = ["Log to my spreadsheet if motion is detected in the living room","When I am not home, let me know when any motion is detected in my house", "Turn on my Philips lamp every sunset","Update my picture in Twitter when I change my profile picture in Facebook","Save in notes when I create a new bookmark"], | |
label = "Select a sample functionality descriptions") | |
button_use_example = gr.Button("Try this sample") | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("<h4><center>Step 1: Generate Trigger Channels</center></h4>") | |
textbox_input = gr.Textbox(label="Functionality Description", placeholder="Describe the functionality here") | |
n_beams_interactive = gr.Slider(minimum=2, maximum=100, value=20, step=1, label="Beam Width") | |
button_generate_tc = gr.Button("Generate Trigger Channels") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Trigger Channel Results</center></h4>") | |
table_tc = gr.Dataframe(headers=["No.","Trigger Channel", "Description"], row_count=1) | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("<h4><center>Step 2: Generate Trigger Functions</center></h4>") | |
dropdown_tc = gr.Dropdown(label="Select the Trigger Channel",type="value", choices=['']) | |
textbox_selected_tc = gr.Textbox(value="", visible=False, label="") | |
button_generate_tf = gr.Button("Generate Trigger Functions") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Trigger Function Results</center></h4>") | |
table_tf = gr.Dataframe(headers=["No.","Trigger Function", "Description"], row_count=1) | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("<h4><center>Step 3: Generate Action Channels</center></h4>") | |
dropdown_tf = gr.Dropdown(label="Select the Trigger Function",type="value", choices=['']) | |
textbox_selected_tf = gr.Textbox(value="", visible=False, label="") | |
button_generate_ac = gr.Button("Generate Action Channels") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Action Channel Results</center></h4>") | |
table_ac = gr.Dataframe(headers=["No.","Action Channel", "Description"], row_count=1) | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("<h4><center>Step 4: Generate Action Functions</center></h4>") | |
dropdown_ac = gr.Dropdown(label="Select the Action Channel",type="value", choices=['']) | |
textbox_selected_ac = gr.Textbox(value="", visible=False, label="") | |
button_generate_af = gr.Button("Generate Action Functions") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Action Function Results</center></h4>") | |
table_af = gr.Dataframe(headers=["No.","Action Function", "Description"], row_count=1) | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("<h4><center>Step 5: Generate the Final TAP</center></h4>") | |
dropdown_af = gr.Dropdown(label="Select the Action Function",type="value", choices=['']) | |
table_final = gr.Dataframe(headers=["Trigger","Action"], row_count=1) | |
button_use_example.click(return_same, inputs=[dropdown_example], outputs=[textbox_input]) | |
button_use_example.click(generate_preds_tc, inputs=[dropdown_example, n_beams_interactive], outputs=[table_tc]) | |
button_generate_tc.click(generate_preds_tc, inputs=[textbox_input, n_beams_interactive], outputs=[table_tc]) | |
table_tc.change(fn=update_dropdown_trig_ch, inputs=[table_tc], outputs=[dropdown_tc]) | |
dropdown_tc.change(fn=set_trigger_ch, inputs=[table_tc,dropdown_tc], outputs=[textbox_selected_tc]) | |
button_generate_tf.click(generate_preds_tf, inputs=[textbox_input, n_beams_interactive, textbox_selected_tc], outputs=[table_tf]) | |
table_tf.change(fn=update_dropdown_trig_func, inputs=[table_tf], outputs=[dropdown_tf]) | |
dropdown_tf.change(fn=set_trig_func, inputs=[table_tf,dropdown_tf], outputs=[textbox_selected_tf]) | |
button_generate_ac.click(generate_preds_ac, inputs=[textbox_input, n_beams_interactive, textbox_selected_tc, textbox_selected_tf], outputs=[table_ac]) | |
table_ac.change(fn=update_dropdown_action_ch, inputs=[table_ac], outputs=[dropdown_ac]) | |
dropdown_ac.change(fn=set_action_ch, inputs=[table_ac,dropdown_ac], outputs=[textbox_selected_ac]) | |
button_generate_af.click(generate_preds_af, inputs=[textbox_input, n_beams_interactive, textbox_selected_tc, textbox_selected_tf, textbox_selected_ac], outputs=[table_af]) | |
table_af.change(fn=update_dropdown_action_func, inputs=[table_af], outputs=[dropdown_af]) | |
dropdown_af.change(fn=set_final_result, inputs=[textbox_selected_tf, table_af, dropdown_af], outputs=[table_final]) | |
with gr.TabItem("One-Click"): | |
gr.Markdown("<h3><center>Instructions for One-Click Mode</center></h3>") | |
gr.Markdown(""" | |
1. Describe the functionality by yourself in the `Functionality Description` text box | |
2. Click `Generate TAP` button. The TAP candidates will show up in the `TAP Results` table. The table consists of 4 columns: Trigger, Action, Trigger Description, and Action Description. You can scroll the table horizontally. | |
""") | |
gr.Markdown(""" NOTE: You can control how many sequences are returned by tuning the `Beam Width` slider. A larger value will cause a longer generation time.""") | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("You can describe your own functionality directly in the `Functionality Description` text box or try a description sample from the dropdown below:") | |
dropdown_example = gr.Dropdown(type ="value", | |
choices = ["Log to my spreadsheet if motion is detected in the living room","When I am not home, let me know when any motion is detected in my house", "Turn on my Philips lamp every sunset","Update my picture in Twitter when I change my profile picture in Facebook","Save in notes when I create a new bookmark"], | |
label = "Select a sample functionality description") | |
button_use_example = gr.Button("Try this sample") | |
with gr.Box(): | |
with gr.Column(): | |
textbox_input = gr.Textbox(label="Functionality Description", placeholder="Describe the functionality here") | |
n_beams_oneshot = gr.Slider(minimum=2, maximum=100, value=20, step=1, label="Beam Width") | |
button_generate_oneshot = gr.Button("Generate TAPs") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>TAP Results</center></h4>") | |
table_oneshot = gr.Dataframe(headers=["Trigger", "Action", "Trigger Description", "Action Description"], row_count=1) | |
button_use_example.click(return_same, inputs=[dropdown_example], outputs=[textbox_input]) | |
button_use_example.click(generate_oneshot, inputs=[dropdown_example, n_beams_oneshot], outputs=[table_oneshot]) | |
button_generate_oneshot.click(generate_oneshot, inputs=[textbox_input, n_beams_oneshot], outputs=[table_oneshot]) | |
with gr.TabItem("Functionality Discovery"): | |
gr.Markdown("<h3><center>Instructions for Functionality Discovery Mode</center></h3>") | |
gr.Markdown(""" | |
1. Describe the functionality in the `Functionality Description` text box. | |
2. Click `Discover Functionalities` button. The table containing relevant trigger and action channels will show up. Each channel is accompanied by a list of available functionalities. You can scroll the table horizontally. | |
""") | |
gr.Markdown(""" NOTE: You can control how many sequences are returned by tuning the `Beam Width` slider. A larger value will cause a longer generation time.""") | |
with gr.Box(): | |
with gr.Column(): | |
gr.Markdown("You can describe your own functionality directly in the `Functionality Description` text box or try a description sample from the dropdown below:") | |
dropdown_example = gr.Dropdown(type ="value", | |
choices = ["Log to my spreadsheet if motion is detected in the living room","When I am not home, let me know when any motion is detected in my house", "Turn on my Philips lamp every sunset","Update my picture in Twitter when I change my profile picture in Facebook","Save in notes when I create a new bookmark"], | |
label = "Select a sample functionality description") | |
button_use_example = gr.Button("Try this sample") | |
with gr.Box(): | |
with gr.Column(): | |
textbox_input = gr.Textbox(label="Functionality Description", placeholder="Describe the functionality here") | |
n_beams_discover = gr.Slider(minimum=2, maximum=100, value=20, step=1, label="Beam Width") | |
button_discover_function = gr.Button("Discover Functions!") | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Relevant Trigger Channels and Functionalities</center></h4>") | |
table_discover_tc = gr.Dataframe(headers=["Trigger", "Available Functions", "Trigger Description"], row_count=1) | |
gr.Markdown("<br>") | |
gr.Markdown("<h4><center>Relevant Action Channels and Functionalities</center></h4>") | |
table_discover_ac = gr.Dataframe(headers=["Action", "Available Functions", "Action Description"], row_count=1) | |
button_use_example.click(return_same, inputs=[dropdown_example], outputs=[textbox_input]) | |
button_use_example.click(generate_channel, inputs=[dropdown_example, n_beams_discover], outputs=[table_discover_tc, table_discover_ac]) | |
button_discover_function.click(generate_channel, inputs=[textbox_input, n_beams_discover], outputs=[table_discover_tc, table_discover_ac]) | |
demo.launch() |