Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import requests
 import folium
-from datetime import datetime
+from datetime import datetime, timedelta
 import tempfile
 import os
 
@@ -11,12 +11,12 @@ def get_noaa_forecast(lat, lon):
     
     try:
         # Get the forecast URL for the coordinates
-        response = requests.get(points_url)
+        response = requests.get(points_url, timeout=10)
         response.raise_for_status()
         forecast_url = response.json()['properties']['forecast']
         
         # Get the actual forecast
-        forecast_response = requests.get(forecast_url)
+        forecast_response = requests.get(forecast_url, timeout=10)
         forecast_response.raise_for_status()
         forecast_data = forecast_response.json()
         
@@ -29,83 +29,149 @@ def get_noaa_forecast(lat, lon):
             forecast_text += f"Wind: {period['windSpeed']} {period['windDirection']}\n"
             forecast_text += f"{period['detailedForecast']}\n"
         
-        return forecast_text
+        return forecast_text.strip()
     except requests.exceptions.RequestException as e:
         return f"Error fetching forecast: {str(e)}"
 
-def get_radar_url(lat, lon):
-    """Get NOAA radar image URL for given coordinates."""
-    # Calculate the closest radar station (this is a simplified version)
-    # In a production environment, you'd want to use the actual NOAA radar station directory
-    base_url = "https://radar.weather.gov/ridge/standard/"
-    # This returns the latest radar image for the region
-    # You would need to determine the correct station based on coordinates
-    return f"{base_url}CONUS_LATEST_loop.gif"
+def get_radar_images():
+    """Get current radar and forecast radar images."""
+    try:
+        # Current radar
+        current_radar = "https://radar.weather.gov/ridge/standard/CONUS_0.gif"
+        
+        # Forecast radar - using NDFD precipitation forecast images
+        # These are probability of precipitation forecasts for different time periods
+        now = datetime.utcnow()
+        forecast_date = now.strftime("%Y%m%d")
+        
+        # 6-hour and 12-hour precipitation probability forecasts
+        forecast_6hr = f"https://digital.weather.gov/images/conus/MaxPcpn6_{forecast_date}00.png"
+        forecast_12hr = f"https://digital.weather.gov/images/conus/MaxPcpn12_{forecast_date}00.png"
+        
+        return {
+            "current": current_radar,
+            "forecast_6hr": forecast_6hr,
+            "forecast_12hr": forecast_12hr
+        }
+    except Exception as e:
+        return None
 
 def create_map():
     """Create a folium map centered on the US."""
     m = folium.Map(location=[39.8283, -98.5795], zoom_start=4)
+    m.add_child(folium.ClickForLatLng())  # Enable click events
     return m._repr_html_()
 
-def update_weather(lat, lon, map_click_coords):
+def update_weather(lat, lon):
     """Update weather information based on coordinates."""
-    # Use map click coordinates if provided, otherwise use manual input
-    if map_click_coords is not None:
-        lat, lon = map_click_coords[0], map_click_coords[1]
-    
-    # Get forecast and radar
-    forecast = get_noaa_forecast(lat, lon)
-    radar_url = get_radar_url(lat, lon)
-    
-    # Create updated map with marker
-    m = folium.Map(location=[lat, lon], zoom_start=8)
-    folium.Marker([lat, lon], popup=f"Lat: {lat}, Lon: {lon}").add_to(m)
-    
-    return forecast, radar_url, m._repr_html_()
+    try:
+        # Validate coordinates
+        lat = float(lat)
+        lon = float(lon)
+        if not (-90 <= lat <= 90 and -180 <= lon <= 180):
+            return "Invalid coordinates. Latitude must be between -90 and 90, longitude between -180 and 180.", None, None, None, create_map()
+        
+        # Get forecast and radar
+        forecast = get_noaa_forecast(lat, lon)
+        radar_images = get_radar_images()
+        
+        if radar_images is None:
+            return forecast, None, None, None, create_map()
+        
+        # Create updated map with marker
+        m = folium.Map(location=[lat, lon], zoom_start=8)
+        folium.Marker([lat, lon], popup=f"Lat: {lat:.4f}, Lon: {lon:.4f}").add_to(m)
+        m.add_child(folium.ClickForLatLng())  # Enable click events
+        
+        return (
+            forecast,
+            radar_images["current"],
+            radar_images["forecast_6hr"],
+            radar_images["forecast_12hr"],
+            m._repr_html_()
+        )
+    except ValueError as e:
+        return f"Error: Invalid coordinate format - {str(e)}", None, None, None, create_map()
+    except Exception as e:
+        return f"Error: {str(e)}", None, None, None, create_map()
 
 # Create Gradio interface
