Update app.py via AI Editor

app.py

@@ -12,14 +12,11 @@ import uuid
 import flask
 import logging
 
-# Load environment variables
 load_dotenv()
 
-# 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"
@@ -49,14 +46,17 @@ 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')
-
-# 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"]
+# Index IDs from AccuWeather's documentation (example IDs, replace with actual as needed)
+INDEX_IDS = {
+    "Health": 31,          # e.g., Flu Index
+    "Environmental": 34,   # e.g., Air Quality Index
+    "Pollen": 11,          # e.g., Tree Pollen
+    "Mosquito": 50,        # e.g., Mosquito Index
+    "Pests": 53            # e.g., Pest Activity
+}
 
 def get_location_key(lat, lon):
     url = f"{BASE_URL}/locations/v1/cities/geoposition/search"
@@ -94,66 +94,66 @@ def get_current_conditions(location_key):
         logger.error(f"Error in get_current_conditions: {e}")
         return None
 
-def get_forecast(location_key):
+def get_forecast_5day(location_key):
     if location_key is None:
         return None
     url = f"{BASE_URL}/forecasts/v1/daily/5day/{location_key}"
     params = {
         "apikey": API_KEY,
-        "metric": "false",  # Fahrenheit
+        "metric": "false",
     }
     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}")
+        logger.error(f"Error in get_forecast_5day: {e}")
         return None
 
-def get_hourly_forecast(location_key):
+def get_forecast_1day(location_key):
     if location_key is None:
         return None
-    url = f"{BASE_URL}/forecasts/v1/hourly/12hour/{location_key}"
+    url = f"{BASE_URL}/forecasts/v1/daily/1day/{location_key}"
     params = {
         "apikey": API_KEY,
-        "metric": "false",  # Fahrenheit
+        "metric": "false",
     }
     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_hourly_forecast: {e}")
+        logger.error(f"Error in get_forecast_1day: {e}")
         return None
 
-def get_indices(location_key):
+def get_hourly_forecast_1hour(location_key):
     if location_key is None:
         return None
-    url = f"{BASE_URL}/indices/v1/daily/5day/{location_key}"
+    url = f"{BASE_URL}/forecasts/v1/hourly/1hour/{location_key}"
     params = {
         "apikey": API_KEY,
+        "metric": "false",
     }
     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_indices: {e}")
+        logger.error(f"Error in get_hourly_forecast_1hour: {e}")
         return None
 
-def get_alerts(location_key):
+def get_indices_1day(location_key, index_id):
     if location_key is None:
         return None
-    url = f"{BASE_URL}/alerts/v1/{location_key}"
-    params = {
-        "apikey": API_KEY,
-    }
+    url = f"{BASE_URL}/indices/v1/daily/1day/{location_key}/{index_id}"
+    params = {"apikey": API_KEY}
     try:
         response = requests.get(url, params=params)
         response.raise_for_status()
+        # returns a list with one dict per day (only 1 for 1day endpoint)
         return response.json()
     except requests.RequestException as e:
-        logger.error(f"Error in get_alerts: {e}")
+        logger.error(f"Error in get_indices_1day {index_id}: {e}")
         return None
 
 def create_current_weather_card(current):
@@ -168,40 +168,65 @@ def create_current_weather_card(current):
         ])
     ], className="mb-4")
 
