# Linux / macOS
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

# Or macOS ARM (Apple Silicon)
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
bash Miniconda3-latest-MacOSX-arm64.sh

conda create -n urban-geo python=3.11 -y
conda activate urban-geo

pip install pandas geopandas matplotlib seaborn shapely fiona pyproj \
    osmnx networkx h3 requests beautifulsoup4 \
    psycopg2-binary sqlalchemy geoalchemy2 \
    earthengine-api geemap \
    streamlit pydeck plotly folium

# Ubuntu/Debian
sudo apt install postgresql postgis -y

# macOS (Homebrew)
brew install postgresql@16 postgis

# Start the service
sudo systemctl start postgresql   # Linux
brew services start postgresql@16 # macOS

sudo -u postgres createdb urban_semarang
sudo -u postgres psql -d urban_semarang -c "CREATE EXTENSION postgis; CREATE EXTENSION h3;"

mkdir -p urban_analytics/{data/raw,data/processed,output,notebooks,scripts}
cd urban_analytics

earthengine authenticate

import pandas as pd
import geopandas as gpd
import osmnx as ox
import h3
import ee

ee.Initialize()

print("pandas", pd.__version__)
print("geopandas", gpd.__version__)
print("osmnx", ox.__version__)
print("h3", h3.__version__)
print("GEE OK")
print("\n✓ All systems go. Ready for Module 1.")

# Cell 1 — City Configuration
# Change this ONE dict to switch the entire pipeline to a new city

CITY = {
    "name": "Semarang",
    "province": "Jawa Tengah",
    "osm_query": "Semarang, Indonesia",
    "lat": -6.97,
    "lon": 110.42,
    "epsg_utm": 32749,
    "bps_code": "3374",
    "coastal": True,
    "bbox": [110.28, -7.12, 110.53, -6.88],
}

print(f"Working with: {CITY['name']}, {CITY['province']}")

# Cell 2 — Practice DataFrames
import pandas as pd

# Sample district data — we'll fetch real data in Module 2
districts = pd.DataFrame({
    "kecamatan": ["Kec A", "Kec B", "Kec C", "Kec D", "Kec E"],
    "population": [85000, 120000, 65000, 95000, 110000],
    "area_km2": [12.5, 8.3, 22.1, 15.6, 9.8],
    "elevation_m": [3, 85, 210, 45, 5],
})

# Derived columns
districts["density"] = (districts["population"] / districts["area_km2"]).round(0)
districts["flood_risk"] = districts["elevation_m"].apply(
    lambda e: "high" if e < 5 else ("medium" if e < 20 else "low")
)

print(districts.to_string(index=False))

# Cell 3 — Summary by risk category
summary = districts.groupby("flood_risk").agg(
    n_kecamatan=("kecamatan", "count"),
    total_pop=("population", "sum"),
    avg_density=("density", "mean"),
).round(0)

print(summary)

# Cell 4 — Functions we'll reuse throughout the course
import math

def haversine(lat1, lon1, lat2, lon2):
    """Distance in km between two GPS points."""
    R = 6371
    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = math.sin(dlat/2)**2 + math.cos(math.radians(lat1)) * \
        math.cos(math.radians(lat2)) * math.sin(dlon/2)**2
    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

def calculate_kdb(footprint_m2, land_area_m2):
    """KDB = building footprint / land parcel area."""
    return round(footprint_m2 / land_area_m2, 3) if land_area_m2 > 0 else 0

def classify_density(pop_per_km2):
    """Indonesian urban density classification."""
    if pop_per_km2 > 15000: return "very_high"
    if pop_per_km2 > 10000: return "high"
    if pop_per_km2 > 5000: return "medium"
    return "low"

# Test
print(f"Distance city center to bbox corner: "
      f"{haversine(CITY['lat'], CITY['lon'], CITY['bbox'][1], CITY['bbox'][0]):.1f} km")
print(f"KDB of 250m² on 400m² lot: {calculate_kdb(250, 400)}")
print(f"14,000 pop/km²: {classify_density(14000)}")

# Cell 5 — Save config
import json
from pathlib import Path

config_path = Path("../data/city_config.json")
config_path.write_text(json.dumps(CITY, indent=2, ensure_ascii=False))
print(f"Saved to {config_path.resolve()}")

import json, requests
import pandas as pd
import geopandas as gpd
from pathlib import Path

