grosse modif

app.py

@@ -1,7 +1,7 @@
 import streamlit as st
 import pandas as pd
 import plotly.express as px
-
+import requests
 
 st.set_page_config(page_title="Getaround – Dashboard Analyse", layout="wide")
 
@@ -9,343 +9,393 @@ st.title("🚗 Dashboard Analyse – Getaround")
 st.markdown("""
 Bienvenue sur le dashboard interactif de l’étude Getaround.  
 Nous allons explorer :  
-1. Les retards et annulations  
-2. L’impact d’un buffer entre deux locations  
-3. L’analyse des prix des véhicules  
-4. La conclusion business
-""")
-
-
-df = pd.read_csv("data/get_around_delay_analysis.csv")
-df_pricing = pd.read_csv("data/pricing_clean.csv")
-
-loc_moyenne = df_pricing["rental_price_per_day"].mean()
-
-# EDA SUR LES RETARDS 
-st.header("📊 Analyse des retards et annulations")
-
-
-fig_state = px.pie(df, names="state", title="Répartition par état des locations")
-st.plotly_chart(fig_state, use_container_width=True)
-
-annulation = (df["state"] == "canceled").sum()
-st.metric("Nombre total d'annulations", annulation)
-
-st.markdown("""
-👉 Environ **15 % des transactions sont annulées**.  
-La proportion est légèrement plus élevée via **Connect** que via Mobile.
-""")
-
-
-fig_delay = px.histogram(
-    df.query("-150 <= delay_at_checkout_in_minutes <= 150"),
-    x="delay_at_checkout_in_minutes",
-    nbins=60,
-    title="Distribution des retards (fenêtre -150 à 150 min)"
-)
-st.plotly_chart(fig_delay, use_container_width=True)
-
-st.markdown("""
-👉 La majorité des retards est **courte** :  
-- 50 % ≤ 9 min  
-- 75 % ≤ 67 min  
-Mais certains cas extrêmes dépassent plusieurs jours.
-""")
-
-# ANALYSE DES ANNULATIONS 
-st.header("❌ Analyse des annulations liées aux retards")
-
-mask = df['previous_ended_rental_id'] > 0
-df_nan = df[mask]
-st.metric("Le nombre d'annulations du au retard du véhicule liées à un location précendente est de", (df_nan["state"] == "canceled").sum())
-annulation = (df_nan["state"] == "canceled").sum() 
-st.metric("La location moyenne d'un véhicule par jour est de ", df_pricing['rental_price_per_day'].mean())
-st.metric("La perte du aux annulations s'élève a :", (annulation * loc_moyenne).round(2),"$")
-
-canceled = df[df["state"] == "canceled"][["rental_id", "car_id", "previous_ended_rental_id", "checkin_type","time_delta_with_previous_rental_in_minutes"]]
-
-merged = canceled.merge(
-    df[["rental_id", "car_id", "delay_at_checkout_in_minutes", "checkin_type"]],
-    left_on="previous_ended_rental_id",   
-    right_on="rental_id",                 
-    suffixes=("_canceled", "_previous")
-)
-
-conflict_strict = merged[
-    merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"]
-]
-st.metric("Conflits stricts :", len(conflict_strict))
-st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict["delay_at_checkout_in_minutes"].mean().round(2))
-
-st.markdown("""
-👉 Parmi les **229 annulations liées à une location précédente**,  
-**37** sont dues à un retard allant au delà de l'heure de début de la prochaine location.  
-Ces retards sont très longs (~4h15 en moyenne).
+1. Analyse Retards  
+2. Analyse Pricing 
+3. Prédiction API 
 """)
 
