Update app.py

app.py

@@ -1,19 +1,24 @@
+#!/usr/bin/env python3
+
 import gradio as gr
 import pandas as pd
 import numpy as np
-import re
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+from windrose import WindroseAxes
+from datetime import datetime, timedelta
 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
-from windrose import WindroseAxes
-from datetime import datetime
+from PIL import Image
+import io
+from zoneinfo import ZoneInfo
+import re
 
-# 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...")
@@ -27,347 +32,430 @@ def install_playwright_browsers():
     except Exception as e:
         print(f"Error installing browsers: {e}")
 
-# Install browsers when the module loads
-install_playwright_browsers()
+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 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="
-    
+def navigate_to_previous_day(page):
+    """Navigate to the previous day using specific selector IDs"""
     try:
-        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'
-            )
-            
-            page = context.new_page()
-            response = page.goto(url)
-            print(f"Response status: {response.status}")
+        current_values = page.evaluate('''() => {
+            const monthSelect = document.getElementById('50');
+            const daySelect = document.getElementById('51');
+            const yearSelect = document.getElementById('52');
             
-            page.wait_for_selector('table', timeout=30000)
-            time.sleep(5)
-            
-            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 {
+                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');
                 
-                return getTextContent();
-            }''')
-            
-            print(f"Found {len(content['rows'] if content else [])} rows of data")
-            browser.close()
-            return content
-            
+                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 scraping data: {str(e)}")
-        raise e
+        print(f"Error navigating to previous day: {str(e)}")
+        return False
 
-def parse_date(date_str):
-    """Parse date string to datetime"""
+def extract_day_data(page):
+    """Extract all data from the current day's table"""
     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")
+        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)
         
-    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))
-        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
-
-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)
-    
-    Parameters:
-    df (pandas.DataFrame): DataFrame with datetime and snowfall_3hr columns
-    
-    Returns:
-    float: 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()
-    )
-    
-    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')
+        current_date = page.evaluate('''() => {
+            return {
+                month: document.getElementById('50').value,
+                day: document.getElementById('51').value,
+                year: document.getElementById('52').value
+            };
+        }''')
         
-        # 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")
+        table_data = page.evaluate('''() => {
+            const table = document.querySelector('table');
+            if (!table) return null;
+            
+            const headers = Array.from(table.querySelectorAll('th'))
+                .map(th => th.textContent.trim());
+            
+            const rows = Array.from(table.querySelectorAll('tbody tr'))
+                .map(row => Array.from(row.querySelectorAll('td'))
+                    .map(td => td.textContent.trim()));
+            
+            return { headers, rows };
+        }''')
         
-        # Sum only the valid 3-hour amounts, treating NaN as 0
-        valid_amounts = group['snowfall_3hr'].fillna(0)
-        daily_total = valid_amounts.sum()
+        return current_date, table_data
         
-        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 daily_totals.sum()
-
-def create_daily_snow_plot(df, ax):
-    """
-    Create a daily snow plot showing summed 3-hour amounts
-    """
-    # Create a copy of the dataframe
-    snow_df = df[['datetime', 'snowfall_3hr']].copy()
-    
-    # Create day groups based on 9 AM reset
-    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 totals by summing 3-hour amounts
-    daily_snow = snow_df.groupby('day_group').apply(process_daily_snow).reset_index()
-    daily_snow.columns = ['date', 'new_snow']
-    
-    # Create the bar plot
-    ax.bar(daily_snow['date'], daily_snow['new_snow'], color='blue')
-    ax.set_title('Daily New Snow (Sum of 3-hour amounts, 9 AM Reset)', pad=20)
-    ax.set_xlabel('Date')
-    ax.set_ylabel('New Snow (inches)')
-    ax.tick_params(axis='x', rotation=45)
-    ax.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
-            ax.text(i, v, f'{v:.1f}"', 
-                   ha='center', va='bottom')
-
+    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']
+            
+            if len(row_data) != 9:
+                continue
+            
+            # 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")
+            
+            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
 
+            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
+    
+    if not rows:
+        raise ValueError("No valid data rows to create DataFrame")
+    
+    df = pd.DataFrame(rows)
+    
+    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)
+    df['date'] = df['datetime'].dt.date
+    return df.sort_values('datetime')
 