CITY = json.loads(Path("../data/city_config.json").read_text())
print(f"Acquiring data for: {CITY['name']}")

import osmnx as ox

# Download city boundary
boundary = ox.geocode_to_gdf(CITY["osm_query"])
boundary.to_file("../data/raw/admin_boundary.geojson", driver="GeoJSON")
print(f"Boundary area: {boundary.to_crs(epsg=CITY['epsg_utm']).area.iloc[0] / 1e6:.1f} km²")

# Download building footprints via OSMnx
tags = {"building": True}
buildings = ox.features_from_place(CITY["osm_query"], tags=tags)

# Keep only polygons (discard nodes)
buildings = buildings[buildings.geometry.type.isin(["Polygon", "MultiPolygon"])].copy()

# Calculate footprint area in m²
buildings_utm = buildings.to_crs(epsg=CITY["epsg_utm"])
buildings["footprint_m2"] = buildings_utm.geometry.area.round(1)

# Save
cols = ["name", "building", "building:levels", "footprint_m2", "geometry"]
cols = [c for c in cols if c in buildings.columns]
buildings[cols].to_file("../data/raw/buildings.geojson", driver="GeoJSON")
print(f"Downloaded {len(buildings):,} building footprints")

# Street network — we'll analyze this deeply in Module 4
G = ox.graph_from_place(CITY["osm_query"], network_type="drive")
ox.save_graphml(G, "../data/raw/street_network.graphml")

nodes, edges = ox.graph_to_gdfs(G)
print(f"Network: {len(nodes):,} intersections, {len(edges):,} road segments")

# BPS API — population by sub-district
# Note: you need a free API key from webapi.bps.go.id
BPS_KEY = "YOUR_BPS_API_KEY"  # Register at webapi.bps.go.id

# Alternative: scrape the BPS website table
url = f"https://semarangkota.bps.go.id/indicator/12/71/1/jumlah-penduduk.html"
try:
    tables = pd.read_html(url)
    population = tables[0]
    population.to_csv("../data/raw/population_bps.csv", index=False)
    print(f"Scraped {len(population)} rows from BPS")
except Exception as e:
    print(f"BPS scraping failed: {e}")
    print("Tip: manually download from the BPS website and save as CSV")

# Key urban facilities
poi_tags = {
    "amenity": ["hospital", "school", "marketplace"],
    "shop": True,
}
pois = ox.features_from_place(CITY["osm_query"], tags=poi_tags)
pois_points = pois.copy()
pois_points["geometry"] = pois_points.geometry.centroid
pois_points[["name", "amenity", "shop", "geometry"]].dropna(
    subset=["name"]
).to_file("../data/raw/pois.geojson", driver="GeoJSON")
print(f"Downloaded {len(pois_points):,} POIs")

# Quick inventory check
raw = Path("../data/raw")
for f in sorted(raw.glob("*")):
    size = f.stat().st_size / 1024
    unit = "KB"
    if size > 1024:
        size /= 1024; unit = "MB"
    print(f"  {f.name:<35} {size:>8.1f} {unit}")

import json
import geopandas as gpd
import pandas as pd
import h3
import matplotlib.pyplot as plt
from shapely.geometry import Polygon
from pathlib import Path

CITY = json.loads(Path("../data/city_config.json").read_text())

# Load Module 2 outputs
buildings = gpd.read_file("../data/raw/buildings.geojson")
boundary = gpd.read_file("../data/raw/admin_boundary.geojson")

print(f"Buildings: {len(buildings):,} features, CRS: {buildings.crs}")
print(f"Boundary CRS: {boundary.crs}")

# Reproject to UTM for metric calculations
buildings_utm = buildings.to_crs(epsg=CITY["epsg_utm"])

# Building footprint area (m²)
buildings["footprint_m2"] = buildings_utm.geometry.area.round(1)

# Estimate floors if available from OSM tags
if "building:levels" in buildings.columns:
    buildings["floors"] = pd.to_numeric(
        buildings["building:levels"], errors="coerce"
    ).fillna(1).astype(int)
else:
    buildings["floors"] = 1

buildings["floor_area_m2"] = buildings["footprint_m2"] * buildings["floors"]

print(buildings[["footprint_m2", "floors", "floor_area_m2"]].describe().round(1))

