Update app.py

app.py

@@ -0,0 +1,265 @@
+import os
+import math
+import json
+import requests
+import streamlit as st
+from datetime import datetime
+
+# Optional: transformers for gpt-oss-20b (graceful fallback to tiny model)
+USE_HF = st.sidebar.toggle("Use Hugging Face model for summaries", value=False, help="Turns on text generation via openai/gpt-oss-20b (requires lots of RAM/GPU).")
+HF_MODEL_PRIMARY = "openai/gpt-oss-20b"
+HF_MODEL_FALLBACK = "gpt2"  # small CPU-friendly fallback
+GEN_TEMP = st.sidebar.slider("Gen temperature", 0.0, 1.0, 0.5, 0.05)
+
+# ---------- OSM / Overpass helpers ----------
+HEADERS = {
+    "User-Agent": "OttawaHotelsAttractionsApp/1.0 (contact: you@example.com)"  # Replace with your email/domain
+}
+
+def nominatim_bbox(city="Ottawa", country="Canada"):
+    """Get bounding box for the city using OSM Nominatim (free)."""
+    url = "https://nominatim.openstreetmap.org/search"
+    params = {"city": city, "country": country, "format": "json", "limit": 1}
+    r = requests.get(url, params=params, headers=HEADERS, timeout=20)
+    r.raise_for_status()
+    data = r.json()
+    if not data:
+        return None
+    # OSM returns [south, north, west, east]
+    south, north, west, east = map(float, data[0]["boundingbox"])
+    return (south, west, north, east)
+
+def overpass(query):
+    url = "https://overpass-api.de/api/interpreter"
+    r = requests.post(url, data={"data": query}, headers=HEADERS, timeout=60)
+    r.raise_for_status()
+    return r.json()
+
+def build_overpass_query(bbox, kind="hotel"):
+    s, w, n, e = bbox
+    if kind == "hotel":
+        # tourism=hotel is the standard OSM tag for hotels
+        body = f"""
+        [out:json][timeout:25];
+        (
+          node["tourism"="hotel"]({s},{w},{n},{e});
+          way["tourism"="hotel"]({s},{w},{n},{e});
+          relation["tourism"="hotel"]({s},{w},{n},{e});
+        );
+        out center tags;
+        """
+    elif kind == "attraction":
+        # Mix of common attraction types
+        body = f"""
+        [out:json][timeout:30];
+        (
+          node["tourism"="attraction"]({s},{w},{n},{e});
+          way["tourism"="attraction"]({s},{w},{n},{e});
+          relation["tourism"="attraction"]({s},{w},{n},{e});
+          node["tourism"="museum"]({s},{w},{n},{e});
+          way["tourism"="museum"]({s},{w},{n},{e});
+          relation["tourism"="museum"]({s},{w},{n},{e});
+          node["amenity"="museum"]({s},{w},{n},{e});
+          way["amenity"="museum"]({s},{w},{n},{e});
+          relation["amenity"="museum"]({s},{w},{n},{e});
+          node["tourism"="gallery"]({s},{w},{n},{e});
+          way["tourism"="gallery"]({s},{w},{n},{e});
+          relation["tourism"="gallery"]({s},{w},{n},{e});
+          node["tourism"="theme_park"]({s},{w},{n},{e});
+          node["tourism"="zoo"]({s},{w},{n},{e});
+          node["tourism"="viewpoint"]({s},{w},{n},{e});
+          node["historic"]({s},{w},{n},{e});
+        );
+        out center tags;
+        """
+    else:
+        raise ValueError("Unsupported kind")
+    return body
+
+def node_name(tags):
+    return tags.get("name") or tags.get("alt_name") or tags.get("official_name") or tags.get("brand") or "Unnamed"
+
+def to_osm_link(elem):
+    et = elem.get("type", "node")
+    eid = elem.get("id")
+    return f"https://www.openstreetmap.org/{et}/{eid}"
+
+def score_poi(elem, is_hotel=False):
+    """Heuristic score to approximate 'top' using tag richness."""
+    tags = elem.get("tags", {})
+    score = 0
+    if "name" in tags: score += 2
+    if "wikidata" in tags: score += 3
+    if "wikipedia" in tags: score += 3
+    if "website" in tags: score += 2
+    if "brand" in tags: score += 1
+    if "operator" in tags: score += 1
+
+    if is_hotel:
+        # Hotels sometimes have 'stars' tag
+        stars = tags.get("stars")
+        try:
+            if stars:
+                score += 2 * float(stars)
+        except:
+            pass
+
+        # Chain hotels often provide contact info
+        for k in ("phone", "email"):
+            if k in tags:
+                score += 0.5
+
+    # Slight boost for nodes with precise location
+    if "lat" in elem.get("center", {}) or "lat" in elem:
+        score += 0.5
+
+    return score
+
+def prepare_results(overpass_json, is_hotel=False):
+    elements = overpass_json.get("elements", [])
+    # Normalize center lat/lon
+    for e in elements:
+        if "center" in e:
+            e["lat"], e["lon"] = e["center"]["lat"], e["center"]["lon"]
+        else:
+            e["lat"], e["lon"] = e.get("lat"), e.get("lon")
+
+    # Score & filter out nameless entries when possible
+    scored = []
+    for e in elements:
+        tags = e.get("tags", {})
+        nm = node_name(tags)
+        if not nm or nm.lower().startswith("unnamed"):
+            # keep only if it has website/wikidata
+            if not (tags.get("website") or tags.get("wikidata")):
+                continue
+        scored.append((score_poi(e, is_hotel=is_hotel), e))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    top5 = [e for _, e in scored[:5]]
+
+    # Convert to compact dicts
+    compact = []
+    for e in top5:
+        t = e.get("tags", {})
+        compact.append({
+            "name": node_name(t),
+            "lat": e.get("lat"),
+            "lon": e.get("lon"),
+            "website": t.get("website"),
+            "address": t.get("addr:full") or ", ".join(
+                filter(None, [
+                    t.get("addr:housenumber"),
+                    t.get("addr:street"),
+                    t.get("addr:city"),
+                    t.get("addr:postcode")
+                ])
+            ) or t.get("addr:city"),
+            "stars": t.get("stars") if is_hotel else None,
+            "phone": t.get("phone"),
+            "osm_link": to_osm_link(e)
+        })
+    return compact
+
+# ---------- Hugging Face text generation (optional) ----------
+def gen_blurb(items, title, model_name):
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            device_map="auto",
+            torch_dtype="auto"
+        )
+        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    except Exception as e:
+        # fallback tiny model
+        from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+        tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_FALLBACK)
+        model = AutoModelForCausalLM.from_pretrained(HF_MODEL_FALLBACK)
+        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+
+    place_lines = []
+    for i, p in enumerate(items, 1):
+        line = f"{i}. {p['name']}"
+        if p.get("stars"):
+            line += f" ({p['stars']}★)"
+        place_lines.append(line)
+
+    prompt = (
+        f"Write a warm, vivid 3–4 sentence blurb introducing the list below for a travel app, "
+        f"focusing on Ottawa and speaking to families and solo travelers. Avoid exaggeration.\n"
+        f"Title: {title}\n"
+        f"List:\n" + "\n".join(place_lines)
+    )
+    out = pipe(prompt, max_new_tokens=120, temperature=GEN_TEMP, do_sample=True, top_p=0.92)
+    return out[0]["generated_text"].split("List:")[-1].strip()
+
+# ---------- UI ----------
+st.set_page_config(page_title="Ottawa Hotels & Attractions Finder", page_icon="🗺️", layout="wide")
+st.title("🗺️ Ottawa Hotels & Attractions Finder")
+st.caption("Powered by OpenStreetMap (Nominatim + Overpass). Optional summaries by Hugging Face `openai/gpt-oss-20b`.")
+
+with st.form("search_form"):
+    col1, col2 = st.columns([2,1])
+    with col1:
+        city = st.text_input("City", value="Ottawa", help="You can change this if you like.")
+        country = st.text_input("Country", value="Canada")
+    with col2:
+        submit = st.form_submit_button("Find Top 5 Hotels & Attractions", use_container_width=True)
+
+if submit:
+    try:
+        bbox = nominatim_bbox(city, country)
+        if not bbox:
+            st.error("Could not find that city via Nominatim.")
+        else:
+            st.success(f"Found {city}, {country}. Searching OpenStreetMap…")
+            q_hotels = build_overpass_query(bbox, "hotel")
+            q_attr = build_overpass_query(bbox, "attraction")
+
+            hotels_raw = overpass(q_hotels)
+            attrs_raw = overpass(q_attr)
+
+            hotels = prepare_results(hotels_raw, is_hotel=True)
+            attrs = prepare_results(attrs_raw, is_hotel=False)
+
+            colA, colB = st.columns(2, vertical_alignment="start")
+
+            with colA:
+                st.subheader("🏨 Top 5 Hotels")
+                if USE_HF and hotels:
+                    with st.spinner("Writing hotel blurb with Hugging Face…"):
+                        blurb = gen_blurb(hotels, "Top Hotels in Ottawa", HF_MODEL_PRIMARY)
+                        st.write(blurb)
+                for h in hotels:
+                    st.markdown(f"**{h['name']}**" + (f" — {h['stars']}★" if h.get('stars') else ""))
+                    if h["address"]:
+                        st.write(h["address"])
+                    meta = []
+                    if h["website"]: meta.append(f"[Website]({h['website']})")
+                    if h["osm_link"]: meta.append(f"[OSM]({h['osm_link']})")
+                    if meta: st.write(" • ".join(meta))
+                    st.write("")
+
+            with colB:
+                st.subheader("📍 Top 5 Attractions")
+                if USE_HF and attrs:
+                    with st.spinner("Writing attractions blurb with Hugging Face…"):
+                        blurb = gen_blurb(attrs, "Top Attractions in Ottawa", HF_MODEL_PRIMARY)
+                        st.write(blurb)
+                for a in attrs:
+                    st.markdown(f"**{a['name']}**")
+                    if a["address"]:
+                        st.write(a["address"])
+                    meta = []
+                    if a["website"]: meta.append(f"[Website]({a['website']})")
+                    if a["osm_link"]: meta.append(f"[OSM]({a['osm_link']})")
+                    if meta: st.write(" • ".join(meta))
+                    st.write("")
+
+            st.caption("Notes: Results come from OpenStreetMap community data. Scores approximate ‘top’ via tag richness (stars, website, wikidata, etc.).")
+    except requests.HTTPError as e:
+        st.error(f"HTTP error: {e}")
+    except Exception as ex:
+        st.error(f"Something went wrong: {ex}")