app.py

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()