Implement natural NOAA-style weather text forecasting

- Replace mechanical bullet points with flowing narrative paragraphs
- Add comprehensive overview paragraph with weather pattern analysis
- Implement period-based forecasts (Today, Tonight, Tomorrow, etc.)
- Create natural timing narratives instead of repetitive alerts
- Use authentic NOAA phraseology and sentence structure
- Generate contextual weather descriptions combining conditions

Features natural language like:
"A persistent weather system will bring frequent periods of rain,
with some heavy downpours possible. Temperatures will be mild
with highs near 21°C and overnight lows dropping to 9°C."

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -663,72 +663,239 @@ def analyze_weather_events(forecast_data):
 def generate_forecast_text(forecast_data, location_name="Selected Location"):
     """
     Generate NOAA-style forecast text from gridded data
-    Similar to NWS Zone Forecast Product (ZFP) formatting
+    Natural flowing language similar to NWS Zone Forecast Products
     """
     events = analyze_weather_events(forecast_data)
+    current_time = datetime.now()
+    
+    # Analyze overall conditions and trends
+    temperatures = forecast_data['temperature']
+    precipitation = forecast_data.get('precipitation', [0] * len(temperatures))
+    wind_speeds = forecast_data['wind_speed']
+    humidity = forecast_data['humidity']
+    
+    # Calculate key statistics
+    max_temp = max(temperatures)
+    min_temp = min(temperatures)
+    avg_precip = sum(precipitation) / len(precipitation) if precipitation else 0
+    max_wind = max(wind_speeds)
+    
+    # Determine dominant weather pattern
+    rain_hours = sum(1 for p in precipitation if p > 0.1)
+    heavy_rain_hours = sum(1 for p in precipitation if p > 2.0)
+    windy_hours = sum(1 for w in wind_speeds if w > 10)
+    
+    forecast_text = f"**{location_name} Extended Forecast**\n\n"
+    forecast_text += f"Issued {current_time.strftime('%A %B %d, %Y at %I:%M %p')}\n\n"
+    
+    # Generate overview paragraph
+    overview = generate_overview_paragraph(rain_hours, heavy_rain_hours, windy_hours, max_temp, min_temp, max_wind, len(temperatures))
+    forecast_text += overview + "\n\n"
+    
+    # Generate detailed daily forecasts with natural language
+    daily_forecasts = generate_daily_detailed_forecasts(forecast_data, events)
+    forecast_text += daily_forecasts
+    
+    # Add specific timing information in narrative form
+    timing_narrative = generate_timing_narrative(events, precipitation, forecast_data['timestamps'])
+    if timing_narrative:
+        forecast_text += "\n" + timing_narrative + "\n"
+    
+    # Add any significant weather advisories
+    advisories = generate_advisories(events)
+    if advisories:
+        forecast_text += "\n**Weather Advisories:**\n" + advisories
+    
+    return forecast_text
+
+def generate_overview_paragraph(rain_hours, heavy_rain_hours, windy_hours, max_temp, min_temp, max_wind, total_hours):
+    """Generate a natural overview paragraph like NOAA"""
+    overview_parts = []
+    
+    # Temperature narrative
+    if max_temp > 25:
+        temp_desc = f"warm with highs reaching {max_temp:.0f}°C"
+    elif max_temp < 10:
+        temp_desc = f"cool with highs only reaching {max_temp:.0f}°C"
+    else:
+        temp_desc = f"mild with highs near {max_temp:.0f}°C"
+    
+    if min_temp < 0:
+        temp_desc += f" and overnight lows dropping to {min_temp:.0f}°C"
+    elif abs(max_temp - min_temp) > 15:
+        temp_desc += f" with significant cooling overnight to {min_temp:.0f}°C"
+    
+    # Weather pattern narrative
+    if rain_hours > total_hours * 0.6:
+        if heavy_rain_hours > 3:
+            weather_pattern = "A persistent weather system will bring frequent periods of rain, with some heavy downpours possible"
+        else:
+            weather_pattern = "Unsettled weather with rain likely through much of the forecast period"
+    elif rain_hours > total_hours * 0.3:
+        weather_pattern = "Scattered showers and periods of rain expected"
+    elif rain_hours > 0:
+        weather_pattern = "A few light showers possible"
+    else:
+        weather_pattern = "Generally dry conditions expected"
     
