Upload folder using huggingface_hub (part 2)

src/gradio_app.py

@@ -229,10 +229,23 @@ def schematic_click_targets(_nodes, _edges, basin_id: int, n_points: int = N_CLI
 
 
 def load_reach_graph(data_root: Path, basin_id: int):
+    """
+    Loads the enriched reach graph node table when available (real
+    static features: IDPR, catchment area, landcover, geology, cavité
+    proximity — see node_features.py) and falls back to the bare
+    structural table (station_code/coords/is_gauged/etc. only) if the
+    enrichment step hasn't been run yet. Previously always loaded the
+    bare table even when the enriched one existed right alongside it --
+    meaning no real feature values ever reached this app regardless of
+    whether they'd actually been computed.
+    """
     file_key = BASIN_FILE_NAMES[basin_id]
     graph_dir = data_root / "reach_graph"
-    nodes_path = graph_dir / f"{file_key}_nodes.csv"
+    enriched_path = graph_dir / f"{file_key}_nodes_enriched.csv"
+    bare_path = graph_dir / f"{file_key}_nodes.csv"
     edges_path = graph_dir / f"{file_key}_edges.csv"
+
+    nodes_path = enriched_path if enriched_path.exists() else bare_path
     if not nodes_path.exists() or not edges_path.exists():
         return None
     return pd.read_csv(nodes_path), pd.read_csv(edges_path)
@@ -260,7 +273,43 @@ def build_figure_reach_graph(nodes_df: pd.DataFrame, edges_df: pd.DataFrame, bas
         confluence_codes = edges_df["target"].value_counts()
         confluence_codes = confluence_codes[confluence_codes >= 2].index
         confluences = nodes_df[nodes_df["station_code"].isin(confluence_codes)]
-    gauges = nodes_df[nodes_df["is_gauged"]]
+    gauges = nodes_df[nodes_df["is_gauged"]].copy()
+
+    # Reconstruct single landcover/geology class labels from one-hot columns
+    # (add_landcover_features/add_geology_features produce landcover_<Class>/
+    # geology_<Class> boolean columns, not one string column) -- only if
+    # those columns actually exist in this deployment's enriched table.
+    def _onehot_label(df: pd.DataFrame, prefix: str) -> pd.Series:
+        cols = [c for c in df.columns if c.startswith(prefix)]
+        if not cols:
+            return pd.Series(["—"] * len(df), index=df.index)
+        return df[cols].idxmax(axis=1).str[len(prefix):].where(df[cols].any(axis=1), "—")
+
+    gauges["_landcover_label"] = _onehot_label(gauges, "landcover_")
+    gauges["_geology_label"] = _onehot_label(gauges, "geology_")
+
+    # Build hover columns from whichever real static features are actually
+    # present, rather than a fixed set -- not every deployment will have
+    # every enrichment source run.
+    hover_fields = [("Elevation", gauges["elevation_m"].round(1).astype(str) + " m")]
+    if "idpr_value" in gauges.columns:
+        hover_fields.append(("IDPR", gauges["idpr_value"].astype(str)))
+    if "catchment_area_km2" in gauges.columns:
+        hover_fields.append(("Catchment area", gauges["catchment_area_km2"].round(1).astype(str) + " km²"))
+    if any(c.startswith("landcover_") for c in gauges.columns):
+        hover_fields.append(("Landcover", gauges["_landcover_label"]))
+    if any(c.startswith("geology_") for c in gauges.columns):
+        hover_fields.append(("Geology", gauges["_geology_label"]))
+    if "ndvi_p50" in gauges.columns:
+        hover_fields.append(("NDVI (median)", gauges["ndvi_p50"].round(1).astype(str)))
+    if "distance_to_nearest_cavity_km" in gauges.columns:
+        hover_fields.append(("Nearest cavity", gauges["distance_to_nearest_cavity_km"].round(1).astype(str) + " km"))
+
+    customdata = pd.concat([gauges["station_code"]] + [f[1] for f in hover_fields], axis=1).values
+    hover_lines = ["<b>%{customdata[0]}</b>"] + [
+        f"{label}: %{{customdata[{i+1}]}}" for i, (label, _) in enumerate(hover_fields)
+    ]
+    hovertemplate = "<br>".join(hover_lines) + "<extra></extra>"
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -279,8 +328,8 @@ def build_figure_reach_graph(nodes_df: pd.DataFrame, edges_df: pd.DataFrame, bas
         marker=dict(symbol="circle", size=11, color=gauges["elevation_m"], colorscale="earth",
                     line=dict(width=1, color="black"), showscale=True, colorbar=dict(title="Elev (m)", thickness=12)),
         text=gauges["station_code"], textposition="top right", textfont=dict(size=8),
-        customdata=gauges["station_code"],
-        hovertemplate="%{customdata}<extra></extra>",
+        customdata=customdata,
+        hovertemplate=hovertemplate,
         name=f"gauges (n={len(gauges)})", showlegend=True,
     ))
     fig.update_layout(
@@ -388,7 +437,13 @@ with gr.Blocks(title="River Network Explorer") as demo:
             metric_gw = gr.Textbox(label="Est. groundwater level")
         coords_md = gr.Markdown("Coordinates: —")
         
-        gr.Markdown("### Station Time Series Plots")
+        gr.Markdown("### Station details")
+        timeseries_station_dropdown = gr.Dropdown(
+            choices=[], label="Jump directly to a station (faster than sliding to find it)", interactive=True,
+        )
+        station_details = gr.Dataframe(
+            headers=["Feature", "Value"], label="Static features", interactive=False, wrap=True,
+        )
         with gr.Tabs():
             with gr.TabItem("Water Level"):
                 plot_waterlevel = gr.Plot()
@@ -429,7 +484,9 @@ with gr.Blocks(title="River Network Explorer") as demo:
                 coords_md: "Coordinates: —",
                 plot_waterlevel: default_fig,
                 plot_discharge: default_fig,
-                plot_rating: default_fig
+                plot_rating: default_fig,
+                station_details: pd.DataFrame(columns=["Feature", "Value"]),
+                timeseries_station_dropdown: gr.update(choices=[], value=None),
             }
 
         if view_val == "Network validation":
@@ -454,8 +511,11 @@ with gr.Blocks(title="River Network Explorer") as demo:
                 m_confl: n_confluences,
                 m_gauges: n_gauged,
                 val_plot_output: fig,
-                val_caption: "Confirm visually: confluences (◆) should sit where a tributary joins.",
-                val_snap_caption: ""
+                val_caption: "Confirm visually: confluences (◆) should sit where a tributary joins. "
+                              "Hover a gauge to see its static features, or switch to Explore for the full detail table.",
+                val_snap_caption: "",
+                station_details: pd.DataFrame(columns=["Feature", "Value"]),
+                timeseries_station_dropdown: gr.update(choices=[], value=None),
             }
         else:
             centerlines = get_centerlines(DATA_ROOT, nodes)