# Convert building centroids to H3 cells at resolution 9
H3_RES = 9

centroids = buildings.geometry.centroid.to_crs(epsg=4326)
buildings["h3_cell"] = [
    h3.latlng_to_cell(pt.y, pt.x, H3_RES) for pt in centroids
]

print(f"Unique H3 cells: {buildings['h3_cell'].nunique():,}")
print(f"Sample cell: {buildings['h3_cell'].iloc[0]}")

# Aggregate per hexagon
h3_stats = buildings.groupby("h3_cell").agg(
    building_count=("footprint_m2", "count"),
    total_footprint=("footprint_m2", "sum"),
    avg_footprint=("footprint_m2", "mean"),
    max_floors=("floors", "max"),
    total_floor_area=("floor_area_m2", "sum"),
).round(1)

# Create H3 hexagon geometries for mapping
def h3_to_polygon(cell_id):
    boundary = h3.cell_to_boundary(cell_id)
    return Polygon([(lng, lat) for lat, lng in boundary])

h3_grid = gpd.GeoDataFrame(
    h3_stats,
    geometry=[h3_to_polygon(c) for c in h3_stats.index],
    crs="EPSG:4326"
)
h3_grid.index.name = "h3_cell"

print(f"H3 grid: {len(h3_grid)} hexagons")
print(h3_grid.head())

# H3 res-9 hex area in m² (approximate)
HEX_AREA_M2 = 105000  # ~0.105 km²

h3_grid["kdb_approx"] = (h3_grid["total_footprint"] / HEX_AREA_M2).round(3)
h3_grid["density_class"] = pd.cut(
    h3_grid["kdb_approx"],
    bins=[0, 0.1, 0.3, 0.5, 1.0, float("inf")],
    labels=["sparse", "low", "medium", "high", "very_high"]
)

print(h3_grid["density_class"].value_counts())

# Map: building density by H3 cell
fig, ax = plt.subplots(figsize=(12, 10))
boundary.to_crs(epsg=4326).boundary.plot(ax=ax, color="black", linewidth=1)
h3_grid.plot(column="kdb_approx", cmap="YlOrRd", legend=True,
             ax=ax, alpha=0.7, edgecolor="grey", linewidth=0.2)
ax.set_title(f"Building Density (KDB approx) — {CITY['name']}")
plt.savefig("../output/h3_building_density.png", dpi=150, bbox_inches="tight")
plt.show()

# Save processed data
buildings.to_file("../data/processed/buildings_processed.gpkg", driver="GPKG")
h3_grid.reset_index().to_file("../data/processed/h3_grid.gpkg", driver="GPKG")
print("Saved: buildings_processed.gpkg, h3_grid.gpkg")

import json
import osmnx as ox
import networkx as nx
import geopandas as gpd
import matplotlib.pyplot as plt
from pathlib import Path

CITY = json.loads(Path("../data/city_config.json").read_text())

# Load the graph saved in Module 2
G = ox.load_graphml("../data/raw/street_network.graphml")
G_undir = ox.convert.to_undirected(G)

nodes, edges = ox.graph_to_gdfs(G_undir)
print(f"Network: {len(nodes):,} nodes, {len(edges):,} edges")

# Betweenness centrality (may take several minutes for large cities)
print("Calculating betweenness centrality...")
bc = nx.betweenness_centrality(G_undir, weight="length")

print("Calculating closeness centrality...")
cc = nx.closeness_centrality(G_undir, distance="length")

# Attach to nodes GeoDataFrame
nodes["betweenness"] = nodes.index.map(bc)
nodes["closeness"] = nodes.index.map(cc)

print(f"Top betweenness: {nodes['betweenness'].max():.6f}")
print(f"Top closeness: {nodes['closeness'].max():.6f}")

# Walk network for isochrones
G_walk = ox.graph_from_place(CITY["osm_query"], network_type="walk")

# Find nearest node to city center
center_node = ox.nearest_nodes(G_walk, CITY["lon"], CITY["lat"])

# Walking speed ~ 4.5 km/h = 1.25 m/s
WALK_SPEED = 1.25
for u, v, data in G_walk.edges(data=True):
    data["time"] = data["length"] / WALK_SPEED