-    # Group events by time periods
-    periods = []
+    # Wind narrative
+    if max_wind > 15:
+        weather_pattern += f", accompanied by gusty winds up to {max_wind:.0f} m/s"
+    elif windy_hours > total_hours * 0.4:
+        weather_pattern += " with breezy conditions at times"
+    
+    return f"{weather_pattern}. Temperatures will be {temp_desc}."
+
+def generate_daily_detailed_forecasts(forecast_data, events):
+    """Generate detailed daily forecasts in natural NOAA style"""
     current_time = datetime.now()
+    forecasts = []
     
-    # Define forecast periods
-    period_definitions = [
-        ('This Afternoon', 12, 18),
-        ('Tonight', 18, 6),
-        ('Tomorrow', 6, 18),
-        ('Tomorrow Night', 18, 6),
-        ('Day 3', 6, 18),
-        ('Day 3 Night', 18, 6),
-        ('Day 4', 6, 18)
-    ]
-    
-    forecast_text = f"**Weather Forecast for {location_name}**\n\n"
-    forecast_text += f"Issued: {current_time.strftime('%A, %B %d, %Y at %I:%M %p %Z')}\n\n"
-    
-    # Process each time period
-    for period_name, start_hour, end_hour in period_definitions:
-        period_events = []
-        period_temps = []
-        
-        # Find events in this period
-        for event in events:
-            event_hour = event['time'].hour
-            
-            if start_hour <= end_hour:  # Same day period
-                if start_hour <= event_hour < end_hour:
-                    period_events.append(event)
-            else:  # Overnight period
-                if event_hour >= start_hour or event_hour < end_hour:
-                    period_events.append(event)
-        
-        if not period_events:
-            continue
-            
-        # Get temperature range for period
-        period_temps = [forecast_data['temperature'][i] for i, ts in enumerate(forecast_data['timestamps']) 
-                       if ts in [e['time'] for e in period_events]]
+    # Group data by days
+    timestamps = forecast_data['timestamps']
+    temperatures = forecast_data['temperature']
+    precipitation = forecast_data.get('precipitation', [0] * len(temperatures))
+    wind_speeds = forecast_data['wind_speed']
+    humidity = forecast_data['humidity']
+    
+    # Process 4 days of forecasts
+    for day_offset in range(4):
+        target_date = current_time + timedelta(days=day_offset)
         
-        if period_temps:
-            min_temp = min(period_temps)
-            max_temp = max(period_temps)
-        else:
+        # Get day and night periods
+        day_start = target_date.replace(hour=6, minute=0, second=0, microsecond=0)
+        day_end = target_date.replace(hour=18, minute=0, second=0, microsecond=0)
+        night_end = (target_date + timedelta(days=1)).replace(hour=6, minute=0, second=0, microsecond=0)
+        
+        # Find data for this day
+        day_indices = [i for i, ts in enumerate(timestamps) 
+                      if day_start <= ts < day_end]
+        night_indices = [i for i, ts in enumerate(timestamps) 
+                        if day_end <= ts < night_end]
+        
+        if not day_indices and not night_indices:
             continue
         
