Remove all fallback data - fail fast if DWD ICON unavailable

- Remove fetch_fallback_data() and process_fallback_data() functions
- Replace all fallback calls with proper error exceptions
- Update error handling to fail cleanly with informative messages
- Remove synthetic data generation and fallback processing
- Simplify plot creation by removing fallback data handling
- Application now works only with real DWD ICON data or fails

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

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

app.py

@@ -226,8 +226,7 @@ def fetch_dwd_icon_data(lat, lon):
         print(f"Fetching real DWD ICON data for {lat:.3f}°N, {lon:.3f}°E")
         
         if not GRIB_AVAILABLE:
-            print("Warning: GRIB2 libraries not available, using fallback data")
-            return fetch_fallback_data(lat, lon)
+            raise Exception("GRIB2 libraries not available. Install cfgrib and pygrib for DWD ICON data access.")
         
         # Get latest model run
         run_date = get_latest_dwd_run()
@@ -250,16 +249,14 @@ def fetch_dwd_icon_data(lat, lon):
         clat_file, clon_file = download_dwd_coordinate_files(run_date)
         
         if not clat_file or not clon_file:
-            print("Failed to download coordinate files, using fallback")
-            return fetch_fallback_data(lat, lon)
+            raise Exception("Failed to download coordinate files from DWD ICON server")
         
         # Parse coordinate files
         clat_ds = parse_grib_file(clat_file)
         clon_ds = parse_grib_file(clon_file)
         
         if clat_ds is None or clon_ds is None:
-            print("Failed to parse coordinate files, using fallback")
-            return fetch_fallback_data(lat, lon)
+            raise Exception("Failed to parse coordinate files from DWD ICON server")
         
         # Get coordinate arrays
         # DWD coordinate files may use different variable names
@@ -287,7 +284,7 @@ def fetch_dwd_icon_data(lat, lon):
             print(f"Error extracting coordinate arrays: {e}")
             print(f"CLAT dataset: {clat_ds}")
             print(f"CLON dataset: {clon_ds}")
-            return fetch_fallback_data(lat, lon)
+            raise Exception(f"Failed to extract coordinate arrays: {e}")
         
         # Find nearest grid point
         nearest_idx = find_nearest_grid_point(lat, lon, grid_lats, grid_lons)
@@ -353,76 +350,8 @@ def fetch_dwd_icon_data(lat, lon):
         print(f"Error fetching real DWD ICON data: {e}")
         import traceback
         traceback.print_exc()
-        return fetch_fallback_data(lat, lon)
+        raise Exception(f"Failed to fetch DWD ICON data: {e}")
 
