Update app.py

app.py

@@ -1,464 +1,363 @@
 import gradio as gr
-import requests
 import pandas as pd
 import numpy as np
-from datetime import datetime, timedelta
+import re
+from playwright.sync_api import sync_playwright
+import time
+import os
+import subprocess
+import sys
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec
-import json
-from bs4 import BeautifulSoup
+from windrose import WindroseAxes
+from datetime import datetime
 
-def get_raw_data(station_id):
-    """
-    Get raw data from the NWS API.
-    """
-    headers = {
-        'User-Agent': '(Weather Data Viewer, contact@yourdomain.com)',
-        'Accept': 'application/json'
-    }
-    
-    # Calculate correct date range for last 3 days
-    end_time = datetime.utcnow()
-    start_time = end_time - timedelta(hours=72)  # Last 3 days
-    
-    params = {
-        'start': start_time.isoformat() + 'Z',
-        'end': end_time.isoformat() + 'Z'
-    }
-    
-    url = f"https://api.weather.gov/stations/{station_id}/observations"
-    
+# Install Playwright browsers on startup
+def install_playwright_browsers():
     try:
-        print("\nFetching observations...")
-        print(f"URL: {url}")
-        print(f"Time range: {start_time} to {end_time}")
-        response = requests.get(url, headers=headers, params=params)
-        print(f"Response status: {response.status_code}")
-        
-        if response.status_code != 200:
-            print(f"Response content: {response.text}")
-            response.raise_for_status()
-        
-        data = response.json()
-        
-        if 'features' in data:
-            print(f"\nNumber of observations: {len(data['features'])}")
-            if len(data['features']) > 0:
-                print("\nFirst observation properties:")
-                print(json.dumps(data['features'][0]['properties'], indent=2))
-                
-                print("\nAll available property keys:")
-                keys = set()
-                for feature in data['features']:
-                    keys.update(feature['properties'].keys())
-                print(sorted(list(keys)))
-        
-        return data
+        if not os.path.exists('/home/user/.cache/ms-playwright'):
+            print("Installing Playwright browsers...")
+            subprocess.run(
+                [sys.executable, "-m", "playwright", "install", "chromium"],
+                check=True,
+                capture_output=True,
+                text=True
+            )
+            print("Playwright browsers installed successfully")
     except Exception as e:
