Update app.py

app.py

@@ -60,11 +60,133 @@ def get_raw_data(station_id):
         traceback.print_exc()
         return None
 
+def parse_raw_data(data):
+    """
+    Parse the raw JSON data into a DataFrame with additional weather information.
+    """
+    if not data or 'features' not in data:
+        return None
+
+    records = []
+    print("\n=== Detailed Weather Information ===")
+    
+    for feature in data['features']:
+        props = feature['properties']
+        
+        # Print detailed information for each observation
+        print(f"\nTimestamp: {props['timestamp']}")
+        
+        # Present Weather
+        if props['presentWeather']:
+            print("Present Weather:")
+            for weather in props['presentWeather']:
+                print(f"  - {weather}")
+        else:
+            print("Present Weather: None reported")
+            
+        # Precipitation
+        precip = props.get('precipitationLast3Hours', {}).get('value')
+        print(f"Precipitation (last 3 hours): {precip if precip is not None else 'Not reported'} mm")
+        
+        # Raw Message
+        raw_msg = props.get('rawMessage', '')
+        if raw_msg:
+            print(f"Raw Message: {raw_msg}")
+        else:
+            print("Raw Message: None")
+            
+        # Extract text description if available
+        text_desc = props.get('textDescription', '')
+        if text_desc:
+            print(f"Text Description: {text_desc}")
+            
+        print("-" * 50)
+        
+        # Create record for DataFrame
+        record = {
+            'timestamp': props['timestamp'],
+            'temperature': props.get('temperature', {}).get('value'),
+            'wind_speed': props.get('windSpeed', {}).get('value'),
+            'wind_direction': props.get('windDirection', {}).get('value'),
+            'precipitation_3h': props.get('precipitationLast3Hours', {}).get('value'),
+            'present_weather': '; '.join(str(w) for w in props.get('presentWeather', [])) if props.get('presentWeather') else None,
+            'raw_message': props.get('rawMessage', ''),
+            'text_description': props.get('textDescription', ''),
+            'dewpoint': props.get('dewpoint', {}).get('value'),
+            'relative_humidity': props.get('relativeHumidity', {}).get('value'),
+            'wind_chill': props.get('windChill', {}).get('value')
+        }
+        
+        records.append(record)
+
+    df = pd.DataFrame(records)
+    
+    print("\nDataFrame columns from API:")
+    print(df.columns.tolist())
+    print("\nDetailed sample of raw API data:")
+    pd.set_option('display.max_columns', None)
+    print(df.head().to_string())
+    
+    return df
+
+def process_weather_data(df):
+    """
+    Process the weather DataFrame including precipitation and additional fields.
+    """
+    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 Celsius to Fahrenheit if not null
+    if df['temperature'].notna().any():
+        df['temperature'] = (df['temperature'] * 9/5) + 32
+
+    # Convert wind speed from km/h to mph if not null
+    if df['wind_speed'].notna().any():
+        df['wind_speed'] = df['wind_speed'] * 0.621371
+
+    # Convert precipitation from mm to inches if not null
+    if 'precipitation_3h' in df.columns and df['precipitation_3h'].notna().any():
+        df['precipitation_3h'] = df['precipitation_3h'] * 0.0393701  # mm to inches
+
+    # Convert dewpoint from Celsius to Fahrenheit if not null
+    if 'dewpoint' in df.columns and df['dewpoint'].notna().any():
+        df['dewpoint'] = (df['dewpoint'] * 9/5) + 32
+
+    # Convert wind chill from Celsius to Fahrenheit if not null
+    if 'wind_chill' in df.columns and df['wind_chill'].notna().any():
+        df['wind_chill'] = (df['wind_chill'] * 9/5) + 32
+
+    # Print summary of weather conditions
+    print("\n=== Weather Summary ===")
+    print(f"Time range: {df['timestamp'].min()} to {df['timestamp'].max()}")
+    
+    print("\nPrecipitation Summary:")
+    precip_data = df[df['precipitation_3h'].notna()]
+    if not precip_data.empty:
+        print(f"Total precipitation events: {len(precip_data)}")
+        print(f"Maximum 3-hour precipitation: {precip_data['precipitation_3h'].max():.2f} inches")
+    else:
+        print("No precipitation data available")
+
+    print("\nPresent Weather Conditions Summary:")
+    weather_data = df[df['present_weather'].notna()]
+    if not weather_data.empty:
+        unique_conditions = weather_data['present_weather'].unique()
+        print("Observed weather conditions:")
+        for condition in unique_conditions:
+            print(f"  - {condition}")
+    else:
+        print("No present weather conditions reported")
+
+    return df
+
 def scrape_snow_depth():
     """
     Scrapes snow depth data from the weather.gov timeseries page.
-    Searches for a table that has headers with keywords 'time' and 'snow'.
-    Returns a DataFrame with columns "timestamp" and "snowDepth".
     """
     url = "https://www.weather.gov/wrh/timeseries?site=YCTIM&hours=720&units=english&chart=on&headers=on&obs=tabular&hourly=false&pview=standard&font=12&plot="
     try:
