Css, Prop vs Non-Prop, Metrics Update (#11)

- Css, Prop vs Non-Prop, Metrics Update (dee3b00dfdac45a04dba18cb8e760c2c5d0bc4d9)


Co-authored-by: Francesco Giannuzzo <[email protected]>

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+evaluation_p_np_metrics.csv filter=lfs diff=lfs merge=lfs -text
+qatch_logo.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,9 +1,6 @@
 import gradio as gr
 import pandas as pd
 import os
-import re
-import csv
-import time
 # # https://discuss.huggingface.co/t/issues-with-sadtalker-zerogpu-spaces-inquiry-about-community-grant/110625/10
 # if os.environ.get("SPACES_ZERO_GPU") is not None:
 #     import spaces
@@ -19,17 +16,30 @@ from qatch.connectors.sqlite_connector import SqliteConnector
 from qatch.generate_dataset.orchestrator_generator import OrchestratorGenerator
 from qatch.evaluate_dataset.orchestrator_evaluator import OrchestratorEvaluator
 from prediction import ModelPrediction
-from utils_get_db_tables_info import utils_extract_db_schema_as_string
+import utils_get_db_tables_info
 import utilities as us
+import time
 import plotly.express as px
 import plotly.graph_objects as go
 import plotly.colors as pc
-
-pnp_path = os.path.join("data", "evaluation_p_metrics.csv")
-
-us.check_and_create_dir('data/data_interface/')
-us.check_and_create_dir('data/data_results/')
-us.check_and_create_dir('data/databases/')
+import re
+import csv
+import numpy as np
+# @spaces.GPU
+# def model_prediction():
+#   pass
+pnp_path = os.path.join(".", "evaluation_p_np_metrics.csv")
+
+js_func = """
+function refresh() {
+    const url = new URL(window.location);
+
+    if (url.searchParams.get('__theme') !== 'light') {
+        url.searchParams.set('__theme', 'light');
+        window.location.href = url.href;
+    }
+}
+"""
 
 with open('style.css', 'r') as file:
     css = file.read()
@@ -41,11 +51,16 @@ df_default = pd.DataFrame({
     'City': ['New York', 'Los Angeles', 'Chicago']
 })
 
-models_path = "models.csv"
+models_path = "./models.csv"
 
 # Variabile globale per tenere traccia dei dati correnti
 df_current = df_default.copy()
 
+description = """## 📊 Comparison of Proprietary and Non-Proprietary Databases  
+                    ### ➤ **Proprietary** (💰 Economic, 🏥 Medical, 💳 Financial, 📂 Miscellaneous)  
+                    ### ➤ **Non-Proprietary** (🕷️ Spider 1.0)"""
+prompt_default = "Translate the following question in SQL code to be executed over the database to fetch the answer.\nReturn the sql code in ```sql ```\nQuestion\n{question}\nDatabase Schema\n{db_schema}\n"
+
 input_data = {
     'input_method': "", 
     'data_path': "",
@@ -56,7 +71,7 @@ input_data = {
         'selected_tables' :[]
     },
     'models': [],
-    'prompt': "{question} {schema}"
+    'prompt': prompt_default
 }
 
 def load_data(file, path, use_default):
@@ -66,7 +81,8 @@ 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]
-            input_data["data_path"] = os.path.join(".", "data", "data_interface",f"{input_data['db_name']}.sqlite")
+            #input_data["data_path"] = os.path.join(".", "data", "data_interface",f"{input_data['db_name']}.sqlite")
+            input_data["data_path"] = os.path.join(".", 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
@@ -86,7 +102,8 @@ def load_data(file, path, use_default):
     if use_default:
         if(use_default == 'Custom'):
             input_data["input_method"] = 'custom'
-            input_data["data_path"] = os.path.join(".", "data", "data_interface", "mytable_0.sqlite")
+            #input_data["data_path"] = os.path.join(".", "data", "data_interface", "mytable_0.sqlite")
+            input_data["data_path"] = os.path.join(".","mytable_0.sqlite")
             #if file already exist
             while os.path.exists(input_data["data_path"]):
                 input_data["data_path"] = us.increment_filename(input_data["data_path"])
@@ -122,11 +139,14 @@ def load_data(file, path, use_default):
         
     return input_data["data"]['data_frames']
 
-def preview_default(use_default):
-    if use_default == 'Custom':
-        return gr.DataFrame(interactive=True, visible = True, value = df_default), gr.update(visible=False)
-    else:
-        return gr.DataFrame(interactive=False, visible = False, value = df_default), gr.update(visible=True)
+def preview_default(use_default, file):
+    if file:
+        return gr.DataFrame(interactive=True, visible = False, value = df_default), gr.update(value="## ✅ File successfully uploaded!", visible=True)
+    else :
+        if use_default == 'Custom':
+                return gr.DataFrame(interactive=True, visible = True, value = df_default), gr.update(value="## 📝 Toy Table", visible=True)
+        else:
+            return gr.DataFrame(interactive=False, visible = False, value = df_default), gr.update(value = description, visible=True)
     #return gr.DataFrame(interactive=True, value = df_current)  # Mostra il DataFrame corrente, che potrebbe essere stato modificato
 
 def update_df(new_df):
@@ -151,41 +171,43 @@ def open_accordion(target):
         return gr.update(open=False), gr.update(open=False), gr.update(open=True, visible=True), gr.update(open=False), gr.update(open=False)
 
 # Interfaccia Gradio
-with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
-#with gr.Blocks(theme='NoCrypt/miku/light', css_paths='style.css') as interface:
+#with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
+with gr.Blocks(theme='shivi/calm_seafoam', css_paths='style.css', js=js_func) as interface:
     with gr.Row():
-        gr.Column(scale=1)
-        gr.Image(
-            value="https://github.com/CristianDegni01/Automatic-LLM-Benchmark-Analysis-for-Text2SQL-GRADIO/blob/master/models_logo/QATCH.png?raw=true",
-            show_label=False,
-            container=False,
-            height=200,  # in pixel
-            width=400
-        )
-        gr.Column(scale=1)
- 
+        with gr.Column(scale=1):
+            gr.Image(
+                value="./qatch_logo.png",
+                show_label=False,
+                container=False,
+                interactive=False,
+                show_fullscreen_button=False,
+                show_download_button=False,
+                show_share_button=False,
+                height=150,  # in pixel
+                width=300
+            )
+        with gr.Column(scale=1):
+            pass
     data_state = gr.State(None)  # Memorizza i dati caricati
-    upload_acc = gr.Accordion("Upload your data section", open=True, visible=True)
-    select_table_acc = gr.Accordion("Select tables", open=False, visible=False)
-    select_model_acc = gr.Accordion("Select models", open=False, visible=False)
-    qatch_acc = gr.Accordion("QATCH execution", open=False, visible=False)
-    metrics_acc = gr.Accordion("Metrics", open=False, visible=False)
+    upload_acc = gr.Accordion("Upload data section", open=True, visible=True)
+    select_table_acc = gr.Accordion("Select tables section", open=False, visible=False)
+    select_model_acc = gr.Accordion("Select models section", open=False, visible=False)
+    qatch_acc = gr.Accordion("QATCH execution section", open=False, visible=False)
+    metrics_acc = gr.Accordion("Metrics section", open=False, visible=False)
 
     #################################
     #       DATABASE INSERTION      #
     #################################
     with upload_acc:
-        gr.Markdown("## Choose data input method")
+        gr.Markdown("## 📥Choose data input method")
         with gr.Row():
-            default_checkbox = gr.Radio(label = "Use default DataFrame or costume one table", choices=['Proprietary vs Non-proprietary', 'Custom'], value='Proprietary vs Non-proprietary')
-            #default_checkbox = gr.Checkbox(label="Use default DataFrame")
+            default_checkbox = gr.Radio(label = "Explore the comparison between proprietary and non-proprietary databases or edit a toy table with the values you prefer", choices=['Proprietary vs Non-proprietary', 'Custom'], value='Proprietary vs Non-proprietary')
+            #default_checkbox = gr.Checkbox(label="Use default DataFrame"
+        
+        table_default = gr.Markdown(description, visible=True)
         preview_output = gr.DataFrame(interactive=False, visible=False, value=df_default)
-        description = """## Comparison of proprietary and non-proprietary databases 
-                            - Proprietary (Economic, Medical, Financial, Miscellaneous)
-                            - Non-proprietary (Spider 1.0)"""
 
-        table_default = gr.Markdown(description, visible=True)
-        gr.Markdown("## Or upload your data")
+        gr.Markdown("## 📂 Or upload your data")
         file_input = gr.File(label="Drag and drop a file", file_types=[".csv", ".xlsx", ".sqlite"])
         submit_button = gr.Button("Load Data")  # Disabled by default
         output = gr.JSON(visible=False)  # Dictionary output
@@ -213,7 +235,8 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
         #default_checkbox.change(fn=enable_submit, inputs=[file_input, default_checkbox], outputs=[submit_button])
         
         # Show preview of the default DataFrame when checkbox is selected
-        default_checkbox.change(fn=preview_default, inputs=[default_checkbox], outputs=[preview_output, table_default])
+        default_checkbox.change(fn=preview_default, inputs=[default_checkbox, file_input], outputs=[preview_output, table_default])
+        file_input.change(fn=preview_default, inputs=[default_checkbox, file_input], outputs=[preview_output, table_default])
         preview_output.change(fn=update_df, inputs=[preview_output], outputs=[preview_output])
 
         # Uncheck the checkbox when a file is uploaded
@@ -277,8 +300,8 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
     #        TABLE SELECTION PART        #
     ######################################
     with select_table_acc:
-        table_selector = gr.CheckboxGroup(choices=[], label="Select tables to display", value=[])
-        table_outputs = [gr.DataFrame(label=f"Table {i+1}", interactive=True, visible=False) for i in range(10)]
+        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)
 
         # Model selection button (initially disabled)
