new cities added

.gitignore

@@ -31,5 +31,16 @@ test_output.log
 # They are committed for the Hugging Face Space so it needs no runtime download.
 # If they exceed Space size limits, switch to git-lfs (see PROGRESS.md).
 
+# Secondary city cores now live in the HF dataset
+# (build-small-hackathon/discoverroute-cities) and are pulled + pre-warmed at
+# boot — so DON'T commit newly baked cores into the repo (keeps the image lean).
+# London/Barcelona/New York predate this and stay tracked; this only ignores new
+# untracked cores (San Francisco, Tokyo, Mumbai, Shanghai, Berlin, …).
+data/cities/*_walk.graphml
+data/cities/*_pois.parquet
+!data/cities/london_*
+!data/cities/barcelona_*
+!data/cities/newyork_*
+
 # Inference trace logs (Open Trace) — written at runtime, pushed to HF Dataset
 logs/

app.py

@@ -59,7 +59,7 @@ def suggest(query: str = "") -> list:
 def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
          vibe: str = "", adventurousness: float = 0.3,
          prefer_green: float = 0.0, prefer_quiet: float = 0.0,
-         profile: str = "") -> dict:
+         profile: str = "", city: str = "") -> dict:
     """Plan a route and return everything the custom frontend renders."""
     try:
         profile_obj = json.loads(profile) if profile else {}
@@ -70,6 +70,7 @@ def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
         start_query=start, dest_query=dest, mode=mode, budget=budget, vibe=vibe,
         adventurousness=adventurousness, prefer_green=prefer_green,
         prefer_quiet=prefer_quiet, profile=profile_obj, n_alternatives=N_ALTERNATIVES,
+        city=city,
     )
 
     if result.error:
@@ -160,6 +161,18 @@ def warmup() -> None:
         print("[warmup] routing graph + POIs ready", flush=True)
     except Exception as exc:  # noqa: BLE001
         print(f"[warmup] graph FAILED: {exc}", flush=True)
+
+    # Pre-warm the secondary cities: pull each from the HF dataset (if not already
+    # local) and load it into memory NOW, at boot, so the first user to pick a city
+    # waits 0 s — and request-time stays fully offline (files are local by then).
+    from discoverroute import config
+    from discoverroute.routing import area as area_mod
+    for slug in config.PREWARM_CITIES:
+        try:
+            area_mod._city_area(slug)  # downloads if needed + loads + caches
+            print(f"[warmup] city ready: {slug}", flush=True)
+        except Exception as exc:  # noqa: BLE001 - one bad city must not block boot
+            print(f"[warmup] city {slug} skipped: {exc}", flush=True)
     try:
         from discoverroute.interpret import embed
         embed.vibe_to_affinity("quiet green wander")

data/cities/cities_manifest.json

@@ -52,5 +52,95 @@
     "build_date": "2026-06-13",
     "source": "OpenStreetMap",
     "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "sanfrancisco": {
+    "label": "San Francisco",
+    "center": [
+      37.788,
+      -122.4075
+    ],
+    "bbox": [
+      -122.44387424116717,
+      37.75905120318436,
+      -122.37112575883283,
+      37.81694879681563
+    ],
+    "tz": "America/Los_Angeles",
+    "poi_count": 3802,
+    "build_date": "2026-06-14",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "tokyo": {
+    "label": "Tokyo",
+    "center": [
+      35.6762,
+      139.7653
+    ],
+    "bbox": [
+      139.72991277516684,
+      35.64725120318437,
+      139.80068722483315,
+      35.705148796815635
+    ],
+    "tz": "Asia/Tokyo",
+    "poi_count": 10051,
+    "build_date": "2026-06-14",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "mumbai": {
+    "label": "Mumbai",
+    "center": [
+      18.922,
+      72.8347
+    ],
+    "bbox": [
+      72.80431189708523,
+      18.893051203184367,
+      72.86508810291477,
+      18.950948796815634
+    ],
+    "tz": "Asia/Kolkata",
+    "poi_count": 413,
+    "build_date": "2026-06-14",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "shanghai": {
+    "label": "Shanghai",
+    "center": [
+      31.234,
+      121.481
+    ],
+    "bbox": [
+      121.4473812266571,
+      31.205051203184368,
+      121.51461877334289,
+      31.262948796815635
+    ],
+    "tz": "Asia/Shanghai",
+    "poi_count": 2071,
+    "build_date": "2026-06-14",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "berlin": {
+    "label": "Berlin",
+    "center": [
+      52.517,
+      13.3889
+    ],
+    "bbox": [
+      13.341661332878164,
+      52.48805120318437,
+      13.436138667121835,
+      52.54594879681564
+    ],
+    "tz": "Europe/Berlin",
+    "poi_count": 10810,
+    "build_date": "2026-06-14",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
   }
 }

src/discoverroute/config.py

@@ -87,11 +87,34 @@ def corridor_halfwidth_m(budget: float) -> float:
 CITY_DATA_DIR = DATA_DIR / "cities"
 CITIES_MANIFEST_PATH = CITY_DATA_DIR / "cities_manifest.json"
 CITIES = {
-    "london":    {"label": "London",    "center": (51.5118, -0.1230), "radius_m": 3200, "tz": "Europe/London"},
-    "barcelona": {"label": "Barcelona", "center": (41.3870,  2.1700), "radius_m": 3200, "tz": "Europe/Madrid"},
-    "newyork":   {"label": "New York",  "center": (40.7560, -73.9845), "radius_m": 3200, "tz": "America/New_York"},
+    "london":       {"label": "London",        "center": (51.5118, -0.1230), "radius_m": 3200, "tz": "Europe/London"},
+    "barcelona":    {"label": "Barcelona",     "center": (41.3870,  2.1700), "radius_m": 3200, "tz": "Europe/Madrid"},
+    "newyork":      {"label": "New York",      "center": (40.7560, -73.9845), "radius_m": 3200, "tz": "America/New_York"},
+    "sanfrancisco": {"label": "San Francisco", "center": (37.7880, -122.4075), "radius_m": 3200, "tz": "America/Los_Angeles"},
+    "tokyo":        {"label": "Tokyo",         "center": (35.6762, 139.7653), "radius_m": 3200, "tz": "Asia/Tokyo"},
+    "mumbai":       {"label": "Mumbai",        "center": (18.9220,  72.8347), "radius_m": 3200, "tz": "Asia/Kolkata"},
+    "shanghai":     {"label": "Shanghai",      "center": (31.2340, 121.4810), "radius_m": 3200, "tz": "Asia/Shanghai"},
+    "berlin":       {"label": "Berlin",        "center": (52.5170,  13.3889), "radius_m": 3200, "tz": "Europe/Berlin"},
 }
 
+# Secondary city cores are hosted as a HF *dataset* (just a folder of files), not
+# committed into this repo — so the Space/app image stays lean and scales past a
+# handful of cities. Each `<slug>_walk.graphml` + `<slug>_pois.parquet` is pulled
+# on demand (public repo => no token needed) and cached into CITY_DATA_DIR, after
+# which the normal on-disk path (city_graph_path/city_pois_path) just works.
+CITIES_DATASET_REPO = os.environ.get(
+    "DISCOVERROUTE_CITIES_REPO", "build-small-hackathon/discoverroute-cities"
+)
+# Cities to download + load into memory at boot ("pre-warm") so the first user to
+# pick one waits 0 s. Default: every configured city. Boot cost is paid once,
+# before any request, and keeps request-time fully offline (files already local).
+# Override with a comma-separated slug list, e.g. "london,newyork,tokyo".
+PREWARM_CITIES = [
+    s.strip() for s in os.environ.get(
+        "DISCOVERROUTE_PREWARM_CITIES", ",".join(CITIES)
+    ).split(",") if s.strip() in CITIES
+]
+
 
 def city_graph_path(slug: str) -> Path:
     return CITY_DATA_DIR / f"{slug}_walk.graphml"

src/discoverroute/pipeline.py

@@ -56,11 +56,12 @@ def plan_route(
     prefer_quiet: float = 0.0,
     profile: dict | None = None,
     n_alternatives: int = 1,
+    city: str = "",
 ) -> PlanResult:
     """Plan a route + log one plan-level trace row. Never raises for user errors."""
     result = _plan_route_impl(
         start_query, dest_query, mode, budget, vibe, adventurousness,
-        prefer_green, prefer_quiet, profile, n_alternatives,
+        prefer_green, prefer_quiet, profile, n_alternatives, city,
     )
     try:  # one Open-Trace / Field-Notes row per call; never break a route
         from discoverroute.interpret.affinity import source_of
@@ -93,6 +94,7 @@ def _plan_route_impl(
     prefer_quiet: float = 0.0,
     profile: dict | None = None,
     n_alternatives: int = 1,
+    city: str = "",
 ) -> PlanResult:
     """Plan a route. Returns a PlanResult; never raises for user-facing errors."""
     # Validate & clamp inputs up front (an unknown mode would silently route at
@@ -110,7 +112,7 @@ def _plan_route_impl(
         # Pick the area: Paris is pre-baked/instant; any other city is fetched
         # live from OSM (only the box spanning the two endpoints).
         area = area_mod.resolve_area(
-            start, end, label=_city_label(start_query, dest_query))
+            start, end, label=_city_label(start_query, dest_query), city=city)
         graph = area.graph
         plain = g.plain_route(graph, *start, *end, mode=mode)
     except RouteError as exc:

src/discoverroute/routing/area.py

@@ -173,17 +173,41 @@ def _in_bbox(pt, bbox) -> bool:
 
 
 def available_cities() -> list[str]:
-    """Slugs of pre-baked cities whose data is actually present on disk."""
+    """Slugs of pre-baked cities whose data is present on disk (incl. pulled)."""
     return [s for s in config.CITIES
             if config.city_graph_path(s).exists() and config.city_pois_path(s).exists()]
 
 
+def ensure_city_files(slug: str) -> None:
+    """Make a city's graph + POI parquet exist locally, pulling from the HF
+    dataset if absent. Downloads into CITY_DATA_DIR so every existing on-disk
+    code path (city_graph_path/available_cities) then works unchanged. The repo
+    is public, so no token is needed; the file is cached after the first pull.
+    """
+    targets = [config.city_graph_path(slug), config.city_pois_path(slug)]
+    if all(p.exists() for p in targets):
+        return
+    from huggingface_hub import hf_hub_download
+    config.CITY_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    for path in targets:
+        if path.exists():
+            continue
+        t0 = time.time()
+        hf_hub_download(
+            repo_id=config.CITIES_DATASET_REPO, repo_type="dataset",
+            filename=path.name, local_dir=str(config.CITY_DATA_DIR),
+        )
+        logger.info("pulled %s from %s in %.1fs",
+                    path.name, config.CITIES_DATASET_REPO, time.time() - t0)
+
+
 @functools.lru_cache(maxsize=8)
 def _city_area(slug: str) -> Area:
-    """Load a pre-baked city (committed graph + parquet) as an offline Area."""
+    """Load a pre-baked city as an offline Area, pulling its files if needed."""
     from discoverroute.routing import graph as g
 
     spec = config.CITIES[slug]
+    ensure_city_files(slug)
     graph = ox.load_graphml(config.city_graph_path(slug))
     df = pd.read_parquet(config.city_pois_path(slug))
     origin = tuple(spec["center"])
@@ -244,15 +268,26 @@ def _build_ondemand(bbox, label: str) -> Area:
 
 
 def resolve_area(start: tuple[float, float], end: tuple[float, float],
-                 label: str = "") -> Area:
+                 label: str = "", city: str = "") -> Area:
     """Pick the right area for an A→B request.
 
-    Both endpoints inside Paris => the instant pre-baked area. Otherwise fetch a
-    just-big-enough box around the two points live from OSM. Endpoints too far
-    apart for an on-demand box are rejected with a friendly RouteError.
+    An explicit ``city`` slug (from the UI picker) wins outright — the pre-baked
+    core is loaded (pulled from the dataset if needed). Otherwise both endpoints
+    inside Paris => the pre-baked Paris area; both inside one cached city core =>
+    that core; anything else is fetched just-big-enough live from OSM. Endpoints
+    too far apart for an on-demand box are rejected with a friendly RouteError.
     """
     from discoverroute.routing.graph import RouteError
 
+    # 0) Explicit city pick (the UI dropdown) — load that core, full stop.
+    slug = (city or "").strip().lower()
+    if slug:
+        if slug == "paris":
+            return _paris_area()
+        if slug in config.CITIES:
+            return _city_area(slug)
+        # Unknown slug => ignore and fall through to inference (never crash a route).
+
     # 1) Paris — full pre-baked city (instant, offline).
     if config.in_paris(*start) and config.in_paris(*end):
         return _paris_area()

src/discoverroute/ui/shell.py

@@ -82,6 +82,7 @@ body{ font-family:'DM Sans',ui-sans-serif,system-ui,sans-serif; color:var(--dr-i
 /* a leading pin/flag glyph for the start & destination fields */
 .field-wrap{ position:relative; }
 .field-wrap > input[type=text]{ padding-left:34px; }
