app.py

import streamlit as st
import pandas as pd
import plotly.express as px
import requests
import plotly.graph_objects as go
from plotly.subplots import make_subplots

st.set_page_config(page_title="Getaround – Dashboard Analyse", layout="wide")

st.markdown("""
    <style>
        .stTabs [role="tablist"] {
            justify-content: center;
            gap: 25px;
        }
        .stTabs [role="tab"] {
            font-size: 17px;
            font-weight: 600;
            padding: 10px 20px;
            border-radius: 10px;
            background-color: #f8f9fa;
            color: #444;
            transition: all 0.3s ease-in-out;
        }
        .stTabs [role="tab"]:hover {
            background-color: #e0e0e0;
            transform: scale(1.05);
        }
        .stTabs [role="tab"][aria-selected="true"] {
            background-color: #4CAF50;
            color: white;
            font-weight: 700;
            box-shadow: 0px 4px 8px rgba(0,0,0,0.2);
        }
    </style>
""", unsafe_allow_html=True)

st.title("🚙🚕 Bonjour et bienvenue sur le dashboard du projet Getaround ! 🚗🚑")

st.markdown("""
             
Vous trouverez ci-dessous les différentes étapes du projet ainsi qu'un outil de prédiction élaboré en fonction des données
            
""")

tab1, tab2, tab3, tab4 = st.tabs(["📊⏱ Analyse des locations et retards", "💲Analyse tarifaire", " ✍️ Constat et conclusions", "🔮✨ Prédiction par API"])

with tab1:

# Import des datasets

    delay = pd.read_excel("data/get_around_delay_analysis.xlsx")
    price=pd.read_csv('data/get_around_pricing_project.csv')
    annulation_by_delay=pd.read_csv('data/annulation_by_delay.csv')
   
    st.header("1. Les chiffres de locations sur 21 310 locations") 
    st.subheader("- A quelle fréquence sont loués les véhicules ?")

# ANALYSE DES LOCATIONS

# Premier graph nombre de locations des véhicules

    car_usage = delay['car_id'].value_counts()

    car_usage_top10 = car_usage[car_usage <= 15]

    fig = px.histogram(
    car_usage_top10,
    nbins=15,
    labels={'value': 'Nombre de locations', 'count': 'Nombre de véhicules'}
    )

    fig.update_layout(
    bargap=0.1,
    height=600
    )

    st.plotly_chart(fig, use_container_width=True)
    

    st.markdown("<h4>👉 Près de 45% des véhicules n'ont été loués qu'une seule fois</h4>", unsafe_allow_html=True)

    st.markdown("---")

    st.header("2. Les types de location et les annulations")
    st.subheader("- Quel mode de location est privilégié et quelle proportion d'annulation ?")

# Second graph type de locations et annulations

    checkin_counts = delay['checkin_type'].value_counts()
    course_state = delay['state'].value_counts()

    fig = make_subplots(
    rows=1, cols=2, specs=[[{'type':'domain'}, {'type':'domain'}]],
    subplot_titles=("Répartition des types de check-in", "Répartition des statuts des locations")
    )

    fig.add_trace(
    go.Pie(labels=checkin_counts.index, values=checkin_counts.values, name="Check-in type"),
    row=1, col=1
    )

    fig.add_trace(
    go.Pie(labels=course_state.index, values=course_state.values, name="State"),
    row=1, col=2
    )

    fig.update_traces(hole=0, textinfo='label+percent')
    fig.update_layout(
    height=500,
    width=900,
    
    showlegend=False,
    )

    st.plotly_chart(fig, use_container_width=True)

    st.markdown("<h4>👉 Concernant les locations, le check-in mobile représente 80% quand le connect n'est que de 20%." \
    " La proportion de courses annulées est de 15% environ pour un total d'environ 3200", unsafe_allow_html=True)

    st.markdown("---")