-def fetch_fallback_data(lat, lon):
-    """
-    Generate realistic fallback data when real DWD data is unavailable
-    """
-    print("Using fallback synthetic data")
-    
-    current_time = datetime.now(timezone.utc)
-    forecast_hours = []
-    
-    # Generate forecast times - 4 days with 6-hour intervals
-    for i in range(0, 97, 6):  # Every 6 hours for 4 days
-        forecast_time = current_time + timedelta(hours=i)
-        forecast_hours.append(forecast_time)
-    
-    # Create realistic weather patterns based on location and season
-    import math
-    base_temp = 15 + 10 * math.sin((current_time.timetuple().tm_yday - 80) * 2 * math.pi / 365)
-    
-    simulated_data = {
-        "location": {"lat": lat, "lon": lon, "name": f"Location {lat:.2f}°N, {lon:.2f}°E"},
-        "current": {
-            "temp_c": base_temp,
-            "humidity": 65,
-            "wind_kph": 15,
-            "pressure_mb": 1013,
-            "cloud": 40,
-            "vis_km": 10
-        },
-        "forecast": {
-            "forecastday": []
-        }
-    }
-    
-    # Generate daily data
-    current_day = None
-    day_data = None
-    
-    for i, forecast_time in enumerate(forecast_hours):
-        if forecast_time.date() != current_day:
-            if day_data:
-                simulated_data["forecast"]["forecastday"].append(day_data)
-            
-            current_day = forecast_time.date()
-            day_data = {
-                "date": current_day.strftime("%Y-%m-%d"),
-                "hour": []
-            }
-        
-        # Generate hourly data
-        hour_temp = base_temp + 5 * math.sin(forecast_time.hour * math.pi / 12) + 2 * math.sin(i * 0.1)
-        hour_data = {
-            "time": forecast_time.strftime("%Y-%m-%d %H:%M"),
-            "temp_c": hour_temp,
-            "humidity": int(60 + 20 * math.cos(forecast_time.hour * math.pi / 12 + i * 0.1)),
-            "wind_kph": 10 + 8 * math.sin(forecast_time.hour * math.pi / 8 + i * 0.05),
-            "wind_dir": int((forecast_time.hour * 15 + i * 5) % 360),
-            "pressure_mb": 1013 + 5 * math.sin(forecast_time.hour * math.pi / 12),
-            "precip_mm": max(0, math.sin(forecast_time.hour * math.pi / 6 + i * 0.2) * 0.5),
-            "cloud": int(30 + 40 * math.sin(forecast_time.hour * math.pi / 10 + i * 0.15)),
-            "vis_km": 10 + 5 * math.cos(forecast_time.hour * math.pi / 12),
-            "gust_kph": 15 + 10 * math.sin(forecast_time.hour * math.pi / 6 + i * 0.1)
-        }
-        day_data["hour"].append(hour_data)
-    
-    if day_data:
-        simulated_data["forecast"]["forecastday"].append(day_data)
-    
-    return simulated_data
 
 def get_forecast_data(lat, lon, forecast_hour="00"):
     """
@@ -434,13 +363,11 @@ def get_forecast_data(lat, lon, forecast_hour="00"):
         # Fetch data from DWD ICON model
         weather_data = fetch_dwd_icon_data(lat, lon)
         
-        # Check if we got real DWD data or fallback data
+        # Process real DWD GRIB2 data only
         if 'weather_data' in weather_data:
-            # Real DWD GRIB2 data
             return process_real_dwd_data(weather_data, lat, lon)
         else:
-            # Fallback simulated data
-            return process_fallback_data(weather_data, lat, lon)
+            raise Exception(\"Invalid weather data format received from DWD ICON server\")
             
     except Exception as e:
         import traceback
@@ -449,27 +376,8 @@ def get_forecast_data(lat, lon, forecast_hour="00"):
         print("Full error traceback:")
         print(traceback.format_exc())
         
-        # Return fallback synthetic data with error note
-        forecast_days = 4
-        hours = np.arange(0, forecast_days * 24, 6)
-        np.random.seed(int(lat * 100 + lon * 100))
-        
-        current_date = datetime.now()
-        timestamps = [current_date + timedelta(hours=int(h)) for h in hours]
-        temperature = 15 + 10 * np.sin(hours * np.pi / 12) + np.random.normal(0, 2, len(hours))
-        humidity = 60 + 20 * np.sin(hours * np.pi / 24 + np.pi/4) + np.random.normal(0, 5, len(hours))
-        wind_speed = 5 + 3 * np.sin(hours * np.pi / 18) + np.random.normal(0, 1, len(hours))
-        
-        return {
-            'timestamps': timestamps,
-            'temperature': temperature,
-            'humidity': humidity,
-            'wind_speed': wind_speed,
-            'lat': lat,
-            'lon': lon,
-            'error': error_msg,
-            'forecast_date': 'Fallback synthetic data'
-        }
+        # No fallback - raise the error
+        raise Exception(error_msg)
 
 def process_real_dwd_data(dwd_data, lat, lon):
     """
@@ -651,63 +559,6 @@ def process_real_dwd_data(dwd_data, lat, lon):
         print(f"Error processing real DWD data: {e}")
         raise e
 
