Update app.py

app.py

@@ -0,0 +1,207 @@
+# app.py
+import gradio as gr
+import requests
+import pycountry
+import pandas as pd
+import folium
+from folium.plugins import MarkerCluster
+import io
+import base64
+import time
+
+# --- Helpers --------------------------------------------------------------
+
+USER_AGENT = "hf-space-poi-finder/1.0 (your_email@example.com)"
+
+def list_countries():
+    items = sorted([(c.name, c.alpha_2) for c in pycountry.countries], key=lambda x: x[0])
+    names = [name for name, code in items]
+    codes = [code for name, code in items]
+    # return mapping lists so gradio can show names but we keep codes
+    return names, codes
+
+# Return list of subdivision names and a matching list of their codes (ISO 3166-2)
+def list_subdivisions(country_code):
+    subs = list(pycountry.subdivisions.get(country_code=country_code))
+    if not subs:
+        return [], []
+    items = sorted([(s.name, s.code) for s in subs], key=lambda x: x[0])
+    names = [n for n, c in items]
+    codes = [c for n, c in items]
+    return names, codes
+
+# Use Nominatim to geocode the subdivision name (state) inside country to get bbox
+def geocode_region(name, country_code):
+    url = "https://nominatim.openstreetmap.org/search"
+    params = {
+        "q": f"{name}, {country_code}",
+        "format": "json",
+        "limit": 1,
+        "polygon_geojson": 0,
+        "addressdetails": 0,
+    }
+    headers = {"User-Agent": USER_AGENT}
+    resp = requests.get(url, params=params, headers=headers, timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+    if not data:
+        return None
+    item = data[0]
+    # Nominatim returns boundingbox as [south, north, west, east] (strings)
+    bbox = [float(item["boundingbox"][0]), float(item["boundingbox"][1]),
+            float(item["boundingbox"][2]), float(item["boundingbox"][3])]
+    # convert to Overpass bbox ordering: south,west,north,east
+    return (bbox[0], bbox[2], bbox[1], bbox[3])
+
+# Build Overpass API query to fetch nodes/ways/relations with amenity tags in bbox
+def overpass_query(amenities, bbox, timeout=60):
+    # amenities: list like ["cafe","motel","hotel"]
+    south, west, north, east = bbox
+    amen_regex = "|".join([a for a in amenities])
+    # query nodes, ways, relations; output center for ways/relations
+    q = f"""
+    [out:json][timeout:{timeout}];
+    (
+      node["amenity"~"^{amen_regex}$"]({south},{west},{north},{east});
+      way["amenity"~"^{amen_regex}$"]({south},{west},{north},{east});
+      relation["amenity"~"^{amen_regex}$"]({south},{west},{north},{east});
+    );
+    out center tags;
+    """
+    return q
+
+def fetch_places(amenities, bbox):
+    q = overpass_query(amenities, bbox)
+    url = "https://overpass-api.de/api/interpreter"
+    headers = {"User-Agent": USER_AGENT}
+    resp = requests.post(url, data=q.encode("utf-8"), headers=headers, timeout=120)
+    resp.raise_for_status()
+    data = resp.json()
+    elements = data.get("elements", [])
+    rows = []
+    for el in elements:
+        tags = el.get("tags", {})
+        name = tags.get("name") or tags.get("name:en") or ""
+        amenity = tags.get("amenity", "")
+        # coords: node has lat/lon; way/relation use 'center'
+        if el.get("type") == "node":
+            lat = el.get("lat")
+            lon = el.get("lon")
+        else:
+            center = el.get("center")
+            lat = center.get("lat") if center else None
+            lon = center.get("lon") if center else None
+        address = ", ".join(v for k, v in tags.items() if k.startswith("addr:")) or ""
+        rows.append({
+            "name": name,
+            "amenity": amenity,
+            "lat": lat,
+            "lon": lon,
+            "address": address,
+            "osm_id": f'{el.get("type")}/{el.get("id")}',
+            "tags": tags
+        })
+    df = pd.DataFrame(rows)
+    # remove ones without coordinates
+    df = df.dropna(subset=["lat", "lon"])
+    # reorder columns
+    if not df.empty:
+        df = df[["name","amenity","lat","lon","address","osm_id","tags"]]
+    return df
+
+def df_to_csv_bytes(df):
+    buf = io.StringIO()
+    df.to_csv(buf, index=False)
+    return buf.getvalue().encode("utf-8")
+
+def make_map(df, center_bbox=None):
+    # center map on bbox if provided else on mean coordinates
+    if df.empty:
+        # empty map default world view
+        m = folium.Map(location=[20,0], zoom_start=2)
+        return m._repr_html_()
+    if center_bbox:
+        south, west, north, east = center_bbox
+        center_lat = (south + north) / 2.0
+        center_lon = (west + east) / 2.0
+        zoom = 8
+    else:
+        center_lat = df["lat"].mean()
+        center_lon = df["lon"].mean()
+        zoom = 10
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom)
+    cluster = MarkerCluster().add_to(m)
+    for _, row in df.iterrows():
+        name = row.get("name") or row.get("amenity")
+        popup_html = f"<b>{name}</b><br>{row.get('amenity')}<br>{row.get('address')}"
+        folium.Marker([row["lat"], row["lon"]], popup=popup_html).add_to(cluster)
+    return m._repr_html_()
+
+# --- Gradio interface functions -------------------------------------------
+
+COUNTRY_NAMES, COUNTRY_CODES = list_countries()
+
+def update_states(selected_country_name):
+    # find index
+    try:
+        idx = COUNTRY_NAMES.index(selected_country_name)
+        code = COUNTRY_CODES[idx]
+    except ValueError:
+        return gr.update(choices=[]), gr.update(visible=False)
+    names, codes = list_subdivisions(code)
+    if not names:
+        # no subdivisions in pycountry for that country
+        return gr.update(choices=[]), gr.update(visible=False)
+    return gr.update(choices=names, value=names[0]), gr.update(visible=True)
+
+def run_search(country_name, state_name, categories):
+    start = time.time()
+    # get country code
+    try:
+        idx = COUNTRY_NAMES.index(country_name)
+        country_code = COUNTRY_CODES[idx]
+    except ValueError:
+        return "Invalid country", None, None, None
+    # geocode state
+    bbox = geocode_region(state_name if state_name else country_name, country_code)
+    if bbox is None:
+        return f"Could not geocode region '{state_name}'. Try a different subdivision or broaden to the country.", None, None, None
+    if not categories:
+        return "Please select at least one category.", None, None, None
+    df = fetch_places(categories, bbox)
+    map_html = make_map(df, center_bbox=bbox)
+    csv_bytes = df_to_csv_bytes(df)
+    elapsed = time.time() - start
+    msg = f"Found {len(df)} places for {', '.join(categories)} in {state_name}, {country_name} (took {elapsed:.1f}s)."
+    # prepare downloadable link (data URI)
+    csv_b64 = base64.b64encode(csv_bytes).decode("utf-8")
+    csv_href = f"data:text/csv;base64,{csv_b64}"
+    return msg, df, map_html, csv_href
+
+# --- Build Gradio UI -----------------------------------------------------
+
+place_options = ["cafe","motel","hotel","restaurant","bar","pub","bakery","fast_food","guest_house","hostel"]
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Client-finder SaaS dashboard (OSM) — deploy on Hugging Face Spaces")
+    with gr.Row():
+        with gr.Column(scale=1):
+            country = gr.Dropdown(choices=COUNTRY_NAMES, value="United States", label="Country")
+            state = gr.Dropdown(choices=[], label="State / Subdivision")
+            update_btn = gr.Button("Refresh states")
+            categories = gr.CheckboxGroup(place_options, label="Categories to search", value=["cafe","restaurant"])
+            search_btn = gr.Button("Search places")
+            info = gr.Textbox(label="Status", interactive=False)
+            download = gr.File(label="Download results (CSV)", interactive=False)
+        with gr.Column(scale=2):
+            map_html_out = gr.HTML(label="Map")
+            table_out = gr.Dataframe(headers=["name","amenity","lat","lon","address","osm_id"], label="Results Table")
+
+    # initial population of states for default country
+    state.update(choices=list_subdivisions("US")[0], value=(list_subdivisions("US")[0][0] if list_subdivisions("US")[0] else None))
+
+    update_btn.click(fn=update_states, inputs=country, outputs=[state, state], _js=None)
+    search_btn.click(fn=run_search, inputs=[country, state, categories], outputs=[info, table_out, map_html_out, download])
+
+if __name__ == "__main__":
+    demo.launch()