Upload app/geocode.py with huggingface_hub

app/geocode.py

@@ -22,55 +22,33 @@ log = logging.getLogger("riprap.geocode")
 
 URL = "https://geosearch.planninglabs.nyc/v2/search"
 NOMINATIM_URL = "https://nominatim.openstreetmap.org/search"
-NOMINATIM_UA = "Riprap-NYC/0.1 (civic-flood-tool; +https://huggingface.co/spaces/msradam/riprap-nyc)"
+NOMINATIM_UA = "Riprap-NYC/0.5 (civic-flood-tool; +https://huggingface.co/spaces/msradam/riprap-nyc)"
 
-# NYC-bbox guard: lat 40.49–40.92, lon -74.27 to -73.69. Anything outside
-# this is probably not NYC; treat NYC Geosearch hits outside it as bogus.
+# NYC-bbox guard: lat 40.49–40.92, lon -74.27 to -73.69.
 NYC_BBOX = (40.49, -74.27, 40.92, -73.69)
 
-# NYC ZIP prefixes are 100–104 (Manhattan), 110 (Queens), 112 (Brooklyn),
-# 113 (Queens), 114 (Queens), 116 (Queens), 100 (Bronx 104), 103 (SI 1),
-# basically all 1x with 3rd char 0–6. Upstate NY is 12x, 13x, 14x. We use
-# this only as a HINT to escalate to Nominatim, not as a hard filter.
 _UPSTATE_ZIP_RE = re.compile(r"\b1[2-4]\d{3}\b")
-_NON_NYC_HINTS = re.compile(
-    r"\b(albany|troy|schenectady|saratoga|kingston|poughkeepsie|newburgh|"
-    r"yonkers|white plains|hudson|rhinebeck|peekskill|beacon|tarrytown|"
-    r"new paltz|catskill|tivoli|hyde park|coxsackie|cohoes|amsterdam|"
-    r"glens falls|lake george|nyack|garrison|cold spring|highland|saugerties)\b",
-    re.IGNORECASE,
-)
-
 _BOROUGHS = ("Manhattan", "Bronx", "Brooklyn", "Queens", "Staten Island")
 
-
 def _detect_borough(text: str) -> str | None:
     t = text.lower()
     for b in _BOROUGHS:
         if b.lower() in t:
             return b
-    # neighborhood -> borough hints (incomplete but covers our demo set)
+    # neighborhood -> borough hints
     hints = {
-        "queens": "Queens",
-        "jamaica": "Queens", "hollis": "Queens", "rockaway": "Queens",
-        "elmhurst": "Queens", "maspeth": "Queens", "ozone park": "Queens",
-        "astoria": "Queens", "flushing": "Queens", "edgemere": "Queens",
+        "queens": "Queens", "jamaica": "Queens", "rockaway": "Queens",
+        "astoria": "Queens", "flushing": "Queens",
         "manhattan": "Manhattan", "harlem": "Manhattan", "soho": "Manhattan",
-        "tribeca": "Manhattan", "midtown": "Manhattan", "les": "Manhattan",
-        "chelsea": "Manhattan", "noho": "Manhattan",
-        "brooklyn": "Brooklyn", "bushwick": "Brooklyn",
-        "carroll gardens": "Brooklyn", "gowanus": "Brooklyn",
-        "park slope": "Brooklyn", "williamsburg": "Brooklyn",
-        "coney island": "Brooklyn", "red hook": "Brooklyn",
-        "bronx": "Bronx", "fordham": "Bronx", "riverdale": "Bronx",
-        "staten island": "Staten Island", "richmond": "Staten Island",
+        "brooklyn": "Brooklyn", "bushwick": "Brooklyn", "red hook": "Brooklyn",
+        "bronx": "Bronx", "fordham": "Bronx",
+        "staten island": "Staten Island",
     }
     for needle, boro in hints.items():
         if needle in t:
             return boro
     return None
 
-
 @dataclass
 class GeocodeHit:
     address: str
@@ -81,45 +59,32 @@ class GeocodeHit:
     bin: str | None
     raw: dict
 
-
 def geocode(text: str, limit: int = 5) -> list[GeocodeHit]:
-    """Return up to `limit` candidates from Geosearch, ranked by API order."""
-    r = httpx.get(URL, params={"text": text, "size": limit}, timeout=15)
-    r.raise_for_status()
-    feats = r.json().get("features", [])
-    out = []
-    for f in feats:
-        p = f.get("properties", {})
-        coords = (f.get("geometry") or {}).get("coordinates") or [None, None]
-        out.append(GeocodeHit(
-            address=p.get("label") or p.get("name") or text,
-            borough=p.get("borough"),
-            lat=coords[1],
-            lon=coords[0],
-            bbl=p.get("addendum", {}).get("pad", {}).get("bbl"),
-            bin=p.get("addendum", {}).get("pad", {}).get("bin"),
-            raw=p,
-        ))
-    return out
-
-
-def _looks_upstate(text: str) -> bool:
-    """Heuristic: should this query bypass NYC Geosearch?"""
-    if _UPSTATE_ZIP_RE.search(text):
-        return True
-    if _NON_NYC_HINTS.search(text):
-        return True
-    return False
-
-
-def _in_nyc_bbox(lat: float, lon: float) -> bool:
-    s, w, n, e = NYC_BBOX
-    return s <= lat <= n and w <= lon <= e
-
+    """NYC Geosearch primary."""
+    try:
+        r = httpx.get(URL, params={"text": text, "size": limit}, timeout=5)
+        r.raise_for_status()
+        feats = r.json().get("features", [])
+        out = []
+        for f in feats:
+            p = f.get("properties", {})
+            coords = (f.get("geometry") or {}).get("coordinates") or [None, None]
+            out.append(GeocodeHit(
+                address=p.get("label") or p.get("name") or text,
+                borough=p.get("borough"),
+                lat=coords[1],
+                lon=coords[0],
+                bbl=p.get("addendum", {}).get("pad", {}).get("bbl"),
+                bin=p.get("addendum", {}).get("pad", {}).get("bin"),
+                raw=p,
+            ))
+        return out
+    except Exception as e:
+        log.warning("Geosearch failed: %r", e)
+        return []
 
 def geocode_nominatim(text: str) -> GeocodeHit | None:
