Update app.py

app.py

@@ -1,63 +1,40 @@
 import gradio as gr
 import pandas as pd
-import numpy as np
 import matplotlib.pyplot as plt
 
-# --- Mois disponibles, en cohérence avec ton fichier ---
-MOIS = ['Janv.', 'Fev.', 'Mars', 'Avr.', 'Mai', 'Juin', 'Juil.', 'Août', 'Sept.', 'Oct.', 'Nov.', 'Dec.']
+mois_disponibles = ['Janv.', 'Fev.', 'Mars', 'Avr.', 'Mai', 'Juin', 'Juil.', 'Août', 'Sept.', 'Oct.', 'Nov.', 'Dec.']
 
-# =========================
-# Onglet 1 : ancien graphe
-# =========================
 def generer_graphique(file, mois):
-    """
-    Ancien comportement : charge 'CDT Assemblage' et 'CDT PE' (skiprows=4),
-    fusionne par 'Standard', calcule la moyenne et colorise selon la valeur.
-    """
-    try:
-        # Lecture des deux feuilles historiques
-        sheet1 = pd.read_excel(file.name, sheet_name='CDT Assemblage', skiprows=4)
-        sheet2 = pd.read_excel(file.name, sheet_name='CDT PE', skiprows=4)
-    except Exception as e:
-        raise gr.Error(f"Impossible de lire les feuilles 'CDT Assemblage' et 'CDT PE'. Détails: {e}")
+    sheet1 = pd.read_excel(file.name, sheet_name='CDT Assemblage', skiprows=4)
+    sheet2 = pd.read_excel(file.name, sheet_name='CDT PE', skiprows=4)
 
-    def extraire(df, mois_col):
-        # 3e colonne = standards dans ta structure existante
+    def extraire(df, mois):
         standards = df.iloc[:, 2]
-        if mois_col not in df.columns:
-            # certains exports peuvent trim/varier les noms (ex: 'Août' -> 'Aout')
-            # on tente une correspondance souple
-            candidats = [c for c in df.columns if str(c).strip().lower() == mois_col.strip().lower()]
-            if not candidats:
-                raise gr.Error(f"Colonne mois '{mois_col}' introuvable dans la feuille.\nColonnes vues : {list(df.columns)}")
-            mois_col = candidats[0]
-        valeurs = df[mois_col]
-        df_filtre = pd.DataFrame({'Standard': standards, 'Valeur': valeurs}).dropna()
+        valeurs = df[mois]
+        df_filtré = pd.DataFrame({'Standard': standards, 'Valeur': valeurs}).dropna()
         exclure = ['Objectifs', 'Résultats', 'mat>', 'mat> B']
-        mask = ~df_filtre['Standard'].astype(str).str.contains('|'.join(exclure), case=False, na=False)
-        return df_filtre[mask]
+        return df_filtré[~df_filtré['Standard'].astype(str).str.contains('|'.join(exclure), case=False)]
 
     df1 = extraire(sheet1, mois)
     df2 = extraire(sheet2, mois)
     merged = pd.merge(df1, df2, on='Standard', suffixes=('_1', '_2'))
     merged['Moyenne'] = merged[['Valeur_1', 'Valeur_2']].mean(axis=1)
 
-    # Respecter l'ordre d'origine des standards de la première feuille
     ordre = sheet1.iloc[:, 2].dropna().tolist()
-    ordre_filtre = [s for s in ordre if s in merged['Standard'].values]
-    merged = merged.set_index('Standard').loc[ordre_filtre].reset_index()
+    ordre_filtré = [s for s in ordre if s in merged['Standard'].values]
+    merged = merged.set_index('Standard').loc[ordre_filtré].reset_index()
 
-    # Couleurs par seuils
-    def couleur(val):
+    # Définir les couleurs selon les valeurs
+    couleurs = []
+    for val in merged['Moyenne']:
         if val < 3:
-            return 'red'
+            couleurs.append('red')
         elif val < 6.5:
-            return 'yellow'
+            couleurs.append('yellow')
         elif val < 9.2:
-            return 'green'
+            couleurs.append('green')
         else:
-            return 'skyblue'
-    couleurs = [couleur(v) for v in merged['Moyenne']]
+            couleurs.append('skyblue')
 
     fig, ax = plt.subplots(figsize=(12, 6))
     ax.bar(merged['Standard'], merged['Moyenne'], color=couleurs)
@@ -66,187 +43,18 @@ def generer_graphique(file, mois):
     ax.set_ylabel("Moyenne")
     plt.xticks(rotation=45, ha='right')
     plt.tight_layout()
