Update app.py

app.py

@@ -139,11 +139,10 @@ def parse_weather_data(data):
 
 def calculate_total_new_snow(df):
     """
-    Calculate total new snow with strict anomaly filtering:
-    1. Daily reset at 9 AM
-    2. Maximum 3 inch per hour increase
-    3. Complete removal of anomalous days
-    4. Continuous validation of accumulation rates
+    Calculate total new snow by:
+    1. Looking at values before 9 AM each day
+    2. Ensuring reasonable hourly change rates (max 3 inches/hour)
+    3. Allowing high totals if they accumulate gradually
     
     Parameters:
     df (pandas.DataFrame): DataFrame with datetime and snowfall_3hr columns
@@ -162,73 +161,72 @@ def calculate_total_new_snow(df):
         lambda x: x.date() if x.hour >= 9 else (x - pd.Timedelta(days=1)).date()
     )
     
-    def validate_snow_sequence(values):
+    def validate_sequence(values, times):
         """
-        Validate a sequence of snow measurements within a day
-        Returns cleaned measurements with anomalies removed
+        Validate a sequence of snow readings by checking hourly change rates.
+        Returns the most reliable final value.
         """
-        if len(values) == 0:
-            return []
+        if len(values) <= 1:
+            return values[-1] if len(values) > 0 else 0.0
         
-        valid_values = []
-        current_valid = values[0] if values[0] <= 3.0 else 0.0
+        # Calculate hour-to-hour changes
+        changes = np.diff(values)
         
-        for i in range(1, len(values)):
-            change = values[i] - values[i-1]
-            
-            # Check if this measurement is valid
-            if change >= 0 and change <= 3.0:
-                current_valid = values[i]
-            else:
-                # If invalid, maintain the last valid measurement
-                values[i] = current_valid
+        # If any change is too large (> 3 inches per hour), we need to find the reliable sequence
+        if any(change > 3.0 for change in changes):
+            # Find the longest sequence of reasonable changes
+            valid_indices = [0]  # Start with first reading
+            current_value = values[0]
             
-            valid_values.append(current_valid)
+            for i in range(1, len(values)):
+                change = values[i] - values[i-1]
+                if 0 <= change <= 3.0:  # Allow only positive changes up to 3 inches
+                    valid_indices.append(i)
+                    current_value = values[i]
+                else:
+                    # Check if this might be a reset (value lower than previous)
+                    if values[i] < values[i-1]:
+                        # If it looks like a reset, start new sequence
+                        current_value = values[i]
+                        valid_indices.append(i)
+                    else:
+                        # If it's a spike, ignore it
+                        values[i] = current_value
             
-        return valid_values
+            # Return the last valid value
+            return values[valid_indices[-1]]
+        else:
+            # If all changes are reasonable, use the last value
+            return values[-1]
     
     def process_daily_snow(group):
         """Process snow measurements for a single day period"""
-        if len(group) == 0:
+        # Only look at measurements before 9 AM
+        morning_data = group[group['datetime'].dt.hour < 9].copy()
+        
+        if len(morning_data) == 0:
             return 0.0
-            
-        # Sort measurements by time
-        group = group.sort_values('datetime')
         
-        # Get the snow measurements
-        measurements = group['snowfall_3hr'].values
+        # Sort by time to ensure proper sequence
+        morning_data = morning_data.sort_values('datetime')
         
-        # If we see any extremely high values (>21 inches), invalidate the entire day
-        if any(m > 21.0 for m in measurements):
-            return 0.0
-            
-        # Clean the measurements
-        valid_measurements = validate_snow_sequence(measurements)
+        values = morning_data['snowfall_3hr'].values
+        times = morning_data['datetime'].values
         
-        # Calculate the daily total from valid measurements
-        if valid_measurements:
-            # Get the maximum valid measurement for the day
-            daily_total = max(valid_measurements)
-            
-            # Additional sanity check - if total is too high, return 0
-            if daily_total > 12.0:  # Max reasonable daily total
-                return 0.0
-                
-            return daily_total
-            
-        return 0.0
+        # Validate the sequence and get the final value
+        daily_total = validate_sequence(values, times)
+        
+        return daily_total
     
-    # Process each day
+    # Calculate daily snow totals
     daily_totals = snow_df.groupby('day_group').apply(process_daily_snow)
     
-    # Remove any remaining anomalous days (days with unusually high totals)
-    daily_totals = daily_totals.where(daily_totals <= 12.0, 0.0)
-    
     return daily_totals.sum()
 
 def create_daily_snow_plot(df, ax):
     """
-    Create an improved daily snow plot with strict anomaly filtering
+    Create an improved daily snow plot focusing on pre-9 AM totals
+    with validation of hourly change rates
     """
     # Create a copy of the dataframe
     snow_df = df[['datetime', 'snowfall_3hr']].copy()
@@ -242,9 +240,6 @@ def create_daily_snow_plot(df, ax):
     daily_snow = snow_df.groupby('day_group').apply(process_daily_snow).reset_index()
     daily_snow.columns = ['date', 'new_snow']
     
-    # Additional filtering for the plot
-    daily_snow = daily_snow[daily_snow['new_snow'] <= 12.0]  # Remove any remaining anomalous days
-    
     # Create the bar plot
     ax.bar(daily_snow['date'], daily_snow['new_snow'], color='blue')
     ax.set_title('Daily New Snow (9 AM Reset)', pad=20)
@@ -252,9 +247,6 @@ def create_daily_snow_plot(df, ax):
     ax.set_ylabel('New Snow (inches)')
     ax.tick_params(axis='x', rotation=45)
     ax.grid(True, axis='y', linestyle='--', alpha=0.7)
-    
-    # Set reasonable y-axis limits
-    ax.set_ylim(0, max(12, daily_snow['new_snow'].max() * 1.1))
 
 def create_daily_snow_plot(df, ax):
     """