Create app.py

app.py

@@ -0,0 +1,218 @@
+import dash
+from dash import dcc, html, Input, Output, State
+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
+
+# Load environment variables
+load_dotenv()
+
+# Initialize the Dash app
+app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
+
+# AccuWeather API key
+API_KEY = os.getenv('ACCUWEATHER_API_KEY')
+
+# Base URL for AccuWeather API
+BASE_URL = "http://dataservice.accuweather.com"
+
+def get_location_key(lat, lon):
+    url = f"{BASE_URL}/locations/v1/cities/geoposition/search"
+    params = {
+        "apikey": API_KEY,
+        "q": f"{lat},{lon}",
+    }
+    response = requests.get(url, params=params)
+    data = response.json()
+    return data["Key"]
+
+def get_current_conditions(location_key):
+    url = f"{BASE_URL}/currentconditions/v1/{location_key}"
+    params = {
+        "apikey": API_KEY,
+        "details": "true",
+    }
+    response = requests.get(url, params=params)
+    return response.json()[0]
+
+def get_forecast(location_key):
+    url = f"{BASE_URL}/forecasts/v1/daily/5day/{location_key}"
+    params = {
+        "apikey": API_KEY,
+        "metric": "true",
+    }
+    response = requests.get(url, params=params)
+    return response.json()
+
+def get_indices(location_key):
+    url = f"{BASE_URL}/indices/v1/daily/5day/{location_key}"
+    params = {
+        "apikey": API_KEY,
+    }
+    response = requests.get(url, params=params)
+    return response.json()
+
+def get_alerts(location_key):
+    url = f"{BASE_URL}/alerts/v1/{location_key}"
+    params = {
+        "apikey": API_KEY,
+    }
+    response = requests.get(url, params=params)
+    return response.json()
+
+# App layout
+app.layout = dbc.Container([
+    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")
+
+@app.callback(
+    Output("location-store", "data"),
+    Input("location-interval", "n_intervals")
+)
+def update_location(n):
+    return {"latitude": 0, "longitude": 0}  # Replace with actual browser location data
+
+@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")
+)
+def update_weather(location):
+    if not location:
+        return "Waiting for location data...", "", "", "", ""
+
+    lat, lon = location["latitude"], location["longitude"]
+    
+    loading_output = html.Div([
+        html.P("Loading weather data...", className="text-center"),
+        dbc.Spinner(color="primary", type="grow"),
+    ])
+
+    def fetch_weather_data():
+        nonlocal loading_output
+        try:
+            location_key = get_location_key(lat, lon)
+            current = get_current_conditions(location_key)
+            forecast = get_forecast(location_key)
+            indices = get_indices(location_key)
+            alerts = get_alerts(location_key)
+
+            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)
+
+            loading_output = ""
+            
+            return current_weather, forecast_output, indices_output, alert_output
+
+        except Exception as e:
+            loading_output = html.Div(f"Error fetching weather data: {str(e)}", className="text-danger")
+            return "", "", "", ""
+
+    # 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
+
+    if thread.is_alive():
+        loading_output = html.Div("Weather data fetch timed out. Please try again.", className="text-warning")
+        return loading_output, "", "", "", ""
+
+    current_weather, forecast_output, indices_output, alert_output = fetch_weather_data()
+    return loading_output, current_weather, forecast_output, indices_output, alert_output
+
+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"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"Humidity: {current['RelativeHumidity']}%"),
+        ])
+    ], 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)",
+        legend_title="Temperature",
+        height=400
+    )
+    
+    return dbc.Card([
+        dbc.CardBody([
+            html.H4("5-Day Forecast", className="card-title"),
+            dcc.Graph(figure=fig)
+        ])
+    ], className="mb-4")
+
+def create_indices_card(indices):
+    return dbc.Card([
+        dbc.CardBody([
+            html.H4("Weather Indices", className="card-title"),
+            html.Div([
+                html.P(f"{index['Name']}: {index['Category']}")
+                for index in indices[:5]  # Display first 5 indices
+            ])
+        ])
+    ], className="mb-4")
+
+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"),
+            html.Div([
+                html.P(alert['Text'])
+                for alert in alerts
+            ])
+        ])
+    ], className="mb-4")
+
+if __name__ == '__main__':
+    print("Starting the Dash application...")
+    app.run(debug=True, host='0.0.0.0', port=7860)
+    print("Dash application has finished running.")