-    return fig
-
-# ===========================================
-# Onglet 2 : nouvelles courbes d'évolution
-# ===========================================
-def _find_header_row(df_raw, mois_labels):
-    """
-    Trouve la ligne d'en-tête qui contient un max de libellés de mois.
-    Retourne l'index de cette ligne ou None.
-    """
-    best_idx, best_cnt = None, -1
-    mois_lower = [m.strip().lower() for m in mois_labels]
-    for i in range(min(200, len(df_raw))):  # pas besoin de balayer toute la feuille
-        row_vals = [str(x).strip().lower() for x in df_raw.iloc[i, :].tolist()]
-        cnt = sum(m in row_vals for m in mois_lower)
-        if cnt > best_cnt:
-            best_cnt, best_idx = cnt, i
-    # on considère acceptable si >= 6 mois trouvés
-    return best_idx if best_cnt >= 6 else None
-
-def _prep_synthese(df_raw):
-    """
-    Nettoie la feuille 'Synthèse usine' en détectant l'en-tête (mois),
-    puis renvoie (df, mois_trouves, cols_avant_mois)
-    - df : dataframe propre (lignes de données sous l'en-tête)
-    - mois_trouves : liste des mois présents dans les colonnes
-    - cols_avant_mois : noms des colonnes "descriptives" avant les colonnes mois
-    """
-    hdr_idx = _find_header_row(df_raw, MOIS)
-    if hdr_idx is None:
-        raise gr.Error("Impossible d'identifier l'en-tête des mois dans 'Synthèse usine'.")
-    header = df_raw.iloc[hdr_idx].tolist()
-    df = df_raw.iloc[hdr_idx+1:].copy()
-    df.columns = [str(c).strip() if str(c) != 'nan' else f"col_{i}" for i, c in enumerate(header)]
-
-    # Harmoniser les mois ('Août' vs 'Aout', etc.)
-    colmap = {}
-    for c in df.columns:
-        c_norm = str(c).strip()
-        if c_norm.lower() == 'aout':
-            c_norm = 'Août'
-        colmap[c] = c_norm
-    df.rename(columns=colmap, inplace=True)
-
-    mois_trouves = [m for m in MOIS if m in df.columns]
-    if len(mois_trouves) < 6:
-        raise gr.Error(f"Colonnes mois insuffisantes détectées. Trouvées: {mois_trouves}")
-
-    # Colonnes descriptives = toutes les colonnes avant les mois
-    first_mois_idx = min(df.columns.get_loc(m) for m in mois_trouves)
-    cols_avant_mois = df.columns[:first_mois_idx].tolist()
-    # Nettoyage : forward-fill sur colonnes descriptives (souvent structure en lignes regroupées)
-    for c in cols_avant_mois:
-        df[c] = df[c].replace({np.nan: None})
-        df[c] = df[c].ffill()
-
-    return df, mois_trouves, cols_avant_mois
-
-def _pick_best_column_for(labels_df, candidates, keywords):
-    """
-    Parmi les colonnes 'candidates', trouve celle qui matche le mieux 'keywords'
-    (tous les mots-clés doivent apparaître, insensibles à la casse).
-    """
-    best_col, best_hits = None, -1
-    kws = [k.lower() for k in keywords]
-    for c in candidates:
-        vals = labels_df[c].astype(str).str.lower()
-        hits = vals.apply(lambda x: all(k in x for k in kws)).sum()
-        if hits > best_hits:
-            best_hits, best_col = hits, c
-    return best_col
-
-def _extract_series(df, mois_cols, cols_avant_mois, kpi_keywords, type_keywords):
-    """
-    Extrait une série (sur 12 mois) pour un couple (KPI, TYPE).
-    - kpi_keywords : ex. ['cdt', 'assemblage']
-    - type_keywords : ex. ['obj'] ou ['act'] (gère 'act'/'act.')
-    Retourne un pd.Series indexé par mois_cols (peut contenir NaN).
-    """
-    # On cherche sur les colonnes descriptives où se trouvent KPI et TYPE
-    kpi_col = _pick_best_column_for(df, cols_avant_mois, kpi_keywords)
-    type_col = _pick_best_column_for(df, cols_avant_mois, type_keywords)
-
-    if kpi_col is None:
-        raise gr.Error(f"Impossible de localiser le KPI {' '.join(kpi_keywords)} dans 'Synthèse usine'.")
-    if type_col is None:
-        # parfois 'Obj/Act' est dans la même colonne que le KPI ou dans une 2e colonne voisine
-        # on tente alors dans kpi_col
-        type_col = kpi_col
-
-    # Filtrage
-    mask_kpi = df[kpi_col].astype(str).str.lower().apply(lambda x: all(k in x for k in [k.lower() for k in kpi_keywords]))
-    # gérer 'act' ou 'act.' et 'obj'
-    type_norm = [t.lower().rstrip('.') for t in type_keywords]
-    mask_type = df[type_col].astype(str).str.lower().apply(lambda x: any(t in x.rstrip('.') for t in type_norm))
-
-    sub = df[mask_kpi & mask_type]
-    if sub.empty:
-        # fallback: si pas trouvé, tenter recherche large en concaténant les colonnes descriptives
-        concat_desc = df[cols_avant_mois].astype(str).agg(' '.join, axis=1).str.lower()
-        mask_all = concat_desc.apply(lambda x: all(k in x for k in [k.lower() for k in kpi_keywords])) & \
-                   concat_desc.apply(lambda x: any(t in x for t in type_norm))
-        sub = df[mask_all]
-
-    if sub.empty:
-        # on renvoie une série NaN pour ne pas casser le tracé global
-        return pd.Series([np.nan]*len(mois_cols), index=mois_cols, dtype=float)
 