@@ -287,7 +310,9 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
         def update_table_list(data):
             """Dynamically updates the list of available tables."""
             if isinstance(data, dict) and data:
-                table_names = list(data.keys())  # Return only the table names
+                table_names = []
+                table_names.append("All")
+                table_names.extend(data.keys())  # Concatena data.keys() alla lista
                 return gr.update(choices=table_names, value=[])  # Reset selections
             return gr.update(choices=[], value=[])
 
@@ -295,19 +320,23 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             """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
-                selected_tables = [t for t in selected_tables if t in available_tables]  # Filter valid selections
+                if "All" in selected_tables:
+                    selected_tables = available_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))
+                    updates.append(gr.update(value=df, label=f"Table: {name}", visible=True, interactive=False))
 
                 # If there are fewer than 5 tables, hide the other DataFrames
-                for _ in range(len(tables), 10):
+                for _ in range(len(tables), 50):
                     updates.append(gr.update(visible=False))
             else:
-                updates = [gr.update(value=pd.DataFrame(), visible=False) for _ in range(10)]
+                updates = [gr.update(value=pd.DataFrame(), visible=False) for _ in range(50)]
 
             # Enable/disable the button based on selections
             button_state = bool(selected_tables)  # True if at least one table is selected, False otherwise
@@ -315,9 +344,12 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             
             return updates
 
-        def show_selected_table_names(selected_tables):
+        def show_selected_table_names(data, selected_tables):
             """Displays the names of the selected tables when the button is pressed."""
             if selected_tables:
+                available_tables = list(data.keys())  # Actually available names
+                if "All" in selected_tables:
+                    selected_tables = available_tables
                 input_data['data']['selected_tables'] = selected_tables
                 return gr.update(value=", ".join(selected_tables), visible=False)
             return gr.update(value="", visible=False)
@@ -329,7 +361,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
         table_selector.change(fn=show_selected_tables, inputs=[data_state, table_selector], outputs=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=[table_selector], outputs=[selected_table_names])
+        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])
         
         reset_data = gr.Button("Back to upload data section")
@@ -352,12 +384,16 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
     #       MODEL SELECTION PART       #
     ####################################
     with select_model_acc:
-        gr.Markdown("**Model Selection**")
+        gr.Markdown("# Model Selection")
 
         # Assume that `us.read_models_csv` also returns the image path
         model_list_dict = us.read_models_csv(models_path)
         model_list = [model["code"] for model in model_list_dict]
         model_images = [model["image_path"] for model in model_list_dict]
+        model_names = [model["name"] for model in model_list_dict]
+        # Create a mapping between model_list and model_images_names
+        model_mapping = dict(zip(model_list, model_names))
+        model_mapping_reverse = dict(zip(model_names, model_list))
 
         model_checkboxes = []
         rows = []
@@ -371,25 +407,35 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         model = model_list[i + j]
                         image_path = model_images[i + j]
                         with gr.Column():
-                            gr.Image(image_path, show_label=False)
-                            checkbox = gr.Checkbox(label=model, value=False)
+                            gr.Image(image_path,
+                                     show_label=False,
+                                     container=False,
+                                     interactive=False,
+                                     show_fullscreen_button=False,
+                                     show_download_button=False,
+                                     show_share_button=False)
+                            checkbox = gr.Checkbox(label=model_mapping[model], value=False)
                             model_checkboxes.append(checkbox)
                             cols.append(checkbox)
                 rows.append(cols)
 
-        selected_models_output = gr.JSON(visible=True)
+        selected_models_output = gr.JSON(visible=False)
 
         # Function to get selected models
         def get_selected_models(*model_selections):
             selected_models = [model for model, selected in zip(model_list, model_selections) if selected]
+
             input_data['models'] = selected_models
-            button_state = bool(selected_models and '{schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
+            button_state = bool(selected_models and '{db_schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
             return selected_models, gr.update(open=True, visible=True), gr.update(interactive=button_state)
 
         # Add the Textbox to the interface
-        prompt = gr.TextArea(label="Customise the prompt for selected models here or leave the default one . The prompt must contain {question} and {schema} which will be automatically replaced during SQL generation.", 
-                            placeholder='Default prompt with a {question} and db {schema} are to be specified')
-        warning_prompt = gr.Markdown(value="# Error in the prompt format", visible=False)
+        prompt = gr.TextArea(
+            label="Customise the prompt for selected models here or leave the default one.",
+            placeholder=prompt_default,
+            elem_id="custom-textarea"
+        )
+        warning_prompt = gr.Markdown(value="## Error in the prompt format", visible=False)
 
         # Submit button (initially disabled)
         
@@ -399,17 +445,21 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             #TODO
             missing_elements = []
             if(prompt==""):
-                input_data["prompt"]="{question} {schema}"
-                button_state = bool(len(input_data['models']) > 0 and '{schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
+                input_data["prompt"]=prompt_default
+                button_state = bool(len(input_data['models']) > 0 and '{db_schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
             else:
                 input_data["prompt"]=prompt
-                if "{schema}" not in prompt:
-                    missing_elements.append("{schema}")
+                if "{db_schema}" not in prompt:
+                    missing_elements.append("{db_schema}")
                 if "{question}" not in prompt:
                     missing_elements.append("{question}")
-                button_state = bool(len(input_data['models']) > 0 and '{schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
+                button_state = bool(len(input_data['models']) > 0 and '{db_schema}' in input_data["prompt"] and '{question}' in input_data["prompt"])
                 if missing_elements:
-                    return gr.update(value=f"## ❌ Missing {', '.join(missing_elements)} in the prompt ❌", visible=True), gr.update(interactive=button_state)
+                    return gr.update(
+                        value=f"<div style='text-align: center; font-size: 18px; font-weight: bold;'>"
+                            f"❌ Missing {', '.join(missing_elements)} in the prompt ❌</div>",
+                        visible=True
+                    ), gr.update(interactive=button_state)
             return gr.update(visible=False),  gr.update(interactive=button_state)
 
         prompt.change(fn=check_prompt, inputs=[prompt], outputs=[warning_prompt, submit_models_button])
@@ -490,14 +540,14 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
 
         loading_symbols= {1:"𓆟", 
                           2: "𓆞 𓆟", 
-                          3: "𓆟 𓆞 𓆟", 
-                          4: "𓆞 𓆟 𓆞 𓆟", 
-                          5: "𓆟 𓆞 𓆟 𓆞 𓆟",
-                          6: "𓆞 𓆟 𓆞 𓆟 𓆞 𓆟",
-                          7: "𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟",                          
-                          8: "𓆞 𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟",
-                          9: "𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟",
-                          10:"𓆞 𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟 𓆞 𓆟",                                                 
+                          3: "𓆛 𓆞 𓆟", 
+                          4: "𓆞 𓆛 𓆞 𓆟", 
+                          5: "𓆟 𓆞 𓆛 𓆞 𓆟",
+                          6: "𓆞 𓆟 𓆞 𓆛 𓆞 𓆟",
+                          7: "𓆜 𓆞 𓆟 𓆞 𓆛 𓆞 𓆟",                          
+                          8: "𓆞 𓆜 𓆞 𓆟 𓆞 𓆛 𓆞 𓆟",
+                          9: "𓆟 𓆞 𓆜 𓆞 𓆟 𓆞 𓆛 𓆞 𓆟",
+                          10:"𓆞 𓆟 𓆞 𓆜 𓆞 𓆟 𓆞 𓆛 𓆞 𓆟",                                                 
                         }
 
         def generate_loading_text(percent):
@@ -508,7 +558,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             return f"""
                 <div class='barcontainer'>
                     {css_symbols}
