Kaynağa Gözat

Prediction nombre de pmr

Nadine Elleuch 1 yıl önce
ebeveyn
işleme
ecc676eea6
1 değiştirilmiş dosya ile 2067 ekleme ve 0 silme
  1. 2067 0
      code_ partie1_prediction.py

+ 2067 - 0
code_ partie1_prediction.py

@@ -0,0 +1,2067 @@
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+from scipy import stats
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from scipy.stats import chi2_contingency
+import requests
+import pandas as pd
+from datetime import datetime, timedelta, date
+import json
+import os
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+import statsmodels.formula.api as smf
+import matplotlib.patheffects as path_effects
+import matplotlib.dates as mdates
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+pd.set_option('display.max_columns', None)
+dataset = 'export_des_missions_2025-06-13_100933-8546-653608357.csv' 
+df = pd.read_csv(dataset, sep=';')
+df
+
+df.describe(include='all')
+
+
+df1=df.copy()
+df1
+
+airports = 'airports.csv' 
+airports = pd.read_csv(airports)
+airports
+
+df_iata_pays = airports[['iata_code', 'iso_country']]
+
+# Supprimer les lignes sans code IATA
+df_iata_pays = df_iata_pays.dropna(subset=['iata_code'])
+
+df_iata_pays
+
+# Renommer les colonnes avant la jointure pour éviter conflits
+df_iata_pays_origin = df_iata_pays.rename(columns={'iata_code': 'Origine', 'iso_country': 'pays_origine'})
+df_iata_pays_dest = df_iata_pays.rename(columns={'iata_code': 'Destination', 'iso_country': 'pays_destination'})
+
+# Merge origine
+df1 = df1.merge(df_iata_pays_origin, on='Origine', how='left')
+
+# Merge destination 
+df1 = df1.merge(df_iata_pays_dest, on='Destination', how='left')
+
+df1
+
+!pip install pycountry
+
+import pycountry
+
+def iso_to_country_name(code):
+    try:
+        return pycountry.countries.get(alpha_2=code).name
+    except:
+        return code
+
+df1['Origine'] = df1['pays_origine'].apply(iso_to_country_name)
+df1['Destination'] = df1['pays_destination'].apply(iso_to_country_name)
+
+df1['code_pays_origine'] = df1['pays_origine']
+df1['code_pays_Destination'] = df1['pays_destination']
+
+df1 = df1.drop(columns=['pays_origine', 'pays_destination'])
+
+df1.head(40)
+
+API_KEY = 'NNPh5mZBBbBTNm6qnvvzI56gY1P339NZ' 
+BASE_URL = 'https://calendarific.com/api/v2/holidays'
+CACHE_FILE = 'cache_feries.json'
+
+df1['date_arrivee'] = pd.to_datetime(df1['ST arrivée'], format='%d/%m/%Y %H:%M', errors='coerce').dt.date
+df1['date_depart'] = pd.to_datetime(df1['ST départ'], format='%d/%m/%Y %H:%M', errors='coerce').dt.date
+
+# Extraction des couples (pays, année) uniques dans origine et destination
+def extract_pays_annee(df1, col_pays, col_date):
+    subset = df1[[col_pays, col_date]].dropna()
+    subset['annee'] = subset[col_date].apply(lambda x: x.year)
+    return set(zip(subset[col_pays], subset['annee']))
+
+pays_annees_origine = extract_pays_annee(df1, 'code_pays_origine', 'date_arrivee')
+pays_annees_destination = extract_pays_annee(df1, 'code_pays_Destination', 'date_depart')
+pays_annees = pays_annees_origine.union(pays_annees_destination)
+
+# Charger le cache depuis fichier JSON
+if os.path.exists(CACHE_FILE):
+    with open(CACHE_FILE, 'r') as f:
+        cache_feries = json.load(f)
+    # Conversion des clés de string à tuple
+    cache_feries = {tuple(k.split(',')): v for k, v in cache_feries.items()}
+    print(f"Cache chargé, {len(cache_feries)} entrées")
+else:
+    cache_feries = {}
+    print("Pas de cache trouvé, nouvelle création")
+
+def save_cache():
+    with open(CACHE_FILE, 'w') as f:
+        json.dump({','.join(k): v for k, v in cache_feries.items()}, f, indent=2)
+
+def fetch_holidays(country_code, year):
+    key = (country_code, str(year))
+    if key in cache_feries:
+        return cache_feries[key]
+    
+    print(f"Appel API pour {country_code} {year}...")
+    params = {
+        'api_key': API_KEY,
+        'country': country_code,
+        'year': year,
+        'type': 'national,religious'  
+    }
+    try:
+        response = requests.get(BASE_URL, params=params)
+        response.raise_for_status()
+        holidays = response.json()['response']['holidays']
+        data = [
+            {
+                'date': h['date']['iso'], 
+                'name': h['name'],
+                'type': ','.join(h.get('type', []))  
+            } for h in holidays
+        ]
+        cache_feries[key] = data
+        save_cache()
+        return data
+    except Exception as e:
+        print(f"Erreur API pour {country_code} {year} : {e}")
+        return []
+
+# Remplissage complet du cache (pour les pays/années manquants)
+for (pays, annee) in pays_annees:
+    fetch_holidays(pays, annee)
+
+def check_holiday(date, country_code):
+    if pd.isna(date) or pd.isna(country_code):
+        return False, None, None
+    key = (country_code, str(date.year))
+    holidays = cache_feries.get(key, [])
+    for h in holidays:
+        if h['date'] == date.isoformat():
+            return True, h['name'], h['type']
+    return False, None, None
+
+df1[['ferie_origine', 'fete_origine', 'type_fete_origine']] = df1.apply(
+    lambda row: pd.Series(check_holiday(row['date_arrivee'], row['code_pays_origine'])),
+    axis=1
+)
+df1[['ferie_destination', 'fete_destination', 'type_fete_destination']] = df1.apply(
+    lambda row: pd.Series(check_holiday(row['date_depart'], row['code_pays_Destination'])),
+    axis=1
+)
+
+df1.head(30)  
+
+# Fonction d'alerte popup dans Jupyter 
+def notify_jupyter(message):
+    from IPython.display import display, Javascript
+    js_code = f'alert("{message}");'
+    display(Javascript(js_code))
+
+def check_tomorrow_feries(df):
+    demain = datetime.now().date() + timedelta(days=1)
+    
+    # Extraire tous les codes pays à vérifier (origine + destination)
+    pays_origine = df['code_pays_origine'].dropna().unique()
+    pays_destination = df['code_pays_Destination'].dropna().unique()
+    pays_a_verifier = set(pays_origine).union(pays_destination)
+
+    alerts = []
+    for pays in pays_a_verifier:
+        is_ferie, nom, type_fete = check_holiday(demain, pays)
+        if is_ferie:
+            alerts.append(f"{demain.isoformat()} - {pays} : {nom} ({type_fete})")
+
+    if alerts:
+        message = "Jour(s) férié(s) demain :\n" + "\n".join(alerts)
+        print(message)
+        notify_jupyter(message)
+    else:
+        print(f"Aucun jour férié demain ({demain.isoformat()}) pour les pays dans le dataframe.")
+
+
+check_tomorrow_feries(df1)
+
+
+#planifier tache : cron job(linux) / task scheduler(windows)
+def check_holiday_for_date(check_date, country_code):
+    if not check_date or not country_code:
+        return False, None, None
+    key = (country_code, str(check_date.year))
+    holidays = cache_feries.get(key, [])
+    if not holidays:
+        holidays = fetch_holidays(country_code, check_date.year)
+    for h in holidays:
+        if h['date'] == check_date.isoformat():
+            return True, h['name'], h['type']
+    return False, None, None
+
+date_test = date(2025, 6, 6)  
+pays_origine = 'DE'
+pays_destination = 'TN'
+
+ferie_origine, nom_origine, type_origine = check_holiday_for_date(date_test, pays_origine)
+
+ferie_destination, nom_destination, type_destination = check_holiday_for_date(date_test, pays_destination)
+
+print(f"Date : {date_test}")
+print(f"Pays origine ({pays_origine}) : {'Férié' if ferie_origine else 'Non férié'} - {nom_origine} ({type_origine})")
+print(f"Pays destination ({pays_destination}) : {'Férié' if ferie_destination else 'Non férié'} - {nom_destination} ({type_destination})")
+
+# Nombre de PMR par Origine
+pmr_par_origine = df1.groupby('Origine').size().reset_index(name='Nombre_PMR')
+print(pmr_par_origine)
+
+pmr_par_origine_sorted = pmr_par_origine.sort_values(by='Nombre_PMR', ascending=False)
+
+data_to_plot = pmr_par_origine_sorted.copy()
+
+# barplot
+plt.figure(figsize=(max(20, len(data_to_plot) * 0.25), 10))  # ajuster automatiquement la largeur
+
+sns.barplot(data=data_to_plot, x='Origine', y='Nombre_PMR', palette='Blues_d')
+
+plt.title("Nombre de PMR par origine", fontsize=18)
+plt.xlabel("origine", fontsize=14)
+plt.ylabel("Nombre de PMR", fontsize=14)
+plt.xticks(rotation=90, fontsize=9)
+plt.yticks(fontsize=12)
+plt.grid(axis='y', linestyle='--', alpha=0.7)
+
+plt.tight_layout()
+plt.show()
+
+
+# Nombre de PMR par Origine
+pmr_par_destination = df1.groupby('Destination').size().reset_index(name='Nombre_PMR')
+print(pmr_par_destination)
+
+pmr_par_destination_sorted = pmr_par_destination.sort_values(by='Nombre_PMR', ascending=False)
+
+data_to_plot = pmr_par_destination_sorted.copy()
+
+# barplot
+plt.figure(figsize=(max(20, len(data_to_plot) * 0.25), 10)) 
+
+sns.barplot(data=data_to_plot, x='Destination', y='Nombre_PMR', palette='Blues_d')
+
+plt.title("Nombre de PMR par Destination", fontsize=18)
+plt.xlabel("Destination", fontsize=14)
+plt.ylabel("Nombre de PMR", fontsize=14)
+plt.xticks(rotation=90, fontsize=9)
+plt.yticks(fontsize=12)
+plt.grid(axis='y', linestyle='--', alpha=0.7)
+
+plt.tight_layout()
+plt.show()
+
+
+# test ANOVA (Analyse de la Variance) 
+
+# une ligne = un pmr
+df1['PMR'] = 1  
+
+# Tester si l'Origine est significative
+model_origine = ols('PMR ~ C(Origine)', data=df1).fit()
+anova_origine = sm.stats.anova_lm(model_origine, typ=2)
+print("ANOVA pour Origine :")
+print(anova_origine)
+
+# Tester si la Destination est significative
+model_destination = ols('PMR ~ C(Destination)', data=df1).fit()
+anova_destination = sm.stats.anova_lm(model_destination, typ=2)
+print("\nANOVA pour Destination :")
+print(anova_destination)
+
+
+# tester la dépendance entre Origine et Destination
+
+contingency_table = pd.crosstab(df1['Origine'], df1['Destination'])
+
+# Test du Chi²
+chi2, p, dof, expected = chi2_contingency(contingency_table)
+
+print("Chi² :", chi2)
+print("Degrés de liberté :", dof)
+print("P-value :", p)
+
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+plt.figure(figsize=(20, 10))
+sns.heatmap(contingency_table, cmap='Blues')
+plt.title('Heatmap Origine vs Destination')
+plt.xlabel('Destination')
+plt.ylabel('Origine')
+plt.show()
+
+
+df1['Origine'] = df1['Origine'].fillna('').str.strip()
+df1['Destination'] = df1['Destination'].fillna('').str.strip()
+
+# Détection des cas
+entree_et_reste = df1[(df1['Origine'] != '') & (df1['Destination'] == '')]
+sortie_seulement = df1[(df1['Origine'] == '') & (df1['Destination'] != '')]
+escale = df1[(df1['Origine'] != '') & (df1['Destination'] != '')]
+
+# Labels et valeurs
+labels = ['Entrée et restée en France', 'Sortie uniquement de France', 'Escale']
+counts = [len(entree_et_reste), len(sortie_seulement), len(escale)]
+total = len(df1)
+percentages = [round(c / total * 100, 2) for c in counts]
+
+#  graphe
+plt.figure(figsize=(9, 6))
+bars = plt.bar(labels, counts, color=['#b0e0e6', '#add8e6', '#aec6cf'])
+plt.title('Répartition des passagers via la France')
+plt.ylabel('Nombre de passagers')
+plt.xticks(rotation=15)
+plt.grid(axis='y', linestyle='', alpha=0.7)
+
+# Ajout des valeurs + %
+for bar, count, perc in zip(bars, counts, percentages):
+    plt.text(bar.get_x() + bar.get_width()/2,
+             bar.get_height() + total*0.001,  # un peu au-dessus
+             f'{count} ({perc}%)',
+             ha='center', va='bottom', fontsize=10, fontweight='bold')
+
+plt.tight_layout()
+plt.show()
+
+
+# Création de la variable 'org_dest'
+def type_passage(row):
+    if row['Origine'] != '' and row['Destination'] == '':
+        return '0' # entrée en France
+    elif row['Origine'] == '' and row['Destination'] != '':
+        return '1' # sortie de France
+    elif row['Origine'].upper() != 'FRANCE' and row['Destination'].upper() != 'FRANCE':
+        return '2' #escaleF
+   
+df1['org_dest'] = df1.apply(type_passage, axis=1)
+df1 = df1.drop(columns=['PMR'])
+
+df1.head(40)
+
+
+
+contingency_table = df1['org_dest'].value_counts().sort_index()
+
+print(contingency_table)
+
+table = pd.DataFrame({'PMR_count': contingency_table})
+chi2, p, dof, expected = chi2_contingency([table['PMR_count'], expected := [table['PMR_count'].sum() / 3] * 3])
+
+print(f"\nChi2 = {chi2:.2f}, p-value = {p:.4f}")
+
+
+# Conversion en datetime avec dayfirst=True (car format jour/mois/année)
+df1['ST arrivée'] = pd.to_datetime(df1['ST arrivée'], dayfirst=True)
+df1['ST départ'] = pd.to_datetime(df1['ST départ'], dayfirst=True)
+
+# Extraction jour de la semaine (0=lundi, 6=dimanche)
+df1['jour_semaine_entree'] = df1['ST arrivée'].dt.dayofweek
+df1['jour_semaine_depart'] = df1['ST départ'].dt.dayofweek
+
+# Format HH:MM 
+df1['heure_entree'] = df1['ST arrivée'].dt.strftime('%H:%M')
+df1['heure_depart'] = df1['ST départ'].dt.strftime('%H:%M')
+
+# Mois : Janvier, Février, etc.
+df1['mois_entree'] = df1['ST arrivée'].dt.month_name()
+df1['mois_depart'] = df1['ST départ'].dt.month_name()
+
+df1.head()
+
+
+# Mapper les numéros de jours (0 à 6) en noms
+jours = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']
+df1['jour_nom_entree'] = df1['jour_semaine_entree'].map(dict(enumerate(jours)))
+df1['jour_nom_depart'] = df1['jour_semaine_depart'].map(dict(enumerate(jours)))
+
+def countplot_avec_valeurs(data, colonne, ordre, titre, xlabel, ylabel):
+    plt.figure(figsize=(10, 4))
+    ax = sns.countplot(data=data, x=colonne, order=ordre)
+    plt.title(titre)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.xticks(rotation=45)
+    
+    # Ajouter les valeurs au-dessus des barres
+    for p in ax.patches:
+        hauteur = p.get_height()
+        ax.text(p.get_x() + p.get_width() / 2., hauteur + 3,  # +3 pour décoller un peu du sommet
+                int(hauteur), ha='center', fontsize=10)
+    
+    plt.tight_layout()
+    plt.show()
+
+countplot_avec_valeurs(df1, 'jour_nom_entree', jours,
+                       'Répartition des entrées par jour de la semaine',
+                       'Jour de la semaine', 'Nombre d\'entrées')
+
+countplot_avec_valeurs(df1, 'jour_nom_depart', jours,
+                       'Répartition des départs par jour de la semaine',
+                       'Jour de la semaine', 'Nombre de départs')
+
+
+mois_ordre = ['January', 'February', 'March', 'April', 'May', 'June',
+              'July', 'August', 'September', 'October', 'November', 'December']
+
+# Filtrer les mois présents dans la colonne 'mois_entree' et 'mois_depart'
+mois_ordre_entree = [m for m in mois_ordre if m in df1['mois_entree'].unique()]
+mois_ordre_depart = [m for m in mois_ordre if m in df1['mois_depart'].unique()]
+
+def countplot_avec_valeurs(data, colonne, ordre, titre, xlabel, ylabel):
+    plt.figure(figsize=(10, 4))
+    ax = sns.countplot(data=data, x=colonne, order=ordre)
+    plt.title(titre)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.xticks(rotation=45)
+
+    for p in ax.patches:
+        hauteur = p.get_height()
+        ax.text(p.get_x() + p.get_width() / 2., hauteur + 3,
+                int(hauteur), ha='center', fontsize=10)
+
+    plt.tight_layout()
+    plt.show()
+
+# Répartition par mois d'entrée
+countplot_avec_valeurs(df1, 'mois_entree', mois_ordre_entree,
+                       'Répartition des entrées par mois',
+                       'Mois', 'Nombre d\'entrées')
+
+# Répartition par mois de départ
+countplot_avec_valeurs(df1, 'mois_depart', mois_ordre_depart,
+                       'Répartition des départs par mois',
+                       'Mois', 'Nombre de départs')
+
+
+
+API_URL = "https://iata-and-icao-codes.p.rapidapi.com/airlines"
+HEADERS = {
+    "x-rapidapi-key": "9bd1fe1013mshfef01143800e2cbp18a39ejsnfa4b363d6392",
+    "x-rapidapi-host": "iata-and-icao-codes.p.rapidapi.com"
+}
+
+response = requests.get(API_URL, headers=HEADERS)
+
+if response.status_code == 200:
+    data = response.json()
+    airlines_df = pd.DataFrame(data)
+
+    # Renommer les colonnes pour faciliter la fusion
+    airlines_arr = airlines_df.rename(columns={'iata_code': 'Code Cie arrivée', 'name': 'nom_compagnie_arr'})
+    airlines_dest = airlines_df.rename(columns={'iata_code': 'Code Cie départ', 'name': 'nom_compagnie_dest'})
+
+    df1 = df1.merge(airlines_arr[['Code Cie arrivée', 'nom_compagnie_arr']], on='Code Cie arrivée', how='left')
+
+    df1 = df1.merge(airlines_dest[['Code Cie départ', 'nom_compagnie_dest']], on='Code Cie départ', how='left')
+
+    # Dictionnaire de corrections manuelles si certaines compagnies manquent dans l'API
+    corrections = {
+        'EZY': 'easyJet',
+        'EJU': 'easyJet Europe',
+        'VF': 'Volotea',
+        'ENT': 'Enter Air',
+        'N0': 'Norwegian Air Sweden'
+    }
+
+    for code, name in corrections.items():
+        df1.loc[df1['Code Cie arrivée'] == code, 'nom_compagnie_arr'] = name
+        df1.loc[df1['Code Cie départ'] == code, 'nom_compagnie_dest'] = name
+
+    # Formatage final : Nom (Code)
+    df1['nom_compagnie_arr'] = df1.apply(
+        lambda row: f"{row['nom_compagnie_arr']} ({row['Code Cie arrivée']})"
+        if pd.notna(row['nom_compagnie_arr']) else row['Code Cie arrivée'],
+        axis=1
+    )
+
+    df1['nom_compagnie_dest'] = df1.apply(
+        lambda row: f"{row['nom_compagnie_dest']} ({row['Code Cie départ']})"
+        if pd.notna(row['nom_compagnie_dest']) else row['Code Cie départ'],
+        axis=1
+    )
+
+    df1[['Code Cie arrivée', 'nom_compagnie_arr', 'Code Cie départ', 'nom_compagnie_dest']].head(40)
+
+else:
+    print(f"Erreur API: code {response.status_code}")
+
+
+
+# Associer chaque vol à sa compagnie 
+compagnie_par_vol_arr = df1.groupby(['Num Vol arrivée'])['nom_compagnie_arr'].first()
+compagnie_par_vol_dep = df1.groupby(['Num Vol départ'])['nom_compagnie_dest'].first()
+
+# Compter le nombre de vols uniques par compagnie (arrivée et départ)
+nb_vols_uniques_arr = compagnie_par_vol_arr.value_counts().sort_values(ascending=False)
+nb_vols_uniques_dep = compagnie_par_vol_dep.value_counts().sort_values(ascending=False)
+
+fig, axes = plt.subplots(1, 2, figsize=(18, 6))
+
+# ARRIVÉE
+sns.barplot(x=nb_vols_uniques_arr.index, y=nb_vols_uniques_arr.values,
+            palette="Blues_d", ax=axes[0])
+axes[0].set_title("Vols uniques par compagnie (arrivée)")
+axes[0].set_xlabel("Compagnie")
+axes[0].set_ylabel("Nombre de vols uniques")
+axes[0].tick_params(axis='x', rotation=90)
+for i, v in enumerate(nb_vols_uniques_arr.values):
+    axes[0].text(i, v + 0.5, str(v), ha='center', fontsize=8)
+
+# DÉPART
+sns.barplot(x=nb_vols_uniques_dep.index, y=nb_vols_uniques_dep.values,
+            palette="Greens_d", ax=axes[1])
+axes[1].set_title("Vols uniques par compagnie (départ)")
+axes[1].set_xlabel("Compagnie")
+axes[1].set_ylabel("Nombre de vols uniques")
+axes[1].tick_params(axis='x', rotation=90)
+for i, v in enumerate(nb_vols_uniques_dep.values):
+    axes[1].text(i, v + 0.5, str(v), ha='center', fontsize=8)
+
+plt.tight_layout()
+plt.show()
+
+
+
+
+# Comptage des compagnies à l’arrivée
+compte_arr = df1['nom_compagnie_arr'].value_counts()
+
+# Comptage des compagnies au départ
+compte_dep = df1['nom_compagnie_dest'].value_counts()
+
+def ajouter_valeurs_barres(ax, valeurs):
+    for i, v in enumerate(valeurs):
+        ax.text(i, v + max(valeurs)*0.01, str(v), ha='center', va='bottom', fontsize=9)
+
+# ARRIVÉE
+plt.figure(figsize=(15, 6))
+ax1 = sns.barplot(x=compte_arr.index, y=compte_arr.values, palette='Blues_d')
+plt.title("Nombre de PMR par compagnie aérienne à l’arrivée")
+plt.xlabel("Compagnie")
+plt.ylabel("Nombre total PMR par compagnie")
+plt.xticks(rotation=90)
+ajouter_valeurs_barres(ax1, compte_arr.values)
+plt.tight_layout()
+plt.show()
+
+# DÉPART
+plt.figure(figsize=(15, 6))
+ax2 = sns.barplot(x=compte_dep.index, y=compte_dep.values, palette='Greens_d')
+plt.title("Nombre de PMR par compagnie aérienne départ")
+plt.xlabel("Compagnie")
+plt.ylabel("Nombre Total PMR")
+plt.xticks(rotation=90)
+ajouter_valeurs_barres(ax2, compte_dep.values)
+plt.tight_layout()
+plt.show()
+
+
+# Nombre de PMR par vol arrivée
+pmr_par_vol_arrivee = df1.groupby('Num Vol arrivée').size().sort_values(ascending=False)
+
+# Compagnie associée à chaque vol arrivée
+compagnie_par_vol_arrivee = df1.groupby('Num Vol arrivée')['nom_compagnie_arr'].first()
+
+df_vols_arrivee = pd.DataFrame({
+    'nombre_pmr': pmr_par_vol_arrivee,
+    'compagnie': compagnie_par_vol_arrivee
+}).dropna()  # <-- Important pour éviter NaN
+
+# Moyenne PMR par vol par compagnie arrivée
+moyenne_pmr_par_compagnie_arrivee = (
+    df_vols_arrivee.groupby('compagnie')['nombre_pmr']
+    .mean()
+    .sort_values(ascending=False)
+)
+
+# Nombre de PMR par vol arrivée
+
+plt.figure(figsize=(18, 6))
+sns.barplot(x=pmr_par_vol_arrivee.index.astype(str), y=pmr_par_vol_arrivee.values, palette='Blues_d')
+plt.title("Nombre de PMR par vol arrivée")
+plt.xlabel("Vol arrivée (CodeCie_NumVol)")
+plt.ylabel("Nombre de PMR")
+plt.xticks(rotation=90)
+
+for i, v in enumerate(pmr_par_vol_arrivee.values):
+    if pd.notna(v) and pd.notnull(v):  # Vérification
+        plt.text(i, v + 0.5, str(int(v)), ha='center', fontsize=8)
+
+plt.tight_layout()
+plt.show()
+
+# Moyenne PMR par vol par compagnie arrivée 
+
+plt.figure(figsize=(15, 6))
+sns.barplot(x=moyenne_pmr_par_compagnie_arrivee.index, y=moyenne_pmr_par_compagnie_arrivee.values, palette='coolwarm')
+plt.title("Moyenne de PMR par vol par compagnie (arrivée)")
+plt.xlabel("Compagnie")
+plt.ylabel("Moyenne PMR par vol")
+plt.xticks(rotation=90)
+
+for i, v in enumerate(moyenne_pmr_par_compagnie_arrivee.values):
+    if pd.notna(v) and pd.notnull(v):  # Vérification
+        plt.text(i, v + 0.05, f"{v:.2f}", ha='center', fontsize=10)
+
+plt.tight_layout()
+plt.show()
+
+
+
+# Nombre de PMR par vol départ 
+pmr_par_vol_depart = df1.groupby([ 'Num Vol départ']).size().sort_values(ascending=False)
+
+compagnie_par_vol_depart = df1.groupby([ 'Num Vol départ'])['nom_compagnie_dest'].first()
+
+df_vols_depart = pd.DataFrame({
+    'nombre_pmr': pmr_par_vol_depart,
+    'compagnie': compagnie_par_vol_depart
+})
+
+# Calcul moyenne PMR par vol par compagnie départ
+moyenne_pmr_par_compagnie_depart = df_vols_depart.groupby('compagnie')['nombre_pmr'].mean().sort_values(ascending=False)
+
+#  Nombre PMR par vol départ 
+
+plt.figure(figsize=(18, 6))
+sns.barplot(x=pmr_par_vol_depart.index, y=pmr_par_vol_depart.values, palette='Greens_d')
+plt.title("Nombre de PMR par vol départ")
+plt.xlabel("Vol départ (CodeCie_NumVol)")
+plt.ylabel("Nombre de PMR")
+plt.xticks(rotation=90)
+
+for i, v in enumerate(pmr_par_vol_depart.values):
+    plt.text(i, v + 0.5, str(v), ha='center', fontsize=8)
+
+plt.tight_layout()
+plt.show()
+
+# Moyenne PMR par vol par compagnie départ
+
+plt.figure(figsize=(15, 6))
+sns.barplot(x=moyenne_pmr_par_compagnie_depart.index, y=moyenne_pmr_par_compagnie_depart.values, palette='coolwarm')
+plt.title("Moyenne de PMR par vol par compagnie (départ)")
+plt.xlabel("Compagnie")
+plt.ylabel("Moyenne PMR par vol")
+plt.xticks(rotation=90)
+
+for i, v in enumerate(moyenne_pmr_par_compagnie_depart.values):
+    plt.text(i, v + 0.05, f"{v:.2f}", ha='center', fontsize=10)
+
+plt.tight_layout()
+plt.show()
+
+
+# Calcul PMR par vol arrivée 
+pmr_par_vol_arrivee = df1.groupby('Num Vol arrivée').size().reset_index(name='nombre_pmr')
+compagnie_arr = df1.groupby('Num Vol arrivée')['nom_compagnie_arr'].first().reset_index()
+df_vols_arrivee = pmr_par_vol_arrivee.merge(compagnie_arr, on='Num Vol arrivée')
+
+# Calcul PMR par vol départ
+pmr_par_vol_depart = df1.groupby('Num Vol départ').size().reset_index(name='nombre_pmr')
+compagnie_dep = df1.groupby('Num Vol départ')['nom_compagnie_dest'].first().reset_index()
+df_vols_depart = pmr_par_vol_depart.merge(compagnie_dep, on='Num Vol départ')
+
+# ANOVA arrivée
+modele_arr = ols('nombre_pmr ~ C(nom_compagnie_arr)', data=df_vols_arrivee).fit()
+anova_arr = sm.stats.anova_lm(modele_arr, typ=2)
+print("ANOVA - nombre PMR par compagnie (arrivée) :")
+print(anova_arr)
+
+# Tukey HSD arrivée
+tukey_arr = pairwise_tukeyhsd(endog=df_vols_arrivee['nombre_pmr'],
+                              groups=df_vols_arrivee['nom_compagnie_arr'],
+                              alpha=0.05)
+print(tukey_arr.summary())
+tukey_arr.plot_simultaneous()
+plt.title('Tukey HSD - PMR par compagnie (arrivée)')
+plt.show()
+
+# --- ANOVA départ ---
+modele_dep = ols('nombre_pmr ~ C(nom_compagnie_dest)', data=df_vols_depart).fit()
+anova_dep = sm.stats.anova_lm(modele_dep, typ=2)
+print("ANOVA - nombre PMR par compagnie (départ) :")
+print(anova_dep)
+
+# Tukey HSD départ
+tukey_dep = pairwise_tukeyhsd(endog=df_vols_depart['nombre_pmr'],
+                              groups=df_vols_depart['nom_compagnie_dest'],
+                              alpha=0.05)
+print(tukey_dep.summary())
+tukey_dep.plot_simultaneous()
+plt.title('Tukey HSD - PMR par compagnie (départ)')
+plt.show()
+
+
+# Calcul du nombre de PMR par compagnie à l'arrivée
+pmr_arr = df1['nom_compagnie_arr'].value_counts(dropna=False).reset_index()
+pmr_arr.columns = ['compagnie', 'total_pmr']
+
+# Calcul de la distribution cumulée (en excluant NaN dans le calcul)
+pmr_arr_nonan = pmr_arr[pmr_arr['compagnie'].notna()].copy()
+pmr_arr_nonan['cumsum'] = pmr_arr_nonan['total_pmr'].cumsum() / pmr_arr_nonan['total_pmr'].sum()
+
+# Identifier les compagnies représentant 80% des PMR
+top_80_arr = pmr_arr_nonan[pmr_arr_nonan['cumsum'] <= 0.8]['compagnie'].tolist()
+
+# Créer une nouvelle colonne dans df1 avec regroupement
+def simplify_compagnie(x):
+    if pd.isna(x):
+        return x  # garder NaN tel quel
+    elif x in top_80_arr:
+        return x
+    else:
+        return 'Other'
+
+df1['compagnie_arr_simplifiée'] = df1['nom_compagnie_arr'].apply(simplify_compagnie)
+
+# Recompter les PMR par compagnie simplifiée (y compris NaN)
+pmr_arr_grouped = df1['compagnie_arr_simplifiée'].value_counts(dropna=False).reset_index()
+pmr_arr_grouped.columns = ['compagnie', 'total_pmr']
+
+# Nettoyer pour le graphique : enlever NaN
+pmr_arr_grouped_clean = pmr_arr_grouped[pmr_arr_grouped['compagnie'].notna()]
+
+# Garder seulement le top 80, exclure 'Other'
+pmr_arr_top = pmr_arr_grouped_clean[pmr_arr_grouped_clean['compagnie'] != 'Other']
+
+# Tracer la courbe avec uniquement le top 80, sans 'Other'
+plt.figure(figsize=(12, 6))
+plt.bar(pmr_arr_top['compagnie'], pmr_arr_top['total_pmr'], color='steelblue')
+plt.title("Top compagnies représentant 80% des PMR à l'arrivée")
+plt.xlabel("Compagnie aérienne")
+plt.ylabel("Nombre de PMR")
+plt.xticks(rotation=90)
+plt.tight_layout()
+plt.show()
+
+
+# Calcul du nombre de PMR par compagnie à la destination (en comptant aussi les NaN)
+pmr_dest = df1['nom_compagnie_dest'].value_counts(dropna=False).reset_index()
+pmr_dest.columns = ['compagnie', 'total_pmr']
+
+# Calcul de la distribution cumulée (sur les compagnies non NaN)
+pmr_dest_nonan = pmr_dest[pmr_dest['compagnie'].notna()]
+pmr_dest_nonan.loc[:, 'cumsum'] = pmr_dest_nonan['total_pmr'].cumsum() / pmr_dest_nonan['total_pmr'].sum()
+
+# Identifier les compagnies représentant 80% des PMR à la destination
+top_80_dest = pmr_dest_nonan[pmr_dest_nonan['cumsum'] <= 0.8]['compagnie'].tolist()
+
+# Fonction pour simplifier la colonne des compagnies à la destination
+def simplify_compagnie_dest(x):
+    if pd.isna(x):
+        return x  # garder NaN tel quel
+    elif x in top_80_dest:
+        return x
+    else:
+        return 'Other'
+
+df1['compagnie_dest_simplifiée'] = df1['nom_compagnie_dest'].apply(simplify_compagnie_dest)
+
+# Recompter les PMR par compagnie simplifiée à la destination (avec NaN)
+pmr_dest_grouped = df1['compagnie_dest_simplifiée'].value_counts(dropna=False).reset_index()
+pmr_dest_grouped.columns = ['compagnie', 'total_pmr']
+
+# Filtrer pour le graphique : garder seulement le top 80, exclure 'Other' et NaN
+pmr_dest_top = pmr_dest_grouped[
+    (pmr_dest_grouped['compagnie'] != 'Other') &
+    (pmr_dest_grouped['compagnie'].notna())
+]
+
+# Tracer la courbe avec uniquement le top 80, sans 'Other'
+plt.figure(figsize=(12, 6))
+plt.bar(pmr_dest_top['compagnie'], pmr_dest_top['total_pmr'], color='steelblue')
+plt.title("Top compagnies représentant 80% des PMR à la destination")
+plt.xlabel("Compagnie aérienne")
+plt.ylabel("Nombre de PMR")
+plt.xticks(rotation=90)
+plt.tight_layout()
+plt.show()
+
+
+df1
+
+def time_to_minutes(t):
+    try:
+        if pd.isna(t):
+            return np.nan
+        h, m = map(int, t.split(':'))
+        return h * 60 + m
+    except Exception:
+        return np.nan
+
+# encodage cyclique (sin/cos) 
+def encode_cyclic_period(period_idx, total_periods=58):
+    if np.isnan(period_idx):
+        return np.nan, np.nan
+    angle = 2 * np.pi * period_idx / total_periods
+    return np.sin(angle), np.cos(angle)
+
+# Conversion heures vers minutes
+df1['minutes_entree'] = df1['heure_entree'].apply(time_to_minutes)
+df1['minutes_depart'] = df1['heure_depart'].apply(time_to_minutes)
+
+# Calcul des périodes entières (58 périodes de 24.83 minutes environ) 
+periode_duration = 1440 / 58  # ≈ 24.8276 min
+df1['periode_entree'] = df1['minutes_entree'].apply(
+    lambda x: int(x // periode_duration) if not np.isnan(x) else np.nan)
+df1['periode_depart'] = df1['minutes_depart'].apply(
+    lambda x: int(x // periode_duration) if not np.isnan(x) else np.nan)
+
+# Encodage cyclique
+df1[['periode_entree_sin', 'periode_entree_cos']] = df1['periode_entree'].apply(
+    lambda x: pd.Series(encode_cyclic_period(x)))
+df1[['periode_depart_sin', 'periode_depart_cos']] = df1['periode_depart'].apply(
+    lambda x: pd.Series(encode_cyclic_period(x)))
+
+df1
+
+
+plt.figure(figsize=(8, 8))
+plt.title("Visualisation encodage cyclique des heures (arrivée et départ)")
+
+# Scatter points
+plt.scatter(df1['periode_entree_cos'], df1['periode_entree_sin'], color='blue', label='Heure Arrivée', alpha=0.6)
+plt.scatter(df1['periode_depart_cos'], df1['periode_depart_sin'], color='red', label='Heure Départ', alpha=0.6)
+
+# Circle
+circle = plt.Circle((0, 0), 1, color='grey', fill=False, linestyle='--')
+plt.gca().add_artist(circle)
+
+def annotated_text(x, y, text, color):
+    txt = plt.text(x, y, text, fontsize=10, color=color, fontweight='bold')
+    txt.set_path_effects([path_effects.Stroke(linewidth=2, foreground='white'), path_effects.Normal()])
+
+# periodes Unique entrée
+unique_entree_periods = df1['periode_entree'].dropna().unique()
+for periode in unique_entree_periods:
+    periode = int(periode)
+    minutes = periode * 25
+    h = minutes // 60
+    m = minutes % 60
+    # Calculate cos and sin for the label position (radius a bit > 1 for visibility)
+    angle = 2 * np.pi * (periode / 58)
+    x = 1.1 * np.cos(angle)
+    y = 1.1 * np.sin(angle)
+    annotated_text(x, y, f"{h:02d}h{m:02d}", 'blue')
+
+#  periodes Unique départ
+unique_depart_periods = df1['periode_depart'].dropna().unique()
+for periode in unique_depart_periods:
+    periode = int(periode)
+    minutes = periode * 25
+    h = minutes // 60
+    m = minutes % 60
+    angle = 2 * np.pi * (periode / 58)
+    x = 1.2 * np.cos(angle)  # Slightly farther out to not overlap entrée labels
+    y = 1.2 * np.sin(angle)
+    annotated_text(x, y, f"{h:02d}h{m:02d}", 'red')
+
+plt.xlabel('Cosinus')
+plt.ylabel('Sinus')
+plt.legend()
+plt.grid(True)
+plt.axis('equal')
+plt.tight_layout()
+plt.show()
+
+
+entree_counts = df1['periode_entree'].dropna().astype(int).value_counts().sort_index()
+depart_counts = df1['periode_depart'].dropna().astype(int).value_counts().sort_index()
+
+# Fusionner dans un même index
+all_indices = sorted(set(entree_counts.index).union(depart_counts.index))
+entree = [entree_counts.get(i, 0) for i in all_indices]
+depart = [depart_counts.get(i, 0) for i in all_indices]
+
+# Créer les labels combinés (indice + heure)
+def indice_to_hour_str(indice):
+    total_minutes = indice * 25
+    h = total_minutes // 60
+    m = total_minutes % 60
+    return f"{indice:02d} ({h:02d}h{m:02d})"
+
+horaire_labels = [indice_to_hour_str(i) for i in all_indices]
+
+# Positions des barres
+x = np.arange(len(all_indices))
+width = 0.4
+
+# Barplot
+plt.figure(figsize=(14, 6))
+plt.bar(x - width/2, entree, width=width, label='Arrivée', color='blue')
+plt.bar(x + width/2, depart, width=width, label='Départ', color='red')
+
+plt.xlabel("Indice de période (tranche de 25 minutes)")
+plt.ylabel("Nombre de PMR")
+plt.title("Nombre d'arrivées et de départs par tranche horaire")
+plt.xticks(x, horaire_labels, rotation=90)
+plt.legend()
+plt.grid(True, axis='y', linestyle='--', alpha=0.7)
+plt.tight_layout()
+plt.show()
+
+
+# Extraire le jour de la semaine pour arrivée et départ
+df1['jour_semaine_arrivee'] = df1['ST arrivée'].dt.day_name()
+df1['jour_semaine_depart'] = df1['ST départ'].dt.day_name()
+
+# Compter le nombre de PMR par jour de la semaine (arrivée)
+pmr_arrivee_sem = df1.groupby('jour_semaine_arrivee').size().reindex(
+    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+)
+
+# Compter le nombre de PMR par jour de la semaine (départ)
+pmr_depart_sem = df1.groupby('jour_semaine_depart').size().reindex(
+    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+)
+
+# Créer un DataFrame pour faciliter le tracé
+df_sem = pd.DataFrame({
+    'Arrivées': pmr_arrivee_sem,
+    'Départs': pmr_depart_sem
+})
+
+df_sem.plot(kind='bar', figsize=(10,5), color=['skyblue', 'salmon'])
+
+plt.title("Nombre total de PMR par jour de la semaine (Arrivées vs Départs)")
+plt.ylabel("Nombre de PMR")
+plt.xlabel("Jour de la semaine")
+plt.xticks(rotation=45)
+plt.grid(axis='y')
+plt.tight_layout()
+plt.show()
+
+
+# Grouper par date uniquement 
+pmr_par_jour_arrivee = df1.groupby(df1['ST arrivée'].dt.date).size()
+pmr_par_jour_depart = df1.groupby(df1['ST départ'].dt.date).size()
+
+# Tracer les courbes
+plt.figure(figsize=(12, 6))
+plt.plot(pmr_par_jour_arrivee.index, pmr_par_jour_arrivee.values, marker='o', linestyle='-', color='blue', label='Arrivées')
+plt.plot(pmr_par_jour_depart.index, pmr_par_jour_depart.values, marker='o', linestyle='-', color='red', label='Départs')
+
+plt.title("Évolution du nombre de PMR par jour (Arrivées vs Départs)")
+plt.xlabel("Date")
+plt.ylabel("Nombre de PMR")
+plt.legend()
+plt.grid(True)
+
+# Rendre l'axe X plus clair avec format date
+ax = plt.gca()
+ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))  
+plt.xticks(rotation=45)
+
+plt.tight_layout()
+plt.show()
+
+
+df1['ST arrivée arrondie'] = df1['ST arrivée'].dt.floor('25min')
+df1['ST départ arrondie'] = df1['ST départ'].dt.floor('25min')
+
+pmr_par_25min_arrivee = df1.groupby('ST arrivée arrondie').size()
+pmr_par_25min_depart = df1.groupby('ST départ arrondie').size()
+
+
+plt.figure(figsize=(14, 6))
+plt.plot(pmr_par_25min_arrivee.index, pmr_par_25min_arrivee.values, label='Arrivées', marker='o')
+plt.plot(pmr_par_25min_depart.index, pmr_par_25min_depart.values, label='Départs', marker='o')
+
+plt.title("Nombre de PMR par tranche de 25 minutes")
+plt.xlabel("Date et heure")
+plt.ylabel("Nombre de PMR")
+
+ax = plt.gca()
+ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
+ax.xaxis.set_major_locator(mdates.HourLocator(interval=1))  # tick every 1 hour
+
+plt.xticks(rotation=45)
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.show()
+
+
+df1 = df1.drop(columns=['jour_nom_entree', 'jour_nom_depart', 'minutes_entree'	,'minutes_depart'	,'periode_entree',	'periode_depart','jour_semaine_arrivee','ST arrivée arrondie',	'ST départ arrondie'])
+
+
+df1
+
+colonnes_details = [
+    'Detail SORTI', 'Detail MEET-RPI', 'Detail ELB', 'Detail MEETR-A',
+    'Detail MEETL-A', 'Detail MEET-LIEU', 'Detail MEET-BNQ', 'Detail MEET-ACC',
+    'Detail PEMB', 'Detail MEET-EMB', 'Detail MEETR-D', 'Detail MEETL-D', 'Detail MEET-COR'
+]
+
+for col in colonnes_details:
+    print(f"\n--- {col} ---")
+    print(df1[col].value_counts(dropna=False))  # dropna=False pour aussi voir les NaN
+    print(df1[col].value_counts(dropna=False, normalize=True).round(3) * 100)  # pourcentage
+
+
+# nouvelle colonne binaire : 1 si "NO SHOW", 0 sinon
+df1['no_show'] = df1[['Detail SORTI', 'Detail MEETR-A', 'Detail MEETL-A','Detail MEET-ACC']].apply(
+    lambda row: 'NO SHOW' in row.values, axis=1).astype(int)
+
+# compagnie à l'arrivée
+no_show_by_company = df1.groupby('nom_compagnie_arr')['no_show'].agg(['count', 'sum'])
+no_show_by_company['taux_no_show'] = no_show_by_company['sum'] / no_show_by_company['count']
+no_show_by_company = no_show_by_company.sort_values('taux_no_show', ascending=False)
+
+plt.figure(figsize=(12, 6))
+plt.bar(no_show_by_company.index[:20], no_show_by_company['taux_no_show'][:20], color='tomato')
+plt.xticks(rotation=90)
+plt.title("Taux de NO SHOW par compagnie (Top 20)")
+plt.ylabel("Taux de NO SHOW")
+plt.xlabel("Compagnie aérienne")
+plt.tight_layout()
+plt.show()
+
+
+# Table de contingence entre compagnie et no_show
+contingency_table = pd.crosstab(df1['nom_compagnie_arr'], df1['no_show'])
+chi2, p, dof, expected = chi2_contingency(contingency_table)
+print(f"Chi² statistic : {chi2:.2f}")
+print(f"Degrees of freedom : {dof}")
+print(f"P-value : {p:.5f}")
+
+if p < 0.05:
+    print("✅ Il existe une relation significative entre la compagnie aérienne et le NO SHOW (on rejette H0).")
+else:
+    print("❌ Aucune relation significative détectée (on ne peut pas rejeter H0).")
+
+
+# nouvelle colonne binaire : 1 si "NO SHOW" dans l'une des colonnes sélectionnées, 0 sinon
+df1['no_show'] = df1[['Detail SORTI', 'Detail MEETR-A', 'Detail MEETL-A', 'Detail MEET-ACC']].apply(
+    lambda row: 'NO SHOW' in row.values, axis=1).astype(int)
+
+# compagnie à la destination
+no_show_by_company_dest = df1.groupby('nom_compagnie_dest')['no_show'].agg(['count', 'sum'])
+no_show_by_company_dest['taux_no_show'] = no_show_by_company_dest['sum'] / no_show_by_company_dest['count']
+no_show_by_company_dest = no_show_by_company_dest.sort_values('taux_no_show', ascending=False)
+
+plt.figure(figsize=(12, 6))
+plt.bar(no_show_by_company_dest.index[:20], no_show_by_company_dest['taux_no_show'][:20], color='tomato')
+plt.xticks(rotation=90)
+plt.title("Taux de NO SHOW par compagnie à la destination (Top 20)")
+plt.ylabel("Taux de NO SHOW")
+plt.xlabel("Compagnie aérienne")
+plt.tight_layout()
+plt.show()
+
+
+signal_counts = df['Statut signalement arrivée'].value_counts()
+
+plt.figure(figsize=(10,6))
+ax = signal_counts.plot(kind='bar', color='skyblue')
+plt.title("Répartition des demandes d'assistance par délai de signalement")
+plt.ylabel("Nombre de demandes")
+plt.xlabel("Statut signalement arrivée")
+plt.xticks(rotation=45, ha='right')
+
+# Ajouter les nombres au-dessus des barres
+for p in ax.patches:
+    height = p.get_height()
+    ax.text(p.get_x() + p.get_width() / 2, height + 5,  # 5 = décalage vertical au-dessus
+            f'{int(height)}', ha='center')
+
+plt.tight_layout()
+plt.show()
+
+
+df1['Statut signalement arrivée'] = df['Statut signalement arrivée'].fillna('Non précisé')
+
+# Grouper par signalement et calculer le taux moyen de no-show
+no_show_by_signal = df1.groupby('Statut signalement arrivée')['no_show'].mean().sort_values()
+
+plt.figure(figsize=(10, 6))
+no_show_by_signal.plot(kind='bar', color='salmon')
+plt.ylabel("Taux de no-show")
+plt.title("Taux de no-show selon le moment du signalement de l’assistance")
+plt.xticks(rotation=45)
+plt.grid(axis='y')
+plt.tight_layout()
+plt.show()
+
+
+print(df1['Statut signalement arrivée'].unique())
+
+# Nettoyage des valeurs
+df1['Statut signalement arrivée'] = df1['Statut signalement arrivée'].replace({
+    '<1h': '<6h',
+    '<2h': '<6h',
+    '<6h': '<6h',
+    'N.A': 'Non précisé',
+    np.nan: 'Non précisé'
+})
+
+
+from pandas.api.types import CategoricalDtype
+
+ordre = CategoricalDtype(
+    categories=['<6h', '<12h', '<24h', '<36h', '>36h'],
+    ordered=True
+)
+
+df1['Statut signalement arrivée'] = df1['Statut signalement arrivée'].astype(ordre)
+df1['Signalement_encoded'] = df1['Statut signalement arrivée'].cat.codes
+
+
+df1
+
+# Trier par nombre de passagers
+passagers_par_vol_date = df1.groupby(['Code Cie arrivée', 'ST arrivée']).size().reset_index(name='nb_passagers')
+top_vols = passagers_par_vol_date.sort_values(by='nb_passagers', ascending=False).head(10)
+
+
+plt.figure(figsize=(12, 6))
+bars = plt.barh(
+    top_vols['Code Cie arrivée'] + ' - ' + top_vols['ST arrivée'].astype(str),
+    top_vols['nb_passagers'],
+    color='skyblue'
+)
+
+plt.xlabel("Nombre de passagers")
+plt.title("Top 10 des vols avec le plus de passagers")
+
+for bar in bars:
+    width = bar.get_width()
+    plt.text(width + 1, bar.get_y() + bar.get_height()/2, str(int(width)), va='center')
+
+plt.gca().invert_yaxis()
+plt.tight_layout()
+plt.show()
+
+
+df1['ST arrivée'] = pd.to_datetime(df1['ST arrivée'], errors='coerce')
+
+df1['tranche_25min_arr'] = df1['ST arrivée'].dt.floor('25min')
+
+pmr_arrivee_25min = df1.groupby(['tranche_25min_arr']).size().reset_index(name='pmr_total')
+
+
+df1['ST départ'] = pd.to_datetime(df1['ST départ'], errors='coerce')
+
+# Arrondir à la tranche de 25 minutes
+df1['tranche_25min_depart'] = df1['ST départ'].dt.floor('25min')
+
+# Grouper par tranche et compter les PMR
+pmr_depart_25min = df1.groupby(['tranche_25min_depart']).size().reset_index(name='pmr_total')
+
+
+pmr_arrivee_25min = pmr_arrivee_25min.rename(columns={'tranche_25min_arr': 'tranche_25min'})
+pmr_depart_25min = pmr_depart_25min.rename(columns={'tranche_25min_depart': 'tranche_25min'})
+
+pmr_merged = pd.merge(
+    pmr_arrivee_25min,
+    pmr_depart_25min,
+    on='tranche_25min',
+    how='outer',
+    suffixes=('_arrivee', '_depart')
+)
+
+# Remplacer les NaN par 0
+pmr_merged['pmr_total_arrivee'] = pmr_merged['pmr_total_arrivee'].fillna(0).astype(int)
+pmr_merged['pmr_total_depart'] = pmr_merged['pmr_total_depart'].fillna(0).astype(int)
+
+pmr_merged['total'] = pmr_merged['pmr_total_arrivee'] + pmr_merged['pmr_total_depart']
+
+pmr_merged = pmr_merged.sort_values('tranche_25min').reset_index(drop=True)
+
+pmr_merged[['tranche_25min', 'pmr_total_arrivee', 'pmr_total_depart', 'total']]
+pmr_merged = pmr_merged.rename(columns={'total': 'pmr_total'})
+pmr_merged
+
+#df1=df1[['org_dest', 'ST arrivée',	'ST départ','mois_entree'	,'mois_depart','periode_entree_sin',	'periode_entree_cos'	,'periode_depart_sin',	'periode_depart_cos','no_show','compagnie_arr_encoded','compagnie_dest_encoded']]
+df1
+
+df1['jour_semaine_entree'] = df1['ST arrivée'].dt.weekday
+df1['jour_semaine_entree_sin'] = np.sin(2 * np.pi * df1['jour_semaine_entree'] / 7)
+df1['jour_semaine_entree_cos'] = np.cos(2 * np.pi * df1['jour_semaine_entree'] / 7)
+
+df1['jour_semaine_depart'] = df1['ST départ'].dt.weekday
+df1['jour_semaine_depart_sin'] = np.sin(2 * np.pi * df1['jour_semaine_depart'] / 7)
+df1['jour_semaine_depart_cos'] = np.cos(2 * np.pi * df1['jour_semaine_depart'] / 7)
+
+
+print(df1[pd.to_numeric(df1['mois_entree'], errors='coerce').isna()]['mois_entree'].unique())
+print(df1[pd.to_numeric(df1['mois_depart'], errors='coerce').isna()]['mois_depart'].unique())
+
+mois_map = {
+    'janvier': 1, 'février': 2, 'mars': 3, 'avril': 4,
+    'mai': 5, 'juin': 6, 'juillet': 7, 'août': 8,
+    'septembre': 9, 'octobre': 10, 'novembre': 11, 'décembre': 12
+}
+
+df1['mois_entree'] = df1['mois_entree'].str.lower().str.strip().map(mois_map)
+df1['mois_depart'] = df1['mois_depart'].str.lower().str.strip().map(mois_map)
+
+
+df1
+
+df1['mois_entree_sin'] = np.sin(2 * np.pi * df1['mois_entree'] / 12)
+df1['mois_entree_cos'] = np.cos(2 * np.pi * df1['mois_entree'] / 12)
+
+df1['mois_depart_sin'] = np.sin(2 * np.pi * df1['mois_depart'] / 12)
+df1['mois_depart_cos'] = np.cos(2 * np.pi * df1['mois_depart'] / 12)
+
+
+#df1 = df1.drop(columns=['mois_entree',	'mois_depart'	,'ST arrivée','ST départ','mois_entree','mois_depart','jour_semaine_entree', 'jour_semaine_depart','mois_entree_sin',	'mois_entree_cos'	,'mois_depart_sin'	,'mois_depart_cos'], errors='ignore')
+df1
+
+df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
+df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
+
+# Nombre de vols uniques par compagnie à l’arrivée par tranche
+arrivee_grouped = (
+    df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Code Cie arrivée']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
+arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
+
+# Nombre de vols uniques par compagnie au départ par tranche
+depart_grouped = (
+    df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Code Cie départ']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
+depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
+
+pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
+
+# Fusion avec les données arrivées et départs
+df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
+df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
+df_final.fillna(0, inplace=True)
+
+# Nombre total de vols uniques (arrivée + départ) par tranche
+arrivee_total = (
+    df1.groupby('tranche_arrivee')['Code Cie arrivée']
+    .nunique()
+    .reset_index(name='nb_vols_arrivee')
+    .rename(columns={'tranche_arrivee': 'tranche_25min'})
+)
+
+depart_total = (
+    df1.groupby('tranche_depart')['Code Cie départ']
+    .nunique()
+    .reset_index(name='nb_vols_depart')
+    .rename(columns={'tranche_depart': 'tranche_25min'})
+)
+
+vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
+vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
+
+# Fusion avec le total des vols
+df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
+df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
+
+df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
+df_final['is_weekend'] = df_final['jourSemaine'].isin([5,6]).astype(int)
+df_final = df_final.drop(columns=['pmr_total_arrivee', 'pmr_total_depart'], errors='ignore')
+
+cols = df_final.columns.tolist()
+for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine', 'is_weekend']:
+    if col in cols:
+        cols.remove(col)
+
+new_cols_order = ['tranche_25min', 'jourSemaine', 'is_weekend', 'nb_vols_total'] + cols + ['pmr_total']
+
+df_final = df_final[new_cols_order]
+
+df_final.head(10)
+
+
+df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
+df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
+
+# Nombre de vols uniques par compagnie à l’arrivée par tranche
+arrivee_grouped = (
+    df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Num Vol arrivée']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
+arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
+
+# Nombre de vols uniques par compagnie au départ par tranche
+depart_grouped = (
+    df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Num Vol départ']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
+depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
+
+# PMR à l’arrivée par tranche et compagnie (nombre d'occurrences)
+pmr_arrivee = (
+    df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])
+    .size()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+pmr_arrivee.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
+pmr_arrivee.columns = ['tranche_25min'] + [f"pmr_arrivee_{col}" for col in pmr_arrivee.columns[1:]]
+
+# PMR au départ par tranche et compagnie
+pmr_depart = (
+    df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])
+    .size()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+pmr_depart.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
+pmr_depart.columns = ['tranche_25min'] + [f"pmr_depart_{col}" for col in pmr_depart.columns[1:]]
+
+pmr_merged = pd.merge(pmr_arrivee, pmr_depart, on='tranche_25min', how='outer').fillna(0)
+pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
+
+df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
+df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
+df_final.fillna(0, inplace=True)
+
+arrivee_total = (
+    df1.groupby('tranche_arrivee')['Num Vol arrivée']
+    .nunique()
+    .reset_index(name='nb_vols_arrivee')
+    .rename(columns={'tranche_arrivee': 'tranche_25min'})
+)
+
+depart_total = (
+    df1.groupby('tranche_depart')['Num Vol départ']
+    .nunique()
+    .reset_index(name='nb_vols_depart')
+    .rename(columns={'tranche_depart': 'tranche_25min'})
+)
+
+vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
+vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
+
+df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
+df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
+
+pmr_cols = [col for col in df_final.columns if col.startswith('pmr_arrivee_') or col.startswith('pmr_depart_')]
+df_final['pmr_total'] = df_final[pmr_cols].sum(axis=1)
+
+df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
+
+df_final = df_final.drop(columns=['pmr_total_arrivee', 'pmr_total_depart'], errors='ignore')
+
+cols = df_final.columns.tolist()
+for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine']:
+    if col in cols:
+        cols.remove(col)
+
+new_cols_order = ['tranche_25min', 'jourSemaine',  'nb_vols_total'] + cols + ['pmr_total']
+df_final = df_final[new_cols_order]
+
+df_final.head(10)
+
+
+import requests
+import pandas as pd
+
+API_KEY = 'NNPh5mZBBbBTNm6qnvvzI56gY1P339NZ'
+BASE_URL = 'https://calendarific.com/api/v2/holidays'
+
+def get_holidays_for_year_with_names(year, country='FR'):
+    params = {
+        'api_key': API_KEY,
+        'country': country,
+        'year': year
+    }
+    response = requests.get(BASE_URL, params=params)
+    data = response.json()
+    holidays = {}
+    if data['meta']['code'] == 200:
+        for holiday in data['response']['holidays']:
+            date_iso = holiday['date']['iso']  # format yyyy-mm-dd
+            name = holiday['name']
+            holidays[date_iso] = name
+    else:
+        print(f"Erreur API pour l'année {year}:", data['meta'].get('error_detail', 'Erreur inconnue'))
+    return holidays
+
+# Préparation des tranches 25 minutes dans df1 (exemple avec tes colonnes)
+df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
+df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
+
+# Nombre de vols uniques par compagnie à l’arrivée par tranche
+arrivee_grouped = (
+    df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Num Vol arrivée']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
+arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
+
+# Nombre de vols uniques par compagnie au départ par tranche
+depart_grouped = (
+    df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Num Vol départ']
+    .nunique()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
+depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
+
+# PMR à l’arrivée par tranche et compagnie
+pmr_arrivee = (
+    df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])
+    .size()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+pmr_arrivee.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
+pmr_arrivee.columns = ['tranche_25min'] + [f"pmr_arrivee_{col}" for col in pmr_arrivee.columns[1:]]
+
+# PMR au départ par tranche et compagnie
+pmr_depart = (
+    df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])
+    .size()
+    .unstack(fill_value=0)
+    .reset_index()
+)
+pmr_depart.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
+pmr_depart.columns = ['tranche_25min'] + [f"pmr_depart_{col}" for col in pmr_depart.columns[1:]]
+
+# Fusion des PMR arrivee et depart
+pmr_merged = pd.merge(pmr_arrivee, pmr_depart, on='tranche_25min', how='outer').fillna(0)
+pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
+
+# Fusion des données vols et pmr
+df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
+df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
+df_final.fillna(0, inplace=True)
+
+# Calcul du nombre total de vols par tranche
+arrivee_total = (
+    df1.groupby('tranche_arrivee')['Num Vol arrivée']
+    .nunique()
+    .reset_index(name='nb_vols_arrivee')
+    .rename(columns={'tranche_arrivee': 'tranche_25min'})
+)
+
+depart_total = (
+    df1.groupby('tranche_depart')['Num Vol départ']
+    .nunique()
+    .reset_index(name='nb_vols_depart')
+    .rename(columns={'tranche_depart': 'tranche_25min'})
+)
+
+vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
+vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
+
+df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
+df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
+
+pmr_cols = [col for col in df_final.columns if col.startswith('pmr_arrivee_') or col.startswith('pmr_depart_')]
+df_final['pmr_total'] = df_final[pmr_cols].sum(axis=1)
+
+df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
+
+cols = df_final.columns.tolist()
+for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine']:
+    if col in cols:
+        cols.remove(col)
+new_cols_order = ['tranche_25min', 'jourSemaine', 'nb_vols_total'] + cols + ['pmr_total']
+df_final = df_final[new_cols_order]
+
+# holiday_name
+
+years = df_final['tranche_25min'].dt.year.unique()
+
+all_holidays = {}
+for year in years:
+    holidays_for_year = get_holidays_for_year_with_names(year, country='FR')
+    all_holidays.update(holidays_for_year)
+
+df_final['date_str'] = df_final['tranche_25min'].dt.strftime('%Y-%m-%d')
+
+df_final['holiday_name'] = df_final['date_str'].map(all_holidays).fillna('')
+
+df_final.drop(columns=['date_str'], inplace=True)
+
+df_final.head(10)
+
+
+df_final
+
+df_final['minutes'] = df_final['tranche_25min'].dt.hour * 60 + df_final['tranche_25min'].dt.minute
+df_final['tranche_num'] = df_final['minutes'] // 25
+max_tranche = 24 * 60 // 25
+
+df_final['tranche_sin'] = np.sin(2 * np.pi * df_final['tranche_num'] / max_tranche)
+df_final['tranche_cos'] = np.cos(2 * np.pi * df_final['tranche_num'] / max_tranche)
+
+max_jour = 7
+df_final['jour_sin'] = np.sin(2 * np.pi * df_final['jourSemaine'] / max_jour)
+df_final['jour_cos'] = np.cos(2 * np.pi * df_final['jourSemaine'] / max_jour)
+
+# Supprime les colonnes originales si nécessaire
+df_final = df_final.drop(columns=['tranche_25min', 'jourSemaine'])
+
+
+df_final
+
+
+
+X = df_final.drop(columns=['pmr_total'])
+y = df_final['pmr_total']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+rf = RandomForestRegressor(n_estimators=100, random_state=42)
+
+rf.fit(X_train, y_train)
+
+y_pred = rf.predict(X_test)
+
+mae = mean_absolute_error(y_test, y_pred)
+rmse = mean_squared_error(y_test, y_pred, squared=False)
+
+print(f"MAE: {mae:.2f}")
+print(f"RMSE: {rmse:.2f}")
+
+
+ordered_columns = [
+    "nb_vols_total",
+    "pmr_arrivee_Aer Lingus (EI)",
+    "pmr_arrivee_Air Algerie (AH)",
+    "pmr_arrivee_Air Canada (AC)",
+    "pmr_arrivee_Air China (CA)",
+    "pmr_arrivee_Air France (AF)",
+    "pmr_arrivee_Air India (AI)",
+    "pmr_arrivee_Air Senegal (HC)",
+    "pmr_arrivee_Air Tahiti Nui (TN)",
+    "pmr_arrivee_American Airlines (AA)",
+    "pmr_arrivee_Asiana Airlines (OZ)",
+    "pmr_arrivee_Avianca (AV)",
+    "pmr_arrivee_Brussels Airlines (SN)",
+    "pmr_arrivee_Cathay Pacific (CX)",
+    "pmr_arrivee_EL AL (LY)",
+    "pmr_arrivee_Emirates (EK)",
+    "pmr_arrivee_Etihad Airways (EY)",
+    "pmr_arrivee_LATAM Chile (LA)",
+    "pmr_arrivee_Lufthansa (LH)",
+    "pmr_arrivee_Norwegian Air Sweden (N0)",
+    "pmr_arrivee_Nouvelair (BJ)",
+    "pmr_arrivee_Other",
+    "pmr_arrivee_PIA (PK)",
+    "pmr_arrivee_Qatar Airways (QR)",
+    "pmr_arrivee_SAS Scandinavian (SK)",
+    "pmr_arrivee_Singapore Airlines (SQ)",
+    "pmr_arrivee_SunExpress (XQ)",
+    "pmr_arrivee_Turkish Airlines (TK)",
+    "pmr_arrivee_United Airlines (UA)",
+    "pmr_arrivee_Volotea (VF)",
+    "pmr_arrivee_easyJet (EZY)",
+    "pmr_arrivee_easyJet Europe (EJU)",
+    "pmr_depart_Air Algerie (AH)",
+    "pmr_depart_Air Canada (AC)",
+    "pmr_depart_Air France (AF)",
+    "pmr_depart_Air India (AI)",
+    "pmr_depart_Air Senegal (HC)",
+    "pmr_depart_Alitalia (AZ)",
+    "pmr_depart_American Airlines (AA)",
+    "pmr_depart_Avianca (AV)",
+    "pmr_depart_British Airways (BA)",
+    "pmr_depart_Brussels Airlines (SN)",
+    "pmr_depart_EL AL (LY)",
+    "pmr_depart_Emirates (EK)",
+    "pmr_depart_Ethiopian Airlines (ET)",
+    "pmr_depart_Jet2.com (LS)",
+    "pmr_depart_Lufthansa (LH)",
+    "pmr_depart_Nouvelair (BJ)",
+    "pmr_depart_Other",
+    "pmr_depart_Qatar Airways (QR)",
+    "pmr_depart_Royal Air Maroc (AT)",
+    "pmr_depart_SunExpress (XQ)",
+    "pmr_depart_Turkish Airlines (TK)",
+    "pmr_depart_United Airlines (UA)",
+    "pmr_depart_Volotea (VF)",
+    "pmr_depart_easyJet (EZY)",
+    "pmr_depart_easyJet Europe (EJU)",
+    "arrivee_Aer Lingus (EI)",
+    "arrivee_Air Algerie (AH)",
+    "arrivee_Air Canada (AC)",
+    "arrivee_Air China (CA)",
+    "arrivee_Air France (AF)",
+    "arrivee_Air India (AI)",
+    "arrivee_Air Senegal (HC)",
+    "arrivee_Air Tahiti Nui (TN)",
+    "arrivee_American Airlines (AA)",
+    "arrivee_Asiana Airlines (OZ)",
+    "arrivee_Avianca (AV)",
+    "arrivee_Brussels Airlines (SN)",
+    "arrivee_Cathay Pacific (CX)",
+    "arrivee_EL AL (LY)",
+    "arrivee_Emirates (EK)",
+    "arrivee_Etihad Airways (EY)",
+    "arrivee_LATAM Chile (LA)",
+    "arrivee_Lufthansa (LH)",
+    "arrivee_Norwegian Air Sweden (N0)",
+    "arrivee_Nouvelair (BJ)",
+    "arrivee_Other",
+    "arrivee_PIA (PK)",
+    "arrivee_Qatar Airways (QR)",
+    "arrivee_SAS Scandinavian (SK)",
+    "arrivee_Singapore Airlines (SQ)",
+    "arrivee_SunExpress (XQ)",
+    "arrivee_Turkish Airlines (TK)",
+    "arrivee_United Airlines (UA)",
+    "arrivee_Volotea (VF)",
+    "arrivee_easyJet (EZY)",
+    "arrivee_easyJet Europe (EJU)",
+    "depart_Air Algerie (AH)",
+    "depart_Air Canada (AC)",
+    "depart_Air France (AF)",
+    "depart_Air India (AI)",
+    "depart_Air Senegal (HC)",
+    "depart_Alitalia (AZ)",
+    "depart_American Airlines (AA)",
+    "depart_Avianca (AV)",
+    "depart_British Airways (BA)",
+    "depart_Brussels Airlines (SN)",
+    "depart_EL AL (LY)",
+    "depart_Emirates (EK)",
+    "depart_Ethiopian Airlines (ET)",
+    "depart_Jet2.com (LS)",
+    "depart_Lufthansa (LH)",
+    "depart_Nouvelair (BJ)",
+    "depart_Other",
+    "depart_Qatar Airways (QR)",
+    "depart_Royal Air Maroc (AT)",
+    "depart_SunExpress (XQ)",
+    "depart_Turkish Airlines (TK)",
+    "depart_United Airlines (UA)",
+    "depart_Volotea (VF)",
+    "depart_easyJet (EZY)",
+    "depart_easyJet Europe (EJU)",
+    "minutes",
+    "tranche_num",
+    "tranche_sin",
+    "tranche_cos",
+    "jour_sin",
+    "jour_cos"
+]
+
+
+def generate_pmr(size):
+    return np.random.poisson(lam=2, size=size)
+
+n_samples = 1000  
+
+pmr_arrivee_cols = [c for c in ordered_columns if c.startswith("pmr_arrivee_")]
+pmr_depart_cols = [c for c in ordered_columns if c.startswith("pmr_depart_")]
+arrivee_cols = [c for c in ordered_columns if c.startswith("arrivee_")]
+depart_cols = [c for c in ordered_columns if c.startswith("depart_")]
+
+data = {}
+
+data["nb_vols_total"] = np.random.randint(0, 50, size=n_samples)
+
+for col in pmr_arrivee_cols:
+    data[col] = generate_pmr(n_samples)
+
+for col in pmr_depart_cols:
+    data[col] = generate_pmr(n_samples)
+
+for col in arrivee_cols + depart_cols:
+    # Binary 0/1 for arrival/departure presence flags
+    data[col] = np.random.choice([0, 1], size=n_samples)
+
+data["minutes"] = np.random.randint(0, 1440, size=n_samples)
+
+data["tranche_num"] = data["minutes"] // 25
+
+data["tranche_sin"] = np.sin(2 * np.pi * data["tranche_num"] / 96)
+data["tranche_cos"] = np.cos(2 * np.pi * data["tranche_num"] / 96)
+
+jour_num = np.random.randint(0, 7, size=n_samples)
+
+data["jour_sin"] = np.sin(2 * np.pi * jour_num / 7)
+data["jour_cos"] = np.cos(2 * np.pi * jour_num / 7)
+
+import pandas as pd
+df = pd.DataFrame(data)
+
+df = df[ordered_columns]
+
+pmr_pred = rf.predict(df)
+
+for tranche, pred in zip(data['tranche_num'], pmr_pred):
+    start_minute = tranche * 25
+    end_minute = (tranche + 1) * 25 - 1
+    start_hour, start_min = divmod(start_minute, 60)
+    end_hour, end_min = divmod(end_minute, 60)
+    print(f"Tranche {tranche} ({start_hour:02d}:{start_min:02d} - {end_hour:02d}:{end_min:02d}): Prédiction PMR = {pred:.2f}")
+
+
+import requests
+import pandas as pd
+import numpy as np
+
+API_KEY = "OaVTBoRzf6lvHiOkYr8UFhNg06CGGdB6"
+
+# Fonction qui récupère la liste des jours fériés d'une année pour un pays
+def get_holidays_for_year_country(year, country_code):
+    url = "https://calendarific.com/api/v2/holidays"
+    params = {
+        'api_key': API_KEY,
+        'country': country_code,
+        'year': year,
+        'type': 'national,religious'  # tu peux ajuster le type si besoin
+    }
+    response = requests.get(url, params=params)
+    if response.status_code != 200:
+        print(f"Erreur API pour {year} - {country_code}: {response.status_code}")
+        return set()
+    holidays = response.json().get('response', {}).get('holidays', [])
+    # Extraire les dates ISO (YYYY-MM-DD) dans un set pour accès rapide
+    holiday_dates = set(hol['date']['iso'] for hol in holidays)
+    return holiday_dates
+
+df['ST arrivée'] = pd.to_datetime(df['ST arrivée'], errors='coerce')
+
+df['year_arrivee'] = df['ST arrivée'].dt.year
+unique_year_country = df[['year_arrivee', 'code_pays_origine']].dropna().drop_duplicates()
+
+# Dictionnaire pour stocker les jours fériés par (année, pays)
+holidays_map = {}
+
+for idx, row in unique_year_country.iterrows():
+    year = int(row['year_arrivee'])
+    country = row['code_pays_origine']
+    holidays_map[(year, country)] = get_holidays_for_year_country(year, country)
+
+# Fonction pour vérifier si la date est un jour férié via le mapping
+def is_holiday_mapped(row):
+    if pd.isnull(row['ST arrivée']) or pd.isnull(row['code_pays_origine']):
+        return False
+    key = (row['ST arrivée'].year, row['code_pays_origine'])
+    date_str = row['ST arrivée'].strftime('%Y-%m-%d')
+    return date_str in holidays_map.get(key, set())
+
+df['jour_ferie_arrivee'] = df.apply(is_holiday_mapped, axis=1)
+
+df.drop(columns=['year_arrivee'], inplace=True)
+
+def encode_cyclique_time(dt_series):
+    minutes = dt_series.dt.hour.fillna(0) * 60 + dt_series.dt.minute.fillna(0)
+    minutes_in_day = 24 * 60
+    sin_time = np.sin(2 * np.pi * minutes / minutes_in_day)
+    cos_time = np.cos(2 * np.pi * minutes / minutes_in_day)
+    return sin_time, cos_time
+
+df['sin_ST_arrivee'], df['cos_ST_arrivee'] = encode_cyclique_time(df['ST arrivée'])
+df['jour_sem_arrivee'] = df['ST arrivée'].dt.dayofweek
+
+features_pmr = [
+    'Num Vol arrivée', 
+    'Code Cie arrivée', 
+    'code_pays_origine',
+    'Origine', 
+    'jour_sem_arrivee',
+    'sin_ST_arrivee', 'cos_ST_arrivee',
+    'jour_ferie_arrivee'  
+]
+
+df_volArr = df[features_pmr].dropna().copy()
+
+df_volArr.head(30)
+
+
+!pip install lightgbm
+
+pip install catboost
+
+import pandas as pd
+import numpy as np
+import requests
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score
+from lightgbm import LGBMRegressor
+from catboost import CatBoostRegressor, Pool
+from sklearn.metrics import confusion_matrix, accuracy_score, ConfusionMatrixDisplay
+import matplotlib.pyplot as plt
+
+API_KEY = "OaVTBoRzf6lvHiOkYr8UFhNg06CGGdB6"
+
+def get_holidays_for_year_country(year, country_code):
+    url = "https://calendarific.com/api/v2/holidays"
+    params = {
+        'api_key': API_KEY,
+        'country': country_code,
+        'year': year,
+        'type': 'national,religious'
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        print(f"Erreur API pour {year} - {country_code}: {e}")
+        return set()
+    
+    holidays = response.json().get('response', {}).get('holidays', [])
+    return set(hol['date']['iso'] for hol in holidays if 'date' in hol and 'iso' in hol['date'])
+
+def encode_cyclique_time(dt_series):
+    hours = dt_series.dt.hour.fillna(0)
+    minutes = dt_series.dt.minute.fillna(0)
+    total_minutes = hours * 60 + minutes
+    minutes_in_day = 24 * 60
+    sin_time = np.sin(2 * np.pi * total_minutes / minutes_in_day)
+    cos_time = np.cos(2 * np.pi * total_minutes / minutes_in_day)
+    return sin_time, cos_time
+
+def prepare_data():
+    local_csv_path = "export_des_missions_2025-06-13_100933-8546-653608357.csv"
+    cols_to_keep = ['Num Vol arrivée', 'Num Vol départ', 'Code Cie arrivée', 'Code Cie départ',
+                    'Origine', 'Destination', 'ST départ', 'ST arrivée']
+    df = pd.read_csv(local_csv_path, sep=';')
+    df = df[cols_to_keep].copy()
+
+    df['ST arrivée'] = pd.to_datetime(df['ST arrivée'], errors='coerce')
+    df['ST départ'] = pd.to_datetime(df['ST départ'], errors='coerce')
+
+    airports = pd.read_csv('airports.csv')
+    df_iata_pays = airports[['iata_code', 'iso_country']].dropna(subset=['iata_code'])
+
+    df_iata_pays_origin = df_iata_pays.rename(columns={'iata_code': 'Origine', 'iso_country': 'code_pays_origine'})
+    df_iata_pays_dest = df_iata_pays.rename(columns={'iata_code': 'Destination', 'iso_country': 'code_pays_destination'})
+
+    df = df.merge(df_iata_pays_origin, on='Origine', how='left')
+    df = df.merge(df_iata_pays_dest, on='Destination', how='left')
+
+    pmr_depart = df.groupby('Num Vol départ').size().reset_index(name='pmr_total_depart')
+    pmr_arrivee = df.groupby('Num Vol arrivée').size().reset_index(name='pmr_total_arrivee')
+
+    df_depart = df[['Num Vol départ', 'Code Cie départ', 'Origine', 'Destination', 'ST départ', 'code_pays_destination']].copy()
+    df_arrivee = df[['Num Vol arrivée', 'Code Cie arrivée', 'Origine', 'Destination', 'ST arrivée', 'code_pays_origine']].copy()
+
+    df_depart = df_depart.merge(pmr_depart, on='Num Vol départ', how='left')
+    df_arrivee = df_arrivee.merge(pmr_arrivee, on='Num Vol arrivée', how='left')
+
+    df_depart.rename(columns={
+        'Num Vol départ': 'Num Vol',
+        'Code Cie départ': 'Code Cie',
+        'ST départ': 'ST',
+        'code_pays_destination': 'code_pays',
+        'pmr_total_depart': 'pmr total'
+    }, inplace=True)
+
+    df_arrivee.rename(columns={
+        'Num Vol arrivée': 'Num Vol',
+        'Code Cie arrivée': 'Code Cie',
+        'ST arrivée': 'ST',
+        'code_pays_origine': 'code_pays',
+        'pmr_total_arrivee': 'pmr total'
+    }, inplace=True)
+
+    df_depart['type_vol'] = 'depart'
+    df_arrivee['type_vol'] = 'arrivee'
+
+    df_depart = df_depart[df_depart['Num Vol'].notna() & (df_depart['Num Vol'] != '')]
+    df_arrivee = df_arrivee[df_arrivee['Num Vol'].notna() & (df_arrivee['Num Vol'] != '')]
+
+    df_vols = pd.concat([df_depart, df_arrivee], ignore_index=True)
+    df_vols = df_vols.drop_duplicates(subset=['Num Vol'])
+
+    df_vols['Trajet'] = df_vols.apply(
+        lambda row: row['Destination'] if row['type_vol'] == 'depart' else row['Origine'],
+        axis=1
+    )
+
+    df_vols['ST'] = pd.to_datetime(df_vols['ST'], errors='coerce')
+    df_vols['Origine'] = df_vols['Origine'].fillna('')
+    df_vols['Destination'] = df_vols['Destination'].fillna('')
+    df_vols['code_pays'] = df_vols['code_pays'].fillna('')
+    
+
+    # Compter le nombre de vols par jour
+    frequence_vol_par_jour = df_vols.groupby(['Num Vol']).size().rename('frequence_vol_par_jour')
+    df_vols = df_vols.merge(frequence_vol_par_jour, on='Num Vol', how='left')
+
+
+
+    unique_year_country = df_vols[['ST', 'code_pays']].dropna()
+    unique_year_country['year'] = unique_year_country['ST'].dt.year
+    unique_year_country = unique_year_country[['year', 'code_pays']].drop_duplicates()
+
+    holidays_map = {}
+    for _, row in unique_year_country.iterrows():
+        key = (int(row['year']), row['code_pays'])
+        if key not in holidays_map:
+            holidays_map[key] = get_holidays_for_year_country(*key)
+
+    def is_holiday(row):
+        if pd.isnull(row['ST']) or pd.isnull(row['code_pays']):
+            return False
+        key = (row['ST'].year, row['code_pays'])
+        date_str = row['ST'].strftime('%Y-%m-%d')
+        return date_str in holidays_map.get(key, set())
+
+    df_vols['jour_ferie'] = df_vols.apply(is_holiday, axis=1)
+    df_vols['sin_ST'], df_vols['cos_ST'] = encode_cyclique_time(df_vols['ST'])
+    df_vols['jour_sem'] = df_vols['ST'].dt.dayofweek.fillna(-1).astype(int)
+
+    final_cols = [
+        'Num Vol',
+        'Code Cie',
+        'Trajet',
+        'jour_sem',
+        'sin_ST',
+        'cos_ST',
+        'jour_ferie',
+        'frequence_vol_par_jour',
+        'pmr total'
+    ]
+
+    df_vols_final = df_vols[final_cols].copy()
+
+    df_vols_final.to_csv('vols.csv', index=False)
+    print("Données enrichies sauvegardées dans vols.csv")
+
+def train_and_evaluate():
+    df = pd.read_csv('vols.csv')
+
+    X = df.drop(columns=["pmr total", "Num Vol"])  
+    y = df["pmr total"]
+
+    categorical_cols = X.select_dtypes(include='object').columns.tolist()
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    train_pool = Pool(X_train, y_train, cat_features=categorical_cols)
+    test_pool = Pool(X_test, y_test, cat_features=categorical_cols)
+
+    model = CatBoostRegressor(
+        iterations=1000,
+        learning_rate=0.05,
+        depth=6,
+        loss_function='RMSE',
+        eval_metric='RMSE',
+        random_seed=42,
+        verbose=100,
+        early_stopping_rounds=50
+    )
+
+    model.fit(train_pool, eval_set=test_pool, use_best_model=True)
+
+    y_pred = model.predict(X_test)
+
+    mse = mean_squared_error(y_test, y_pred)
+    r2 = r2_score(y_test, y_pred)
+
+    print(f"Mean Squared Error (MSE): {mse:.2f}")
+    print(f"R^2 Score: {r2:.2f}")
+
+    df_result = X_test.copy()
+    df_result['y_true'] = y_test
+    df_result['y_pred'] = y_pred
+    print(df_result.head(10))
+    
+    total_y_true = y_test.sum()
+    print(f"Somme totale de y_true : {total_y_true}")
+    total_y_pred = y_pred.sum()
+    print(f"Somme totale de y_pred : {total_y_pred}")
+
+    
+    y_test_class = y_test.round().astype(int)
+    y_pred_class = np.round(y_pred).astype(int)
+
+    cm = confusion_matrix(y_test_class, y_pred_class)
+    acc = accuracy_score(y_test_class, y_pred_class)
+
+    print(f"\nAccuracy (rounded predictions): {acc:.2f}")
+
+    disp = ConfusionMatrixDisplay(confusion_matrix=cm)
+    disp.plot(cmap='Blues')
+    plt.title('Confusion Matrix (rounded values)')
+    plt.show()
+
+if __name__ == "__main__":
+    prepare_data()
+    train_and_evaluate()
+
+
+import pandas as pd
+from sklearn.linear_model import Ridge
+from sklearn.metrics import mean_squared_error, r2_score
+from sklearn.model_selection import train_test_split
+
+# Charger les données
+df = pd.read_csv("vols.csv")
+
+y = df["pmr total"]
+X = df.drop(columns=["pmr total"])
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Encodage par la moyenne cible (Target Encoding)
+X_train_enc = X_train.copy()
+X_test_enc = X_test.copy()
+
+for col in X.select_dtypes(include=["object", "category"]).columns:
+    means = X_train_enc.join(y_train)[[col, "pmr total"]].groupby(col)["pmr total"].mean()
+    X_train_enc[col] = X_train_enc[col].map(means)
+    X_test_enc[col] = X_test_enc[col].map(means)
+    
+    # Remplacer les valeurs inconnues (non vues dans le train) par la moyenne globale
+    global_mean = y_train.mean()
+    X_test_enc[col] = X_test_enc[col].fillna(global_mean)
+
+# Modèle Ridge
+model = Ridge(alpha=1.0)
+model.fit(X_train_enc, y_train)
+
+# Prédictions
+y_pred = model.predict(X_test_enc)
+
+# Évaluation
+mse = mean_squared_error(y_test, y_pred)
+r2 = r2_score(y_test, y_pred)
+
+print(f"Mean Squared Error (MSE): {mse:.2f}")
+print(f"R² Score: {r2:.2f}")
+
+
+
+with open("AE.ipynb", "r", encoding="utf-8") as f:
+    notebook = json.load(f)
+
+with open("code.py", "w", encoding="utf-8") as f:
+    for cell in notebook["cells"]:
+        if cell["cell_type"] == "code":
+            f.write("".join(cell["source"]))
+            f.write("\n\n")
+
+
+
+
+