first_commit

app.py

@@ -0,0 +1,665 @@
+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.title("🚙🚕 Bonjour et bienvenue sur le dashboard du projet Getaround ! 🚗🚑")
+
+st.markdown("""
+             
+A votre disposition 3 rubriques : 
+            
+1. L'analyse des locations : leur type, les retards, les annulations 
+2. L'analyse tarifaire 
+3. Les prédiction par API 
+""")
+
+tab1, tab2, tab3 = st.tabs(["📊⏱ Analyse des locations et retards", "💲Analyse tarifaire", "🔮✨ 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. L'analyse des chiffres 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,
+    title="Distribution des véhicules peu loués (1 à 15 locations)",
+    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. L'Analyse du type de location et des 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 checkin 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 checkin, 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. Analyse des 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")
+    )
+
+# Titre Streamlit
+    st.title("Analyse des locations maintenues malgré un retard")
+
+# Graphique Plotly
+    fig = px.bar(
+    ended_by_delay,
+    x="delay_group",
+    y="nb_ended",
+    color="checkin_type_ended",
+    barmode="group",
+    title="Évolution des locations maintenues selon la durée du retard et le type de check-in",
+    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 maintenue 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('---')
+
+    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.
+    """)
+
+
+
+# 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("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(("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(
+    title="Perte potentielle de CA en fonction du retard",
+    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("""---""")
+
+# Affichage de la matrice de corrélation
+
+    st.subheader("Regardons enfin les corrélations potentielles en vue " \
+    "de la mise en place d'un modèle prédictif")
+
+    bool_features = [
+    "private_parking_available", "has_gps", "has_air_conditioning",
+    "automatic_car", "has_getaround_connect", "has_speed_regulator", "winter_tires",
+    ]
+    price[bool_features] = price[bool_features].astype(int)
+
+    numeric_cols = ["mileage", "engine_power", "rental_price_per_day"] + bool_features
+
+    corr_matrix = price[numeric_cols].corr()
+
+    fig = px.imshow(
+    corr_matrix,
+    text_auto=".2f",
+    color_continuous_scale="RdBu_r",
+    )
+
+    fig.update_layout(
+    width=900,
+    height=700
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    st.subheader("Les principaux facteurs semblent être : la puissance, la boîte de vitesses, " \
+    "la présence de Get Around connect ainsi qu'un parking privé")
+    
+with tab3:
+ 
+    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}")

data/annulation_by_delay.csv

@@ -0,0 +1,15 @@
+delay_group,checkin_type_canceled,nb_annulations
+≤0,connect,66
+≤0,mobile,34
+1-15 min,connect,4
+1-15 min,mobile,13
+15-30 min,connect,9
+15-30 min,mobile,8
+30-60 min,connect,14
+30-60 min,mobile,7
+1-2 h,connect,11
+1-2 h,mobile,9
+2-4 h,connect,8
+2-4 h,mobile,7
+>4 h,connect,9
+>4 h,mobile,7

data/ended_by_delay.csv

@@ -0,0 +1,15 @@
+delay_group,checkin_type_ended,nb_ended
+≤0,connect,421
+≤0,mobile,335
+1-15 min,connect,84
+1-15 min,mobile,119
+15-30 min,connect,37
+15-30 min,mobile,90
+30-60 min,connect,49
+30-60 min,mobile,100
+1-2 h,connect,48
+1-2 h,mobile,115
+2-4 h,connect,24
+2-4 h,mobile,46
+>4 h,connect,7
+>4 h,mobile,47

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+streamlit
+pandas
+plotly
+matplotlib
+seaborn
+scikit-learn
+requests
+openpyxl