Refactor: Improved comments and code structure + test file errors fix for /src/data_processing and /src/modeling forlders + config.py update and model update

src/config.py

@@ -18,7 +18,7 @@ PROCESSED_DATA_PATH = DATA_DIR / "processed" / "data_rh_final.csv"
 MODEL_NAME = "attrition_logistic_regression.joblib"
 MODEL_PATH = MODELS_DIR / MODEL_NAME
 
-TARGET_VARIABLE = 'a_quitte_l_entreprise_numeric'
+TARGET_VARIABLE = "a_quitte_l_entreprise_numeric"
 
 DB_USER = os.getenv("POSTGRES_USER", "default_user")
 DB_PASSWORD = os.getenv("POSTGRES_PASSWORD", "default_password")
@@ -32,12 +32,12 @@ API_VERSION = "0.1.0"
 
 # --- AJOUT DES MAPPINGS ET CATÉGORIES ICI ---
 BINARY_FEATURES_MAPPING = {
-    'genre': {'M': 0, 'F': 1}, # Adaptez si 'Masculin'/'Féminin' etc.
-    'heure_supplementaires': {'Non': 0, 'Oui': 1} # Adaptez 'Non'/'Oui' si nécessaire.
+    "genre": {"M": 0, "F": 1},  # Adaptez si 'Masculin'/'Féminin' etc.
+    "heure_supplementaires": {"Non": 0, "Oui": 1},  # Adaptez 'Non'/'Oui' si nécessaire.
 }
 
 ORDINAL_FEATURES_CATEGORIES = {
-    'frequence_deplacement': ["Aucun", "Occasionnel", "Frequent"],
+    "frequence_deplacement": ["Aucun", "Occasionnel", "Frequent"],
     # Ajoutez vos autres colonnes ordinales et leurs catégories ordonnées ici
 }
-# --- FIN AJOUT ---
+# --- FIN AJOUT ---

src/data_processing/load_data.py

@@ -1,136 +1,232 @@
+"""
+Module pour le chargement et la préparation initiale des données.
+
+Fonctions pour charger les données brutes depuis des fichiers CSV,
+les fusionner, et préparer les clés de jointure. Fournit également des fonctions
+pour charger les données depuis une base de données PostgreSQL une fois peuplée.
+La fonction principale `get_data` sert d'interface pour obtenir les données
+pour le reste de l'application, typiquement pour l'entraînement du modèle.
+"""
 import pandas as pd
-# Supprimé: from sqlalchemy import create_engine # Nous utiliserons la session/engine de database_setup
-from src.database.database_setup import SessionLocal, engine # Importer SessionLocal et engine
-from src.database.models import Employee # Importer votre modèle Employee
+from sqlalchemy.orm import Session # Importé pour être utilisé dans load_data_from_postgres
+
+from src.database.database_setup import SessionLocal, engine # engine est utilisé implicitement par read_sql_query via db.bind
+from src.database.models import Employee
 from src import config
 import logging
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Configuration du logging pour ce module
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
-def load_data_from_csv(path=config.PROCESSED_DATA_PATH):
-    """Charge les données depuis un fichier CSV (gardé pour référence ou fallback)."""
+
+def load_data_from_csv(path: str = config.PROCESSED_DATA_PATH) -> pd.DataFrame | None:
+    """
+    Charge les données depuis un unique fichier CSV spécifié.
+
+    Utilisé comme fonction de secours ou pour charger un dataset déjà traité et sauvegardé en CSV.
+
+    Args:
+        path (str, optional): Chemin vers le fichier CSV.
+                              Par défaut, utilise config.PROCESSED_DATA_PATH.
+
+    Returns:
+        pd.DataFrame | None: DataFrame Pandas contenant les données chargées,
+                             ou None si le fichier n'est pas trouvé.
+    """
     try:
         logger.info(f"Chargement des données CSV depuis {path}...")
         df = pd.read_csv(path)
-        logger.info("Données CSV chargées avec succès.")
+        logger.info(f"Données CSV chargées avec succès depuis {path}: {df.shape[0]} lignes.")
         return df
     except FileNotFoundError:
         logger.error(f"Fichier CSV non trouvé : {path}")
         return None
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors du chargement du CSV {path}: {e}", exc_info=True)
+        return None
+
 
 def load_data_from_postgres() -> pd.DataFrame:
-    """Charge les données de la table 'employees' depuis PostgreSQL dans un DataFrame."""
-    db = SessionLocal()
+    """
+    Charge l'intégralité des données de la table 'employees' depuis PostgreSQL
+    dans un DataFrame Pandas.
+
+    Utilise SQLAlchemy pour interagir avec la base de données configurée.
+
+    Returns:
+        pd.DataFrame: DataFrame Pandas contenant les données de la table 'employees'.
+                      Retourne un DataFrame vide en cas d'erreur ou si la table est vide.
+    """
+    db: Session = SessionLocal()
     try:
-        logger.info("Chargement des données depuis la table 'employees' de PostgreSQL...")
-        # Construire la requête pour sélectionner toutes les colonnes de la table Employee
-        query = db.query(Employee)
-        # Exécuter la requête et la charger dans un DataFrame Pandas
-        df = pd.read_sql_query(query.statement, db.bind) # Utiliser db.bind pour la connexion
-        
+        logger.info(
+            "Chargement des données depuis la table 'employees' de PostgreSQL..."
+        )
+        query = db.query(Employee) # Construit une requête pour sélectionner toutes les colonnes de Employee
+        # Exécute la requête et charge les résultats dans un DataFrame Pandas
+        df = pd.read_sql_query(sql=query.statement, con=db.bind)
+
         if df.empty:
-            logger.warning("Aucune donnée trouvée dans la table 'employees'. Le DataFrame est vide.")
+            logger.warning(
+                "Aucune donnée trouvée dans la table 'employees'. Le DataFrame est vide."
+            )
         else:
             logger.info(f"{len(df)} lignes chargées depuis la table 'employees'.")
         return df
     except Exception as e:
-        logger.error(f"Erreur lors du chargement des données depuis PostgreSQL : {e}", exc_info=True)
-        return pd.DataFrame() # Retourner un DataFrame vide en cas d'erreur
+        logger.error(
+            f"Erreur lors du chargement des données depuis PostgreSQL : {e}",
+            exc_info=True,
+        )
+        return pd.DataFrame()  # Retourner un DataFrame vide en cas d'erreur
     finally:
         db.close()
+        logger.debug("Session PostgreSQL fermée pour load_data_from_postgres.")
 
-def get_data(source: str = "postgres") -> pd.DataFrame: # Changement de la source par défaut
+
+def get_data(source: str = "postgres") -> pd.DataFrame | None:
     """
-    Fonction principale pour charger les données.
-    'source' peut être "postgres" ou "csv".
+    Fonction principale pour obtenir le jeu de données pour l'application.
+
+    Sert d'interface pour charger les données soit depuis PostgreSQL (par défaut),
+    soit depuis des fichiers CSV bruts (via `load_and_merge_csvs`).
+
+    Args:
+        source (str, optional): La source des données. Peut être "postgres" ou "csv".
+                                Par défaut à "postgres".
+
+    Returns:
+        pd.DataFrame | None: DataFrame Pandas contenant les données, ou None si une
+                             erreur majeure de chargement se produit (ex: CSV introuvables).
+                             Peut retourner un DataFrame vide si la source est vide (ex: table PG vide).
     """
     logger.info(f"Récupération des données depuis la source : {source}")
     if source == "postgres":
         return load_data_from_postgres()
     elif source == "csv":
-        # Vous pourriez vouloir charger le CSV fusionné et nettoyé si vous l'aviez sauvegardé,
-        # ou relancer le processus de fusion si vous voulez repartir des bruts.
-        # Pour l'instant, on garde la logique précédente si 'csv' est appelé.
-        # Si vous avez un fichier CSV qui correspond à ce qui est dans la BDD:
-        # return load_data_from_csv(config.PROCESSED_DATA_PATH)
-        # Sinon, si vous voulez repartir des bruts (ce qui est moins pertinent maintenant):
-        from .load_data import load_and_merge_csvs # Assurez-vous que cette fonction existe toujours
-        logger.warning("Chargement depuis les CSV bruts via load_and_merge_csvs. Cette source est moins recommandée maintenant.")
-        return load_and_merge_csvs() # Si load_and_merge_csvs est toujours là et fait le travail
+        logger.warning(
+            "Chargement depuis les CSV bruts via load_and_merge_csvs. "
+            "Cette source est principalement pour le peuplement initial de la BDD."
+        )
+        # L'import local est inhabituel. S'il est utilisé, il devrait être en haut du fichier.
+        # Cependant, si load_and_merge_csvs est spécifique à ce cas, le garder ici
+        # évite un import circulaire si load_and_merge_csvs devait importer qqch de ce module.
+        # Pour l'instant, nous le laissons, mais c'est un point d'attention.
+        # from .load_data import load_and_merge_csvs # Ceci créerait une récursion.
+        # Il faut s'assurer que load_and_merge_csvs est bien défini dans ce même fichier.
+        return load_and_merge_csvs()
     else:
-        logger.error(f"Source de données non reconnue : {source}. Utilisation de PostgreSQL par défaut.")
+        logger.error(
+            f"Source de données non reconnue : {source}. Tentative avec PostgreSQL par défaut."
+        )
         return load_data_from_postgres()
 
 
-# La fonction load_and_merge_csvs() peut être gardée si vous en avez encore besoin pour
-# peupler la base ou pour d'autres usages, sinon elle pourrait être enlevée à terme.
-# Assurez-vous qu'elle est toujours présente si get_data(source="csv") l'appelle.
-# Pour l'instant, nous la laissons pour ne pas casser le script de peuplement si vous l'avez utilisé.
-def load_and_merge_csvs():
-    """Charge les 3 fichiers CSV bruts, prépare la clé de jointure et les fusionne."""
+def load_and_merge_csvs() -> pd.DataFrame | None:
+    """
+    Charge les données depuis les trois fichiers CSV bruts (`extrait_sirh.csv`,
+    `extrait_eval.csv`, `extrait_sondage.csv`), prépare les clés de jointure `id_employee`
+    (notamment à partir de `eval_number` et `code_sondage`), et fusionne les DataFrames.
+
+    Cette fonction est principalement utilisée pour le peuplement initial de la base de données.
+    Elle s'assure que les `id_employee` sont traités comme des chaînes de caractères pour
+    des fusions cohérentes.
+
+    Returns:
+        pd.DataFrame | None: Un DataFrame fusionné contenant les données des trois sources,
+                             ou None si une erreur critique se produit (ex: fichier introuvable,
+                             colonne clé de jointure manquante).
+    """
     try:
-        logger.info("Chargement des fichiers CSV bruts...")
+        logger.info("Chargement des fichiers CSV bruts pour fusion...")
         df_sirh = pd.read_csv(config.RAW_SIRH_PATH)
         df_eval = pd.read_csv(config.RAW_EVAL_PATH)
         df_sondage = pd.read_csv(config.RAW_SONDAGE_PATH)
 
-        logger.info("Préparation de la clé de jointure dans df_eval...")
-        if 'eval_number' in df_eval.columns:
-            # S'assurer que eval_number est traité comme string avant split
-            df_eval['id_employee_str_temp'] = df_eval['eval_number'].astype(str).str.split('_').str[1]
-            
-            # Tenter une conversion numérique pour valider le format si nécessaire,
-            # mais la clé finale pour la jointure sera une string.
-            numeric_ids_for_check = pd.to_numeric(df_eval['id_employee_str_temp'], errors='coerce')
+        # Préparation de df_eval
+        logger.info("Préparation de la clé de jointure 'id_employee' dans df_eval à partir de 'eval_number'...")
+        if "eval_number" in df_eval.columns:
+            df_eval["id_employee_str_temp"] = (
+                df_eval["eval_number"].astype(str).str.split("_", n=1).str.get(1) # Prend tout après le premier '_'
+            )
+            numeric_ids_for_check = pd.to_numeric(
+                df_eval["id_employee_str_temp"], errors="coerce"
+            )
             nan_count = numeric_ids_for_check.isnull().sum()
             if nan_count > 0:
-                # Le message exact attendu par votre test est important ici
-                logger.warning(f"{nan_count} 'eval_number' n'ont pas pu être convertis en 'id_employee' valides.") # Message original
-
-            # La clé de jointure finale doit être une string
-            df_eval['id_employee'] = df_eval['id_employee_str_temp'].astype(str) # Assurer le type string
-            df_eval = df_eval.drop(columns=['id_employee_str_temp'])
+                logger.warning(
+                    f"{nan_count} 'eval_number' (après extraction) n'ont pas pu être convertis "
+                    f"en id_employee numériques valides et sont devenus NaN."
+                )
+            df_eval["id_employee"] = df_eval["id_employee_str_temp"].astype(str) # Clé finale en string
+            df_eval = df_eval.drop(columns=["id_employee_str_temp"])
             logger.info("'id_employee' créé et formaté en string dans df_eval.")
         else:
-            logger.error("La colonne 'eval_number' est introuvable dans df_eval.")
+            logger.error("La colonne 'eval_number' est introuvable dans df_eval. Impossible de créer 'id_employee'.")
             return None
 
-        # S'assurer que les id_employee dans les autres tables sont aussi des strings
-        for df_temp, name in [(df_sirh, 'df_sirh'), (df_sondage, 'df_sondage')]:
-            if 'id_employee' in df_temp.columns:
-                df_temp['id_employee'] = df_temp['id_employee'].astype(str) # Assurer le type string
-            else:
-                logger.error(f"La colonne 'id_employee' est introuvable dans {name}.")
+        # Préparation de df_sondage
+        logger.info("Préparation de la clé de jointure 'id_employee' dans df_sondage à partir de 'code_sondage'...")
+        if "code_sondage" in df_sondage.columns: # Supposons que code_sondage est directement l'id_employee
+            # Si code_sondage nécessite une transformation similaire à eval_number, appliquez-la ici.
+            # Pour cet exemple, on suppose que code_sondage EST l'id_employee.
+            df_sondage["id_employee"] = df_sondage["code_sondage"].astype(str)
+            # Si vous aviez 'id_employee_str_temp' ici aussi, n'oubliez pas de le drop.
+            logger.info("'id_employee' (depuis code_sondage) formaté en string dans df_sondage.")
+        else:
+            # Si 'code_sondage' n'existe pas, on pourrait vérifier si 'id_employee' existe déjà
+            if "id_employee" not in df_sondage.columns:
+                logger.error("Ni 'code_sondage' ni 'id_employee' trouvés dans df_sondage.")
                 return None
-        
-        logger.info("Fusion des DataFrames...")
-        df_merged = pd.merge(df_sirh, df_eval, on='id_employee', how='left')
-        df_merged = pd.merge(df_merged, df_sondage, on='id_employee', how='left')
+            else: # id_employee existe déjà, on s'assure juste du type
+                 df_sondage["id_employee"] = df_sondage["id_employee"].astype(str)
+                 logger.info("'id_employee' existant dans df_sondage formaté en string.")
+
+
+        # Standardisation du type de 'id_employee' dans df_sirh
+        if "id_employee" in df_sirh.columns:
+            df_sirh["id_employee"] = df_sirh["id_employee"].astype(str)
+        else:
+            logger.error("La colonne 'id_employee' est introuvable dans df_sirh.")
+            return None
+
+        logger.info("Fusion des DataFrames (df_sirh <- df_eval <- df_sondage)...")
+        df_merged = pd.merge(df_sirh, df_eval, on="id_employee", how="left")
+        df_merged = pd.merge(df_merged, df_sondage, on="id_employee", how="left")
 
-        logger.info(f"Données fusionnées : {df_merged.shape}")
+        logger.info(f"Données fusionnées avec succès : {df_merged.shape[0]} lignes, {df_merged.shape[1]} colonnes.")
         return df_merged
 
     except FileNotFoundError as e:
         logger.error(f"Erreur de chargement CSV : Fichier non trouvé - {e}")
         return None
     except Exception as e:
-        logger.error(f"Erreur inattendue lors du chargement/fusion CSV : {e}", exc_info=True)
+        logger.error(
+            f"Erreur inattendue lors du chargement/fusion CSV : {e}", exc_info=True
+        )
         return None
 
 
-# Pour tester ce module : poetry run python -m src.data_processing.load_data
 if __name__ == "__main__":
-    logger.info("--- Test du chargement depuis PostgreSQL ---")
+    logger.info("--- Test du chargement des données depuis PostgreSQL ---")
     data_from_db = get_data(source="postgres")
     if data_from_db is not None and not data_from_db.empty:
+        print("Premières lignes de data_from_db:")
         print(data_from_db.head())
         print(f"\nDimensions des données depuis DB : {data_from_db.shape}")
-        print(f"\nTypes de données depuis DB :\n{data_from_db.dtypes}")
+        # print(f"\nTypes de données depuis DB :\n{data_from_db.dtypes}") # Peut être verbeux
     else:
-        print("Aucune donnée chargée depuis la base ou une erreur s'est produite.")
+        print("Aucune donnée chargée depuis la base ou une erreur s'est produite lors du chargement.")
 
