Update app.py

app.py

@@ -6,94 +6,155 @@ import numpy as np
 from datetime import datetime, timedelta
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec
+import json
 
-# Set the style for all plots
-plt.style.use('seaborn-v0_8-darkgrid')
-plt.rcParams['figure.figsize'] = [12, 8]
-plt.rcParams['figure.dpi'] = 100
-plt.rcParams['font.size'] = 10
-plt.rcParams['axes.labelsize'] = 12
-plt.rcParams['axes.titlesize'] = 14
-
-def get_weather_data(station_id, hours=72):
+def get_raw_data(station_id):
     """
-    Fetch weather data from NWS API
+    Get raw data from multiple endpoints to find snow depth data
     """
+    # Try standard observations endpoint
+    url1 = f"https://api.weather.gov/stations/{station_id}/observations"
+    # Try station metadata endpoint
+    url2 = f"https://api.weather.gov/stations/{station_id}"
+    # Try grid point data endpoint (need to get grid coordinates first)
+    url3 = f"https://api.weather.gov/points/{station_id}"
+    
     headers = {
         'User-Agent': '(Weather Data Viewer, contact@yourdomain.com)',
         'Accept': 'application/json'
     }
     
+    params = {
+        'limit': 720,  # Get maximum available data
+        'start': (datetime.utcnow() - timedelta(hours=720)).isoformat() + 'Z'
+    }
+    
     try:
-        # First get latest observation to see format
-        latest_url = f'https://api.weather.gov/stations/{station_id}/observations/latest'
-        response = requests.get(latest_url, headers=headers)
-        response.raise_for_status()
-        latest = response.json()
-        print("Latest observation data structure:")
-        print(latest)
-        
-        # Get historical observations
-        observations_url = f'https://api.weather.gov/stations/{station_id}/observations'
-        params = {
-            'limit': hours,
-            'start': (datetime.utcnow() - timedelta(hours=hours)).isoformat() + 'Z'
-        }
-        
-        response = requests.get(observations_url, headers=headers, params=params)
-        response.raise_for_status()
-        data = response.json()
+        # Get standard observations
+        print("\nTrying standard observations endpoint...")
+        response1 = requests.get(url1, headers=headers, params=params)
+        response1.raise_for_status()
+        data1 = response1.json()
+        print("Sample observation data:")
+        if 'features' in data1 and len(data1['features']) > 0:
+            print(json.dumps(data1['features'][0]['properties'], indent=2))
 
-        records = []
-        for obs in data['features']:
-            props = obs['properties']
-            
-            # Print the first observation's full structure
-            if len(records) == 0:
-                print("\nFirst observation properties:")
-                print(props)
-            
-            record = {
-                'timestamp': props['timestamp'],
-                'temperature': props.get('temperature', {}).get('value'),
-                'relative_humidity': props.get('relativeHumidity', {}).get('value'),
-                'wind_speed': props.get('windSpeed', {}).get('value'),
-                'wind_direction': props.get('windDirection', {}).get('value'),
-                'barometric_pressure': props.get('barometricPressure', {}).get('value'),
-                'snow_depth': props.get('snowDepth', {}).get('value'),
-                'snow_accumulation': props.get('snowfall', {}).get('value', 0)
-            }
-            records.append(record)
+        # Get station metadata
+        print("\nTrying station metadata endpoint...")
+        response2 = requests.get(url2, headers=headers)
+        response2.raise_for_status()
+        data2 = response2.json()
+        print("Station metadata:")
+        print(json.dumps(data2, indent=2))
+
+        # Try to get grid point data
+        print("\nTrying grid point endpoint...")
+        response3 = requests.get(url3, headers=headers)
+        if response3.status_code == 200:
+            data3 = response3.json()
+            print("Grid point data:")
+            print(json.dumps(data3, indent=2))
             
