oeeil 0.1.0__py3-none-any.whl

oeeil/__init__.py

@@ -0,0 +1,96 @@
+__version__ = "0.1.0"
+
+# Analyse
+from .modules.analyse.classify_exposure_level import classify_exposure_level
+from .modules.analyse.compute_daily_exposure import compute_daily_exposure
+from .modules.analyse.compute_exposure_indicators import compute_exposure_indicators
+from .modules.analyse.identify_critical_locations import identify_critical_locations
+from .modules.analyse.stratify_life_rhythm import stratify_life_rhythm
+
+# Pretraitement
+from .modules.pretraitement.convert_mv_to_concentration import convert_mv_to_concentration
+from .modules.pretraitement.detect_extinction_periods import detect_extinction_periods
+from .modules.pretraitement.detect_pollution_events import detect_pollution_events
+from .modules.pretraitement.filter_pollutant_outliers import filter_pollutant_outliers
+from .modules.pretraitement.flag_environmental_conditions import flag_environmental_conditions
+from .modules.pretraitement.imputation_valeurs_manquantes import (
+    impute_missing_values,
+    print_imputation_report,
+)
+from .modules.pretraitement.manage_missing_suppression import manage_missing_suppression
+from .modules.pretraitement.normalize_gas_percentage import normalize_gas_percentage
+
+# Reporting
+from .modules.reporting.generate_report import generate_report
+from .modules.reporting.statistical_summary_report import statistical_summary_report
+
+# Standardisation
+from .modules.standardisation.aggregate_close_gps_points import aggregate_close_gps_points
+from .modules.standardisation.convert_timezone import convert_timezone
+from .modules.standardisation.identify_calibration_pairs import identify_calibration_pairs
+from .modules.standardisation.standardize_db import standardize_db
+from .modules.standardisation.synchronize_oeeil_campaign import synchronize_oeeil_campaign
+from .modules.standardisation.synchronize_with_reference import synchronize_with_reference
+
+# Traitement
+from .modules.traitement.classify_indoor_outdoor_co2 import classify_indoor_outdoor_co2
+from .modules.traitement.classify_indoor_outdoor_cov import classify_indoor_outdoor_cov
+from .modules.traitement.classify_transport_mode import classify_transport_mode
+from .modules.traitement.compute_displacement_speed import compute_displacement_speed
+from .modules.traitement.correlate_transport_environment import correlate_transport_environment
+from .modules.traitement.detect_cov_outliers import detect_cov_outliers
+from .modules.traitement.interpolate_gps_coordinates import interpolate_gps_coordinates
+from .modules.traitement.normalize_cov_percentage import normalize_cov_percentage
+
+# Visualisation
+from .modules.visualisation.calendar_heatmap import calendar_heatmap
+from .modules.visualisation.statistical_summary_visual import statistical_summary_visual
+from .modules.visualisation.visualize_exposure import visualize_exposure
+
+
+__all__ = [
+    # Analyse
+    "classify_exposure_level",
+    "compute_daily_exposure",
+    "compute_exposure_indicators",
+    "identify_critical_locations",
+    "stratify_life_rhythm",
+
+    # Pretraitement
+    "convert_mv_to_concentration",
+    "detect_extinction_periods",
+    "detect_pollution_events",
+    "filter_pollutant_outliers",
+    "flag_environmental_conditions",
+    "impute_missing_values",
+    "print_imputation_report",
+    "manage_missing_suppression",
+    "normalize_gas_percentage",
+
+    # Reporting
+    "generate_report",
+    "statistical_summary_report",
+
+    # Standardisation
+    "aggregate_close_gps_points",
+    "convert_timezone",
+    "identify_calibration_pairs",
+    "standardize_db",
+    "synchronize_oeeil_campaign",
+    "synchronize_with_reference",
+
+    # Traitement
+    "classify_indoor_outdoor_co2",
+    "classify_indoor_outdoor_cov",
+    "classify_transport_mode",
+    "compute_displacement_speed",
+    "correlate_transport_environment",
+    "detect_cov_outliers",
+    "interpolate_gps_coordinates",
+    "normalize_cov_percentage",
+
+    # Visualisation
+    "calendar_heatmap",
+    "statistical_summary_visual",
+    "visualize_exposure",
+]