# Troisième graph proportion d'annulation selon le type de location

    st.subheader("Quelle mode de location est plus impacté par les annulations ?")

    total_per_type = delay.groupby('checkin_type')['state'].count()
    canceled_per_type = delay[delay['state'] == 'canceled'].groupby('checkin_type')['state'].count()
    proportion_canceled = (canceled_per_type / total_per_type).fillna(0) * 100

    prop_delay = proportion_canceled.reset_index()
    prop_delay.columns = ['checkin_type', 'proportion_canceled']

    color_map = {
    'mobile': 'pink', 
    'connect': 'royalblue'
    }

    fig = px.bar(
    prop_delay, 
    x='checkin_type', 
    y='proportion_canceled', 
    text=prop_delay['proportion_canceled'].round(1),
    labels={'checkin_type':'Type de check-in', 'proportion_canceled':'% Annulations'},
    color='checkin_type',
    color_discrete_map=color_map
    )

    fig.update_layout(
    height=600
    )
    fig.update_traces(textposition='outside')

    st.plotly_chart(fig, use_container_width=True)

    st.markdown("<h4>👉 Selon le type de check-in, la proportion d'annulation est différente. Les utilisateurs de la version Connect " \
    "sont plus susceptibles d'annuler leur location de 4 points"
    "", unsafe_allow_html=True)

    st.markdown("---")

    st.header("3. Les retards")

 # Traitement outlier des retards

    summary = delay['delay_at_checkout_in_minutes'].describe()

    Q1 = delay['delay_at_checkout_in_minutes'].quantile(0.25)
    Q3 = delay['delay_at_checkout_in_minutes'].quantile(0.75)
    IQR = Q3 - Q1

    lower_bound = Q1 - 1.5*IQR
    upper_bound = Q3 + 1.5*IQR

    delay_filtered = delay[(delay['delay_at_checkout_in_minutes'] >= lower_bound) &
                    (delay['delay_at_checkout_in_minutes'] <= upper_bound)]

# Quatrième Graph de distribution des retards

    st.markdown("""
    Regardons dans le détail la distribution des délais de retard""")

    fig = px.histogram(
    delay_filtered,
    x='delay_at_checkout_in_minutes',
    nbins=50,
    color='checkin_type',
    barmode='overlay',
    labels={'delay_at_checkout_in_minutes': 'Retard au checkout (minutes)', 'count': 'Nombre de locations'},
    color_discrete_map={'mobile': 'royalblue', 'connect': 'crimson'}
    )

    fig.update_layout(
        height=600,
        bargap=0.1
    )

    st.plotly_chart(fig, use_container_width=True)


    st.markdown("""
    👉 L'absence de retard dans le total des courses est importante et les valeurs se centrent autour de 0. 
                Cependant nous constatons que de retards importants peuvent être présents.""" 
    )

# Centrage sur les courses annulées :

# Création du dataframe relatant les cancel

    delay_canceled = delay[delay["state"] == "canceled"][["rental_id", "car_id", "previous_ended_rental_id", 
                                                          "checkin_type","time_delta_with_previous_rental_in_minutes"]]

# Rattachement de la location annulée à l'id de la location précédente

    delay_merged = delay_canceled.merge(
    delay[["rental_id", "car_id", "delay_at_checkout_in_minutes", "checkin_type"]],
    left_on="previous_ended_rental_id",
    right_on="rental_id",                 
    suffixes=("_canceled", "_previous")
    )

# Inspection de l'écart entre le delta et le retard

    delay_problems = delay_merged[
    delay_merged["delay_at_checkout_in_minutes"] > delay_merged["time_delta_with_previous_rental_in_minutes"]
    ]

# Découpage des retards en tranches horaires

    bins = [0, 15, 30, 60, 120, 9999]
    labels = ["0-15 min", "15-30 min", "30-60 min", "1-2 h", ">2 h"]

    delay_problems["delay_category"] = pd.cut(
    delay_problems["delay_at_checkout_in_minutes"],
    bins=bins,
    labels=labels,
    include_lowest=True
    )

    st.markdown("---")

    st.subheader("""Quelle est la proportion de la durée des différents retards dans les annulations ?""")

