feat: updated talk to drias based on talk to ipcc

climateqa/engine/talk_to_data/drias/config.py

@@ -1,7 +1,7 @@
 
 DRIAS_TABLES = [
     "total_winter_precipitation",
-    "total_summer_precipiation",
+    "total_summer_precipitation",
     "total_annual_precipitation",
     "total_remarkable_daily_precipitation",
     "frequency_of_remarkable_daily_precipitation",
@@ -18,7 +18,7 @@ DRIAS_TABLES = [
 
 DRIAS_INDICATOR_COLUMNS_PER_TABLE = {
     "total_winter_precipitation": "total_winter_precipitation",
-    "total_summer_precipiation": "total_summer_precipitation",
+    "total_summer_precipitation": "total_summer_precipitation",
     "total_annual_precipitation": "total_annual_precipitation",
     "total_remarkable_daily_precipitation": "total_remarkable_daily_precipitation",
     "frequency_of_remarkable_daily_precipitation": "frequency_of_remarkable_daily_precipitation",
@@ -70,11 +70,14 @@ DRIAS_INDICATOR_TO_UNIT = {
     "number_of_days_with_dry_ground": "days"
 }
 
+DRIAS_PLOT_PARAMETERS = [
+    'year',
+    'location'
+]
 DRIAS_UI_TEXT = """
 Hi, I'm **Talk to Drias**, designed to answer your questions using [**DRIAS - TRACC 2023**](https://www.drias-climat.fr/accompagnement/sections/401) data.  
 I'll answer by displaying a list of SQL queries, graphs and data most relevant to your question.
 
-❓ **How to use?**  
 You can ask me anything about these climate indicators: **temperature**, **precipitation** or **drought**.  
 You can specify **location** and/or **year**.  
 You can choose from a list of climate models. By default, we take the **average of each model**.

climateqa/engine/talk_to_data/drias/plots.py

@@ -1,5 +1,6 @@
 import os
-
+import geojson
+from math import cos, radians
 from typing import Callable
 import pandas as pd
 from plotly.graph_objects import Figure
@@ -11,6 +12,7 @@ from climateqa.engine.talk_to_data.drias.queries import (
 )
 from climateqa.engine.talk_to_data.drias.config import DRIAS_INDICATOR_TO_UNIT
 
+
 def plot_indicator_evolution_at_location(params: dict) -> Callable[..., Figure]:
     """Generates a function to plot indicator evolution over time at a location.
     
@@ -122,10 +124,11 @@ def plot_indicator_evolution_at_location(params: dict) -> Callable[..., Figure]:
             hovertemplate=f"{indicator_label}: %{{y:.2f}} {unit}<br>Year: %{{x}}<extra></extra>"
         )
         fig.update_layout(
-            title=f"Plot of {indicator_label} in {location} ({model_label})",
+            title=f"Evolution of {indicator_label} in {location} ({model_label})",
             xaxis_title="Year",
             yaxis_title=f"{indicator_label} ({unit})",
             template="plotly_white",
+            height=900,
         )
         return fig
 
@@ -138,6 +141,7 @@ indicator_evolution_at_location: Plot = {
     "params": ["indicator_column", "location", "model"],
     "plot_function": plot_indicator_evolution_at_location,
     "sql_query": indicator_per_year_at_location_query,
+    'short_name': 'Indicator Evolution'
 }
 
 
@@ -206,6 +210,7 @@ def plot_indicator_number_of_days_per_year_at_location(
             yaxis_title=f"{indicator_label} ({unit})",
             yaxis=dict(range=[0, max(indicators)]),
             bargap=0.5,
+            height=900,
             template="plotly_white",
         )
 
@@ -220,6 +225,7 @@ indicator_number_of_days_per_year_at_location: Plot = {
     "params": ["indicator_column", "location", "model"],
     "plot_function": plot_indicator_number_of_days_per_year_at_location,
     "sql_query": indicator_per_year_at_location_query,
+    "short_name": "Indicator Yearly Frequency",
 }
 
 
@@ -242,6 +248,8 @@ def plot_distribution_of_indicator_for_given_year(
     """
     indicator = params["indicator_column"]
     year = params["year"]
+    if year is None:
+        year = 2030
     indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
     unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
 
@@ -288,6 +296,7 @@ def plot_distribution_of_indicator_for_given_year(
             yaxis_title="Frequency (%)",
             plot_bgcolor="rgba(0, 0, 0, 0)",
             showlegend=False,
+            height=900,
         )
 
         return fig
@@ -301,6 +310,7 @@ distribution_of_indicator_for_given_year: Plot = {
     "params": ["indicator_column", "model", "year"],
     "plot_function": plot_distribution_of_indicator_for_given_year,
     "sql_query": indicator_for_given_year_query,
+    'short_name': 'Indicator Distribution'
 }
 
 
@@ -323,6 +333,8 @@ def plot_map_of_france_of_indicator_for_given_year(
     """
     indicator = params["indicator_column"]
     year = params["year"]
+    if year is None:
+        year = 2030
     indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
     unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
 
@@ -347,28 +359,60 @@ def plot_map_of_france_of_indicator_for_given_year(
             longitudes = df_model["longitude"].astype(float).tolist()
             model_label = f"Model : {df['model'].unique()[0]}"
 
-
-        fig.add_trace(
-            go.Scattermapbox(
-                lat=latitudes,
-                lon=longitudes,
-                mode="markers",
-                marker=dict(
-                    size=10,
-                    color=indicators,  # Color mapped to values
-                    colorscale="Turbo",  # Color scale (can be 'Plasma', 'Jet', etc.)
-                    cmin=min(indicators),  # Minimum color range
-                    cmax=max(indicators),  # Maximum color range
-                    showscale=True,  # Show colorbar
-                ),
-                text=[f"{indicator_label}: {value:.2f} {unit}" for value in indicators],  # Add hover text showing the indicator value
-                hoverinfo="text"  # Only show the custom text on hover
-            )
-        )
+        side_km = 8
+        delta_lat = side_km / 111
+        features = []
+        for idx, (lat, lon, val) in enumerate(zip(latitudes, longitudes, indicators)):
+            delta_lon  = side_km / (111 * cos(radians(lat)))
+            half_lat = delta_lat / 2
+            half_lon = delta_lon / 2
+            features.append(geojson.Feature(
+                    geometry=geojson.Polygon([[
+                        [lon - half_lon, lat - half_lat],
+                        [lon + half_lon, lat - half_lat],
+                        [lon + half_lon, lat + half_lat],
+                        [lon - half_lon, lat + half_lat],
+                        [lon - half_lon, lat - half_lat]
+                    ]]),
+                    properties={"value": val},
+                    id=str(idx)
+                ))
+
+        geojson_data = geojson.FeatureCollection(features)
+
+        custom_colorscale = [
+            [0.0, "rgb(5, 48, 97)"],
+            [0.10, "rgb(33, 102, 172)"],
+            [0.20, "rgb(67, 147, 195)"],
+            [0.30, "rgb(146, 197, 222)"],
+            [0.40, "rgb(209, 229, 240)"],
+            [0.50, "rgb(247, 247, 247)"],
+            [0.60, "rgb(253, 219, 199)"],
+            [0.75, "rgb(244, 165, 130)"],
+            [0.85, "rgb(214, 96, 77)"],
+            [0.90, "rgb(178, 24, 43)"],
+            [1.0, "rgb(103, 0, 31)"]
+        ]
+
+        fig = go.Figure(go.Choroplethmapbox(
+            geojson=geojson_data,
+            locations=[str(i) for i in range(len(indicators))],
+            featureidkey="id",
+            z=indicators,
+            colorscale=custom_colorscale,
+            zmin=min(indicators),
+            zmax=max(indicators),
+            marker_opacity=0.7,
+            marker_line_width=0,
+            colorbar_title=f"{indicator_label} ({unit})",
+            text=[f"{indicator_label}: {value:.2f} {unit}" for value in indicators],  # Add hover text showing the indicator value
+            hoverinfo="text" 
+        ))
 
         fig.update_layout(
             mapbox_style="open-street-map",  # Use OpenStreetMap
-            mapbox_zoom=3,
+            mapbox_zoom=5,
+            height=900,
             mapbox_center={"lat": 46.6, "lon": 2.0},
             coloraxis_colorbar=dict(title=f"{indicator_label} ({unit})"),  # Add legend
             title=f"{indicator_label} in {year} in France ({model_label}) " # Title
@@ -380,10 +424,11 @@ def plot_map_of_france_of_indicator_for_given_year(
 
 map_of_france_of_indicator_for_given_year: Plot = {
     "name": "Map of France of an indicator for a given year",
-    "description": "Heatmap on the map of France of the values of an in indicator for a given year",
+    "description": "Heatmap on the map of France of the values of an indicator for a given year",
     "params": ["indicator_column", "year", "model"],
     "plot_function": plot_map_of_france_of_indicator_for_given_year,
     "sql_query": indicator_for_given_year_query,
+    'short_name': 'Map of France'
 }
 
 DRIAS_PLOTS = [

climateqa/engine/talk_to_data/drias/queries.py

@@ -71,6 +71,8 @@ def indicator_for_given_year_query(
     """
     indicator_column = params.get("indicator_column")
     year = params.get('year')
+    if year is None:
+        year = 2050
     if year is None or indicator_column is None: # If one parameter is missing, returns an empty query
         return ""
     

climateqa/engine/talk_to_data/workflow/drias.py

@@ -6,131 +6,154 @@ from climateqa.engine.llm import get_llm
 from climateqa.engine.talk_to_data.input_processing import find_param, find_relevant_plots, find_relevant_tables_per_plot
 from climateqa.engine.talk_to_data.query import execute_sql_query, find_indicator_column
 from climateqa.engine.talk_to_data.objects.plot import Plot
-from climateqa.engine.talk_to_data.objects.states import PlotState, State, TableState
-from climateqa.engine.talk_to_data.drias.config import DRIAS_TABLES, DRIAS_INDICATOR_COLUMNS_PER_TABLE
+from climateqa.engine.talk_to_data.objects.states import State, TTDOutput
+from climateqa.engine.talk_to_data.drias.config import DRIAS_TABLES, DRIAS_INDICATOR_COLUMNS_PER_TABLE, DRIAS_PLOT_PARAMETERS
 from climateqa.engine.talk_to_data.drias.plots import DRIAS_PLOTS
 
 ROOT_PATH = os.path.dirname(os.path.dirname(os.getcwd()))
 
-async def process_table(
+async def process_output(
+    output_title: str,
     table: str,
-    params: dict[str, Any],
     plot: Plot,
-) -> TableState:
-    """Processes a table to extract relevant data and generate visualizations.
-    
-    This function retrieves the SQL query for the specified table, executes it,
-    and generates a visualization based on the results.
-    
+    params: dict[str, Any]
+) -> tuple[str, TTDOutput, dict[str, bool]]:
+    """
+    Processes a table for a given plot and parameters: builds the SQL query, executes it,
+    and generates the corresponding figure.
+
     Args:
-        table (str): The name of the table to process
-        params (dict[str, Any]): Parameters used for querying the table
-        plot (Plot): The plot object containing SQL query and visualization function
-        
+        output_title (str): Title for the output (used as key in outputs dict).
+        table (str): The name of the table to process.
+        plot (Plot): The plot object containing SQL query and visualization function.
+        params (dict[str, Any]): Parameters used for querying the table.
+
     Returns:
-        TableState: The state of the processed table
+        tuple: (output_title, results dict, errors dict)
     """
-    table_state: TableState = {
-        'table_name': table,
-        'params': params.copy(),
+    results: TTDOutput = {
         'status': 'OK',
-        'dataframe': None,
+        'plot': plot,
+        'table': table,
         'sql_query': None,
+        'dataframe': None,
         'figure': None
     }
+    errors = {
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
 
-    table_state['params']['indicator_column'] = find_indicator_column(table, DRIAS_INDICATOR_COLUMNS_PER_TABLE)
-    sql_query = plot['sql_query'](table, table_state['params'])
+    # Find the indicator column for this table
+    indicator_column = find_indicator_column(table, DRIAS_INDICATOR_COLUMNS_PER_TABLE)
+    if indicator_column:
+        params['indicator_column'] = indicator_column
 
-    if sql_query == "":
-        table_state['status'] = 'ERROR'
-        return table_state
-    table_state['sql_query'] = sql_query
-    df = await execute_sql_query(sql_query)
+    # Build the SQL query
+    sql_query = plot['sql_query'](table, params)
+    if not sql_query:
+        results['status'] = 'ERROR'
+        return output_title, results, errors
 
-    table_state['dataframe'] = df
-    table_state['figure'] = plot['plot_function'](table_state['params'])
+    results['sql_query'] = sql_query
+    errors['have_sql_query'] = True
 
-    return table_state
+    # Execute the SQL query
+    df = await execute_sql_query(sql_query)
+    if df is not None and len(df) > 0:
+        results['dataframe'] = df
+        errors['have_dataframe'] = True
+    else:
+        results['status'] = 'NO_DATA'
 
+    # Generate the figure (always, even if df is empty, for consistency)
+    results['figure'] = plot['plot_function'](params)
+
+    return output_title, results, errors
 
 async def drias_workflow(user_input: str) -> State:
-    """Performs the complete workflow of Talk To Drias : from user input to sql queries, dataframes and figures generated
+    """
+    Orchestrates the DRIAS workflow: from user input to SQL queries, dataframes, and figures.
 
     Args:
-        user_input (str): initial user input
+        user_input (str): The user's question.
 
     Returns:
-        State: Final state with all the results
+        State: Final state with all results and error messages if any.
     """
     state: State = {
         'user_input': user_input,
         'plots': [],
-        'plot_states': {},
+        'outputs': {},
         'error': ''
     }
 
     llm = get_llm(provider="openai")
-
     plots = await find_relevant_plots(state, llm, DRIAS_PLOTS)
 
-    state['plots'] = plots
-
-    if len(state['plots']) < 1:
+    if not plots:
         state['error'] = 'There is no plot to answer to the question'
         return state
 
-    have_relevant_table = False
-    have_sql_query = False
-    have_dataframe = False
+    plots = plots[:2]  # limit to 2 types of plots
+    state['plots'] = plots
 
-    for plot_name in state['plots']:
-        
-        plot = next((p for p in DRIAS_PLOTS if p['name'] == plot_name), None) # Find the associated plot object
+    errors = {
+        'have_relevant_table': False,
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
+    outputs = {}
+
+    # Find relevant tables for each plot and prepare outputs
+    for plot_name in plots:
+        plot = next((p for p in DRIAS_PLOTS if p['name'] == plot_name), None)
         if plot is None:
             continue
-        
-        plot_state: PlotState = {
-            'plot_name': plot_name,
-            'tables': [],
-            'table_states': {}
-        }
-
-        plot_state['plot_name'] = plot_name
 
         relevant_tables = await find_relevant_tables_per_plot(state, plot, llm, DRIAS_TABLES)
-
-        if len(relevant_tables) > 0 :
-            have_relevant_table = True
-
-        plot_state['tables'] = relevant_tables
-
-        params = {}
-        for param_name in plot['params']:
-            param = await find_param(state, param_name, relevant_tables[0])
-            if param:
-                params.update(param)
-        
-        tasks = [process_table(table, params, plot) for table in plot_state['tables'][:3]]
-        results = await asyncio.gather(*tasks)
-
-        # Store results back in plot_state
-        have_dataframe = False
-        have_sql_query = False
-        for table_state in results:
-            if table_state['sql_query']:
-                have_sql_query = True
-            if table_state['dataframe'] is not None and len(table_state['dataframe']) > 0:
-                have_dataframe = True
-            plot_state['table_states'][table_state['table_name']] = table_state
-
-        state['plot_states'][plot_name] = plot_state
-                
-    if not have_relevant_table:
+        if relevant_tables:
+            errors['have_relevant_table'] = True
+
+        for table in relevant_tables:
+            output_title = f"{plot['short_name']} - {' '.join(table.capitalize().split('_'))}"
+            outputs[output_title] = {
+                'table': table,
+                'plot': plot,
+                'status': 'OK'
+            }
+
+    # Gather all required parameters
+    params = {}
+    for param_name in DRIAS_PLOT_PARAMETERS:
+        param = await find_param(state, param_name, mode='DRIAS')
+        if param:
+            params.update(param)
+
+    # Process all outputs in parallel using process_output
+    tasks = [
+        process_output(output_title, output['table'], output['plot'], params.copy())
+        for output_title, output in outputs.items()
+    ]
+    results = await asyncio.gather(*tasks)
+
+    # Update outputs with results and error flags
+    for output_title, task_results, task_errors in results:
+        outputs[output_title]['sql_query'] = task_results['sql_query']
+        outputs[output_title]['dataframe'] = task_results['dataframe']
+        outputs[output_title]['figure'] = task_results['figure']
+        outputs[output_title]['status'] = task_results['status']
+        errors['have_sql_query'] |= task_errors['have_sql_query']
+        errors['have_dataframe'] |= task_errors['have_dataframe']
+
+    state['outputs'] = outputs
+
+    # Set error messages if needed
+    if not errors['have_relevant_table']:
         state['error'] = "There is no relevant table in our database to answer your question"
-    elif not have_sql_query:
+    elif not errors['have_sql_query']:
         state['error'] = "There is no relevant sql query on our database that can help to answer your question"
-    elif not have_dataframe:
+    elif not errors['have_dataframe']:
         state['error'] = "There is no data in our table that can answer to your question"
-    
-    return state
+
+    return state

front/tabs/tab_drias.py

@@ -11,9 +11,10 @@ class DriasUIElements(TypedDict):
     details_accordion: gr.Accordion
     examples_hidden: gr.Textbox
     examples: gr.Examples
+    image_examples: gr.Row
     drias_direct_question: gr.Textbox
     result_text: gr.Textbox
-    table_names_display: gr.DataFrame
+    table_names_display: gr.Radio
     query_accordion: gr.Accordion
     drias_sql_query: gr.Textbox
     chart_accordion: gr.Accordion
@@ -21,9 +22,6 @@ class DriasUIElements(TypedDict):
     drias_display: gr.Plot
     table_accordion: gr.Accordion
     drias_table: gr.DataFrame
-    pagination_display: gr.Markdown
-    prev_button: gr.Button
-    next_button: gr.Button
 
 
 async def ask_drias_query(query: str, index_state: int, user_id: str):
@@ -31,7 +29,7 @@ async def ask_drias_query(query: str, index_state: int, user_id: str):
     return result
 
 
-def show_results(sql_queries_state, dataframes_state, plots_state):
+def show_results(sql_queries_state, dataframes_state, plots_state, table_names):
     if not sql_queries_state or not dataframes_state or not plots_state:
         # If all results are empty, show "No result"
         return (
@@ -40,9 +38,6 @@ def show_results(sql_queries_state, dataframes_state, plots_state):
             gr.update(visible=False),
             gr.update(visible=False),
             gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
         )
     else:
         # Show the appropriate components with their data
@@ -51,10 +46,7 @@ def show_results(sql_queries_state, dataframes_state, plots_state):
             gr.update(visible=True),
             gr.update(visible=True),
             gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
+            gr.update(choices=table_names, value=table_names[0], visible=True),
         )
 
 
@@ -72,39 +64,8 @@ def filter_by_model(dataframes, figures, index_state, model_selection):
     return df, figure
 
 
-def update_pagination(index, sql_queries):
-    pagination = f"{index + 1}/{len(sql_queries)}" if sql_queries else ""
-    return pagination
-
-
-def show_previous(index, sql_queries, dataframes, plots):
-    if index > 0:
-        index -= 1
-    return (
-        sql_queries[index],
-        dataframes[index],
-        plots[index](dataframes[index]),
-        index,
-    )
-
-
-def show_next(index, sql_queries, dataframes, plots):
-    if index < len(sql_queries) - 1:
-        index += 1
-    return (
-        sql_queries[index],
-        dataframes[index],
-        plots[index](dataframes[index]),
-        index,
-    )
-
-
-def display_table_names(table_names):
-    return [[table_name] for table_name in table_names]
-
-
-def on_table_click(evt: gr.SelectData, table_names, sql_queries, dataframes, plots):
-    index = evt.index[1]
+def on_table_click(selected_label, table_names, sql_queries, dataframes, plots):
+    index = table_names.index(selected_label)
     figure = plots[index](dataframes[index])
     return (
         sql_queries[index],
@@ -117,7 +78,7 @@ def on_table_click(evt: gr.SelectData, table_names, sql_queries, dataframes, plo
 def create_drias_ui() -> DriasUIElements:
     """Create and return all UI elements for the DRIAS tab."""
     with gr.Tab("France - Talk to DRIAS", elem_id="tab-vanna", id=6) as tab:
-        with gr.Accordion(label="Details") as details_accordion:
+        with gr.Accordion(label="❓ How to use?", elem_id="details") as details_accordion:
             gr.Markdown(DRIAS_UI_TEXT)
             
         # Add examples for common questions
@@ -141,19 +102,35 @@ def create_drias_ui() -> DriasUIElements:
                 elem_id="direct-question",
                 interactive=True,
             )
+        
+        
+        with gr.Row(visible=True, elem_id="example-img-container") as image_examples:
+            gr.Markdown("### Examples of possible visualizations")
+
+            with gr.Row():
+                gr.Image("./front/assets/talk_to_drias_winter_temp_paris_example.png", label="Evolution of Mean Winter Temperature in Paris", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_drias_annual_temperature_france_example.png", label="Mean Annual Temperature in 2030 in France", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_drias_frequency_remarkable_precipitation_lyon_example.png", label="Frequency of Remarkable Daily Precipitation in Lyon", elem_classes=["example-img"])
 
         result_text = gr.Textbox(
             label="", elem_id="no-result-label", interactive=False, visible=True
         )
-        table_names_display = gr.DataFrame(
-            [], label="List of relevant indicators", headers=["Indicator Name"], interactive=False, elem_id="table-names", visible=False
-        )
-
-        with gr.Accordion(label="SQL Query Used", visible=False) as query_accordion:
-            drias_sql_query = gr.Textbox(
-                label="", elem_id="sql-query", interactive=False
+        
+        with gr.Row():
+            table_names_display = gr.Radio(
+                choices=[], 
+                label="Relevant figures created",
+                interactive=True,
+                elem_id="table-names",
+                visible=False
             )
 
+            with gr.Accordion(label="SQL Query Used", visible=False) as query_accordion:
+                drias_sql_query = gr.Textbox(
+                    label="", elem_id="sql-query", interactive=False
+                )
+
+    
         with gr.Accordion(label="Chart", visible=False) as chart_accordion:
             model_selection = gr.Dropdown(
                 label="Model", choices=DRIAS_MODELS, value="ALL", interactive=True
@@ -165,19 +142,12 @@ def create_drias_ui() -> DriasUIElements:
         ) as table_accordion:
             drias_table = gr.DataFrame([], elem_id="vanna-table")
 
-        pagination_display = gr.Markdown(
-            value="", visible=False, elem_id="pagination-display"
-        )
-
-        with gr.Row():
-            prev_button = gr.Button("Previous", visible=False)
-            next_button = gr.Button("Next", visible=False)
-
         return DriasUIElements(
             tab=tab,
             details_accordion=details_accordion,
             examples_hidden=examples_hidden,
             examples=examples,
+            image_examples=image_examples,
             drias_direct_question=drias_direct_question,
             result_text=result_text,
             table_names_display=table_names_display,
@@ -188,9 +158,6 @@ def create_drias_ui() -> DriasUIElements:
             drias_display=drias_display,
             table_accordion=table_accordion,
             drias_table=drias_table,
-            pagination_display=pagination_display,
-            prev_button=prev_button,
-            next_button=next_button
         )
 
 
@@ -210,6 +177,10 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         lambda x: (gr.Accordion(open=False), gr.Textbox(value=x)),
         inputs=[ui_elements["examples_hidden"]],
         outputs=[ui_elements["details_accordion"], ui_elements["drias_direct_question"]]
+    ).then(
+        lambda : gr.update(visible=False),
+        inputs=None,
+        outputs=ui_elements["image_examples"]
     ).then(
         ask_drias_query,
         inputs=[ui_elements["examples_hidden"], index_state, user_id],
@@ -226,25 +197,14 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         ],
     ).then(
         show_results,
-        inputs=[sql_queries_state, dataframes_state, plots_state],
+        inputs=[sql_queries_state, dataframes_state, plots_state, table_names_list],
         outputs=[
             ui_elements["result_text"],
             ui_elements["query_accordion"],
             ui_elements["table_accordion"],
             ui_elements["chart_accordion"],
-            ui_elements["prev_button"],
-            ui_elements["next_button"],
-            ui_elements["pagination_display"],
             ui_elements["table_names_display"],
         ],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    ).then(
-        display_table_names,
-        inputs=[table_names_list],
-        outputs=[ui_elements["table_names_display"]],
     )
 
     # Handle direct question submission
@@ -252,6 +212,10 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         lambda: gr.Accordion(open=False),
         inputs=None,
         outputs=[ui_elements["details_accordion"]]
+    ).then(
+        lambda : gr.update(visible=False),
+        inputs=None,
+        outputs=ui_elements["image_examples"]
     ).then(
         ask_drias_query,
         inputs=[ui_elements["drias_direct_question"], index_state, user_id],
@@ -268,27 +232,15 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         ],
     ).then(
         show_results,
-        inputs=[sql_queries_state, dataframes_state, plots_state],
+        inputs=[sql_queries_state, dataframes_state, plots_state, table_names_list],
         outputs=[
             ui_elements["result_text"],
             ui_elements["query_accordion"],
             ui_elements["table_accordion"],
             ui_elements["chart_accordion"],
-            ui_elements["prev_button"],
-            ui_elements["next_button"],
-            ui_elements["pagination_display"],
             ui_elements["table_names_display"],
         ],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    ).then(
-        display_table_names,
-        inputs=[table_names_list],
-        outputs=[ui_elements["table_names_display"]],
     )
-
     # Handle model selection change
     ui_elements["model_selection"].change(
         filter_by_model,
@@ -296,36 +248,12 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         outputs=[ui_elements["drias_table"], ui_elements["drias_display"]],
     )
 
-    # Handle pagination buttons
-    ui_elements["prev_button"].click(
-        show_previous,
-        inputs=[index_state, sql_queries_state, dataframes_state, plots_state],
-        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    )
-
-    ui_elements["next_button"].click(
-        show_next,
-        inputs=[index_state, sql_queries_state, dataframes_state, plots_state],
-        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    )
 
     # Handle table selection
-    ui_elements["table_names_display"].select(
+    ui_elements["table_names_display"].change(
         fn=on_table_click,
-        inputs=[table_names_list, sql_queries_state, dataframes_state, plots_state],
+        inputs=[ui_elements["table_names_display"], table_names_list, sql_queries_state, dataframes_state, plots_state],
         outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
     )
 
 def create_drias_tab(share_client=None, user_id=None):