Add Dynamical Weather Catalog Viewer app

- Interactive Gradio app for visualizing weather data from Dynamical.org
- Support for NOAA GFS, GEFS, and HRRR datasets
- Interactive map visualizations with Plotly
- Point forecast functionality for specific coordinates
- Time series plots and data tables

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

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

app.py

@@ -0,0 +1,253 @@
+import gradio as gr
+import xarray as xr
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+# Catalog configuration
+CATALOG = {
+    "NOAA GFS Analysis (Hourly)": {
+        "url": "https://data.dynamical.org/noaa/gfs/analysis-hourly/latest",
+        "type": "analysis",
+        "variables": ["temperature_2m", "precipitation", "wind_u_10m", "wind_v_10m", "mean_sea_level_pressure"]
+    },
+    "NOAA GFS Forecast": {
+        "url": "https://data.dynamical.org/noaa/gfs/forecast/latest",
+        "type": "forecast",
+        "variables": ["temperature_2m", "precipitation", "wind_u_10m", "wind_v_10m", "mean_sea_level_pressure"]
+    },
+    "NOAA GEFS Analysis": {
+        "url": "https://data.dynamical.org/noaa/gefs/analysis/latest",
+        "type": "analysis",
+        "variables": ["temperature_2m", "precipitation", "wind_u_10m", "wind_v_10m"]
+    },
+    "NOAA GEFS Forecast (35-day)": {
+        "url": "https://data.dynamical.org/noaa/gefs/forecast/latest",
+        "type": "forecast",
+        "variables": ["temperature_2m", "precipitation", "wind_u_10m", "wind_v_10m"]
+    },
+    "NOAA HRRR Forecast (48-hour)": {
+        "url": "https://data.dynamical.org/noaa/hrrr/forecast/latest",
+        "type": "forecast",
+        "variables": ["temperature_2m", "precipitation", "wind_u_10m", "wind_v_10m"]
+    }
+}
+
+# Cache for loaded datasets
+dataset_cache = {}
+
+def load_dataset(dataset_name, use_cache=True):
+    """Load a dataset from the Dynamical catalog"""
+    if use_cache and dataset_name in dataset_cache:
+        return dataset_cache[dataset_name]
+
+    try:
+        url = CATALOG[dataset_name]["url"]
+        ds = xr.open_zarr(url)
+        if use_cache:
+            dataset_cache[dataset_name] = ds
+        return ds
+    except Exception as e:
+        return None
+
+def create_map_visualization(dataset_name, variable, time_index=0):
+    """Create an interactive map visualization of the selected variable"""
+    try:
+        ds = load_dataset(dataset_name)
+        if ds is None:
+            return None, f"Error loading dataset: {dataset_name}"
+
+        # Check if variable exists
+        if variable not in ds.variables:
+            available_vars = list(ds.data_vars)
+            return None, f"Variable '{variable}' not found. Available: {available_vars}"
+
+        # Get the data
+        data_var = ds[variable]
+
+        # Handle time dimension
+        if 'time' in data_var.dims:
+            if time_index >= len(ds.time):
+                time_index = 0
+            data_var = data_var.isel(time=time_index)
+
+        # Handle ensemble dimension if present
+        if 'ensemble' in data_var.dims:
+            data_var = data_var.isel(ensemble=0)
+
+        # Load data into memory (subsample for performance)
+        step = max(1, len(ds.latitude) // 200)  # Limit to ~200 points per dimension
+        data_var = data_var.isel(latitude=slice(None, None, step), longitude=slice(None, None, step))
+        data_values = data_var.compute().values
+
+        # Get coordinates
+        lats = ds.latitude.isel(latitude=slice(None, None, step)).values
+        lons = ds.longitude.isel(longitude=slice(None, None, step)).values
+
+        # Create plotly figure
+        fig = go.Figure(data=go.Heatmap(
+            z=data_values,
+            x=lons,
+            y=lats,
+            colorscale='RdBu_r',
+            hovertemplate='Lat: %{y:.2f}<br>Lon: %{x:.2f}<br>Value: %{z:.2f}<extra></extra>'
+        ))
+
+        time_str = ""
+        if 'time' in ds[variable].dims:
+            time_val = pd.to_datetime(ds.time.isel(time=time_index).values)
+            time_str = f" - {time_val.strftime('%Y-%m-%d %H:%M UTC')}"
+
+        fig.update_layout(
+            title=f"{dataset_name}: {variable}{time_str}",
+            xaxis_title="Longitude",
+            yaxis_title="Latitude",
+            height=600,
+            hovermode='closest'
+        )
+
+        return fig, f"Successfully loaded {dataset_name}"
+
+    except Exception as e:
+        return None, f"Error creating visualization: {str(e)}"
+
+def get_point_forecast(dataset_name, lat, lon, variable):
+    """Get forecast data for a specific point"""
+    try:
+        ds = load_dataset(dataset_name)
+        if ds is None:
+            return None, "Error loading dataset"
+
+        if variable not in ds.variables:
+            return None, f"Variable '{variable}' not found in dataset"
+
+        # Find nearest point
+        data_var = ds[variable].sel(latitude=lat, longitude=lon, method='nearest')
+
+        # Handle ensemble dimension
+        if 'ensemble' in data_var.dims:
+            data_var = data_var.isel(ensemble=0)
+
+        # Load data
+        data_values = data_var.compute().values
+
+        # Create time series plot
+        if 'time' in ds[variable].dims:
+            times = pd.to_datetime(ds.time.values)
+
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(
+                x=times,
+                y=data_values,
+                mode='lines+markers',
+                name=variable
+            ))
+
+            fig.update_layout(
+                title=f"Point Forecast: {variable} at ({lat:.2f}, {lon:.2f})",
+                xaxis_title="Time (UTC)",
+                yaxis_title=variable,
+                height=400,
+                hovermode='x unified'
+            )
+
+            # Create data table
+            df = pd.DataFrame({
+                'Time (UTC)': times,
+                variable: data_values
+            })
+
+            return fig, df.to_html(index=False)
+        else:
+            return None, f"No time dimension found for {variable}"
+
+    except Exception as e:
+        return None, f"Error getting point forecast: {str(e)}"
+
+def update_available_variables(dataset_name):
+    """Update the variable dropdown based on selected dataset"""
+    try:
+        ds = load_dataset(dataset_name, use_cache=False)
+        if ds is None:
+            return gr.Dropdown(choices=CATALOG[dataset_name]["variables"], value=CATALOG[dataset_name]["variables"][0])
+
+        available_vars = list(ds.data_vars)
+        return gr.Dropdown(choices=available_vars, value=available_vars[0] if available_vars else None)
+    except:
+        return gr.Dropdown(choices=CATALOG[dataset_name]["variables"], value=CATALOG[dataset_name]["variables"][0])
+
+# Create Gradio interface
+with gr.Blocks(title="Dynamical Weather Catalog Viewer") as app:
+    gr.Markdown("""
+    # 🌍 Dynamical Weather Catalog Viewer
+
+    Explore weather analysis and forecast data from the [Dynamical.org catalog](https://dynamical.org/catalog/).
+
+    **Features:**
+    - Visualize global weather data on interactive maps
+    - Click a location to get point forecasts
+    - Browse multiple datasets: NOAA GFS, GEFS, and HRRR
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            dataset_dropdown = gr.Dropdown(
+                choices=list(CATALOG.keys()),
+                value=list(CATALOG.keys())[0],
+                label="Select Dataset"
+            )
+            variable_dropdown = gr.Dropdown(
+                choices=CATALOG[list(CATALOG.keys())[0]]["variables"],
+                value=CATALOG[list(CATALOG.keys())[0]]["variables"][0],
+                label="Select Variable"
+            )
+            time_slider = gr.Slider(
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=0,
+                label="Time Index"
+            )
+            load_btn = gr.Button("Load Map", variant="primary")
+            status_text = gr.Textbox(label="Status", interactive=False)
+
+        with gr.Column(scale=2):
+            map_plot = gr.Plot(label="Map Visualization")
+
+    gr.Markdown("## 📍 Point Forecast")
+    gr.Markdown("Enter coordinates to get a time series forecast for a specific location")
+
+    with gr.Row():
+        lat_input = gr.Number(value=40.7, label="Latitude", precision=2)
+        lon_input = gr.Number(value=-74.0, label="Longitude", precision=2)
+        forecast_btn = gr.Button("Get Point Forecast", variant="secondary")
+
+    with gr.Row():
+        forecast_plot = gr.Plot(label="Time Series Forecast")
+
+    forecast_table = gr.HTML(label="Forecast Data")
+
+    # Event handlers
+    dataset_dropdown.change(
+        fn=update_available_variables,
+        inputs=[dataset_dropdown],
+        outputs=[variable_dropdown]
+    )
+
+    load_btn.click(
+        fn=create_map_visualization,
+        inputs=[dataset_dropdown, variable_dropdown, time_slider],
+        outputs=[map_plot, status_text]
+    )
+
+    forecast_btn.click(
+        fn=get_point_forecast,
+        inputs=[dataset_dropdown, lat_input, lon_input, variable_dropdown],
+        outputs=[forecast_plot, forecast_table]
+    )
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,8 @@
+gradio==5.47.2
+xarray
+zarr
+fsspec
+aiohttp
+pandas
+numpy
+plotly