Mise à jour

README.md

@@ -0,0 +1,12 @@
+---
+title: Getaround Delay Analysis
+emoji: 🚗
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+app_file: app.py
+pinned: false
+---
+
+# Getaround - Analyse des retards
+Projet d'analyse opérationnelle pour optimiser le temps de repos (buffer) entre les locations.

app.py

@@ -4,253 +4,116 @@ import numpy as np
 from pathlib import Path
 import altair as alt
 
-st.set_page_config(page_title="Getaround — Late Return Buffer Analysis", layout="wide")
+st.set_page_config(page_title="Getaround — Analyse du Seuil de Buffer", layout="wide")
 
 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)")
+st.title("Getaround — Analyse opérationnelle du Buffer")
 
 st.markdown(
     """
-This dashboard explores the trade-off of introducing a **minimum buffer time** between two consecutive rentals.
-A buffer reduces friction caused by late checkouts, but may reduce marketplace utilization.
+Ce tableau de bord explore le compromis lié à l'introduction d'un **temps de repos minimum (buffer)** entre deux locations.
 """
 )
 
+# --- SIDEBAR (Configuration sans les réglages de bins) ---
 with st.sidebar:
-    st.header("Policy settings")
-    scope = st.selectbox("Scope", ["All cars", "Connect only"], index=0)
+    st.header("Paramètres")
+    # Добавлен выбор обоих типов
+    scope = st.selectbox("Périmètre (Scope)", ["All", "Connect", "Mobile"])
+    
     threshold = st.slider(
-        "Minimum buffer (minutes)",
+        "Seuil de Buffer (Minutes)",
         min_value=0,
-        max_value=720,   # data has gaps up to ~720 minutes
+        max_value=720,
         value=120,
-        step=5
+        step=10
     )
 
-    st.header("Visualization")
-    clip_mode = st.selectbox("Delay clipping", ["None", "Percentiles (1–99)", "Fixed range (±24h)"], index=1)
-    bins = st.slider("Histogram bins", 20, 200, 60, step=10)
-
-    st.header("Filters")
-    include_canceled = st.checkbox("Include canceled rentals", value=False)
-
+# --- DATA PROCESSING ---
 work = df.copy()
+if scope != "All":
+    work = work[work["checkin_type"] == scope.lower()]
 
-if not include_canceled:
-    work = work[work["state"] == "ended"].copy()
-
-if scope == "Connect only":
-    work = work[work["checkin_type"] == "connect"].copy()
-
-# --- 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)
-
-# 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)
-work["impact_on_next_driver_min"] = np.maximum(0, work["previous_delay_min"] - work["gap_min"])
-
-# Policy effect: rentals that would be hidden because gap < threshold
-work["affected_by_policy"] = work["gap_min"] < threshold
-
-# Problematic cases: when next driver would be impacted (wait time > 0)
-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
-
-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%"
-)
-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)
-
-if clip_mode == "Percentiles (1–99)":
-    lo, hi = delays.quantile([0.01, 0.99])
-    delays_plot = delays.clip(lo, hi)
-    st.caption(f"Clipped to 1st–99th percentiles: [{lo:.0f}, {hi:.0f}] min")
-elif clip_mode == "Fixed range (±24h)":
-    lo, hi = -1440, 1440
-    delays_plot = delays.clip(lo, hi)
-    st.caption("Clipped to ±24 hours: [-1440, 1440] min")
-else:
-    delays_plot = delays
-    st.caption("No clipping (raw values)")
-
-hist_df = pd.DataFrame({"delay_min": delays_plot})
+# --- VISUALISATION DES DISTRIBUTIONS (LES BINS SONT FIXES MAINTENANT) ---
+st.subheader("Distribution des retards et des écarts")
+c1, c2 = st.columns(2)
 
-chart = (
-    alt.Chart(hist_df)
-    .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"),
-    )
-    .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, 721, 15)
-
-def compute_curve(th):
-    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, 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,
-    "revenue_at_risk_share": revenue_risk_share,
-})
-curve_df["revenue_at_risk_pct"] = 100 * curve_df["revenue_at_risk_share"]
-
-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)
+    # График задержек (Checkout delays)
+    delay_hist = alt.Chart(work[work['delay_at_checkout_min'] > 0]).mark_bar(color="#94a3b8").encode(
+        alt.X("delay_at_checkout_min:Q", bin=alt.Bin(maxbins=50), title="Retard au check-out (Minutes)"),
+        alt.Y('count()', title="Nombre de locations"),
+    ).properties(height=300)
+    st.altair_chart(delay_hist, use_container_width=True)
 
+with c2:
+    # График интервалов (Gaps between rentals)
+    gap_hist = alt.Chart(work[work['time_delta_with_next_rental_min'].notnull()]).mark_bar(color="#cbd5e1").encode(
+        alt.X("time_delta_with_next_rental_min:Q", bin=alt.Bin(maxbins=50), title="Écart entre locations (Minutes)"),
+        alt.Y('count()', title="Nombre de locations"),
+    ).properties(height=300)
+    st.altair_chart(gap_hist, use_container_width=True)
+
+# --- LOGIQUE DE SIMULATION ---
+thresholds = np.arange(0, 730, 10)
+sim_results = []
+problematic_all = work[(work["delay_at_checkout_min"] > work["time_delta_with_next_rental_min"]) & (work["time_delta_with_next_rental_min"].notnull())]
+
+for t in thresholds:
+    num_affected = len(work[work["time_delta_with_next_rental_min"] < t])
+    solved = problematic_all[problematic_all["time_delta_with_next_rental_min"] < t]
+    
+    sim_results.append({
+        "threshold_min": t,
+        "affected_count": num_affected,
+        "solved_pct": (len(solved) / len(problematic_all) * 100) if len(problematic_all) > 0 else 0,
+        "revenue_at_risk_pct": (num_affected / len(work) * 100) if len(work) > 0 else 0
+    })
+sim_df = pd.DataFrame(sim_results)
+
+# --- GRAPHIQUES D'IMPACT ---
 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",
-            "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. "
-    "blocked_minutes is the additional slack time removed by the buffer threshold."
-)
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Efficacité : Problèmes résolus")
+    line_solved = alt.Chart(sim_df).mark_line(color="#2563eb", strokeWidth=3).encode(
+        x=alt.X("threshold_min:Q", title="Seuil de Buffer (Minutes)"),
+        y=alt.Y("solved_pct:Q", title="Cas résolus (%)"),
+    ).properties(height=350)
+    st.altair_chart(line_solved, use_container_width=True)
+
+with col2:
+    st.subheader("Impact : Revenu à risque")
+    line_impact = alt.Chart(sim_df).mark_line(color="#e11d48", strokeWidth=3).encode(
+        x=alt.X("threshold_min:Q", title="Seuil de Buffer (Minutes)"),
+        y=alt.Y("revenue_at_risk_pct:Q", title="Locations affectées (%)"),
+    ).properties(height=350)
+    st.altair_chart(line_impact, use_container_width=True)
+
+# --- METRIQUES FINALES ---
+st.divider()
+res_at_t = sim_df[sim_df["threshold_min"] == threshold].iloc[0]
+m1, m2, m3 = st.columns(3)
+m1.metric("Problèmes résolus", f"{res_at_t['solved_pct']:.1f}%")
+m2.metric("Locations affectées", f"{res_at_t['revenue_at_risk_pct']:.1f}%")
+m3.metric("Perte CA estimée", f"~{res_at_t['affected_count'] * MEDIAN_PRICE:,.0f} €")