oeeil/modules/analyse/classify_exposure_level.py

@@ -0,0 +1,273 @@
+"""
+Fonction 20 — classify_exposure_level
+Classifie le niveau d'exposition à chaque polluant selon des seuils
+paramétrables (OMS 2021 par défaut pour PM2.5/PM10 ; ANSES/ASHRAE pour CO₂).
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Seuils OMS 2021 et ANSES/ASHRAE par défaut
+# Format : {col: [seuil1, seuil2, seuil3]}
+# → niveau 0 (faible)   si valeur < seuil1
+# → niveau 1 (modéré)   si seuil1 ≤ valeur < seuil2
+# → niveau 2 (élevé)    si seuil2 ≤ valeur < seuil3
+# → niveau 3 (très élevé) si valeur ≥ seuil3
+# ---------------------------------------------------------------------------
+DEFAULT_THRESHOLDS = {
+    "pm25":    [5.0,   15.0,  25.0],   # µg/m³  — OMS 2021
+    "pm10":    [15.0,  45.0,  75.0],   # µg/m³  — OMS 2021
+    "co2_ppm": [800.0, 1000.0, 2000.0], # ppm    — ANSES / ASHRAE 62.1
+    # no2_mv / o3_mv : non calibrés → non inclus par défaut
+}
+
+LEVEL_LABELS_DEFAULT = ["faible", "modéré", "élevé", "très élevé"]
+LEVEL_ORDER = {lbl: i for i, lbl in enumerate(LEVEL_LABELS_DEFAULT)}
+
+
+def _classify_column(
+    series: pd.Series,
+    thresholds: list,
+    labels: list,
+) -> pd.Series:
+    """
+    Applique une classification par seuils sur une Series numérique.
+
+    Parameters
+    ----------
+    series : pd.Series
+        Valeurs à classifier.
+    thresholds : list of 3 float
+        [seuil1, seuil2, seuil3] — bornes de séparation entre les 4 niveaux.
+    labels : list of 4 str
+        Étiquettes des niveaux [niveau0, niveau1, niveau2, niveau3].
+
+    Returns
+    -------
+    pd.Series de str (dtype object), NaN pour les valeurs manquantes.
+    """
+    if len(thresholds) != 3:
+        raise ValueError(
+            f"'thresholds' doit contenir exactement 3 valeurs, "
+            f"reçu {len(thresholds)}."
+        )
+    if len(labels) != 4:
+        raise ValueError(
+            f"'level_labels' doit contenir exactement 4 étiquettes, "
+            f"reçu {len(labels)}."
+        )
+
+    s1, s2, s3 = thresholds
+    if not (s1 < s2 < s3):
+        raise ValueError(
+            f"Les seuils doivent être strictement croissants : "
+            f"seuil1={s1} < seuil2={s2} < seuil3={s3} non vérifié."
+        )
+
+    conditions = [
+        series < s1,
+        (series >= s1) & (series < s2),
+        (series >= s2) & (series < s3),
+        series >= s3,
+    ]
+    result = np.select(conditions, labels, default="__nan__")
+    result = pd.Series(result, index=series.index, dtype=object)
+    result[series.isna() | (result == "__nan__")] = np.nan
+    return result
+
+
+def classify_exposure_level(
+    df: pd.DataFrame,
+    pollutant_thresholds: Optional[dict] = None,
+    level_labels: Optional[list] = None,
+    overall_method: str = "max",
+    keep_intermediate: bool = True,
+) -> tuple:
+    """
+    Fonction 20 — Classification du niveau d'exposition par polluant.
+
+    Attribue à chaque mesure un niveau d'exposition (faible / modéré /
+    élevé / très élevé) pour chaque polluant disposant de seuils définis,
+    puis calcule un niveau d'exposition global par ligne.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame OEEIL standardisé. Doit contenir au moins une colonne
+        correspondant à un polluant présent dans `pollutant_thresholds`.
+    pollutant_thresholds : dict, optional
+        Dictionnaire {nom_colonne: [seuil1, seuil2, seuil3]} définissant
+        les bornes de classification pour chaque polluant.
+        Si None, les seuils OMS 2021 (PM2.5, PM10) et ANSES/ASHRAE (CO₂)
+        sont utilisés pour les colonnes présentes dans le DataFrame.
+    level_labels : list of 4 str, optional
+        Étiquettes des 4 niveaux, du plus faible au plus élevé.
+        Par défaut : ["faible", "modéré", "élevé", "très élevé"].
+    overall_method : str
+        Méthode de calcul du niveau global par ligne :
+        - "max"  : niveau le plus défavorable parmi les polluants classifiés
+          (approche précautionneuse, recommandée).
+        - "mean" : niveau moyen arrondi (approche descriptive).
+        Par défaut : "max".
+    keep_intermediate : bool
+        Si True, les colonnes `{col}_exposure_level` par polluant sont
+        conservées dans le DataFrame de sortie.
+        Si False, seule la colonne `exposure_level_overall` est ajoutée.
+        Par défaut : True.
+
+    Returns
+    -------
+    df_out : pd.DataFrame
+        DataFrame enrichi avec :
+        - `{col}_exposure_level` (str) pour chaque polluant classifié
+          (si keep_intermediate=True).
+        - `exposure_level_overall` (str) : niveau global par ligne.
+        - `exposure_score_overall` (int, 0-3) : version ordinale du niveau
+          global (0 = faible, 3 = très élevé), utile pour les calculs aval
+          (AUC, indicateurs d'exposition cumulée).
+    meta : dict
+        Dictionnaire récapitulatif contenant :
+        - "polluants_classifiés" : liste des colonnes effectivement traitées.
+        - "polluants_absents" : colonnes demandées mais absentes du DataFrame.
+        - "seuils_appliqués" : seuils utilisés par polluant.
+        - "distribution_par_polluant" : {col: {niveau: count}} par polluant.
+        - "distribution_globale" : {niveau: count} pour exposure_level_overall.
+        - "taux_très_élevé_global" : fraction de lignes au niveau le plus élevé.
+
+    Notes
+    -----
+    - Les colonnes `no2_mv` et `o3_mv` sont en millivolts bruts et ne
+      disposent pas de seuils OMS dans leur unité native : elles sont
+      ignorées par défaut. Fournir des seuils calibrés via
+      `pollutant_thresholds` si une calibration a été appliquée en amont.
+    - `exposure_score_overall` encode les niveaux comme entiers (0–3) et
+      peut être utilisé directement par la fonction 21 (calcul d'AUC et
+      d'indicateurs d'exposition critique).
+    - Les lignes entièrement NaN sur tous les polluants classifiés reçoivent
+      `exposure_level_overall` = "inconnu" et `exposure_score_overall` = -1.
+
+    Examples
+    --------
+    >>> df_exp, meta = classify_exposure_level(df_oeeil)
+    >>> df_exp[["pm25", "pm25_exposure_level", "exposure_level_overall"]].head()
+
+    >>> # Avec seuils personnalisés (ex. NO₂ calibré en µg/m³)
+    >>> custom = {"pm25": [5, 15, 25], "no2_ug_m3": [10, 25, 200]}
+    >>> df_exp, meta = classify_exposure_level(df_calibrated,
+    ...                                         pollutant_thresholds=custom)
+    """
+
+    # --- Validation des paramètres ---
+    if overall_method not in ("max", "mean"):
+        raise ValueError(
+            "Paramètre 'overall_method' invalide. Choisir 'max' ou 'mean'."
+        )
+
+    labels = level_labels if level_labels is not None else LEVEL_LABELS_DEFAULT
+    if len(labels) != 4:
+        raise ValueError("'level_labels' doit contenir exactement 4 étiquettes.")
+
+    # Table ordinale : label → score entier
+    label_to_score = {lbl: i for i, lbl in enumerate(labels)}
+
+    # Seuils : utiliser ceux fournis, ou les défauts filtrés sur les colonnes présentes
+    if pollutant_thresholds is not None:
+        thresholds = pollutant_thresholds
+    else:
+        thresholds = {
+            col: seuils
+            for col, seuils in DEFAULT_THRESHOLDS.items()
+            if col in df.columns
+        }
+
+    if not thresholds:
+        raise ValueError(
+            "Aucun polluant classifiable trouvé dans le DataFrame avec les "
+            "seuils disponibles. Fournir 'pollutant_thresholds' explicitement "
+            "ou vérifier que le DataFrame contient pm25, pm10 ou co2_ppm."
+        )
+
+    df_out = df.copy()
+    classified_cols = []
+    absent_cols = []
+    distributions = {}
+    seuils_uses = {}
+
+    # --- Classification par polluant ---
+    for col, seuils in thresholds.items():
+        if col not in df_out.columns:
+            absent_cols.append(col)
+            continue
+
+        level_col = f"{col}_exposure_level"
+        df_out[level_col] = _classify_column(df_out[col], seuils, labels)
+        classified_cols.append(col)
+        seuils_uses[col] = seuils
+
+        # Distribution pour le rapport
+        counts = df_out[level_col].value_counts(dropna=False).to_dict()
+        distributions[col] = {str(k): int(v) for k, v in counts.items()}
+
+    if not classified_cols:
+        raise ValueError(
+            f"Aucune colonne classifiable présente dans le DataFrame. "
+            f"Colonnes demandées : {list(thresholds.keys())}. "
+            f"Colonnes du DataFrame : {list(df.columns)}."
+        )
+
+    # --- Calcul du niveau global par ligne ---
+    level_cols = [f"{c}_exposure_level" for c in classified_cols]
+
+    # Convertir les étiquettes en scores pour pouvoir comparer
+    score_matrix = df_out[level_cols].apply(
+        lambda col: col.map(label_to_score)
+    )
+
+    if overall_method == "max":
+        overall_score = score_matrix.max(axis=1)
+    else:  # mean
+        overall_score = score_matrix.mean(axis=1).round().astype("Int64")
+
+    # Reconvertir les scores en étiquettes
+    score_to_label = {i: lbl for i, lbl in enumerate(labels)}
+    overall_label = overall_score.map(score_to_label).fillna("inconnu")
+
+    # Lignes où tous les polluants sont NaN → "inconnu" / score -1
+    all_nan_mask = score_matrix.isna().all(axis=1)
+    overall_score = overall_score.where(~all_nan_mask, other=-1).astype(int)
+    overall_label = overall_label.where(~all_nan_mask, other="inconnu")
+
+    df_out["exposure_level_overall"] = overall_label
+    df_out["exposure_score_overall"] = overall_score
+
+    # Supprimer les colonnes intermédiaires si demandé
+    if not keep_intermediate:
+        df_out.drop(columns=level_cols, inplace=True)
+
+    # --- Rapport ---
+    dist_globale = (
+        df_out["exposure_level_overall"].value_counts(dropna=False).to_dict()
+    )
+    dist_globale = {str(k): int(v) for k, v in dist_globale.items()}
+
+    n_tres_eleve = int(
+        (df_out["exposure_level_overall"] == labels[3]).sum()
+    )
+    taux_tres_eleve = round(n_tres_eleve / max(len(df_out), 1), 4)
+
+    meta = {
+        "polluants_classifiés": classified_cols,
+        "polluants_absents": absent_cols,
+        "seuils_appliqués": seuils_uses,
+        "labels_niveaux": labels,
+        "methode_global": overall_method,
+        "distribution_par_polluant": distributions,
+        "distribution_globale": dist_globale,
+        "taux_très_élevé_global": taux_tres_eleve,
+        "n_lignes_inconnues": int(all_nan_mask.sum()),
+    }
+
+    return df_out, meta

oeeil/modules/analyse/compute_daily_exposure.py

@@ -0,0 +1,273 @@
+"""
+Fonction 23 — compute_daily_exposure
+Calcule l'exposition cumulée journalière par polluant : AUC par jour,
+moyenne journalière, dépassements de seuils OMS, et agrégats sur la période.
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Optional
+
+
+DEFAULT_THRESHOLDS = {
+    "pm25":    [5.0,   15.0,  25.0],
+    "pm10":    [15.0,  45.0,  75.0],
+    "co2_ppm": [800.0, 1000.0, 2000.0],
+}
+
+LEVEL_LABELS = ["faible", "modéré", "élevé", "très élevé"]
+
+
+def compute_daily_exposure(
+    df: pd.DataFrame,
+    timestamp_col: str = "timestamp_local",
+    pollutant_cols: Optional[list] = None,
+    pollutant_thresholds: Optional[dict] = None,
+    who_daily_limits: Optional[dict] = None,
+    min_coverage_pct: float = 0.5,
+    stratification_col: Optional[str] = None,
+) -> tuple:
+    """
+    Fonction 23 — Exposition cumulée journalière par polluant.
+
+    Agrège les données OEEIL à l'échelle journalière pour chaque polluant :
+    calcule la moyenne journalière, l'AUC du jour (intégrale trapézoïdale),
+    la durée de dépassement des seuils OMS, et le niveau d'exposition
+    dominant sur la journée.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame OEEIL enrichi (peut contenir les colonnes issues de F20/F22).
+    timestamp_col : str
+        Colonne horodatage (datetime64 ou convertible). Par défaut :
+        "timestamp_local".
+    pollutant_cols : list of str, optional
+        Colonnes polluants à analyser. Si None, les colonnes correspondant
+        aux seuils disponibles et présentes dans le DataFrame sont utilisées.
+    pollutant_thresholds : dict, optional
+        {col: [seuil1, seuil2, seuil3]} — seuils OMS par polluant.
+        Si None, les seuils par défaut (pm25, pm10, co2_ppm) sont utilisés.
+    who_daily_limits : dict, optional
+        {col: valeur_limite_journalière} — valeur guide OMS 24h (µg/m³ ou
+        ppm). Si le moyenne journalière dépasse cette valeur, un flag
+        `{col}_oms_exceeded` est levé.
+        Par défaut : {"pm25": 15.0, "pm10": 45.0}.
+    min_coverage_pct : float
+        Fraction minimale de la journée devant être couverte par des mesures
+        valides pour qu'un agrégat journalier soit calculé (entre 0 et 1).
+        Les jours sous ce seuil reçoivent NaN. Par défaut : 0.5 (50 %).
+    stratification_col : str, optional
+        Si fourni (ex. "time_period" ou "segment_travail"), les AUC et
+        durées sont également calculées par strate au sein de chaque journée.
+
+    Returns
+    -------
+    df_daily : pd.DataFrame
+        DataFrame indexé par date (une ligne par jour × polluant), avec :
+        - `date`                   : date (YYYY-MM-DD).
+        - `polluant`               : nom de la colonne polluant.
+        - `n_mesures`              : nombre de mesures valides ce jour.
+        - `couverture_pct`         : fraction de la journée couverte.
+        - `moyenne_journaliere`    : moyenne des concentrations (unité brute).
+        - `auc_journaliere`        : AUC trapézoïdale (unité × min).
+        - `max_journalier`         : maximum de la journée.
+        - `niveau_dominant`        : niveau d'exposition le plus fréquent.
+        - `duree_critique_min`     : durée en niveaux élevé/très élevé (min).
+        - `pct_temps_critique`     : fraction du temps en niveaux critiques.
+        - `oms_depasse`            : bool — moyenne > limite OMS journalière.
+    meta : dict
+        Métadonnées globales :
+        - "polluants_traités"      : liste des polluants analysés.
+        - "n_jours_total"          : nombre de jours distincts dans les données.
+        - "n_jours_valides"        : jours avec couverture ≥ min_coverage_pct.
+        - "n_jours_oms_depasse"    : {col: nombre de jours en dépassement OMS}.
+        - "moyenne_periode"        : {col: moyenne sur toute la période}.
+        - "jour_le_plus_critique"  : {col: date avec le % critique le plus élevé}.
+
+    Notes
+    -----
+    - Un jour est considéré comme "valide" si le nombre de mesures valides
+      représente au moins `min_coverage_pct` × 86 400 s / pas_médian_s
+      mesures attendues.
+    - L'AUC journalière est en unité_polluant × minutes sur 24h maximum.
+    - Si `stratification_col` est fournie, la colonne doit être présente dans
+      `df` (typiquement issue de F22).
+
+    Examples
+    --------
+    >>> df_daily, meta = compute_daily_exposure(
+    ...     df_strat, timestamp_col="datetime_utc"
+    ... )
+    >>> meta["n_jours_oms_depasse"]
+    >>> df_daily[df_daily["polluant"] == "co2_ppm"]
+    """
+
+    # --- Validation ---
+    if timestamp_col not in df.columns:
+        raise ValueError(
+            f"Colonne horodatage '{timestamp_col}' absente du DataFrame."
+        )
+    if not (0.0 < min_coverage_pct <= 1.0):
+        raise ValueError(
+            "'min_coverage_pct' doit être compris entre 0 (exclus) et 1."
+        )
+
+    thresholds = pollutant_thresholds or DEFAULT_THRESHOLDS
+    oms_limits = who_daily_limits or {"pm25": 15.0, "pm10": 45.0, "co2_ppm": 1000.0}
+
+    if pollutant_cols is None:
+        pollutant_cols = [c for c in thresholds if c in df.columns]
+
+    if not pollutant_cols:
+        raise ValueError(
+            "Aucun polluant classifiable trouvé. Fournir 'pollutant_cols' "
+            "ou vérifier que le DataFrame contient pm25, pm10 ou co2_ppm."
+        )
+
+    df_work = df.copy()
+    ts = pd.to_datetime(df_work[timestamp_col], dayfirst=True)
+    df_work["_date"] = ts.dt.date
+    df_work["_ts"]   = ts
+
+    ts_sorted = ts.sort_values()
+    pas_median_min = ts_sorted.diff().dt.total_seconds().median() / 60
+
+    if pd.isna(pas_median_min) or pas_median_min <= 0:
+        pas_median_min = 1.0
+
+    n_mesures_journee_complete = (24 * 60) / pas_median_min
+
+    records = []
+
+    for col in pollutant_cols:
+        if col not in df_work.columns:
+            continue
+
+        values = pd.to_numeric(df_work[col], errors="coerce")
+        seuils = thresholds.get(col, [np.inf, np.inf, np.inf])
+        s1, s2, s3 = seuils
+        oms_limite = oms_limits.get(col, None)
+
+        # Colonne niveau (F20 si disponible, sinon recalcul)
+        level_col = f"{col}_exposure_level"
+        if level_col in df_work.columns:
+            levels = df_work[level_col]
+        else:
+            cond = [values < s1,
+                    (values >= s1) & (values < s2),
+                    (values >= s2) & (values < s3),
+                    values >= s3]
+            res = np.select(cond, LEVEL_LABELS, default="__nan__")
+            levels = pd.Series(res, index=df_work.index, dtype=object)
+            levels[values.isna() | (levels == "__nan__")] = np.nan
+
+        for date, grp_idx in df_work.groupby("_date").groups.items():
+            grp     = df_work.loc[grp_idx].sort_values("_ts")
+            v_grp   = values.loc[grp_idx].sort_values()
+            v_grp   = values.loc[grp.index]
+            t_grp   = ts.loc[grp.index]
+            l_grp   = levels.loc[grp.index]
+
+            valid   = v_grp.notna()
+            n_valid = int(valid.sum())
+            couv = min(n_valid / n_mesures_journee_complete, 1.0)
+
+            if couv < min_coverage_pct or n_valid == 0:
+                records.append({
+                    "date": date, "polluant": col,
+                    "n_mesures": n_valid,
+                    "couverture_pct": round(couv, 4),
+                    "moyenne_journaliere": np.nan,
+                    "auc_journaliere": np.nan,
+                    "max_journalier": np.nan,
+                    "niveau_dominant": np.nan,
+                    "duree_critique_min": np.nan,
+                    "pct_temps_critique": np.nan,
+                    "oms_depasse": np.nan,
+                })
+                continue
+
+            # AUC trapézoïdale
+            dt_min = t_grp.diff().dt.total_seconds().div(60)
+            auc = 0.0
+            for i in range(1, len(grp)):
+                vp = v_grp.iloc[i - 1]
+                vc = v_grp.iloc[i]
+                dt = dt_min.iloc[i]
+                if pd.notna(vp) and pd.notna(vc) and pd.notna(dt) and dt > 0:
+                    auc += 0.5 * (vp + vc) * dt
+
+            # Durée par niveau
+            duree_critique = 0.0
+            duree_totale   = 0.0
+            for i in range(1, len(grp)):
+                dt = dt_min.iloc[i]
+                if pd.isna(dt) or dt <= 0:
+                    continue
+                lv = l_grp.iloc[i - 1]
+                duree_totale += dt
+                if lv in ("élevé", "très élevé"):
+                    duree_critique += dt
+
+            pct_critique = duree_critique / max(duree_totale, 1e-9)
+
+            # Niveau dominant
+            lvl_counts = l_grp[l_grp.notna()].value_counts()
+            niveau_dom = lvl_counts.index[0] if len(lvl_counts) > 0 else np.nan
+
+            moy = float(v_grp[valid].mean())
+            mx  = float(v_grp[valid].max())
+            oms_dep = (moy > oms_limite) if oms_limite is not None else np.nan
+
+            records.append({
+                "date":                 date,
+                "polluant":             col,
+                "n_mesures":            n_valid,
+                "couverture_pct":       round(couv, 4),
+                "moyenne_journaliere":  round(moy, 4),
+                "auc_journaliere":      round(auc, 2),
+                "max_journalier":       round(mx, 4),
+                "niveau_dominant":      niveau_dom,
+                "duree_critique_min":   round(duree_critique, 2),
+                "pct_temps_critique":   round(pct_critique, 4),
+                "oms_depasse":          oms_dep,
+            })
+
+    df_daily = pd.DataFrame(records)
+
+    # --- Méta ---
+    n_jours_total  = df_work["_date"].nunique()
+    n_jours_valides = int(df_daily["moyenne_journaliere"].notna().sum()) \
+                      // max(len(pollutant_cols), 1) if len(df_daily) > 0 else 0
+
+    n_jours_oms = {}
+    moyenne_periode = {}
+    jour_critique = {}
+
+    for col in pollutant_cols:
+        if len(df_daily) == 0 or "polluant" not in df_daily.columns:
+            continue
+        sub = df_daily[df_daily["polluant"] == col]
+        if len(sub) == 0:
+            continue
+        n_jours_oms[col] = int(sub["oms_depasse"].sum()) \
+            if sub["oms_depasse"].notna().any() else 0
+        moyenne_periode[col] = round(float(sub["moyenne_journaliere"].mean(skipna=True)), 4) \
+            if sub["moyenne_journaliere"].notna().any() else np.nan
+        idx_max = sub["pct_temps_critique"].idxmax() \
+            if sub["pct_temps_critique"].notna().any() else None
+        jour_critique[col] = str(sub.loc[idx_max, "date"]) if idx_max is not None else None
+
+    meta = {
+        "polluants_traités":     pollutant_cols,
+        "n_jours_total":         n_jours_total,
+        "n_jours_valides":       n_jours_valides,
+        "n_jours_oms_depasse":   n_jours_oms,
+        "moyenne_periode":       moyenne_periode,
+        "jour_le_plus_critique": jour_critique,
+        "min_coverage_pct":      min_coverage_pct,
+        "pas_median_min":        round(pas_median_min, 2),
+    }
+
+    return df_daily, meta