-    # logger.info("\n--- Test du chargement depuis CSV (si toujours pertinent) ---")
-    # data_from_csv = get_data(source="csv") # Nécessiterait les CSV bruts
-    # if data_from_csv is not None:
-    #     print(data_from_csv.head())
+    # Décommentez pour tester le chargement et la fusion des CSV bruts
+    # logger.info("\n--- Test du chargement et de la fusion des CSV bruts ---")
+    # data_from_csv_merge = get_data(source="csv")
+    # if data_from_csv_merge is not None and not data_from_csv_merge.empty:
+    #     print("\nPremières lignes de data_from_csv_merge:")
+    #     print(data_from_csv_merge.head())
+    #     print(f"\nDimensions des données fusionnées depuis CSV : {data_from_csv_merge.shape}")
+    # else:
+    #     print("Aucune donnée chargée depuis les CSV ou une erreur s'est produite lors de la fusion.")

src/data_processing/preprocess.py

@@ -1,101 +1,192 @@
+# Dans src/data_processing/preprocess.py
+"""
+Module de prétraitement des données pour le projet d'attrition RH.
+
+Ce module contient les fonctions nécessaires pour :
+- Mapper les features binaires.
+- Nettoyer les données brutes (conversion de la cible, suppression de colonnes,
+  gestion des doublons, conversion de types spécifiques comme les pourcentages).
+- Créer de nouvelles features (feature engineering) - actuellement un placeholder.
+- Construire une pipeline de prétraitement Scikit-learn (ColumnTransformer) pour
+  l'imputation, la mise à l'échelle des numériques, et l'encodage des catégorielles
+  (OneHot et Ordinal).
+- Exécuter l'ensemble de ce pipeline de preprocessing.
+"""
 import pandas as pd
 from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder
 from sklearn.compose import ColumnTransformer
 from sklearn.pipeline import Pipeline
 from sklearn.impute import SimpleImputer
-from src import config
+from src import config # Pour config.TARGET_VARIABLE, config.BINARY_FEATURES_MAPPING, etc.
 import logging
-import numpy as np
+import numpy as np # Pour np.number lors de la sélection de dtypes
 
+# Configuration du logging pour ce module
 logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
 
 def map_binary_features(df: pd.DataFrame, binary_cols_map: dict) -> pd.DataFrame:
-    """Mappe les colonnes binaires spécifiées en 0 et 1."""
-    df = df.copy()
-    logger.info("Mappage des features binaires...")
+    """
+    Mappe les valeurs des colonnes catégorielles binaires spécifiées en 0 et 1.
+
+    Args:
+        df (pd.DataFrame): DataFrame d'entrée.
+        binary_cols_map (dict): Dictionnaire où les clés sont les noms de colonnes
+                                et les valeurs sont des dictionnaires de mapping
+                                (ex: {'Oui': 1, 'Non': 0}).
+
+    Returns:
+        pd.DataFrame: DataFrame avec les colonnes binaires mappées.
+    """
+    df = df.copy() # Évite les SettingWithCopyWarning
+    logger.info("Application du mappage sur les features binaires...")
     for col, mapping in binary_cols_map.items():
         if col in df.columns:
-            # S'assurer que les valeurs sont bien des strings avant de mapper si nécessaire
+            # Assurer que la colonne est de type string avant d'appliquer .map
+            # Cela évite des erreurs si une colonne est déjà numérique (ex: 0/1)
+            # ou contient des types mixtes.
             df[col] = df[col].astype(str).map(mapping)
-            logger.info(f"Colonne '{col}' mappée en binaire.")
-            # Vérifier si des NaN ont été introduits (signe d'un problème de mapping)
+            # Après .map, les valeurs non trouvées dans le mapping deviennent NaN.
+            # Il est important que ces NaN soient de type float pour que SimpleImputer (numérique) fonctionne.
+            # Si la colonne originale était object et contenait des strings et des NaN après map,
+            # SimpleImputer(strategy='most_frequent') fonctionnerait mais SimpleImputer(strategy='median') échouerait.
+            # Le plus sûr est de convertir en type numérique si on s'attend à 0 et 1.
+            df[col] = pd.to_numeric(df[col], errors='coerce') # Convertit en float, les erreurs (anciens NaN) restent NaN
+
+            logger.info(f"Colonne '{col}' mappée en binaire numérique.")
+            
             nan_count = df[col].isnull().sum()
             if nan_count > 0:
                 logger.warning(
-                    f"{nan_count} valeurs dans '{col}' n'ont pas pu être mappées et sont devenues NaN."
+                    f"{nan_count} valeur(s) dans la colonne '{col}' n'ont pas pu être mappée(s) "
+                    f"correctement et sont devenue(s) NaN (ou étaient déjà NaN)."
                 )
-                # Option: Imputer ici ou laisser SimpleImputer le gérer plus tard
-                # df[col] = df[col].fillna(df[col].mode()[0] if not df[col].mode().empty else 0)
         else:
-            logger.warning(f"Colonne binaire '{col}' non trouvée.")
+            logger.warning(f"Colonne binaire '{col}' spécifiée pour mappage mais non trouvée dans le DataFrame.")
     return df
 
 
 def clean_data(df: pd.DataFrame) -> pd.DataFrame:
-    """Applique les étapes de nettoyage et de conversion de type."""
-    logger.info("Nettoyage des données...")
+    """
+    Applique les étapes de nettoyage de base et les conversions de types spécifiques.
+
+    - Convertit la variable cible textuelle en format numérique.
+    - Supprime les colonnes jugées inutiles ou redondantes.
+    - Supprime les lignes dupliquées.
+    - Convertit la colonne 'augementation_salaire_precedente' (texte en "XX %") en numérique.
+
+    Args:
+        df (pd.DataFrame): DataFrame d'entrée brut ou fusionné.
+
+    Returns:
+        pd.DataFrame: DataFrame nettoyé.
+
+    Raises:
+        ValueError: Si la colonne cible 'a_quitte_l_entreprise' est manquante.
+    """
+    logger.info("Début du nettoyage des données...")
     df = df.copy()
 
+    # Conversion de la variable cible
     if "a_quitte_l_entreprise" in df.columns:
         df[config.TARGET_VARIABLE] = df["a_quitte_l_entreprise"].map(
             {"Oui": 1, "Non": 0}
         )
-        logger.info(f"Colonne '{config.TARGET_VARIABLE}' créée.")
+        # Convertir en type entier nullable pour gérer les NaN si map échoue pour certaines valeurs
+        df[config.TARGET_VARIABLE] = pd.to_numeric(df[config.TARGET_VARIABLE], errors='coerce').astype('Int64')
+        logger.info(f"Colonne cible '{config.TARGET_VARIABLE}' créée et convertie en Int64.")
     else:
-        logger.error("La colonne 'a_quitte_l_entreprise' est manquante.")
-        raise ValueError("Colonne cible manquante.")
-
+        # Pour la prédiction, cette colonne ne sera pas présente.
+        # On ne devrait pas lever d'erreur si on est en mode prédiction.
+        # Cette fonction est appelée par run_preprocessing_pipeline qui sépare X et y *après*.
+        # Et aussi par populate_db qui a besoin de la cible.
+        # Pour predict.py, on ajoute une colonne factice 'a_quitte_l_entreprise'.
+        # Donc, cette condition est surtout pour la robustesse lors de l'entraînement.
+        logger.warning("La colonne 'a_quitte_l_entreprise' est manquante. Si c'est pour la prédiction, c'est normal.")
+        # Si cette fonction est appelée par un flux où la cible DOIT être là (comme populate_db ou train_model avant split X/y)
+        # alors une erreur est appropriée.
+        # Pour l'instant, on logue un warning, le check de présence de TARGET_VARIABLE se fera plus tard.
+
+
+    # Liste des colonnes à supprimer (adaptez si nécessaire)
+    # 'id_employee' est conservé pour le moment, car il est utilisé par populate_db
+    # et sera explicitement retiré de X dans train_model.py avant l'entraînement.
     cols_to_drop = [
-        "id_employee",
-        "nombre_heures_travailless",
+        "nombre_heures_travailless", # Semble être une coquille (s en trop)
         "eval_number",
         "nombre_employee_sous_responsabilite",
         "code_sondage",
         "ayant_enfants",
-        "a_quitte_l_entreprise",
-        "annee_experience_totale",
-        "niveau_hierarchique_poste",
-        "annees_dans_le_poste_actuel",
-        "annes_sous_responsable_actuel",
+        "a_quitte_l_entreprise", # Version texte de la cible, une fois la version numérique créée
+        "annee_experience_totale", # Supposée redondante ou moins pertinente
+        "niveau_hierarchique_poste", # Supposée redondante ou moins pertinente
+        "annees_dans_le_poste_actuel", # Supposée redondante ou moins pertinente
+        "annes_sous_responsable_actuel", # Coquille "annes" -> "annees" ?
     ]
-    df = df.drop(
-        columns=[col for col in cols_to_drop if col in df.columns], errors="ignore"
-    )
-    logger.info(f"Colonnes supprimées (si présentes) : {cols_to_drop}")
+    actual_cols_to_drop = [col for col in cols_to_drop if col in df.columns]
+    if actual_cols_to_drop:
+        df = df.drop(columns=actual_cols_to_drop, errors="ignore")
+        logger.info(f"Colonnes supprimées : {actual_cols_to_drop}")
+    else:
+        logger.info("Aucune colonne de la liste `cols_to_drop` n'a été trouvée pour suppression.")
+
 
+    # Suppression des doublons
     initial_rows = len(df)
     df = df.drop_duplicates()
     if len(df) < initial_rows:
         logger.info(f"{initial_rows - len(df)} lignes dupliquées supprimées.")
 
-    col_aug = "augementation_salaire_precedente"  # Mettez le nom exact
+    # Conversion de 'augementation_salaire_precedente'
+    col_aug = "augementation_salaire_precedente"
     if col_aug in df.columns:
-        logger.info(f"Conversion de '{col_aug}' en numérique...")
-        df[col_aug] = df[col_aug].astype(str).str.replace(" %", "", regex=False)
+        logger.info(f"Conversion de la colonne '{col_aug}' en numérique...")
+        df[col_aug] = df[col_aug].astype(str).str.replace(" %", "", regex=False).str.strip()
         df[col_aug] = pd.to_numeric(df[col_aug], errors="coerce")
         nan_count = df[col_aug].isnull().sum()
         if nan_count > 0:
-            logger.warning(f"{nan_count} valeurs dans '{col_aug}' sont devenues NaN.")
-        logger.info(f"'{col_aug}' convertie avec succès.")
+            logger.warning(
+                f"{nan_count} valeur(s) dans '{col_aug}' n'ont pas pu être converties "
+                f"en numérique et sont devenue(s) NaN."
+            )
+        logger.info(f"Colonne '{col_aug}' convertie avec succès en type numérique.")
     else:
         logger.warning(
-            f"La colonne '{col_aug}' n'a pas été trouvée pour la conversion."
+            f"La colonne '{col_aug}' n'a pas été trouvée pour la conversion numérique."
         )
 
-    logger.info("Nettoyage terminé.")
+    logger.info("Nettoyage des données terminé.")
     return df
 
 
 def create_features(df: pd.DataFrame) -> pd.DataFrame:
-    """Crée de nouvelles features."""
-    logger.info("Création de features...")
+    """
+    Crée de nouvelles features (ingénierie des features) à partir des colonnes existantes.
+
+    Args:
+        df (pd.DataFrame): DataFrame d'entrée (généralement après nettoyage et mappage binaire).
+
+    Returns:
+        pd.DataFrame: DataFrame avec les nouvelles features ajoutées.
+    """
+    logger.info("Début de la création de features...")
     df = df.copy()
-    # --- AJOUTEZ VOS FEATURES ICI ---
-    logger.info("Création de features terminée.")
+
+    # --- EXEMPLE DE FEATURE A AJOUTER ---
+    # Si vous voulez ajouter une feature 'satisfaction_moyenne' basée sur les colonnes Q_...
+    # sondage_cols = [col for col in df.columns if col.startswith('Q_') and col not in ['Q_satisfaction_generale']]
+    # if sondage_cols:
+    #     df['satisfaction_moyenne_autres_sondages'] = df[sondage_cols].mean(axis=1, skipna=True)
+    #     logger.info("Feature 'satisfaction_moyenne_autres_sondages' créée.")
+    # else:
+    #     logger.info("Aucune colonne de sondage (Q_...) trouvée pour calculer 'satisfaction_moyenne_autres_sondages'.")
+
+    # Pour l'instant, cette fonction ne fait rien de plus.
+    # Vous pouvez ajouter ici la logique de création de features que vous aviez dans vos notebooks.
+    logger.info("Création de features terminée (actuellement, pas de nouvelles features implémentées).")
     return df
 
 
@@ -103,10 +194,32 @@ def build_preprocessor(
     numerical_cols: list,
     onehot_cols: list,
     ordinal_cols: list,
-    ordinal_categories: dict,
+    ordinal_categories_map: dict, # Renommé pour correspondre à l'usage dans la fct
 ) -> ColumnTransformer:
-    """Construit la pipeline de preprocessing Sklearn."""
-    logger.info("Construction du préprocesseur Sklearn...")
+    """
+    Construit et retourne un objet ColumnTransformer de Scikit-learn pour le prétraitement.
+
+    Le ColumnTransformer applique :
+    - Imputation par la médiane puis StandardScaler aux colonnes numériques.
+    - Imputation par la valeur la plus fréquente puis OneHotEncoder aux colonnes catégorielles nominales.
+    - Imputation par la valeur la plus fréquente puis OrdinalEncoder aux colonnes catégorielles ordinales.
+
+    Args:
+        numerical_cols (list): Liste des noms des colonnes numériques.
+        onehot_cols (list): Liste des noms des colonnes catégorielles à encoder en One-Hot.
+        ordinal_cols (list): Liste des noms des colonnes catégorielles ordinales.
+        ordinal_categories_map (dict): Dictionnaire spécifiant l'ordre des catégories
+                                     pour chaque colonne ordinale.
+                                     Format: {'nom_col_ord': ['cat1', 'cat2', ...]}
+
+    Returns:
+        ColumnTransformer: Objet ColumnTransformer configuré mais non ajusté.
+
+    Raises:
+        ValueError: Si les catégories pour une colonne ordinale ne sont pas définies
+                    dans `ordinal_categories_map`.
+    """
+    logger.info("Construction du préprocesseur Sklearn (ColumnTransformer)...")
     transformers_list = []
 
     if numerical_cols:
@@ -117,6 +230,7 @@ def build_preprocessor(
             ]
         )
         transformers_list.append(("num", numerical_transformer, numerical_cols))
+        logger.info(f"Transformateur numérique configuré pour les colonnes : {numerical_cols}")
 
     if onehot_cols:
         onehot_transformer = Pipeline(
@@ -131,12 +245,16 @@ def build_preprocessor(
             ]
         )
         transformers_list.append(("onehot", onehot_transformer, onehot_cols))
+        logger.info(f"Transformateur OneHot configuré pour les colonnes : {onehot_cols}")
+
 
     if ordinal_cols:
         for col in ordinal_cols:
-            if col not in ordinal_categories:
-                raise ValueError(f"Les catégories pour '{col}' ne sont pas définies.")
-            categories_for_col = [ordinal_categories[col]]
+            if col not in ordinal_categories_map: # Utilisation de ordinal_categories_map
+                raise ValueError(
+                    f"Les catégories pour la colonne ordinale '{col}' ne sont pas définies dans ordinal_categories_map."
+                )
+            categories_for_col = [ordinal_categories_map[col]] # Utilisation de ordinal_categories_map
             ordinal_transformer_col = Pipeline(
                 steps=[
                     ("imputer", SimpleImputer(strategy="most_frequent")),
@@ -145,55 +263,94 @@ def build_preprocessor(
                         OrdinalEncoder(
                             categories=categories_for_col,
                             handle_unknown="use_encoded_value",
-                            unknown_value=-1,
+                            unknown_value= np.nan # Utiliser np.nan, qui sera géré par l'imputer numérique si la colonne devient numérique
+                                                 # ou -1 si vous préférez et que l'imputer numérique n'est pas appliqué ensuite
                         ),
                     ),
                 ]
             )
             transformers_list.append((f"ord_{col}", ordinal_transformer_col, [col]))
+        logger.info(f"Transformateurs ordinaux configurés pour les colonnes : {ordinal_cols}")
+
 
     if not transformers_list:
-        logger.warning("Aucune colonne spécifiée. Préprocesseur vide.")
+        logger.warning("Aucune colonne spécifiée pour le preprocessing. Le ColumnTransformer sera vide et utilisera remainder='passthrough'.")
+        # Retourner un transformateur qui ne fait rien mais ne plante pas.
         return ColumnTransformer(transformers=[], remainder="passthrough")
 
     preprocessor = ColumnTransformer(transformers=transformers_list, remainder="drop")