# Cinquième graph de la part des durées de retard dans les annulations selon le checkin : 

    fig = px.pie(
    delay_problems,
    names="delay_category",
    facet_col="checkin_type_canceled",
    )

    fig.for_each_annotation(lambda a: a.update(
    text=a.text.split("=")[-1]
    ))

    st.plotly_chart(fig, use_container_width=True)

    st.markdown("""Les retards de plus de 2 heures représentent la majeure partie des annulations, 
                ce qui paraît logique pour le futur client. Le check-in mobile présente une proportion 
                de cette durée supérieure de 8,9 points au connect.""")


    st.markdown("---")

    st.header("""Quel est l'impact réel des retards sur les annulations, selon le type de check-in ?""")

# Création d'intervalles pour déterminer les différents créneaux de retard

    bins = [-9999, 0, 15, 30, 60, 120, 240, 9999]
    labels = ["≤0", "1-15 min", "15-30 min", "30-60 min", "1-2 h", "2-4 h", ">4 h"]

    delay_merged["delay_group"] = pd.cut(
    delay_merged["delay_at_checkout_in_minutes"],
    bins=bins,
    labels=labels,
    include_lowest=True
    )

# Groupage des annulations par intervalles de retard
    annulation_by_delay = (
    delay_merged.groupby(["delay_group", "checkin_type_canceled"])["rental_id_canceled"]
    .count()
    .reset_index(name="nb_annulations")
    )

# Sixième graph pour visualisation de l'importance de la durée des retards

    fig = px.bar(
    annulation_by_delay,
    x="delay_group",
    y="nb_annulations",
    color="checkin_type_canceled",
    barmode="group",
    labels={
        "delay_group": "Temps de retard",
        "nb_annulations": "Nombre d'annulations",
        "checkin_type_canceled": "Type de check-in"
    }
    )

    st.plotly_chart(fig, use_container_width=True)

# Analyse des locations maintenues malgré un retard précédent

    st.header("""Quels sont les chiffres des locations maintenues malgré un retard précédent ?""")

    # Création du dataframe relatant les ended 
    delay_ended = delay[delay["state"] == "ended"][["rental_id", "car_id", "previous_ended_rental_id", 
                                                "checkin_type","time_delta_with_previous_rental_in_minutes"]] 
    
    delay_ended_merged = delay_ended.merge( 
    delay[["rental_id", "car_id", "delay_at_checkout_in_minutes", "checkin_type"]], 
    left_on="previous_ended_rental_id", 
    right_on="rental_id", 
    suffixes=("_ended", "_previous") ) 

    delay_ended_merged["delay_group"] = pd.cut(
    delay_ended_merged["delay_at_checkout_in_minutes"],
    bins=bins,
    labels=labels,
    include_lowest=True
    )

# Agrégation : nombre de courses terminées malgré un retard
    ended_by_delay = (
    delay_ended_merged.groupby(["delay_group", "checkin_type_ended"])["rental_id_ended"].count().reset_index(name="nb_ended")
    )


# Graphique Plotly
    fig = px.bar(
    ended_by_delay,
    x="delay_group",
    y="nb_ended",
    color="checkin_type_ended",
    barmode="group",
    labels={
        "delay_group": "Temps de retard",
        "nb_ended": "Nombre de locations maintenues",
        "checkin_type_ended": "Type de check-in"
    }
)

    st.plotly_chart(fig, use_container_width=True)

    st.subheader('Les locations maintenues malgré un retard précédent sont en nombre beaucoup plus important que les annulations. ' \
    'Sur le seul créneau de 1 à 15 minutes, elles sont au nombre de 203, quand seulement 17 sont annulées sur ce même retard. ' \
    'Pour le créneau de 15 à 30 minutes, elles sont 127 de maintenues contre 17 annulées.')

    st.markdown('---')