-    """National OSM Nominatim fallback. Used when NYC Geosearch can't
-    plausibly answer the query."""
+    """National OSM Nominatim fallback."""
     try:
         r = httpx.get(NOMINATIM_URL, params={
             "q": text, "format": "jsonv2", "addressdetails": "1",
@@ -134,80 +99,40 @@ def geocode_nominatim(text: str) -> GeocodeHit | None:
         return None
     row = rows[0]
     addr = row.get("address") or {}
-    label = row.get("display_name") or text
+    
+    # Try to map Nominatim borough/county back to NYC standard
+    boro = addr.get("suburb") or addr.get("city_district") or addr.get("county")
+    if boro and "Kings" in boro: boro = "Brooklyn"
+    if boro and "New York County" in boro: boro = "Manhattan"
+    if boro and "Queens" in boro: boro = "Queens"
+    if boro and "Bronx" in boro: boro = "Bronx"
+    if boro and "Richmond" in boro: boro = "Staten Island"
+
     return GeocodeHit(
-        address=label,
-        borough=addr.get("city") or addr.get("town") or addr.get("village") or addr.get("county"),
+        address=row.get("display_name") or text,
+        borough=boro,
         lat=float(row["lat"]),
         lon=float(row["lon"]),
-        bbl=None,
+        bbl=None, # Nominatim doesn't have BBLs
         bin=None,
         raw={"source": "nominatim", **row},
     )
 
-
 def geocode_one(text: str) -> GeocodeHit | None:
-    \"\"\"Best match for `text`, using NYC Geosearch primary with a national
-    OSM Nominatim fallback for upstate / non-NYC queries.
-    \"\"\"
-    # RESILIENCE PATCH: Hardcoded success for canonical demo addresses.
-    t = text.lower()
-    # 1. 80 Pioneer Street (Red Hook)
-    if '80 pioneer' in t:
-        return GeocodeHit(
-            address='80 Pioneer Street, Brooklyn, NY 11231',
-            borough='Brooklyn', lat=40.67805, lon=-74.00958,
-            bbl='3005530030', bin='3008985', raw={'source': 'patch'},
-        )
-    # 2. PS 188 (Lower East Side) - very close to East River and transit
-    if 'ps 188' in t or '442 east houston' in t:
-        return GeocodeHit(
-            address='442 East Houston Street, Manhattan, NY 10002',
-            borough='Manhattan', lat=40.71965, lon=-73.97745,
-            bbl='1003550001', bin='1004124', raw={'source': 'patch'},
-        )
-    # 3. Bowling Green (Financial District) - subway-heavy
-    if 'bowling green' in t:
-        return GeocodeHit(
-            address='Bowling Green Station, Manhattan, NY 10004',
-            borough='Manhattan', lat=40.7048, lon=-74.0135,
-            bbl='1000070001', bin='1000001', raw={'source': 'patch'},
-        )
-    # 4. 2950 W 25 St (Coney Island) - NYCHA + Sandy heavy
-    if '2950 w 25' in t or 'coney island' in t:
-        return GeocodeHit(
-            address='2950 West 25th Street, Brooklyn, NY 11224',
-            borough='Brooklyn', lat=40.5755, lon=-73.9930,
-            bbl='3070490001', bin='3000000', raw={'source': 'patch'},
-        )
-
-    if _looks_upstate(text):
-        log.info("upstate hint detected in %r — using Nominatim", text)
-        hit = geocode_nominatim(text)
-        if hit:
-            return hit
-
+    """Dynamic geocoder with failover."""
+    # 1. Try Geosearch
+    hits = geocode(text)
     hint = _detect_borough(text)
-    try:
-        hits = geocode(text, limit=8)
-    except Exception as e:
-        # Geosearch is unreachable or returned a server error — fall back to
-        # Nominatim rather than surfacing a 503 to every downstream specialist.
-        log.warning("Geosearch unavailable (%r) — falling back to Nominatim", e)
-        return geocode_nominatim(text)
+    
     if hint:
         in_boro = [h for h in hits if h.borough and h.borough.lower() == hint.lower()]
-        if in_boro:
-            return in_boro[0]
-
+        if in_boro: return in_boro[0]
+    
     if hits:
         top = hits[0]
-        if top.lat is not None and _in_nyc_bbox(top.lat, top.lon):
+        if top.lat and 40.4 <= top.lat <= 41.0: # Broad NYC check
             return top
-        # Geosearch returned a hit, but it's outside the NYC bbox — that
-        # means even the NYC API thinks the answer isn't NYC. Try
-        # Nominatim before giving up.
-        log.info("Geosearch top hit outside NYC bbox (%s, %s) — falling back",
-                 top.lat, top.lon)
 
+    # 2. Fall back to Nominatim
+    log.info("Falling back to Nominatim for %r", text)
     return geocode_nominatim(text)