-        print(f"Error fetching data: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
+        print(f"Error installing browsers: {e}")
 
-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
+# Install browsers when the module loads
+install_playwright_browsers()
 
-    records = []
-    print("\n=== Detailed Weather Information ===")
+def scrape_weather_data(site_id, hours=720):
+    """Scrape weather data from weather.gov timeseries"""
+    url = f"https://www.weather.gov/wrh/timeseries?site={site_id}&hours={hours}&units=english&chart=on&headers=on&obs=tabular&hourly=false&pview=full&font=12&plot="
     
-    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")
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(
+                headless=True,
+                args=['--no-sandbox', '--disable-dev-shm-usage']
+            )
             
-        # 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")
+            context = browser.new_context(
+                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+            )
+            
+            page = context.new_page()
+            response = page.goto(url)
+            print(f"Response status: {response.status}")
+            
+            page.wait_for_selector('table', timeout=30000)
+            time.sleep(5)
             
-        # Extract text description if available
-        text_desc = props.get('textDescription', '')
-        if text_desc:
-            print(f"Text Description: {text_desc}")
+            print("Extracting data...")
+            content = page.evaluate('''() => {
+                const getTextContent = () => {
+                    const rows = [];
+                    const tables = document.getElementsByTagName('table');
+                    for (const table of tables) {
+                        if (table.textContent.includes('Date/Time')) {
+                            const headerRow = Array.from(table.querySelectorAll('th'))
+                                .map(th => th.textContent.trim());
+                            
+                            const dataRows = Array.from(table.querySelectorAll('tbody tr'))
+                                .map(row => Array.from(row.querySelectorAll('td'))
+                                    .map(td => td.textContent.trim()));
+                            
+                            return {headers: headerRow, rows: dataRows};
+                        }
+                    }
+                    return null;
+                };
+                
+                return getTextContent();
+            }''')
+            
+            print(f"Found {len(content['rows'] if content else [])} rows of data")
+            browser.close()
+            return content
             
-        print("-" * 50)
+    except Exception as e:
+        print(f"Error scraping data: {str(e)}")
+        raise e
+
+def parse_date(date_str):
+    """Parse date string to datetime"""
+    try:
+        current_year = datetime.now().year
+        return pd.to_datetime(f"{date_str}, {current_year}", format="%b %d, %I:%M %p, %Y")
+    except:
+        return pd.NaT
+
+def parse_weather_data(data):
+    """Parse the weather data into a pandas DataFrame"""
+    if not data or 'rows' not in data:
+        raise ValueError("No valid weather data found")
         
-        # 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')
+    df = pd.DataFrame(data['rows'])
+    
+    columns = ['datetime', 'temp', 'dew_point', 'humidity', 'wind_chill', 
+              'wind_dir', 'wind_speed', 'snow_depth', 'snowfall_3hr', 
+              'snowfall_6hr', 'snowfall_24hr', 'swe']
+    
+    df = df.iloc[:, :12]
+    df.columns = columns
+    
+    numeric_cols = ['temp', 'dew_point', 'humidity', 'wind_chill', 'snow_depth',
+                   'snowfall_3hr', 'snowfall_6hr', 'snowfall_24hr', 'swe']
+    for col in numeric_cols:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+    
+    def parse_wind(x):
+        if pd.isna(x): return np.nan, np.nan
+        match = re.search(r'(\d+)G(\d+)', str(x))
+        if match:
+            return float(match.group(1)), float(match.group(2))
+        try:
+            return float(x), np.nan
+        except:
+            return np.nan, np.nan
+    
+    wind_data = df['wind_speed'].apply(parse_wind)
+    df['wind_speed'] = wind_data.apply(lambda x: x[0])
+    df['wind_gust'] = wind_data.apply(lambda x: x[1])
+    
+    def parse_direction(direction):
+        direction_map = {
+            'N': 0, 'NNE': 22.5, 'NE': 45, 'ENE': 67.5,
+            'E': 90, 'ESE': 112.5, 'SE': 135, 'SSE': 157.5,
+            'S': 180, 'SSW': 202.5, 'SW': 225, 'WSW': 247.5,
+            'W': 270, 'WNW': 292.5, 'NW': 315, 'NNW': 337.5
         }
-        
-        records.append(record)
-
-    df = pd.DataFrame(records)
+        return direction_map.get(direction, np.nan)
     
-    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())
+    df['wind_dir_deg'] = df['wind_dir'].apply(parse_direction)
+    
+    df['datetime'] = df['datetime'].apply(parse_date)
+    df['date'] = df['datetime'].dt.date
     
     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.