# Isochrone polygons
isochrones = []
for minutes in [5, 10, 15]:
    subgraph = nx.ego_graph(G_walk, center_node,
                            radius=minutes * 60, distance="time")
    iso_nodes = ox.graph_to_gdfs(subgraph, edges=False)
    hull = iso_nodes.unary_union.convex_hull
    isochrones.append({"minutes": minutes, "geometry": hull})

iso_gdf = gpd.GeoDataFrame(isochrones, crs="EPSG:4326")
iso_gdf.to_file("../data/processed/isochrones.gpkg", driver="GPKG")
print(f"Generated {len(iso_gdf)} isochrones")

# Betweenness centrality map
fig, ax = plt.subplots(figsize=(14, 10))
edges_gdf = ox.graph_to_gdfs(G_undir, nodes=False)
edges_gdf.plot(ax=ax, color="#ddd", linewidth=0.3)
nodes.plot(ax=ax, column="betweenness", cmap="hot_r",
           markersize=nodes["betweenness"] * 50000,
           alpha=0.7, legend=True)
ax.set_title(f"Betweenness Centrality — {CITY['name']}")
ax.set_axis_off()
plt.savefig("../output/betweenness_map.png", dpi=150, bbox_inches="tight")
plt.show()

# Save centrality nodes
nodes.to_file("../data/processed/centrality_nodes.gpkg", driver="GPKG")
print("Saved: centrality_nodes.gpkg")

# Load buildings
ogr2ogr -f "PostgreSQL" \
  PG:"dbname=urban_semarang user=postgres" \
  data/processed/buildings_processed.gpkg \
  -nln buildings -overwrite -lco GEOMETRY_NAME=geom

# Load H3 grid
ogr2ogr -f "PostgreSQL" \
  PG:"dbname=urban_semarang user=postgres" \
  data/processed/h3_grid.gpkg \
  -nln h3_grid -overwrite -lco GEOMETRY_NAME=geom

# Load centrality nodes
ogr2ogr -f "PostgreSQL" \
  PG:"dbname=urban_semarang user=postgres" \
  data/processed/centrality_nodes.gpkg \
  -nln centrality_nodes -overwrite -lco GEOMETRY_NAME=geom

# Load admin boundary
ogr2ogr -f "PostgreSQL" \
  PG:"dbname=urban_semarang user=postgres" \
  data/raw/admin_boundary.geojson \
  -nln admin_boundary -overwrite -lco GEOMETRY_NAME=geom

-- Connect: psql -d urban_semarang

CREATE INDEX IF NOT EXISTS idx_buildings_geom ON buildings USING GIST(geom);
CREATE INDEX IF NOT EXISTS idx_h3_grid_geom ON h3_grid USING GIST(geom);
CREATE INDEX IF NOT EXISTS idx_centrality_geom ON centrality_nodes USING GIST(geom);

-- Verify tables loaded
SELECT tablename, pg_size_pretty(pg_total_relation_size(tablename::text))
FROM pg_tables
WHERE schemaname = 'public';

-- Find buildings within 500m of a coastal point
SELECT count(*) AS coastal_buildings,
       round(avg(footprint_m2)::numeric, 1) AS avg_footprint
FROM buildings
WHERE ST_DWithin(
    geom::geography,
    ST_SetSRID(ST_MakePoint(110.42, -6.97), 4326)::geography,
    500  -- meters
);

-- Join buildings to H3 hexagons and aggregate
CREATE MATERIALIZED VIEW h3_building_summary AS
SELECT
    h.h3_cell,
    h.geom,
    count(b.*) AS building_count,
    coalesce(sum(b.footprint_m2), 0) AS total_footprint,
    coalesce(avg(b.footprint_m2), 0)::numeric(10,1) AS avg_footprint
FROM h3_grid h
LEFT JOIN buildings b ON ST_Contains(h.geom, b.geom)
GROUP BY h.h3_cell, h.geom;

CREATE INDEX idx_h3_summary_geom ON h3_building_summary USING GIST(geom);

-- Check result
SELECT count(*) AS hexagons,
       sum(building_count) AS total_buildings
FROM h3_building_summary;

import geopandas as gpd
from sqlalchemy import create_engine

engine = create_engine("postgresql://postgres@localhost/urban_semarang")

# Load H3 building summary as GeoDataFrame
h3_summary = gpd.read_postgis(
    "SELECT * FROM h3_building_summary",
    engine, geom_col="geom"
)
print(f"Loaded {len(h3_summary)} hexagons from PostGIS")
print(h3_summary[["h3_cell", "building_count", "total_footprint"]].head())

