Add revenue impact proxy and pricing integration to dashboard

app.py

@@ -8,13 +8,29 @@ st.set_page_config(page_title="Getaround — Late Return Buffer Analysis", layou
 
 APP_DIR = Path(__file__).resolve().parent
 DATA_PATH = APP_DIR / "get_around_delay_analysis.csv"
+PRICING_PATH = APP_DIR / "get_around_pricing_project.csv"
+
 
 @st.cache_data
 def load_data():
     df = pd.read_csv(DATA_PATH)
+    # на всякий случай чистим индексные столбцы
+    df = df.loc[:, ~df.columns.str.match(r"^Unnamed")]
     return df
 
+
+@st.cache_data
+def load_pricing():
+    dfp = pd.read_csv(PRICING_PATH)
+    dfp = dfp.loc[:, ~dfp.columns.str.match(r"^Unnamed")]
+    return dfp
+
+
 df = load_data()
+pricing_df = load_pricing()
+
+MEDIAN_PRICE = float(pricing_df["rental_price_per_day"].median())
+MEAN_PRICE = float(pricing_df["rental_price_per_day"].mean())
 
 st.title("Getaround — Late Return Buffer (2017 analysis)")
 
@@ -25,11 +41,16 @@ A buffer reduces friction caused by late checkouts, but may reduce marketplace u
 """
 )
 
-
 with st.sidebar:
     st.header("Policy settings")
     scope = st.selectbox("Scope", ["All cars", "Connect only"], index=0)
-    threshold = st.slider("Minimum buffer (minutes)", min_value=0, max_value=360, value=120, step=5)
+    threshold = st.slider(
+        "Minimum buffer (minutes)",
+        min_value=0,
+        max_value=720,   # data has gaps up to ~720 minutes
+        value=120,
+        step=5
+    )
 
     st.header("Visualization")
     clip_mode = st.selectbox("Delay clipping", ["None", "Percentiles (1–99)", "Fixed range (±24h)"], index=1)
@@ -46,13 +67,12 @@ if not include_canceled:
 if scope == "Connect only":
     work = work[work["checkin_type"] == "connect"].copy()
 
-
-# Build previous delay mapping to estimate impact on next driver
+# --- Build previous delay mapping to estimate impact on next driver ---
 ended = df[df["state"] == "ended"][["rental_id", "delay_at_checkout_in_minutes"]].copy()
 ended["delay_at_checkout_in_minutes"] = ended["delay_at_checkout_in_minutes"].fillna(0)
 
-prev_delay_map = dict(zip(ended["rental_id"].astype(float), ended["delay_at_checkout_in_minutes"]))
 # previous_ended_rental_id is float due to NaNs in source
+prev_delay_map = dict(zip(ended["rental_id"].astype(float), ended["delay_at_checkout_in_minutes"]))
 work["previous_delay_min"] = work["previous_ended_rental_id"].map(prev_delay_map).fillna(0)
 
 work["gap_min"] = work["time_delta_with_previous_rental_in_minutes"].fillna(np.inf)
@@ -67,19 +87,46 @@ work["problematic"] = work["impact_on_next_driver_min"] > 0
 # Solved cases under policy: problematic cases among affected rentals
 work["solved_by_policy"] = work["problematic"] & work["affected_by_policy"]
 
+# --- Revenue impact proxy (time-based) ---
+# We only know "slack time" between consecutive rentals (gap_min) when previous rental exists.
+eligible = np.isfinite(work["gap_min"])
+gap_pos = work["gap_min"].where(eligible, 0).clip(lower=0)
+
+# How much of the slack gets blocked by applying a buffer threshold
+work["blocked_minutes"] = np.where(eligible, np.maximum(0, threshold - gap_pos), 0)
+
+total_gap_minutes = float(gap_pos.sum())
+total_blocked_minutes = float(work["blocked_minutes"].sum())
+
+revenue_at_risk_pct = (100 * total_blocked_minutes / total_gap_minutes) if total_gap_minutes > 0 else 0.0
+blocked_days = total_blocked_minutes / 1440
+estimated_revenue_loss_eur = blocked_days * MEDIAN_PRICE
+
+# --- Summary metrics ---
 total_rentals = len(work)
 affected = int(work["affected_by_policy"].sum())
 problematic = int(work["problematic"].sum())
 solved = int(work["solved_by_policy"].sum())
 
-pct = lambda a, b: (100*a/b) if b else 0
+pct = lambda a, b: (100 * a / b) if b else 0
 
-col1, col2, col3, col4 = st.columns(4)
+col1, col2, col3, col4, col5 = st.columns(5)
 col1.metric("Ended rentals (in scope)", f"{total_rentals:,}")
-col2.metric("Rentals affected by policy", f"{affected:,}", f"{pct(affected,total_rentals):.1f}%")
-col3.metric("Problematic cases (wait > 0)", f"{problematic:,}", f"{pct(problematic,total_rentals):.1f}%")
-col4.metric("Problematic cases solved", f"{solved:,}", f"{pct(solved,problematic):.1f}% of problematic" if problematic else "0%")
+col2.metric("Rentals affected by policy", f"{affected:,}", f"{pct(affected, total_rentals):.1f}%")
+col3.metric("Problematic cases (wait > 0)", f"{problematic:,}", f"{pct(problematic, total_rentals):.1f}%")
+col4.metric(
+    "Problematic cases solved",
+    f"{solved:,}",
+    f"{pct(solved, problematic):.1f}% of problematic" if problematic else "0%"
+)
+col5.metric("Revenue at risk (proxy)", f"{revenue_at_risk_pct:.1f}%", f"≈ €{estimated_revenue_loss_eur:,.0f} est.")
+
+st.caption(
+    f"€ estimate uses median daily price from pricing dataset (median = €{MEDIAN_PRICE:.0f}, mean = €{MEAN_PRICE:.0f}). "
+    "Revenue-at-risk proxy is based on blocked inter-rental slack (time between consecutive rentals)."
+)
 
+# --- Delay distribution ---
 st.subheader("Distribution of checkout delays (minutes)")
 
 delays = df["delay_at_checkout_in_minutes"].dropna().astype(float)
@@ -103,69 +150,107 @@ chart = (
     .mark_bar()
     .encode(
         x=alt.X("delay_min:Q", bin=alt.Bin(maxbins=bins), title="Checkout delay (min)"),
-        y=alt.Y("count():Q", title="Count")
+        y=alt.Y("count():Q", title="Count"),
     )
     .properties(height=280)
 )
 
 st.altair_chart(chart, use_container_width=True)
 
-
-
-
 st.divider()
 
+# --- Threshold sensitivity curve ---
 st.subheader("Threshold sensitivity (quick curve)")
 
-thresholds = np.arange(0, 361, 15)
+thresholds = np.arange(0, 721, 15)
 
 def compute_curve(th):
-    affected = (work["gap_min"] < th)
-    solved = work["problematic"] & affected
-    return affected.mean(), solved.sum()
+    affected_mask = (work["gap_min"] < th)
+    solved_mask = work["problematic"] & affected_mask
+
+    eligible = np.isfinite(work["gap_min"])
+    gap_pos = work["gap_min"].where(eligible, 0).clip(lower=0)
+    blocked = np.where(eligible, np.maximum(0, th - gap_pos), 0)
+
+    total_gap = float(gap_pos.sum())
+    total_blocked = float(blocked.sum())
+    revenue_risk_share = (total_blocked / total_gap) if total_gap > 0 else 0.0
+
+    return float(affected_mask.mean()), int(solved_mask.sum()), float(revenue_risk_share)
 
 affected_share = []
 solved_counts = []
+revenue_risk_share = []
+
 for th in thresholds:
-    a, s = compute_curve(th)
+    a, s, r = compute_curve(th)
     affected_share.append(a)
     solved_counts.append(s)
+    revenue_risk_share.append(r)
 
 curve_df = pd.DataFrame({
     "threshold_min": thresholds,
     "affected_share": affected_share,
-    "solved_problematic_cases": solved_counts
+    "solved_problematic_cases": solved_counts,
+    "revenue_at_risk_share": revenue_risk_share,
 })
+curve_df["revenue_at_risk_pct"] = 100 * curve_df["revenue_at_risk_share"]
 
-c1, c2 = st.columns([1,1])
+c1, c2, c3 = st.columns([1, 1, 1])
 with c1:
     st.caption("Share of rentals affected (hidden from search)")
     st.line_chart(curve_df.set_index("threshold_min")["affected_share"], height=260)
 with c2:
     st.caption("Number of problematic cases solved")
     st.line_chart(curve_df.set_index("threshold_min")["solved_problematic_cases"], height=260)
+with c3:
+    st.caption("Revenue at risk (proxy) — share of blocked slack time")
+    st.line_chart(curve_df.set_index("threshold_min")["revenue_at_risk_share"], height=260)
+
+st.subheader("Elbow view: solved friction vs revenue-at-risk")
+scatter = (
+    alt.Chart(curve_df)
+    .mark_circle(size=70)
+    .encode(
+        x=alt.X("revenue_at_risk_pct:Q", title="Revenue at risk (proxy, %)"),
+        y=alt.Y("solved_problematic_cases:Q", title="Problematic cases solved"),
+        tooltip=[
+            alt.Tooltip("threshold_min:Q", title="Threshold (min)"),
+            alt.Tooltip("revenue_at_risk_pct:Q", title="Revenue at risk (%)", format=".2f"),
+            alt.Tooltip("solved_problematic_cases:Q", title="Solved cases"),
+            alt.Tooltip("affected_share:Q", title="Affected share", format=".3f"),
+        ],
+    )
+    .properties(height=320)
+)
+st.altair_chart(scatter, use_container_width=True)
 
 st.divider()
 
+# --- Examples ---
 st.subheader("Examples of high-friction situations")
 examples = work[work["problematic"]].copy()
 examples["estimated_wait_min"] = examples["impact_on_next_driver_min"].round(0).astype(int)
 examples = examples.sort_values("estimated_wait_min", ascending=False).head(20)
 
 st.dataframe(
-    examples[[
-        "rental_id",
-        "car_id",
-        "checkin_type",
-        "gap_min",
-        "previous_delay_min",
-        "estimated_wait_min",
-        "affected_by_policy"
-    ]],
-    use_container_width=True
+    examples[
+        [
+            "rental_id",
+            "car_id",
+            "checkin_type",
+            "gap_min",
+            "previous_delay_min",
+            "estimated_wait_min",
+            "affected_by_policy",
+            "blocked_minutes",
+        ]
+    ],
+    use_container_width=True,
 )
 
 st.caption(
     "Interpretation: estimated_wait_min approximates how long the next driver may have to wait "
-    "if the previous driver returns the car late and the planned gap is small."
+    "if the previous driver returns the car late and the planned gap is small. "
+    "blocked_minutes is the additional slack time removed by the buffer threshold."
 )