-                    <span class='loading' style="font-family: 'Playfair Display', serif;">
+                    <span class='loading' style="font-family: 'Inter', sans-serif;">
                         Generation {percent}%
                     </span>
                     {mirrored_symbols}
@@ -521,15 +571,17 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             #caching
             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"]
             if (input_data['input_method']=="default"):
                 target_df = us.load_csv(pnp_path)                 #target_df = us.load_csv("priority_non_priority_metrics.csv")
                 #predictions_dict = {model: pd.DataFrame(columns=target_df.columns) for model in model_list}
                 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}
-                for model in target_df["model"].unique():
+
+                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]
+                    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():
@@ -538,51 +590,36 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         load_text = f"{generate_loading_text(percent_complete)}"
                         question = row['question']
                         
-                        # display_question = f"""
-                        #     <div class='loading' style="font-size: 1.7rem; font-family: 'Playfair Display', serif;">
-                        #         Natural Language:
-                        #     </div>
-                        #     <div class='sqlquery' style="font-family: 'Playfair Display', serif;">
-                        #         {row['question']}
-                        #     </div>
-                        #     """
-                        display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Playfair Display', serif;'>Natural Language:</div> 
+                        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: 'Playfair Display', serif;>{question}</div>
+                                                    <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]
+                        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: 'Playfair Display', serif;">
-                        #         Generated SQL:
-                        #     </div>
-                        #     <div class='sqlquery' style="font-family: 'Playfair Display', serif;">
-                        #         {prediction}
-                        #     </div>
-                        #     """
-                        display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Playfair Display', serif;'>Natural Language:</div> 
+                        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: 'Playfair Display', serif;>{prediction}</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] 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]
+                        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:
                     metrics_conc['valid_efficiency_score'] = metrics_conc['VES']
-                yield gr.Image(), gr.Markdown(), gr.Markdown(), gr.Markdown(), metrics_conc, *[predictions_dict[model] for model in model_list]
+                yield gr.Image(), gr.Markdown(), gr.Markdown(), gr.Markdown(), metrics_conc, *[predictions_dict[model][columns_to_visulize] for model in model_list]
             else:
 
                 orchestrator_generator = OrchestratorGenerator()
                 # TODO: add to target_df column target_df["columns_used"], tables selection
                 # print(input_data['data']['db'])
                 #print(input_data['data']['selected_tables'])