import json, ee
import geemap
from pathlib import Path

ee.Initialize()
CITY = json.loads(Path("../data/city_config.json").read_text())

# Define study area from bounding box
bbox = CITY["bbox"]
aoi = ee.Geometry.Rectangle([bbox[0], bbox[1], bbox[2], bbox[3]])

print(f"Study area: {CITY['name']}")
print(f"Bounding box: {bbox}")

def get_composite(year, aoi):
    """Cloud-masked median composite from Landsat 8/9."""
    collection = (ee.ImageCollection("LANDSAT/LC08/C02/T1_L2")
        .merge(ee.ImageCollection("LANDSAT/LC09/C02/T1_L2"))
        .filterBounds(aoi)
        .filterDate(f"{year}-01-01", f"{year}-12-31")
        .filter(ee.Filter.lt("CLOUD_COVER", 20)))

    def mask_clouds(img):
        qa = img.select("QA_PIXEL")
        mask = qa.bitwiseAnd(1 << 3).eq(0).And(qa.bitwiseAnd(1 << 4).eq(0))
        return img.updateMask(mask)

    return collection.map(mask_clouds).median().clip(aoi)

composite_2015 = get_composite(2015, aoi)
composite_2023 = get_composite(2023, aoi)
print("Composites ready")

def add_indices(img):
    """Add NDVI, NDBI, MNDWI to a Landsat image."""
    ndvi = img.normalizedDifference(["SR_B5", "SR_B4"]).rename("NDVI")
    ndbi = img.normalizedDifference(["SR_B6", "SR_B5"]).rename("NDBI")
    mndwi = img.normalizedDifference(["SR_B3", "SR_B6"]).rename("MNDWI")
    return img.addBands([ndvi, ndbi, mndwi])

img_2015 = add_indices(composite_2015)
img_2023 = add_indices(composite_2023)

# Visualize NDVI
Map = geemap.Map(center=[CITY["lat"], CITY["lon"]], zoom=11)
Map.addLayer(img_2023.select("NDVI"), {"min": -0.2, "max": 0.8, "palette": ["red", "yellow", "green"]}, "NDVI 2023")
Map

# Training points (replace with your own labeled samples)
# Classes: 0=water, 1=vegetation, 2=built-up, 3=bare_soil
bands = ["SR_B2","SR_B3","SR_B4","SR_B5","SR_B6","SR_B7","NDVI","NDBI","MNDWI"]

# Use a GEE training dataset or create your own FeatureCollection
# For reproducibility, use ESA WorldCover as pseudo-labels
worldcover = ee.Image("ESA/WorldCover/v200").clip(aoi)

# Sample training points from WorldCover
training = img_2023.select(bands).addBands(worldcover.rename("label")).sample(
    region=aoi, scale=30, numPixels=5000, seed=42
)

# Train Random Forest
classifier = ee.Classifier.smileRandomForest(50).train(
    features=training, classProperty="label", inputProperties=bands
)

# Classify both years
classified_2015 = img_2015.select(bands).classify(classifier)
classified_2023 = img_2023.select(bands).classify(classifier)
print("Classification complete")

# Elevation from SRTM
dem = ee.Image("USGS/SRTMGL1_003").clip(aoi)
elevation = dem.select("elevation")
slope = ee.Terrain.slope(dem)

# Normalize to 0-1 (higher value = more hazardous)
h_elev = elevation.multiply(-1).add(50).divide(50).clamp(0, 1)  # low elevation = high risk
h_slope = slope.multiply(-1).add(30).divide(30).clamp(0, 1)

# Built-up density as exposure proxy
ndbi_norm = img_2023.select("NDBI").add(1).divide(2).clamp(0, 1)

# Green cover as vulnerability proxy (less green = more vulnerable)
ndvi_inv = img_2023.select("NDVI").multiply(-1).add(1).divide(2).clamp(0, 1)

# Composite
risk = (h_elev.multiply(0.40)
    .add(ndbi_norm.multiply(0.35))
    .add(ndvi_inv.multiply(0.25)))

# Visualize
Map = geemap.Map(center=[CITY["lat"], CITY["lon"]], zoom=11)
Map.addLayer(risk, {"min": 0, "max": 1, "palette": ["green", "yellow", "red"]}, "Risk")
Map