-    logger.info("Préprocesseur Sklearn construit.")
+    logger.info("Préprocesseur Sklearn (ColumnTransformer) construit avec succès.")
     return preprocessor
 
 
 def run_preprocessing_pipeline(
     df: pd.DataFrame,
-    binary_cols_map: dict = None,
-    ordinal_cols_categories: dict = None,
+    binary_cols_map: dict = None, # Doit venir de config.BINARY_FEATURES_MAPPING
+    ordinal_cols_categories_map: dict = None, # Doit venir de config.ORDINAL_FEATURES_CATEGORIES. Renommé pour cohérence.
     preprocessor: ColumnTransformer = None,
     fit: bool = False,
 ):
-    """Exécute le pipeline de preprocessing complet."""
+    """
+    Exécute le pipeline de preprocessing complet sur le DataFrame fourni.
+
+    Orchestre les étapes de nettoyage, mappage binaire, création de features,
+    et application (ajustement ou transformation) du ColumnTransformer.
+
+    Args:
+        df (pd.DataFrame): DataFrame d'entrée brut.
+        binary_cols_map (dict, optional): Mapping pour les features binaires.
+                                          Utilise config.BINARY_FEATURES_MAPPING si non fourni (dans l'appelant).
+        ordinal_cols_categories_map (dict, optional): Catégories pour les features ordinales.
+                                                Utilise config.ORDINAL_FEATURES_CATEGORIES si non fourni (dans l'appelant).
+        preprocessor (ColumnTransformer, optional): Un ColumnTransformer pré-ajusté.
+                                                  Requis si `fit` est False.
+        fit (bool, optional): Si True, le préprocesseur est ajusté (`fit_transform`) sur les données.
+                              Si False, le `preprocessor` fourni est utilisé pour transformer (`transform`) les données.
+                              Par défaut à False.
+
+    Returns:
+        Tuple: Contenant selon le mode `fit`:
+               Si `fit` est True: (X_processed_df, y_series, fitted_processor_instance)
+               Si `fit` est False: (X_processed_df, y_series)
+               Où X_processed_df est un DataFrame et y_series est une Series.
+
+    Raises:
+        ValueError: Si la colonne cible est manquante après les premières étapes,
+                    ou si `fit` est False et aucun `preprocessor` n'est fourni,
+                    ou si une colonne ordinale spécifiée n'existe pas dans le DataFrame.
+    """
+    logger.info(f"Exécution du pipeline de preprocessing (fit={fit})...")
     df_clean = clean_data(df)
 
-    if binary_cols_map:
-        df_clean = map_binary_features(df_clean, binary_cols_map)
+    # Utiliser les mappings passés en argument, ou ceux de config si non fournis par l'appelant
+    current_binary_map = binary_cols_map if binary_cols_map is not None else config.BINARY_FEATURES_MAPPING
+    if current_binary_map: # Vérifier si le mapping est non vide/None
+        df_mapped = map_binary_features(df_clean, current_binary_map)
+    else:
+        df_mapped = df_clean.copy() # Pas de mappage binaire à faire
 
-    df_featured = create_features(df_clean)
+    df_featured = create_features(df_mapped)
 
     if config.TARGET_VARIABLE not in df_featured.columns:
         raise ValueError(
-            f"La colonne cible '{config.TARGET_VARIABLE}' n'est pas présente."
+            f"La colonne cible '{config.TARGET_VARIABLE}' n'est pas présente après clean/map/feature."
         )
 
     y = df_featured[config.TARGET_VARIABLE]
     X = df_featured.drop(config.TARGET_VARIABLE, axis=1)
 
-    ordinal_to_encode = (
-        list(ordinal_cols_categories.keys()) if ordinal_cols_categories else []
-    )
+    # Utiliser les catégories ordinales passées en argument, ou celles de config
+    current_ordinal_map = ordinal_cols_categories_map if ordinal_cols_categories_map is not None else config.ORDINAL_FEATURES_CATEGORIES
+    ordinal_to_encode = list(current_ordinal_map.keys()) if current_ordinal_map else []
 
+
+    # Identification des types de colonnes pour le ColumnTransformer
     potential_numerical_cols = X.select_dtypes(include=[np.number]).columns.tolist()
-    # Les colonnes numériques incluent maintenant les binaires mappées.
-    # On enlève les ordinales, car elles seront traitées séparément (même si numériques).
     numerical_to_scale = [
         col for col in potential_numerical_cols if col not in ordinal_to_encode
     ]
