Update app.py

app.py

@@ -1,24 +1,19 @@
-#!/usr/bin/env python3
-
 import gradio as gr
 import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-from windrose import WindroseAxes
-from datetime import datetime, timedelta
+import re
 from playwright.sync_api import sync_playwright
 import time
 import os
 import subprocess
 import sys
-from PIL import Image
-import io
-from zoneinfo import ZoneInfo
-import re
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+from windrose import WindroseAxes
+from datetime import datetime
 
+# Install Playwright browsers on startup
 def install_playwright_browsers():
-    """Install required Playwright browsers"""
     try:
         if not os.path.exists('/home/user/.cache/ms-playwright'):
             print("Installing Playwright browsers...")
@@ -32,429 +27,322 @@ def install_playwright_browsers():
     except Exception as e:
         print(f"Error installing browsers: {e}")
 
-def calculate_daily_snow(df):
-    """Calculate daily new snow based on maximum value before reset time"""
-    df = df.copy()
-    # Create a reporting period identifier (4PM to 4PM)
-    df['report_date'] = df['datetime'].apply(lambda x: 
-        (x - timedelta(hours=16)).date() if x.hour >= 16 
-        else (x - timedelta(days=1, hours=16)).date()
-    )
-    # Group by reporting period and get the maximum new snow value
-    daily_snow = df.groupby('report_date')['new_snow'].max()
-    return daily_snow
-
-def navigate_to_previous_day(page):
-    """Navigate to the previous day using specific selector IDs"""
-    try:
-        current_values = page.evaluate('''() => {
-            const monthSelect = document.getElementById('50');
-            const daySelect = document.getElementById('51');
-            const yearSelect = document.getElementById('52');
-            
-            return {
-                month: parseInt(monthSelect.value),
-                day: parseInt(daySelect.value),
-                year: parseInt(yearSelect.value)
-            };
-        }''')
-        
-        current_date = datetime(
-            current_values['year'],
-            current_values['month'],
-            current_values['day']
-        )
-        previous_date = current_date - timedelta(days=1)
-        
-        print(f"Navigating from {current_date.date()} to {previous_date.date()}")
-        
-        success = page.evaluate('''(prevDate) => {
-            try {
-                const monthSelect = document.getElementById('50');
-                const daySelect = document.getElementById('51');
-                const yearSelect = document.getElementById('52');
-                
-                yearSelect.value = prevDate.year.toString();
-                yearSelect.dispatchEvent(new Event('change', { bubbles: true }));
-                
-                monthSelect.value = prevDate.month.toString();
-                monthSelect.dispatchEvent(new Event('change', { bubbles: true }));
-                
-                daySelect.value = prevDate.day.toString();
-                daySelect.dispatchEvent(new Event('change', { bubbles: true }));
-                
-                return true;
-            } catch (e) {
-                console.error('Error setting date:', e);
-                return false;
-            }
-        }''', {
-            'month': previous_date.month,
-            'day': previous_date.day,
-            'year': previous_date.year
-        })
-        
-        if success:
-            print(f"Successfully navigated to {previous_date.date()}")
-        
-        time.sleep(3)
-        return success
-    except Exception as e:
-        print(f"Error navigating to previous day: {str(e)}")
-        return False
+# Install browsers when the module loads
+install_playwright_browsers()
 
-def extract_day_data(page):
-    """Extract all data from the current day's table"""
+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="
+    
     try:
-        page.evaluate('''() => {
-            const buttons = Array.from(document.querySelectorAll('button'));
-            const showAllBtn = buttons.find(b => b.textContent.trim().toLowerCase() === 'show all');
-            if (showAllBtn) {
-                showAllBtn.click();
-                return true;
-            }
-            return false;
-        }''')
-        time.sleep(2)
-        
-        current_date = page.evaluate('''() => {
-            return {
-                month: document.getElementById('50').value,
-                day: document.getElementById('51').value,
-                year: document.getElementById('52').value
-            };
-        }''')
-        
-        table_data = page.evaluate('''() => {
-            const table = document.querySelector('table');
-            if (!table) return null;
+        with sync_playwright() as p:
+            browser = p.chromium.launch(
+                headless=True,
+                args=['--no-sandbox', '--disable-dev-shm-usage']
+            )
             
-            const headers = Array.from(table.querySelectorAll('th'))
-                .map(th => th.textContent.trim());
+            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'
+            )
             
-            const rows = Array.from(table.querySelectorAll('tbody tr'))
-                .map(row => Array.from(row.querySelectorAll('td'))
-                    .map(td => td.textContent.trim()));
+            page = context.new_page()
+            response = page.goto(url)
+            print(f"Response status: {response.status}")
             
-            return { headers, rows };
-        }''')
-        
-        return current_date, table_data
-        
-    except Exception as e:
-        print(f"Error extracting day data: {str(e)}")
-        return None, None
-
-def convert_to_dataframe(all_data):
-    """Convert collected data to pandas DataFrame format"""
-    rows = []
-    for data in all_data:
-        try:
-            date_str = data['date']
-            row_data = data['data']
+            page.wait_for_selector('table', timeout=30000)
+            time.sleep(5)
             