@@ -74,7 +196,6 @@ def scrape_snow_depth():
             return pd.DataFrame()
         soup = BeautifulSoup(response.text, 'html.parser')
         
-        # Look through all tables for one with headers that include keywords "time" and "snow"
         tables = soup.find_all("table")
         target_table = None
         for table in tables:
@@ -91,7 +212,6 @@ def scrape_snow_depth():
             print("No table with required headers found.")
             return pd.DataFrame()
         
-        # Determine the column indices using a case-insensitive search
         header_row = target_table.find("tr")
         headers = [th.get_text(strip=True) for th in header_row.find_all("th")]
         time_index = None
@@ -101,11 +221,11 @@ def scrape_snow_depth():
                 time_index = i
             if "snow" in header.lower():
                 snow_index = i
+        
         if time_index is None or snow_index is None:
             print("Required columns not found in the table headers.")
             return pd.DataFrame()
         
-        # Extract rows from the table (skip the header row)
         data = []
         rows = target_table.find_all("tr")[1:]
         for row in rows:
@@ -117,82 +237,15 @@ def scrape_snow_depth():
             data.append((time_text, snow_text))
         
         df = pd.DataFrame(data, columns=["Time", "Snow Depth"])
-        # Convert "Time" to datetime objects
         df["Time"] = pd.to_datetime(df["Time"], errors="coerce")
-        # Convert "Snow Depth" to numeric values
         df["Snow Depth"] = pd.to_numeric(df["Snow Depth"], errors="coerce")
         print("Scraped snow depth data:")
         print(df.head())
-        # Rename columns to match the API data
         return df.rename(columns={"Time": "timestamp", "Snow Depth": "snowDepth"})
     except Exception as e:
         print(f"Error scraping snow depth: {e}")
         return pd.DataFrame()
 
-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']
-        
-        # Extract any properties with "snow" in their key (if present)
-        snow_fields = {k: v for k, v in props.items() if 'snow' in k.lower()}
-        if snow_fields:
-            print("\nFound snow-related fields:")
-            for k, v in snow_fields.items():
-                print(f"{k}: {v}")
-        
-        record = {
-            'timestamp': props['timestamp'],
-            'temperature': props.get('temperature', {}).get('value'),
-            'wind_speed': props.get('windSpeed', {}).get('value'),
-            'wind_direction': props.get('windDirection', {}).get('value')
-        }
-        
-        # Add any snow-related fields to the record
-        for k, v in snow_fields.items():
-            if isinstance(v, dict) and 'value' in v:
-                record[k] = v['value']
-            else:
-                record[k] = v
-        
-        records.append(record)
-
-    df = pd.DataFrame(records)
-    
-    print("\nDataFrame columns from API:")
-    print(df.columns.tolist())
-    print("\nSample of raw API data:")
-    print(df.head())
-    
-    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 Celsius to Fahrenheit if not null
-    if df['temperature'].notna().all():
-        df['temperature'] = (df['temperature'] * 9/5) + 32
-
-    # Convert wind speed from km/h to mph if not null (original unit is km/h)
-    if df['wind_speed'].notna().all():
-        df['wind_speed'] = df['wind_speed'] * 0.621371
-
-    return df
-
 def create_wind_rose(ax, data, title):
     """
     Create a wind rose subplot.
@@ -249,22 +302,26 @@ def create_wind_rose(ax, data, title):
 def create_visualizations(df):
     """
     Create static visualizations using matplotlib.