-    """
-    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:
-        response = requests.get(url)
-        if response.status_code != 200:
-            print(f"Failed to fetch HTML page: {response.status_code}")
-            return pd.DataFrame()
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        tables = soup.find_all("table")
-        target_table = None
-        for table in tables:
-            header_row = table.find("tr")
-            if not header_row:
-                continue
-            headers = [th.get_text(strip=True) for th in header_row.find_all("th")]
-            print("Found table headers:", headers)
-            if any("time" in h.lower() for h in headers) and any("snow" in h.lower() for h in headers):
-                target_table = table
-                break
-        
-        if target_table is None:
-            print("No table with required headers found.")
-            return pd.DataFrame()
-        
-        header_row = target_table.find("tr")
-        headers = [th.get_text(strip=True) for th in header_row.find_all("th")]
-        time_index = None
-        snow_index = None
-        for i, header in enumerate(headers):
-            if "time" in header.lower():
-                time_index = i
-            if "snow" in header.lower():
-                snow_index = i
+def process_daily_snow(group):
+    """Sum up ONLY the 3-hour snowfall amounts for each day period"""
+    # Sort by time to ensure proper sequence
+    group = group.sort_values('datetime')
+    
+    # Initialize variables for tracking snow accumulation
+    daily_total = 0
+    last_valid_time = None
+    last_amount = 0
+    
+    for _, row in group.iterrows():
+        current_amount = row['snowfall_3hr'] if pd.notna(row['snowfall_3hr']) else 0
         
-        if time_index is None or snow_index is None:
-            print("Required columns not found in the table headers.")
-            return pd.DataFrame()
-        
-        data = []
-        rows = target_table.find_all("tr")[1:]
-        for row in rows:
-            cells = row.find_all("td")
-            if len(cells) <= max(time_index, snow_index):
-                continue
-            time_text = cells[time_index].get_text(strip=True)
-            snow_text = cells[snow_index].get_text(strip=True)
-            data.append((time_text, snow_text))
-        
-        df = pd.DataFrame(data, columns=["Time", "Snow Depth"])
-        df["Time"] = pd.to_datetime(df["Time"], errors="coerce")
-        df["Snow Depth"] = pd.to_numeric(df["Snow Depth"], errors="coerce")
-        print("Scraped snow depth data:")
-        print(df.head())
-        return df.rename(columns={"Time": "timestamp", "Snow Depth": "snowDepth"})
-    except Exception as e:
-        print(f"Error scraping snow depth: {e}")
-        return pd.DataFrame()
+        # If this is a new reading (not overlapping with previous)
+        if current_amount > 0:
+            if last_valid_time is None or (row['datetime'] - last_valid_time).total_seconds() > 3600:
+                daily_total += current_amount
+                last_valid_time = row['datetime']
+                last_amount = current_amount
+            else:
+                # For overlapping periods, only count the difference if it's higher
+                if current_amount > last_amount:
+                    daily_total += (current_amount - last_amount)
+                    last_amount = current_amount
+    
+    return daily_total
 
-def create_wind_rose(ax, data, title):
-    """
-    Create a wind rose subplot.
-    """
-    if data.empty or data['wind_direction'].isna().all() or data['wind_speed'].isna().all():
-        ax.text(0.5, 0.5, 'No wind data available', 
-                horizontalalignment='center',
-                verticalalignment='center',
-                transform=ax.transAxes)
-        ax.set_title(title)
-        return
+def calculate_total_new_snow(df):
+    """Calculate total new snow accumulation"""
+    # Sort by datetime to ensure correct calculation
+    df = df.sort_values('datetime')
+    
+    # Create a copy of the dataframe with ONLY datetime and 3-hour snowfall
+    snow_df = df[['datetime', 'snowfall_3hr']].copy()
+    
+    # Create a day group that starts at 9 AM instead of midnight
+    snow_df['day_group'] = snow_df['datetime'].apply(
+        lambda x: x.date() if x.hour >= 9 else (x - pd.Timedelta(days=1)).date()
+    )
+    
+    # Calculate daily snow totals
+    daily_totals = snow_df.groupby('day_group').apply(process_daily_snow)
+    
+    return daily_totals.sum()
 
-    plot_data = data.copy()
-    
-    direction_bins = np.arange(0, 361, 45)
-    directions = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']
-    
-    mask = plot_data['wind_direction'].notna() & plot_data['wind_speed'].notna()
-    plot_data = plot_data[mask]
-    
-    if plot_data.empty:
-        ax.text(0.5, 0.5, 'No valid wind data', 
-                horizontalalignment='center',
-                verticalalignment='center',
-                transform=ax.transAxes)
-        ax.set_title(title)
-        return
-    
-    plot_data.loc[:, 'direction_bin'] = pd.cut(plot_data['wind_direction'], 
-                                               bins=direction_bins, 
-                                               labels=directions,
-                                               include_lowest=True)
-    
-    wind_stats = plot_data.groupby('direction_bin', observed=True)['wind_speed'].mean()
-    
-    all_directions = pd.Series(0.0, index=directions)
-    wind_stats = wind_stats.combine_first(all_directions)
-    
-    angles = np.linspace(0, 2*np.pi, len(directions), endpoint=False)
-    values = [wind_stats[d] for d in directions]
-    
-    if any(v > 0 for v in values):
-        ax.bar(angles, values, width=0.5, alpha=0.6)
-        ax.set_xticks(angles)
-        ax.set_xticklabels(directions)
-    else:
-        ax.text(0.5, 0.5, 'No significant wind', 
-                horizontalalignment='center',
-                verticalalignment='center',
-                transform=ax.transAxes)
-    
-    ax.set_title(title)
+def create_wind_rose(df, ax):
+    """Create a wind rose plot"""
+    if not isinstance(ax, WindroseAxes):
+        ax = WindroseAxes.from_ax(ax=ax)
+    ax.bar(df['wind_dir_deg'].dropna(), df['wind_speed'].dropna(), 
+           bins=np.arange(0, 40, 5), normed=True, opening=0.8, edgecolor='white')
+    ax.set_legend(title='Wind Speed (mph)')
+    ax.set_title('Wind Rose')
 
-def create_visualizations(df):
-    """
-    Create static visualizations using matplotlib.
-    """
-    fig = plt.figure(figsize=(20, 30))  # Increased height to accommodate new plots
-    gs = GridSpec(7, 2, figure=fig)  # Increased number of rows
+def create_plots(df):
+    """Create all weather plots including SWE estimates"""
+    # Create figure with adjusted height and spacing
+    fig = plt.figure(figsize=(20, 24))
+    
+    # Calculate height ratios for different plots
+    height_ratios = [1, 1, 1, 1, 1]  # Equal height for all plots
+    gs = GridSpec(5, 1, figure=fig, height_ratios=height_ratios)
+    gs.update(hspace=0.4)  # Increase vertical spacing between plots
     
     # Temperature plot
-    ax1 = fig.add_subplot(gs[0, :])
-    if not df['temperature'].isna().all():
-        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 = fig.add_subplot(gs[0])
+    ax1.plot(df['datetime'], df['temp'], label='Temperature', color='red')
+    ax1.plot(df['datetime'], df['wind_chill'], label='Wind Chill', color='blue')
+    ax1.set_title('Temperature and Wind Chill Over Time', pad=20)
+    ax1.set_xlabel('Date')
     ax1.set_ylabel('Temperature (°F)')
-    ax1.set_xlabel('')
+    ax1.legend()
     ax1.grid(True)
+    ax1.tick_params(axis='x', rotation=45)
     
     # 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')
+    ax2 = fig.add_subplot(gs[1])
+    ax2.plot(df['datetime'], df['wind_speed'], label='Wind Speed', color='blue')
+    ax2.plot(df['datetime'], df['wind_gust'], label='Wind Gust', color='orange')
+    ax2.set_title('Wind Speed and Gusts Over Time', pad=20)
+    ax2.set_xlabel('Date')
     ax2.set_ylabel('Wind Speed (mph)')
-    ax2.set_xlabel('')
+    ax2.legend()
     ax2.grid(True)
+    ax2.tick_params(axis='x', rotation=45)
     
-    # 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 precipitation data available',
-                horizontalalignment='center',
-                verticalalignment='center',
-                transform=ax3.transAxes)
+    # Snow depth plot
+    ax3 = fig.add_subplot(gs[2])
+    ax3.plot(df['datetime'], df['snow_depth'], color='blue', label='Snow Depth')
+    ax3.set_title('Snow Depth Over Time', pad=20)
+    ax3.set_xlabel('Date')
+    ax3.set_ylabel('Snow Depth (inches)')
     ax3.grid(True)
+    ax3.tick_params(axis='x', rotation=45)
     
-    # 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:  # 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
+    # Daily new snow bar plot
+    ax4 = fig.add_subplot(gs[3])
+    snow_df = df[['datetime', 'snowfall_3hr']].copy()
+    snow_df['day_group'] = snow_df['datetime'].apply(
+        lambda x: x.date() if x.hour >= 9 else (x - pd.Timedelta(days=1)).date()
+    )
+    daily_snow = snow_df.groupby('day_group').apply(process_daily_snow).reset_index()
+    daily_snow.columns = ['date', 'new_snow']
+    
+    # Create the bar plot
+    ax4.bar(daily_snow['date'], daily_snow['new_snow'], color='blue')
+    ax4.set_title('Daily New Snow (Sum of 3-hour amounts, 9 AM Reset)', pad=20)
+    ax4.set_xlabel('Date')
+    ax4.set_ylabel('New Snow (inches)')
+    ax4.tick_params(axis='x', rotation=45)
+    ax4.grid(True, axis='y', linestyle='--', alpha=0.7)
+    
+    # Add value labels on top of each bar
+    for i, v in enumerate(daily_snow['new_snow']):
+        if v > 0:  # Only label bars with snow
+            ax4.text(i, v, f'{v:.1f}"', ha='center', va='bottom')
+    
+    # SWE bar plot
+    ax5 = fig.add_subplot(gs[4])
+    daily_swe = df.groupby('date')['swe'].mean()
+    ax5.bar(daily_swe.index, daily_swe.values, color='lightblue')
+    ax5.set_title('Snow/Water Equivalent', pad=20)
+    ax5.set_xlabel('Date')
+    ax5.set_ylabel('SWE (inches)')
+    ax5.tick_params(axis='x', rotation=45)
+    
+    # Adjust layout
+    plt.subplots_adjust(top=0.95, bottom=0.05, left=0.1, right=0.95)
+    
+    # Create separate wind rose figure
+    fig_rose = plt.figure(figsize=(10, 10))
+    ax_rose = WindroseAxes.from_ax(fig=fig_rose)
+    create_wind_rose(df, ax_rose)
+    fig_rose.subplots_adjust(top=0.95, bottom=0.05, left=0.1, right=0.95)
+    
+    return fig, fig_rose
 
-def get_weather_data(station_id, hours):
-    """
-    Main function to get and process weather data.
-    Combines API data and scraped snow depth data.
-    """
+def analyze_weather_data(site_id, hours):
+    """Analyze weather data and create visualizations"""
     try:
-        # Get raw data from API
-        raw_data = get_raw_data(station_id)
-        if raw_data is None:
-            return None, "Failed to fetch data from API"
-
-        # Parse raw API data
-        df = parse_raw_data(raw_data)
-        if df is None:
-            return None, "Failed to parse API data"
-
-        # Process API data
-        df = process_weather_data(df)
-        if df is None:
-            return None, "Failed to process API data"
+        print(f"Scraping data for {site_id}...")
+        raw_data = scrape_weather_data(site_id, hours)
+        if not raw_data:
+            return "Error: Could not retrieve weather data.", None, None
         
-        # Scrape snow depth data and merge with API data
-        snow_df = scrape_snow_depth()
-        if not snow_df.empty:
-            df = df.sort_values('timestamp')
-            snow_df = snow_df.sort_values('timestamp')
-            # Merge using nearest timestamp within a 30-minute tolerance
-            df = pd.merge_asof(df, snow_df, on='timestamp', tolerance=pd.Timedelta('30min'), direction='nearest')
+        print("Parsing data...")    
+        df = parse_weather_data(raw_data)
         
-        print("\nProcessed combined data sample:")
-        print(df.head())
+        # Calculate total new snow using the new method
+        total_new_snow = calculate_total_new_snow(df)
+        current_swe = df['swe'].iloc[0]  # Get most recent SWE measurement
+        
+        print("Calculating statistics...")
+        stats = {
+            'Temperature Range': f"{df['temp'].min():.1f}°F to {df['temp'].max():.1f}°F",
+            'Average Temperature': f"{df['temp'].mean():.1f}°F",
+            'Max Wind Speed': f"{df['wind_speed'].max():.1f} mph",
+            'Max Wind Gust': f"{df['wind_gust'].max():.1f} mph",
+            'Average Humidity': f"{df['humidity'].mean():.1f}%",
+            'Current Snow Depth': f"{df['snow_depth'].iloc[0]:.1f} inches",
+            'Total New Snow': f"{total_new_snow:.1f} inches",
+            'Current Snow/Water Equivalent': f"{current_swe:.2f} inches"
+        }
+        
+        html_output = "<div style='font-size: 16px; line-height: 1.5;'>"
+        html_output += f"<p><strong>Weather Station:</strong> {site_id}</p>"
+        html_output += f"<p><strong>Data Range:</strong> {df['datetime'].min().strftime('%Y-%m-%d %H:%M')} to {df['datetime'].max().strftime('%Y-%m-%d %H:%M')}</p>"
+        for key, value in stats.items():
+            html_output += f"<p><strong>{key}:</strong> {value}</p>"
+        html_output += "</div>"
+        
+        print("Creating plots...")
+        main_plots, wind_rose = create_plots(df)
+        
+        return html_output, main_plots, wind_rose
         
-        return df, None
-
     except Exception as e:
-        return None, f"Error: {str(e)}"
-
-def fetch_and_display(station_id, hours):
-    """
-    Fetch data and create visualization.
-    """
-    df, error = get_weather_data(station_id, hours)
-    
-    if error:
-        return None, error
-    
-    if df is not None and not df.empty:
-        fig = create_visualizations(df)
-        return fig, "Data fetched successfully!"
-    
-    return None, "No data available for the specified parameters."
+        print(f"Error in analysis: {str(e)}")
+        return f"Error analyzing data: {str(e)}", None, None
 
 # Create Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Weather Data Viewer")
-    gr.Markdown("Displays comprehensive weather data from NWS stations including temperature, wind, precipitation, and snow depth.")
+with gr.Blocks(title="Weather Station Data Analyzer") as demo:
+    gr.Markdown("# Weather Station Data Analyzer")
+    gr.Markdown("""
+    Enter a weather station ID and number of hours to analyze.
+    Example station IDs:
+    - YCTIM (Yellowstone Club - Timber)
+    - KBZN (Bozeman Airport)
+    - KSLC (Salt Lake City)
+    """)
     
     with gr.Row():
-        station_id = gr.Textbox(label="Station ID", value="YCTIM")
-        hours = gr.Slider(minimum=24, maximum=168, value=72, label="Hours of Data", step=24)
+        site_id = gr.Textbox(
+            label="Weather Station ID",
+            value="YCTIM",
+            placeholder="Enter station ID (e.g., YCTIM)"
+        )
+        hours = gr.Number(
+            label="Hours of Data",
+            value=720,
+            minimum=1,
+            maximum=1440
+        )
+    
+    analyze_btn = gr.Button("Fetch and Analyze Weather Data")
     
-    fetch_btn = gr.Button("Fetch Data")
+    with gr.Row():
+        stats_output = gr.HTML(label="Statistics")
     
-    plot_output = gr.Plot()
-    message = gr.Textbox(label="Status")
+    with gr.Row():
+        weather_plots = gr.Plot(label="Weather Plots")
+        wind_rose = gr.Plot(label="Wind Rose")
     
-    fetch_btn.click(
-        fn=fetch_and_display,
-        inputs=[station_id, hours],
-        outputs=[plot_output, message]
+    analyze_btn.click(
+        fn=analyze_weather_data,
+        inputs=[site_id, hours],
+        outputs=[stats_output, weather_plots, wind_rose]
     )
 
-# Launch the app
 if __name__ == "__main__":
     demo.launch()