app.py

import gradio as gr
import folium

# Dictionary of radar sites with their center coordinates (latitude, longitude)
RADAR_SITES = {
    "KTLX": {"name": "KTLX (Oklahoma City)", "lat": 35.333, "lon": -97.277},
    "KFWS": {"name": "KFWS (Fort Worth)", "lat": 32.847, "lon": -97.276},
    "KHGX": {"name": "KHGX (Houston)", "lat": 29.757, "lon": -95.389}
}

# Dictionary of radar product tile URLs (from Iowa State Mesonet)
RADAR_PRODUCT_TILES = {
    "Reflectivity": "https://mesonet.agron.iastate.edu/tiles/nexrad-base/{z}/{x}/{y}.png",
    "Velocity": "https://mesonet.agron.iastate.edu/tiles/nexrad-velo/{z}/{x}/{y}.png"
}

# Function to build the base map tile URL for non-OSM providers
def get_base_map_tiles(provider, api_key):
    if provider == "OpenStreetMap":
        # OpenStreetMap is the default; no API key required.
        return None
    elif provider == "MapTiler":
        # MapTiler Streets style URL – replace YOUR_KEY with the provided API key.
        return f"https://api.maptiler.com/maps/streets/{{z}}/{{x}}/{{y}}.png?key={api_key}"
    elif provider == "Mapbox":
        # Mapbox Streets style URL – replace YOUR_TOKEN with the provided API key.
        return f"https://api.mapbox.com/styles/v1/mapbox/streets-v11/tiles/{{z}}/{{x}}/{{y}}?access_token={api_key}"
    else:
        return None

# Function to generate the HTML map with a radar overlay.
def generate_map(radar_site, product, map_provider, api_key):
    # Retrieve the selected radar site coordinates; default to center of USA if not found.
    site = RADAR_SITES.get(radar_site, {"lat": 39.8283, "lon": -98.5795})
    center_lat = site["lat"]
    center_lon = site["lon"]

    # Create a folium map centered on the radar site.
    m = folium.Map(location=[center_lat, center_lon], zoom_start=6, control_scale=True)

    # If a provider other than OpenStreetMap is selected, add its tile layer.
    if map_provider != "OpenStreetMap":
        base_tile_url = get_base_map_tiles(map_provider, api_key)
        if base_tile_url:
            folium.TileLayer(
                tiles=base_tile_url,
                attr=f"{map_provider} Map",
                name=f"{map_provider} Map",
                overlay=False,
                control=True
            ).add_to(m)
    # Otherwise, OpenStreetMap is used by default.
    
    # Add the radar overlay tile layer based on the selected product.
    radar_tile_url = RADAR_PRODUCT_TILES.get(product)
    if radar_tile_url:
        folium.raster_layers.TileLayer(
            tiles=radar_tile_url,
            attr="NOAA NEXRAD",
            name=f"Radar {product}",
            overlay=True,
            control=True,
            opacity=0.7
        ).add_to(m)
    
    # Add a layer control so users can toggle layers.
    folium.LayerControl().add_to(m)
    
    # Render the map as an HTML string.
    map_html = m.get_root().render()
    return map_html

# Define the choices for each input.
site_choices = list(RADAR_SITES.keys())
product_choices = list(RADAR_PRODUCT_TILES.keys())
map_provider_choices = ["OpenStreetMap", "MapTiler", "Mapbox"]

# Create the Gradio interface.
iface = gr.Interface(
    fn=generate_map,
    inputs=[
        gr.inputs.Dropdown(choices=site_choices, label="Radar Site"),
        gr.inputs.Dropdown(choices=product_choices, label="Radar Product"),
        gr.inputs.Dropdown(choices=map_provider_choices, label="Map Provider"),
        gr.inputs.Textbox(lines=1, placeholder="Enter API key if required", label="API Key")
    ],
    outputs=gr.outputs.HTML(label="Radar Map"),
    title="Radar Viewer",
    description="A simplified radar viewer mimicking some functionality of Supercell Wx. Select a radar site and product, choose a base map provider (enter an API key if needed), and view the radar overlay."
)

iface.launch()