-def create_hourly_forecast_card(hourly):
-    if not hourly:
+def create_hourly_1hour_card(hourly):
+    if not hourly or not isinstance(hourly, list):
         return dbc.Card([
             dbc.CardBody([
-                html.H4("12-Hour Hourly Forecast", className="card-title"),
-                html.P("No hourly forecast available")
+                html.H4("Next Hour Forecast", className="card-title"),
+                html.P("No 1-hour 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)
-    )
+    hr = hourly[0]
+    dt = datetime.strptime(hr['DateTime'], "%Y-%m-%dT%H:%M:%S%z").strftime("%I:%M %p")
+    temp = hr['Temperature']['Value']
+    phrase = hr['IconPhrase']
     return dbc.Card([
         dbc.CardBody([
-            html.H4("12-Hour Hourly Forecast", className="card-title"),
-            dcc.Graph(figure=fig)
+            html.H4("Next Hour Forecast", className="card-title"),
+            html.P(f"Time: {dt}"),
+            html.P(f"Temperature: {temp}°F"),
+            html.P(f"Condition: {phrase}")
+        ])
+    ], className="mb-4")
+
+def create_forecast_1day_card(forecast):
+    if not forecast or 'DailyForecasts' not in forecast or not forecast['DailyForecasts']:
+        return dbc.Card([
+            dbc.CardBody([
+                html.H4("1-Day Forecast", className="card-title"),
+                html.P("No 1-day forecast available.")
+            ])
+        ], className="mb-4")
+    day = forecast['DailyForecasts'][0]
+    date = datetime.strptime(day['Date'], "%Y-%m-%dT%H:%M:%S%z").strftime("%A, %m-%d")
+    max_temp = day['Temperature']['Maximum']['Value']
+    min_temp = day['Temperature']['Minimum']['Value']
+    day_phrase = day['Day']['IconPhrase']
+    night_phrase = day['Night']['IconPhrase']
+    return dbc.Card([
+        dbc.CardBody([
+            html.H4("1-Day Forecast", className="card-title"),
+            html.P(f"Date: {date}"),
+            html.P(f"High: {max_temp}°F"),
+            html.P(f"Low: {min_temp}°F"),
+            html.P(f"Day: {day_phrase}"),
+            html.P(f"Night: {night_phrase}")
         ])
     ], className="mb-4")
 
-def create_forecast_card(forecast):
+def create_forecast_5day_card(forecast):
+    if not forecast or 'DailyForecasts' not in forecast or not forecast['DailyForecasts']:
+        return dbc.Card([
+            dbc.CardBody([
+                html.H4("5-Day Forecast", className="card-title"),
+                html.P("No 5-day forecast available.")
+            ])
+        ], className="mb-4")
     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 = go.Figure()
     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(
@@ -218,51 +243,30 @@ 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("Health Indices", className="card-title"),
-            html.Div([
-                html.P(f"{index['Name']}: {index['Category']}")
-                for index in health_indices[:5]
-            ])
-        ])
-    ], className="mb-4")
-
-def create_alert_card(alerts):
-    if not alerts:
-        return html.Div()
+def create_indices_card(indices_dict):
+    cards = []
+    for idx_name, idx_data in indices_dict.items():
+        if not idx_data or not isinstance(idx_data, list) or 'Category' not in idx_data[0]:
+            cards.append(html.Div([
+                html.H5(f"{idx_name} Index"),
+                html.P("No data available.")
+            ], style={"marginBottom": "10px"}))
+        else:
+            info = idx_data[0]
+            cards.append(html.Div([
+                html.H5(f"{idx_name} Index"),
+                html.P(f"{info.get('Name', '')}: {info.get('Category', '')}"),
+                html.P(f"Value: {info.get('Value', 'N/A')}"),
+                html.P(f"Category Value: {info.get('CategoryValue', 'N/A')}"),
+                html.P(f"Text: {info.get('Text', '')}")
+            ], style={"marginBottom": "10px"}))
     return dbc.Card([
         dbc.CardBody([
-            html.H4("Weather Alerts", className="card-title text-danger"),
-            html.Div([
-                html.P(alert['Text'])
-                for alert in alerts
-            ])
+            html.H4("Today's Health & Environmental Indices", className="card-title"),
+            *cards
         ])
     ], className="mb-4")
 
-# App layout
 app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
 server = app.server
 
@@ -281,7 +285,7 @@ app.layout = dbc.Container([
                 dbc.CardBody([
                     html.H5("Navigation", className="card-title"),
                     dbc.Nav([
-                        dbc.NavLink("Health Indices", href="#", id="nav-health"),
+                        dbc.NavLink("Health & Env. Indices", href="#", id="nav-health"),
                         dbc.NavLink("Current Weather", href="#", id="nav-current"),
                     ], vertical=True, pills=True)
                 ])
@@ -302,8 +306,8 @@ app.layout = dbc.Container([
                 type="default",
                 children=[
                     html.Div(id="hourly-forecast-output"),
-                    html.Div(id="forecast-output"),
-                    html.Div(id="alert-output")
+                    html.Div(id="forecast-1day-output"),
+                    html.Div(id="forecast-output")
                 ],
                 style={"width": "100%"}
             )
@@ -350,8 +354,8 @@ def set_session_cookie(response):
         Output("indices-output", "children"),
         Output("current-weather-output", "children"),
         Output("hourly-forecast-output", "children"),
+        Output("forecast-1day-output", "children"),
         Output("forecast-output", "children"),
-        Output("alert-output", "children"),
     ],
     [Input("location-store", "data")],
     [State("session-store", "data")]
@@ -366,7 +370,7 @@ def update_weather(location, session_data):
         return [dbc.Spinner(color="primary"), "", "", "", ""]
 
     lat, lon = location["latitude"], location["longitude"]
-    results = {"indices": "", "current": "", "hourly": "", "forecast": "", "alerts": ""}
+    results = {"indices": "", "current": "", "hourly": "", "forecast_1day": "", "forecast": ""}
     def fetch_weather_data():
         try:
             location_key = get_data_from_session(session_id, "location_key")
@@ -377,27 +381,29 @@ def update_weather(location, session_data):
                 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:
+            forecast_5day = get_forecast_5day(location_key)
+            forecast_1day = get_forecast_1day(location_key)
+            hourly_1hour = get_hourly_forecast_1hour(location_key)
+            indices_dict = {}
+            for idx_name, idx_id in INDEX_IDS.items():
+                indices_dict[idx_name] = get_indices_1day(location_key, idx_id)
+
+            if current is None or forecast_5day is None or forecast_1day is None:
                 raise ValueError("Failed to fetch weather data")
 
-            results["indices"] = create_indices_card(indices)
+            results["indices"] = create_indices_card(indices_dict)
             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)
+            results["hourly"] = create_hourly_1hour_card(hourly_1hour)
+            results["forecast_1day"] = create_forecast_1day_card(forecast_1day)
+            results["forecast"] = create_forecast_5day_card(forecast_5day)
             save_session_data(session_id, "weather_results", results)
         except Exception as e:
             logger.error(f"Session {session_id} error: {str(e)}")
             results["indices"] = ""
             results["current"] = ""
             results["hourly"] = ""
-            results["forecast"] = ""
-            results["alerts"] = dbc.Card([
+            results["forecast_1day"] = ""
+            results["forecast"] = dbc.Card([
                 dbc.CardBody([
                     html.P(f"Error fetching weather data: {str(e)}", className="text-danger")
                 ])
@@ -412,8 +418,8 @@ def update_weather(location, session_data):
             weather_results.get("indices", ""),
             weather_results.get("current", ""),
             weather_results.get("hourly", ""),
+            weather_results.get("forecast_1day", ""),
             weather_results.get("forecast", ""),
-            weather_results.get("alerts", ""),
         ]
     else:
         return [dbc.Spinner(color="primary"), "", "", "", ""]