Update app.py

app.py

@@ -7,12 +7,15 @@ import base64
 import time
 import overpy
 from geopy.geocoders import Nominatim
+import requests
+from bs4 import BeautifulSoup
 
 # -------------------------------------------------------------------
 # Setup
 # -------------------------------------------------------------------
 geolocator = Nominatim(user_agent="hf-saas-dashboard")
 api = overpy.Overpass()
+GOOGLE_API_KEY = "YOUR_GOOGLE_API_KEY"  # put your key here
 
 # -------------------------------------------------------------------
 # Helpers
@@ -64,61 +67,93 @@ def fetch_places(amenities, bbox):
     result = api.query(query)
     rows = []
 
-    # Nodes
-    for node in result.nodes:
-        tags = node.tags
-        rows.append({
+    def parse_tags(tags, lat, lon, osm_id):
+        return {
             "name": tags.get("name", ""),
             "amenity": tags.get("amenity", ""),
-            "lat": node.lat,
-            "lon": node.lon,
-            "address": ", ".join(v for k, v in tags.items() if k.startswith("addr:")),
+            "lat": lat,
+            "lon": lon,
             "phone": tags.get("phone", ""),
             "website": tags.get("website", ""),
-            "opening_hours": tags.get("opening_hours", ""),
-            "osm_id": f"node/{node.id}",
-        })
+            "osm_id": osm_id,
+        }
+
+    for node in result.nodes:
+        rows.append(parse_tags(node.tags, node.lat, node.lon, f"node/{node.id}"))
 
-    # Ways
     for way in result.ways:
-        tags = way.tags
-        center_lat = getattr(way, "center_lat", None)
-        center_lon = getattr(way, "center_lon", None)
-        rows.append({
-            "name": tags.get("name", ""),
-            "amenity": tags.get("amenity", ""),
-            "lat": center_lat,
-            "lon": center_lon,
-            "address": ", ".join(v for k, v in tags.items() if k.startswith("addr:")),
-            "phone": tags.get("phone", ""),
-            "website": tags.get("website", ""),
-            "opening_hours": tags.get("opening_hours", ""),
-            "osm_id": f"way/{way.id}",
-        })
+        rows.append(parse_tags(way.tags, getattr(way, "center_lat", None), getattr(way, "center_lon", None), f"way/{way.id}"))
 
-    # Relations
     for rel in result.relations:
-        tags = rel.tags
-        center_lat = getattr(rel, "center_lat", None)
-        center_lon = getattr(rel, "center_lon", None)
-        rows.append({
-            "name": tags.get("name", ""),
-            "amenity": tags.get("amenity", ""),
-            "lat": center_lat,
-            "lon": center_lon,
-            "address": ", ".join(v for k, v in tags.items() if k.startswith("addr:")),
-            "phone": tags.get("phone", ""),
-            "website": tags.get("website", ""),
-            "opening_hours": tags.get("opening_hours", ""),
-            "osm_id": f"relation/{rel.id}",
-        })
+        rows.append(parse_tags(rel.tags, getattr(rel, "center_lat", None), getattr(rel, "center_lon", None), f"relation/{rel.id}"))
+
+    return pd.DataFrame(rows).dropna(subset=["lat", "lon"])
+
+
+# -------------------------------
+# Google API Enrichment
+# -------------------------------
+def enrich_with_google_api(df):
+    """Enrich OSM results with Google Places API (phone + website)."""
+    for i, row in df.iterrows():
+        if row["phone"] and row["website"]:
+            continue  # already have data
+
+        query = f"{row['name']} near {row['lat']},{row['lon']}"
+        url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
+        params = {"query": query, "key": GOOGLE_API_KEY}
+        r = requests.get(url, params=params)
+        data = r.json()
+
+        if data.get("results"):
+            place_id = data["results"][0]["place_id"]
+
+            # Fetch details
+            details_url = "https://maps.googleapis.com/maps/api/place/details/json"
+            d_params = {"place_id": place_id, "fields": "formatted_phone_number,website", "key": GOOGLE_API_KEY}
+            d = requests.get(details_url, params=d_params).json()
 
-    df = pd.DataFrame(rows).dropna(subset=["lat", "lon"])
-    if not df.empty:
-        df = df[["name", "amenity", "lat", "lon", "address", "phone", "website", "opening_hours", "osm_id"]]
+            details = d.get("result", {})
+            df.at[i, "phone"] = details.get("formatted_phone_number", row["phone"])
+            df.at[i, "website"] = details.get("website", row["website"])
     return df
 
 