+.field-wrap > select.dr-field{ padding-left:34px; cursor:pointer; }
 .field-wrap::before{ content:attr(data-glyph); position:absolute; left:12px; top:50%;
   transform:translateY(-50%); font-size:14px; pointer-events:none; z-index:2; line-height:1; }
 
@@ -314,6 +315,21 @@ def _vibe_chips() -> str:
     return f'<div class="vibe-chips" id="dr-vibe-chips">{chips}</div>'
 
 
+# (slug, label) for the city picker: Paris (the always-on default) then every
+# configured core. The chosen slug is sent to /plan and wins area resolution.
+_CITY_CHOICES = [("paris", "Paris")] + [
+    (slug, spec["label"]) for slug, spec in config.CITIES.items()
+]
+
+
+def _city_options() -> str:
+    opts = "".join(
+        f'<option value="{slug}"{" selected" if slug == "paris" else ""}>{label}</option>'
+        for slug, label in _CITY_CHOICES
+    )
+    return opts
+
+
 def _left_panel() -> str:
     return f"""
 <aside class="left-panel" id="left-panel">
@@ -337,6 +353,15 @@ def _left_panel() -> str:
     {_vibe_chips()}
   </div>
 
+  <div class="dr-control">
+    <label class="dr-label" for="dr-city">City</label>
+    <div class="field-wrap" data-glyph="🌍">
+      <select id="dr-city" class="dr-field">{_city_options()}</select>
+    </div>
+    <div class="dr-help">Pick the city to explore — Start &amp; Destination should be
+      places within it.</div>
+  </div>
+
   <div class="dr-control combo">
     <label class="dr-label" for="dr-start">Start</label>
     <div class="field-wrap" data-glyph="📍">
@@ -344,8 +369,7 @@ def _left_panel() -> str:
              value="Place de la République, Paris">
     </div>
     <div class="combo-list" id="dr-start-list"></div>
-    <div class="dr-help">📍 Paris · London · Barcelona · New York — try a landmark
-      (e.g. "British Museum, London"), not a street address.</div>
+    <div class="dr-help">Try a landmark (e.g. "British Museum"), not a street address.</div>
   </div>
 
   <div class="dr-control combo">
@@ -781,6 +805,7 @@ async function plan() {
       adventurousness: +$("dr-adv-i").value,
       prefer_green: +$("dr-green-i").value, prefer_quiet: +$("dr-quiet-i").value,
       profile: JSON.stringify(readProfile()),
+      city: $("dr-city").value,
     });
     renderResult((r.data && r.data[0]) || {});
   } catch (e) {