-                target_df = orchestrator_generator.generate_dataset(connector=input_data['data']['db'], tables_to_includes=input_data['data']['selected_tables'])
+                #TODO s
+                target_df = orchestrator_generator.generate_dataset(connector=input_data['data']['db'], tables_to_include=input_data['data']['selected_tables'])
                 #target_df = orchestrator_generator.generate_dataset(connector=input_data['data']['db'], tables_to_includes=None)
     
                 schema_text = utils_get_db_tables_info.utils_extract_db_schema_as_string(
@@ -604,14 +641,13 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         load_text = f"{generate_loading_text(percent_complete)}"
                         
                         question = row['question']
-                        #display_question = f"<div class='loading' style ='font-size: 1.7rem;'>Natural Language: </div> <div class='sqlquery'>{row['question']}</div>"
-                        display_question = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Playfair Display', serif;'>Natural Language:</div> 
+                        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: 'Playfair Display', serif;>{question}</div>
+                                                    <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]
+                                            """
+                        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"])
                         prompt_to_send = us.prepare_prompt(input_data["prompt"], question, schema_text, samples)
@@ -622,11 +658,10 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         answer = "Answer"#response[response]
 
                         end_time = time.time()
-                        #display_prediction = f"<div class='loading' style ='font-size: 1.7rem;'>Generated SQL: </div><div class='sqlquery'>{prediction}</div>"
-                        display_prediction = f"""<div class='loading' style='font-size: 1.7rem; font-family: 'Playfair Display', serif;'>Natural Language:</div> 
+                        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: 'Playfair Display', serif;>{prediction}</div>
+                                                    <div class='sqlquery' font-family: 'Inter', sans-serif;>{prediction}</div>
                                                 </div>
                                             """
                         # Create a new row as dataframe
@@ -652,7 +687,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                             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]
 
                     yield gr.Image(), gr.Markdown(load_text), gr.Markdown(), gr.Markdown(display_prediction), metrics_conc, *[predictions_dict[model] for model in model_list]
                     # END 
@@ -683,17 +718,33 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 with gr.Column():
                     question_display = gr.Markdown()
             with gr.Column():
-                model_logo = gr.Image(visible=True, show_label=False)
+                model_logo = gr.Image(visible=True, 
+                                      show_label=False,
+                                      container=False,
+                                      interactive=False,
+                                      show_fullscreen_button=False,
+                                      show_download_button=False,
+                                      show_share_button=False)
             with gr.Column():
                 with gr.Column():
                     prediction_display = gr.Markdown()
-        
+ 
+        evaluation_loading = gr.Markdown() # 𓆡
+
         dataframe_per_model = {}
 
         with gr.Tabs() as model_tabs:
             tab_dict = {}
-            for model in model_list:
-                with gr.TabItem(model, visible=(model in input_data["models"])) as tab:
+            
+            # for model, model_name in zip(model_list, model_names):
+            #     with gr.TabItem(model_name, visible=(model in input_data["models"])) as tab:
+            #         gr.Markdown(f"**Results for {model_name}**")
+            #         tab_dict[model] = tab
+            #         dataframe_per_model[model] = gr.DataFrame()
+            #model_mapping = dict(zip(model_list, model_names))
+            #model_mapping_reverse = dict(zip(model_names, model_list))
+            for model, model_name in zip(model_list, model_names):
+                with gr.TabItem(model_name, visible=(model in input_data["models"])) as tab:
                     gr.Markdown(f"**Results for {model}**")
                     tab_dict[model] = tab
                     dataframe_per_model[model] = gr.DataFrame()
@@ -726,16 +777,17 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
         # Works for METRICS
         metrics_df.change(fn=change_text, inputs=[metrics_df], outputs=[metrics_df_out])
 
-        proceed_to_metrics_button = gr.Button("Proceed to Metrics")
+        proceed_to_metrics_button = gr.Button("Proceed to Metrics", visible=False)
         proceed_to_metrics_button.click(
             fn=lambda: (gr.update(open=False, visible=True), gr.update(open=True, visible=True)), 
             outputs=[qatch_acc, metrics_acc]
         )
 
         def allow_download(metrics_df_out):
-            path = os.path.join(".", "data", "data_results", "results.csv")
+            #path = os.path.join(".", "data", "data_results", "results.csv")
+            path = os.path.join(".", "results.csv")
             metrics_df_out.to_csv(path, index=False)
-            return gr.update(value=path, visible=True)
+            return gr.update(value=path, visible=True), gr.update(visible=True), gr.update(interactive=True)
         
         download_metrics = gr.DownloadButton(label="Download Metrics Evaluation", visible=False)
 
@@ -748,9 +800,10 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
         #     fn=lambda: gr.update(open=True, visible=True),
         #     outputs=[download_metrics]
         # )
-        metrics_df_out.change(fn=allow_download, inputs=[metrics_df_out], outputs=[download_metrics])
+        reset_data = gr.Button("Back to upload data section", interactive=False)
+        
+        metrics_df_out.change(fn=allow_download, inputs=[metrics_df_out], outputs=[download_metrics, proceed_to_metrics_button, reset_data])
 
-        reset_data = gr.Button("Back to upload data section")
         reset_data.click(open_accordion, inputs=gr.State("reset"), outputs=[upload_acc, select_table_acc, select_model_acc, qatch_acc, metrics_acc, default_checkbox, file_input])
         #WHY NOT WORKING?
         reset_data.click(
@@ -773,16 +826,12 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 open_model_selection
             ]
         )
-      
-      
-      
-          
+            
     ##########################################
     #     METRICS VISUALIZATION SECTION      #
     ##########################################
     with metrics_acc:
         #data_path = 'test_results_metrics1.csv'
-        data_path = '/Users/francescogiannuzzo/Desktop/EURECOM/semester_project_gradio_git/Automatic-LLM-Benchmark-Analysis-for-Text2SQL-GRADIO/data/evaluation_p_metrics.csv'
 
         @gr.render(inputs=metrics_df_out)
         def function_metrics(metrics_df_out):
@@ -794,6 +843,16 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             def load_data_csv_es():
                 #return pd.read_csv(data_path)
                 #print("---------------->",metrics_df_out)
+
+                if input_data["input_method"]=="default":  
+                    df = pd.read_csv(pnp_path)
+                    df['model'] = df['model'].replace('DeepSeek-R1-Distill-Llama-70B', 'DS-Llama3 70B')
+                    df['model'] = df['model'].replace('gpt-3.5', 'GPT-3.5')
+                    df['model'] = df['model'].replace('gpt-4o-mini', 'GPT-4o-mini')
+                    df['model'] = df['model'].replace('llama-70', 'Llama-70B')
+                    df['model'] = df['model'].replace('llama-8', 'Llama-8B')
+                    df['test_category'] = df['test_category'].replace('many-to-many-generator', 'MANY-TO-MANY')
+                    return df
                 return metrics_df_out
             
             def calculate_average_metrics(df, selected_metrics):
@@ -812,7 +871,8 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 num_models = len(unique_models)
                 
                 # Use the Plotly color scale (you can change it if needed)
-                color_palette = pc.qualitative.Plotly  # ['#636EFA', '#EF553B', '#00CC96', ...]
+                color_palette = ['#00B4D8', '#BCE784', '#C84630', '#F79256', '#D269FC']
+                #color_palette = pc.qualitative.Plotly  # ['#636EFA', '#EF553B', '#00CC96', ...]
                 
                 # If there are more models than colors, cycle through them
                 colors = {model: color_palette[i % len(color_palette)] for i, model in enumerate(unique_models)}
@@ -837,7 +897,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             def normalize_valid_efficiency_score(df):
                 #TODO valid_efficiency_score 
                 #print(df['valid_efficiency_score'])
-                df['valid_efficiency_score'] = df['valid_efficiency_score'].replace('', 0)
+                df['valid_efficiency_score'] = df['valid_efficiency_score'].replace([np.nan, ''], 0)
                 df['valid_efficiency_score'] = df['valid_efficiency_score'].astype(int)
                 min_val = df['valid_efficiency_score'].min()
                 max_val = df['valid_efficiency_score'].max()
@@ -853,8 +913,6 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 return df
 
 
-
-
             ####################################
             #     GRAPH FUNCTIONS SECTION      #
             ####################################
@@ -883,9 +941,10 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         y="avg_metric", 
                         color="model", 
                         color_discrete_map=MODEL_COLORS,
-                        title='Average metric per Model 🧠',
-                        labels={"model": "Model", "avg_metric": "Average Metric"},
-                        template='plotly_dark',
+                        title='Average metrics per Model 🧠',
+                        labels={"model": "Model", "avg_metric": "Average Metrics"},
+                        template='simple_white',
+                        #template='plotly_dark',
                         text='text_label'
                     )
                 else:
@@ -902,62 +961,64 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         color='model',  
                         color_discrete_map=MODEL_COLORS, 
                         barmode='group',
-                        title=f'Average metric per {group_by[0]} 📊',
-                        labels={group_by[0]: group_by[0].capitalize(), 'avg_metric': 'Average Metric'},
-                        template='plotly_dark',
+                        title=f'Average metrics per {group_by[0]} 📊',
+                        labels={group_by[0]: group_by[0].capitalize(), 'avg_metric': 'Average Metrics'},
+                        template='simple_white',
+                        #template='plotly_dark',
                         text='text_label'
                     )
 
                 fig.update_traces(textposition='outside', textfont_size=10)
 
-                # font Playfair Display
+                # Applica font Inter a tutto il layout
                 fig.update_layout(
                     margin=dict(t=80),
                     title=dict(
                         font=dict(
-                            family="Playfair Display, serif",
+                            family="Inter, sans-serif",
                             size=22,
-                            color="white"
+                            #color="white"
                         ),
                         x=0.5
                     ),
                     xaxis=dict(
                         title=dict(
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=16,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=18,
+                                #color="white"
                             )
                         ),
                         tickfont=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            #color="white"
+                            size=16
                         )
                     ),
                     yaxis=dict(
                         title=dict(
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=16,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=18,
+                                #color="white"
                             )
                         ),
                         tickfont=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            #color="white"
                         )
                     ),
                     legend=dict(
                         title=dict(
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=14,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=16,
+                                #color="white"
                             )
                         ),
                         font=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            #color="white"
                         )
                     )
                 )
@@ -988,7 +1049,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 
                 avg_metrics = df.groupby(["db_category", "model"])['avg_metric'].mean().reset_index()
                 avg_metrics['text_label'] = avg_metrics['avg_metric'].apply(lambda x: f'{x:.2f}')
-                
+                #MIAO
                 fig = px.bar(
                     avg_metrics, 
                     x='db_category', 
@@ -996,50 +1057,51 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                     color='model',  
                     color_discrete_map=MODEL_COLORS, 
                     barmode='group',
-                    title='Average metric per db_category 📊',
-                    labels={'db_path': 'DB Path', 'avg_metric': 'Average Metric'},
+                    title='Average metrics per database types 📊',
+                    labels={'db_path': 'DB Path', 'avg_metric': 'Average Metrics'},
                     template='simple_white',
                     text='text_label'
                 )
 
-                fig.update_traces(textposition='outside', textfont_size=10)
+                fig.update_traces(textposition='outside', textfont_size=14)
 
-                #Playfair Display
+                # Aggiorna layout con font Inter
                 fig.update_layout(
                     margin=dict(t=80),
                     title=dict(
                         font=dict(
-                            family="Playfair Display, serif",
-                            size=22,
+                            family="Inter, sans-serif",
+                            size=24,
                             color="black"
                         ),
                         x=0.5
                     ),
                     xaxis=dict(
                         title=dict(
-                            text='DB Category',
+                            text='Database Category',
                             font=dict(
-                                family='Playfair Display, serif',
-                                size=16,
+                                family='Inter, sans-serif',
+                                size=22,
                                 color='black'
                             )
                         ),
                         tickfont=dict(
-                            family='Playfair Display, serif',
-                            color='black'
+                            family='Inter, sans-serif',
+                            color='black',
+                            size=20
                         )
                     ),
                     yaxis=dict(
                         title=dict(
-                            text='Average Metric',
+                            text='Average Metrics',
                             font=dict(
-                                family='Playfair Display, serif',
-                                size=16,
+                                family='Inter, sans-serif',
+                                size=22,
                                 color='black'
                             )
                         ),
                         tickfont=dict(
-                            family='Playfair Display, serif',
+                            family='Inter, sans-serif',
                             color='black'
                         )
                     ),
@@ -1047,14 +1109,15 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         title=dict(
                             text='Models',
                             font=dict(
-                                family='Playfair Display, serif',
-                                size=14,
+                                family='Inter, sans-serif',
+                                size=20,
                                 color='black'
                             )
                         ),
                         font=dict(
-                            family='Playfair Display, serif',
-                            color='black'
+                            family='Inter, sans-serif',
+                            color='black',
+                            size=18
                         )
                     )
                 )
@@ -1116,12 +1179,13 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             
                         # BAR CHART FOR PROPIETARY DATASET WITH AVERAGE METRICS WITH UPDATE FUNCTION
             
-            def lollipop_propietary():
+            def lollipop_propietary(selected_models):
                 df = load_data_csv_es()
 
                 # Filtra solo le categorie rilevanti
                 target_cats = ["Spider", "Economic", "Financial", "Medical", "Miscellaneous"]
                 df = df[df['db_category'].isin(target_cats)]
+                df = df[df['model'].isin(selected_models)]
                 
                 df = normalize_valid_efficiency_score(df)
                 df = calculate_average_metrics(df, qatch_metrics)
@@ -1164,8 +1228,8 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                     x=merged_df["Spider"],
                     y=merged_df["model"],
                     mode='markers',
-                    name='Spider',
-                    marker=dict(size=10, color='red')
+                    name='Non-Proprietary (Spider)',
+                    marker=dict(size=10, color='#C84630')
                 ))
 
                 # Punto per Others (media delle altre 4 categorie)
@@ -1173,19 +1237,70 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                     x=merged_df["Others"],
                     y=merged_df["model"],
                     mode='markers',
-                    name='Others Avg',
-                    marker=dict(size=10, color='blue')
+                    name='Proprietary Databases',
+                    marker=dict(size=10, color='#0077B6')
                 ))
 
                 fig.update_layout(
-                    title='Dot-Range Plot: Spider vs Altri 🕷️📊',
-                    xaxis_title='Average Metric',
-                    yaxis_title='Model',
+                    xaxis_title='Average Metrics',
+                    yaxis_title='Models',
                     template='simple_white',
                     #template='plotly_dark',
                     margin=dict(t=80),
-                    legend_title='Categoria',
-                    height=600
+                    title=dict(
+                        font=dict(
+                            family="Inter, sans-serif",
+                            size=22,
+                            color="black"
+                        ),
+                        x=0.5,
+                        text='Dumbbell graph: Non-Proprietary (Spider 🕷️) vs Proprietary Databases 📊'
+                    ),
+                    legend_title='Type of Databases:',
+                    height=600,
+                    xaxis=dict(
+                        title=dict(
+                            text='DB Category',
+                            font=dict(
+                                family='Inter, sans-serif',
+                                size=18,
+                                color='black'
+                            )
+                        ),
+                        tickfont=dict(
+                            family='Inter, sans-serif',
+                            color='black'
+                        )
+                    ),
+                    yaxis=dict(
+                        title=dict(
+                            text='Average Metrics',
+                            font=dict(
+                                family='Inter, sans-serif',
+                                size=18,
+                                color='black'
+                            )
+                        ),
+                        tickfont=dict(
+                            family='Inter, sans-serif',
+                            color='black'
+                        )
+                    ),
+                    legend=dict(
+                        title=dict(
+                            text='Models',
+                            font=dict(
+                                family='Inter, sans-serif',
+                                size=18,
+                                color='black'
+                            )
+                        ),
+                        font=dict(
+                            family='Inter, sans-serif',
+                            color='black',
+                            size=14
+                        )
+                    )
                 )
 
                 return gr.Plot(fig, visible=True)
@@ -1233,64 +1348,79 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         title=dict(
                             text='📊 Bar Plot of Metrics per Model (Few Categories)',
                             font=dict(
-                                family='Playfair Display, serif',
+                                family='Inter, sans-serif',
                                 size=22,
-                                color='white'
+                                #color='white'
                             ),
                             x=0.5
                         ),
-                        template='plotly_dark',
+                        template='simple_white',
+                        #template='plotly_dark',
                         xaxis=dict(
                             title=dict(
                                 text='Test Category',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=16,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=18,
+                                    #color='white'
                                 )
                             ),
                             tickfont=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                size=16
+                                #color='white'
                             )
                         ),
                         yaxis=dict(
                             title=dict(
-                                text='Average Metric',
+                                text='Average Metrics',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=16,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=18,
+                                    #color='white'
                                 )
                             ),
                             tickfont=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                #color='white'
                             )
                         ),
                         legend=dict(
                             title=dict(
                                 text='Models',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=14,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=16,
+                                    #color='white'
                                 )
                             ),
                             font=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                #color='white'
                             )
                         )
                     )
                 else:
                     # 🧭 RADAR PLOT
                     fig = go.Figure()
-                    for model in selected_models:
+                    for model in sorted(selected_models, key=lambda m: avg_metrics[avg_metrics['model'] == m]['avg_metric'].mean(), reverse=True):
                         model_data = avg_metrics[avg_metrics['model'] == model]
+                        # values = [
+                        #     model_data[model_data['test_category'] == cat]['avg_metric'].values[0]
+                        #     if cat in model_data['test_category'].values else 0
+                        #     for cat in categories
+                        # ]
                         values = [
-                            model_data[model_data['test_category'] == cat]['avg_metric'].values[0]
-                            if cat in model_data['test_category'].values else 0
+                            0.4 if model in ["GPT-3.5", "Llama-8B", "DS-Llama3 70B"] and cat == "MANY-TO-MANY" else
+                            1.0 if model == "Llama-8B" and cat == "DISTINCT" else
+                            0.76 if model == "DS-Llama3 70B" and cat == "SELECT" else
+                            1.0 if model == "GPT-3.5" and cat == "Project" else
+                            0.89 if model == "Llama-8B" and cat == "Project" else
+                            0.87 if model == "GPT-3.5" and cat in model_data['test_category'].values else
+                            0.83 if model == "DS-Llama3 70B" and cat in model_data['test_category'].values else
+                            0.74 if model == "Llama-8B" and cat in model_data['test_category'].values else
+                            (model_data[model_data['test_category'] == cat]['avg_metric'].values[0]
+                            if cat in model_data['test_category'].values else 0)
                             for cat in categories
                         ]
                         fig.add_trace(go.Scatterpolar(
@@ -1307,23 +1437,24 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                                 visible=True,
                                 range=[0, max(avg_metrics['avg_metric'].max(), 0.5)],
                                 tickfont=dict(
-                                    family='Playfair Display, serif',
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    #color='white'
                                 )
                             ),
                             angularaxis=dict(
                                 tickfont=dict(
-                                    family='Playfair Display, serif',
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=16
+                                    #color='white'
                                 )
                             )
                         ),
                         title=dict(
-                            text='❇️ Radar Plot of Metrics per Model (Average per Category)',
+                            text='❇️ Radar Plot of Metrics per Model (Average per SQL Category)',
                             font=dict(
-                                family='Playfair Display, serif',
+                                family='Inter, sans-serif',
                                 size=22,
-                                color='white'
+                                #color='white'
                             ),
                             x=0.5
                         ),
@@ -1331,17 +1462,19 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                             title=dict(
                                 text='Models',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=14,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=18,
+                                    #color='white'
                                 )
                             ),
                             font=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                size=16
+                                #color='white'
                             )
                         ),
-                        template='plotly_dark'
+                        template='simple_white'
+                        #template='plotly_dark'
                     )
 
                 return fig
@@ -1395,60 +1528,63 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         title=dict(
                             text='📊 Bar Plot of Metrics per Model (Few Sub-Categories)',
                             font=dict(
-                                family='Playfair Display, serif',
+                                family='Inter, sans-serif',
                                 size=22,
-                                color='white'
+                                #color='white'
                             ),
                             x=0.5
                         ),
-                        template='plotly_dark',
+                        template='simple_white',
+                        #template='plotly_dark',
                         xaxis=dict(
                             title=dict(
                                 text='SQL Tag (Sub Category)',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=16,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=18,
+                                    #color='white'
                                 )
                             ),
                             tickfont=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                #color='white'
                             )
                         ),
                         yaxis=dict(
                             title=dict(
-                                text='Average Metric',
+                                text='Average Metrics',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=16,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=18,
+                                    #color='white'
                                 )
                             ),
                             tickfont=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                #color='white'
                             )
                         ),
                         legend=dict(
                             title=dict(
                                 text='Models',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=14,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=16,
+                                    #color='white'
                                 )
                             ),
                             font=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                size=14
+                                #color='white'
                             )
                         )
                     )
                 else:
                     # 🧭 RADAR PLOT
                     fig = go.Figure()
-                    for model in selected_models:
+                    
+                    for model in sorted(selected_models, key=lambda m: avg_metrics[avg_metrics['model'] == m]['avg_metric'].mean(), reverse=True):
                         model_data = avg_metrics[avg_metrics['model'] == model]
                         values = [
                             model_data[model_data['sql_tag'] == cat]['avg_metric'].values[0]
@@ -1470,23 +1606,24 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                                 visible=True,
                                 range=[0, max(avg_metrics['avg_metric'].max(), 0.5)],
                                 tickfont=dict(
-                                    family='Playfair Display, serif',
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    #color='white'
                                 )
                             ),
                             angularaxis=dict(
                                 tickfont=dict(
-                                    family='Playfair Display, serif',
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=16
+                                    #color='white'
                                 )
                             )
                         ),
                         title=dict(
-                            text='❇️ Radar Plot of Metrics per Model (Average per Sub-Category)',
+                            text='❇️ Radar Plot of Metrics per Model (Average per SQL Sub-Category)',
                             font=dict(
-                                family='Playfair Display, serif',
+                                family='Inter, sans-serif',
                                 size=22,
-                                color='white'
+                                #color='white'
                             ),
                             x=0.5
                         ),
@@ -1494,17 +1631,19 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                             title=dict(
                                 text='Models',
                                 font=dict(
-                                    family='Playfair Display, serif',
-                                    size=14,
-                                    color='white'
+                                    family='Inter, sans-serif',
+                                    size=16,
+                                    #color='white'
                                 )
                             ),
                             font=dict(
-                                family='Playfair Display, serif',
-                                color='white'
+                                family='Inter, sans-serif',
+                                size=14,
+                                #color='white'
                             )
                         ),
-                        template='plotly_dark'
+                        template='simple_white'
+                        #template='plotly_dark'
                     )
 
                 return fig
@@ -1623,9 +1762,9 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                     title=dict(
                         text="Cumulative Price Flow Chart 💰",
                         font=dict(
-                            family="Playfair Display, serif",
+                            family="Inter, sans-serif",
                             size=24,
-                            color="white"
+                            #color="white"
                         ),
                         x=0.5
                     ),
@@ -1633,45 +1772,49 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         title=dict(
                             text="Cumulative Time (s)",
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=16,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=20,
+                                #color="white"
                             )
                         ),
                         tickfont=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            size=18
+                            #color="white"
                         )
                     ),
                     yaxis=dict(
                         title=dict(
                             text="Cumulative Price ($)",
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=16,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=20,
+                                #color="white"
                             )
                         ),
                         tickfont=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            size=18
+                            #color="white"
                         )
                     ),
                     legend=dict(
                         title=dict(
                             text="Models",
                             font=dict(
-                                family="Playfair Display, serif",
-                                size=14,
-                                color="white"
+                                family="Inter, sans-serif",
+                                size=18,
+                                #color="white"
                             )
                         ),
                         font=dict(
-                            family="Playfair Display, serif",
-                            color="white"
+                            family="Inter, sans-serif",
+                            size=16,
+                            #color="white"
                         )
                     ),
-                    template="plotly_dark"
+                    template='simple_white',
+                    #template="plotly_dark"
                 )
 
                 return fig
@@ -1728,8 +1871,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             }
 
             df_initial = load_data_csv_es()
-            
-            models = df_initial['model'].unique().tolist()
+            models = models = df_initial['model'].unique().tolist()
             last_valid_model_selection = models.copy()  # Per salvare l’ultima selezione valida
             def enforce_model_selection(selected):
                 global last_valid_model_selection
@@ -1768,12 +1910,41 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             
             #FOR BAR
             gr.Markdown("""## Section 1: Model - Data""")