-    Plots temperature, wind speed, and snow depth.
     """
-    fig = plt.figure(figsize=(20, 24))
-    gs = GridSpec(5, 2, figure=fig)
+    fig = plt.figure(figsize=(20, 30))  # Increased height to accommodate new plots
+    gs = GridSpec(7, 2, figure=fig)  # Increased number of rows
     
+    # Temperature plot
     ax1 = fig.add_subplot(gs[0, :])
-    ax2 = fig.add_subplot(gs[1, :])
-    ax3 = fig.add_subplot(gs[2, :])
-    
     if not df['temperature'].isna().all():
-        ax1.plot(df['timestamp'], df['temperature'], linewidth=2)
-    ax1.set_title('Temperature Over Time')
+        ax1.plot(df['timestamp'], df['temperature'], linewidth=2, label='Temperature')
+        if 'wind_chill' in df.columns and not df['wind_chill'].isna().all():
+            ax1.plot(df['timestamp'], df['wind_chill'], linewidth=2, label='Wind Chill', linestyle='--')
+        if 'dewpoint' in df.columns and not df['dewpoint'].isna().all():
+            ax1.plot(df['timestamp'], df['dewpoint'], linewidth=2, label='Dewpoint', linestyle=':')
+        ax1.legend()
+    ax1.set_title('Temperature Measurements Over Time')
     ax1.set_ylabel('Temperature (°F)')
     ax1.set_xlabel('')
     ax1.grid(True)
     
+    # Wind speed plot
+    ax2 = fig.add_subplot(gs[1, :])
     if not df['wind_speed'].isna().all():
         ax2.plot(df['timestamp'], df['wind_speed'], linewidth=2)
     ax2.set_title('Wind Speed Over Time')
@@ -272,34 +329,62 @@ def create_visualizations(df):
     ax2.set_xlabel('')
     ax2.grid(True)
     
-    # Plot snow depth if available
-    if 'snowDepth' in df.columns and not df['snowDepth'].isna().all():
-        ax3.plot(df['timestamp'], df['snowDepth'], linewidth=2)
-        ax3.set_ylim(0, 80)  # Fixed y-axis limit to 80 inches
+    # Precipitation plot (new)
+    ax3 = fig.add_subplot(gs[2, :])
+    if 'precipitation_3h' in df.columns and not df['precipitation_3h'].isna().all():
+        ax3.bar(df['timestamp'], df['precipitation_3h'], width=0.02)
+        ax3.set_title('Precipitation (Last 3 Hours)')
+        ax3.set_ylabel('Precipitation (inches)')
     else:
-        ax3.text(0.5, 0.5, 'No snow depth data available', 
-                 horizontalalignment='center',
-                 verticalalignment='center',
-                 transform=ax3.transAxes)
-    ax3.set_title('Snow Depth')
-    ax3.set_ylabel('Snow Depth (inches)')
-    ax3.set_xlabel('')
+        ax3.text(0.5, 0.5, 'No precipitation data available',
+                horizontalalignment='center',
+                verticalalignment='center',
+                transform=ax3.transAxes)
     ax3.grid(True)
     
-    # Format x-axis labels
-    for ax in [ax1, ax2, ax3]:
+    # Relative Humidity plot (new)
+    ax4 = fig.add_subplot(gs[3, :])
+    if 'relative_humidity' in df.columns and not df['relative_humidity'].isna().all():
+        ax4.plot(df['timestamp'], df['relative_humidity'], linewidth=2)
+        ax4.set_title('Relative Humidity Over Time')
+        ax4.set_ylabel('Relative Humidity (%)')
+        ax4.set_ylim(0, 100)
+    else:
+        ax4.text(0.5, 0.5, 'No humidity data available',
+                horizontalalignment='center',
+                verticalalignment='center',
+                transform=ax4.transAxes)
+    ax4.grid(True)
+    
+    # Snow depth plot
+    ax5 = fig.add_subplot(gs[4, :])
+    if 'snowDepth' in df.columns and not df['snowDepth'].isna().all():
+        ax5.plot(df['timestamp'], df['snowDepth'], linewidth=2)
+        ax5.set_ylim(0, 80)  # Fixed y-axis limit to 80 inches
+    else:
+        ax5.text(0.5, 0.5, 'No snow depth data available',
+                horizontalalignment='center',
+                verticalalignment='center',
+                transform=ax5.transAxes)
+    ax5.set_title('Snow Depth')
+    ax5.set_ylabel('Snow Depth (inches)')
+    ax5.set_xlabel('')
+    ax5.grid(True)
+    
+    # Format x-axis labels for all plots
+    for ax in [ax1, ax2, ax3, ax4, ax5]:
         ax.tick_params(axis='x', rotation=45)
         ax.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d %H:%M'))
     
+    # Wind rose plots
     dates = sorted(df['date'].unique())
     for i, date in enumerate(dates):
-        if i < 2:
-            ax = fig.add_subplot(gs[4, i], projection='polar')
+        if i < 2:  # Only show last two days
+            ax = fig.add_subplot(gs[6, i], projection='polar')
             day_data = df[df['date'] == date].copy()
             create_wind_rose(ax, day_data, pd.to_datetime(date).strftime('%Y-%m-%d'))
     
     plt.tight_layout()
-    
     return fig
 
 def get_weather_data(station_id, hours):
@@ -357,7 +442,7 @@ def fetch_and_display(station_id, hours):
 # Create Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("# Weather Data Viewer")
-    gr.Markdown("Displays temperature, wind speed, and snow depth from NWS stations.")
+    gr.Markdown("Displays comprehensive weather data from NWS stations including temperature, wind, precipitation, and snow depth.")
     
     with gr.Row():
         station_id = gr.Textbox(label="Station ID", value="YCTIM")
@@ -375,4 +460,5 @@ with gr.Blocks() as demo:
     )
 
 # Launch the app
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()