@@ -476,9 +536,119 @@ with gr.Blocks(title="River Network Explorer") as demo:
                 validation_group: gr.update(visible=False),
                 status_md: status_text,
                 plot_output: fig,
-                slider: 43
+                slider: 43,
+                station_details: pd.DataFrame(columns=["Feature", "Value"]),
+                timeseries_station_dropdown: gr.update(
+                    choices=sorted(nodes[nodes["basin_id"] == basin_id]["station_code"].tolist()),
+                    value=None,
+                ),
             }
 
+    def find_nearest_gauge_with_data(station_code, basin_id, hydro_df):
+        """
+        For a station with zero real discharge/water-level rows, find
+        the nearest OTHER real gauge that does have data -- for display-
+        only interpolation. Returns (nearest_code, distance_km) or
+        (None, None) if nothing in this basin has any real data at all.
+
+        Distance uses plain haversine on real station coordinates, same
+        approach used throughout this project's spatial joins -- no new
+        method invented for this one case.
+        """
+        import math
+
+        stations_with_data = set(hydro_df["station_code"].unique())
+        try:
+            nodes, _ = get_graph(DATA_ROOT)
+        except Exception:
+            return None, None
+        basin_nodes = nodes[nodes["basin_id"] == basin_id]
+        target_row = basin_nodes[basin_nodes["station_code"] == station_code]
+        candidates = basin_nodes[
+            basin_nodes["station_code"].isin(stations_with_data) & (basin_nodes["station_code"] != station_code)
+        ]
+        if target_row.empty or candidates.empty:
+            return None, None
+        tlat, tlon = target_row.iloc[0]["latitude"], target_row.iloc[0]["longitude"]
+
+        def haversine_km(lat1, lon1, lat2, lon2):
+            R = 6371.0
+            lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
+            dlat, dlon = lat2 - lat1, lon2 - lon1
+            a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+            return R * 2 * math.asin(math.sqrt(a))
+
+        dists = candidates.apply(lambda r: haversine_km(tlat, tlon, r["latitude"], r["longitude"]), axis=1)
+        nearest_idx = dists.idxmin()
+        return candidates.loc[nearest_idx, "station_code"], float(dists.loc[nearest_idx])
+
+    def _mark_estimated(fig, real_station_code, distance_km):
+        """
+        Stamps a clear, impossible-to-miss "not a real measurement"
+        label onto a display-only interpolated figure -- same principle
+        as this project's existing "Est. groundwater level" labeling
+        (see the metric_gw textbox above): an estimated value must never
+        look identical to a real one, anywhere in this app.
+        """
+        try:
+            fig.suptitle(
+                f"⚠ ESTIMATED — no real data at this station. Showing nearest real "
+                f"gauge {real_station_code} ({distance_km:.1f} km away) for display only.",
+                fontsize=9, color="#B23B00", y=1.02,
+            )
+        except Exception:
+            pass
+        return fig
+
+    def get_station_timeseries_plots(station_code, basin_id=None):
+        """
+        Shared by both the slider (nearest station to the clicked
+        position) and the direct station dropdown -- same plots, two
+        ways to choose which station. Avoids duplicating the hydro-
+        loading/plotting logic in two places that could drift apart.
+
+        DISPLAY-ONLY INTERPOLATION: if `station_code` has zero real
+        discharge/water-level rows, falls back to the nearest real
+        gauge's actual time series for display, clearly stamped as
+        estimated (see _mark_estimated). This never touches the real
+        training data pipeline (node_features.py / dynamic_features.py) --
+        it exists only inside this app, at display time, on a value that
+        is discarded immediately after rendering.
+        """
+        default_fig = go.Figure()
+        hydro = get_hydrometric(DATA_ROOT)
+        fig_wl, fig_disc, fig_rc = default_fig, default_fig, default_fig
+        if hydro is not None and station_code:
+            loader, hydro_df = hydro
+            station_df = hydro_df[hydro_df["station_code"] == station_code]
+            plot_code = station_code
+            estimated_from, estimated_km = None, None
+
+            if station_df.empty and basin_id is not None:
+                estimated_from, estimated_km = find_nearest_gauge_with_data(station_code, basin_id, hydro_df)
+                if estimated_from is not None:
+                    plot_code = estimated_from
+                    station_df = hydro_df[hydro_df["station_code"] == plot_code]
+
+            if not station_df.empty:
+                try:
+                    fig_wl = loader.plot_waterlevel(df=station_df, stations=[plot_code]).figure
+                except Exception:
+                    pass
+                try:
+                    fig_disc = loader.plot_discharge(df=station_df, stations=[plot_code]).figure
+                except Exception:
+                    pass
+                try:
+                    fig_rc = loader.plot_rating_curve(plot_code, df=station_df).figure
+                except Exception:
+                    pass
+                if estimated_from is not None:
+                    fig_wl = _mark_estimated(fig_wl, estimated_from, estimated_km)
+                    fig_disc = _mark_estimated(fig_disc, estimated_from, estimated_km)
+                    fig_rc = _mark_estimated(fig_rc, estimated_from, estimated_km)
+        return fig_wl, fig_disc, fig_rc
+
     def compute_position(basin_id, percent):
         fraction = percent / 100.0
         basin_name = BASIN_NAMES[basin_id]