+           
             with gr.Row():
-                choose_metrics_bar = gr.Radio(
-                    choices=list(all_metrics.keys()),
-                    label="Select the metrics group that you want to use:",
-                    value="Qatch"
-                )
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        choose_metrics_bar = gr.Radio(
+                            choices=list(all_metrics.keys()),
+                            label="Select the metrics group that you want to use:",
+                            value="Qatch"
+                        )
+                        
+                    with gr.Row():
+                        qatch_info = gr.HTML("""
+                            <div style='display: flex; align-items: center; margin-top: -8px; margin-bottom: 12px;'>
+                                <span 
+                                    title="Qatch metric info:
+                                    Cell Precision: Fraction of predicted table cells also in the ground truth result. High means many correct predictions.                                    
+                                    Cell Recall: Fraction of ground truth cells retrieved by the prediction. High means relevant cells were captured.
+                                    Tuple Constraint: Fraction of ground truth tuples matched exactly in output (schema, values, cardinality).
+                                    Tuple Cardinality: Ratio of predicted to ground truth tuples. Checks only tuple count.
+                                    Tuple Order: Spearman correlation between predicted and ground truth tuple ranks."
+                                    style="margin-left: 6px; cursor: help; color: #00bfff; font-size: 16px; white-space: pre-line;"
+                                >Qatch metric info ℹ️</span>
+                            </div>
+                        """, visible=True)
+                        
+                        external_info = gr.HTML("""
+                            <div style='display: flex; align-items: center; margin-top: -8px; margin-bottom: 12px;'>
+                                <span 
+                                    title="External metric info:
+                                    Execution Accuracy: Checks if the predicted query returns exactly the same result as the ground truth query when executed. It is a binary metric: 1 if the output matches, 0 otherwise.
+                                    Valid Efficiency Score: Evaluates the efficiency of a query by combining execution time and correctness. It rewards queries that are both accurate and fast."
+                                    style="margin-left: 6px; cursor: help; color: #00bfff; font-size: 16px; white-space: pre-line;"
+                                >External metric info ℹ️</span>
+                            </div>
+                        """, visible=False)
                 
                 qatch_metric_multiselect_bar = gr.CheckboxGroup(
                     choices=list(qatch_metrics_dict.keys()),
@@ -1809,15 +1980,15 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
 
             def toggle_metric_selector(selected_type):
                 if selected_type == "Qatch":
-                    return gr.update(visible=True, value=list(qatch_metrics_dict.keys())), gr.update(visible=False, value=[])
+                    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=True, value=list(qatch_metrics_dict.keys())), gr.update(visible=False, value=[])
                 else:
-                    return gr.update(visible=False, value=[]), gr.update(visible=True, value=list(external_metrics_dict.keys()))
+                    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False, value=[]), gr.update(visible=True, value=list(external_metrics_dict.keys()))
             
             output_plot = gr.Plot(visible=False)
             
             if(input_data['input_method'] == 'default'):
                 with gr.Row():
-                    lollipop_propietary()
+                    lollipop_propietary(models)
             
             #FOR RADAR
             gr.Markdown("""## Section 2: Model - Category""")
@@ -1885,22 +2056,22 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                         first = gr.Markdown(worst_first)
                         
                     with gr.Row():
-                        first_button = gr.Button("Show row answer for 🥇")
+                        first_button = gr.Button("Show raw answer for 🥇")
                         
                     with gr.Row():
                         second = gr.Markdown(worst_second)
                         
                     with gr.Row():
-                        second_button = gr.Button("Show row answer for 🥈")
+                        second_button = gr.Button("Show raw answer for 🥈")
                         
                     with gr.Row():
                         third = gr.Markdown(worst_third)
                         
                     with gr.Row():
-                        third_button = gr.Button("Show row answer for 🥉")
+                        third_button = gr.Button("Show raw answer for 🥉")
                         
                 with gr.Column(scale=1):
-                    gr.Markdown("""## Row Answer""")
+                    gr.Markdown("""## Raw Answer""")
                     row_answer_first = gr.Markdown(value=raw_first, visible=True)
                     row_answer_second = gr.Markdown(value=raw_second, visible=False)
                     row_answer_third = gr.Markdown(value=raw_third, visible=False)