# ANALYSE TARIFAIRE
 
with tab2:

    st.header("1. Le parc automobile des propriétaires")

    st.subheader("Quelles sont les 10 marques les plus présentes ?")

# Tri des véhicules pour déterminer les véhicules uniques

    cols_check = [
    "model_key", "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"
    ]

    price_dedup = price.drop_duplicates(subset=cols_check, keep="first")

# Premier graph de la représentation des 10 premières marques 

    model_counts = price_dedup["model_key"].value_counts().reset_index()
    model_counts.columns = ["model_key", "total"]

    top10_models = model_counts.head(10)

    fig = px.bar(
    top10_models,
    x="model_key",
    y="total",
    labels={"model_key": "Marque", "total": "Véhicules"}
    )

    st.plotly_chart(fig, use_container_width=True)

# Second graph de la représentation des marques les plus louées

    st.subheader('Quelles sont les marques ayant le plus de succès ?')

    model_counts = price["model_key"].value_counts().reset_index()
    model_counts.columns = ["model_key", "total"]

    top10_models = model_counts.head(10)

    fig = px.bar(
    top10_models,
    x="model_key",
    y="total",
    labels={"model_key": "Marque", "total": "Véhicules"}
    )

    st.plotly_chart(fig, use_container_width=True)

    st.markdown('Les 3 marques les plus présentes sont aussi les plus louées : Citroën, BMW et Renault')

    st.markdown('---')

# Troisième graph pour estimer le prix d'une location

    st.subheader("2. Quelle base tarifaire pour estimer le prix d'une location ?")

    fig = px.histogram(
    price, 
    x="rental_price_per_day", 
    nbins=30, 
    labels={"rental_price_per_day": "Prix journalier de la location"}
    )

# Calcul médiane, moyenne et prix de référence
    median_value = price["rental_price_per_day"].median()
    mean_value = price["rental_price_per_day"].mean()
    ref_price = ((mean_value + median_value)/2).round(2)

# Ligne verticale médiane
    fig.add_vline(
    x=median_value,
    line_dash="dash",
    line_color="red",
    annotation_text=f"Médiane = {median_value:.2f}",
    annotation_position="top right"
    )

# Ligne verticale moyenne
    fig.add_vline(
    x=mean_value,
    line_dash="dot",
    line_color="blue",
    annotation_text=f"Moyenne = {mean_value:.2f}",
    annotation_position="top left"
    )

    st.plotly_chart(fig, use_container_width=True)

    st.markdown(" 👉 Le constat est simple, la moyenne tarifaire d'une location est de 121 dollars quand la médiane est à 119 dollars. " \
    "La prix d'une location est donc fixé à la valeur intermédiaire soit 120,11 dollars.")

# Quatrième graph pour visualiser le montant des pertes selon les retards

    st.subheader(("3. Quelle est le réel impact de perte de CA des retards ?"))

# Mise en place des intervalles

    ordre = ["≤0", "1-15 min", "15-30 min", "30-60 min", "1-2 h", "2-4 h", ">4 h"]

# Transformer delay_group en catégorie ordonnée
    annulation_by_delay["delay_group"] = pd.Categorical(
    annulation_by_delay["delay_group"],
    categories=ordre,
    ordered=True
    )

# On calcule la perte potentielle pour chaque ligne
    annulation_by_delay["perte_potentielle"] = annulation_by_delay["nb_annulations"] * ref_price

# Tableau loss pour visualiser la perte par délai et type de checkin
    loss = annulation_by_delay.pivot_table(
    index="delay_group",
    columns="checkin_type_canceled",
    values="perte_potentielle",
    aggfunc="sum",
    fill_value=0
)

# Ajouter une colonne de perte totale par intervalle
    loss["total_perte"] = loss.sum(axis=1)