-    
-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 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
+    
+    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
+            };
+        }''')
+        
+        date_str = f"{current_date['month']}/{current_date['day']}/{current_date['year']}"
+        print(f"Processing date: {date_str}")
+        
+        # Extract data
+        _, table_data = extract_day_data(page)
+        
+        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}")
+    
+    return all_data
 
-def create_plots(df):
-    """Create all weather plots including SWE estimates"""
-    # Create figure with adjusted height and spacing
+def create_comparison_plots(df_alpine, df_ridge=None):
+    """Create weather plots with optional ridge data overlay"""
     fig = plt.figure(figsize=(20, 24))
-    
-    # Calculate height ratios for different plots
-    height_ratios = [1, 1, 1, 1, 1]  # Equal height for all plots
+    height_ratios = [1, 1, 1, 1, 1]
     gs = GridSpec(5, 1, figure=fig, height_ratios=height_ratios)
-    gs.update(hspace=0.4)  # Increase vertical spacing between plots
+    gs.update(hspace=0.4)
     
     # Temperature plot
     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.legend()
-    ax1.grid(True)
+    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.tick_params(axis='x', rotation=45)
     
     # Wind speed plot
     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.legend()
-    ax2.grid(True)
+    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.tick_params(axis='x', rotation=45)
     
     # 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.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.tick_params(axis='x', rotation=45)
     
     # Daily new snow bar plot
     ax4 = fig.add_subplot(gs[3])
-    daily_snow = df.groupby('date')['snowfall_3hr'].sum()
-    ax4.bar(daily_snow.index, daily_snow.values, color='blue')
-    ax4.set_title('Daily New Snow', pad=20)
-    ax4.set_xlabel('Date')
-    ax4.set_ylabel('New Snow (inches)')
+    daily_snow_alpine = calculate_daily_snow(df_alpine)
+    bar_width = 0.35
+    
+    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.tick_params(axis='x', rotation=45)
+    ax4.grid(True, alpha=0.3)
+    if df_ridge is not None:
+        ax4.legend()
     
-    # SWE bar plot
+    # H2O (SWE) 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)')
+    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)
+    
+    ax5.set_title('Snow/Water Equivalent', pad=20, fontsize=14
+
+    ax5.set_xlabel('Date', fontsize=12)
+    ax5.set_ylabel('SWE (inches)', fontsize=12)
     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 separate wind rose figure
+    # Create wind rose (alpine only)
     fig_rose = plt.figure(figsize=(10, 10))
     ax_rose = WindroseAxes.from_ax(fig=fig_rose)
-    create_wind_rose(df, ax_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)
     fig_rose.subplots_adjust(top=0.95, bottom=0.05, left=0.1, right=0.95)
     
     return fig, fig_rose
 
-def analyze_weather_data(site_id, hours):
+def analyze_weather_data(days=3, include_ridge=False):
     """Analyze weather data and create visualizations"""
     try:
-        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",  # Updated to use new calculation
-            '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
-        
+        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
+            
     except Exception as e:
-        print(f"Error in analysis: {str(e)}")
-        return f"Error analyzing data: {str(e)}", None, None
+        print(f"Error during analysis: {str(e)}")
+        return f"Error during analysis: {str(e)}", None, None
 
 # Create Gradio interface
-with gr.Blocks(title="Weather Station Data Analyzer") as demo:
-    gr.Markdown("# Weather Station Data Analyzer")
+with gr.Blocks(title="Bridger Bowl Weather Analyzer") as demo:
+    gr.Markdown("# Bridger Bowl Weather 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)
+    Analyze weather data from Bridger Bowl's weather stations.
+    Specify how many days of historical data to analyze and whether to include Ridge data.
     """)
     
     with gr.Row():
-        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,
+        days_input = gr.Number(
+            label="Number of Days to Analyze",
+            value=3,
             minimum=1,
-            maximum=1440
+            maximum=31
+        )
+        include_ridge = gr.Checkbox(
+            label="Include Ridge Data",
+            value=False
         )
     
-    analyze_btn = gr.Button("Fetch and Analyze Weather Data")
+    analyze_btn = gr.Button("Collect and Analyze Weather Data")
     
     with gr.Row():
-        stats_output = gr.HTML(label="Statistics")
+        stats_output = gr.HTML(label="Statistics and Data Collection Info")
     
     with gr.Row():
         weather_plots = gr.Plot(label="Weather Plots")
@@ -375,9 +463,12 @@ with gr.Blocks(title="Weather Station Data Analyzer") as demo:
     
     analyze_btn.click(
         fn=analyze_weather_data,
-        inputs=[site_id, hours],
+        inputs=[days_input, include_ridge],
         outputs=[stats_output, weather_plots, wind_rose]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    install_playwright_browsers()
+    demo.launch()
+
+