Update app.py via AI Editor

app.py

@@ -3,19 +3,51 @@ from dash import dcc, html, Input, Output, State, clientside_callback
 import dash_bootstrap_components as dbc
 import plotly.graph_objs as go
 import requests
-import pandas as pd
 from datetime import datetime
 import os
 from dotenv import load_dotenv
 import threading
 import json
+import uuid
+import flask
+import logging
 
 # Load environment variables
 load_dotenv()
 
-# Initialize the Dash app
-app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
-server = app.server
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("weather_dash")
+
+# Session and threading management
+session_locks = {}
+session_data_store = {}
+SESSION_COOKIE = "weather_dash_session_id"
+
+def get_session_id():
+    ctx = flask.request.cookies.get(SESSION_COOKIE)
+    if not ctx:
+        ctx = str(uuid.uuid4())
+    return ctx
+
+def get_session_lock(session_id):
+    if session_id not in session_locks:
+        session_locks[session_id] = threading.Lock()
+    return session_locks[session_id]
+
+def get_session_data(session_id):
+    if session_id not in session_data_store:
+        session_data_store[session_id] = {}
+    return session_data_store[session_id]
+
+def save_session_data(session_id, key, value):
+    session_data = get_session_data(session_id)
+    session_data[key] = value
+    session_data_store[session_id] = session_data
+
+def get_data_from_session(session_id, key):
+    session_data = get_session_data(session_id)
+    return session_data.get(key, None)
 
 # AccuWeather API key
 API_KEY = os.getenv('ACCUWEATHER_API_KEY')
@@ -23,6 +55,9 @@ API_KEY = os.getenv('ACCUWEATHER_API_KEY')
 # Base URL for AccuWeather API
 BASE_URL = "http://dataservice.accuweather.com"
 