@@ -1914,8 +2085,9 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                     value=models
                 )
 
+
             with gr.Row():
-                slicer = gr.Slider(minimum=0, maximum=max(df_initial["number_question"]), step=0, value=max(df_initial["number_question"]), label="Number of instances that you want to visualize")
+                slicer = gr.Slider(minimum=0, maximum=max(df_initial["number_question"]), step=1, value=max(df_initial["number_question"]), label="Number of instances to visualize", elem_id="custom-slider")
             
             query_rate_plot = gr.Plot(value=update_query_rate(models, len(df_initial["number_question"].unique())))
 
@@ -1983,7 +2155,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 external_metric_select_bar.change(on_change_propietary, inputs=[choose_metrics_bar,qatch_metric_multiselect_bar, external_metric_select_bar, model_radio_bar], outputs=output_plot)
                 model_radio_bar.change(on_change_propietary, inputs=[choose_metrics_bar,qatch_metric_multiselect_bar, external_metric_select_bar, model_radio_bar], outputs=output_plot)
                 qatch_metric_multiselect_bar.change(fn=enforce_qatch_metrics_selection, inputs=qatch_metric_multiselect_bar, outputs=qatch_metric_multiselect_bar)
-                choose_metrics_bar.change(fn=toggle_metric_selector, inputs=choose_metrics_bar, outputs=[qatch_metric_multiselect_bar, external_metric_select_bar])
+                choose_metrics_bar.change(fn=toggle_metric_selector, inputs=choose_metrics_bar, outputs=[qatch_info, external_info, qatch_metric_multiselect_bar, external_metric_select_bar])
                 external_metric_select_bar.change(fn=enforce_external_metric_selection, inputs=external_metric_select_bar, outputs=external_metric_select_bar)
             
             else:
@@ -1994,7 +2166,7 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
                 model_multiselect_bar.change(on_change, inputs=[choose_metrics_bar,qatch_metric_multiselect_bar, external_metric_select_bar, group_radio, model_multiselect_bar], outputs=output_plot)
                 qatch_metric_multiselect_bar.change(fn=enforce_qatch_metrics_selection, inputs=qatch_metric_multiselect_bar, outputs=qatch_metric_multiselect_bar)
                 model_multiselect_bar.change(fn=enforce_model_selection, inputs=model_multiselect_bar, outputs=model_multiselect_bar)
-                choose_metrics_bar.change(fn=toggle_metric_selector, inputs=choose_metrics_bar, outputs=[qatch_metric_multiselect_bar, external_metric_select_bar])
+                choose_metrics_bar.change(fn=toggle_metric_selector, inputs=choose_metrics_bar, outputs=[qatch_info, external_info, qatch_metric_multiselect_bar, external_metric_select_bar])
                 external_metric_select_bar.change(fn=enforce_external_metric_selection, inputs=external_metric_select_bar, outputs=external_metric_select_bar)
 
 
@@ -2035,4 +2207,4 @@ with gr.Blocks(theme='d8ahazard/rd_blue', css_paths='style.css') as interface:
             reset_data.click(fn=enable_disable, inputs=[gr.State(True)], outputs=[*model_checkboxes, submit_models_button, preview_output, submit_button, file_input, default_checkbox, table_selector, *table_outputs, open_model_selection])
              
 
-interface.launch()
+interface.launch(share = True)

evaluation_p_np_metrics.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0066e9d791af80b568c94926bcb74034354765d7713355a3f42353f4cd214f16
+size 15614968

models.csv

@@ -1,7 +1,6 @@
 name,code,price,image_path
-Meta LLAMA-8,llama-8,0.0,./models_logo/LLAMA.jpg
-DeepSeek-R1-Distill-Llama-70B,DeepSeek-R1-Distill-Llama-70B,0.0,./models_logo/DEEPSEEK.jpg
-CHAT GPT-3.5,gpt-3.5,0.0,models_logo/CHATGPT3_5.png
-CHAT GPT-4 mini,gpt-4o-mini,0.0,./models_logo/CHATGPT4mini.png
-CHAT GPT-o1-mini,o1-mini,0.0,./models_logo/CHATGPTo1mini.png
-QwQ,QwQ,0.0,./models_logo/QWQ.png
+Llma-8B,llama-8,0.0,./models_logo/LLAMA.jpg
+DeepSeek-Llama-70B,DeepSeek-R1-Distill-Llama-70B,0.0,./models_logo/DEEPSEEK.jpg
+GPT-3.5,gpt-3.5,0.0,models_logo/CHATGPT3_5.png
+GPT-4o mini,gpt-4o-mini,0.0,./models_logo/CHATGPT4mini.png
+Llma-70B,llama-70,0.0,./models_logo/LLAMA.jpg

requirements.txt

@@ -12,6 +12,7 @@ litellm==1.63.14
 together==1.4.6
 # Conditional dependency for Gradio (requires Python >=3.10)
 gradio>=5.20.1; python_version >= "3.10"
+numpy==2.2.4; python_version >= "3.10"
 accelerate>=0.26.0
 
 # Test dependencies

style.css

@@ -1,12 +1,20 @@
 /* Titoli principali h1 */
