Create app.py

app.py

@@ -0,0 +1,275 @@
+import gradio as gr
+import requests
+import json
+import pandas as pd
+from datetime import datetime
+import matplotlib.pyplot as plt
+import io
+import base64
+from PIL import Image
+import re
+
+# NIWA Snow Monitoring Stations
+SNOW_STATIONS = {
+    "Mahanga EWS": {
+        "name": "Mahanga Electronic Weather Station", 
+        "location": "Mount Mahanga, Tasman",
+        "elevation": "1940m",
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mahanga-ews-snow-depth-web.png"
+    },
+    "Mueller Hut": {
+        "name": "Mueller Hut",
+        "location": "Aoraki/Mount Cook National Park",
+        "elevation": "1800m", 
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/mueller-hut-snow-depth-web.png"
+    },
+    "Rose Ridge": {
+        "name": "Rose Ridge",
+        "location": "Canterbury",
+        "elevation": "1580m",
+        "image_url": "https://webstatic.niwa.co.nz/snow-plots/rose-ridge-snow-depth-web.png"
+    }
+}
+
+def fetch_snow_depth_image(station_key):
+    """Fetch snow depth chart image from NIWA servers"""
+    try:
+        station = SNOW_STATIONS[station_key]
+        image_url = station["image_url"]
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        
+        response = requests.get(image_url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            # Convert to PIL Image
+            image = Image.open(io.BytesIO(response.content))
+            
+            info = f"""
+            **Station:** {station['name']}
+            **Location:** {station['location']}
+            **Elevation:** {station['elevation']}
+            **Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} (Image fetch time)
+            
+            *Note: This chart shows current snow depth relative to historical records. Data is updated weekly.*
+            """
+            
+            return image, info, "✅ Successfully fetched snow depth data"
+            
+        else:
+            return None, f"❌ Failed to fetch data. HTTP {response.status_code}", f"Error fetching from {image_url}"
+            
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}", "Failed to connect to NIWA servers"
+
+def try_fetch_json_data():
+    """Attempt to find JSON endpoints for snow data"""
+    potential_endpoints = [
+        "https://data.niwa.co.nz/api/snow/depth",
+        "https://api.niwa.co.nz/snow/depth", 
+        "https://webstatic.niwa.co.nz/api/snow-data.json",
+        "https://niwa.co.nz/api/snow/stations"
+    ]
+    
+    results = []
+    headers = {'User-Agent': 'Mozilla/5.0 (compatible; SnowDataFetcher/1.0)'}
+    
+    for endpoint in potential_endpoints:
+        try:
+            response = requests.get(endpoint, headers=headers, timeout=5)
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    results.append(f"✅ {endpoint}: Found JSON data")
+                except:
+                    results.append(f"🔍 {endpoint}: Response received but not JSON")
+            else:
+                results.append(f"❌ {endpoint}: HTTP {response.status_code}")
+        except:
+            results.append(f"❌ {endpoint}: Connection failed")
+    
+    return "\n".join(results)
+
+def get_all_stations_data():
+    """Fetch data for all available stations"""
+    results = []
+    images = []
+    
+    for station_key in SNOW_STATIONS.keys():
+        try:
+            image, info, status = fetch_snow_depth_image(station_key)
+            if image:
+                images.append((image, f"{SNOW_STATIONS[station_key]['name']} Snow Depth"))
+                results.append(f"✅ {station_key}: {status}")
+            else:
+                results.append(f"❌ {station_key}: {status}")
+        except Exception as e:
+            results.append(f"❌ {station_key}: Error - {str(e)}")
+    
+    return images, "\n".join(results)
+
+def search_additional_endpoints():
+    """Search for additional NIWA data endpoints"""
+    # Try to find other potential data sources
+    search_urls = [
+        "https://niwa.co.nz/freshwater/snow-and-ice-network/",
+        "https://data.niwa.co.nz/",
+        "https://developer.niwa.co.nz/"
+    ]
+    
+    findings = []
+    headers = {'User-Agent': 'Mozilla/5.0'}
+    
+    for url in search_urls:
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            if response.status_code == 200:
+                # Look for API references or data URLs in the content
+                content = response.text.lower()
+                if 'api' in content:
+                    findings.append(f"✅ {url}: Contains API references")
+                if 'json' in content:
+                    findings.append(f"🔍 {url}: Contains JSON references") 
+                if 'data' in content:
+                    findings.append(f"📊 {url}: Contains data references")
+            else:
+                findings.append(f"❌ {url}: HTTP {response.status_code}")
+        except:
+            findings.append(f"❌ {url}: Connection failed")
+    
+    return "\n".join(findings) if findings else "No additional endpoints found"
+
+# Create Gradio Interface
+with gr.Blocks(title="NIWA Snow Depth Monitor", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🏔️ NIWA Snow Depth Data Fetcher
+    
+    This app fetches real-time snow depth data from New Zealand's National Institute of Water and Atmospheric Research (NIWA) public servers.
+    
+    **Data Sources:**
+    - Snow depth charts from NIWA's Electronic Weather Stations
+    - Updated weekly with quality-controlled data
+    - Covers key South Island alpine monitoring sites
+    """)
+    
+    with gr.Tab("📊 Individual Station Data"):
+        with gr.Row():
+            station_dropdown = gr.Dropdown(
+                choices=list(SNOW_STATIONS.keys()),
+                value="Mahanga EWS",
+                label="Select Snow Monitoring Station",
+                info="Choose a NIWA snow monitoring station"
+            )
+            fetch_btn = gr.Button("🔄 Fetch Snow Data", variant="primary")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                snow_image = gr.Image(label="Snow Depth Chart", height=400)
+            with gr.Column(scale=1):
+                station_info = gr.Markdown(label="Station Information")
+        
+        fetch_status = gr.Textbox(label="Status", interactive=False)
+    
+    with gr.Tab("🗺️ All Stations Overview"):
+        with gr.Row():
+            fetch_all_btn = gr.Button("📡 Fetch All Station Data", variant="primary")
+        
+        all_stations_gallery = gr.Gallery(
+            label="All Snow Monitoring Stations",
+            columns=2,
+            height=400
+        )
+        all_stations_status = gr.Textbox(label="Fetch Results", interactive=False)
+    
+    with gr.Tab("🔍 API Discovery"):
+        gr.Markdown("""
+        ### API Endpoint Discovery
+        This section attempts to find additional JSON/API endpoints for accessing raw snow data.
+        """)
+        
+        with gr.Row():
+            search_json_btn = gr.Button("🔍 Search for JSON APIs", variant="secondary")
+            search_endpoints_btn = gr.Button("🌐 Search Additional Endpoints", variant="secondary")
+        
+        json_results = gr.Textbox(label="JSON API Search Results", lines=8, interactive=False)
+        endpoint_results = gr.Textbox(label="Additional Endpoint Search", lines=6, interactive=False)
+    
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown("""
+        ### About This App
+        
+        **Data Source:** New Zealand's National Institute of Water and Atmospheric Research (NIWA)
+        
+        **Monitoring Stations:**
+        - **Mahanga EWS**: Mount Mahanga, Tasman (1940m elevation)
+        - **Mueller Hut**: Aoraki/Mount Cook National Park (1800m elevation)  
+        - **Rose Ridge**: Canterbury (1580m elevation)
+        
+        **Data Notes:**
+        - Charts show current snow depth relative to historical records
+        - Data is updated weekly from raw measurements
+        - Single monitoring point may not represent entire surrounding area
+        - Inherent uncertainty in snow depth measurements
+        
+        **Technical Details:**
+        - Fetches PNG chart images from NIWA's public web servers
+        - Attempts to discover JSON API endpoints for raw data access
+        - No authentication required for public data
+        
+        **Use Cases:**
+        - Alpine weather monitoring
+        - Skiing and mountaineering planning
+        - Climate research and analysis
+        - Avalanche risk assessment support
+        
+        **Limitations:**
+        - Visual charts only (numerical data requires NIWA DataHub registration)
+        - Weekly update frequency
+        - Limited to available monitoring stations
+        
+        For raw numerical data access, visit: https://data.niwa.co.nz/
+        """)
+    
+    # Event handlers
+    fetch_btn.click(
+        fn=fetch_snow_depth_image,
+        inputs=[station_dropdown],
+        outputs=[snow_image, station_info, fetch_status]
+    )
+    
+    fetch_all_btn.click(
+        fn=get_all_stations_data,
+        outputs=[all_stations_gallery, all_stations_status]
+    )
+    
+    search_json_btn.click(
+        fn=try_fetch_json_data,
+        outputs=[json_results]
+    )
+    
+    search_endpoints_btn.click(
+        fn=search_additional_endpoints,
+        outputs=[endpoint_results]
+    )
+
+# Launch instructions for HuggingFace Spaces
+if __name__ == "__main__":
+    app.launch()
+
+# Requirements for HuggingFace Spaces (requirements.txt):
+"""
+gradio>=4.0.0
+requests>=2.25.0
+pandas>=1.3.0
+matplotlib>=3.5.0
+Pillow>=8.0.0
+"""
+
+# App file structure for HuggingFace Spaces:
+"""
+app.py (this file)
+requirements.txt (with the above dependencies)
+README.md (with app description)
+"""