-            if len(row_data) != 9:
-                continue
+            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();
+            }''')
             
-            # Parse date and time
-            parsed_date = datetime.strptime(f"{date_str}", "%m/%d/%Y")
-            time_str = row_data[0] if row_data[0] else "12:00AM"
-            full_datetime = datetime.strptime(f"{date_str} {time_str}", "%m/%d/%Y %I:%M%p")
+            print(f"Found {len(content['rows'] if content else [])} rows of data")
+            browser.close()
+            return content
             
-            def clean_numeric(value):
-                try:
-                    if isinstance(value, str):
-                        cleaned = re.sub(r'[^\d.-]', '', value)
-                        return float(cleaned) if cleaned else 0.0
-                    return float(value) if value else 0.0
-                except:
-                    return 0.0
+    except Exception as e:
+        print(f"Error scraping data: {str(e)}")
+        raise e
 
-            row = {
-                'datetime': full_datetime,
-                'temp': clean_numeric(row_data[1]),
-                'new_snow': clean_numeric(row_data[2]),
-                'snow_depth': clean_numeric(row_data[3]),
-                'h2o': clean_numeric(row_data[4]),
-                'humidity': clean_numeric(row_data[5]),
-                'wind_speed': clean_numeric(row_data[6]),
-                'wind_gust': clean_numeric(row_data[7]),
-                'wind_dir': row_data[8],
-                'location': data.get('location', 'alpine')
-            }
-            rows.append(row)
-            
-        except Exception as e:
-            print(f"Error processing row: {str(e)}")
-            continue
+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")
+        
+    df = pd.DataFrame(data['rows'])
     
-    if not rows:
-        raise ValueError("No valid data rows to create DataFrame")
+    columns = ['datetime', 'temp', 'dew_point', 'humidity', 'wind_chill', 
+              'wind_dir', 'wind_speed', 'snow_depth', 'snowfall_3hr', 
+              'snowfall_6hr', 'snowfall_24hr', 'swe']
     
-    df = pd.DataFrame(rows)
+    df = df.iloc[:, :12]
+    df.columns = columns
     
-    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
-    }
-    df['wind_dir_deg'] = df['wind_dir'].map(direction_map)
+    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
+        }
+        return direction_map.get(direction, np.nan)
+    
+    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.sort_values('datetime')
+    
+    return df
 
-def scrape_location_data(page, location_id, num_days):
-    """Scrape data for a specific location"""
-    print(f"\nSwitching to location: {location_id}")
-    page.evaluate(f'''() => {{
-        const locationSelect = document.getElementById('48');
-        locationSelect.value = "{location_id}";
-        locationSelect.dispatchEvent(new Event('change', {{ bubbles: true }}));
-    }}''')
-    time.sleep(3)  # Wait for location change to take effect
+def calculate_total_new_snow(df):
+    """
+    Calculate total new snow by:
+    1. Using ONLY the 3-hour snowfall amounts
+    2. Using 9 AM as the daily reset point
+    3. Filtering out obvious anomalies (>9 inches in 3 hours)
+    """
+    # Sort by datetime to ensure correct calculation
+    df = df.sort_values('datetime')
     
-    all_data = []
-    for day in range(num_days):
-        print(f"\nProcessing {location_id} - day {day + 1} of {num_days}")
-        
-        # Get current date
-        current_date = page.evaluate('''() => {
-            return {
-                month: document.getElementById('50').value,
-                day: document.getElementById('51').value,
-                year: document.getElementById('52').value
-            };
-        }''')
+    # 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()
+    )
+    
+    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')
         
-        date_str = f"{current_date['month']}/{current_date['day']}/{current_date['year']}"
-        print(f"Processing date: {date_str}")
+        # Print debugging information
+        print(f"\nSnowfall amounts for {group['day_group'].iloc[0]}:")
+        for _, row in group.iterrows():
+            if pd.notna(row['snowfall_3hr']):
+                print(f"{row['datetime'].strftime('%Y-%m-%d %H:%M')}: {row['snowfall_3hr']} inches")
         
-        # Extract data
-        _, table_data = extract_day_data(page)
+        # Sum only the valid 3-hour amounts, treating NaN as 0
+        valid_amounts = group['snowfall_3hr'].fillna(0)
+        daily_total = valid_amounts.sum()
         
-        if table_data and table_data['rows']:
-            rows_found = len(table_data['rows'])
-            print(f"Found {rows_found} rows of data")
-            
-            for row in table_data['rows']:
-                row_data = {
-                    'date': date_str,
-                    'headers': table_data['headers'],
-                    'data': row,
-                    'location': location_id
-                }
-                all_data.append(row_data)
-            
-            # Navigate to previous day if not the last iteration
-            if day < num_days - 1:
-                success = navigate_to_previous_day(page)
-                if not success:
-                    print("Failed to navigate to previous day!")
-                    break
-                time.sleep(3)
-        else:
-            print(f"No data found for {date_str}")
+        print(f"Daily total: {daily_total} inches")
+        return daily_total
+    
+    # Calculate daily snow totals
+    daily_totals = snow_df.groupby('day_group').apply(process_daily_snow)
     
-    return all_data
+    return daily_totals.sum()
+
+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_comparison_plots(df_alpine, df_ridge=None):
-    """Create weather plots with optional ridge data overlay"""
+def create_plots(df):
+    """Create all weather plots including SWE estimates"""
+    # Create figure with adjusted height and spacing
     fig = plt.figure(figsize=(20, 24))
-    height_ratios = [1, 1, 1, 1, 1]
+    
+    # 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)
+    gs.update(hspace=0.4)  # Increase vertical spacing between plots
     
     # Temperature plot
     ax1 = fig.add_subplot(gs[0])
-    ax1.plot(df_alpine['datetime'], df_alpine['temp'], label='Alpine Temperature', color='red', linewidth=2)
-    if df_ridge is not None:
-        ax1.plot(df_ridge['datetime'], df_ridge['temp'], label='Ridge Temperature', color='darkred', linewidth=2, linestyle='--')
-    ax1.set_title('Temperature Over Time', pad=20, fontsize=14)
-    ax1.set_xlabel('Date', fontsize=12)
-    ax1.set_ylabel('Temperature (°F)', fontsize=12)
-    ax1.legend(fontsize=12)
-    ax1.grid(True, alpha=0.3)
+    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.legend()
+    ax1.grid(True)
     ax1.tick_params(axis='x', rotation=45)
     
     # Wind speed plot
     ax2 = fig.add_subplot(gs[1])
-    ax2.plot(df_alpine['datetime'], df_alpine['wind_speed'], label='Alpine Wind Speed', color='blue', linewidth=2)
-    ax2.plot(df_alpine['datetime'], df_alpine['wind_gust'], label='Alpine Wind Gust', color='orange', linewidth=2)
-    if df_ridge is not None:
-        ax2.plot(df_ridge['datetime'], df_ridge['wind_speed'], label='Ridge Wind Speed', color='darkblue', linewidth=2, linestyle='--')
-        ax2.plot(df_ridge['datetime'], df_ridge['wind_gust'], label='Ridge Wind Gust', color='darkorange', linewidth=2, linestyle='--')
-    ax2.set_title('Wind Speed and Gusts Over Time', pad=20, fontsize=14)
-    ax2.set_xlabel('Date', fontsize=12)
-    ax2.set_ylabel('Wind Speed (mph)', fontsize=12)
-    ax2.legend(fontsize=12)
-    ax2.grid(True, alpha=0.3)
+    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.legend()
+    ax2.grid(True)
     ax2.tick_params(axis='x', rotation=45)
     
     # Snow depth plot
     ax3 = fig.add_subplot(gs[2])
-    ax3.plot(df_alpine['datetime'], df_alpine['snow_depth'], color='blue', label='Alpine Snow Depth', linewidth=2)
-    if df_ridge is not None:
-        ax3.plot(df_ridge['datetime'], df_ridge['snow_depth'], color='darkblue', label='Ridge Snow Depth', linewidth=2, linestyle='--')
-    ax3.set_title('Snow Depth Over Time', pad=20, fontsize=14)
-    ax3.set_xlabel('Date', fontsize=12)
-    ax3.set_ylabel('Snow Depth (inches)', fontsize=12)
-    ax3.legend(fontsize=12)
-    ax3.grid(True, alpha=0.3)
+    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)
     
     # Daily new snow bar plot
     ax4 = fig.add_subplot(gs[3])
-    daily_snow_alpine = calculate_daily_snow(df_alpine)
-    bar_width = 0.35
+    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']
     
-    if df_ridge is not None:
-        daily_snow_ridge = calculate_daily_snow(df_ridge)
-        # Plot bars side by side
-        ax4.bar(daily_snow_alpine.index - bar_width/2, daily_snow_alpine.values, 
-                bar_width, color='blue', alpha=0.7, label='Alpine')
-        ax4.bar(daily_snow_ridge.index + bar_width/2, daily_snow_ridge.values, 
-                bar_width, color='darkblue', alpha=0.7, label='Ridge')
-    else:
-        ax4.bar(daily_snow_alpine.index, daily_snow_alpine.values, color='blue', alpha=0.7)
-        
-    ax4.set_title('Daily New Snow (4PM to 4PM)', pad=20, fontsize=14)
-    ax4.set_xlabel('Date', fontsize=12)
-    ax4.set_ylabel('New Snow (inches)', fontsize=12)
+    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, alpha=0.3)
-    if df_ridge is not None:
-        ax4.legend()
+    ax4.grid(True, axis='y', linestyle='--', alpha=0.7)
     
-    # H2O (SWE) plot
-    ax5 = fig.add_subplot(gs[4])
-    daily_swe_alpine = df_alpine.groupby('date')['h2o'].mean()
-    if df_ridge is not None:
-        daily_swe_ridge = df_ridge.groupby('date')['h2o'].mean()
-        ax5.bar(daily_swe_alpine.index - bar_width/2, daily_swe_alpine.values, 
-                bar_width, color='lightblue', alpha=0.7, label='Alpine')
-        ax5.bar(daily_swe_ridge.index + bar_width/2, daily_swe_ridge.values, 
-                bar_width, color='steelblue', alpha=0.7, label='Ridge')
-    else:
-        ax5.bar(daily_swe_alpine.index, daily_swe_alpine.values, color='lightblue', 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')
     
-    ax5.set_title('Snow/Water Equivalent', pad=20, fontsize=14)
-    ax5.set_xlabel('Date', fontsize=12)
-    ax5.set_ylabel('SWE (inches)', fontsize=12)
+    # 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)
-    ax5.grid(True, alpha=0.3)
-    if df_ridge is not None:
-        ax5.legend()
     
+    # Adjust layout
     plt.subplots_adjust(top=0.95, bottom=0.05, left=0.1, right=0.95)
     
-    # Create wind rose (alpine only)
+    # Create separate wind rose figure
     fig_rose = plt.figure(figsize=(10, 10))
     ax_rose = WindroseAxes.from_ax(fig=fig_rose)
-    ax_rose.bar(df_alpine['wind_dir_deg'].dropna(), df_alpine['wind_speed'].dropna(), 
-                bins=np.arange(0, 40, 5), normed=True, opening=0.8, edgecolor='white')
-    ax_rose.set_legend(title='Wind Speed (mph)', fontsize=10)
-    ax_rose.set_title('Wind Rose (Alpine)', fontsize=14, pad=20)
+    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 analyze_weather_data(days=3, include_ridge=False):
+def analyze_weather_data(site_id, hours):
     """Analyze weather data and create visualizations"""
     try:
-        print("Launching browser...")
-        with sync_playwright() as p:
-            browser = p.chromium.launch(
-                headless=True,
-                args=['--no-sandbox', '--disable-dev-shm-usage']
-            )
-            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',
-                timezone_id='America/Denver',
-                locale='en-US'
-            )
-            
-            print("Opening page...")
-            page = context.new_page()
-            page.goto("https://bridgerbowl.com/weather/history-tables/alpine")
-            page.wait_for_load_state('networkidle')
-            time.sleep(5)
-            
-            # Scrape Alpine data
-            print("\nScraping Alpine data...")
-            alpine_data = scrape_location_data(page, "alpine", days)
-            df_alpine = convert_to_dataframe(alpine_data)
-            
-            # Scrape Ridge data if requested
-            df_ridge = None
-            if include_ridge:
-                print("\nScraping Ridge data...")
-                ridge_data = scrape_location_data(page, "ridge", days)
-                df_ridge = convert_to_dataframe(ridge_data)
-            
-            # Create plots and statistics
-            print("\nCreating plots...")
-            main_plots, wind_rose = create_comparison_plots(df_alpine, df_ridge)
-            
-            # Calculate statistics
-            alpine_snow = calculate_daily_snow(df_alpine)
-            stats = {
-                'Alpine Temperature Range': f"{df_alpine['temp'].min():.1f}°F to {df_alpine['temp'].max():.1f}°F",
-                'Alpine Average Temperature': f"{df_alpine['temp'].mean():.1f}°F",
-                'Alpine Max Wind Speed': f"{df_alpine['wind_speed'].max():.1f} mph",
-                'Alpine Max Wind Gust': f"{df_alpine['wind_gust'].max():.1f} mph",
-                'Alpine Current Snow Depth': f"{df_alpine['snow_depth'].iloc[0]:.1f} inches",
-                'Alpine Total New Snow': f"{alpine_snow.sum():.1f} inches",
-                'Alpine Current SWE': f"{df_alpine['h2o'].iloc[0]:.2f} inches"
-            }
-            
-            if include_ridge and df_ridge is not None:
-                ridge_snow = calculate_daily_snow(df_ridge)
-                stats.update({
-                    'Ridge Temperature Range': f"{df_ridge['temp'].min():.1f}°F to {df_ridge['temp'].max():.1f}°F",
-                    'Ridge Average Temperature': f"{df_ridge['temp'].mean():.1f}°F",
-                    'Ridge Max Wind Speed': f"{df_ridge['wind_speed'].max():.1f} mph",
-                    'Ridge Max Wind Gust': f"{df_ridge['wind_gust'].max():.1f} mph",
-                    'Ridge Current Snow Depth': f"{df_ridge['snow_depth'].iloc[0]:.1f} inches",
-                    'Ridge Total New Snow': f"{ridge_snow.sum():.1f} inches",
-                    'Ridge Current SWE': f"{df_ridge['h2o'].iloc[0]:.2f} inches"
-                })
-            
-            # Create HTML report
-            html_report = "<h3>Weather Statistics:</h3>"
-            for key, value in stats.items():
-                html_report += f"<p><strong>{key}:</strong> {value}</p>"
-            
-            browser.close()
-            return html_report, main_plots, wind_rose
-            
+        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
+        
+        print("Parsing data...")    
+        df = parse_weather_data(raw_data)
+        
+        # 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
+        
     except Exception as e:
-        print(f"Error during analysis: {str(e)}")
-        return f"Error during analysis: {str(e)}", None, None
+        print(f"Error in analysis: {str(e)}")
+        return f"Error analyzing data: {str(e)}", None, None
 
 # Create Gradio interface
-with gr.Blocks(title="Bridger Bowl Weather Analyzer") as demo:
-    gr.Markdown("# Bridger Bowl Weather Analyzer")
+with gr.Blocks(title="Weather Station Data Analyzer") as demo:
+    gr.Markdown("# Weather Station Data Analyzer")
     gr.Markdown("""
-    Analyze weather data from Bridger Bowl's weather stations.
-    Specify how many days of historical data to analyze and whether to include Ridge data.
+    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():
-        days_input = gr.Number(
-            label="Number of Days to Analyze",
-            value=3,
-            minimum=1,
-            maximum=31
+        site_id = gr.Textbox(
+            label="Weather Station ID",
+            value="YCTIM",
+            placeholder="Enter station ID (e.g., YCTIM)"
         )
-        include_ridge = gr.Checkbox(
-            label="Include Ridge Data",
-            value=False
+        hours = gr.Number(
+            label="Hours of Data",
+            value=720,
+            minimum=1,
+            maximum=1440
         )
     
-    analyze_btn = gr.Button("Collect and Analyze Weather Data")
+    analyze_btn = gr.Button("Fetch and Analyze Weather Data")
     
     with gr.Row():
-        stats_output = gr.HTML(label="Statistics and Data Collection Info")
+        stats_output = gr.HTML(label="Statistics")
     
     with gr.Row():
         weather_plots = gr.Plot(label="Weather Plots")
@@ -462,10 +350,9 @@ with gr.Blocks(title="Bridger Bowl Weather Analyzer") as demo:
     
     analyze_btn.click(
         fn=analyze_weather_data,
-        inputs=[days_input, include_ridge],
+        inputs=[site_id, hours],
         outputs=[stats_output, weather_plots, wind_rose]
     )
 
 if __name__ == "__main__":
-    install_playwright_browsers()
     demo.launch()