+# Health-related index keywords
+HEALTH_INDEX_KEYWORDS = ["Air Quality", "Asthma", "Flu", "Allergy", "Respiratory", "Pollen"]
+
 def get_location_key(lat, lon):
     url = f"{BASE_URL}/locations/v1/cities/geoposition/search"
     params = {
@@ -37,7 +72,7 @@ def get_location_key(lat, lon):
             raise ValueError("Location key not found in API response")
         return data["Key"]
     except requests.RequestException as e:
-        print(f"Error in get_location_key: {e}")
+        logger.error(f"Error in get_location_key: {e}")
         return None
 
 def get_current_conditions(location_key):
@@ -56,7 +91,7 @@ def get_current_conditions(location_key):
             raise ValueError("No current conditions data in API response")
         return data[0]
     except requests.RequestException as e:
-        print(f"Error in get_current_conditions: {e}")
+        logger.error(f"Error in get_current_conditions: {e}")
         return None
 
 def get_forecast(location_key):
@@ -65,14 +100,30 @@ def get_forecast(location_key):
     url = f"{BASE_URL}/forecasts/v1/daily/5day/{location_key}"
     params = {
         "apikey": API_KEY,
-        "metric": "true",
+        "metric": "false",  # Fahrenheit
+    }
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e:
+        logger.error(f"Error in get_forecast: {e}")
+        return None
+
+def get_hourly_forecast(location_key):
+    if location_key is None:
+        return None
+    url = f"{BASE_URL}/forecasts/v1/hourly/12hour/{location_key}"
+    params = {
+        "apikey": API_KEY,
+        "metric": "false",  # Fahrenheit
     }
     try:
         response = requests.get(url, params=params)
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e:
-        print(f"Error in get_forecast: {e}")
+        logger.error(f"Error in get_hourly_forecast: {e}")
         return None
 
 def get_indices(location_key):
@@ -87,7 +138,7 @@ def get_indices(location_key):
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e:
-        print(f"Error in get_indices: {e}")
+        logger.error(f"Error in get_indices: {e}")
         return None
 
 def get_alerts(location_key):
@@ -102,41 +153,64 @@ def get_alerts(location_key):
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e:
-        print(f"Error in get_alerts: {e}")
+        logger.error(f"Error in get_alerts: {e}")
         return None
 
 def create_current_weather_card(current):
     return dbc.Card([
         dbc.CardBody([
             html.H4("Current Weather", className="card-title"),
-            html.P(f"Temperature: {current['Temperature']['Metric']['Value']}°C"),
+            html.P(f"Temperature: {current['Temperature']['Imperial']['Value']}°F"),
             html.P(f"Condition: {current['WeatherText']}"),
-            html.P(f"Feels Like: {current['RealFeelTemperature']['Metric']['Value']}°C"),
-            html.P(f"Wind: {current['Wind']['Speed']['Metric']['Value']} km/h"),
+            html.P(f"Feels Like: {current['RealFeelTemperature']['Imperial']['Value']}°F"),
+            html.P(f"Wind: {current['Wind']['Speed']['Imperial']['Value']} mph"),
             html.P(f"Humidity: {current['RelativeHumidity']}%"),
         ])
     ], className="mb-4")
 
+def create_hourly_forecast_card(hourly):
+    if not hourly:
+        return dbc.Card([
+            dbc.CardBody([
+                html.H4("12-Hour Hourly Forecast", className="card-title"),
+                html.P("No hourly forecast available")
+            ])
+        ], className="mb-4")
+    hours = [datetime.strptime(hr['DateTime'], "%Y-%m-%dT%H:%M:%S%z").strftime("%I %p") for hr in hourly]
+    temps = [hr['Temperature']['Value'] for hr in hourly]
+    conditions = [hr['IconPhrase'] for hr in hourly]
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=hours, y=temps, name="Temperature", line=dict(color="orange")))
+    fig.update_layout(
+        title="Next 12 Hours Forecast",
+        xaxis_title="Time",
+        yaxis_title="Temperature (°F)",
+        legend_title="Legend",
+        height=350,
+        margin=dict(l=40, r=40, t=40, b=40)
+    )
+    return dbc.Card([
+        dbc.CardBody([
+            html.H4("12-Hour Hourly Forecast", className="card-title"),
+            dcc.Graph(figure=fig)
+        ])
+    ], className="mb-4")
+
 def create_forecast_card(forecast):
     daily_forecasts = forecast['DailyForecasts']
-    
     fig = go.Figure()
-    
     dates = [datetime.strptime(day['Date'], "%Y-%m-%dT%H:%M:%S%z").strftime("%m-%d") for day in daily_forecasts]
     max_temps = [day['Temperature']['Maximum']['Value'] for day in daily_forecasts]
     min_temps = [day['Temperature']['Minimum']['Value'] for day in daily_forecasts]
-    
     fig.add_trace(go.Scatter(x=dates, y=max_temps, name="Max Temp", line=dict(color="red")))
     fig.add_trace(go.Scatter(x=dates, y=min_temps, name="Min Temp", line=dict(color="blue")))
-    
     fig.update_layout(
         title="5-Day Temperature Forecast",
         xaxis_title="Date",
-        yaxis_title="Temperature (°C)",
+        yaxis_title="Temperature (°F)",
         legend_title="Temperature",
         height=400
     )
