Table select, bug upload and metrics_bug

app.py

@@ -40,6 +40,7 @@ function refresh() {
     }
 }
 """
+reset_flag=False
 
 with open('style.css', 'r') as file:
     css = file.read()
@@ -80,8 +81,9 @@ def load_data(file, path, use_default):
         try:
             input_data["input_method"] = 'uploaded_file'
             input_data["db_name"] = os.path.splitext(os.path.basename(file))[0]
+            #TODO if not sqlite
             #input_data["data_path"] = os.path.join(".", "data", "data_interface",f"{input_data['db_name']}.sqlite")
-            input_data["data_path"] = f"{input_data['db_name']}.sqlite"
+            input_data["data_path"] = file #f"{input_data['db_name']}.sqlite"
             input_data["data"] = us.load_data(file, input_data["db_name"])
             df_current = input_data["data"]['data_frames'].get('MyTable', df_default)  # Carica il DataFrame
             if(input_data["data"]['data_frames'] and input_data["data"]["db"] is None): #for csv and xlsx files
@@ -295,10 +297,11 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
             ]
         )
 
-   ######################################
+    ######################################
     #        TABLE SELECTION PART        #
     ######################################
     with select_table_acc:
+        previous_selection = gr.State([])
         table_selector = gr.CheckboxGroup(choices=[], label="Select tables from the choosen database", value=[])
         table_outputs = [gr.DataFrame(label=f"Table {i+1}", interactive=True, visible=False) for i in range(50)]
         selected_table_names = gr.Textbox(label="Selected tables", visible=False, interactive=False)
@@ -310,37 +313,69 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
             """Dynamically updates the list of available tables."""
             if isinstance(data, dict) and data:
                 table_names = []
-                table_names.append("All")
-                table_names.extend(data.keys())  # Concatena data.keys() alla lista
+
+                if input_data['input_method'] == "default":
+                    table_names.append("All")
+
+                elif len(data) < 6:
+                    table_names.append("All")  # In caso ci siano poche tabelle, ha senso mantenere "All"
+
+                table_names.extend(data.keys())
                 return gr.update(choices=table_names, value=[])  # Reset selections
-            return gr.update(choices=[], value=[])
 
+            return gr.update(choices=[], value=[])
+        
         def show_selected_tables(data, selected_tables):
-            """Displays only the tables selected by the user and enables the button."""
             updates = []
-            if isinstance(data, dict) and data:
-
-                available_tables = list(data.keys())  # Actually available names
-                if "All" in selected_tables:
-                    selected_tables = available_tables
+            available_tables = list(data.keys()) if isinstance(data, dict) and data else []
+            input_method = input_data['input_method']
+
+            allow_all = input_method == "default" or len(available_tables) < 6
+            selected_set = set(selected_tables)
+            tables_set = set(available_tables)
+
+            # ▶️ 
+            if allow_all:
+                if "All" in selected_set:
+                    selected_tables = ["All"] + available_tables
+                elif selected_set == tables_set:
+                    selected_tables = []
                 else:
-                    selected_tables = [t for t in selected_tables if t in available_tables]  # Filter valid selections
-                
-                tables = {name: data[name] for name in selected_tables}  # Filter the DataFrames
-                
-                for i, (name, df) in enumerate(tables.items()):
-                    updates.append(gr.update(value=df, label=f"Table: {name}", visible=True, interactive=False))
+                    #
+                    selected_tables = [t for t in selected_tables if t in available_tables]
+            else:
+                # 
+                selected_tables = [t for t in selected_tables if t in available_tables and t != "All"][:5]
 
-                # If there are fewer than 5 tables, hide the other DataFrames
-                for _ in range(len(tables), 50):
-                    updates.append(gr.update(visible=False))
+            # 
+            tables = {name: data[name] for name in selected_tables if name in data}
+
+            for i, (name, df) in enumerate(tables.items()):
+                updates.append(gr.update(value=df, label=f"Table: {name}", visible=True, interactive=False))
+            for _ in range(len(tables), 50):
+                updates.append(gr.update(visible=False))
+
+            # ✅ Bottone abilitato solo se c'è almeno una tabella valida
+            updates.append(gr.update(interactive=bool(tables)))
+
+            # 🔄 Aggiorna la CheckboxGroup con logica coerente
+            if allow_all:
+                updates.insert(0, gr.update(
+                    choices=["All"] + available_tables,
+                    value=selected_tables
+                ))
             else:
-                updates = [gr.update(value=pd.DataFrame(), visible=False) for _ in range(50)]
+                if len(selected_tables) >= 5:
+                    updates.insert(0, gr.update(
+                        choices=selected_tables,
+                        value=selected_tables
+                    ))
+                else:
+                    updates.insert(0, gr.update(
+                        choices=available_tables,
+                        value=selected_tables
+                    ))
 
-            # Enable/disable the button based on selections
-            button_state = bool(selected_tables)  # True if at least one table is selected, False otherwise
-            updates.append(gr.update(interactive=button_state))  # Update button state
-            
             return updates
 
         def show_selected_table_names(data, selected_tables):
@@ -357,8 +392,12 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
         data_state.change(fn=update_table_list, inputs=[data_state], outputs=[table_selector])
 
         # Updates the visible tables and the button state based on user selections
-        table_selector.change(fn=show_selected_tables, inputs=[data_state, table_selector], outputs=table_outputs + [open_model_selection])
-
+        #table_selector.change(fn=show_selected_tables, inputs=[data_state, table_selector], outputs=table_outputs + [open_model_selection])
+        table_selector.change(
+            fn=show_selected_tables,
+            inputs=[data_state, table_selector],
+            outputs=[table_selector] + table_outputs + [open_model_selection]
+        )
         # Shows the list of selected tables when "Choose your models" is clicked
         open_model_selection.click(fn=show_selected_table_names, inputs=[data_state, table_selector], outputs=[selected_table_names])
         open_model_selection.click(open_accordion, inputs=gr.State("model_selection"), outputs=[upload_acc, select_table_acc, select_model_acc, qatch_acc, metrics_acc])
@@ -568,6 +607,7 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
         
         def qatch_flow():
             #caching
+            global reset_flag
             predictions_dict = {model: pd.DataFrame(columns=['id', 'question', 'predicted_sql', 'time', 'query', 'db_path']) for model in model_list}
             metrics_conc = pd.DataFrame()
             columns_to_visulize = ["db_path", "tbl_name", "test_category", "sql_tag", "query", "question", "predicted_sql", "time", "price", "answer"]
@@ -577,35 +617,36 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                 target_df = target_df[target_df["tbl_name"].isin(input_data['data']['selected_tables'])]
                 target_df = target_df[target_df["model"].isin(input_data['models'])]
                 predictions_dict = {model: target_df[target_df["model"] == model] if model in target_df["model"].unique() else pd.DataFrame(columns=target_df.columns) for model in model_list}
-
+                reset_flag = False
                 for model in input_data['models']:
                     model_image_path = next((m["image_path"] for m in model_list_dict if m["code"] == model), None)                
                     yield gr.Image(model_image_path), gr.Markdown(), gr.Markdown(), gr.Markdown(), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
                     count=1
                     for _, row in predictions_dict[model].iterrows():
                     #for index, row in target_df.iterrows():
-                        percent_complete = round(count / len(predictions_dict[model]) * 100, 2)
-                        count=count+1
-                        load_text = f"{generate_loading_text(percent_complete)}"
-                        question = row['question']
-                        
-                        display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Natural Language:</div> 
-                                                <div style='display: flex; align-items: center;'>
-                                                    <div class='sqlquery' font-family: 'Inter', sans-serif;>{question}</div>
-                                                    <div style='font-size: 3rem'>➡️</div>
-                                                </div>
-                                            """
-                        yield gr.Image(), gr.Markdown(load_text), gr.Markdown(display_question), gr.Markdown(), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
-                        #time.sleep(0.02)
-                        prediction = row['predicted_sql']
-                        
-                        display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Predicted SQL:</div> 
-                                                <div style='display: flex; align-items: center;'>
-                                                    <div style='font-size: 3rem'>➡️</div>
-                                                    <div class='sqlquery' font-family: 'Inter', sans-serif;>{prediction}</div>
-                                                </div>
-                                            """
-                        yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
+                        if (reset_flag == False):
+                            percent_complete = round(count / len(predictions_dict[model]) * 100, 2)
+                            count=count+1
+                            load_text = f"{generate_loading_text(percent_complete)}"
+                            question = row['question']
+                            
+                            display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Natural Language:</div> 
+                                                    <div style='display: flex; align-items: center;'>
+                                                        <div class='sqlquery' font-family: 'Inter', sans-serif;>{question}</div>
+                                                        <div style='font-size: 3rem'>➡️</div>
+                                                    </div>
+                                                """
+                            yield gr.Image(), gr.Markdown(load_text), gr.Markdown(display_question), gr.Markdown(), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
+                            #time.sleep(0.02)
+                            prediction = row['predicted_sql']
+                            
+                            display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Predicted SQL:</div> 
+                                                    <div style='display: flex; align-items: center;'>
+                                                        <div style='font-size: 3rem'>➡️</div>
+                                                        <div class='sqlquery' font-family: 'Inter', sans-serif;>{prediction}</div>
+                                                    </div>
+                                                """
+                            yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
                     yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
                 metrics_conc = target_df    
                 if 'valid_efficiency_score' not in metrics_conc.columns:
@@ -622,74 +663,74 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                 #target_df = orchestrator_generator.generate_dataset(connector=input_data['data']['db'], tables_to_includes=None)
 
                 predictor = ModelPrediction()
-        
+                reset_flag = False
                 for model in input_data["models"]:
                     model_image_path = next((m["image_path"] for m in model_list_dict if m["code"] == model), None)
                     yield gr.Image(model_image_path), gr.Markdown(), gr.Markdown(), gr.Markdown(), metrics_conc, *[predictions_dict[model] for model in model_list]
                     count=0
                     for index, row in target_df.iterrows():
-                        
-                        percent_complete = round(((index+1) / len(target_df)) * 100, 2)
-                        load_text = f"{generate_loading_text(percent_complete)}"
-                        
-                        question = row['question']
-                        display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Natural Language:</div> 
-                                                <div style='display: flex; align-items: center;'>
-                                                    <div class='sqlquery' font-family: 'Inter', sans-serif;>{question}</div>
-                                                    <div style='font-size: 3rem'>➡️</div>
-                                                </div>
-                                            """
-                        yield gr.Image(), gr.Markdown(load_text), gr.Markdown(display_question), gr.Markdown(), metrics_conc, *[predictions_dict[model]for model in model_list]
-                        start_time = time.time()
-                        samples = us.generate_some_samples(input_data['data']['db'], row["tbl_name"])
-
-                        schema_text = utils_get_db_tables_info.utils_extract_db_schema_as_string(
-                        db_id = input_data["db_name"], 
-                        base_path = input_data["data_path"], 
-                        normalize=False, 
-                        sql=row["query"]
-                        )
-
-                        prompt_to_send = us.prepare_prompt(input_data["prompt"], question, schema_text, samples)
-                        #PREDICTION SQL
-                        if prompt_to_send == prompt_default:
-                            prompt_to_send = None
-                        response = predictor.make_prediction(question=question, db_schema=schema_text, model_name=model, prompt=f"{prompt_to_send}")
-                        prediction = response['response_parsed']
-                        price = response['cost']
-                        answer = response['response']
-
-                        end_time = time.time()
-                        display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>>Predicted SQL:</div> 
-                                                <div style='display: flex; align-items: center;'>
-                                                    <div style='font-size: 3rem'>➡️</div>
-                                                    <div class='sqlquery' font-family: 'Inter', sans-serif;>{prediction}</div>
-                                                </div>
-                                            """
-                        # Create a new row as dataframe
-                        new_row = pd.DataFrame([{
-                            'id': index,
-                            'question': question,
-                            'predicted_sql': prediction,
-                            'time': end_time - start_time,
-                            'query': row["query"],
-                            'db_path': input_data["data_path"],
-                            'price':price,
-                            'answer':answer,
-                            'number_question':count
-                        }]).dropna(how="all")  # Remove only completely empty rows
-                        count=count+1
-                        # TODO: use a for loop
-                        for col in target_df.columns:
-                            if col not in new_row.columns:
-                                new_row[col] = row[col]
-
-                        # Update model's prediction dataframe incrementally
-                        if not new_row.empty:
-                            predictions_dict[model] = pd.concat([predictions_dict[model], new_row], ignore_index=True)
-
-                        # yield gr.Textbox(), gr.Textbox(prediction), *[predictions_dict[model] for model in input_data["models"]], None
-                        yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model]for model in model_list]
+                        if (reset_flag == False):                        
+                            percent_complete = round(((index+1) / len(target_df)) * 100, 2)
+                            load_text = f"{generate_loading_text(percent_complete)}"
+                            
+                            question = row['question']
+                            display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>Natural Language:</div> 
+                                                    <div style='display: flex; align-items: center;'>
+                                                        <div class='sqlquery' font-family: 'Inter', sans-serif;>{question}</div>
+                                                        <div style='font-size: 3rem'>➡️</div>
+                                                    </div>
+                                                """
+                            yield gr.Image(), gr.Markdown(load_text), gr.Markdown(display_question), gr.Markdown(), metrics_conc, *[predictions_dict[model]for model in model_list]
+                            start_time = time.time()
+                            samples = us.generate_some_samples(input_data['data']['db'], row["tbl_name"])
+
+                            schema_text = utils_get_db_tables_info.utils_extract_db_schema_as_string(
+                            db_id = input_data["db_name"], 
+                            base_path = input_data["data_path"], 
+                            normalize=False, 
+                            sql=row["query"]
+                            )
+                            
+                            prompt_to_send = us.prepare_prompt(input_data["prompt"], question, schema_text, samples)
+                            #PREDICTION SQL
+
+                            response = predictor.make_prediction(question=question, db_schema=schema_text, model_name=model, prompt=f"{prompt_to_send}")
+                            prediction = response['response_parsed']
+                            price = response['cost']
+                            answer = response['response']
+
+                            end_time = time.time()
+                            display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Inter', sans-serif;'>>Predicted SQL:</div> 
+                                                    <div style='display: flex; align-items: center;'>
+                                                        <div style='font-size: 3rem'>➡️</div>
+                                                        <div class='sqlquery' font-family: 'Inter', sans-serif;>{prediction}</div>
+                                                    </div>
+                                                """
+                            # Create a new row as dataframe
+                            new_row = pd.DataFrame([{
+                                'id': index,
+                                'question': question,
+                                'predicted_sql': prediction,
+                                'time': end_time - start_time,
+                                'query': row["query"],
+                                'db_path': input_data["data_path"],
+                                'price':price,
+                                'answer':answer,
+                                'number_question':count,
+                                'prompt' : prompt_to_send
+                            }]).dropna(how="all")  # Remove only completely empty rows
+                            count=count+1
+                            # TODO: use a for loop
+                            for col in target_df.columns:
+                                if col not in new_row.columns:
+                                    new_row[col] = row[col]
+
+                            # Update model's prediction dataframe incrementally
+                            if not new_row.empty:
+                                predictions_dict[model] = pd.concat([predictions_dict[model], new_row], ignore_index=True)
+
+                            # yield gr.Textbox(), gr.Textbox(prediction), *[predictions_dict[model] for model in input_data["models"]], None
+                            yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model]for model in model_list]
 
                     yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model] for model in model_list]
                     # END 
@@ -802,7 +843,11 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
         #     fn=lambda: gr.update(open=True, visible=True),
         #     outputs=[download_metrics]
         # )
-        reset_data = gr.Button("Back to upload data section", interactive=False)
+        def refresh():
+            global reset_flag
+            reset_flag = True
+
+        reset_data = gr.Button("Back to upload data section", interactive=True)
         
         metrics_df_out.change(fn=allow_download, inputs=[metrics_df_out], outputs=[download_metrics, proceed_to_metrics_button, reset_data])
 
@@ -812,6 +857,7 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
             fn=lambda: gr.update(visible=False),
             outputs=[download_metrics]
         )
+        reset_data.click(refresh)
 
         reset_data.click(
             fn=enable_disable,
@@ -1958,7 +2004,8 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                     model_multiselect_bar = gr.CheckboxGroup(
                         choices=models,
                         label="Select one or more models:",
-                        value=models
+                        value=models,
+                        interactive=len(models) > 1
                     )
                     
                     group_radio = gr.Radio(
@@ -1991,7 +2038,8 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                 model_multiselect_radar = gr.CheckboxGroup(
                     choices=models,
                     label="Select one or more models:",
-                    value=models
+                    value=models,
+                    interactive=len(models) > 1
                 )
                     
             with gr.Row():
@@ -2022,11 +2070,18 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                     label="Select the metrics group that you want to use:",
                     value="Qatch"
                 )
+                model_choices = list(all_model_as_dic.keys())
+                
+                if len(model_choices) == 2:
+                    model_choices = [model_choices[0]]  # supponiamo che il modello sia in prima posizione
+                    selected_value = model_choices[0]
+                else:
+                    selected_value = "All"
                 
                 model_radio_ranking = gr.Radio(
-                    choices=list(all_model_as_dic.keys()),
+                    choices=model_choices,
                     label="Select the model that you want to use:",
-                    value="All"
+                    value=selected_value
                 )
                 
                 category_radio_ranking = gr.Radio(
@@ -2071,7 +2126,8 @@ with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as
                 model_multiselect_rate = gr.CheckboxGroup(
                     choices=models,
                     label="Select one or more models:",
-                    value=models
+                    value=models,
+                    interactive=len(models) > 1
                 )