Merged in feature/talk_to_ipcc (pull request #23)

app.py

@@ -17,6 +17,7 @@ from front.tabs import create_config_modal, cqa_tab, create_about_tab
 from front.tabs import MainTabPanel, ConfigPanel
 from front.tabs.tab_drias import create_drias_tab
 from front.tabs.tab_ipcc import create_ipcc_tab
+
 from front.utils import process_figures
 from gradio_modal import Modal
 
@@ -535,6 +536,7 @@ def main_ui():
             local_cqa_components = cqa_tab(tab_name="France - Local Q&A")
             drias_components = create_drias_tab(share_client=share_client, user_id=user_id)
             ipcc_components = create_ipcc_tab(share_client=share_client, user_id=user_id)
+
             create_about_tab()
 
         event_handling(cqa_components, config_components, tab_name="ClimateQ&A")

climateqa/engine/talk_to_data/input_processing.py

@@ -10,6 +10,7 @@ from climateqa.engine.talk_to_data.objects.llm_outputs import ArrayOutput
 from climateqa.engine.talk_to_data.objects.location import Location
 from climateqa.engine.talk_to_data.objects.plot import Plot
 from climateqa.engine.talk_to_data.objects.states import State
+import calendar
 
 async def detect_location_with_openai(sentence: str) -> str:
     """
@@ -46,7 +47,7 @@ def loc_to_coords(location: str) -> tuple[float, float]:
     Raises:
         AttributeError: If the location cannot be found
     """
-    geolocator = Nominatim(user_agent="city_to_latlong")
+    geolocator = Nominatim(user_agent="city_to_latlong", timeout=5)
     coords = geolocator.geocode(location)
     return (coords.latitude, coords.longitude)
 
@@ -118,7 +119,37 @@ async def detect_year_with_openai(sentence: str) -> str:
         return years_list[0]
     else:
         return ""
-    
+
+async def detect_month_with_openai(sentence: str) -> dict[str, str]:
+    """
+    Detects month in a sentence using OpenAI's API via LangChain.
+    Returns the month as an integer string (e.g., "7" for July), or "" if not found.
+    """
+    llm = get_llm()
+    prompt = """
+    Extract the month (as a number from 1 to 12) mentioned in the following sentence.
+    Return the result as a Python list of integers. If no month is mentioned, return an empty list.
+
+    Sentence: "{sentence}"
+    """
+    prompt = ChatPromptTemplate.from_template(prompt)
+    structured_llm = llm.with_structured_output(ArrayOutput)
+    chain = prompt | structured_llm
+    response: ArrayOutput = await chain.ainvoke({"sentence": sentence})
+    months_list = eval(response['array'])
+    if len(months_list) > 0:
+        month_number = int(months_list[0])
+        month_name = calendar.month_name[month_number]
+        return {
+            "month_number": str(month_number),
+            "month_name": month_name
+        }
+    else:
+        return {
+            "month_number" : "",
+            "month_name" : ""
+        }
+
 
 async def detect_relevant_tables(user_question: str, plot: Plot, llm, table_names_list: list[str]) -> list[str]:
     """Identifies relevant tables for a plot based on user input.
@@ -227,6 +258,13 @@ async def find_year(user_input: str) -> str| None:
         return None
     return year
 
+async def find_month(user_input: str) -> dict[str, str|None]:
+    """Extracts month information from user input using LLM."""
+    print(f"---- Find month ---")
+    month_info = await detect_month_with_openai(user_input)
+    month_info = {key: None if value == "" else value for key, value in month_info.items()}
+    return month_info
+
 async def find_relevant_plots(state: State, llm, plots: list[Plot]) -> list[str]:
     print("---- Find relevant plots ----")
     relevant_plots = await detect_relevant_plots(state['user_input'], llm, plots)
@@ -237,16 +275,9 @@ async def find_relevant_tables_per_plot(state: State, plot: Plot, llm, tables: l
     relevant_tables = await detect_relevant_tables(state['user_input'], plot, llm, tables)
     return relevant_tables
 
-async def find_param(state: State, param_name:str, mode: Literal['DRIAS', 'IPCC'] = 'DRIAS') -> dict[str, Optional[str]] | Location | None:
-    """Perform the good method to retrieve the desired parameter
-
-    Args:
-        state (State): state of the workflow
-        param_name (str): name of the desired parameter
-        table (str): name of the table
-
-    Returns:
-        dict[str, Any] | None: 
+async def find_param(state: State, param_name: str, mode: Literal['DRIAS', 'IPCC'] = 'DRIAS') -> dict[str, Optional[str]] | Location | None:
+    """
+    Perform the good method to retrieve the desired parameter.
     """
     if param_name == 'location':
         location = await find_location(state['user_input'], mode)
@@ -254,4 +285,7 @@ async def find_param(state: State, param_name:str, mode: Literal['DRIAS', 'IPCC'
     if param_name == 'year':
         year = await find_year(state['user_input'])
         return {'year': year}
-    return None
+    if param_name == 'month':
+        month = await find_month(state['user_input'])
+        return month
+    return None

climateqa/engine/talk_to_data/ipcc/config.py

@@ -6,16 +6,22 @@ from climateqa.engine.talk_to_data.config import IPCC_DATASET_URL
 IPCC_TABLES = [
     "mean_temperature",
     "total_precipitation",
+    "minimum_temperature",
+    "maximum_temperature"
 ]
 
 IPCC_INDICATOR_COLUMNS_PER_TABLE = {
     "mean_temperature": "mean_temperature",
-    "total_precipitation": "total_precipitation"
+    "total_precipitation": "total_precipitation",
+    "minimum_temperature": "minimum_temperature",
+    "maximum_temperature": "maximum_temperature"
 }
 
 IPCC_INDICATOR_TO_UNIT = {
     "mean_temperature": "°C",
-    "total_precipitation": "mm/day"
+    "total_precipitation": "mm/day",
+    "minimum_temperature": "°C",
+    "maximum_temperature": "°C"
 }
 
 IPCC_SCENARIO = [
@@ -30,7 +36,8 @@ IPCC_MODELS = []
 
 IPCC_PLOT_PARAMETERS = [
     'year',
-    'location'
+    'location',
+    'month'
 ]
 
 MACRO_COUNTRIES = ['JP',
@@ -63,7 +70,9 @@ HUGE_MACRO_COUNTRIES = ['CL',
 
 IPCC_INDICATOR_TO_COLORSCALE = {
     "mean_temperature": TEMPERATURE_COLORSCALE,
-    "total_precipitation": PRECIPITATION_COLORSCALE
+    "total_precipitation": PRECIPITATION_COLORSCALE,
+    "minimum_temperature": TEMPERATURE_COLORSCALE,
+    "maximum_temperature": TEMPERATURE_COLORSCALE,
 }
 
 IPCC_UI_TEXT = """
@@ -77,9 +86,12 @@ By default, we take the **mediane of each climate model**.
 Current available charts : 
 - Yearly evolution of an indicator at a specific location (historical + SSP Projections)
 - Yearly spatial distribution of an indicator in a specific country 
+- Yearly evolution of an indicator in a specific month at a specific location (historical + SSP Projections)
 
 Current available indicators :
 - Mean temperature 
+- Minimum temperature
+- Maximum temperature
 - Total precipitation
 
 For example, you can ask:  

climateqa/engine/talk_to_data/ipcc/plot_informations.py

@@ -47,4 +47,27 @@ Each grid point is colored according to the value of the indicator ({unit}), all
 - For each grid point of {location} country ({country_name}), the value of {indicator} in {year} and for the selected scenario is extracted and mapped to its geographic coordinates.
 - The grid points correspond to 1-degree squares centered on the grid points of the IPCC dataset. Each grid point has been mapped to a country using [**reverse_geocoder**](https://github.com/thampiman/reverse-geocoder). 
 - The coordinates used for each region are those of the closest available grid point in the IPCC database, which uses a regular grid with a spatial resolution of 1 degree.
+"""
+
+def indicator_specific_month_evolution_informations(
+        indicator: str,
+        params: dict[str, str]
+) -> str:
+    if "location" not in params:
+        raise ValueError('"location" must be provided in params')
+    location = params["location"]
+    if "month_name" not in params:
+        raise ValueError('"month_name" must be provided in params')
+    month = params["month_name"]
+    unit = IPCC_INDICATOR_TO_UNIT[indicator]
+    return f"""
+This plot shows how the climate indicator **{indicator}** evolves over time in **{location}** for the month of **{month}**.
+It combines both historical (from 1950 to 2015) observations and future (from 2016 to 2100) projections for the different SSP climate scenarios (SSP126, SSP245, SSP370 and SSP585).
+The x-axis represents the years (from 1950 to 2100), and the y-axis shows the value of the {indicator} ({unit}) for the selected month.
+Each line corresponds to a different scenario, allowing you to compare how {indicator} for month {month} might change under various future conditions.
+
+**Data source:**  
+- The data comes from the IPCC climate datasets (Parquet files) for the relevant indicator, location, and month.
+- For each year and scenario, the value of {indicator} for month {month} is extracted for the selected location.
+- The coordinates used for {location} correspond to the closest available point in the IPCC database, which uses a regular grid with a spatial resolution of 1 degree.
 """

climateqa/engine/talk_to_data/ipcc/plots.py

@@ -5,8 +5,8 @@ import pandas as pd
 import geojson
 
 from climateqa.engine.talk_to_data.ipcc.config import IPCC_INDICATOR_TO_COLORSCALE, IPCC_INDICATOR_TO_UNIT, IPCC_SCENARIO
-from climateqa.engine.talk_to_data.ipcc.plot_informations import choropleth_map_informations, indicator_evolution_informations
-from climateqa.engine.talk_to_data.ipcc.queries import indicator_for_given_year_query, indicator_per_year_at_location_query
+from climateqa.engine.talk_to_data.ipcc.plot_informations import choropleth_map_informations, indicator_evolution_informations, indicator_specific_month_evolution_informations
+from climateqa.engine.talk_to_data.ipcc.queries import indicator_for_given_year_query, indicator_per_year_and_specific_month_at_location_query, indicator_per_year_at_location_query
 from climateqa.engine.talk_to_data.objects.plot import Plot
 
 def generate_geojson_polygons(latitudes: list[float], longitudes: list[float], indicators: list[float]) -> geojson.FeatureCollection:
@@ -102,6 +102,82 @@ indicator_evolution_at_location_historical_and_projections: Plot = {
     "short_name": "Evolution"
 }
 
+def plot_indicator_monthly_evolution_at_location(
+    params: dict,
+) -> Callable[[pd.DataFrame], Figure]:
+    """
+    Returns a function that generates a line plot showing the evolution of a climate indicator
+    for a specific month over time at a specific location, including both historical data
+    and future projections for different climate scenarios.
+
+    Args:
+        params (dict): Dictionary with:
+            - indicator_column (str): Name of the climate indicator column to plot.
+            - location (str): Location (e.g., country, city) for which to plot the indicator.
+            - month (str): Month name to plot.
+
+    Returns:
+        Callable[[pd.DataFrame], Figure]: Function that takes a DataFrame and returns a Plotly Figure.
+    """
+    indicator = params["indicator_column"]
+    location = params["location"]
+    month = params["month_name"]
+    indicator_label = " ".join(word.capitalize() for word in indicator.split("_"))
+    unit = IPCC_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        df = df.sort_values(by='year')
+        years = df['year'].astype(int).tolist()
+        indicators = df[indicator].astype(float).tolist()
+        scenarios = df['scenario'].astype(str).tolist()
+
+        # Find last historical value for continuity
+        last_historical = [(y, v) for y, v, s in zip(years, indicators, scenarios) if s == 'historical']
+        last_historical_year, last_historical_indicator = last_historical[-1] if last_historical else (None, None)
+
+        fig = go.Figure()
+        for scenario in IPCC_SCENARIO:
+            x = [y for y, s in zip(years, scenarios) if s == scenario]
+            y = [v for v, s in zip(indicators, scenarios) if s == scenario]
+            # Connect historical to scenario
+            if scenario != 'historical' and last_historical_indicator is not None:
+                x = [last_historical_year] + x
+                y = [last_historical_indicator] + y
+            fig.add_trace(go.Scatter(
+                x=x,
+                y=y,
+                mode='lines',
+                name=scenario
+            ))
+
+        fig.update_layout(
+            title=f'Evolution of {indicator_label} in {month} in {location} (Historical + SSP Scenarios)',
+            xaxis_title='Year',
+            yaxis_title=f'{indicator_label} ({unit})',
+            legend_title='Scenario',
+            height=800,
+        )
+        return fig
+
+    return plot_data
+
+
+indicator_specific_month_evolution_at_location: Plot = {
+    "name": "Indicator specific month Evolution at Location (Historical + Projections)",
+    "description": (
+        "Shows how a climate indicator (e.g., rainfall, temperature) for a specific month changes over time at a specific location, "
+        "including historical data and future projections. "
+        "Useful for questions about the value or trend of an indicator for a given month at a location, "
+        "such as 'How does July temperature evolve in Paris over time?'. "
+        "Parameters: indicator_column (the climate variable), location (e.g., country, city), month (1-12)."
+    ),
+    "params": ["indicator_column", "location", "month"],
+    "plot_function": plot_indicator_monthly_evolution_at_location,
+    "sql_query": indicator_per_year_and_specific_month_at_location_query,
+    "plot_information": indicator_specific_month_evolution_informations,
+    "short_name": "Evolution for a specific month"
+}
+
 def plot_choropleth_map_of_country_indicator_for_specific_year(
     params: dict,
 ) -> Callable[[pd.DataFrame], Figure]:
@@ -167,6 +243,7 @@ def plot_choropleth_map_of_country_indicator_for_specific_year(
 
     return plot_data
 
+
 choropleth_map_of_country_indicator_for_specific_year: Plot = {
     "name": "Choropleth Map of a Country's Indicator Distribution for a Specific Year",
     "description": (
@@ -185,5 +262,6 @@ choropleth_map_of_country_indicator_for_specific_year: Plot = {
 
 IPCC_PLOTS = [
     indicator_evolution_at_location_historical_and_projections,
-    choropleth_map_of_country_indicator_for_specific_year
+    choropleth_map_of_country_indicator_for_specific_year,
+    indicator_specific_month_evolution_at_location
 ]

climateqa/engine/talk_to_data/ipcc/queries.py

@@ -2,6 +2,7 @@ from typing import TypedDict, Optional
 
 from climateqa.engine.talk_to_data.ipcc.config import HUGE_MACRO_COUNTRIES, MACRO_COUNTRIES
 from climateqa.engine.talk_to_data.config import IPCC_DATASET_URL
+
 class IndicatorPerYearAtLocationQueryParams(TypedDict, total=False):
     """
     Parameters for querying the evolution of an indicator per year at a specific location.
@@ -42,7 +43,7 @@ def indicator_per_year_at_location_query(
         return ""
 
     if country_code in MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
         sql_query = f"""
         SELECT year, scenario, AVG({indicator_column}) as {indicator_column}
         FROM {table_path}
@@ -51,12 +52,12 @@ def indicator_per_year_at_location_query(
         ORDER BY year, scenario
         """
     elif country_code in HUGE_MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_annualy_macro.parquet'"
         sql_query = f"""
-        SELECT year, scenario, {indicator_column},
+        SELECT year, scenario, {indicator_column}
         FROM {table_path}
         WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950
-        ORDER year, scenario
+        ORDER BY year, scenario
         """
     else:
         table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}.parquet'"
@@ -74,6 +75,66 @@ def indicator_per_year_at_location_query(
         """
     return sql_query.strip()
 
+class IndicatorPerYearAndSpecificMonthAtLocationQueryParams(TypedDict, total=False):
+    """
+    Parameters for querying the evolution of an indicator per year for a specific month at a specific location.
+
+    Attributes:
+        indicator_column (str): Name of the climate indicator column.
+        latitude (str): Latitude of the location.
+        longitude (str): Longitude of the location.
+        country_code (str): Country code.
+        month (str): Month targeted
+    """
+    indicator_column: str
+    latitude: str
+    longitude: str
+    country_code: str
+    month: str
+
+def indicator_per_year_and_specific_month_at_location_query(
+    table: str, params: IndicatorPerYearAndSpecificMonthAtLocationQueryParams
+) -> str:
+    """
+    Builds an SQL query to get the evolution of an indicator per year for a specific month at a specific location.
+
+    Args:
+        table (str): SQL table of the indicator.
+        params (dict): Dictionary with required params:
+            - indicator_column (str)
+            - latitude (str or float)
+            - longitude (str or float)
+            - month (int)
+
+    Returns:
+        str: The SQL query string.
+    """
+    indicator_column = params.get("indicator_column")
+    latitude = params.get("latitude")
+    longitude = params.get("longitude")
+    country_code = params.get("country_code")
+    month = params.get('month_number')
+
+    if not all([indicator_column, latitude, longitude, country_code, month]):
+        return ""
+
+    if country_code in (MACRO_COUNTRIES+HUGE_MACRO_COUNTRIES):
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, {indicator_column}
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950 AND month={month}
+        ORDER BY year, scenario
+        """
+    else:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, MEDIAN({indicator_column}) AS {indicator_column}
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950 AND month={month}
+        GROUP BY scenario, year
+        """
+    return sql_query.strip()
 class IndicatorForGivenYearQueryParams(TypedDict, total=False):
     """
     Parameters for querying an indicator's values across locations for a specific year.
@@ -109,7 +170,7 @@ def indicator_for_given_year_query(
         return ""
 
     if country_code in MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
         sql_query = f"""
         SELECT latitude, longitude, scenario, AVG({indicator_column}) as {indicator_column}
         FROM {table_path}
@@ -118,9 +179,9 @@ def indicator_for_given_year_query(
         ORDER BY latitude, longitude, scenario
         """
     elif country_code in HUGE_MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_annualy_macro.parquet'"
         sql_query = f"""
-        SELECT latitude, longitude, scenario, {indicator_column},
+        SELECT latitude, longitude, scenario, {indicator_column}
         FROM {table_path}
         WHERE year = {year}
         ORDER BY latitude, longitude, scenario
@@ -140,4 +201,4 @@ def indicator_for_given_year_query(
         ORDER BY latitude, longitude, scenario
         """
 
-    return sql_query.strip()
+    return sql_query.strip()

climateqa/engine/talk_to_data/main.py

@@ -50,7 +50,7 @@ async def ask_drias(query: str, index_state: int = 0, user_id: str | None = None
 
     if "error" in final_state and final_state["error"] != "":
         # No Sql query, no dataframe, no figure, no plot information, empty sql queries list, empty result dataframes list, empty figures list, empty plot information list, index state = 0, empty table list, error message
-        return None, None, None, None, [], [], [], 0, [], final_state["error"]
+        return None, None, None, None, [], [], [], [], 0, [], final_state["error"]
 
     sql_query = sql_queries[index_state]
     dataframe = result_dataframes[index_state]
@@ -112,7 +112,7 @@ async def ask_ipcc(query: str, index_state: int = 0, user_id: str | None = None)
 
     if "error" in final_state and final_state["error"] != "":
         # No Sql query, no dataframe, no figure, no plot information, empty sql queries list, empty result dataframes list, empty figures list, empty plot information list, index state = 0, empty table list, error message
-        return None, None, None, None, [], [], [], 0, [], final_state["error"]
+        return None, None, None, None, [], [], [], [], 0, [], final_state["error"]
 
     sql_query = sql_queries[index_state]
     dataframe = result_dataframes[index_state]
@@ -121,4 +121,4 @@ async def ask_ipcc(query: str, index_state: int = 0, user_id: str | None = None)
     
     log_drias_interaction_to_huggingface(query, sql_query, user_id)
 
-    return sql_query, dataframe, figure, plot_information, sql_queries, result_dataframes, figures, plot_informations, index_state, plot_title_list, ""
+    return sql_query, dataframe, figure, plot_information, sql_queries, result_dataframes, figures, plot_informations, index_state, plot_title_list, ""

climateqa/engine/talk_to_data/query.py

@@ -3,6 +3,8 @@ from concurrent.futures import ThreadPoolExecutor
 import duckdb
 import pandas as pd
 import os
+import requests
+import tempfile
 
 def find_indicator_column(table: str, indicator_columns_per_table: dict[str,str]) -> str:
     """Retrieves the name of the indicator column within a table.
@@ -41,14 +43,88 @@ async def execute_sql_query(sql_query: str) -> pd.DataFrame:
     def _execute_query():
         # Execute the query
         con = duckdb.connect()
-        HF_TOKEN = os.getenv("HF_TOKEN")
-        con.execute(f"""CREATE SECRET hf_token (
-            TYPE huggingface,
-            TOKEN '{HF_TOKEN}'
-        );""")
-        results = con.execute(sql_query).fetchdf()
-        # return fetched data
-        return results
+        
+        # Try to use Hugging Face authentication if token is available
+        HF_TTD_TOKEN = os.getenv("HF_TTD_TOKEN")
+        
+        try:
+            if HF_TTD_TOKEN:
+                # Set up Hugging Face authentication - updated syntax
+                con.execute(f"""
+                    CREATE SECRET IF NOT EXISTS hf_token (
+                        TYPE HUGGINGFACE,
+                        TOKEN '{HF_TTD_TOKEN}'
+                    );
+                """)
+                print("Hugging Face authentication configured")
+            
+            # Execute the query
+            results = con.execute(sql_query).fetchdf()
+            return results
+                
+        except duckdb.HTTPException as e:
+            print(f"HTTP error accessing Hugging Face dataset: {e}")
+            
+            # If we have a token but still get HTTP error, try without authentication
+            if HF_TTD_TOKEN:
+                print("Retrying without authentication...")
+                try:
+                    # Create a new connection without the secret
+                    con_no_auth = duckdb.connect()
+                    results = con_no_auth.execute(sql_query).fetchdf()
+                    return results
+                except Exception as e2:
+                    print(f"Also failed without authentication: {e2}")
+            
+            # Try to download the file locally and retry
+            print("Trying to download file locally and retry...")
+            
+            # Extract the URL from the error message or construct it from the query
+            error_str = str(e)
+            url = None
+            
+            if "HTTP GET error on '" in error_str:
+                url = error_str.split("HTTP GET error on '")[1].split("'")[0]
+            else:
+                # Try to extract URL from the SQL query
+                import re
+                url_match = re.search(r"'(https://huggingface\.co/[^']+)'", sql_query)
+                if url_match:
+                    url = url_match.group(1)
+            
+            if url:
+                table_name = url.split('/')[-1]
+                local_path = os.path.join(tempfile.gettempdir(), table_name)
+                print(f"Downloading {url} to {local_path}")
+                
+                # Add authentication headers if token is available
+                headers = {}
+                if HF_TTD_TOKEN:
+                    headers['Authorization'] = f'Bearer {HF_TTD_TOKEN}'
+                
+                response = requests.get(url, headers=headers, stream=True)
+                if response.status_code == 200:
+                    with open(local_path, 'wb') as f:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                    
+                    # Modify the SQL query to use the local file
+                    modified_sql = sql_query.replace(f"'{url}'", f"'{local_path}'")
+                    results = con.execute(modified_sql).fetchdf()
+                    return results
+                elif response.status_code == 401:
+                    print("Authentication failed - check your HF_TTD_TOKEN")
+                    raise Exception("Authentication failed. Please check your HF_TTD_TOKEN environment variable.")
+                else:
+                    print(f"Failed to download file: {response.status_code}")
+                    raise e
+            else:
+                print("Could not extract URL from error message")
+                raise e
+        
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+            raise e
 
     # Run the query in a thread pool to avoid blocking
     loop = asyncio.get_event_loop()

climateqa/engine/talk_to_data/workflow/ipcc.py

@@ -152,10 +152,18 @@ async def ipcc_workflow(user_input: str) -> State:
 
     # 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"
+        state['error'] = (
+            "Sorry, I couldn't find any relevant table in our database to answer your question.\n"
+            "Try asking about a different climate indicator like temperature or precipitation."
+        )
     elif not errors['have_sql_query']:
-        state['error'] = "There is no relevant sql query on our database that can help to answer your question"
+        state['error'] = (
+            "Sorry, I couldn't generate a relevant SQL query to answer your question.\n"
+            "Try rephrasing your question to focus on a specific location, a year, or a month."
+        )
     elif not errors['have_dataframe']:
-        state['error'] = "There is no data in our table that can answer to your question"
-
+        state['error'] = (
+            "Sorry, there is no data in our tables that can answer your question.\n"
+            "Try asking about a more common location, or a different year."
+        )
     return state

front/tabs/tab_ipcc.py

@@ -68,6 +68,8 @@ def show_filter_by_scenario(table_names, index_state, dataframes):
         return gr.update(visible=False)
         
 def filter_by_scenario(dataframes, figures, table_names, index_state, scenario):
+    if len(dataframes) == 0:
+        return None, None 
     df = dataframes[index_state]
     if not table_names[index_state].startswith("Map"):
         return df, figures[index_state](df)

requirements.txt

@@ -26,4 +26,5 @@ duckdb==1.2.1
 openai==1.61.1
 pydantic==2.9.2
 pydantic-settings==2.2.1
-geojson==3.2.0
+geojson==3.2.0
+requests==2.32.3

style.css

@@ -741,4 +741,4 @@ div#tab-vanna{
 #example-img-container {
     flex-direction: column;
     align-items: left;
-}
+}