-conflict_minus30 = merged[
-    merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 30
-]
-
-conflict_minus60 = merged[
-    merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 60
-]
-
-conflict_minus90 = merged[
-    merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 90
-]
-
-conflict_minus180 = merged[
-    merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 180
-]
-
-
-results = [
-    {"Buffer": "-30 min", "Conflits": (len(conflict_minus30)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus30["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-60 min", "Conflits": (len(conflict_minus60)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus60["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-90 min", "Conflits": (len(conflict_minus90)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus90["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-180 min", "Conflits": (len(conflict_minus180)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus180["delay_at_checkout_in_minutes"].mean()},
-]
-df_conflicts = pd.DataFrame(results)
-df_conflicts['lost_value'] = df_conflicts["Conflits"]*loc_moyenne
-st.dataframe(df_conflicts)
-
-st.markdown("""Si on regarde 30 miniutes avant le début de la location du véhicule combien ont été annulé (buffer de 30 minutes), on détecte 10 annulations supplémentaires : ces cas correspondent à des locations rendues trop proches de la suivante (<30 min de marge).
-Avec un buffer de 60 minutes, seulement 3 cas en plus → ce sont donc des situations rares mais critiques.
-En élargissant à 90 minutes, on ajoute encore 7 cas.""")
-
-
-fig_type = px.histogram(
-    df.query("-150 <= delay_at_checkout_in_minutes <= 150"),
-    x="delay_at_checkout_in_minutes",
-    color="checkin_type",
-    nbins=int((150 - (-150)) / 10),  
-    opacity=0.2,
-    title="Distribution des retards par type de check-in",
-    labels={"delay_at_checkout_in_minutes": "Retard (minutes)"},
-    range_x=[-150, 150],
-    width=1200, height=600,
-)
-fig_type.update_layout(barmode="overlay")
-fig_type.update_yaxes(title="Nombre de locations")
-#
-st.plotly_chart(fig_type, use_container_width=True)
-
+tab1, tab2, tab3 = st.tabs(["📊 Analyse Retards", "💰 Analyse Pricing", "🤖 Prédiction API"])
 
-st.markdown(""" ANALYSE SUR MOBILE """)
-
-mask = merged["checkin_type_canceled"] == "mobile"
-merged_mob = merged[mask]
-conflict_strict1= merged_mob[
-    merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"]
-]
-st.metric("Conflits stricts :", len(conflict_strict1))
-st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict1["delay_at_checkout_in_minutes"].mean().round(2))
+with tab1:
+    st.header("Analyse des retards")
 
-conflict_1minus30 = merged_mob[
-    merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 30
-]
+    df = pd.read_csv("data/get_around_delay_analysis.csv")
+    df_pricing = pd.read_csv("data/pricing_clean.csv")
 
-conflict_1minus60 = merged_mob[
-    merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 60
-]
+    loc_moyenne = df_pricing["rental_price_per_day"].mean()
 
-conflict_1minus90 = merged_mob[
-    merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 90
-]
+    # EDA SUR LES RETARDS 
+    st.header("📊 Analyse des retards et annulations")
+
+
+    fig_state = px.pie(df, names="state", title="Répartition par état des locations")
+    st.plotly_chart(fig_state, use_container_width=True)
+
+    annulation = (df["state"] == "canceled").sum()
+    st.metric("Nombre total d'annulations", annulation)
+
+    st.markdown("""
+    👉 Environ **15 % des transactions sont annulées**.  
+    La proportion est légèrement plus élevée via **Connect** que via Mobile.
+    """)
+
+
+    fig_delay = px.histogram(
+        df.query("-150 <= delay_at_checkout_in_minutes <= 150"),
+        x="delay_at_checkout_in_minutes",
+        nbins=60,
+        title="Distribution des retards (fenêtre -150 à 150 min)"
+    )
+    st.plotly_chart(fig_delay, use_container_width=True)
+
+    st.markdown("""
+    👉 La majorité des retards est **courte** :  
+    - 50 % ≤ 9 min  
+    - 75 % ≤ 67 min  
+    Mais certains cas extrêmes dépassent plusieurs jours.
+    """)
+
+    # ANALYSE DES ANNULATIONS 
+    st.header("❌ Analyse des annulations liées aux retards")
+
+    mask = df['previous_ended_rental_id'] > 0
+    df_nan = df[mask]
+    st.metric("Le nombre d'annulations du au retard du véhicule liées à un location précendente est de", (df_nan["state"] == "canceled").sum())
+    annulation = (df_nan["state"] == "canceled").sum() 
+    st.metric("La location moyenne d'un véhicule par jour est de ", df_pricing['rental_price_per_day'].mean().round(2))
+    st.metric("La perte du aux annulations s'élève a :", (annulation * loc_moyenne).round(2))
+
+    canceled = df[df["state"] == "canceled"][["rental_id", "car_id", "previous_ended_rental_id", "checkin_type","time_delta_with_previous_rental_in_minutes"]]
+
+    merged = canceled.merge(
+        df[["rental_id", "car_id", "delay_at_checkout_in_minutes", "checkin_type"]],
+        left_on="previous_ended_rental_id",   
+        right_on="rental_id",                 
+        suffixes=("_canceled", "_previous")
+    )
+
+    conflict_strict = merged[
+        merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"]
+    ]
+    st.metric("Conflits stricts :", len(conflict_strict))
+    st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict["delay_at_checkout_in_minutes"].mean().round(2))
+
+    st.markdown("""
+    👉 Parmi les **229 annulations liées à une location précédente**,  
+    **37** sont dues à un retard allant au delà de l'heure de début de la prochaine location.  
+    Ces retards sont très longs (~4h15 en moyenne).
+    """)
+
+    conflict_minus30 = merged[
+        merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 30
+    ]
+
+    conflict_minus60 = merged[
+        merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 60
+    ]
+
+    conflict_minus90 = merged[
+        merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 90
+    ]
+
+    conflict_minus180 = merged[
+        merged["delay_at_checkout_in_minutes"] > merged["time_delta_with_previous_rental_in_minutes"] - 180
+    ]
+
+
+    results = [
+        {"Buffer": "-30 min", "Conflits": (len(conflict_minus30)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus30["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-60 min", "Conflits": (len(conflict_minus60)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus60["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-90 min", "Conflits": (len(conflict_minus90)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus90["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-180 min", "Conflits": (len(conflict_minus180)-len(conflict_strict)), "Moyenne retard (min)": conflict_minus180["delay_at_checkout_in_minutes"].mean()},
+    ]
+    df_conflicts = pd.DataFrame(results)
+    df_conflicts['lost_value'] = df_conflicts["Conflits"]*loc_moyenne
+    st.dataframe(df_conflicts)
+
+    st.markdown("""Si on regarde 30 miniutes avant le début de la location du véhicule combien ont été annulé (buffer de 30 minutes), on détecte 10 annulations supplémentaires : ces cas correspondent à des locations rendues trop proches de la suivante (<30 min de marge).
+    Avec un buffer de 60 minutes, seulement 3 cas en plus → ce sont donc des situations rares mais critiques.
+    En élargissant à 90 minutes, on ajoute encore 7 cas.""")
+
+
+    fig_type = px.histogram(
+        df.query("-150 <= delay_at_checkout_in_minutes <= 150"),
+        x="delay_at_checkout_in_minutes",
+        color="checkin_type",
+        nbins=int((150 - (-150)) / 10),  
+        opacity=0.2,
+        title="Distribution des retards par type de check-in",
+        labels={"delay_at_checkout_in_minutes": "Retard (minutes)"},
+        range_x=[-150, 150],
+        width=1200, height=600,
+    )
+    fig_type.update_layout(barmode="overlay")
+    fig_type.update_yaxes(title="Nombre de locations")
+    #
+    st.plotly_chart(fig_type, use_container_width=True)
+
+
+    st.markdown(""" ANALYSE SUR MOBILE """)
+
+    mask = merged["checkin_type_canceled"] == "mobile"
+    merged_mob = merged[mask]
+    conflict_strict1= merged_mob[
+        merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"]
+    ]
+    st.metric("Conflits stricts :", len(conflict_strict1))
+    st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict1["delay_at_checkout_in_minutes"].mean().round(2))
+
+    conflict_1minus30 = merged_mob[
+        merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 30
+    ]
+
+    conflict_1minus60 = merged_mob[
+        merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 60
+    ]
+
+    conflict_1minus90 = merged_mob[
+        merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 90
+    ]
+
+    conflict_1minus180 = merged_mob[
+        merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 180
+    ]
+
+
+    results = [
+        {"Buffer": "-30 min", "Conflits": (len(conflict_1minus30)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus30["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-60 min", "Conflits": (len(conflict_1minus60)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus60["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-90 min", "Conflits": (len(conflict_1minus90)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus90["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-180 min", "Conflits": (len(conflict_1minus180)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus180["delay_at_checkout_in_minutes"].mean()},
+    ]
+    df_conflicts_mob = pd.DataFrame(results)
+    df_conflicts_mob['lost_value'] = df_conflicts_mob["Conflits"]*loc_moyenne
+    st.dataframe(df_conflicts_mob)
 
-conflict_1minus180 = merged_mob[
-    merged_mob["delay_at_checkout_in_minutes"] > merged_mob["time_delta_with_previous_rental_in_minutes"] - 180
-]
+    st.markdown(""" ANALYSE SUR CONNECT """)
 
+    mask = merged["checkin_type_canceled"] == "connect"
+    merged_connect = merged[mask]
+    conflict_strict2 = merged_connect[
+        merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"]
+    ]
+    st.metric("Conflits stricts :", len(conflict_strict2))
+    st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict2["delay_at_checkout_in_minutes"].mean().round(2))
 
-results = [
-    {"Buffer": "-30 min", "Conflits": (len(conflict_1minus30)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus30["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-60 min", "Conflits": (len(conflict_1minus60)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus60["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-90 min", "Conflits": (len(conflict_1minus90)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus90["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-180 min", "Conflits": (len(conflict_1minus180)-len(conflict_strict1)), "Moyenne retard (min)": conflict_1minus180["delay_at_checkout_in_minutes"].mean()},
-]
-df_conflicts_mob = pd.DataFrame(results)
-df_conflicts_mob['lost_value'] = df_conflicts_mob["Conflits"]*loc_moyenne
-st.dataframe(df_conflicts_mob)
 
-st.markdown(""" ANALYSE SUR CONNECT """)
+    conflict_2minus30 = merged_connect[
+        merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 30
+    ]
 
-mask = merged["checkin_type_canceled"] == "connect"
-merged_connect = merged[mask]
-conflict_strict2 = merged_connect[
-    merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"]
-]
-st.metric("Conflits stricts :", len(conflict_strict2))
-st.metric("Moyenne retard précédent (conflits seulement) :", conflict_strict2["delay_at_checkout_in_minutes"].mean().round(2))
 
+    conflict_2minus60 = merged_connect[
+        merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 60
+    ]
 
-conflict_2minus30 = merged_connect[
-    merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 30
-]
+    conflict_2minus90 = merged_connect[
+        merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 90
+    ]
 
+    conflict_2minus180 = merged_connect[
+        merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 180
+    ]
 
-conflict_2minus60 = merged_connect[
-    merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 60
-]
 
-conflict_2minus90 = merged_connect[
-    merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 90
-]
+    results = [
+        {"Buffer": "-30 min", "Conflits": (len(conflict_2minus30)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus30["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-60 min", "Conflits": (len(conflict_2minus60)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus60["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-90 min", "Conflits": (len(conflict_2minus90)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus90["delay_at_checkout_in_minutes"].mean()},
+        {"Buffer": "-180 min", "Conflits": (len(conflict_2minus180)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus180["delay_at_checkout_in_minutes"].mean()},
+    ]
+    df_conflicts_con = pd.DataFrame(results)
 
-conflict_2minus180 = merged_connect[
-    merged_connect["delay_at_checkout_in_minutes"] > merged_connect["time_delta_with_previous_rental_in_minutes"] - 180
-]
+    df_conflicts_con['lost_value'] = df_conflicts_con["Conflits"]*loc_moyenne
 
+    st.dataframe(df_conflicts_con)
 
-results = [
-    {"Buffer": "-30 min", "Conflits": (len(conflict_2minus30)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus30["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-60 min", "Conflits": (len(conflict_2minus60)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus60["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-90 min", "Conflits": (len(conflict_2minus90)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus90["delay_at_checkout_in_minutes"].mean()},
-    {"Buffer": "-180 min", "Conflits": (len(conflict_2minus180)-len(conflict_strict2)), "Moyenne retard (min)": conflict_2minus180["delay_at_checkout_in_minutes"].mean()},
-]
-df_conflicts_con = pd.DataFrame(results)
+    st.markdown("""Les deux systèmes subissent des annulations liées aux délais courts.
+    Connect est plus fréquent en volume absolu, mais ses retards sont légèrement moins sévères.
+    Mobile présente moins de cas mais avec des retards plus longs → donc plus difficiles à absorber sans impact client.
+    Les deux méthodes sont exposées aux retards, mais Connect encaisse plus de cas tandis que Mobile concentre les retards les plus importants.
+    Un buffer opérationnel de 30 minutes permettrai un gain rapide sans trop affecté le CA global.
+    """ )
 
-df_conflicts_con['lost_value'] = df_conflicts_con["Conflits"]*loc_moyenne
+    # IMPACT DES BUFFERS 
+    st.header("⏳ Simulation de buffer entre locations")
+    st.markdown(""" Afin d'analyser l'impact d'un buffer nous prenons cette fois ci que les locations qui ont eu lieu et filtrons toutes les locations ayant débutées dans les 30 minutes qui suit la précéddentes.
+    Ces locations sont celle qui risquent d'etre impactées par ce delai """)
 
-st.dataframe(df_conflicts_con)
+    loc_moyenne = df_pricing["rental_price_per_day"].mean()
+    CA_total = (df['state'] == 'ended').sum() * loc_moyenne
 
-st.markdown("""Les deux systèmes subissent des annulations liées aux délais courts.
-Connect est plus fréquent en volume absolu, mais ses retards sont légèrement moins sévères.
-Mobile présente moins de cas mais avec des retards plus longs → donc plus difficiles à absorber sans impact client.
-Les deux méthodes sont exposées aux retards, mais Connect encaisse plus de cas tandis que Mobile concentre les retards les plus importants.
-Un buffer opérationnel de 30 minutes permettrai un gain rapide sans trop affecté le CA global.
-""" )
 
-# IMPACT DES BUFFERS 
-st.header("⏳ Simulation de buffer entre locations")
-st.markdown(""" Afin d'analyser l'impact d'un buffer nous prenons cette fois ci que les locations qui ont eu lieu et filtrons toutes les locations ayant débutées dans les 30 minutes qui suit la précéddentes.
-Ces locations sont celle qui risquent d'etre impactées par ce delai """)
+    df_valid = df[df["state"] == "ended"].copy()
+    df_valid["ecart"] = df_valid["time_delta_with_previous_rental_in_minutes"] - df_valid["delay_at_checkout_in_minutes"]
 
-loc_moyenne = df_pricing["rental_price_per_day"].mean()
-CA_total = (df['state'] == 'ended').sum() * loc_moyenne
+    def count_blocked(df, buffer):
+        return (df["ecart"] < buffer).sum()
 
+    results = []
+    for b in [30, 60, 90, 180]:
+        blocked = count_blocked(df_valid, b)
+        perte_estimee = blocked * loc_moyenne
+        results.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
 
-df_valid = df[df["state"] == "ended"].copy()
-df_valid["ecart"] = df_valid["time_delta_with_previous_rental_in_minutes"] - df_valid["delay_at_checkout_in_minutes"]
+    df_results = pd.DataFrame(results)
+    st.dataframe(df_results)
 
-def count_blocked(df, buffer):
-    return (df["ecart"] < buffer).sum()
 
-results = []
-for b in [30, 60, 90, 180]:
-    blocked = count_blocked(df_valid, b)
-    perte_estimee = blocked * loc_moyenne
-    results.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
+    st.markdown(""" MOBILE UNIQUEMENT""")
 
-df_results = pd.DataFrame(results)
-st.dataframe(df_results)
+    df_valid_mob = df[(df["state"] == "ended") & (df["checkin_type"] == "mobile")].copy()
+    df_valid_mob["ecart"] = df_valid_mob["time_delta_with_previous_rental_in_minutes"] - df_valid_mob["delay_at_checkout_in_minutes"]
 
+    def count_blocked(df, buffer):
+        return (df["ecart"] < buffer).sum()
 
-st.markdown(""" MOBILE UNIQUEMENT""")
+    results2 = []
+    for b in [30, 60, 90, 180]:
+        blocked = count_blocked(df_valid_mob, b)
+        perte_estimee = blocked * loc_moyenne
+        results2.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
 
-df_valid_mob = df[(df["state"] == "ended") & (df["checkin_type"] == "mobile")].copy()
-df_valid_mob["ecart"] = df_valid_mob["time_delta_with_previous_rental_in_minutes"] - df_valid_mob["delay_at_checkout_in_minutes"]
+    df_results_mob = pd.DataFrame(results2)
+    st.dataframe(df_results_mob)
 
-def count_blocked(df, buffer):
-    return (df["ecart"] < buffer).sum()
 
-results2 = []
-for b in [30, 60, 90, 180]:
-    blocked = count_blocked(df_valid_mob, b)
-    perte_estimee = blocked * loc_moyenne
-    results.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
+    st.markdown(""" CONNECT UNIQUEMENT""")
 
-df_results_mob = pd.DataFrame(results2)
-st.dataframe(df_results_mob)
+    df_valid_con = df[(df["state"] == "ended") & (df["checkin_type"] == "connect")].copy()
+    df_valid_con["ecart"] = df_valid_con["time_delta_with_previous_rental_in_minutes"] - df_valid_con["delay_at_checkout_in_minutes"]
 
+    def count_blocked(df, buffer):
+        return (df["ecart"] < buffer).sum()
 
-st.markdown(""" CONNECT UNIQUEMENT""")
+    results3 = []
+    for b in [30, 60, 90, 180]:
+        blocked = count_blocked(df_valid_con, b)
+        perte_estimee = blocked * loc_moyenne
+        results3.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
 
-df_valid_con = df[(df["state"] == "ended") & (df["checkin_type"] == "connect")].copy()
-df_valid_con["ecart"] = df_valid_con["time_delta_with_previous_rental_in_minutes"] - df_valid_con["delay_at_checkout_in_minutes"]
+    df_results_con = pd.DataFrame(results3)
+    st.dataframe(df_results_con)
 
-def count_blocked(df, buffer):
-    return (df["ecart"] < buffer).sum()
+    st.markdown("""
+    👉 Un buffer **de 30 min bloque ~340 locations** → pertes supérieures aux gains.  
+    👉 Un buffer de **180 min réduit beaucoup les annulations** mais fait perdre trop de CA.  
+    **Conclusion : un buffer global n’est pas viable.**
+    """)
 
-results3 = []
-for b in [30, 60, 90, 180]:
-    blocked = count_blocked(df_valid_con, b)
-    perte_estimee = blocked * loc_moyenne
-    results.append({"Buffer (min)": b, "Locations bloquées": blocked, "Perte estimée ($)": round(perte_estimee, 2)})
+    # CONCLUSION BUSINESS
+    st.header("📌 Conclusion business")
 
-df_results_con = pd.DataFrame(results3)
-st.dataframe(df_results_con)
+    st.markdown("""
+    Nos analyses montrent :  
+    - Les retards courts sont fréquents, mais les **annulations sont rares (229 cas)**.  
+    - Les retards extrêmes sont à l’origine de la majorité des conflits.  
+    - Un buffer global **réduit les annulations mais détruit plus de revenu** qu’il n’en sauve.  
+
+    ✅ **Recommandations** :  
+    - Pas de buffer global.  
+    - Buffer ciblé (<1h) sur cas à risque, zone chaude.  
+    - Notifications pour inciter à rendre le véhicule en avance.  
+    - Eventuellement pénalités pour retards répétés.(=> mais c'est anticommercial )
 
-st.markdown("""
-👉 Un buffer **de 30 min bloque ~340 locations** → pertes supérieures aux gains.  
-👉 Un buffer de **180 min réduit beaucoup les annulations** mais fait perdre trop de CA.  
-**Conclusion : un buffer global n’est pas viable.**
-""")
+    👉 L’impact économique du buffer est donc limité,  
+    mais des mesures ciblées peuvent réduire la friction sans perte majeure de CA.
+    """)
+    
 
-# ANALYSE DU PRICING 
-st.header("💰 Analyse des prix de location")
+# ANALYSE DU PRICING
+with tab2:
+    st.header("Analyse Pricing")
+    
+    df_pricing = pd.read_csv("data/pricing_clean.csv")
 
-fig_price = px.histogram(df_pricing, x="rental_price_per_day", nbins=50,
-                         title="Distribution des prix de location par jour")
-st.plotly_chart(fig_price, use_container_width=True)
+    fig_price = px.histogram(df_pricing, x="rental_price_per_day", nbins=50,
+                            title="Distribution des prix de location par jour")
+    st.plotly_chart(fig_price, use_container_width=True)
 
 
-fig_car_typ = px.box(df_pricing, x="car_type", y="rental_price_per_day",
-             title="Prix par type de véhicule")
-st.plotly_chart(fig_car_typ, use_container_width=True)
+    fig_car_typ = px.box(df_pricing, x="car_type", y="rental_price_per_day",
+                title="Prix par type de véhicule")
+    st.plotly_chart(fig_car_typ, use_container_width=True)
 
 
-st.markdown("""
-👉 Le marché est concentré autour de **100–140 $/jour**.  
-Les **SUV, coupés, cabriolets** sont plus chers.  
-Les **citadines** et **hatchbacks** moins chers.
-""")
-
-st.markdown(""" **Indice de correlation** """)
-df_corr = df_pricing.copy()
-bool_cols = df_corr.select_dtypes(include="bool").columns
-df_corr[bool_cols] = df_corr[bool_cols].astype(int)
-
-num_df = df_corr.select_dtypes(include=["int64", "float64"])
+    st.markdown("""
+    👉 Le marché est concentré autour de **100–140 $/jour**.  
+    Les **SUV, coupés, cabriolets** sont plus chers.  
+    Les **citadines** et **hatchbacks** moins chers.
+    """)
 
-corr = num_df.corr()
 
-fig_cor = px.imshow(
-    corr,
-    text_auto=True,
-    color_continuous_scale="RdBu_r",
-    title="Matrice de corrélation",
-    height=800,
-    width=1000
-)
-st.plotly_chart(fig_cor, use_container_width=True)
+    df_corr = df_pricing.copy()
+    bool_cols = df_corr.select_dtypes(include="bool").columns
+    df_corr[bool_cols] = df_corr[bool_cols].astype(int)
 
-st.markdown(""" + corrélation prix ↔ puissance moteur
+    num_df = df_corr.select_dtypes(include=["int64", "float64"])
 
-– corrélation prix ↔ kilométrage
+    corr = num_df.corr()
 
-Transmission automatique = + valeur
+    fig_cor = px.imshow(
+        corr,
+        text_auto=True,
+        color_continuous_scale="RdBu_r",
+        title="Matrice de corrélation",
+        height=800,
+        width=1000
+    )
+    st.plotly_chart(fig_cor, use_container_width=True)
+
+    st.markdown(""" 
+    + corrélation prix ↔ puissance moteur
+    – corrélation prix ↔ kilométrage
+    Transmission automatique = + valeur ajoutée
+    Présence de GPS = + valeur ajoutée """)
+    
+with tab3:
+    st.header("Tester l'API de prédiction des prix")
+
+    API_URL = "https://gdleds-api-get.hf.space/predict"
+
+    with st.form("api_test_form"):
+        st.write("### Entrez les caractéristiques du véhicule :")
+
+        model_key = st.selectbox("Marque", ["Audi", "BMW", "Renault", "Peugeot", "Citroën"])
+        mileage = st.number_input("Kilométrage", min_value=0, max_value=300000, value=50000)
+        engine_power = st.number_input("Puissance moteur (CV)", min_value=30, max_value=300, value=110)
+        fuel = st.selectbox("Carburant", ["diesel", "petrol", "hybrid_petrol", "electro"])
+        paint_color = st.selectbox("Couleur", ["black", "white", "grey", "red", "blue", "silver"])
+        car_type = st.selectbox("Type de véhicule", ["hatchback", "subcompact", "sedan", "suv", "estate", "convertible", "coupe", "van"])
+
+        private_parking_available = st.checkbox("Parking privé disponible", value=True)
+        has_gps = st.checkbox("GPS", value=True)
+        has_air_conditioning = st.checkbox("Climatisation", value=True)
+        automatic_car = st.checkbox("Boîte automatique", value=False)
+        has_getaround_connect = st.checkbox("Getaround Connect", value=True)
+        has_speed_regulator = st.checkbox("Régulateur de vitesse", value=True)
+        winter_tires = st.checkbox("Pneus hiver", value=False)
+
+        submitted = st.form_submit_button("Prédire le prix")
+
+        if submitted:
+            input_data = {
+                "input": [[
+                    model_key, mileage, engine_power, fuel, paint_color, car_type,
+                    private_parking_available, has_gps, has_air_conditioning,
+                    automatic_car, has_getaround_connect, has_speed_regulator, winter_tires
+                ]]
+            }
+
+            try:
+                response = requests.post(API_URL, json=input_data)
+                if response.status_code == 200:
+                    prediction = response.json().get("prediction", [None])[0]
+                    st.success(f"💰 Prix prédit : {prediction:.2f} $ / jour")
+                else:
+                    st.error(f"Erreur API ({response.status_code}) : {response.text}")
+            except Exception as e:
+                st.error(f"Impossible d'appeler l'API : {e}")
 
-Présence de GPS = + valeur ajoutée """)
 
 
-
-# CONCLUSION BUSINESS
-st.header("📌 Conclusion business")
-
-st.markdown("""
-Nos analyses montrent :  
-- Les retards courts sont fréquents, mais les **annulations sont rares (229 cas)**.  
-- Les retards extrêmes sont à l’origine de la majorité des conflits.  
-- Un buffer global **réduit les annulations mais détruit plus de revenu** qu’il n’en sauve.  
-
-✅ **Recommandations** :  
-- Pas de buffer global.  
-- Buffer ciblé (<1h) sur cas à risque, zone chaude.  
-- Notifications pour inciter à rendre le véhicule en avance.  
-- Eventuellement pénalités pour retards répétés.(=> mais c'est anticommercial )
-
-👉 L’impact économique du buffer est donc limité,  
-mais des mesures ciblées peuvent réduire la friction sans perte majeure de CA.
-""")