-def process_fallback_data(weather_data, lat, lon):
-    """
-    Process fallback simulated data into forecast format
-    """
-    # Extract hourly forecast data
-    timestamps = []
-    temperature = []
-    humidity = []
-    wind_speed = []
-    wind_direction = []
-    wind_gust = []
-    pressure = []
-    precipitation = []
-    cloud_cover = []
-    visibility = []
-    
-    # Process hourly data from all forecast days
-    for day_forecast in weather_data["forecast"]["forecastday"]:
-        for hour_data in day_forecast["hour"]:
-            # Parse timestamp
-            timestamp = datetime.strptime(hour_data["time"], "%Y-%m-%d %H:%M")
-            timestamps.append(timestamp)
-            
-            # Extract weather variables
-            temperature.append(hour_data["temp_c"])
-            humidity.append(hour_data["humidity"])
-            wind_speed.append(hour_data["wind_kph"] * 0.277778)  # Convert kph to m/s
-            wind_direction.append(hour_data["wind_dir"])
-            wind_gust.append(hour_data["gust_kph"] * 0.277778)  # Convert kph to m/s
-            pressure.append(hour_data["pressure_mb"])
-            precipitation.append(hour_data["precip_mm"])
-            cloud_cover.append(hour_data["cloud"])
-            visibility.append(hour_data["vis_km"])
-    
-    # Limit to reasonable forecast length (4 days = 96 hours)
-    max_hours = min(len(timestamps), 96)
-    
-    result = {
-        'timestamps': timestamps[:max_hours],
-        'temperature': temperature[:max_hours],
-        'humidity': humidity[:max_hours],
-        'wind_speed': wind_speed[:max_hours],
-        'wind_direction': wind_direction[:max_hours],
-        'wind_gust': wind_gust[:max_hours],
-        'pressure': pressure[:max_hours],
-        'precipitation': precipitation[:max_hours],
-        'cloud_cover': cloud_cover[:max_hours],
-        'visibility': visibility[:max_hours],
-        'lat': lat,
-        'lon': lon,
-        'forecast_date': datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC'),
-        'data_source': 'DWD ICON Model (Simulated)',
-        'location_name': weather_data["location"]["name"]
-    }
-    
-    print(f"Successfully processed {len(timestamps)} hours of fallback forecast data")
-    return result
 
 def analyze_weather_events(forecast_data):
     """
@@ -1593,8 +1444,8 @@ def create_forecast_plot(forecast_data):
     ax9 = fig.add_subplot(gs[2, 2])
     ax9.axis('off')
     
-    # Check if we have real data or fallback
-    data_source = "Real DWD ICON Data" if 'error' not in forecast_data else "Fallback Synthetic Data"
+    # Only real DWD ICON data now
+    data_source = "Real DWD ICON Data"
     forecast_info = forecast_data.get('forecast_date', 'Unknown')
     
     # Grid point info
@@ -1638,11 +1489,7 @@ Wind: {forecast_data['wind_speed'][0]:.1f} m/s
     if 'pressure' in forecast_data:
         summary_text += f"Pressure: {forecast_data['pressure'][0]:.1f} hPa\n"
     
-    # Add error info if present
-    if 'error' in forecast_data:
-        summary_text += f"\nNote: Using fallback data\nReason: {forecast_data['error'][:80]}..."
-    
-    color = 'lightgreen' if 'error' not in forecast_data else 'lightyellow'
+    color = 'lightgreen'
     ax9.text(0.05, 0.95, summary_text, transform=ax9.transAxes, fontsize=8,
             verticalalignment='top', bbox=dict(boxstyle='round', facecolor=color, alpha=0.7))
     
@@ -1655,30 +1502,27 @@ def process_map_click(lat, lon):
     if lat is None or lon is None:
         return "Please click on the map to select a location", None, ""
     
-    # Get forecast data
-    forecast_data = get_forecast_data(lat, lon)
-    
-    # Create plot
-    plot = create_forecast_plot(forecast_data)
-    
-    # Create summary text
-    if isinstance(forecast_data, dict):
-        data_type = "Real DWD ICON Data" if 'error' not in forecast_data else "Fallback Data"
+    try:
+        # Get forecast data - will raise exception if it fails
+        forecast_data = get_forecast_data(lat, lon)
+        
+        # Create plot
+        plot = create_forecast_plot(forecast_data)
+        
+        # Create summary text
+        data_type = "Real DWD ICON Data"
         forecast_info = forecast_data.get('forecast_date', '')
         summary = f"Forecast for location: {lat:.3f}°N, {lon:.3f}°E\n\nUsing: {data_type}\nForecast: {forecast_info}"
         
-        if 'error' in forecast_data:
-            summary += f"\n\nNote: Real data unavailable - {forecast_data['error'][:150]}..."
-        
         # Generate NOAA-style text forecast
         location_name = forecast_data.get('location_name', f"{lat:.2f}°N, {lon:.2f}°E")
         text_forecast = generate_forecast_text(forecast_data, location_name)
         
-    else:
-        summary = forecast_data
-        text_forecast = "Unable to generate text forecast - data error"
-    
-    return summary, plot, text_forecast
+        return summary, plot, text_forecast
+        
+    except Exception as e:
+        error_msg = f"❌ Failed to retrieve DWD ICON data: {str(e)}"
+        return error_msg, None, "Unable to generate forecast - DWD ICON data unavailable"
 
 def create_attribution_text():
     """Create proper attribution for the dataset"""