+# -------------------------------
+# Google Scraper Fallback (⚠️ not ToS-compliant)
+# -------------------------------
+def scrape_google_maps(name, lat, lon):
+    """Scrape Google Maps web UI for phone number (last resort, experimental)."""
+    search_url = f"https://www.google.com/maps/search/{name}/@{lat},{lon},15z"
+    headers = {"User-Agent": "Mozilla/5.0"}
+    r = requests.get(search_url, headers=headers)
+
+    if r.status_code != 200:
+        return None
+
+    soup = BeautifulSoup(r.text, "html.parser")
+    # ⚠️ This selector is fragile and may break anytime
+    phone = None
+    for span in soup.find_all("span"):
+        if "+" in span.text and any(c.isdigit() for c in span.text):
+            phone = span.text.strip()
+            break
+    return phone
+
+
+def enrich_with_scraper(df):
+    for i, row in df.iterrows():
+        if row["phone"]:
+            continue
+        phone = scrape_google_maps(row["name"], row["lat"], row["lon"])
+        if phone:
+            df.at[i, "phone"] = phone
+    return df
+
+
+# -------------------------------
+# Visualization
+# -------------------------------
 def df_to_csv_bytes(df):
     return df.to_csv(index=False).encode("utf-8")
 
@@ -126,6 +161,7 @@ def df_to_csv_bytes(df):
 def make_map(df, center_bbox=None):
     if df.empty:
         return folium.Map(location=[20, 0], zoom_start=2)._repr_html_()
+
     if center_bbox:
         south, west, north, east = center_bbox
         center_lat = (south + north) / 2
@@ -133,19 +169,31 @@ def make_map(df, center_bbox=None):
     else:
         center_lat = df["lat"].mean()
         center_lon = df["lon"].mean()
+
     m = folium.Map(location=[center_lat, center_lon], zoom_start=8)
     cluster = MarkerCluster().add_to(m)
+
     for _, row in df.iterrows():
-        popup_html = f"<b>{row['name']}</b><br>{row['amenity']}<br>{row['address']}<br>{row['phone']}<br>{row['website']}"
-        folium.Marker([row["lat"], row["lon"]], popup=popup_html).add_to(cluster)
+        popup_html = f"""
+        <b>{row['name'] or 'Unnamed Place'}</b><br>
+        📞 {row['phone'] if row['phone'] else 'N/A'}<br>
+        🌐 <a href="{row['website']}" target="_blank">{row['website'] or 'N/A'}</a><br>
+        🍴 {row['amenity']}
+        """
+        folium.Marker(
+            [row["lat"], row["lon"]],
+            popup=folium.Popup(popup_html, max_width=300),
+            tooltip=row["name"] if row["name"] else row["amenity"]
+        ).add_to(cluster)
+
     return m._repr_html_()
 
+
 # -------------------------------------------------------------------
 # Gradio Callbacks
 # -------------------------------------------------------------------
 COUNTRY_NAMES, COUNTRY_CODES = list_countries()
 
-
 def update_states(selected_country_name):
     try:
         idx = COUNTRY_NAMES.index(selected_country_name)
@@ -172,40 +220,46 @@ def run_search(country_name, state_name, categories):
         return "Please select at least one category.", None, None, None
 
     df = fetch_places(categories, bbox)
+
+    # Try Google API enrichment
+    if GOOGLE_API_KEY and GOOGLE_API_KEY != "YOUR_GOOGLE_API_KEY":
+        df = enrich_with_google_api(df)
+
+    # Fallback scraper if still missing phones
+    df = enrich_with_scraper(df)
+
     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)."
+    msg = f"Found {len(df)} places in {state_name}, {country_name}. Took {elapsed:.1f}s."
 
-    # Download link
     csv_b64 = base64.b64encode(csv_bytes).decode("utf-8")
     csv_href = f'<a href="data:text/csv;base64,{csv_b64}" download="results.csv">📥 Download CSV</a>'
 
     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)")
+    gr.Markdown("# 🌍 Hybrid Client Finder (OSM + Google API + Scraper Fallback)")
 
     with gr.Row():
         with gr.Column(scale=1):
             country = gr.Dropdown(choices=COUNTRY_NAMES, value="United States", label="Country")
-
-            # Default US states
             us_names, _ = list_subdivisions("US")
             state = gr.Dropdown(choices=us_names, value=(us_names[0] if us_names else None), 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")
+            categories = gr.CheckboxGroup(place_options, label="Categories", value=["cafe", "restaurant"])
+            search_btn = gr.Button("Search")
 
             info = gr.Textbox(label="Status", interactive=False)
-            download = gr.HTML(label="Download results (CSV)")
+            download = gr.HTML(label="Download CSV")
 
         with gr.Column(scale=2):
             map_html_out = gr.HTML(label="Map")