-        # Generate period text
-        period_text = generate_period_text(period_name, period_events, min_temp, max_temp)
-        forecast_text += period_text + "\n\n"
+        # Day period
+        if day_indices:
+            day_temps = [temperatures[i] for i in day_indices]
+            day_precip = [precipitation[i] for i in day_indices if i < len(precipitation)]
+            day_winds = [wind_speeds[i] for i in day_indices]
+            
+            day_high = max(day_temps) if day_temps else 20
+            day_rain = any(p > 0.1 for p in day_precip)
+            day_heavy_rain = any(p > 2.0 for p in day_precip)
+            day_windy = any(w > 12 for w in day_winds)
+            
+            # Generate day forecast
+            if day_offset == 0:
+                period_name = "Today"
+            elif day_offset == 1:
+                period_name = "Tomorrow"
+            else:
+                period_name = target_date.strftime("%A")
+            
+            day_forecast = generate_period_narrative(period_name, day_high, None, day_rain, day_heavy_rain, day_windy, True)
+            forecasts.append(day_forecast)
+        
+        # Night period
+        if night_indices:
+            night_temps = [temperatures[i] for i in night_indices]
+            night_precip = [precipitation[i] for i in night_indices if i < len(precipitation)]
+            night_winds = [wind_speeds[i] for i in night_indices]
+            
+            night_low = min(night_temps) if night_temps else 10
+            night_rain = any(p > 0.1 for p in night_precip)
+            night_heavy_rain = any(p > 2.0 for p in night_precip)
+            night_windy = any(w > 12 for w in night_winds)
+            
+            # Generate night forecast
+            if day_offset == 0:
+                night_name = "Tonight"
+            elif day_offset == 1:
+                night_name = "Tomorrow Night"
+            else:
+                night_name = f"{target_date.strftime('%A')} Night"
+            
+            night_forecast = generate_period_narrative(night_name, None, night_low, night_rain, night_heavy_rain, night_windy, False)
+            forecasts.append(night_forecast)
     
-    # Add specific event timing predictions
-    timing_alerts = generate_timing_alerts(events)
-    if timing_alerts:
-        forecast_text += "**Timing Details:**\n" + timing_alerts + "\n\n"
+    return '\n\n'.join(forecasts)
+
+def generate_period_narrative(period_name, high_temp, low_temp, has_rain, heavy_rain, windy, is_day):
+    """Generate natural narrative for a specific period"""
+    conditions = []
+    
+    # Weather conditions
+    if heavy_rain:
+        conditions.append("heavy rain at times")
+    elif has_rain:
+        conditions.append("periods of rain")
+    
+    if windy:
+        if conditions:
+            conditions.append("gusty winds")
+        else:
+            conditions.append("breezy conditions")
     
-    # Add weather advisories
-    advisories = generate_advisories(events)
-    if advisories:
-        forecast_text += "**Weather Advisories:**\n" + advisories + "\n\n"
+    # Build the narrative
+    if is_day:
+        if conditions:
+            weather_text = f"**{period_name}:** {', '.join(conditions).capitalize()}"
+        else:
+            weather_text = f"**{period_name}:** Partly cloudy"
+        
+        if high_temp:
+            weather_text += f". High {high_temp:.0f}°C"
+    else:
+        if conditions:
+            weather_text = f"**{period_name}:** {', '.join(conditions).capitalize()}"
+        else:
+            weather_text = f"**{period_name}:** Mostly clear"
+        
+        if low_temp:
+            weather_text += f". Low {low_temp:.0f}°C"
     
-    return forecast_text
+    weather_text += "."
+    return weather_text
+
+def generate_timing_narrative(events, precipitation, timestamps):
+    """Generate narrative timing information rather than bullet points"""
+    if not events or not any(p > 0.1 for p in precipitation):
+        return ""
+    
+    # Find rain periods
+    rain_periods = []
+    in_rain = False
+    rain_start = None
+    
+    for i, (ts, precip) in enumerate(zip(timestamps, precipitation)):
+        if precip > 0.1 and not in_rain:
+            rain_start = ts
+            in_rain = True
+        elif precip <= 0.1 and in_rain:
+            rain_periods.append((rain_start, timestamps[i-1]))
+            in_rain = False
+    
+    if in_rain and rain_start:
+        rain_periods.append((rain_start, timestamps[-1]))
+    
+    if not rain_periods:
+        return ""
+    
+    # Create narrative
+    if len(rain_periods) == 1:
+        start, end = rain_periods[0]
+        return f"Rain expected from approximately {start.strftime('%I %p')} through {end.strftime('%I %p')}."
+    elif len(rain_periods) <= 3:
+        timing_text = "Periods of rain expected "
+        times = []
+        for start, end in rain_periods:
+            times.append(f"{start.strftime('%I %p')}-{end.strftime('%I %p')}")
+        timing_text += " and ".join(times[:-1]) + f" and {times[-1]}." if len(times) > 1 else times[0] + "."
+        return timing_text
+    else:
+        return "Multiple rounds of rain expected throughout the forecast period with the heaviest amounts during afternoon and evening hours."
 
 def generate_period_text(period_name, events, min_temp, max_temp):
     """