-    # Si plusieurs lignes matchent, on prend la première non vide sur les mois (ou la moyenne)
-    # Ici, on prend la moyenne par mois pour être robuste
-    series_vals = sub[mois_cols].apply(pd.to_numeric, errors='coerce').mean(axis=0)
-    return series_vals
-
-def courbes_evolution(file):
-    """
-    Nouvelle fonctionnalité : lit 'Synthèse usine' -> tableau '#@mat B AOS par regroupement de ligne'
-    puis trace 6 courbes :
-      - CDT Assemblage (OBJ, ACT)
-      - CDT PE        (OBJ, ACT)
-      - Moyenne OBJ (entre les 2 OBJ)
-      - Moyenne ACT (entre les 2 ACT)
-    """
-    try:
-        df_raw = pd.read_excel(file.name, sheet_name='Synthèse usine', header=None)
-    except Exception as e:
-        raise gr.Error(f"Impossible de lire la feuille 'Synthèse usine'. Détails: {e}")
-
-    df, mois_cols, cols_desc = _prep_synthese(df_raw)
-
-    # Extraire les 4 séries principales
-    asm_obj = _extract_series(df, mois_cols, cols_desc, kpi_keywords=['cdt', 'assemblage'], type_keywords=['obj'])
-    asm_act = _extract_series(df, mois_cols, cols_desc, kpi_keywords=['cdt', 'assemblage'], type_keywords=['act'])
-    pe_obj  = _extract_series(df, mois_cols, cols_desc, kpi_keywords=['cdt', 'pe'],          type_keywords=['obj'])
-    pe_act  = _extract_series(df, mois_cols, cols_desc, kpi_keywords=['cdt', 'pe'],          type_keywords=['act'])
-
-    # Moyennes OBJ/ACT entre Assemblage et PE
-    mean_obj = pd.concat([asm_obj, pe_obj], axis=1).mean(axis=1)
-    mean_act = pd.concat([asm_act, pe_act], axis=1).mean(axis=1)
-
-    # Tracé
-    fig, ax = plt.subplots(figsize=(12, 6))
-    x = np.arange(len(mois_cols))
-
-    # 4 courbes + 2 moyennes
-    ax.plot(x, asm_obj.values, marker='o', label='CDT Assemblage - OBJ')
-    ax.plot(x, asm_act.values, marker='o', label='CDT Assemblage - ACT')
-    ax.plot(x, pe_obj.values,  marker='o', label='CDT PE - OBJ')
-    ax.plot(x, pe_act.values,  marker='o', label='CDT PE - ACT')
-    ax.plot(x, mean_obj.values, marker='D', linestyle='--', label='Moyenne OBJ (Asm+PE)')
-    ax.plot(x, mean_act.values, marker='D', linestyle='--', label='Moyenne ACT (Asm+PE)')
-
-    ax.set_xticks(x)
-    ax.set_xticklabels(mois_cols, rotation=0)
-    ax.set_xlabel("Mois")
-    ax.set_ylabel("Valeur")
-    ax.set_title("Évolution mensuelle – CDT Assemblage & CDT PE (OBJ/ACT) + Moyennes")
-    ax.grid(True, which='both', linestyle=':', linewidth=0.8)
-    ax.legend(loc='best', ncol=2)
-    plt.tight_layout()
     return fig
 
-# ======================
-# Interface Gradio (UI)
-# ======================
-with gr.Blocks(title="Maturity Analysis Dashboard") as demo:
-    gr.Markdown("## Analyse de Maturité\nChargez votre fichier Excel et utilisez les onglets ci-dessous.")
-    with gr.Tabs():
-        with gr.Tab("Par standard (ancien)"):
-            in_file1 = gr.File(label="Fichier Excel (.xlsx)", file_types=[".xlsx"])
-            mois_dd  = gr.Dropdown(choices=MOIS, value="Janv.", label="Mois")
-            out_plot1 = gr.Plot(label="Graphique")
-            btn1 = gr.Button("Générer")
-            btn1.click(fn=generer_graphique, inputs=[in_file1, mois_dd], outputs=out_plot1)
-
-        with gr.Tab("Courbes d’évolution (nouveau)"):
-            in_file2 = gr.File(label="Fichier Excel (.xlsx)", file_types=[".xlsx"])
-            out_plot2 = gr.Plot(label="Évolution mensuelle")
-            btn2 = gr.Button("Tracer")
-            btn2.click(fn=courbes_evolution, inputs=[in_file2], outputs=out_plot2)
-
-# Pour HF Spaces / Docker : ne pas ouvrir de navigateur
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-
+interface = gr.Interface(
+    fn=generer_graphique,
+    inputs=[
+        gr.File(label="Fichier Excel (.xlsx)", file_types=[".xlsx"]),
+        gr.Dropdown(choices=mois_disponibles, label="Mois")
+    ],
+    outputs=gr.Plot(label="Graphique"),
+    title="Analyse de Maturité par Standard",
+    description="Chargez un fichier Excel, sélectionnez un mois, et visualisez la moyenne des scores."
+)
+
+interface.launch()