@@ -491,7 +661,8 @@ with gr.Blocks(title="River Network Explorer") as demo:
             return {
                 plot_output: default_fig, metric_elev: 0.0, metric_dist: "", 
                 metric_gw: "No data", coords_md: "Coordinates: —", 
-                plot_waterlevel: default_fig, plot_discharge: default_fig, plot_rating: default_fig
+                plot_waterlevel: default_fig, plot_discharge: default_fig, plot_rating: default_fig,
+                station_details: pd.DataFrame(columns=["Feature", "Value"]),
             }
 
         centerlines = get_centerlines(DATA_ROOT, nodes)
@@ -529,24 +700,8 @@ with gr.Blocks(title="River Network Explorer") as demo:
 
         gw_text = f"{gwl:.1f} m" if gwl is not None else (f"No well (nearest {nearest_well_km:.0f}km away)" if nearest_well_km else "No data")
 
-        hydro = get_hydrometric(DATA_ROOT)
-        fig_wl, fig_disc, fig_rc = default_fig, default_fig, default_fig
-        if hydro is not None:
-            loader, hydro_df = hydro
-            station_df = hydro_df[hydro_df["station_code"] == nearest_station]
-            if not station_df.empty:
-                try:
-                    fig_wl = loader.plot_waterlevel(df=station_df, stations=[nearest_station]).figure
-                except Exception:
-                    pass
-                try:
-                    fig_disc = loader.plot_discharge(df=station_df, stations=[nearest_station]).figure
-                except Exception:
-                    pass
-                try:
-                    fig_rc = loader.plot_rating_curve(nearest_station, df=station_df).figure
-                except Exception:
-                    pass
+        fig_wl, fig_disc, fig_rc = get_station_timeseries_plots(nearest_station, basin_id)
+        details = show_station_details(basin_id, nearest_station)
 
         return {
             plot_output: fig2,
@@ -556,20 +711,99 @@ with gr.Blocks(title="River Network Explorer") as demo:
             coords_md: f"Coordinates: {lat:.4f}, {lon:.4f}",
             plot_waterlevel: fig_wl,
             plot_discharge: fig_disc,
-            plot_rating: fig_rc
+            plot_rating: fig_rc,
+            station_details: details,
         }
 
     all_outputs = [
         explore_group, validation_group, status_md, plot_output, slider,
         metric_elev, metric_dist, metric_gw, coords_md, 
         plot_waterlevel, plot_discharge, plot_rating,
-        m_nodes, m_edges, m_confl, m_gauges, val_caption, val_plot_output, val_snap_caption
+        m_nodes, m_edges, m_confl, m_gauges, val_caption, val_plot_output, val_snap_caption,
+        station_details, timeseries_station_dropdown,
     ]
 
