Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

help me implement api use for getting data in this code import pandas as pd import…

  1. User

    help me implement api use for getting data in this code import pandas as pd import logging import os from dash import Dash, html, dash_table, dcc import plotly.express as px from dash.dependencies import Input, Output from dash.exceptions import PreventUpdate

    Configure logging

    logging.basicConfig(level=logging.INFO) logger = logging.getLogger(name)

    def load_data(filepath): if not os.path.exists(filepath): logger.error(f"The file {filepath} does not exist.") raise FileNotFoundError(f"The file {filepath} does not exist.")

    columns_to_use = ['dt', 'Country', 'AverageTemperature']
    try:
        df = pd.read_csv(filepath, usecols=columns_to_use, parse_dates=['dt'])
        logger.info("CSV file loaded successfully.")
    except ValueError as error:
        logger.error(f"Error reading the CSV file: {error}")
        raise ValueError(f"Error reading the file: {error}")
    
    required_cols = {'dt', 'Country', 'AverageTemperature'}
    if not required_cols.issubset(df.columns):
        missing = required_cols - set(df.columns)
        logger.error(f"The required columns are missing: {missing}")
        raise ValueError(f"The required columns are missing: {missing}")
    
    df.rename(columns={'dt': 'Date and Time'}, inplace=True)
    logger.info("Column 'dt' renamed to 'Date and Time'.")
    
    initial_row_count = df.shape[0]
    df.dropna(subset=['AverageTemperature'], inplace=True)
    final_row_count = df.shape[0]
    logger.info(f"Dropped {initial_row_count - final_row_count} rows with NaN 'AverageTemperature'.")
    
    return df
    

    def filter_country_data(country_df): country_df.set_index('Date and Time', inplace=True) country_df.sort_index(inplace=True) logger.info("DataFrame filtered by country and indexed by 'Date and Time'.") return country_df

    def calculate_moving_average(country_df, window_size=5): numeric_cols = country_df.select_dtypes(include='number').columns.tolist() logger.debug(f"Numeric columns selected for aggregation: {numeric_cols}")

    if 'AverageTemperature' not in numeric_cols:
        logger.error("The 'AverageTemperature' column is missing or non-numeric.")
        raise ValueError("The 'AverageTemperature' column is missing or non-numeric.")
    
    try:
        # Resample data to 5-year intervals
        resampled_df = country_df[numeric_cols].resample('5Y').mean()
        logger.info("Data resampled to 5-year intervals.")
    except Exception as error:
        logger.error(f"Error during resampling: {error}")
        raise ValueError(f"Error during resampling: {error}")
    
    # Calculate moving average
    resampled_df['MovingAverage'] = resampled_df['AverageTemperature'].rolling(window=window_size).mean()
    logger.info(f"5-year moving average calculated with window size {window_size}.")
    
    return resampled_df
    

    def create_bar_chart(bar_df): bar_df_reset = bar_df.reset_index() fig = px.bar( bar_df_reset, x='Date and Time', y='AverageTemperature', title='Average Temperature Over Time' ) fig.update_layout( plot_bgcolor='#121212', paper_bgcolor='#121212', font_color='white', xaxis=dict(title='Date and Time', showgrid=False, color='white'), yaxis=dict(title='Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white') ) logger.info("Bar chart created.") return fig

    def create_box_plot(box_df): box_df_reset = box_df.reset_index() box_df_reset['Year'] = box_df_reset['Date and Time'].dt.year

    fig = px.box(
        box_df_reset,
        x='Year',
        y='AverageTemperature',
        title='Temperature Distribution by Year',
        points='outliers'
    )
    fig.update_layout(
        plot_bgcolor='#121212',
        paper_bgcolor='#121212',
        font_color='white',
        xaxis=dict(title='Year', showgrid=False, color='white'),
        yaxis=dict(title='Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white')
    )
    logger.info("Box plot created.")
    return fig
    

    def create_line_chart(line_df, country_name): line_df_reset = line_df.reset_index() fig = px.line( line_df_reset, x='Date and Time', y='MovingAverage', title=f'5-Year Moving Average Temperature Over Time in {country_name}' ) fig.update_traces(mode='lines', line=dict(color='cyan')) fig.update_layout( plot_bgcolor='#121212', paper_bgcolor='#121212', font_color='white', xaxis=dict(title='Date and Time', showgrid=False, color='white'), yaxis=dict(title='5-Year Moving Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white') ) logger.info("Line chart created.") return fig

    def create_choropleth_map(full_df): map_df = full_df.reset_index() map_df['Year'] = map_df['Date and Time'].dt.year avg_temp_df = map_df.groupby(['Country', 'Year'])['AverageTemperature'].mean().reset_index()

    fig = px.choropleth(
        avg_temp_df,
        locations='Country',
        locationmode='country names',
        color='AverageTemperature',
        hover_name='Country',
        animation_frame='Year',
        color_continuous_scale='Viridis',
        title='Global Average Temperature by Country Over Time',
        labels={'AverageTemperature': 'Avg Temp (°C)'}
    )
    fig.update_layout(
        plot_bgcolor='#121212',
        paper_bgcolor='#121212',
        font_color='white',
        coloraxis_colorbar=dict(title='Avg Temp (°C)')
    )
    logger.info("Choropleth map created.")
    return fig
    

    def create_app_layout(df): return html.Div([ # Header with integrated controls html.Div([ html.H1("Global Land Temperature Dashboard", style={ 'textAlign': 'center', 'color': 'white', 'marginBottom': '10px' }), html.Div([ html.Label("Select a Country:", style={ 'color': 'white', 'fontSize': '18px', 'textAlign': 'center', 'marginBottom': '10px' }), dcc.Dropdown( id='country-dropdown', options=[{'label': country, 'value': country} for country in sorted(df['Country'].unique())], value='Latvia', placeholder="Select a country", style={ 'width': '300px', 'minWidth': '200px', 'margin': '0 auto' } ) ], style={ 'display': 'flex', 'flexDirection': 'column', 'alignItems': 'center', 'marginBottom': '30px' }), ], style={ 'backgroundColor': '#1e1e1e', 'padding': '20px 0' }),

        # Visualization Section: Data Table and Box Plot
        html.Div([
            html.Div([
                # Data Table
                html.Div([
                    html.H3("Data Table", style={
                        'color': 'white',
                        'textAlign': 'center',
                        'marginBottom': '10px'
                    }),
                    dash_table.DataTable(
                        id='data-table',
                        page_size=10,
                        style_data_conditional=[
                            {
                                'if': {'row_index': 'odd'},
                                'backgroundColor': '#2c2c2c'
                            }
                        ],
                        style_cell={
                            'minWidth': '150px', 'maxWidth': '150px', 'width': '150px',
                            'backgroundColor': '#333',
                            'color': 'white',
                            'border': '1px solid #444',
                            'textAlign': 'center'
                        },
                        style_header={
                            'backgroundColor': '#444',
                            'color': 'white',
                            'border': '1px solid #555',
                            'fontWeight': 'bold'
                        },
                    )
                ], style={
                    'flex': '1',
                    'padding': '10px'
                }),
    
                # Box Plot
                html.Div([
                    html.H3("Temperature Distribution by Year", style={
                        'color': 'white',
                        'textAlign': 'center',
                        'marginBottom': '10px'
                    }),
                    dcc.Graph(id='box-plot')
                ], style={
                    'flex': '1',
                    'padding': '10px'
                })
            ], style={
                'display': 'flex',
                'flexWrap': 'wrap',
                'justifyContent': 'center',
                'marginBottom': '30px'
            }),
    
            # Charts Section: Bar Chart and Line Chart
            html.Div([
                html.Div([
                    # Bar Chart
                    html.Div([
                        html.H3("Average Temperature Over Time", style={
                            'color': 'white',
                            'textAlign': 'center',
                            'marginBottom': '10px'
                        }),
                        dcc.Graph(id='bar-chart')
                    ], style={
                        'flex': '1',
                        'padding': '10px'
                    }),
    
                    # Line Chart
                    html.Div([
                        html.H3("5-Year Moving Average Temperature", style={
                            'color': 'white',
                            'textAlign': 'center',
                            'marginBottom': '10px'
                        }),
                        dcc.Graph(id='line-chart')
                    ], style={
                        'flex': '1',
                        'padding': '10px'
                    })
                ], style={
                    'display': 'flex',
                    'flexWrap': 'wrap',
                    'justifyContent': 'center',
                    'marginBottom': '30px'
                }),
            ]),
        ]),
    
        # Geographical Visualization: Choropleth Map
        html.Div([
            html.H3("Global Temperature Trends", style={
                'color': 'white',
                'textAlign': 'center',
                'marginBottom': '10px'
            }),
            dcc.Graph(id='choropleth-map', style={'width': '100%', 'height': '800px'})
        ], style={
            'padding': '10px',
            'marginBottom': '30px'
        }),
    
    ], style={
        'backgroundColor': '#121212',
        'padding': '20px',
        'fontFamily': 'Arial, sans-serif'
    })
    

    def create_dashboard_callbacks(app, df): @app.callback( [Output('data-table', 'data'), Output('line-chart', 'figure'), Output('bar-chart', 'figure'), Output('box-plot', 'figure'), Output('choropleth-map', 'figure')], [Input('country-dropdown', 'value')] ) def update_dashboard(selected_country): if not selected_country: logger.warning("No country selected. Dashboard not updated.") raise PreventUpdate

        filtered_df = df[df['Country'] == selected_country].copy()
        if filtered_df.empty:
            logger.warning(f"No data available for country: {selected_country}")
            return [], {}, {}, {}, {}
    
        try:
            country_filtered_df = filter_country_data(filtered_df)
            country_moving_avg = calculate_moving_average(country_filtered_df)
        except Exception as error:
            logger.error(f"Error processing data for {selected_country}: {error}")
            return [], {}, {}, {}, {}
    
        # Replace NaN in 'MovingAverage' with 'NaN' string
        table_data = country_moving_avg.reset_index().fillna('NaN').to_dict('records')
    
        try:
            line_fig = create_line_chart(country_moving_avg, selected_country)
            bar_fig = create_bar_chart(filtered_df)
            box_fig = create_box_plot(filtered_df)
            choropleth_fig = create_choropleth_map(df)
        except Exception as error:
            logger.error(f"Error creating figures: {error}")
            line_fig, bar_fig, box_fig, choropleth_fig = {}, {}, {}, {}
    
        return table_data, line_fig, bar_fig, box_fig, choropleth_fig
    

    def create_choropleth_map(full_df): map_df = full_df.reset_index() map_df['Year'] = map_df['Date and Time'].dt.year avg_temp_df = map_df.groupby(['Country', 'Year'])['AverageTemperature'].mean().reset_index()

    choropleth_fig = px.choropleth(
        avg_temp_df,
        locations='Country',
        locationmode='country names',
        color='AverageTemperature',
        hover_name='Country',
        animation_frame='Year',
        color_continuous_scale='Viridis',
        title='Global Average Temperature by Country Over Time',
        labels={'AverageTemperature': 'Avg Temp (°C)'}
    )
    choropleth_fig.update_layout(
        plot_bgcolor='#121212',
        paper_bgcolor='#121212',
        font_color='white',
        coloraxis_colorbar=dict(title='Avg Temp (°C)')
    )
    logger.info("Choropleth map created.")
    return choropleth_fig
    

    if name == 'main': DATA_FILE_PATH = 'assets/GlobalLandTemperaturesByCountry.csv' try: df = load_data(DATA_FILE_PATH) except Exception as error: logger.critical(f"Application terminated: {error}") exit(1)

    app = Dash(__name__)
    app.layout = create_app_layout(df)
    create_dashboard_callbacks(app, df)
    app.run_server(debug=True)
    
  2. Assistant

    To implement API usage for fetching data in your Dash application, you'll need to replace or supplement the existing CSV data loading mechanism with API calls. This can provide more flexibility, real-time data updates, and scalability. Below is a step-by-step guide to help you integrate API-based data fetching into your application.

    Overview

    1. Choose an API: Identify a suitable API that provides the necessary temperature data. For demonstration purposes, I'll assume you have access to an API endpoint that returns temperature data in JSON format with the following fields:

      • dt (Date and Time)
      • Country
      • AverageTemperature
    2. Install Required Libraries: Ensure you have the requests library installed to make HTTP requests.

    3. Implement API Data Fetching: Create a function to fetch data from the API.

    4. Modify Existing Functions: Adapt your existing data processing functions to handle the data fetched from the API.

    5. Handle Caching and Rate Limiting: Implement caching to minimize API calls and handle potential rate limits.

    6. Update the Dash Application: Integrate the new data-fetching mechanism into your Dash app.

    Let's go through each of these steps in detail.


    1. Choose an API

    For this example, let's assume you have an API endpoint at https://api.example.com/global-temperatures that returns data in the following JSON format:

    {
        "data": [
            {
                "dt": "2020-01-01",
                "Country": "Latvia",
                "AverageTemperature": 5.3
            },
            ...
        ]
    }
    

    If you don't have an existing API, you might consider setting one up using frameworks like Flask or FastAPI, or using cloud services that provide data APIs.


    2. Install Required Libraries

    Ensure that the requests library is installed. You can install it using pip if you haven't already:

    pip install requests
    

    3. Implement API Data Fetching

    Create a new function fetch_data_from_api that retrieves data from the API. Incorporate error handling and logging for robustness.

    import requests
    
    def fetch_data_from_api(api_url, params=None, headers=None):
        """
        Fetch data from the specified API endpoint.
        
        :param api_url: str - The API endpoint URL.
        :param params: dict - Query parameters for the API request.
        :param headers: dict - Headers for the API request.
        :return: pd.DataFrame - DataFrame containing the fetched data.
        """
        try:
            logger.info(f"Fetching data from API: {api_url}")
            response = requests.get(api_url, params=params, headers=headers, timeout=10)
            response.raise_for_status()  # Raise an error for bad status codes
            data = response.json()
            logger.info("Data fetched successfully from API.")
    
            # Assuming the API returns a JSON object with a 'data' key
            df = pd.DataFrame(data.get('data', []))
            
            # Ensure the required columns are present
            required_cols = ['dt', 'Country', 'AverageTemperature']
            if not all(col in df.columns for col in required_cols):
                missing = set(required_cols) - set(df.columns)
                logger.error(f"Missing columns in API response: {missing}")
                raise ValueError(f"Missing columns in API response: {missing}")
            
            # Parse dates
            df['dt'] = pd.to_datetime(df['dt'])
    
            logger.info("API data converted to DataFrame successfully.")
            return df
    
        except requests.exceptions.HTTPError as http_err:
            logger.error(f"HTTP error occurred: {http_err}")
            raise
        except requests.exceptions.ConnectionError as conn_err:
            logger.error(f"Connection error occurred: {conn_err}")
            raise
        except requests.exceptions.Timeout as timeout_err:
            logger.error(f"Timeout error occurred: {timeout_err}")
            raise
        except requests.exceptions.RequestException as req_err:
            logger.error(f"Request exception: {req_err}")
            raise
        except ValueError as val_err:
            logger.error(f"Value error: {val_err}")
            raise
        except Exception as err:
            logger.error(f"An unexpected error occurred: {err}")
            raise
    

    4. Modify Existing Functions

    Update your data loading logic to use the API instead of the CSV file. You can provide an option to switch between CSV and API based on your preference.

    Update Configuration

    Add configuration variables for the API endpoint and any necessary parameters.

    API_URL = 'https://api.example.com/global-temperatures'  # Replace with your actual API URL
    USE_API = True  # Set to False to use CSV file instead
    API_PARAMS = {  # Add any query parameters if needed
        # 'key': 'your_api_key',
        # 'other_param': 'value'
    }
    API_HEADERS = {  # Add headers if required, e.g., authentication
        # 'Authorization': 'Bearer your_token',
    }
    

    Update the Data Loading Function

    Modify load_data to handle both CSV and API data sources.

    def load_data(source='csv'):
        """
        Load data from a CSV file or an API.
    
        :param source: str - 'csv' to load from CSV file, 'api' to load from API.
        :return: pd.DataFrame - Loaded and processed DataFrame.
        """
        if source == 'api' and USE_API:
            logger.info("Loading data from API.")
            df = fetch_data_from_api(API_URL, params=API_PARAMS, headers=API_HEADERS)
        else:
            logger.info(f"Loading data from CSV file: {DATA_FILE_PATH}")
            if not os.path.exists(DATA_FILE_PATH):
                logger.error(f"The file {DATA_FILE_PATH} does not exist.")
                raise FileNotFoundError(f"The file {DATA_FILE_PATH} does not exist.")
    
            columns_to_use = ['dt', 'Country', 'AverageTemperature']
            try:
                df = pd.read_csv(DATA_FILE_PATH, usecols=columns_to_use, parse_dates=['dt'])
                logger.info("CSV file loaded successfully.")
            except ValueError as error:
                logger.error(f"Error reading the CSV file: {error}")
                raise ValueError(f"Error reading the file: {error}")
    
        # Ensure required columns
        required_cols = {'dt', 'Country', 'AverageTemperature'}
        if not required_cols.issubset(df.columns):
            missing = required_cols - set(df.columns)
            logger.error(f"The required columns are missing: {missing}")
            raise ValueError(f"The required columns are missing: {missing}")
    
        df.rename(columns={'dt': 'Date and Time'}, inplace=True)
        logger.info("Column 'dt' renamed to 'Date and Time'.")
    
        initial_row_count = df.shape[0]
        df.dropna(subset=['AverageTemperature'], inplace=True)
        final_row_count = df.shape[0]
        logger.info(f"Dropped {initial_row_count - final_row_count} rows with NaN 'AverageTemperature'.")
    
        return df
    

    Update the Main Block

    Adjust the main execution block to specify the data source.

    if __name__ == '__main__':
        DATA_FILE_PATH = 'assets/GlobalLandTemperaturesByCountry.csv'
        DATA_SOURCE = 'api' if USE_API else 'csv'
        
        try:
            df = load_data(source=DATA_SOURCE)
        except Exception as error:
            logger.critical(f"Application terminated: {error}")
            exit(1)
    
        app = Dash(__name__)
        app.layout = create_app_layout(df)
        create_dashboard_callbacks(app, df)
        app.run_server(debug=True)
    

    5. Handle Caching and Rate Limiting

    Fetching data from an API can introduce latency and may be subject to rate limits. To mitigate this, implement caching to store the fetched data locally or in memory, reducing the number of API calls.

    Using functools.lru_cache for Simple Caching

    You can use Python’s functools.lru_cache decorator to cache API responses.

    from functools import lru_cache
    
    @lru_cache(maxsize=1)
    def get_cached_data():
        """
        Retrieve cached data from the API. The cache updates if the underlying data changes.
        """
        return load_data(source='api')
    

    Using External Caching Solutions

    For more robust caching, consider using solutions like Redis or integrating caching mechanisms within Dash callbacks using dcc.Store.

    Here's an example using dcc.Store to cache data on the client-side:

    def create_app_layout(df):
        return html.Div([
            dcc.Store(id='cached-data', data=df.to_dict('records')),  # Initial cache
            # ... rest of your layout
        ])
    

    And update the callbacks to utilize cached-data:

    def create_dashboard_callbacks(app, df):
        @app.callback(
            Output('cached-data', 'data'),
            [Input('country-dropdown', 'value')],
            prevent_initial_call=True
        )
        def update_cache(selected_country):
            if not selected_country:
                raise PreventUpdate
            # Optionally fetch new data based on the selected country
            return df[df['Country'] == selected_country].to_dict('records')
    
        @app.callback(
            [Output('data-table', 'data'),
             Output('line-chart', 'figure'),
             Output('bar-chart', 'figure'),
             Output('box-plot', 'figure'),
             Output('choropleth-map', 'figure')],
            [Input('cached-data', 'data')]
        )
        def update_dashboard(cached_data):
            if not cached_data:
                logger.warning("No data available in cache.")
                raise PreventUpdate
    
            filtered_df = pd.DataFrame(cached_data)
            if filtered_df.empty:
                logger.warning("Filtered data is empty.")
                return [], {}, {}, {}, {}
    
            try:
                country_filtered_df = filter_country_data(filtered_df)
                country_moving_avg = calculate_moving_average(country_filtered_df)
            except Exception as error:
                logger.error(f"Error processing data: {error}")
                return [], {}, {}, {}, {}
    
            table_data = country_moving_avg.reset_index().fillna('NaN').to_dict('records')
            try:
                line_fig = create_line_chart(country_moving_avg, selected_country)
                bar_fig = create_bar_chart(filtered_df)
                box_fig = create_box_plot(filtered_df)
                choropleth_fig = create_choropleth_map(df)
            except Exception as error:
                logger.error(f"Error creating figures: {error}")
                line_fig, bar_fig, box_fig, choropleth_fig = {}, {}, {}, {}
    
            return table_data, line_fig, bar_fig, box_fig, choropleth_fig
    

    Note: The above example demonstrates simple client-side caching. Depending on your application's complexity and requirements, you might need more advanced caching strategies.


    6. Update the Dash Application

    Ensure that all parts of your Dash application are compatible with the new data-fetching mechanism. Here's the complete modified code incorporating API data fetching:

    import pandas as pd
    import logging
    import os
    import requests
    from dash import Dash, html, dash_table, dcc
    import plotly.express as px
    from dash.dependencies import Input, Output
    from dash.exceptions import PreventUpdate
    from functools import lru_cache
    
    # Configure logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)
    
    # Configuration
    API_URL = 'https://api.example.com/global-temperatures'  # Replace with your actual API URL
    USE_API = True  # Set to False to use CSV file instead
    API_PARAMS = {}  # Add any query parameters if needed
    API_HEADERS = {}  # Add headers if required
    DATA_FILE_PATH = 'assets/GlobalLandTemperaturesByCountry.csv'
    
    def fetch_data_from_api(api_url, params=None, headers=None):
        try:
            logger.info(f"Fetching data from API: {api_url}")
            response = requests.get(api_url, params=params, headers=headers, timeout=10)
            response.raise_for_status()
            data = response.json()
            logger.info("Data fetched successfully from API.")
    
            df = pd.DataFrame(data.get('data', []))
            required_cols = ['dt', 'Country', 'AverageTemperature']
            if not all(col in df.columns for col in required_cols):
                missing = set(required_cols) - set(df.columns)
                logger.error(f"Missing columns in API response: {missing}")
                raise ValueError(f"Missing columns in API response: {missing}")
    
            df['dt'] = pd.to_datetime(df['dt'])
            logger.info("API data converted to DataFrame successfully.")
            return df
    
        except requests.exceptions.HTTPError as http_err:
            logger.error(f"HTTP error occurred: {http_err}")
            raise
        except requests.exceptions.ConnectionError as conn_err:
            logger.error(f"Connection error occurred: {conn_err}")
            raise
        except requests.exceptions.Timeout as timeout_err:
            logger.error(f"Timeout error occurred: {timeout_err}")
            raise
        except requests.exceptions.RequestException as req_err:
            logger.error(f"Request exception: {req_err}")
            raise
        except ValueError as val_err:
            logger.error(f"Value error: {val_err}")
            raise
        except Exception as err:
            logger.error(f"An unexpected error occurred: {err}")
            raise
    
    def load_data(source='csv'):
        if source == 'api' and USE_API:
            logger.info("Loading data from API.")
            df = fetch_data_from_api(API_URL, params=API_PARAMS, headers=API_HEADERS)
        else:
            logger.info(f"Loading data from CSV file: {DATA_FILE_PATH}")
            if not os.path.exists(DATA_FILE_PATH):
                logger.error(f"The file {DATA_FILE_PATH} does not exist.")
                raise FileNotFoundError(f"The file {DATA_FILE_PATH} does not exist.")
    
            columns_to_use = ['dt', 'Country', 'AverageTemperature']
            try:
                df = pd.read_csv(DATA_FILE_PATH, usecols=columns_to_use, parse_dates=['dt'])
                logger.info("CSV file loaded successfully.")
            except ValueError as error:
                logger.error(f"Error reading the CSV file: {error}")
                raise ValueError(f"Error reading the file: {error}")
    
        required_cols = {'dt', 'Country', 'AverageTemperature'}
        if not required_cols.issubset(df.columns):
            missing = required_cols - set(df.columns)
            logger.error(f"The required columns are missing: {missing}")
            raise ValueError(f"The required columns are missing: {missing}")
    
        df.rename(columns={'dt': 'Date and Time'}, inplace=True)
        logger.info("Column 'dt' renamed to 'Date and Time'.")
    
        initial_row_count = df.shape[0]
        df.dropna(subset=['AverageTemperature'], inplace=True)
        final_row_count = df.shape[0]
        logger.info(f"Dropped {initial_row_count - final_row_count} rows with NaN 'AverageTemperature'.")
    
        return df
    
    def filter_country_data(country_df):
        country_df.set_index('Date and Time', inplace=True)
        country_df.sort_index(inplace=True)
        logger.info("DataFrame filtered by country and indexed by 'Date and Time'.")
        return country_df
    
    def calculate_moving_average(country_df, window_size=5):
        numeric_cols = country_df.select_dtypes(include='number').columns.tolist()
        logger.debug(f"Numeric columns selected for aggregation: {numeric_cols}")
    
        if 'AverageTemperature' not in numeric_cols:
            logger.error("The 'AverageTemperature' column is missing or non-numeric.")
            raise ValueError("The 'AverageTemperature' column is missing or non-numeric.")
    
        try:
            # Resample data to 5-year intervals
            resampled_df = country_df[numeric_cols].resample('5Y').mean()
            logger.info("Data resampled to 5-year intervals.")
        except Exception as error:
            logger.error(f"Error during resampling: {error}")
            raise ValueError(f"Error during resampling: {error}")
    
        # Calculate moving average
        resampled_df['MovingAverage'] = resampled_df['AverageTemperature'].rolling(window=window_size).mean()
        logger.info(f"5-year moving average calculated with window size {window_size}.")
    
        return resampled_df
    
    def create_bar_chart(bar_df):
        bar_df_reset = bar_df.reset_index()
        fig = px.bar(
            bar_df_reset,
            x='Date and Time',
            y='AverageTemperature',
            title='Average Temperature Over Time'
        )
        fig.update_layout(
            plot_bgcolor='#121212',
            paper_bgcolor='#121212',
            font_color='white',
            xaxis=dict(title='Date and Time', showgrid=False, color='white'),
            yaxis=dict(title='Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white')
        )
        logger.info("Bar chart created.")
        return fig
    
    def create_box_plot(box_df):
        box_df_reset = box_df.reset_index()
        box_df_reset['Year'] = box_df_reset['Date and Time'].dt.year
    
        fig = px.box(
            box_df_reset,
            x='Year',
            y='AverageTemperature',
            title='Temperature Distribution by Year',
            points='outliers'
        )
        fig.update_layout(
            plot_bgcolor='#121212',
            paper_bgcolor='#121212',
            font_color='white',
            xaxis=dict(title='Year', showgrid=False, color='white'),
            yaxis=dict(title='Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white')
        )
        logger.info("Box plot created.")
        return fig
    
    def create_line_chart(line_df, country_name):
        line_df_reset = line_df.reset_index()
        fig = px.line(
            line_df_reset,
            x='Date and Time',
            y='MovingAverage',
            title=f'5-Year Moving Average Temperature Over Time in {country_name}'
        )
        fig.update_traces(mode='lines', line=dict(color='cyan'))
        fig.update_layout(
            plot_bgcolor='#121212',
            paper_bgcolor='#121212',
            font_color='white',
            xaxis=dict(title='Date and Time', showgrid=False, color='white'),
            yaxis=dict(title='5-Year Moving Average Temperature (°C)', showgrid=True, gridcolor='#333', color='white')
        )
        logger.info("Line chart created.")
        return fig
    
    def create_choropleth_map(full_df):
        map_df = full_df.reset_index()
        map_df['Year'] = map_df['Date and Time'].dt.year
        avg_temp_df = map_df.groupby(['Country', 'Year'])['AverageTemperature'].mean().reset_index()
    
        fig = px.choropleth(
            avg_temp_df,
            locations='Country',
            locationmode='country names',
            color='AverageTemperature',
            hover_name='Country',
            animation_frame='Year',
            color_continuous_scale='Viridis',
            title='Global Average Temperature by Country Over Time',
            labels={'AverageTemperature': 'Avg Temp (°C)'}
        )
        fig.update_layout(
            plot_bgcolor='#121212',
            paper_bgcolor='#121212',
            font_color='white',
            coloraxis_colorbar=dict(title='Avg Temp (°C)')
        )
        logger.info("Choropleth map created.")
        return fig
    
    def create_app_layout(df):
        return html.Div([
            # Header with integrated controls
            html.Div([
                html.H1("Global Land Temperature Dashboard", style={
                    'textAlign': 'center',
                    'color': 'white',
                    'marginBottom': '10px'
                }),
                html.Div([
                    html.Label("Select a Country:", style={
                        'color': 'white',
                        'fontSize': '18px',
                        'textAlign': 'center',
                        'marginBottom': '10px'
                    }),
                    dcc.Dropdown(
                        id='country-dropdown',
                        options=[{'label': country, 'value': country} for country in sorted(df['Country'].unique())],
                        value='Latvia',
                        placeholder="Select a country",
                        style={
                            'width': '300px',
                            'minWidth': '200px',
                            'margin': '0 auto'
                        }
                    )
                ], style={
                    'display': 'flex',
                    'flexDirection': 'column',
                    'alignItems': 'center',
                    'marginBottom': '30px'
                }),
            ], style={
                'backgroundColor': '#1e1e1e',
                'padding': '20px 0'
            }),
    
            # Visualization Section: Data Table and Box Plot
            html.Div([
                html.Div([
                    # Data Table
                    html.Div([
                        html.H3("Data Table", style={
                            'color': 'white',
                            'textAlign': 'center',
                            'marginBottom': '10px'
                        }),
                        dash_table.DataTable(
                            id='data-table',
                            page_size=10,
                            style_data_conditional=[
                                {
                                    'if': {'row_index': 'odd'},
                                    'backgroundColor': '#2c2c2c'
                                }
                            ],
                            style_cell={
                                'minWidth': '150px', 'maxWidth': '150px', 'width': '150px',
                                'backgroundColor': '#333',
                                'color': 'white',
                                'border': '1px solid #444',
                                'textAlign': 'center'
                            },
                            style_header={
                                'backgroundColor': '#444',
                                'color': 'white',
                                'border': '1px solid #555',
                                'fontWeight': 'bold'
                            },
                        )
                    ], style={
                        'flex': '1',
                        'padding': '10px'
                    }),
    
                    # Box Plot
                    html.Div([
                        html.H3("Temperature Distribution by Year", style={
                            'color': 'white',
                            'textAlign': 'center',
                            'marginBottom': '10px'
                        }),
                        dcc.Graph(id='box-plot')
                    ], style={
                        'flex': '1',
                        'padding': '10px'
                    })
                ], style={
                    'display': 'flex',
                    'flexWrap': 'wrap',
                    'justifyContent': 'center',
                    'marginBottom': '30px'
                }),
    
                # Charts Section: Bar Chart and Line Chart
                html.Div([
                    html.Div([
                        # Bar Chart
                        html.Div([
                            html.H3("Average Temperature Over Time", style={
                                'color': 'white',
                                'textAlign': 'center',
                                'marginBottom': '10px'
                            }),
                            dcc.Graph(id='bar-chart')
                        ], style={
                            'flex': '1',
                            'padding': '10px'
                        }),
    
                        # Line Chart
                        html.Div([
                            html.H3("5-Year Moving Average Temperature", style={
                                'color': 'white',
                                'textAlign': 'center',
                                'marginBottom': '10px'
                            }),
                            dcc.Graph(id='line-chart')
                        ], style={
                            'flex': '1',
                            'padding': '10px'
                        })
                    ], style={
                        'display': 'flex',
                        'flexWrap': 'wrap',
                        'justifyContent': 'center',
                        'marginBottom': '30px'
                    }),
                ]),
            ]),
    
            # Geographical Visualization: Choropleth Map
            html.Div([
                html.H3("Global Temperature Trends", style={
                    'color': 'white',
                    'textAlign': 'center',
                    'marginBottom': '10px'
                }),
                dcc.Graph(id='choropleth-map', style={'width': '100%', 'height': '800px'})
            ], style={
                'padding': '10px',
                'marginBottom': '30px'
            }),
    
        ], style={
            'backgroundColor': '#121212',
            'padding': '20px',
            'fontFamily': 'Arial, sans-serif'
        })
    
    def create_dashboard_callbacks(app, df):
        @app.callback(
            [Output('data-table', 'data'),
             Output('line-chart', 'figure'),
             Output('bar-chart', 'figure'),
             Output('box-plot', 'figure'),
             Output('choropleth-map', 'figure')],
            [Input('country-dropdown', 'value')]
        )
        def update_dashboard(selected_country):
            if not selected_country:
                logger.warning("No country selected. Dashboard not updated.")
                raise PreventUpdate
    
            filtered_df = df[df['Country'] == selected_country].copy()
            if filtered_df.empty:
                logger.warning(f"No data available for country: {selected_country}")
                return [], {}, {}, {}, {}
    
            try:
                country_filtered_df = filter_country_data(filtered_df)
                country_moving_avg = calculate_moving_average(country_filtered_df)
            except Exception as error:
                logger.error(f"Error processing data for {selected_country}: {error}")
                return [], {}, {}, {}, {}
    
            # Replace NaN in 'MovingAverage' with 'NaN' string
            table_data = country_moving_avg.reset_index().fillna('NaN').to_dict('records')
    
            try:
                line_fig = create_line_chart(country_moving_avg, selected_country)
                bar_fig = create_bar_chart(filtered_df)
                box_fig = create_box_plot(filtered_df)
                choropleth_fig = create_choropleth_map(df)
            except Exception as error:
                logger.error(f"Error creating figures: {error}")
                line_fig, bar_fig, box_fig, choropleth_fig = {}, {}, {}, {}
    
            return table_data, line_fig, bar_fig, box_fig, choropleth_fig
    
    if __name__ == '__main__':
        DATA_SOURCE = 'api' if USE_API else 'csv'
        
        try:
            df = load_data(source=DATA_SOURCE)
        except Exception as error:
            logger.critical(f"Application terminated: {error}")
            exit(1)
    
        app = Dash(__name__)
        app.layout = create_app_layout(df)
        create_dashboard_callbacks(app, df)
        app.run_server(debug=True)
    

    Additional Considerations

    1. API Authentication

    If your API requires authentication (e.g., API keys, tokens), ensure you include them in the API_HEADERS or API_PARAMS. For example:

    API_HEADERS = {
        'Authorization': 'Bearer YOUR_API_TOKEN'
    }
    

    2. Pagination Handling

    If the API paginates responses, you'll need to handle multiple pages. Modify the fetch_data_from_api function to iterate through pages until all data is fetched.

    def fetch_data_from_api(api_url, params=None, headers=None):
        all_data = []
        page = 1
        per_page = 100  # Adjust based on API's pagination
    
        try:
            while True:
                current_params = params.copy() if params else {}
                current_params.update({'page': page, 'per_page': per_page})
                logger.info(f"Fetching page {page} from API.")
                response = requests.get(api_url, params=current_params, headers=headers, timeout=10)
                response.raise_for_status()
                data = response.json()
                page_data = data.get('data', [])
                if not page_data:
                    break
                all_data.extend(page_data)
                page += 1
    
            df = pd.DataFrame(all_data)
            # ... continue processing as before
    

    3. Error Retries

    Implement retries for transient errors using libraries like tenacity.

    from tenacity import retry, stop_after_attempt, wait_fixed
    
    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
    def fetch_data_from_api(api_url, params=None, headers=None):
        # Existing implementation
    

    4. Asynchronous Requests

    For improved performance, especially when dealing with large datasets or multiple API calls, consider using asynchronous requests with aiohttp or similar libraries.


    Conclusion

    By following the steps outlined above, you can successfully integrate API-based data fetching into your Dash application. This approach enhances your app's flexibility, allowing it to leverage real-time data and potentially reduce dependency on static CSV files. Ensure you handle authentication, pagination, and caching appropriately based on your specific API's requirements to build a robust and efficient application.

    If you encounter specific issues or have additional requirements, feel free to ask for further assistance!