# Export risk raster to Google Drive (then download to output/)
task = ee.batch.Export.image.toDrive(
    image=risk,
    description=f"risk_composite_{CITY['name'].lower()}",
    folder="urban_analytics",
    region=aoi,
    scale=30,
    maxPixels=1e9
)
task.start()
print(f"Export started. Check Google Drive > urban_analytics/")

# Also export the change detection
change = classified_2023.subtract(classified_2015).rename("change")
task2 = ee.batch.Export.image.toDrive(
    image=change, description=f"land_change_{CITY['name'].lower()}",
    folder="urban_analytics", region=aoi, scale=30, maxPixels=1e9
)
task2.start()
print("Change detection export started")

# scripts/dashboard.py
import json
import streamlit as st
import pandas as pd
import geopandas as gpd
import pydeck as pdk
import h3
from sqlalchemy import create_engine
from pathlib import Path

# ─── Config ───
CITY = json.loads(Path("data/city_config.json").read_text())
DB_URL = f"postgresql://postgres@localhost/urban_{CITY['name'].lower()}"
engine = create_engine(DB_URL)

st.set_page_config(page_title=f"{CITY['name']} Urban Dashboard", layout="wide")
st.title(f"🏙️ {CITY['name']} Urban Analytics Dashboard")

# ─── Data Loading (cached) ───
@st.cache_data
def load_h3_data():
    df = gpd.read_postgis(
        "SELECT * FROM h3_building_summary",
        engine, geom_col="geom"
    )
    # Convert H3 geometry to lat/lon for pydeck
    df["lat"] = df.geometry.centroid.y
    df["lon"] = df.geometry.centroid.x
    return df

h3_data = load_h3_data()
st.sidebar.metric("Total Hexagons", len(h3_data))
st.sidebar.metric("Total Buildings", f"{h3_data['building_count'].sum():,}")

# ─── H3 Building Density Map ───
st.subheader("Building Density by H3 Cell")

metric = st.selectbox("Color by", ["building_count", "total_footprint", "avg_footprint"])

layer = pdk.Layer(
    "H3HexagonLayer",
    data=h3_data,
    get_hexagon="h3_cell",
    get_fill_color=f"[255, (1 - {metric} / {h3_data[metric].quantile(0.95)}) * 255, 0, 160]",
    get_elevation=metric,
    elevation_scale=2,
    extruded=True,
    pickable=True,
)

view = pdk.ViewState(
    latitude=CITY["lat"], longitude=CITY["lon"],
    zoom=11, pitch=45
)

st.pydeck_chart(pdk.Deck(layers=[layer], initial_view_state=view,
    tooltip={"text": f"H3: {{h3_cell}}\\n{metric}: {{{metric}}}"}))

# ─── HERE Traffic (optional — needs API key) ───
import requests

HERE_KEY = st.sidebar.text_input("HERE API Key", type="password")

if HERE_KEY:
    bbox_str = f"{CITY['bbox'][1]},{CITY['bbox'][0]},{CITY['bbox'][3]},{CITY['bbox'][2]}"
    url = f"https://data.traffic.hereapi.com/v7/flow?in=bbox:{bbox_str}&apiKey={HERE_KEY}"

    @st.cache_data(ttl=300)
    def fetch_traffic():
        resp = requests.get(url)
        if resp.status_code == 200:
            results = resp.json().get("results", [])
            rows = []
            for r in results:
                loc = r.get("location", {})
                flow = r.get("currentFlow", {})
                if "shape" in loc and "speed" in flow:
                    coords = loc["shape"]["links"][0]["points"]
                    mid = coords[len(coords)//2]
                    rows.append({
                        "lat": mid["lat"], "lon": mid["lng"],
                        "speed": flow["speed"],
                        "jam_factor": flow.get("jamFactor", 0),
                    })
            return pd.DataFrame(rows)
        return pd.DataFrame()

    traffic = fetch_traffic()
    if not traffic.empty:
        st.subheader(f"Live Traffic — {len(traffic)} segments")
        traffic["h3_cell"] = [h3.latlng_to_cell(r.lat, r.lon, 9) for _, r in traffic.iterrows()]
        st.dataframe(traffic.head(10))

cd urban_analytics
streamlit run scripts/dashboard.py