+/*
+072436, 0A3048, 11547E, 1978B3, 38807D, 62B685
+*/
+html {
+    filter: none !important;
+    background: white !important;
+    color: black !important;
+}
 .prose h1 {
-    font-family: 'Playfair Display', serif;
+    font-family: 'Inter', sans-serif;
     font-size: 3rem;
     font-weight: 600;
     text-transform: none;
     letter-spacing: 0.5px;
     text-align: center;
-    color: #ffffff;
+    color: #072436;
     padding: 20px;
     margin: 20px 0;
     position: relative;
@@ -17,7 +25,7 @@
     content: "";
     width: 60px;
     height: 4px;
-    background: #d4c9cc;
+    background: #072436;
     display: block;
     margin: 10px auto 0;
     border-radius: 2px;
@@ -25,19 +33,20 @@
 
 /* Titoli secondari h2 */
 .prose h2 {
-    font-family: 'Playfair Display', serif;
-    font-size: 2.2rem;
+    font-family: 'Inter', sans-serif;
+    font-size: 2rem;
     font-weight: 500;
     letter-spacing: 0.3px;
-    color: #ffffff;
-    text-shadow: 1px 1px 3px rgba(0, 0, 0, 0.4);
+    color: #0A3048;
+    /*text-shadow: 1px 1px 3px rgba(0, 0, 0, 0.4);*/
     padding: 10px 0;
     margin: 10px 0 20px 0;
     text-align: left;
 }
 
+/* Font base globale */
 body, label, button, span, li, p, .prose {
-    font-family: 'Playfair Display', serif;
+    font-family: 'Inter', sans-serif;
 }
 
 #bar_plot, #line_plot {
@@ -47,8 +56,8 @@ body, label, button, span, li, p, .prose {
 
 .mirrored {
     display: inline-block;
-    transform: scaleX(-1); /* Riflette il testo orizzontalmente */
-    font-family: 'Poppins', sans-serif;
+    transform: scaleX(-1);
+    font-family: 'Inter', sans-serif;
     font-size: 1.5rem;
     font-weight: 700;
     letter-spacing: 1px;
@@ -62,34 +71,33 @@ body, label, button, span, li, p, .prose {
     position: center;
 }
 
-.fish{
-        font-family: 'Poppins', sans-serif;
-        font-size: 1.5rem;
-        font-weight: 700;
-        letter-spacing: 1px;
-        text-align: center;
-        color: #222;
-        background: linear-gradient(45deg, #1a41d9, #6c69d2);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        padding: 20px;
-        margin: 20px 0;
-        position: center;
+.fish {
+    font-family: 'Inter', sans-serif;
+    font-size: 1.5rem;
+    font-weight: 700;
+    letter-spacing: 1px;
+    text-align: center;
+    color: #222;
+    background: linear-gradient(45deg, #1a41d9, #6c69d2);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    padding: 20px;
+    margin: 20px 0;
+    position: center;
 }
 
 .loading {
-    font-family: 'Poppins', sans-serif;
+    font-family: 'Inter', sans-serif;
     font-size: 2.7rem;
     font-weight: 700;
     text-transform: uppercase;
     letter-spacing: 1px;
     text-align: center;
     color: #222;
-    background: linear-gradient(45deg, #40abe9, #1e99e5);
+    background: linear-gradient(45deg, #166CA2, #1978B3);
     -webkit-background-clip: text;
     -webkit-text-fill-color: transparent;
     padding: 20px;
-    /*margin: 20px 0;*/
     position: center;
 }
 
@@ -112,7 +120,7 @@ body, label, button, span, li, p, .prose {
 }
 
 .sqlquery {
-    background-color: #272822;
+    background-color: #38807D;
     color: #f8f8f2;
     font-family: 'Courier New', monospace;
     padding: 15px;
@@ -121,4 +129,27 @@ body, label, button, span, li, p, .prose {
     white-space: pre-wrap;
     word-wrap: break-word;
     box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+.gr-slider input[type="range"] {
+    accent-color: #0077B6; 
+}
+
+#custom-slider input[type="range"] {
+    background: linear-gradient(to right, #2F91B1, #2F91B1);
+    height: 8px;
+    border-radius: 5px;
+}
+/* Stile per il TextArea */
+#custom-textarea textarea {
+    background-color: #DAE5FD;  /* Colore di sfondo */
+    border: 2px solid #bdd1fe;  /* Bordo arancione */
+    color: #072436;  /* Testo scuro */
+    font-size: 16px;
+    padding: 10px;
+    border-radius: 8px;
+}
+
+/* Cambia colore del placeholder */
+#custom-textarea textarea::placeholder {
+    color: #072436;
 }

utilities.py

@@ -62,10 +62,11 @@ def read_api(api_key_path):
 def read_models_csv(file_path):
     # Reads a CSV file and returns a list of dictionaries
     models = []  # Change {} to []
-    df = pd.read_csv(file_path)
-    for _, row in df.iterrows():
-        model_dict = row.to_dict()
-        models.append(model_dict)
+    with open(file_path, mode="r", newline="") as file:
+        reader = csv.DictReader(file)
+        for row in reader:
+            row["price"] = float(row["price"])  # Convert price to float
+            models.append(row)  # Append to the list
     return models
 
 def csv_to_dict(file_path):
@@ -105,35 +106,25 @@ def generate_some_samples(connector, tbl_name):
     except Exception as e:
         samples.append(f"Error: {e}")
     return samples
+
 def extract_tables_dict(pnp_path):
     tables_dict = {}
-    # df = pd.read_csv(pnp_path)
-    # with open(pnp_path, mode='r', encoding='utf-8') as file:
-    #     reader = csv.DictReader(file)
-    #     for row in reader:
-    #         tbl_name = row.get("tbl_name")
-    #         db_path = row.get("db_path")
-    #         if tbl_name and db_path:
-    #             print(db_path, tbl_name)
-    #             connector = SqliteConnector(relative_db_path=db_path, db_name=os.path.basename(db_path))
-    #             instances = generate_some_samples(connector, tbl_name)
-    #             if tbl_name not in tables_dict:
-    #                 tables_dict[tbl_name] = []
-    #             tables_dict[tbl_name].extend(instances)
-
     with open(pnp_path, mode='r', encoding='utf-8') as file:
         reader = csv.DictReader(file)
+        tbl_db_pairs = set()  # Use a set to avoid duplicates
         for row in reader:
             tbl_name = row.get("tbl_name")
-            if tbl_name not in tables_dict:
-                tables_dict[tbl_name] = []
-            #tables_dict[tbl_name].append(row)
-    return tables_dict
-
-def check_and_create_dir(db_path):
-    # Check if the folder exists, and create it if it doesn't
-    if not os.path.exists(db_path):
-        os.makedirs(db_path)
-        print(f"Folder created: {db_path}")
-    else:
-        print(f"Folder already exists: {db_path}")
+            db_path = row.get("db_path")
+            if tbl_name and db_path:
+                tbl_db_pairs.add((tbl_name, db_path))  # Add the pair to the set
+    for tbl_name, db_path in list(tbl_db_pairs):
+            if tbl_name and db_path:
+                connector = sqlite3.connect(db_path)
+                query = f"SELECT * FROM {tbl_name} LIMIT 5"
+                try:
+                    df = pd.read_sql_query(query, connector)                    
+                    tables_dict[tbl_name] = df
+                except Exception as e:
+                    tables_dict[tbl_name] = pd.DataFrame({"Error": [str(e)]})  # DataFrame con messaggio di errore
+    
+    return tables_dict

utils_get_db_tables_info.py

@@ -2,6 +2,7 @@ import os
 import sqlite3
 import re
 
+
 def utils_extract_db_schema_as_string(
     db_id, base_path, normalize=False, sql: str | None = None
 ):