-    
     return dbc.Card([
         dbc.CardBody([
             html.H4("5-Day Forecast", className="card-title"),
@@ -145,12 +219,32 @@ def create_forecast_card(forecast):
     ], className="mb-4")
 
 def create_indices_card(indices):
+    if not indices:
+        return dbc.Card([
+            dbc.CardBody([
+                html.H4("Health Indices", className="card-title"),
+                html.P("No health indices available.")
+            ])
+        ], className="mb-4")
+    health_indices = []
+    for idx in indices:
+        for keyword in HEALTH_INDEX_KEYWORDS:
+            if keyword.lower() in idx['Name'].lower():
+                health_indices.append(idx)
+                break
+    if not health_indices:
+        return dbc.Card([
+            dbc.CardBody([
+                html.H4("Health Indices", className="card-title"),
+                html.P("No health-related indices available.")
+            ])
+        ], className="mb-4")
     return dbc.Card([
         dbc.CardBody([
-            html.H4("Weather Indices", className="card-title"),
+            html.H4("Health Indices", className="card-title"),
             html.Div([
                 html.P(f"{index['Name']}: {index['Category']}")
-                for index in indices[:5]  # Display first 5 indices
+                for index in health_indices[:5]
             ])
         ])
     ], className="mb-4")
@@ -158,7 +252,6 @@ def create_indices_card(indices):
 def create_alert_card(alerts):
     if not alerts:
         return html.Div()
-    
     return dbc.Card([
         dbc.CardBody([
             html.H4("Weather Alerts", className="card-title text-danger"),
@@ -170,28 +263,54 @@ def create_alert_card(alerts):
     ], className="mb-4")
 
 # App layout
+app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
+
 app.layout = dbc.Container([
+    dcc.Store(id="location-store", storage_type="session"),
+    dcc.Store(id="session-store", storage_type="session"),
+    dcc.Interval(id="location-interval", interval=1000, max_intervals=1),
     dbc.Row([
         dbc.Col([
             html.H1("Weather Dashboard", className="text-center mb-4"),
-            html.Div(id="loading-output"),
-            html.Div(id="alert-output"),
-            dbc.Row([
-                dbc.Col([
-                    html.Div(id="current-weather-output"),
-                ], width=6),
-                dbc.Col([
-                    html.Div(id="forecast-output"),
-                ], width=6),
-            ]),
-            html.Div(id="indices-output"),
         ], width=12)
     ]),
-    dcc.Store(id="location-store"),
-    dcc.Interval(id="location-interval", interval=1000, max_intervals=1),
-], fluid=True, className="mt-4")
+    dbc.Row([
+        dbc.Col([
+            dbc.Card([
+                dbc.CardBody([
+                    html.H5("Navigation", className="card-title"),
+                    dbc.Nav([
+                        dbc.NavLink("Health Indices", href="#", id="nav-health"),
+                        dbc.NavLink("Current Weather", href="#", id="nav-current"),
+                    ], vertical=True, pills=True)
+                ])
+            ], className="mb-4"),
+            dcc.Loading(
+                id="loading",
+                type="default",
+                children=[
+                    html.Div(id="indices-output"),
+                    html.Div(id="current-weather-output")
+                ],
+                style={"width": "100%"}
+            )
+        ], width=4, style={"minWidth": "260px"}),
+        dbc.Col([
+            dcc.Loading(
+                id="loading-forecast",
+                type="default",
+                children=[
+                    html.Div(id="hourly-forecast-output"),
+                    html.Div(id="forecast-output"),
+                    html.Div(id="alert-output")
+                ],
+                style={"width": "100%"}
+            )
+        ], width=8)
+    ], style={"marginTop": "16px"})
+], fluid=True, className="mt-2")
 
-# Clientside callback to get user's location
 clientside_callback(
     """
     function(n_intervals) {
@@ -218,65 +337,88 @@ clientside_callback(
     Input("location-interval", "n_intervals"),
 )
 
+@app.server.after_request
+def set_session_cookie(response):
+    session_id = flask.request.cookies.get(SESSION_COOKIE)
+    if not session_id:
+        session_id = str(uuid.uuid4())
+        response.set_cookie(SESSION_COOKIE, session_id, max_age=60*60*24*7, path="/")
+    return response
+
 @app.callback(
-    [Output("loading-output", "children"),
-     Output("current-weather-output", "children"),
-     Output("forecast-output", "children"),
-     Output("indices-output", "children"),
-     Output("alert-output", "children")],
-    Input("location-store", "data")
+    [
+        Output("indices-output", "children"),
+        Output("current-weather-output", "children"),
+        Output("hourly-forecast-output", "children"),
+        Output("forecast-output", "children"),
+        Output("alert-output", "children"),
+    ],
+    [Input("location-store", "data")],
+    [State("session-store", "data")]
 )
-def update_weather(location):
+def update_weather(location, session_data):
+    session_id = get_session_id()
+    lock = get_session_lock(session_id)
+    logger.info(f"Session {session_id} update_weather called.")
     if not location or 'error' in location:
         error_message = location.get('error', 'Waiting for location data...') if location else 'Waiting for location data...'
-        return error_message, "", "", "", ""
+        logger.warning(f"Session {session_id} waiting for location: {error_message}")
+        return [dbc.Spinner(color="primary"), "", "", "", ""]
 
     lat, lon = location["latitude"], location["longitude"]
-    
-    loading_output = html.Div([
-        html.P("Loading weather data...", className="text-center"),
-        dbc.Spinner(color="primary", type="grow"),
-    ])
-
+    results = {"indices": "", "current": "", "hourly": "", "forecast": "", "alerts": ""}
     def fetch_weather_data():
         try:
-            location_key = get_location_key(lat, lon)
-            if location_key is None:
+            location_key = get_data_from_session(session_id, "location_key")
+            if not location_key:
+                location_key = get_location_key(lat, lon)
+                save_session_data(session_id, "location_key", location_key)
+            if not location_key:
                 raise ValueError("Failed to get location key")
 
             current = get_current_conditions(location_key)
             forecast = get_forecast(location_key)
+            hourly = get_hourly_forecast(location_key)
             indices = get_indices(location_key)
             alerts = get_alerts(location_key)
 
             if current is None or forecast is None or indices is None:
                 raise ValueError("Failed to fetch weather data")
 
-            current_weather = create_current_weather_card(current)
-            forecast_output = create_forecast_card(forecast)
-            indices_output = create_indices_card(indices)
-            alert_output = create_alert_card(alerts)
-
-            return current_weather, forecast_output, indices_output, alert_output
-
+            results["indices"] = create_indices_card(indices)
+            results["current"] = create_current_weather_card(current)
+            results["hourly"] = create_hourly_forecast_card(hourly)
+            results["forecast"] = create_forecast_card(forecast)
+            results["alerts"] = create_alert_card(alerts)
+            save_session_data(session_id, "weather_results", results)
         except Exception as e:
-            error_message = f"Error fetching weather data: {str(e)}"
-            print(error_message)  # Log the error
-            return "", "", "", html.Div(error_message, className="text-danger")
-
-    # Use threading to fetch data asynchronously
-    thread = threading.Thread(target=fetch_weather_data)
-    thread.start()
-    thread.join(timeout=10)  # Wait for up to 10 seconds
+            logger.error(f"Session {session_id} error: {str(e)}")
+            results["indices"] = ""
+            results["current"] = ""
+            results["hourly"] = ""
+            results["forecast"] = ""
+            results["alerts"] = dbc.Card([
+                dbc.CardBody([
+                    html.P(f"Error fetching weather data: {str(e)}", className="text-danger")
+                ])
+            ], className="mb-4")
 
-    if thread.is_alive():
-        error_message = "Weather data fetch timed out. Please try again."
-        return html.Div(error_message, className="text-warning"), "", "", "", ""
+    with lock:
+        fetch_weather_data()
 
-    current_weather, forecast_output, indices_output, alert_output = fetch_weather_data()
-    return "", current_weather, forecast_output, indices_output, alert_output
+    weather_results = get_data_from_session(session_id, "weather_results")
+    if weather_results:
+        return [
+            weather_results.get("indices", ""),
+            weather_results.get("current", ""),
+            weather_results.get("hourly", ""),
+            weather_results.get("forecast", ""),
+            weather_results.get("alerts", ""),
+        ]
+    else:
+        return [dbc.Spinner(color="primary"), "", "", "", ""]
 
 if __name__ == '__main__':
     print("Starting the Dash application...")
-    app.run(debug=True, host='0.0.0.0', port=7860)
+    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)
     print("Dash application has finished running.")