+    # Human-readable labels for the raw column names, and a deliberate
+    # allowlist -- e.g. idpr_nearest_point_distance is excluded on purpose:
+    # it's hardcoded to 0.0 whenever a table is an exact ID match against
+    # IDPR's own station list (see node_features.py's add_idpr_features),
+    # which is every real-gauges-only table this app ever builds. Real
+    # value, not a bug, but a constant 0 conveys nothing to a client.
+    FEATURE_LABELS = {
+        "elevation_m": "Elevation (m)",
+        "idpr_value": "IDPR (infiltration/runoff index)",
+        "catchment_area_km2": "Catchment area (km²)",
+        "cumulative_catchment_area_km2": "Catchment area, BD TOPO cumulative (km²)",
+        "distance_to_nearest_cavity_km": "Distance to nearest known cavity (km)",
+        "n_cavities_within_20km": "Cavities within 20 km",
+        "avg_groundwater_level_m": "Groundwater level (m)",
+        "avg_groundwater_depth_m": "Groundwater depth (m)",
+        "n_nearby_wells": "Nearby groundwater wells",
+        "ndvi_p10": "NDVI (10th percentile)",
+        "ndvi_p50": "NDVI (median)",
+        "ndvi_p90": "NDVI (90th percentile)",
+    }
+
+    def show_station_details(basin_id, station_code):
+        if not station_code:
+            return pd.DataFrame(columns=["Feature", "Value"])
+        reach = load_reach_graph(DATA_ROOT, basin_id)
+        if reach is None:
+            return pd.DataFrame(columns=["Feature", "Value"])
+        reach_nodes, _ = reach
+        row = reach_nodes[reach_nodes["station_code"] == station_code]
+        if row.empty:
+            return pd.DataFrame(columns=["Feature", "Value"])
+        row = row.iloc[0]
+
+        rows = []
+        for col, label in FEATURE_LABELS.items():
+            if col in row.index and pd.notna(row[col]):
+                value = row[col]
+                if isinstance(value, float):
+                    # A column with any NaN gets upcast to float by pandas
+                    # even when every real value is whole (IDPR, well
+                    # counts) -- show "885" not "885.00" when the value
+                    # genuinely has no fractional part.
+                    text = str(int(value)) if value == int(value) else f"{value:.2f}"
+                else:
+                    text = str(value)
+                rows.append([label, text])
+
+        landcover_cols = [c for c in reach_nodes.columns if c.startswith("landcover_")]
+        if landcover_cols:
+            active = [c[len("landcover_"):] for c in landcover_cols if row.get(c) == True]
+            rows.append(["Landcover", active[0] if active else "—"])
+
+        geology_cols = [c for c in reach_nodes.columns if c.startswith("geology_")]
+        if geology_cols:
+            active = [c[len("geology_"):] for c in geology_cols if row.get(c) == True]
+            rows.append(["Geology", active[0] if active else "—"])
+
+        if not rows:
+            rows = [["No enriched static features found", "run scripts/enrich_reach_graph.py"]]
+        return pd.DataFrame(rows, columns=["Feature", "Value"])
+
     view_radio.change(update_view, inputs=[view_radio, basin_radio], outputs=all_outputs)
     basin_radio.change(update_view, inputs=[view_radio, basin_radio], outputs=all_outputs)
 
-    slider_outputs = [plot_output, metric_elev, metric_dist, metric_gw, coords_md, plot_waterlevel, plot_discharge, plot_rating]
+    def jump_to_station(basin_id, station_code):
+        """
+        Single callback for the Explore-page dropdown: both the dynamic
+        time-series plots and the static feature table come from one
+        station selection now, not two separate dropdowns split across
+        two pages.
+        """
+        fig_wl, fig_disc, fig_rc = get_station_timeseries_plots(station_code, basin_id)
+        details = show_station_details(basin_id, station_code)
+        return fig_wl, fig_disc, fig_rc, details
+
+    timeseries_station_dropdown.change(
+        jump_to_station, inputs=[basin_radio, timeseries_station_dropdown],
+        outputs=[plot_waterlevel, plot_discharge, plot_rating, station_details],
+    )
+
+    slider_outputs = [plot_output, metric_elev, metric_dist, metric_gw, coords_md, plot_waterlevel, plot_discharge, plot_rating, station_details]
     slider.change(compute_position, inputs=[basin_radio, slider], outputs=slider_outputs)
 
     demo.load(update_view, inputs=[view_radio, basin_radio], outputs=all_outputs)