# Affichage du graph

    fig = go.Figure()

    fig.add_trace(go.Bar(
    x=loss.index,
    y=loss["connect"],
    name='Connect',
    marker_color='blue',
    hovertemplate='Connect: %{y:.2f} €<extra></extra>'
    ))

    fig.add_trace(go.Bar(
    x=loss.index,
    y=loss["mobile"],
    name='Mobile',
    marker_color='orange',
    hovertemplate='Mobile: %{y:.2f} €<extra></extra>'
    ))

    fig.update_layout(
    xaxis_title="Intervalle de retard",
    yaxis_title="Perte potentielle (€)",
    template='plotly_white',
    hovermode="x unified",
    barmode="group"
    )

    st.plotly_chart(fig, use_container_width=True)

    st.markdown("""
    ### 📊 Analyse des pertes de CA liées aux retards

    - **La plus grande perte de CA n'est clairement pas constituée par les retards**, 
    puisque nous avons **12 011 $** de perdus **sans aucun retard**, soit près de **la moitié des pertes (48,54%)**.  
    - **Mettre en place un délai supplémentaire ne paraît pas justifié**, puisque le nombre d'annulations liées à des
     petits retards (1 à 15 min) représente **17 courses**, pour un total de **2 041 $**, soit **à peine 10% des pertes**.  
    - Pour atteindre l’équivalent des pertes non dues à un retard, il faudrait mettre en place un **délai de plus de 2 heures**,
     sans garantie de trouver une course, ce qui va forcément **nuire à la visibilité des propriétaires**.
    - Ici la conclusion est simple : si nous ajoutons un délai de 30 minutes, cela
    diminuera l'impact de **34 cas seulement sur un total de 17 000 locations mobiles**. Il vaut mieux donc ne pas rajouter de délai au risque
    d'insatisfaire un très grand nombre de propriétaires.
    """)

    st.subheader("En conclusion, il vaut mieux donc se concentrer sur les causes d'annulation tierces " \
    "qui représentent près de la moitié du CA perdu")

    st.markdown("""---""")


with tab3:

    st.subheader("Premier constat")
    st.markdown("""
    Les annulations des véhicules précédemment loués ne sont pas liées à un retard, 
    puisque dans **100 cas sur 229 (43%)**, il n'y en a pas.  

    - Sur ce point, il y a donc d'autres causes à aller chercher potentiellement pour *Get Around*, 
    mais qui ne dépendent pas du retard de la précédente location.  
    - Cela restera néanmoins un point important à creuser pour la société afin d'optimiser le CA.  
    - Il est d'ailleurs presque **2 fois plus prononcé sur le connect que sur le mobile**.  
    - Le fait de ne pas avoir à rencontrer le propriétaire favorise peut-être le désengagement du locataire.
    """)


    st.subheader("Second constat")
    st.markdown("""
    Les annulations dans les cas de retard de **1 à 60 minutes** :  

    - Sont **croissantes pour le connect**  
    - Sont **décroissantes pour le mobile**, mais 3 fois plus nombreuses sur le plus petit retard  
    - Représentent **55 cas sur les 129 restants (42% des annulations)**
    """)

  
    st.subheader("Dernier constat")
    st.markdown("""
    Les retards les plus modérés de **1 à 30 minutes** :  

    - Entraînent plus d'annulations sur le **mobile** que sur le **connect**  
    - Représentent **34 cas sur les 129 restants (14% des annulations seulement)**
    """)

    st.markdown("---")

    st.subheader("Première conclusion sur les locations")

    st.markdown("### 📊 Analyse des annulations et facteurs en jeu")

    st.markdown("""
    ❗ Le **facteur temps** (les retards) n’apparaît **pas comme la cause principale** des annulations.  
    ➝ Même avec **60 minutes de retard**, on n’explique que **42% des annulations**.""")  

    st.markdown("🔍 Cela suggère que **d’autres causes majeures** restent à identifier :")  

    st.markdown("""
    - politique tarifaire  
    - offre et concurrence  
    - notifications de disponibilité des véhicules  
    - comportements utilisateurs""")  

    st.markdown("📱 La **méthode de check-in mobile** est un levier à privilégier : elle concerne **80% des locations**.")

    st.markdown("""⚖️ La mise en place d’un délai supplémentaire de disponibilité du véhicule aurait un impact :  
    - sur les **propriétaires** (perte potentielle de visibilité, donc moins de trafic et de revenus)  
    - sur les **locataires** (réduction de l’offre disponible, frustration potentielle)""")

    st.markdown("""💡 Des pistes de solutions à explorer :  
    - sensibilisation des utilisateurs à la ponctualité  
    - notifications de rappel 30 minutes avant la fin de la location  
    - système de bonus/malus  
    - acompte à la réservation pour responsabiliser le locataire  
    - programme de fidélité """) 

    st.markdown(""" 📉 Enfin, il est nécessaire d’évaluer les **pertes potentielles pour les propriétaires**  
    si un délai additionnel est mis en place, surtout pour le mode de location majoritaire.
    """)

    