-        df = pd.DataFrame(records)
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
-        df['date'] = df['timestamp'].dt.date
-        
-        # Convert units to imperial
-        df['temperature'] = (df['temperature'] * 9/5) + 32  # C to F
-        df['wind_speed'] = df['wind_speed'] * 2.237  # m/s to mph
-        
-        # Handle snow depth
-        print("\nRaw snow depth values:")
-        print(df['snow_depth'].unique())
-        
-        # If snow depth is in meters, convert to inches
-        if df['snow_depth'].notna().any():
-            df['snow_depth'] = df['snow_depth'] * 39.3701  # meters to inches
-        
-        # Forward fill missing snow depth values
-        df['snow_depth'] = df['snow_depth'].ffill()
+            # If we got grid data, try to get forecast data
+            if 'properties' in data3:
+                grid_id = data3['properties'].get('gridId')
+                grid_x = data3['properties'].get('gridX')
+                grid_y = data3['properties'].get('gridY')
+                if all([grid_id, grid_x, grid_y]):
+                    forecast_url = f"https://api.weather.gov/gridpoints/{grid_id}/{grid_x},{grid_y}"
+                    print(f"\nTrying forecast endpoint: {forecast_url}")
+                    response4 = requests.get(forecast_url, headers=headers)
+                    if response4.status_code == 200:
+                        data4 = response4.json()
+                        print("Forecast data:")
+                        print(json.dumps(data4.get('properties', {}), indent=2))
+
+        # Return standard observations for now
+        return data1
+    except Exception as e:
+        print(f"Error fetching data: {e}")
+        print("Full error details:")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def parse_raw_data(data):
+    """
+    Parse the raw JSON data into a DataFrame
+    """
+    if not data or 'features' not in data:
+        return None
+
+    records = []
+    for feature in data['features']:
+        props = feature['properties']
         
-        # Calculate cumulative snow accumulation
-        df['cumulative_snow'] = df['snow_accumulation'].fillna(0).cumsum()
+        # Getting raw message which might contain snow depth info
+        raw_message = props.get('rawMessage', '')
+        print(f"Raw message: {raw_message}")
         
-        print("\nProcessed snow depth values (inches):")
-        print(df['snow_depth'].unique())
+        # Try to parse snow depth from raw message or use NaN
+        snow_depth = None
+
+        record = {
+            'timestamp': props['timestamp'],
+            'temperature': props.get('temperature', {}).get('value'),
+            'wind_speed': props.get('windSpeed', {}).get('value'),
+            'wind_direction': props.get('windDirection', {}).get('value'),
+            'snow_depth': snow_depth,
+            'raw_message': raw_message  # Store raw message for debugging
+        }
+        records.append(record)
+
+    df = pd.DataFrame(records)
+    return df
+
+def process_weather_data(df):
+    """
+    Process the weather DataFrame
+    """
+    if df is None or df.empty:
+        return None
+
+    # Convert timestamp
+    df['timestamp'] = pd.to_datetime(df['timestamp'])
+    df['date'] = df['timestamp'].dt.date
+
+    # Convert temperature from C to F
+    df['temperature'] = (df['temperature'] * 9/5) + 32
+
+    # Convert wind speed from m/s to mph
+    df['wind_speed'] = df['wind_speed'] * 2.237
+
+    return df
+
+def get_weather_data(station_id, hours=72):
+    """
+    Main function to get and process weather data
+    """
+    try:
+        # Get raw data
+        raw_data = get_raw_data(station_id)
+        if raw_data is None:
+            return None, "Failed to fetch data"
+
+        # Parse raw data
+        df = parse_raw_data(raw_data)
+        if df is None:
+            return None, "Failed to parse data"
+
+        # Process data
+        df = process_weather_data(df)
+        if df is None:
+            return None, "Failed to process data"
+
+        print("\nSample of processed data:")
+        print(df.head())
         
         return df, None
-        
-    except requests.exceptions.RequestException as e:
-        return None, f"Error fetching data: {str(e)}"
+
+    except Exception as e:
+        return None, f"Error: {str(e)}"
 
 def create_wind_rose(ax, data, title):
     """
@@ -157,7 +218,6 @@ def create_visualizations(df):
     ax1 = fig.add_subplot(gs[0, :])
     ax2 = fig.add_subplot(gs[1, :])
     ax3 = fig.add_subplot(gs[2, :])
-    ax4 = fig.add_subplot(gs[3, :])
     
     if not df['temperature'].isna().all():
         ax1.plot(df['timestamp'], df['temperature'], linewidth=2)
@@ -182,13 +242,7 @@ def create_visualizations(df):
     ax3.set_xlabel('')
     ax3.grid(True)
     
-    if not df['cumulative_snow'].isna().all():
-        ax4.plot(df['timestamp'], df['cumulative_snow'], linewidth=2)
-    ax4.set_title('Cumulative Snow Accumulation')
-    ax4.set_ylabel('Snow Accumulation (inches)')
-    ax4.grid(True)
-    
-    for ax in [ax1, ax2, ax3, ax4]:
+    for ax in [ax1, ax2, ax3]:
         ax.tick_params(axis='x', rotation=45)
         ax.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d %H:%M'))