-with gr.Blocks() as demo:
+with gr.Blocks(title="NOAA Weather Forecast and Radar") as demo:
     gr.Markdown("# NOAA Weather Forecast and Radar")
     
     with gr.Row():
-        with gr.Column():
-            lat_input = gr.Number(label="Latitude", value=39.8283)
-            lon_input = gr.Number(label="Longitude", value=-98.5795)
+        with gr.Column(scale=1):
+            lat_input = gr.Number(
+                label="Latitude",
+                value=39.8283,
+                minimum=-90,
+                maximum=90
+            )
+            lon_input = gr.Number(
+                label="Longitude",
+                value=-98.5795,
+                minimum=-180,
+                maximum=180
+            )
             submit_btn = gr.Button("Get Weather")
         
-        with gr.Column():
+        with gr.Column(scale=2):
             map_display = gr.HTML(create_map())
-            map_click_coords = gr.State(None)
     
     with gr.Row():
-        forecast_output = gr.Textbox(label="Forecast", lines=10)
-        radar_output = gr.Image(label="Radar")
+        forecast_output = gr.Textbox(
+            label="Forecast",
+            lines=12,
+            placeholder="Enter coordinates or click 'Get Weather' to see the forecast..."
+        )
+    
+    with gr.Row():
+        with gr.Column():
+            current_radar = gr.Image(
+                label="Current Radar",
+                show_label=True,
+                container=True
+            )
+        with gr.Column():
+            forecast_6hr = gr.Image(
+                label="6-Hour Precipitation Forecast",
+                show_label=True,
+                container=True
+            )
+        with gr.Column():
+            forecast_12hr = gr.Image(
+                label="12-Hour Precipitation Forecast",
+                show_label=True,
+                container=True
+            )
     
     # Handle submit button click
     submit_btn.click(
         fn=update_weather,
-        inputs=[lat_input, lon_input, map_click_coords],
-        outputs=[forecast_output, radar_output, map_display]
+        inputs=[lat_input, lon_input],
+        outputs=[
+            forecast_output,
+            current_radar,
+            forecast_6hr,
+            forecast_12hr,
+            map_display
+        ]
     )
     
-    # Handle map clicks
-    # Note: This would require additional JavaScript to capture click events
-    # In a full implementation, you'd need to add custom JS to capture map clicks
-    
     gr.Markdown("""
     ## Instructions
-    1. Enter coordinates manually or click on the map
+    1. Enter coordinates manually or click on the map to select a location
     2. Click "Get Weather" to see the forecast and radar
-    3. Radar image shows the latest available data
+    3. View current radar and precipitation forecasts
+    
+    **Legend:**
+    - Current Radar: Shows current precipitation
+    - 6-Hour Forecast: Shows probability of precipitation over next 6 hours
+    - 12-Hour Forecast: Shows probability of precipitation over next 12 hours
     
-    Note: This is a basic implementation. A production version would need:
-    - Proper radar station selection based on location
-    - Error handling for invalid coordinates
-    - Rate limiting for API requests
-    - Better map interaction
+    **Note**: This app uses the NOAA Weather API and may have occasional delays or service interruptions.
+    Data is provided by the National Weather Service (weather.gov).
     """)
 
-# Launch the app
-if __name__ == "__main__":
-    demo.launch()
-  
+# For Hugging Face Spaces, we need to export the demo
+demo.queue(concurrency_count=3).launch()