Deploy Streamlit dashboard

Dockerfile

@@ -1,20 +1,18 @@
-FROM python:3.13.5-slim
+FROM python:3.10-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Быстрее и чище установка
+ENV PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
 
-COPY requirements.txt ./
-COPY src/ ./src/
+COPY requirements.txt .
+RUN pip install -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+COPY . .
 
-EXPOSE 8501
+# Hugging Face обычно проксирует 7860
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,10 @@
 ---
 title: Getaround Delay Dashboard
-emoji: 🚀
-colorFrom: red
-colorTo: red
+emoji: 😻
+colorFrom: blue
+colorTo: gray
 sdk: docker
-app_port: 8501
-tags:
-- streamlit
 pinned: false
-short_description: Streamlit template space
 ---
 
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,171 @@
+import streamlit as st
+import pandas as pd
+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")
+
+APP_DIR = Path(__file__).resolve().parent
+DATA_PATH = APP_DIR / "get_around_delay_analysis.csv"
+
+@st.cache_data
+def load_data():
+    df = pd.read_csv(DATA_PATH)
+    return df
+
+df = load_data()
+
+st.title("Getaround — Late Return Buffer (2017 analysis)")
+
+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.
+"""
+)
+
+
+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)
+
+    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)
+
+work = df.copy()
+
+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)
+
+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
+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"]
+
+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 = st.columns(4)
+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%")
+
+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})
+
+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()
+
+st.subheader("Threshold sensitivity (quick curve)")
+
+thresholds = np.arange(0, 361, 15)
+
+def compute_curve(th):
+    affected = (work["gap_min"] < th)
+    solved = work["problematic"] & affected
+    return affected.mean(), solved.sum()
+
+affected_share = []
+solved_counts = []
+for th in thresholds:
+    a, s = compute_curve(th)
+    affected_share.append(a)
+    solved_counts.append(s)
+
+curve_df = pd.DataFrame({
+    "threshold_min": thresholds,
+    "affected_share": affected_share,
+    "solved_problematic_cases": solved_counts
+})
+
+c1, c2 = st.columns([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)
+
+st.divider()
+
+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
+)
+
+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."
+)

requirements.txt

@@ -1,3 +1,4 @@
-altair
+streamlit
 pandas
-streamlit
+numpy
+altair

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))