with tab4:
 
    st.subheader("Découvrez notre estimation du prix de location de votre véhicule !")

    col1, col2 = st.columns(2)

    with col1:
        car_brand = st.selectbox("Marque du véhicule", [
            "Citroën", "Peugeot", "PGO", "Renault", "Audi", "BMW", "Ford", "Mercedes",
            "Opel", "Porsche", "Volkswagen", "KIA Motors", "Alfa Romeo", "Ferrari",
            "Fiat", "Lamborghini", "Maserati", "Lexus", "Honda", "Mazda", "Mini",
            "Mitsubishi", "Nissan", "SEAT", "Subaru", "Suzuki", "Toyota", "Yamaha"
        ])
        mileage = st.number_input("Kilométrage", min_value=0, max_value=400_000, value=100_000)
        engine_power = st.number_input("Puissance du moteur", min_value=10, max_value=300, value=120)
        fuel = st.selectbox("Carburant", ["diesel", "petrol", "hybrid_petrol", "electro"])

    with col2:
        paint_color = st.selectbox("Couleur", ["black", "grey", "white", "red", "silver", "blue",
                                               "orange", "beige", "brown", "green"])
        car_type = st.selectbox("Type de véhicule", ["convertible", "coupe", "estate", "hatchback",
                                                     "sedan", "subcompact", "suv", "van"])
        private_parking_available = st.checkbox("Parking privé disponible")
        has_gps = st.checkbox("GPS")
        has_air_conditioning = st.checkbox("Climatisation")
        automatic_car = st.checkbox("Boîte automatique")
        has_getaround_connect = st.checkbox("Getaround Connect")
        has_speed_regulator = st.checkbox("Régulateur de vitesse")
        winter_tires = st.checkbox("Pneus hiver")

# Bouton pour appeler l'API

    if st.button("Estimation du prix"):
        data = {
            "car_brand": car_brand,
            "mileage": mileage,
            "engine_power": engine_power,
            "fuel": fuel,
            "paint_color": paint_color,
            "car_type": car_type,
            "private_parking_available": private_parking_available,
            "has_gps": has_gps,
            "has_air_conditioning": has_air_conditioning,
            "automatic_car": automatic_car,
            "has_getaround_connect": has_getaround_connect,
            "has_speed_regulator": has_speed_regulator,
            "winter_tires": winter_tires
        }

       
        API_URL = "https://djohell-get-around-api.hf.space/predict"

        try:
            response = requests.post(API_URL, json=data)
            response.raise_for_status()
            prediction = response.json().get("prediction")
            st.success(f"Prix journalier estimé : {prediction} $")

        except requests.exceptions.RequestException as e:
            st.error(f"Erreur lors de l'appel à l'API : {e}")