+    # Les colonnes binaires mappées en 0/1 sont numériques et seront scalées par défaut ici.
+    # Si on veut les exclure du scaling, il faudrait les retirer de numerical_to_scale.
 
     onehot_to_encode = [
         col
@@ -201,85 +358,104 @@ def run_preprocessing_pipeline(
         if col not in ordinal_to_encode
     ]
 
+    # Vérifier que les colonnes ordinales existent bien dans X avant de les passer à build_preprocessor
     for col in ordinal_to_encode:
         if col not in X.columns:
-            raise ValueError(f"La colonne ordinale '{col}' spécifiée n'existe pas.")
+            # Cela peut arriver si une colonne listée dans ORDINAL_FEATURES_CATEGORIES a été droppée
+            # ou n'était pas dans le df initial.
+            raise ValueError(f"La colonne ordinale '{col}' spécifiée dans ordinal_cols_categories_map n'existe pas dans le DataFrame X.")
 
-    logger.info(f"Colonnes numériques à scaler : {numerical_to_scale}")
-    logger.info(f"Colonnes catégorielles pour OneHotEncoding : {onehot_to_encode}")
-    logger.info(f"Colonnes catégorielles pour OrdinalEncoding : {ordinal_to_encode}")
+    logger.info(f"Colonnes identifiées pour la mise à l'échelle (numériques) : {numerical_to_scale}")
+    logger.info(f"Colonnes identifiées pour OneHotEncoding : {onehot_to_encode}")
+    logger.info(f"Colonnes identifiées pour OrdinalEncoding : {ordinal_to_encode}")
 
     if fit:
+        # Construire le préprocesseur avec les catégories ordinales actuelles
         processor_instance = build_preprocessor(
             numerical_to_scale,
             onehot_to_encode,
             ordinal_to_encode,
-            ordinal_cols_categories or {},
+            current_ordinal_map, # Passer le dictionnaire complet
         )
-        logger.info("Ajustement (fit) et transformation des données...")
+        logger.info("Ajustement (fit) et transformation des données X...")
         X_processed = processor_instance.fit_transform(X)
         try:
             feature_names = processor_instance.get_feature_names_out()
         except Exception as e:
             logger.warning(
-                f"Impossible d'obtenir les noms de features: {e}. Noms génériques utilisés."
+                f"Impossible d'obtenir les noms de features via get_feature_names_out(): {e}. Noms génériques utilisés."
             )
             feature_names = [f"feature_{i}" for i in range(X_processed.shape[1])]
-        logger.info("Transformation terminée.")
+        logger.info("Transformation X terminée.")
         return (
             pd.DataFrame(X_processed, columns=feature_names, index=X.index),
             y,
             processor_instance,
         )
-    else:
+    else: # Mode transform uniquement
         if preprocessor:
-            logger.info("Transformation des données (sans ajustement)...")
+            logger.info("Transformation des données X (sans ajustement) en utilisant le préprocesseur fourni...")
             X_processed = preprocessor.transform(X)
             try:
                 feature_names = preprocessor.get_feature_names_out()
             except Exception as e:
                 logger.warning(
-                    f"Impossible d'obtenir les noms de features: {e}. Noms génériques utilisés."
+                    f"Impossible d'obtenir les noms de features via get_feature_names_out(): {e}. Noms génériques utilisés."
                 )
                 feature_names = [f"feature_{i}" for i in range(X_processed.shape[1])]
-            logger.info("Transformation terminée.")
+            logger.info("Transformation X terminée.")
             return pd.DataFrame(X_processed, columns=feature_names, index=X.index), y
         else:
+            logger.error("Erreur: `fit` est False mais aucun `preprocessor` n'a été fourni.")
             raise ValueError("Un preprocessor doit être fourni si fit=False.")
 
 
-# Pour tester : poetry run python -m src.data_processing.preprocess
+# Bloc de test pour une exécution directe (poetry run python -m src.data_processing.preprocess)
 if __name__ == "__main__":
-    from .load_data import load_and_merge_csvs
-
-    df_raw = load_and_merge_csvs()
-
-    if df_raw is not None:
-
-        try:
+    logger.info("--- Démarrage du test direct du module preprocess.py ---")
+    # Importer load_and_merge_csvs ici pour éviter l'import circulaire au niveau du module
+    # si load_data devait importer qqch de preprocess (ce qui n'est pas le cas actuellement)
+    try:
+        from src.data_processing.load_data import load_and_merge_csvs
+        df_raw = load_and_merge_csvs()
+
+        if df_raw is not None and not df_raw.empty:
+            logger.info(f"Données brutes chargées pour le test: {df_raw.shape[0]} lignes.")
+            # Test du pipeline de preprocessing complet en mode fit=True
+            # Les mappings et catégories sont pris depuis config.py par défaut dans run_preprocessing_pipeline
             X_p, y_p, proc = run_preprocessing_pipeline(
                 df_raw,
-                binary_cols_map=config.BINARY_FEATURES_MAPPING,
-                ordinal_cols_categories=config.ORDINAL_FEATURES_CATEGORIES,
+                # binary_cols_map et ordinal_cols_categories sont pris de config par défaut
                 fit=True,
             )
-            print("\n--- Preprocessing Réussi ---")
+            print("\n--- Preprocessing Réussi (fit=True) ---")
             print("Shape X_processed:", X_p.shape)
             print("X_processed (head):")
             print(X_p.head())
-
-            # Vérifier que les colonnes binaires sont bien numériques et scalées
-            genre_col = [col for col in X_p.columns if "genre" in col]
-            hs_col = [col for col in X_p.columns if "heure_supplementaires" in col]
-
-            if genre_col:
-                print(f"\nColonne 'genre' traitée (scalée) : {genre_col[0]}")
-            if hs_col:
-                print(f"Colonne 'heure_supplementaires' traitée (scalée) : {hs_col[0]}")
-
-        except Exception as e:
-            print("\n--- Erreur lors du preprocessing ---")
-            print(e)
-            import traceback
-
-            traceback.print_exc()
+            print("\ny (head):")
+            print(y_p.head())
+            print("\nColonnes après preprocessing:", X_p.columns.tolist())
+
+            # Exemple de test en mode transform=True avec le processeur fitté
+            # On prend un échantillon des données brutes pour simuler de nouvelles données
+            if len(df_raw) > 5:
+                df_sample_for_transform = df_raw.sample(n=min(5, len(df_raw)), random_state=42)
+                logger.info(f"\nTest du mode transform sur {len(df_sample_for_transform)} échantillons...")
+                X_t, y_t = run_preprocessing_pipeline(
+                    df_sample_for_transform,
+                    preprocessor=proc, # Utiliser le processeur fitté
+                    fit=False
+                )
+                print("\n--- Preprocessing Réussi (fit=False) ---")
+                print("Shape X_transformed:", X_t.shape)
+                print("X_transformed (head):")
+                print(X_t.head())
+        else:
+            logger.error("Impossible de charger les données brutes pour le test du module preprocess.")
+
+    except Exception as e_main:
+        print(f"\n--- Erreur lors de l'exécution du test de preprocess.py ---")
+        print(e_main)
+        import traceback
+        traceback.print_exc()
+    logger.info("--- Fin du test direct du module preprocess.py ---")

src/modeling/predict.py

@@ -1,141 +1,201 @@
+"""
+Module pour charger la pipeline de Machine Learning entraînée et effectuer des prédictions.
+
+Fonctions principales :
+- `load_prediction_pipeline()`: Charge la pipeline Scikit-learn sauvegardée (modèle + préprocesseur).
+- `predict_attrition()`: Prend des données brutes d'employés en entrée (DataFrame),
+  applique les transformations de preprocessing initiales, puis utilise la pipeline
+  chargée pour prédire la probabilité d'attrition et la classe de départ.
+"""
 import pandas as pd
 from joblib import load
 import logging
-from src import config
-from typing import List, Dict, Union
+from typing import List, Dict, Union, Any # Ajout de Any
 
-# Importer les fonctions de preprocessing nécessaires !
+from src import config # Pour MODEL_PATH et BINARY_FEATURES_MAPPING
+# Importer les fonctions de preprocessing nécessaires
 from src.data_processing.preprocess import (
     clean_data,
     map_binary_features,
     create_features,
 )
 
+# Configuration du logging pour ce module
 logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
-_pipeline = None
+# Variable globale pour stocker la pipeline chargée et éviter de la recharger à chaque appel
+_pipeline: Any = None # Utilisation de Any car le type exact de la pipeline peut être complexe
 
-# --- FIN DÉFINITION ---
 
+def load_prediction_pipeline() -> Any | None:
+    """
+    Charge la pipeline de prédiction complète (préprocesseur + modèle) depuis le disque.
+
+    La pipeline est chargée une seule fois et stockée dans une variable globale `_pipeline`
+    pour optimiser les appels suivants.
 
-def load_prediction_pipeline():
-    """Charge la pipeline complète (preprocessor + modèle) depuis le disque."""
+    Returns:
+        Pipeline | None: L'objet pipeline Scikit-learn chargé, ou None si une erreur
+                         se produit (ex: fichier non trouvé, erreur de chargement).
+    """
     global _pipeline
-    if _pipeline is None:
+    if _pipeline is None: # Charger seulement si pas déjà en mémoire
         if not config.MODEL_PATH.exists():
-            logger.error(f"Fichier pipeline non trouvé : {config.MODEL_PATH}")
+            logger.error(f"Fichier pipeline non trouvé à l'emplacement configuré : {config.MODEL_PATH}")
             return None
         try:
-            logger.info(f"Chargement de la pipeline depuis {config.MODEL_PATH}...")
+            logger.info(f"Chargement de la pipeline de prédiction depuis : {config.MODEL_PATH}...")
             _pipeline = load(config.MODEL_PATH)
-            logger.info("Pipeline chargée avec succès.")
+            logger.info("Pipeline de prédiction chargée avec succès.")
         except Exception as e:
             logger.error(
-                f"Erreur lors du chargement de la pipeline : {e}", exc_info=True
+                f"Erreur critique lors du chargement de la pipeline : {e}", exc_info=True
             )
-            _pipeline = None
+            _pipeline = None # S'assurer que _pipeline est None en cas d'échec
             return None
     return _pipeline
 
 
-def predict_attrition(input_data: pd.DataFrame) -> Union[List[Dict], Dict]:
+def predict_attrition(input_data: pd.DataFrame) -> Union[List[Dict[str, Any]], Dict[str, str]]:
     """
-    Fait une prédiction sur de nouvelles données brutes (DataFrame).
-    Applique les transformations manuelles PUIS la pipeline sauvegardée.
+    Prédit le risque d'attrition pour les employés fournis en entrée.
+
+    Cette fonction prend un DataFrame de données brutes, applique les étapes
+    de preprocessing initiales (nettoyage, mappage binaire, création de features)
+    puis utilise la pipeline Scikit-learn entraînée et chargée pour effectuer
+    les prédictions.
+
+    Args:
+        input_data (pd.DataFrame): DataFrame contenant les données brutes des employés
+                                   pour lesquels faire une prédiction. Les colonnes doivent
+                                   correspondre aux attentes de `clean_data` et
+                                   `map_binary_features` (format brut).
+
+    Returns:
+        Union[List[Dict[str, Any]], Dict[str, str]]:
+            - Une liste de dictionnaires si la prédiction réussit, chaque dictionnaire
+              contenant 'id_employe', 'probabilite_depart', 'prediction_depart'.
+            - Un dictionnaire d'erreur `{"error": "message"}` si la pipeline n'est pas
+              chargée ou si une autre erreur majeure se produit.
     """
     pipeline = load_prediction_pipeline()
     if pipeline is None:
-        return {"error": "Pipeline non chargée. Veuillez entraîner le modèle."}
+        # Le logger dans load_prediction_pipeline aura déjà enregistré l'erreur spécifique.
+        return {"error": "Pipeline de prédiction non chargée. Le modèle n'a peut-être pas été entraîné ou le fichier est manquant."}
 
     try:
-        logger.info(f"Prédiction sur {len(input_data)} enregistrement(s)...")
+        logger.info(f"Début de la prédiction pour {len(input_data)} enregistrement(s)...")
+        
+        # Travailler sur une copie pour éviter de modifier le DataFrame original
+        data_to_process = input_data.copy()
 
         # --- ÉTAPE 1 : Appliquer les transformations manuelles ---
-        # Note: clean_data attend 'a_quitte_l_entreprise', on doit l'ajouter
-        # temporairement si elle n'y est pas, ou modifier clean_data.
-        # Pour la prédiction, il est plus simple de ne pas l'exiger.
-        # Modifions légèrement l'appel ou clean_data.
-        # Ici, on suppose que clean_data peut fonctionner sans la cible,
-        # ou on la modifie pour qu'elle puisse.
-        # Pour l'instant, on ajoute une colonne 'bidon' pour que ça passe.
-        if "a_quitte_l_entreprise" not in input_data.columns:
-            input_data["a_quitte_l_entreprise"] = "Non"  # Valeur arbitraire
-
-        df_cleaned = clean_data(input_data)
+        # clean_data s'attend à la colonne 'a_quitte_l_entreprise' pour créer config.TARGET_VARIABLE.
+        # Pour la prédiction, cette colonne n'existe pas dans les données d'entrée.
+        # Nous ajoutons une colonne factice 'a_quitte_l_entreprise' pour que clean_data
+        # puisse s'exécuter sans erreur. Cette colonne sera ensuite supprimée.
+        if "a_quitte_l_entreprise" not in data_to_process.columns:
+            data_to_process["a_quitte_l_entreprise"] = "Non" # Valeur factice, n'influence pas les features
+            logger.debug("Colonne 'a_quitte_l_entreprise' factice ajoutée pour le preprocessing.")
+
+        df_cleaned = clean_data(data_to_process)
+        # Utiliser le mapping centralisé depuis config.py
         df_mapped = map_binary_features(df_cleaned, config.BINARY_FEATURES_MAPPING)
         df_featured = create_features(df_mapped)
 
-        # Enlever la colonne cible si on l'a ajoutée ou si elle était là
-        X_predict = df_featured.drop(config.TARGET_VARIABLE, axis=1, errors="ignore")
+        # Préparer X_predict : supprimer la variable cible (même factice) et toute autre
+        # colonne qui ne fait pas partie des features attendues par la pipeline.
+        # La pipeline a été entraînée sur un X qui n'incluait pas config.TARGET_VARIABLE.
+        cols_to_drop_for_predict = [config.TARGET_VARIABLE]
+        # Si d'autres colonnes comme 'id_employee' sont présentes dans df_featured mais que la pipeline
+        # ne les attend pas comme features (ce qui est le cas si elles ont été droppées avant le fit
+        # du preprocessor dans train_model.py), il faudrait les lister ici aussi.
+        # Cependant, le ColumnTransformer avec remainder='drop' devrait ignorer les colonnes inconnues.
+        # Mais c'est plus propre de présenter à la pipeline exactement ce qu'elle a vu à l'entraînement.
+        # X_predict = df_featured.drop(columns=[col for col in cols_to_drop_for_predict if col in df_featured.columns], errors="ignore")
+        
+        # En se basant sur train_model.py, X_predict ne doit pas contenir TARGET_VARIABLE.
+        # Les autres colonnes non-features (comme id_employee) ont été retirées AVANT
+        # la définition des listes de colonnes pour build_preprocessor, donc le preprocessor ne les attend pas.
+        if config.TARGET_VARIABLE in df_featured.columns:
+            X_predict = df_featured.drop(config.TARGET_VARIABLE, axis=1)
+        else:
+            X_predict = df_featured # Si TARGET_VARIABLE n'a pas été créé (ex: clean_data modifié)
+        
+        logger.info(f"Transformations manuelles appliquées. Shape de X_predict: {X_predict.shape}")
+        # logger.debug(f"Colonnes de X_predict avant la pipeline : {X_predict.columns.tolist()}")
 
-        logger.info("Transformations manuelles appliquées.")
 
         # --- ÉTAPE 2 : Utiliser la pipeline complète pour prédire ---
-        # La pipeline va maintenant appliquer le ColumnTransformer (scaling, OHE, etc.)
-        # ET ensuite le classifier.
+        logger.info("Application de la pipeline Scikit-learn pour la prédiction...")
         probabilities = pipeline.predict_proba(X_predict)[:, 1]
         predictions = pipeline.predict(X_predict)
+        logger.info("Calcul des probabilités et des classes terminé.")
 
         results = []
-        for i, index in enumerate(X_predict.index):
+        for i, index_val in enumerate(X_predict.index): # Renommé index en index_val pour éviter conflit
             results.append(
                 {
-                    "id_employe": index,
+                    "id_employe": index_val, # Utilise l'index du DataFrame d'entrée
                     "probabilite_depart": float(probabilities[i]),
                     "prediction_depart": int(predictions[i]),
                 }
             )
-        logger.info("Prédiction terminée.")
+        logger.info("Prédictions formatées avec succès.")
         return results
 
     except Exception as e:
-        logger.error(f"Erreur lors de la prédiction : {e}", exc_info=True)
-        return {"error": f"Erreur de prédiction: {e}"}
+        logger.error(f"Erreur critique lors du processus de prédiction : {e}", exc_info=True)
+        return {"error": f"Erreur de prédiction : {str(e)}"}
 
 
-# Pour tester : poetry run python -m src.modeling.predict
+# Pour tester ce module : poetry run python -m src.modeling.predict
 if __name__ == "__main__":
-    # Créez un exemple de données BRUTES (comme si elles venaient d'un nouveau formulaire ou BDD)
-    # Doit contenir TOUTES les colonnes présentes dans les données avant le preprocessing.
-    # Utilisez les mêmes noms que dans vos fichiers CSV initiaux.
-    sample_data = pd.DataFrame(
-        {
-            "age": 45,
-            "genre": "M",
-            "revenu_mensuel": 4850,
-            "statut_marital": "Célibataire",
-            "departement": "Commercial",
-            "poste": "Cadre Commercial",
-            "nombre_experiences_precedentes": 8,
-            "annees_dans_l_entreprise": 5,
-            "satisfaction_employee_environnement": 4,
-            "note_evaluation_precedente": 3,
-            "satisfaction_employee_nature_travail": 3,
-            "satisfaction_employee_equipe": 3,
-            "satisfaction_employee_equilibre_pro_perso": 3,
-            "note_evaluation_actuelle": 3,
-            "heure_supplementaires": "Non",
-            "augementation_salaire_precedente": 15,
-            "nombre_participation_pee": 0,
-            "nb_formations_suivies": 3,
-            "distance_domicile_travail": 20,
-            "niveau_education": 3,
-            "domaine_etude": "Infra & Cloud",
-            "frequence_deplacement": "Occasionnel",
-            "annees_depuis_la_derniere_promotion": 0,
-        },
-        index=["EMP_TEST_1"],
-    )  # Donner des index pour l'ID
-
-    # Vérifier si le modèle existe avant de tester
+    logger.info("--- Test direct du module predict.py ---")
+    # Exemple de données brutes (doit correspondre au schéma EmployeeInput de l'API)
+    sample_data_dict = {
+        # Assurez-vous que toutes les clés correspondent à EmployeeInput et aux attentes de clean_data
+        "age": [45, 30],
+        "genre": ["M", "F"], # Utiliser les valeurs textuelles brutes
+        "revenu_mensuel": [4850, 6000],
+        "statut_marital": ["Célibataire", "Marié(e)"],
+        "departement": ["Commercial", "R&D"],
+        "poste": ["Cadre Commercial", "Ingenieur"],
+        "nombre_experiences_precedentes": [8, 5],
+        "annees_dans_l_entreprise": [5, 2],
+        "satisfaction_employee_environnement": [4,3],
+        "note_evaluation_precedente": [3,4],
+        "satisfaction_employee_nature_travail": [3,2],
+        "satisfaction_employee_equipe": [3,4],
+        "satisfaction_employee_equilibre_pro_perso": [3,2],
+        "note_evaluation_actuelle": [3,4],
+        "heure_supplementaires": ["Non", "Oui"], # Valeurs textuelles brutes
+        "augementation_salaire_precedente": ["15 %", "10 %"], # Format texte brut
+        "nombre_participation_pee": [0,1],
+        "nb_formations_suivies": [3,1],
+        "distance_domicile_travail": [20,5],
+        "niveau_education": ["Bac+3", "Bac+5"], # Exemple, adaptez à vos données
+        "domaine_etude": ["Infra & Cloud", "Developpement"],
+        "frequence_deplacement": ["Occasionnel", "Frequent"], # Exemple, adaptez
+        "annees_depuis_la_derniere_promotion": [0,1],
+        # Pas besoin de 'a_quitte_l_entreprise' ici, la fonction predict_attrition l'ajoute temporairement
+    }
+    sample_df = pd.DataFrame(sample_data_dict, index=["EMP_TEST_A", "EMP_TEST_B"])
+
     if config.MODEL_PATH.exists():
-        predictions_output = predict_attrition(sample_data)
+        logger.info("Modèle trouvé, lancement de la prédiction test...")
+        predictions_output = predict_attrition(sample_df)
         print("\n--- Résultat de la Prédiction Test ---")
-        print(predictions_output)
+        if isinstance(predictions_output, dict) and "error" in predictions_output:
+            print(f"Erreur: {predictions_output['error']}")
+        else:
+            for res in predictions_output:
+                print(res)
     else:
         print(
-            f"\nModèle non trouvé à {config.MODEL_PATH}. Veuillez l'entraîner d'abord."
+            f"\nModèle non trouvé à {config.MODEL_PATH}. Veuillez l'entraîner d'abord avec train_model.py."
         )
+    logger.info("--- Fin du test direct du module predict.py ---")

src/modeling/train_model.py

@@ -1,9 +1,26 @@
+"""
+Module d'entraînement et d'évaluation du modèle de prédiction d'attrition.
+
+Ce script orchestre le pipeline complet de Machine Learning :
+1. Chargement des données prétraitées depuis la source configurée (PostgreSQL).
+2. (Optionnel) Création de features supplémentaires.
+3. Séparation des données en ensembles d'entraînement et de test.
+4. Identification des types de colonnes pour le preprocessing.
+5. Construction d'une pipeline Scikit-learn incluant :
+    - Un préprocesseur (ColumnTransformer) pour imputer, scaler (numériques)
+      et encoder (catégorielles OneHot et Ordinal).
+    - Un classifieur (actuellement LogisticRegression).
+6. Entraînement de la pipeline complète sur les données d'entraînement.
+7. Évaluation du modèle sur les données de test (Matrice de confusion, rapport de
+   classification, F2-score).
+8. Sauvegarde de la pipeline entraînée pour une utilisation ultérieure (prédictions).
+"""
 import numpy as np
-from joblib import dump
+from joblib import dump # Pour sauvegarder la pipeline
 import logging
 
 from sklearn.model_selection import train_test_split
-from sklearn.linear_model import LogisticRegression  # Ou RandomForestClassifier, etc.
+from sklearn.linear_model import LogisticRegression
 from sklearn.pipeline import Pipeline
 from sklearn.metrics import (
     classification_report,
@@ -11,140 +28,173 @@ from sklearn.metrics import (
     confusion_matrix,
 )
 
+# Fonctions et configurations importées des autres modules du projet
 from src.data_processing.load_data import get_data
-# from src.data_processing.load_data import load_and_merge_csvs
 from src.data_processing.preprocess import (
-    clean_data,
-    map_binary_features,
-    create_features,
-    build_preprocessor,
+    create_features, # Utilisé pour la création de features à la volée
+    build_preprocessor, # Pour construire le ColumnTransformer
 )
-from src import config
+from src import config # Pour TARGET_VARIABLE, ORDINAL_FEATURES_CATEGORIES, MODEL_PATH
 
+# Configuration du logging pour ce module
 logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
 
 def train_and_evaluate_pipeline():
     """
-    Orchestre le chargement, la préparation, l'entraînement,
-    l'évaluation et la sauvegarde de la pipeline ML.
+    Orchestre le chargement des données, la préparation, l'entraînement d'un modèle
+    de classification, son évaluation, et la sauvegarde de la pipeline entraînée.
+
+    Cette fonction est le point d'entrée principal pour le processus d'entraînement.
+    Elle utilise les configurations définies dans `config.py` et les fonctions
+    de `load_data.py` et `preprocess.py`.
+
+    Le modèle actuel est une Régression Logistique, et la métrique principale
+    d'évaluation est le F2-score pour la classe positive (départ d'employé).
+
+    Raises:
+        ValueError: Si la colonne cible n'est pas trouvée dans les données
+                    après les étapes initiales de chargement et de feature engineering.
     """
-    logger.info(">>> Début du processus d'entraînement et d'évaluation <<<")
+    logger.info(">>> Début du processus d'entraînement et d'évaluation du modèle <<<")
 
     # --- 1. Charger les données ---
-    # df_raw = load_and_merge_csvs()
+    logger.info("Étape 1: Chargement des données depuis la source configurée (PostgreSQL).")
     df_loaded = get_data(source="postgres")
     if df_loaded is None or df_loaded.empty:
-        logger.error("Arrêt : Impossible de charger les données ou DataFrame vide.")
+        logger.error("Arrêt : Impossible de charger les données ou DataFrame vide depuis la source.")
         return
 
-    # --- 3. Appliquer les transformations "sûres" (avant split) --- PAS BESOIN SI DEJA FAIT DANS populate_db
-    # df_cleaned = clean_data(df_raw)
-    # df_mapped = map_binary_features(df_cleaned, config.BINARY_FEATURES_MAPPING)
-    df_featured = create_features(df_loaded) # Assurez-vous que df_featured est bien défini
+    # --- 2. Création de Features (si applicable) ---
+    # Cette étape applique la fonction create_features pour toute ingénierie de features
+    # qui n'aurait pas été faite avant le stockage en base, ou qui est spécifique à l'entraînement.
+    logger.info("Étape 2: Application de la création de features (si définie).")
+    df_featured = create_features(df_loaded)
 
-    if df_featured.empty: # Vérifier après create_features (ou sur df_loaded si create_features ne fait rien)
-        logger.error("Arrêt : DataFrame vide après chargement/création de features.")
+    if df_featured.empty:
+        logger.error("Arrêt : DataFrame vide après l'étape de création de features.")
         return
 
-    df_for_training = df_featured.copy() 
+    df_for_training = df_featured.copy() # Utiliser une copie pour les modifications suivantes
 
-    if config.TARGET_VARIABLE not in df_for_training.columns: # CETTE VERIFICATION EST MAINTENANT APRES LE CHECK EMPTY
-        raise ValueError(f"La colonne cible '{config.TARGET_VARIABLE}' n'est pas présente.")
+    # --- 3. Vérification et Séparation de la Cible (y) et des Features (X) ---
+    logger.info("Étape 3: Séparation des features (X) et de la variable cible (y).")
+    if config.TARGET_VARIABLE not in df_for_training.columns:
+        logger.error(f"La colonne cible '{config.TARGET_VARIABLE}' est introuvable dans le DataFrame.")
+        raise ValueError(
+            f"La colonne cible '{config.TARGET_VARIABLE}' n'est pas présente dans les données chargées."
+        )
     
     y = df_for_training[config.TARGET_VARIABLE]
-    X = df_for_training.drop(config.TARGET_VARIABLE, axis=1)
-
-    # Colonnes à exclure de X car ce ne sont pas des features pour le modèle
-    # mais des identifiants ou des métadonnées de la BDD
+    
+    # Exclure la cible et les colonnes non-feature de X
     cols_to_exclude_from_features = [
-        config.TARGET_VARIABLE, 
-        'a_quitte_l_entreprise', # La version texte de la cible, si elle est encore là
-        'id_employee',
-        'date_creation_enregistrement', # Si elle vient de la BDD
-        'date_derniere_modification'  # Si elle vient de la BDD
-        # Ajoutez toute autre colonne qui ne doit pas être une feature
+        config.TARGET_VARIABLE,
+        "a_quitte_l_entreprise",  # Version texte originale de la cible, si présente
+        "id_employee",            # Identifiant, non utilisé comme feature
+        "date_creation_enregistrement",
+        "date_derniere_modification"
+        # Ajoutez d'autres colonnes à exclure si nécessaire
     ]
- 
-    X = df_for_training.drop(columns=[col for col in cols_to_exclude_from_features if col in df_for_training.columns], errors='ignore')
-    logger.info(f"Colonnes dans X avant train_test_split (après exclusion): {X.columns.tolist()}")
     
-    # --- 5. Séparer en Train / Test ---
-    logger.info("Séparation des données en ensembles d'entraînement et de test...")
+    X = df_for_training.drop(
+        columns=[col for col in cols_to_exclude_from_features if col in df_for_training.columns],
+        errors="ignore" # ignore si une colonne de la liste n'est pas trouvée dans df_for_training
+    )
+    logger.info(
+        f"Nombre de features initiales dans X avant train_test_split : {len(X.columns)}"
+    )
+    # logger.debug(f"Colonnes dans X : {X.columns.tolist()}") # Décommentez pour débogage détaillé
+
+    # --- 4. Séparation en Ensembles d'Entraînement et de Test ---
+    logger.info("Étape 4: Séparation des données en ensembles d'entraînement et de test (80%/20%).")
     X_train, X_test, y_train, y_test = train_test_split(
         X,
         y,
-        test_size=0.20,
-        random_state=42,
-        stratify=y,  # Stratify est important pour les classes déséquilibrées
+        test_size=0.20, # 20% des données pour le test
+        random_state=42, # Pour la reproductibilité
+        stratify=y,     # Maintient la proportion des classes dans les deux ensembles
     )
-    logger.info(f"Taille Train: {X_train.shape}, Taille Test: {X_test.shape}")
+    logger.info(f"Dimensions de l'ensemble d'entraînement - X_train: {X_train.shape}, y_train: {y_train.shape}")
+    logger.info(f"Dimensions de l'ensemble de test - X_test: {X_test.shape}, y_test: {y_test.shape}")
 
-    # --- 6. Identifier les types de colonnes (basé sur X_train !) ---
-    # C'est important de le faire sur X_train pour éviter toute fuite,
-    # même si dans ce cas, c'est juste pour obtenir les listes de noms.
+    # --- 5. Identification des Types de Colonnes pour le Préprocessing (basé sur X_train) ---
+    logger.info("Étape 5: Identification des types de colonnes pour le préprocessing (sur X_train).")
     potential_numerical_cols = X_train.select_dtypes(
         include=[np.number]
     ).columns.tolist()
-    ordinal_to_encode = list(config.ORDINAL_FEATURES_CATEGORIES.keys())
+    ordinal_to_encode = list(config.ORDINAL_FEATURES_CATEGORIES.keys()) # Colonnes définies comme ordinales
+    
+    # Les colonnes numériques à scaler sont celles qui sont numériques et non ordinales
     numerical_to_scale = [
         col for col in potential_numerical_cols if col not in ordinal_to_encode
     ]
-    onehot_to_encode = X_train.select_dtypes(
-        include=["object", "category"]
-    ).columns.tolist()
+    # Les colonnes pour OneHotEncoding sont celles de type object/category qui ne sont pas ordinales
+    onehot_to_encode = [
+        col for col in X_train.select_dtypes(include=["object", "category"]).columns.tolist()
+        if col not in ordinal_to_encode
+    ]
+    logger.info(f"Colonnes numériques à scaler : {numerical_to_scale}")
+    logger.info(f"Colonnes pour OneHotEncoding : {onehot_to_encode}")
+    logger.info(f"Colonnes pour OrdinalEncoding : {ordinal_to_encode}")
 
-    # --- 7. Construire le préprocesseur (non ajusté) ---
+    # --- 6. Construction du Préprocesseur ---
+    logger.info("Étape 6: Construction du préprocesseur Scikit-learn.")
     preprocessor = build_preprocessor(
         numerical_cols=numerical_to_scale,
         onehot_cols=onehot_to_encode,
         ordinal_cols=ordinal_to_encode,
-        ordinal_categories=config.ORDINAL_FEATURES_CATEGORIES,
+        ordinal_categories_map=config.ORDINAL_FEATURES_CATEGORIES, # Le nom du paramètre a été harmonisé
     )
 
-    # --- 8. Définir le modèle ---
-    # Ajoutez ici vos hyperparamètres optimisés si vous en avez.
-    # L'utilisation de class_weight='balanced' est une première approche
-    # pour gérer le déséquilibre. Vous pourriez intégrer SMOTE dans la pipeline
-    # si nécessaire (en utilisant imblearn.pipeline.Pipeline).
+    # --- 7. Définition du Modèle de Classification ---
+    logger.info("Étape 7: Définition du modèle (LogisticRegression).")
     classifier = LogisticRegression(
         random_state=42, class_weight="balanced", max_iter=1000
     )
 
-    # --- 9. Créer la Pipeline Complète ---
+    # --- 8. Création de la Pipeline Complète (Préprocesseur + Classifieur) ---
+    logger.info("Étape 8: Création de la pipeline Scikit-learn complète.")
     full_pipeline = Pipeline(
         steps=[("preprocessor", preprocessor), ("classifier", classifier)]
     )
     logger.info("Pipeline complète créée.")
 
-    # --- 10. Entraîner la Pipeline Complète (sur X_train, y_train) ---
-    # C'est ici que le 'fit' du preprocessor ET du classifier a lieu,
-    # UNIQUEMENT sur les données d'entraînement.
-    logger.info("Entraînement de la pipeline...")
+    # --- 9. Entraînement de la Pipeline Complète ---
+    logger.info("Étape 9: Entraînement de la pipeline sur l'ensemble d'entraînement...")
     full_pipeline.fit(X_train, y_train)
-    logger.info("Entraînement terminé.")
+    logger.info("Entraînement de la pipeline terminé.")
 
-    # --- 11. Évaluer la Pipeline (sur X_test, y_test) ---
-    logger.info("\n--- Évaluation sur le jeu de Test ---")
+    # --- 10. Évaluation de la Pipeline sur l'Ensemble de Test ---
+    logger.info("Étape 10: Évaluation de la pipeline sur l'ensemble de test...")
     y_pred = full_pipeline.predict(X_test)
+    # y_pred_proba = full_pipeline.predict_proba(X_test)[:, 1] # Gardé pour référence, mais non utilisé actuellement
 
+    logger.info("\n--- Résultats de l'Évaluation sur le Jeu de Test ---")
     print("\nMatrice de Confusion :\n", confusion_matrix(y_test, y_pred))
     print(
         "\nRapport de Classification :\n",
         classification_report(y_test, y_pred, target_names=["Non", "Oui"]),
     )
 
-    f2_scorer = fbeta_score(y_test, y_pred, beta=2)
-    print(f"\nF2-Score (privilégie le Rappel) : {f2_scorer:.4f}")
+    f2_scorer = fbeta_score(y_test, y_pred, beta=2, zero_division=0) # Ajout de zero_division pour éviter warning/erreur
+    print(f"\nF2-Score (privilégie le Rappel pour la classe 'Oui') : {f2_scorer:.4f}")
+
+    # --- 11. Sauvegarde de la Pipeline Ajustée ---
+    logger.info("Étape 11: Sauvegarde de la pipeline entraînée...")
+    try:
+        config.MODELS_DIR.mkdir(parents=True, exist_ok=True) # S'assurer que le dossier existe
+        dump(full_pipeline, config.MODEL_PATH)
+        logger.info(f"Pipeline complète et ajustée sauvegardée dans : {config.MODEL_PATH}")
+    except Exception as e_save:
+        logger.error(f"Erreur lors de la sauvegarde de la pipeline : {e_save}", exc_info=True)
+
 
-    # --- 12. Sauvegarder la Pipeline Ajustée ---
-    dump(full_pipeline, config.MODEL_PATH)
-    logger.info(f"Pipeline complète et ajustée sauvegardée dans {config.MODEL_PATH}")
-    logger.info(">>> Fin du processus <<<")
+    logger.info(">>> Fin du processus d'entraînement et d'évaluation <<<")
 
 
 if __name__ == "__main__":
-    train_and_evaluate_pipeline()
+    train_and_evaluate_pipeline()

tests/unit/test_load_data.py

@@ -1,75 +1,88 @@
 import pandas as pd
-import pytest
 from unittest.mock import patch, MagicMock, call
 
 from src.data_processing.load_data import (
     load_data_from_csv,
     load_data_from_postgres,
     get_data,
-    load_and_merge_csvs
+    load_and_merge_csvs,
 )
-from src import config as app_config # Pour config.PROCESSED_DATA_PATH
+from src import config as app_config  # Pour config.PROCESSED_DATA_PATH
+
 # Supposons que Employee est défini dans models.py pour le test de load_data_from_postgres
 # from src.database.models import Employee # Nécessaire si on mock db.query(Employee) spécifiquement
 
-@patch('src.data_processing.load_data.pd.read_csv')
-@patch('src.data_processing.load_data.logger')
+
+@patch("src.data_processing.load_data.pd.read_csv")
+@patch("src.data_processing.load_data.logger")
 def test_load_data_from_csv_success(mock_logger, mock_read_csv):
     """Teste le chargement réussi depuis un CSV."""
-    sample_df = pd.DataFrame({'col1': [1], 'col2': ['a']})
+    sample_df = pd.DataFrame({"col1": [1], "col2": ["a"]})
     mock_read_csv.return_value = sample_df
-    
-    df = load_data_from_csv("dummy_path.csv")
-    
-    mock_read_csv.assert_called_once_with("dummy_path.csv")
-    mock_logger.info.assert_any_call("Chargement des données CSV depuis dummy_path.csv...")
-    mock_logger.info.assert_any_call("Données CSV chargées avec succès.")
+
+    dummy_path = "dummy_path.csv"
+    df = load_data_from_csv(dummy_path) # path est dummy_path
+
+    mock_read_csv.assert_called_once_with(dummy_path)
+    mock_logger.info.assert_any_call(f"Chargement des données CSV depuis {dummy_path}...")
+    mock_logger.info.assert_any_call(f"Données CSV chargées avec succès depuis {dummy_path}: {len(sample_df)} lignes.")
     pd.testing.assert_frame_equal(df, sample_df)
 
-@patch('src.data_processing.load_data.pd.read_csv')
-@patch('src.data_processing.load_data.logger')
+
+@patch("src.data_processing.load_data.pd.read_csv")
+@patch("src.data_processing.load_data.logger")
 def test_load_data_from_csv_file_not_found(mock_logger, mock_read_csv):
     """Teste la gestion de FileNotFoundError pour load_data_from_csv."""
     mock_read_csv.side_effect = FileNotFoundError("File not found")
-    
+
     df = load_data_from_csv("non_existent.csv")
-    
+
     assert df is None
-    mock_logger.error.assert_called_once_with("Fichier CSV non trouvé : non_existent.csv")
+    mock_logger.error.assert_called_once_with(
+        "Fichier CSV non trouvé : non_existent.csv"
+    )
 
-@patch('src.data_processing.load_data.SessionLocal') # Mocker la classe SessionLocal
-@patch('src.data_processing.load_data.pd.read_sql_query')
-@patch('src.data_processing.load_data.logger')
+
+@patch("src.data_processing.load_data.SessionLocal")  # Mocker la classe SessionLocal
+@patch("src.data_processing.load_data.pd.read_sql_query")
+@patch("src.data_processing.load_data.logger")
 def test_load_data_from_postgres_success(mock_logger, mock_read_sql, mock_SessionLocal):
     """Teste le chargement réussi depuis PostgreSQL."""
-    sample_df = pd.DataFrame({'id_employee': ['E_1'], 'age': [30]})
+    sample_df = pd.DataFrame({"id_employee": ["E_1"], "age": [30]})
     mock_read_sql.return_value = sample_df
-    
+
     # Configurer le mock de la session et de la query
     mock_db_session = MagicMock()
-    mock_SessionLocal.return_value = mock_db_session # Quand SessionLocal() est appelé, il retourne notre mock
-    
+    mock_SessionLocal.return_value = (
+        mock_db_session  # Quand SessionLocal() est appelé, il retourne notre mock
+    )
+
     # Si votre query est db.query(Employee), vous pouvez mocker Employee
     # from src.database.models import Employee (déjà importé si décommenté plus haut)
     # mock_query_obj = MagicMock()
     # mock_db_session.query.return_value = mock_query_obj
 
     df = load_data_from_postgres()
-    
-    mock_SessionLocal.assert_called_once() # Vérifie que SessionLocal() a été instancié
+
+    mock_SessionLocal.assert_called_once()  # Vérifie que SessionLocal() a été instancié
     # mock_db_session.query.assert_called_once_with(Employee) # Si vous mockez Employee
     # mock_read_sql.assert_called_once_with(mock_query_obj.statement, mock_db_session.bind)
     # Version plus simple si on ne mocke pas la query en détail :
     assert mock_read_sql.call_count == 1
 
-    mock_logger.info.assert_any_call("Chargement des données depuis la table 'employees' de PostgreSQL...")
-    mock_logger.info.assert_any_call(f"{len(sample_df)} lignes chargées depuis la table 'employees'.")
+    mock_logger.info.assert_any_call(
+        "Chargement des données depuis la table 'employees' de PostgreSQL..."
+    )
+    mock_logger.info.assert_any_call(
+        f"{len(sample_df)} lignes chargées depuis la table 'employees'."
+    )
     pd.testing.assert_frame_equal(df, sample_df)
-    mock_db_session.close.assert_called_once() # Vérifie que la session est fermée
+    mock_db_session.close.assert_called_once()  # Vérifie que la session est fermée
+
 
-@patch('src.data_processing.load_data.SessionLocal')
-@patch('src.data_processing.load_data.pd.read_sql_query')
-@patch('src.data_processing.load_data.logger')
+@patch("src.data_processing.load_data.SessionLocal")
+@patch("src.data_processing.load_data.pd.read_sql_query")
+@patch("src.data_processing.load_data.logger")
 def test_load_data_from_postgres_empty(mock_logger, mock_read_sql, mock_SessionLocal):
     """Teste le chargement depuis PostgreSQL quand la table est vide."""
     empty_df = pd.DataFrame()
@@ -78,31 +91,39 @@ def test_load_data_from_postgres_empty(mock_logger, mock_read_sql, mock_SessionL
     mock_SessionLocal.return_value = mock_db_session
 
     df = load_data_from_postgres()
-    
+
     pd.testing.assert_frame_equal(df, empty_df)
-    mock_logger.warning.assert_called_once_with("Aucune donnée trouvée dans la table 'employees'. Le DataFrame est vide.")
+    mock_logger.warning.assert_called_once_with(
+        "Aucune donnée trouvée dans la table 'employees'. Le DataFrame est vide."
+    )
     mock_db_session.close.assert_called_once()
 
-@patch('src.data_processing.load_data.SessionLocal')
-@patch('src.data_processing.load_data.pd.read_sql_query')
-@patch('src.data_processing.load_data.logger')
-def test_load_data_from_postgres_exception(mock_logger, mock_read_sql, mock_SessionLocal):
+
+@patch("src.data_processing.load_data.SessionLocal")
+@patch("src.data_processing.load_data.pd.read_sql_query")
+@patch("src.data_processing.load_data.logger")
+def test_load_data_from_postgres_exception(
+    mock_logger, mock_read_sql, mock_SessionLocal
+):
     """Teste la gestion d'exception lors du chargement depuis PostgreSQL."""
     mock_read_sql.side_effect = Exception("DB Connection Error")
     mock_db_session = MagicMock()
     mock_SessionLocal.return_value = mock_db_session
 
     df = load_data_from_postgres()
-    
-    assert df.empty # Doit retourner un DataFrame vide
+
+    assert df.empty  # Doit retourner un DataFrame vide
     mock_logger.error.assert_called_once_with(
         "Erreur lors du chargement des données depuis PostgreSQL : DB Connection Error",
-        exc_info=True
+        exc_info=True,
     )
     mock_db_session.close.assert_called_once()
 
-@patch('src.data_processing.load_data.load_data_from_postgres')
-@patch('src.data_processing.load_data.load_and_merge_csvs') # Si get_data(source='csv') l'appelle
+
+@patch("src.data_processing.load_data.load_data_from_postgres")
+@patch(
+    "src.data_processing.load_data.load_and_merge_csvs"
+)  # Si get_data(source='csv') l'appelle
 # Ou @patch('src.data_processing.load_data.load_data_from_csv') si c'est ce qu'elle appelle
 def test_get_data_source_postgres(mock_load_csv_or_merge, mock_load_postgres):
     """Teste get_data avec source='postgres'."""
@@ -112,8 +133,9 @@ def test_get_data_source_postgres(mock_load_csv_or_merge, mock_load_postgres):
     mock_load_csv_or_merge.assert_not_called()
     assert result == "data_from_db"
 
-@patch('src.data_processing.load_data.load_data_from_postgres')
-@patch('src.data_processing.load_data.load_and_merge_csvs') # Adaptez ce mock
+
+@patch("src.data_processing.load_data.load_data_from_postgres")
+@patch("src.data_processing.load_data.load_and_merge_csvs")  # Adaptez ce mock
 def test_get_data_source_csv(mock_load_csv_or_merge, mock_load_postgres):
     """Teste get_data avec source='csv'."""
     mock_load_csv_or_merge.return_value = "data_from_csv"
@@ -122,34 +144,43 @@ def test_get_data_source_csv(mock_load_csv_or_merge, mock_load_postgres):
     mock_load_postgres.assert_not_called()
     assert result == "data_from_csv"
 
-@patch('src.data_processing.load_data.load_data_from_postgres')
-@patch('src.data_processing.load_data.logger')
+
+@patch("src.data_processing.load_data.load_data_from_postgres")
+@patch("src.data_processing.load_data.logger")
 def test_get_data_invalid_source(mock_logger, mock_load_postgres):
     """Teste get_data avec une source invalide (doit utiliser postgres par défaut)."""
     mock_load_postgres.return_value = "data_from_db_default"
     result = get_data(source="invalid_source")
-    mock_load_postgres.assert_called_once() # Appelée car c'est le défaut
-    mock_logger.error.assert_any_call("Source de données non reconnue : invalid_source. Utilisation de PostgreSQL par défaut.")
+    mock_load_postgres.assert_called_once()  # Appelée car c'est le défaut
+    source_name = "invalid_source"
+    expected_log_msg = f"Source de données non reconnue : {source_name}. Tentative avec PostgreSQL par défaut."
+    mock_logger.error.assert_any_call(expected_log_msg)
     assert result == "data_from_db_default"
-    
-@patch('src.data_processing.load_data.logger') # Mocker le logger en premier (ordre des décorateurs inversé)
-@patch('src.data_processing.load_data.pd.read_csv')
+
+
+@patch(
+    "src.data_processing.load_data.logger"
+)  # Mocker le logger en premier (ordre des décorateurs inversé)
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_success(mock_read_csv, mock_logger):
     """Teste le chargement et la fusion réussis des 3 CSV."""
     # 1. Préparer les DataFrames de simulation retournés par read_csv
-    df_sirh_sample = pd.DataFrame({
-        'id_employee': ['1', '2', '3'],
-        'sirh_feature': ['A1', 'A2', 'A3']
-    })
+    df_sirh_sample = pd.DataFrame(
+        {"id_employee": ["1", "2", "3"], "sirh_feature": ["A1", "A2", "A3"]}
+    )
     # df_eval avec des eval_number qui seront transformés en id_employee '1', '2', 'SPECIAL'
-    df_eval_sample = pd.DataFrame({
-        'eval_number': ['E_1', 'E_2', 'E_SPECIAL'],
-        'eval_feature': ['EvalX', 'EvalY', 'EvalZ']
-    })
-    df_sondage_sample = pd.DataFrame({
-        'id_employee': ['1', '3'], # ID '2' manquant, 'SPECIAL' non présent
-        'sondage_feature': ['SondA', 'SondC']
-    })
+    df_eval_sample = pd.DataFrame(
+        {
+            "eval_number": ["E_1", "E_2", "E_SPECIAL"],
+            "eval_feature": ["EvalX", "EvalY", "EvalZ"],
+        }
+    )
+    df_sondage_sample = pd.DataFrame(
+        {
+            "id_employee": ["1", "3"],  # ID '2' manquant, 'SPECIAL' non présent
+            "sondage_feature": ["SondA", "SondC"],
+        }
+    )
 
     # Configurer le side_effect de mock_read_csv pour retourner ces DataFrames dans l'ordre
     mock_read_csv.side_effect = [df_sirh_sample, df_eval_sample, df_sondage_sample]
@@ -162,107 +193,132 @@ def test_load_and_merge_csvs_success(mock_read_csv, mock_logger):
     expected_calls = [
         call(app_config.RAW_SIRH_PATH),
         call(app_config.RAW_EVAL_PATH),
-        call(app_config.RAW_SONDAGE_PATH)
+        call(app_config.RAW_SONDAGE_PATH),
     ]
     mock_read_csv.assert_has_calls(expected_calls, any_order=False)
     assert mock_read_csv.call_count == 3
 
     # Vérifier les logs importants
-    mock_logger.info.assert_any_call("Chargement des fichiers CSV bruts...")
-    mock_logger.info.assert_any_call("Préparation de la clé de jointure dans df_eval...")
+    mock_logger.info.assert_any_call("Chargement des fichiers CSV bruts pour fusion...")
+    mock_logger.info.assert_any_call("Préparation de la clé de jointure 'id_employee' dans df_eval à partir de 'eval_number'...")
+    mock_logger.info.assert_any_call("Préparation de la clé de jointure 'id_employee' dans df_sondage à partir de 'code_sondage'...")
     # mock_logger.info.assert_any_call("'id_employee' créé dans df_eval.") # log absent du fichier load_data.py
-    mock_logger.info.assert_any_call("Fusion des DataFrames...")
+    mock_logger.info.assert_any_call("Fusion des DataFrames (df_sirh <- df_eval <- df_sondage)...")
     # mock_logger.info.assert_any_call(f"Données fusionnées : {merged_df.shape}") # Le shape peut varier
 
     # Vérifier le DataFrame fusionné
     assert merged_df is not None
-    assert list(merged_df.columns) == ['id_employee', 'sirh_feature', 'eval_number', 'eval_feature', 'sondage_feature']
-    assert len(merged_df) == 3 # Car left merge depuis df_sirh_sample
+    assert list(merged_df.columns) == [
+        "id_employee",
+        "sirh_feature",
+        "eval_number",
+        "eval_feature",
+        "sondage_feature",
+    ]
+    assert len(merged_df) == 3  # Car left merge depuis df_sirh_sample
 
     # Vérifier le contenu (basé sur df_sirh en tant que table de gauche pour les merges)
     # Ligne pour id_employee '1'
-    row_1 = merged_df[merged_df['id_employee'] == '1'].iloc[0]
-    assert row_1['sirh_feature'] == 'A1'
-    assert row_1['eval_feature'] == 'EvalX'
-    assert row_1['sondage_feature'] == 'SondA'
+    row_1 = merged_df[merged_df["id_employee"] == "1"].iloc[0]
+    assert row_1["sirh_feature"] == "A1"
+    assert row_1["eval_feature"] == "EvalX"
+    assert row_1["sondage_feature"] == "SondA"
 
     # Ligne pour id_employee '2'
-    row_2 = merged_df[merged_df['id_employee'] == '2'].iloc[0]
-    assert row_2['sirh_feature'] == 'A2'
-    assert row_2['eval_feature'] == 'EvalY'
-    assert pd.isna(row_2['sondage_feature']) # Pas de '2' dans df_sondage_sample
+    row_2 = merged_df[merged_df["id_employee"] == "2"].iloc[0]
+    assert row_2["sirh_feature"] == "A2"
+    assert row_2["eval_feature"] == "EvalY"
+    assert pd.isna(row_2["sondage_feature"])  # Pas de '2' dans df_sondage_sample
 
     # Ligne pour id_employee '3'
-    row_3 = merged_df[merged_df['id_employee'] == '3'].iloc[0]
-    assert row_3['sirh_feature'] == 'A3'
-    assert pd.isna(row_3['eval_feature']) # 'E_3' n'est pas dans df_eval_sample, df_eval a 'E_SPECIAL' qui donne 'SPECIAL'
-    assert row_3['sondage_feature'] == 'SondC'
-    
+    row_3 = merged_df[merged_df["id_employee"] == "3"].iloc[0]
+    assert row_3["sirh_feature"] == "A3"
+    assert pd.isna(
+        row_3["eval_feature"]
+    )  # 'E_3' n'est pas dans df_eval_sample, df_eval a 'E_SPECIAL' qui donne 'SPECIAL'
+    assert row_3["sondage_feature"] == "SondC"
+
     # Vérifier le type de la colonne 'id_employee'
-    assert merged_df['id_employee'].dtype == 'object'
+    assert merged_df["id_employee"].dtype == "object"
 
 
-@patch('src.data_processing.load_data.logger')
-@patch('src.data_processing.load_data.pd.read_csv')
+@patch("src.data_processing.load_data.logger")
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_sirh_file_not_found(mock_read_csv, mock_logger):
     """Teste FileNotFoundError pour le fichier SIRH."""
     mock_read_csv.side_effect = FileNotFoundError("SIRH file missing")
-    
+
     result_df = load_and_merge_csvs()
-    
+
     assert result_df is None
-    mock_logger.error.assert_any_call("Erreur de chargement CSV : Fichier non trouvé - SIRH file missing")
+    mock_logger.error.assert_any_call(
+        "Erreur de chargement CSV : Fichier non trouvé - SIRH file missing"
+    )
 
-@patch('src.data_processing.load_data.logger')
-@patch('src.data_processing.load_data.pd.read_csv')
+
+@patch("src.data_processing.load_data.logger")
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_eval_file_not_found(mock_read_csv, mock_logger):
     """Teste FileNotFoundError pour le fichier EVAL."""
-    df_sirh_sample = pd.DataFrame({'id_employee': ['1']})
+    df_sirh_sample = pd.DataFrame({"id_employee": ["1"]})
     mock_read_csv.side_effect = [df_sirh_sample, FileNotFoundError("EVAL file missing")]
-    
+
     result_df = load_and_merge_csvs()
-    
+
     assert result_df is None
-    mock_logger.error.assert_any_call("Erreur de chargement CSV : Fichier non trouvé - EVAL file missing")
+    mock_logger.error.assert_any_call(
+        "Erreur de chargement CSV : Fichier non trouvé - EVAL file missing"
+    )
 
 
-@patch('src.data_processing.load_data.logger')
-@patch('src.data_processing.load_data.pd.read_csv')
+@patch("src.data_processing.load_data.logger")
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_missing_eval_number_col(mock_read_csv, mock_logger):
     """Teste le cas où 'eval_number' manque dans df_eval."""
-    df_sirh_sample = pd.DataFrame({'id_employee': ['1']})
-    df_eval_no_eval_number = pd.DataFrame({'autre_col': ['X']}) # Pas de eval_number
-    df_sondage_sample = pd.DataFrame({'id_employee': ['1']})
-    mock_read_csv.side_effect = [df_sirh_sample, df_eval_no_eval_number, df_sondage_sample]
-    
+    df_sirh_sample = pd.DataFrame({"id_employee": ["1"]})
+    df_eval_no_eval_number = pd.DataFrame({"autre_col": ["X"]})  # Pas de eval_number
+    df_sondage_sample = pd.DataFrame({"id_employee": ["1"]})
+    mock_read_csv.side_effect = [
+        df_sirh_sample,
+        df_eval_no_eval_number,
+        df_sondage_sample,
+    ]
+
     result_df = load_and_merge_csvs()
-    
+
     assert result_df is None
-    mock_logger.error.assert_any_call("La colonne 'eval_number' est introuvable dans df_eval.")
+    mock_logger.error.assert_any_call("La colonne 'eval_number' est introuvable dans df_eval. Impossible de créer 'id_employee'.")
 
 
-@patch('src.data_processing.load_data.logger')
-@patch('src.data_processing.load_data.pd.read_csv')
+@patch("src.data_processing.load_data.logger")
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_missing_id_employee_in_sirh(mock_read_csv, mock_logger):
     """Teste le cas où 'id_employee' manque dans df_sirh."""
-    df_sirh_no_id = pd.DataFrame({'autre_col_sirh': ['Y']}) # Pas de id_employee
-    df_eval_sample = pd.DataFrame({'eval_number': ['E_1']})
-    df_sondage_sample = pd.DataFrame({'id_employee': ['1']})
+    df_sirh_no_id = pd.DataFrame({"autre_col_sirh": ["Y"]})  # Pas de id_employee
+    df_eval_sample = pd.DataFrame({"eval_number": ["E_1"]})
+    df_sondage_sample = pd.DataFrame({"id_employee": ["1"]})
     mock_read_csv.side_effect = [df_sirh_no_id, df_eval_sample, df_sondage_sample]
 
     result_df = load_and_merge_csvs()
 
     assert result_df is None
-    mock_logger.error.assert_any_call("La colonne 'id_employee' est introuvable dans df_sirh.")
+    mock_logger.error.assert_any_call(
+        "La colonne 'id_employee' est introuvable dans df_sirh."
+    )
 
 
-@patch('src.data_processing.load_data.logger')
-@patch('src.data_processing.load_data.pd.read_csv')
+@patch("src.data_processing.load_data.logger")
+@patch("src.data_processing.load_data.pd.read_csv")
 def test_load_and_merge_csvs_eval_number_conversion_warning(mock_read_csv, mock_logger):
     """Teste le warning pour les eval_number non convertibles."""
-    df_sirh_sample = pd.DataFrame({'id_employee': ['1', 'bad_id_format']})
-    df_eval_sample = pd.DataFrame({'eval_number': ['E_1', 'E_OK', 'WRONG_FORMAT', 'E_WRONG_TOO'], 'eval_feature': ['x1', 'x2', 'x3', 'x4']})
-    df_sondage_sample = pd.DataFrame({'id_employee': ['1', 'OK']})
+    df_sirh_sample = pd.DataFrame({"id_employee": ["1", "bad_id_format"]})
+    df_eval_sample = pd.DataFrame(
+        {
+            "eval_number": ["E_1", "E_OK", "WRONG_FORMAT", "E_WRONG_TOO"],
+            "eval_feature": ["x1", "x2", "x3", "x4"],
+        }
+    )
+    df_sondage_sample = pd.DataFrame({"id_employee": ["1", "OK"]})
     mock_read_csv.side_effect = [df_sirh_sample, df_eval_sample, df_sondage_sample]
 
     merged_df = load_and_merge_csvs()
@@ -272,10 +328,17 @@ def test_load_and_merge_csvs_eval_number_conversion_warning(mock_read_csv, mock_
     # La logique de split('_').str[1] va lever une erreur ou retourner NaN si pas de '_'.
     # pd.to_numeric(..., errors='coerce') transformera ces erreurs en NaN.
     # Ici, 'WRONG_FORMAT' et 'E_WRONG_TOO' devraient produire des NaN pour 'id_employee' dans df_eval.
-    mock_logger.warning.assert_any_call("3 'eval_number' n'ont pas pu être convertis en 'id_employee' valides.")
+    expected_warning_msg = "3 'eval_number' (après extraction) n'ont pas pu être convertis en id_employee numériques valides et sont devenus NaN."
+    mock_logger.warning.assert_any_call(expected_warning_msg)
     # mock_logger.warning.assert_any_call("3 'eval_number' n'ont pas pu être convertis en 'id_employee' valides.")
     assert merged_df is not None
     # La ligne avec id_employee '1' devrait avoir eval_feature 'x1'
-    assert merged_df.loc[merged_df['id_employee'] == '1', 'eval_feature'].iloc[0] == 'x1'
+    assert (
+        merged_df.loc[merged_df["id_employee"] == "1", "eval_feature"].iloc[0] == "x1"
+    )
     # La ligne avec id_employee 'bad_id_format' ne trouvera pas de correspondance dans df_eval et aura NaN pour eval_feature
-    assert pd.isna(merged_df.loc[merged_df['id_employee'] == 'bad_id_format', 'eval_feature'].iloc[0])
+    assert pd.isna(
+        merged_df.loc[merged_df["id_employee"] == "bad_id_format", "eval_feature"].iloc[
+            0
+        ]
+    )

tests/unit/test_predict.py

@@ -1,95 +1,123 @@
-import pytest
 from unittest.mock import patch, MagicMock
 import numpy as np
 import pandas as pd
 from src.modeling.predict import load_prediction_pipeline, predict_attrition
-from src import config # Pour config.MODEL_PATH
+from src import config  # Pour config.MODEL_PATH
 
-@patch('src.modeling.predict.load') # Mocker joblib.load
-@patch('src.modeling.predict.config.MODEL_PATH')
-@patch('src.modeling.predict.logger')
-def test_load_prediction_pipeline_success(mock_logger, mock_model_path, mock_joblib_load):
+
+@patch("src.modeling.predict.load")  # Mocker joblib.load
+@patch("src.modeling.predict.config.MODEL_PATH")
+@patch("src.modeling.predict.logger")
+def test_load_prediction_pipeline_success(
+    mock_logger, mock_model_path, mock_joblib_load
+):
     """Teste le chargement réussi de la pipeline."""
     mock_pipeline_obj = MagicMock()
     mock_joblib_load.return_value = mock_pipeline_obj
     mock_model_path.exists.return_value = True
-    
+
     # Réinitialiser la variable globale _pipeline pour ce test
     from src.modeling import predict
-    predict._pipeline = None 
+    predict._pipeline = None
 
     pipeline = load_prediction_pipeline()
 
     mock_model_path.exists.assert_called_once()
     mock_joblib_load.assert_called_once_with(mock_model_path)
-    mock_logger.info.assert_any_call(f"Chargement de la pipeline depuis {mock_model_path}...")
-    mock_logger.info.assert_any_call("Pipeline chargée avec succès.")
+    
+    # CORRECTION ICI :
+    expected_log_msg_loading = f"Chargement de la pipeline de prédiction depuis : {mock_model_path}..."
+    mock_logger.info.assert_any_call(expected_log_msg_loading)
+
+    mock_logger.info.assert_any_call("Pipeline de prédiction chargée avec succès.") # Vérifiez aussi ce message
     assert pipeline == mock_pipeline_obj
 
-@patch('src.modeling.predict.config.MODEL_PATH')
-@patch('src.modeling.predict.logger')
+
+@patch("src.modeling.predict.config.MODEL_PATH")
+@patch("src.modeling.predict.logger")
 def test_load_prediction_pipeline_file_not_found(mock_logger, mock_model_path):
     """Teste le cas où le fichier modèle n'est pas trouvé."""
     mock_model_path.exists.return_value = False
-    
+
     from src.modeling import predict
     predict._pipeline = None
 
     pipeline = load_prediction_pipeline()
 
+    # Assertions
     mock_model_path.exists.assert_called_once()
-    mock_logger.error.assert_any_call(f"Fichier pipeline non trouvé : {mock_model_path}")
+    
+    # CORRECTION ICI :
+    expected_log_msg = f"Fichier pipeline non trouvé à l'emplacement configuré : {mock_model_path}"
+    mock_logger.error.assert_any_call(expected_log_msg)
     assert pipeline is None
 
-@patch('src.modeling.predict.load')
-@patch('src.modeling.predict.config.MODEL_PATH')
-@patch('src.modeling.predict.logger')
-def test_load_prediction_pipeline_load_exception(mock_logger, mock_model_path, mock_joblib_load):
+
+@patch("src.modeling.predict.load")
+@patch("src.modeling.predict.config.MODEL_PATH")
+@patch("src.modeling.predict.logger")
+def test_load_prediction_pipeline_load_exception(
+    mock_logger, mock_model_path, mock_joblib_load
+):
     """Teste une exception lors du chargement du modèle."""
     mock_model_path.exists.return_value = True
-    mock_joblib_load.side_effect = Exception("Load error")
+    simulated_exception = Exception("Load error")
+    mock_joblib_load.side_effect = simulated_exception
+    mock_model_path.exists.return_value = True
 
     from src.modeling import predict
+
     predict._pipeline = None
 
     pipeline = load_prediction_pipeline()
 
-    mock_logger.error.assert_any_call("Erreur lors du chargement de la pipeline : Load error", exc_info=True)
+    expected_log_msg = f"Erreur critique lors du chargement de la pipeline : {simulated_exception}"
+    mock_logger.error.assert_any_call(expected_log_msg, exc_info=True)
     assert pipeline is None
-    
-@patch('src.modeling.predict.create_features')
-@patch('src.modeling.predict.map_binary_features')
-@patch('src.modeling.predict.clean_data')
-@patch('src.modeling.predict.load_prediction_pipeline')
-@patch('src.modeling.predict.logger')
+
+
+@patch("src.modeling.predict.create_features")
+@patch("src.modeling.predict.map_binary_features")
+@patch("src.modeling.predict.clean_data")
+@patch("src.modeling.predict.load_prediction_pipeline")
+@patch("src.modeling.predict.logger")
 def test_predict_attrition_success_path(
-    mock_logger, mock_load_pipeline, mock_clean_data,
-    mock_map_binary, mock_create_features
+    mock_logger,
+    mock_load_pipeline,
+    mock_clean_data,
+    mock_map_binary,
+    mock_create_features,
 ):
     """Teste le chemin de succès de predict_attrition avec des mocks."""
     # 1. Configurer les mocks
     mock_pipeline_instance = MagicMock()
     # MODIFIÉ : Retourner des tableaux NumPy et pour 1 seul échantillon
-    mock_pipeline_instance.predict_proba.return_value = np.array([[0.3, 0.7]]) # Pour 1 échantillon
-    mock_pipeline_instance.predict.return_value = np.array([1])              # Pour 1 échantillon
+    mock_pipeline_instance.predict_proba.return_value = np.array(
+        [[0.3, 0.7]]
+    )  # Pour 1 échantillon
+    mock_pipeline_instance.predict.return_value = np.array([1])  # Pour 1 échantillon
     mock_load_pipeline.return_value = mock_pipeline_instance
 
     # Simuler les DataFrames retournés par chaque étape de preprocessing
     # df_raw_input a 1 ligne, donc toutes les sorties mockées doivent aussi correspondre à 1 ligne
-    df_raw_input = pd.DataFrame({'feature1': ['A'], 'feature2': [10]}, index=['EMP_X'])
-    
+    df_raw_input = pd.DataFrame({"feature1": ["A"], "feature2": [10]}, index=["EMP_X"])
+
     # La fonction clean_data dans predict.py ajoute temporairement 'a_quitte_l_entreprise'
     df_cleaned_for_predict = df_raw_input.copy()
     # Supposons que config.TARGET_VARIABLE est 'a_quitte_l_entreprise_numeric'
-    df_cleaned_for_predict[config.TARGET_VARIABLE] = 0 # Ajout factice pour le mock
-    df_cleaned_for_predict['feature1_clean'] = 'A_clean' # Simuler le nettoyage
+    df_cleaned_for_predict[config.TARGET_VARIABLE] = 0  # Ajout factice pour le mock
+    df_cleaned_for_predict["feature1_clean"] = "A_clean"  # Simuler le nettoyage
     mock_clean_data.return_value = df_cleaned_for_predict
 
     # df_mapped_mock et df_featured_mock doivent aussi avoir 1 ligne
-    df_mapped_mock = pd.DataFrame({'feature1_map': [0], 'feature2_map': [10]}, index=['EMP_X'])
+    df_mapped_mock = pd.DataFrame(
+        {"feature1_map": [0], "feature2_map": [10]}, index=["EMP_X"]
+    )
     mock_map_binary.return_value = df_mapped_mock
-    
-    df_featured_mock = pd.DataFrame({'feature1_final': [0], 'feature2_final': [100]}, index=['EMP_X'])
+
+    df_featured_mock = pd.DataFrame(
+        {"feature1_final": [0], "feature2_final": [100]}, index=["EMP_X"]
+    )
     mock_create_features.return_value = df_featured_mock
 
     # 2. Appeler la fonction
@@ -99,23 +127,27 @@ def test_predict_attrition_success_path(
     # 3. Assertions
     mock_load_pipeline.assert_called_once()
     mock_clean_data.assert_called_once()
-    mock_map_binary.assert_called_once_with(mock_clean_data.return_value, config.BINARY_FEATURES_MAPPING)
+    mock_map_binary.assert_called_once_with(
+        mock_clean_data.return_value, config.BINARY_FEATURES_MAPPING
+    )
     mock_create_features.assert_called_once_with(mock_map_binary.return_value)
 
     # X_predict_expected est dérivé de df_featured_mock (1 ligne)
-    X_predict_expected = df_featured_mock.drop(columns=[config.TARGET_VARIABLE], errors='ignore')
-    
+    # X_predict_expected = df_featured_mock.drop(columns=[config.TARGET_VARIABLE], errors="ignore")
+
     # Vérifier que les méthodes de la pipeline sont appelées
     # L'argument passé à predict_proba sera X_predict_expected
     # Vous pouvez utiliser pd.testing.assert_frame_equal si vous voulez être très précis sur l'argument
     # mock_pipeline_instance.predict_proba.assert_called_once_with(X_predict_expected) # Ne fonctionnera pas directement avec assert_frame_equal ici
-    
+
     # Vérification des appels (plus simple et souvent suffisant)
     assert mock_pipeline_instance.predict_proba.call_count == 1
-    assert mock_pipeline_instance.predict.call_count == 1 # Devrait passer maintenant
+    assert mock_pipeline_instance.predict.call_count == 1  # Devrait passer maintenant
 
     assert len(results) == 1
-    assert results[0]['id_employe'] == 'EMP_X'
-    assert results[0]['probabilite_depart'] == 0.7 # Correspond à np.array([[0.3, 0.7]])[:, 1][0]
-    assert results[0]['prediction_depart'] == 1    # Correspond à np.array([1])[0]
-    mock_logger.info.assert_any_call("Prédiction terminée.")
+    assert results[0]["id_employe"] == "EMP_X"
+    assert (
+        results[0]["probabilite_depart"] == 0.7
+    )  # Correspond à np.array([[0.3, 0.7]])[:, 1][0]
+    assert results[0]["prediction_depart"] == 1  # Correspond à np.array([1])[0]
+    mock_logger.info.assert_any_call("Prédictions formatées avec succès.")

tests/unit/test_preprocess.py

@@ -4,9 +4,15 @@ from sklearn.compose import ColumnTransformer
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder
 from sklearn.impute import SimpleImputer
-from src.data_processing.preprocess import map_binary_features, clean_data, build_preprocessor, run_preprocessing_pipeline
+from src.data_processing.preprocess import (
+    map_binary_features,
+    clean_data,
+    build_preprocessor,
+    run_preprocessing_pipeline,
+)
 from src import config  # Pour config.TARGET_VARIABLE
 
+
 # --- Tests existants pour map_binary_features (assurez-vous qu'ils sont robustes) ---
 def test_map_binary_features_simple_case():
     """Teste le mappage binaire simple."""
@@ -40,6 +46,7 @@ def test_map_binary_features_unmapped_values():
     assert df_output["genre"].iloc[1] == 1
     assert pd.isna(df_output["genre"].iloc[2])  # Les valeurs non mappées deviennent NaN
 
+
 @pytest.fixture
 def sample_df_for_clean():
     """Crée un DataFrame d'exemple pour tester clean_data."""
@@ -62,9 +69,8 @@ def test_clean_data_target_conversion(sample_df_for_clean):
     """Vérifie la conversion correcte de la variable cible."""
     df_cleaned = clean_data(sample_df_for_clean)
     assert config.TARGET_VARIABLE in df_cleaned.columns
-    assert df_cleaned[config.TARGET_VARIABLE].equals(
-        pd.Series([1, 0, 1, 0], name=config.TARGET_VARIABLE)
-    )
+    expected_series = pd.Series([1, 0, 1, 0], name=config.TARGET_VARIABLE, dtype='Int64') # Spécifier dtype
+    assert df_cleaned[config.TARGET_VARIABLE].equals(expected_series)
 
 
 def test_clean_data_column_dropping(sample_df_for_clean):
@@ -91,112 +97,127 @@ def test_clean_data_percentage_conversion(sample_df_for_clean):
     )  # "Pas d'augmentation" devient NaN à cause de errors='coerce'
 
 
-def test_clean_data_with_missing_target_column():
-    """Vérifie que clean_data lève une erreur si la colonne cible est manquante."""
-    data = {"employee_id": [1], "eval_number": ["E_1"]}
-    df_no_target = pd.DataFrame(data)
-    with pytest.raises(ValueError, match="Colonne cible manquante"):
-        clean_data(df_no_target)
-
 def test_build_preprocessor_all_types():
     """Teste build_preprocessor avec tous les types de colonnes."""
-    numerical_cols = ['age', 'salaire']
-    onehot_cols = ['departement', 'poste']
-    ordinal_cols = ['frequence_deplacement']
-    ordinal_categories = {
-        'frequence_deplacement': ['Bas', 'Moyen', 'Haut']
-    }
+    numerical_cols = ["age", "salaire"]
+    onehot_cols = ["departement", "poste"]
+    ordinal_cols = ["frequence_deplacement"]
+    ordinal_categories = {"frequence_deplacement": ["Bas", "Moyen", "Haut"]}
 
-    preprocessor = build_preprocessor(numerical_cols, onehot_cols, ordinal_cols, ordinal_categories)
+    preprocessor = build_preprocessor(
+        numerical_cols, onehot_cols, ordinal_cols, ordinal_categories
+    )
 
     assert isinstance(preprocessor, ColumnTransformer)
-    assert len(preprocessor.transformers) == 3 # Un pour num, un pour onehot, un pour ord_frequence_deplacement
+    assert (
+        len(preprocessor.transformers) == 3
+    )  # Un pour num, un pour onehot, un pour ord_frequence_deplacement
 
     # Vérifier le transformateur numérique
-    num_transformer_tuple = next(t for t in preprocessor.transformers if t[0] == 'num')
+    num_transformer_tuple = next(t for t in preprocessor.transformers if t[0] == "num")
     assert isinstance(num_transformer_tuple[1], Pipeline)
     assert len(num_transformer_tuple[1].steps) == 2
     assert isinstance(num_transformer_tuple[1].steps[0][1], SimpleImputer)
-    assert num_transformer_tuple[1].steps[0][1].strategy == 'median'
+    assert num_transformer_tuple[1].steps[0][1].strategy == "median"
     assert isinstance(num_transformer_tuple[1].steps[1][1], StandardScaler)
     assert num_transformer_tuple[2] == numerical_cols
 
     # Vérifier le transformateur one-hot
-    onehot_transformer_tuple = next(t for t in preprocessor.transformers if t[0] == 'onehot')
+    onehot_transformer_tuple = next(
+        t for t in preprocessor.transformers if t[0] == "onehot"
+    )
     assert isinstance(onehot_transformer_tuple[1], Pipeline)
     assert len(onehot_transformer_tuple[1].steps) == 2
     assert isinstance(onehot_transformer_tuple[1].steps[0][1], SimpleImputer)
-    assert onehot_transformer_tuple[1].steps[0][1].strategy == 'most_frequent'
+    assert onehot_transformer_tuple[1].steps[0][1].strategy == "most_frequent"
     assert isinstance(onehot_transformer_tuple[1].steps[1][1], OneHotEncoder)
-    assert onehot_transformer_tuple[1].steps[1][1].drop == 'first'
-    assert onehot_transformer_tuple[1].steps[1][1].handle_unknown == 'ignore'
+    assert onehot_transformer_tuple[1].steps[1][1].drop == "first"
+    assert onehot_transformer_tuple[1].steps[1][1].handle_unknown == "ignore"
     assert onehot_transformer_tuple[2] == onehot_cols
-    
+
     # Vérifier le transformateur ordinal pour 'frequence_deplacement'
-    ord_transformer_tuple = next(t for t in preprocessor.transformers if t[0] == 'ord_frequence_deplacement')
+    ord_transformer_tuple = next(
+        t for t in preprocessor.transformers if t[0] == "ord_frequence_deplacement"
+    )
     assert isinstance(ord_transformer_tuple[1], Pipeline)
     assert len(ord_transformer_tuple[1].steps) == 2
     assert isinstance(ord_transformer_tuple[1].steps[0][1], SimpleImputer)
     assert isinstance(ord_transformer_tuple[1].steps[1][1], OrdinalEncoder)
-    assert ord_transformer_tuple[1].steps[1][1].categories == [['Bas', 'Moyen', 'Haut']]
-    assert ord_transformer_tuple[2] == ['frequence_deplacement']
+    assert ord_transformer_tuple[1].steps[1][1].categories == [["Bas", "Moyen", "Haut"]]
+    assert ord_transformer_tuple[2] == ["frequence_deplacement"]
 
 
 def test_build_preprocessor_only_numerical():
     """Teste build_preprocessor avec seulement des colonnes numériques."""
-    numerical_cols = ['age', 'salaire']
+    numerical_cols = ["age", "salaire"]
     preprocessor = build_preprocessor(numerical_cols, [], [], {})
     assert isinstance(preprocessor, ColumnTransformer)
     assert len(preprocessor.transformers) == 1
-    assert preprocessor.transformers[0][0] == 'num'
+    assert preprocessor.transformers[0][0] == "num"
     assert preprocessor.transformers[0][2] == numerical_cols
 
+
 def test_build_preprocessor_ordinal_col_missing_categories():
     """Teste que build_preprocessor lève une erreur si une catégorie ordinale est manquante."""
     numerical_cols = []
     onehot_cols = []
-    ordinal_cols = ['niveau_satisfaction'] # Cette colonne n'est pas dans ordinal_categories
-    with pytest.raises(ValueError, match="Les catégories pour 'niveau_satisfaction' ne sont pas définies."):
-        build_preprocessor(numerical_cols, onehot_cols, ordinal_cols, config.ORDINAL_FEATURES_CATEGORIES)
+    ordinal_cols = [
+        "niveau_satisfaction"
+    ]  # Cette colonne n'est pas dans ordinal_categories
+    expected_error_message = "Les catégories pour la colonne ordinale 'niveau_satisfaction' ne sont pas définies dans ordinal_categories_map."
+    with pytest.raises(ValueError, match=expected_error_message):
+        build_preprocessor(numerical_cols, onehot_cols, ordinal_cols, config.ORDINAL_FEATURES_CATEGORIES) # Utilisez un nom de variable clair pour le dict de catégories
+
 
 def test_build_preprocessor_no_cols():
     """Teste build_preprocessor quand aucune colonne n'est spécifiée."""
     preprocessor = build_preprocessor([], [], [], {})
     assert isinstance(preprocessor, ColumnTransformer)
-    assert len(preprocessor.transformers) == 0 # Devrait retourner un ColumnTransformer vide
-    assert preprocessor.remainder == 'passthrough' # Selon votre implémentation actuelle
-                                                 # (j'avais mis 'drop', si c'est passthrough, adaptez le test ou la fonction)
+    assert (
+        len(preprocessor.transformers) == 0
+    )  # Devrait retourner un ColumnTransformer vide
+    assert (
+        preprocessor.remainder == "passthrough"
+    )  # Selon votre implémentation actuelle
+    # (j'avais mis 'drop', si c'est passthrough, adaptez le test ou la fonction)
     # Ma version de build_preprocessor avait 'remainder="drop"' et retournait un CT vide.
     # Si vous voulez qu'il soit 'passthrough' dans ce cas, modifiez la fonction ou le test.
     # Pour 'remainder="drop"', len(preprocessor.transformers) == 0 est correct.
-    
+
+
 @pytest.fixture
 def sample_raw_df_for_pipeline():
     """DataFrame brut d'exemple pour tester le pipeline complet."""
     data = {
-        'employee_id': ['E_1', 'E_2', 'E_3', 'E_4'],
-        'a_quitte_l_entreprise': ['Oui', 'Non', 'Oui', 'Non'],
-        'genre': ['M', 'F', 'M', 'F'],
-        'heure_supplementaires': ['Oui', 'Non', 'Non', 'Oui'],
-        'frequence_deplacement': ['Occasionnel', 'Aucun', 'Frequent', 'Occasionnel'],
-        'augmentation_salaire_precedente': ["10 %", "5 %", "12 %", "8 %"],
-        'age': [30, 45, 22, 50],
-        'salaire_mensuel_brut': [5000, 8000, 3500, 9000],
-        'departement': ['Ventes', 'R&D', 'Ventes', 'Marketing'],
+        "employee_id": ["E_1", "E_2", "E_3", "E_4"],
+        "a_quitte_l_entreprise": ["Oui", "Non", "Oui", "Non"],
+        "genre": ["M", "F", "M", "F"],
+        "heure_supplementaires": ["Oui", "Non", "Non", "Oui"],
+        "frequence_deplacement": ["Occasionnel", "Aucun", "Frequent", "Occasionnel"],
+        "augmentation_salaire_precedente": ["10 %", "5 %", "12 %", "8 %"],
+        "age": [30, 45, 22, 50],
+        "salaire_mensuel_brut": [5000, 8000, 3500, 9000],
+        "departement": ["Ventes", "R&D", "Ventes", "Marketing"],
         # Ajoutez d'autres colonnes pour couvrir tous vos types
-        config.TARGET_VARIABLE: [1,0,1,0] # La fonction clean_data va écraser ça, mais pour la cohérence
+        config.TARGET_VARIABLE: [
+            1,
+            0,
+            1,
+            0,
+        ],  # La fonction clean_data va écraser ça, mais pour la cohérence
     }
     return pd.DataFrame(data)
 
+
 def test_run_preprocessing_pipeline_fit_true(sample_raw_df_for_pipeline):
     """Teste run_preprocessing_pipeline en mode fit=True."""
     df_in = sample_raw_df_for_pipeline.copy()
-    
+
     X_processed, y_processed, fitted_processor = run_preprocessing_pipeline(
         df_in,
         binary_cols_map=config.BINARY_FEATURES_MAPPING,
-        ordinal_cols_categories=config.ORDINAL_FEATURES_CATEGORIES,
-        fit=True
+        ordinal_cols_categories_map=config.ORDINAL_FEATURES_CATEGORIES,
+        fit=True,
     )
 
     assert isinstance(X_processed, pd.DataFrame)
@@ -204,20 +225,26 @@ def test_run_preprocessing_pipeline_fit_true(sample_raw_df_for_pipeline):
     assert isinstance(fitted_processor, ColumnTransformer)
     assert X_processed.shape[0] == len(df_in)
     assert y_processed.shape[0] == len(df_in)
-    
+
     # Vérifier que les colonnes attendues (après OHE, etc.) sont là
     # Ceci dépendra de vos colonnes exactes et de get_feature_names_out
     # Par exemple, on s'attend à voir des colonnes issues du OHE de 'departement'
-    assert any(col.startswith('onehot__departement_') for col in X_processed.columns)
-    assert 'num__age' in X_processed.columns
-    assert f'ord_frequence_deplacement__{config.ORDINAL_FEATURES_CATEGORIES["frequence_deplacement"][0]}' not in X_processed.columns # OrdinalEncoder ne préfixe pas comme ça
-    assert 'ord_frequence_deplacement__frequence_deplacement' in X_processed.columns # ou juste 'frequence_deplacement' si remainder='passthrough' et ord pas dans CT
+    assert any(col.startswith("onehot__departement_") for col in X_processed.columns)
+    assert "num__age" in X_processed.columns
+    assert (
+        f'ord_frequence_deplacement__{config.ORDINAL_FEATURES_CATEGORIES["frequence_deplacement"][0]}'
+        not in X_processed.columns
+    )  # OrdinalEncoder ne préfixe pas comme ça
+    assert (
+        "ord_frequence_deplacement__frequence_deplacement" in X_processed.columns
+    )  # ou juste 'frequence_deplacement' si remainder='passthrough' et ord pas dans CT
 
     # Vérifier que le processeur est "fitté" (ex: StandardScaler a mean_ et scale_)
     # Accéder au transformateur numérique dans le ColumnTransformer
-    num_pipeline = fitted_processor.named_transformers_['num']
-    scaler = num_pipeline.named_steps['scaler']
-    assert hasattr(scaler, 'mean_') and scaler.mean_ is not None
+    num_pipeline = fitted_processor.named_transformers_["num"]
+    scaler = num_pipeline.named_steps["scaler"]
+    assert hasattr(scaler, "mean_") and scaler.mean_ is not None
+
 
 @pytest.mark.filterwarnings("ignore:Found unknown categories.*:UserWarning")
 def test_run_preprocessing_pipeline_fit_false(sample_raw_df_for_pipeline):
@@ -228,16 +255,16 @@ def test_run_preprocessing_pipeline_fit_false(sample_raw_df_for_pipeline):
     _, _, fitted_processor = run_preprocessing_pipeline(
         df_train,
         binary_cols_map=config.BINARY_FEATURES_MAPPING,
-        ordinal_cols_categories=config.ORDINAL_FEATURES_CATEGORIES,
-        fit=True
+        ordinal_cols_categories_map=config.ORDINAL_FEATURES_CATEGORIES,
+        fit=True,
     )
-    
+
     X_test_processed, y_test_processed = run_preprocessing_pipeline(
-        df_test, 
-        binary_cols_map=config.BINARY_FEATURES_MAPPING, # Toujours nécessaire pour map_binary_features
-        ordinal_cols_categories=config.ORDINAL_FEATURES_CATEGORIES, # Toujours nécessaire pour build_preprocessor si pas fitté
-        preprocessor=fitted_processor, 
-        fit=False
+        df_test,
+        binary_cols_map=config.BINARY_FEATURES_MAPPING,  # Toujours nécessaire pour map_binary_features
+        ordinal_cols_categories_map=config.ORDINAL_FEATURES_CATEGORIES,  # Toujours nécessaire pour build_preprocessor si pas fitté
+        preprocessor=fitted_processor,
+        fit=False,
     )
 
     assert isinstance(X_test_processed, pd.DataFrame)
@@ -245,9 +272,22 @@ def test_run_preprocessing_pipeline_fit_false(sample_raw_df_for_pipeline):
     # Le nombre de colonnes doit être le même que celui obtenu après fit_transform sur le train
     # Pour cela, il faudrait stocker X_train_processed.shape[1] du test précédent
 
-def test_run_preprocessing_pipeline_fit_false_no_processor():
-    """Teste que fit=False sans preprocessor lève une ValueError."""
-    df_in = pd.DataFrame({'a_quitte_l_entreprise': ['Oui']}) # Minimal DF
-    
-    with pytest.raises(ValueError, match="Un preprocessor doit être fourni si fit=False."):
-        run_preprocessing_pipeline(df_in, fit=False)
+
+def test_run_preprocessing_pipeline_fit_false_no_processor(sample_raw_df_for_pipeline): # Utilisez la fixture
+    """Teste que fit=False sans preprocessor lève une ValueError pour cette raison spécifique."""
+    # Utilisez un DataFrame d'entrée qui est suffisamment complet pour passer les étapes
+    # de clean_data, map_binary_features, create_features et l'identification des colonnes.
+    # La fixture sample_raw_df_for_pipeline devrait convenir si elle est bien définie.
+    df_in = sample_raw_df_for_pipeline.copy() 
+
+    with pytest.raises(
+        ValueError, match="Un preprocessor doit être fourni si fit=False."
+    ):
+        # Appelez avec les mappings pour éviter des erreurs avant le check final
+        run_preprocessing_pipeline(
+            df_in,
+            binary_cols_map=config.BINARY_FEATURES_MAPPING,
+            ordinal_cols_categories_map=config.ORDINAL_FEATURES_CATEGORIES,
+            preprocessor=None, # Explicitement None
+            fit=False
+        )

tests/unit/test_train_model.py

@@ -1,50 +1,117 @@
-import pytest
-from unittest.mock import patch, MagicMock, ANY
+from unittest.mock import patch, MagicMock
 import pandas as pd
 import numpy as np
 from src.modeling.train_model import train_and_evaluate_pipeline
-from src import config # Pour les mappings et la cible
+from src import config  # Pour les mappings et la cible
 
-@patch('src.modeling.train_model.dump') # joblib.dump
-@patch('src.modeling.train_model.confusion_matrix', return_value=np.array([[0,0],[0,0]]))
-@patch('src.modeling.train_model.fbeta_score', return_value=0.5)
-@patch('src.modeling.train_model.classification_report', return_value="Mocked Report")
-@patch('src.modeling.train_model.Pipeline') # sklearn.pipeline.Pipeline
-@patch('src.modeling.train_model.LogisticRegression') # sklearn.linear_model.LogisticRegression
-@patch('src.modeling.train_model.build_preprocessor')
-@patch('src.modeling.train_model.create_features') # de preprocess
-@patch('src.modeling.train_model.map_binary_features') # de preprocess
-@patch('src.modeling.train_model.clean_data') # de preprocess
-@patch('src.modeling.train_model.get_data') # de load_data
-@patch('src.modeling.train_model.logger')
+
+@patch("src.modeling.train_model.dump")  # joblib.dump
+@patch(
+    "src.modeling.train_model.confusion_matrix", return_value=np.array([[0, 0], [0, 0]])
+)
+@patch("src.modeling.train_model.fbeta_score", return_value=0.5)
+@patch("src.modeling.train_model.classification_report", return_value="Mocked Report")
+@patch("src.modeling.train_model.Pipeline")  # sklearn.pipeline.Pipeline
+@patch(
+    "src.modeling.train_model.LogisticRegression"
+)  # sklearn.linear_model.LogisticRegression
+@patch("src.modeling.train_model.build_preprocessor")
+@patch("src.modeling.train_model.create_features")  # de preprocess
+@patch("src.modeling.train_model.get_data")  # de load_data
+@patch("src.modeling.train_model.logger")
 def test_train_and_evaluate_pipeline_success_path(
-    mock_logger, mock_get_data, mock_clean_data, mock_map_binary, mock_create_features,
-    mock_build_preprocessor, mock_LogisticRegression, mock_Pipeline,
-    mock_classification_report, mock_fbeta_score, mock_confusion_matrix, mock_joblib_dump
+    mock_logger,
+    mock_get_data,
+    mock_create_features,
+    mock_build_preprocessor,
+    mock_LogisticRegression,
+    mock_Pipeline,
+    mock_classification_report,
+    mock_fbeta_score,
+    mock_confusion_matrix,
+    mock_joblib_dump,
 ):
     """Teste le chemin principal de train_and_evaluate_pipeline avec des mocks."""
     # 1. Configurer les mocks
     # Mock get_data pour retourner des données avec ASSEZ DE LIGNES
-    sample_df_from_db = pd.DataFrame({
-        'id_employee': [str(i) for i in range(1, 11)], # 10 lignes
-        config.TARGET_VARIABLE: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0], # 4 de classe 1, 6 de classe 0
-        'genre':               [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], # Alterner pour avoir des valeurs
-        'heure_supplementaires': [0, 1, 0, 0, 1, 1, 0, 0, 1, 0],
-        'frequence_deplacement': ['Non-Travel', 'Travel_Rarely', 'Travel_Frequently', 'Non-Travel', 'Travel_Rarely',
-                                  'Non-Travel', 'Travel_Rarely', 'Travel_Frequently', 'Non-Travel', 'Travel_Rarely'],
-        'age':                   [30, 45, 22, 50, 38, 29, 54, 33, 41, 47],
-        'salaire_mensuel_brut':  [5000, 8000, 3500, 9000, 6000, 4800, 9500, 5500, 7000, 8200.0],
-        'department':            ['Ventes', 'R&D', 'Ventes', 'Marketing', 'R&D',
-                                  'Ventes', 'R&D', 'Ventes', 'Marketing', 'R&D'],
-        'augmentation_salaire_precedente': [10.0, 15.0, 5.0, 12.0, 8.0, 9.0, 11.0, 6.0, 13.0, 7.0]
-    })
+    sample_df_from_db = pd.DataFrame(
+        {
+            "id_employee": [str(i) for i in range(1, 11)],  # 10 lignes
+            config.TARGET_VARIABLE: [
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+            ],  # 4 de classe 1, 6 de classe 0
+            "genre": [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],  # Alterner pour avoir des valeurs
+            "heure_supplementaires": [0, 1, 0, 0, 1, 1, 0, 0, 1, 0],
+            "frequence_deplacement": [
+                "Non-Travel",
+                "Travel_Rarely",
+                "Travel_Frequently",
+                "Non-Travel",
+                "Travel_Rarely",
+                "Non-Travel",
+                "Travel_Rarely",
+                "Travel_Frequently",
+                "Non-Travel",
+                "Travel_Rarely",
+            ],
+            "age": [30, 45, 22, 50, 38, 29, 54, 33, 41, 47],
+            "salaire_mensuel_brut": [
+                5000,
+                8000,
+                3500,
+                9000,
+                6000,
+                4800,
+                9500,
+                5500,
+                7000,
+                8200.0,
+            ],
+            "department": [
+                "Ventes",
+                "R&D",
+                "Ventes",
+                "Marketing",
+                "R&D",
+                "Ventes",
+                "R&D",
+                "Ventes",
+                "Marketing",
+                "R&D",
+            ],
+            "augmentation_salaire_precedente": [
+                10.0,
+                15.0,
+                5.0,
+                12.0,
+                8.0,
+                9.0,
+                11.0,
+                6.0,
+                13.0,
+                7.0,
+            ],
+        }
+    )
     mock_get_data.return_value = sample_df_from_db
 
     df_after_features = sample_df_from_db.copy()
     mock_create_features.return_value = df_after_features
-    
+
     mock_preprocessor_instance = MagicMock()
-    mock_build_preprocessor.return_value = (mock_preprocessor_instance, ['mock_col1', 'mock_col2']) # Exemple
+    mock_build_preprocessor.return_value = (
+        mock_preprocessor_instance,
+        ["mock_col1", "mock_col2"],
+    )  # Exemple
 
     mock_classifier_instance = MagicMock()
     mock_LogisticRegression.return_value = mock_classifier_instance
@@ -53,8 +120,10 @@ def test_train_and_evaluate_pipeline_success_path(
     # Avec 10 lignes et test_size=0.2, X_test aura 2 lignes (10 * 0.2 = 2)
     # X_train aura 8 lignes.
     # Les mocks pour predict et predict_proba doivent donc retourner pour 2 échantillons
-    mock_pipeline_instance.predict.return_value = np.array([0, 1]) 
-    mock_pipeline_instance.predict_proba.return_value = np.array([[0.9, 0.1], [0.4, 0.6]])
+    mock_pipeline_instance.predict.return_value = np.array([0, 1])
+    mock_pipeline_instance.predict_proba.return_value = np.array(
+        [[0.9, 0.1], [0.4, 0.6]]
+    )
     mock_Pipeline.return_value = mock_pipeline_instance
 
     # Appeler la fonction
@@ -62,17 +131,18 @@ def test_train_and_evaluate_pipeline_success_path(
 
     # 3. Assertions
     mock_get_data.assert_called_once_with(source="postgres")
-    
-    # Si vous avez bien enlevé les appels à clean_data et map_binary_features de train_model.py :
-    mock_clean_data.assert_not_called()
-    mock_map_binary.assert_not_called()
+
     # Si create_features est toujours appelé :
-    mock_create_features.assert_called_once_with(sample_df_from_db) # Ou df_for_training avant le copy
-    
+    mock_create_features.assert_called_once_with(
+        sample_df_from_db
+    )  # Ou df_for_training avant le copy
+
     mock_build_preprocessor.assert_called_once()
-    mock_LogisticRegression.assert_called_once_with(random_state=42, class_weight='balanced', max_iter=1000)
+    mock_LogisticRegression.assert_called_once_with(
+        random_state=42, class_weight="balanced", max_iter=1000
+    )
     # Par exemple, les appels à predict et predict_proba se feront sur X_test qui a 2 lignes
-    mock_pipeline_instance.predict.assert_called_once() 
+    mock_pipeline_instance.predict.assert_called_once()
     # On peut vérifier la forme de l'argument avec lequel predict a été appelé
     # args_predict, _ = mock_pipeline_instance.predict.call_args
     # assert args_predict[0].shape[0] == 2 # X_test doit avoir 2 lignes
@@ -83,18 +153,28 @@ def test_train_and_evaluate_pipeline_success_path(
     mock_joblib_dump.assert_called_once_with(mock_pipeline_instance, config.MODEL_PATH)
 
 
-@patch('src.modeling.train_model.get_data', return_value=None) # Simule un échec de chargement
-@patch('src.modeling.train_model.logger')
-def test_train_and_evaluate_pipeline_get_data_returns_none(mock_logger, mock_get_data_none):
+@patch(
+    "src.modeling.train_model.get_data", return_value=None
+)  # Simule un échec de chargement
+@patch("src.modeling.train_model.logger")
+def test_train_and_evaluate_pipeline_get_data_returns_none(
+    mock_logger, mock_get_data_none
+):
     """Teste le cas où get_data retourne None."""
     train_and_evaluate_pipeline()
-    mock_logger.error.assert_called_once_with("Arrêt : Impossible de charger les données ou DataFrame vide.")
+    mock_logger.error.assert_called_once_with(
+        "Arrêt : Impossible de charger les données ou DataFrame vide depuis la source."
+    )
 
 
-@patch('src.modeling.train_model.get_data')
-@patch('src.modeling.train_model.logger')
-def test_train_and_evaluate_pipeline_get_data_returns_empty_df(mock_logger, mock_get_data_empty):
+@patch("src.modeling.train_model.get_data")
+@patch("src.modeling.train_model.logger")
+def test_train_and_evaluate_pipeline_get_data_returns_empty_df(
+    mock_logger, mock_get_data_empty
+):
     """Teste le cas où get_data retourne un DataFrame vide."""
-    mock_get_data_empty.return_value = pd.DataFrame() # df vide
-    train_and_evaluate_pipeline() # Devrait maintenant appeler logger.error et return
-    mock_logger.error.assert_called_once_with("Arrêt : Impossible de charger les données ou DataFrame vide.")
+    mock_get_data_empty.return_value = pd.DataFrame()  # df vide
+    train_and_evaluate_pipeline()  # Devrait maintenant appeler logger.error et return
+    mock_logger.error.assert_called_once_with(
+        "Arrêt : Impossible de charger les données ou DataFrame vide depuis la source."
+    )