Update src/module/Dashboard.py

src/module/Dashboard.py

@@ -23,59 +23,60 @@ class HospitalDashboard:
     def __init__(self, client, sheet_name):
         self.client = client
         self.sheet_name = sheet_name
-        # --- INITIALISATION ---
-        # On définit les attributs à None pour éviter les erreurs "AttributeError"
+        # Initialisation des attributs
         self.df_ressources = None 
         self.df_admissions = None
         self.df_stock = None
         
     def load_data(self):
         """Charge les données via le cache ou l'ETL"""
-        # 1. Tenter de récupérer depuis le session_state (Cache ETL déjà existant)
-        if 'data_explorer' in st.session_state and hasattr(st.session_state.data_explorer, 'dataframes'):
-            dfs = st.session_state.data_explorer.dataframes
+        # 1. Tenter de récupérer depuis le session_state
+        if 'data_explorer' in st.session_state and hasattr(st.session_state.data_explorer, 'dataframes_clean'):
+            dfs = st.session_state.data_explorer.dataframes_clean
             # Mapping sécurisé
             self.df_ressources = dfs.get('ressources_jour')
             self.df_admissions = dfs.get('admissions_jour')
             self.df_stock = dfs.get('stock_materiel_jour')
             return True
         
-        # 2. Sinon, lancer l'ETL silencieusement (Premier chargement)
+        # 2. Sinon, lancer l'ETL
         etl = ETL_Engine(self.client, self.sheet_name)
         success, result = etl.run_etl()
         if success:
-            # Mise à jour du state global
             st.session_state.data_explorer = result
-            # Mapping local
-            self.df_ressources = result.dataframes.get('ressources_jour')
-            self.df_admissions = result.dataframes.get('admissions_jour')
-            self.df_stock = result.dataframes.get('stock_materiel_jour')
+            self.df_ressources = result.dataframes_clean.get('ressources_jour')
+            self.df_admissions = result.dataframes_clean.get('admissions_jour')
+            self.df_stock = result.dataframes_clean.get('stock_materiel_jour')
             return True
             
         return False
 
     def _get_kpis(self):
-        """Calcul des KPIs globaux avec typage forcé pour éviter les erreurs"""
+        """Calcul des KPIs globaux avec conversion forcée"""
         # Sécurité : DataFrames vides si None
         df_res = self.df_ressources.copy() if self.df_ressources is not None else pd.DataFrame()
         df_adm = self.df_admissions.copy() if self.df_admissions is not None else pd.DataFrame()
         df_stock = self.df_stock.copy() if self.df_stock is not None else pd.DataFrame()
 
-        # --- 1. SÉCURITÉ TYPES (Int vs Str) ---
-        # On s'assure que les colonnes vitales sont bien des nombres
-        if 'lits_occupes' in df_res.columns:
-            df_res['lits_occupes'] = pd.to_numeric(df_res['lits_occupes'], errors='coerce').fillna(0)
-        if 'lits_total' in df_res.columns:
-            df_res['lits_total'] = pd.to_numeric(df_res['lits_total'], errors='coerce').fillna(0)
-        if 'personnel_disponible' in df_res.columns:
-             df_res['personnel_disponible'] = pd.to_numeric(df_res['personnel_disponible'], errors='coerce').fillna(0)
-        if 'personnel_requis' in df_res.columns:
-             df_res['personnel_requis'] = pd.to_numeric(df_res['personnel_requis'], errors='coerce').fillna(0)
-
-        # --- 2. CALCULS KPI ---
+        # === FIX CRITIQUE : CONVERSION FORCÉE DE TOUTES LES COLONNES NUMÉRIQUES ===
+        
+        # 1. Ressources
+        if not df_res.empty:
+            numeric_cols_res = ['lits_occupes', 'lits_total', 'taux_occupation', 
+                               'personnel_disponible', 'personnel_requis']
+            for col in numeric_cols_res:
+                if col in df_res.columns:
+                    df_res[col] = pd.to_numeric(df_res[col], errors='coerce').fillna(0)
+        
+        # 2. Admissions
+        if not df_adm.empty and 'nb_admissions' in df_adm.columns:
+            df_adm['nb_admissions'] = pd.to_numeric(df_adm['nb_admissions'], errors='coerce').fillna(0)
+        
+        # === CALCULS KPI ===
+        
         # A. Occupation
-        total_lits = df_res['lits_total'].sum()
-        total_occupes = df_res['lits_occupes'].sum()
+        total_lits = df_res['lits_total'].sum() if not df_res.empty else 0
+        total_occupes = df_res['lits_occupes'].sum() if not df_res.empty else 0
         
         if total_lits > 0:
             taux_global = (total_occupes / total_lits) * 100
@@ -83,50 +84,51 @@ class HospitalDashboard:
             taux_global = 0
             
         # B. Tension RH
-        total_staff_dispo = df_res['personnel_disponible'].sum()
-        total_staff_req = df_res['personnel_requis'].sum()
+        total_staff_dispo = df_res['personnel_disponible'].sum() if not df_res.empty else 0
+        total_staff_req = df_res['personnel_requis'].sum() if not df_res.empty else 0
         
         tension_rh = 0
         if total_staff_req > 0:
             tension_rh = (1 - (total_staff_dispo / total_staff_req)) * 100
 
-        # C. Admissions du jour (On fait la somme de la colonne)
-        nb_adm = 0
-        if not df_adm.empty and 'nb_admissions' in df_adm.columns:
-             nb_adm = pd.to_numeric(df_adm['nb_admissions'], errors='coerce').sum()
+        # C. Admissions totales
+        nb_adm = df_adm['nb_admissions'].sum() if not df_adm.empty else 0
 
-        # D. Services en Tension (Combien de services > 85% ?)
+        # D. Services en Tension (>85%)
+        # FIX : Maintenant taux_occupation est bien un float
         nb_tension = 0
         if not df_res.empty and 'taux_occupation' in df_res.columns:
-             nb_tension = df_res[df_res['taux_occupation'] > 0.85].shape[0]
+            nb_tension = int((df_res['taux_occupation'] > 0.85).sum())
 
-        # E. Ruptures Stock (On cherche les mots clés 'Rupture' ou 'Critique')
+        # E. Ruptures Stock
         nb_ruptures = 0
         if not df_stock.empty and 'alerte_stock' in df_stock.columns:
-             nb_ruptures = df_stock[df_stock['alerte_stock'].str.contains('Rupture|Critique', case=False, na=False)].shape[0]
+            nb_ruptures = int(df_stock['alerte_stock'].astype(str).str.contains('Rupture|Critique', case=False, na=False).sum())
 
         return {
             'lits_total': int(total_lits),
             'lits_occupes': int(total_occupes),
-            'taux_global': taux_global,
-            'tension_rh': tension_rh,
+            'taux_global': float(taux_global),
+            'tension_rh': float(tension_rh),
             'nb_adm': int(nb_adm),
             'nb_tension': int(nb_tension),
             'nb_ruptures': int(nb_ruptures)
         }
 
     def plot_main_chart(self):
-        """Graphique Hybride : Historique + Prédiction Standard"""
+        """Graphique Hybride : Historique + Prédiction"""
         fig = go.Figure()
         
         # Historique
         if self.df_ressources is not None and not self.df_ressources.empty:
             df_hist = self.df_ressources.copy()
             if 'date' in df_hist.columns:
-                df_hist['date'] = pd.to_datetime(df_hist['date'])
-                # On moyenne l'occupation par jour
+                df_hist['date'] = pd.to_datetime(df_hist['date'], errors='coerce')
+                # Conversion forcée
+                df_hist['taux_occupation'] = pd.to_numeric(df_hist['taux_occupation'], errors='coerce').fillna(0)
+                
+                # Moyenne par jour
                 daily_occ = df_hist.groupby('date')['taux_occupation'].mean() * 100
-                # On garde les 30 derniers jours pour lisibilité
                 daily_occ = daily_occ.tail(30)
                 
                 fig.add_trace(go.Scatter(
@@ -136,16 +138,16 @@ class HospitalDashboard:
                     fill='tozeroy', fillcolor='rgba(88, 166, 255, 0.1)'
                 ))
         
-        # Prédiction IA (si le module forecasting a tourné)
+        # Prédiction IA
         has_forecast = False
         if 'forecaster' in st.session_state:
             forecaster = st.session_state['forecaster']
             try:
-                # --- CORRECTION FORECASTING (On ignore la 3ème valeur '_') ---
                 f_dates, f_values, _ = forecaster.generate_future_forecast_recursive(months=1)
                 
-                # Adaptation d'échelle si le modèle sort des taux (0.8) au lieu de pourcentages (80)
-                if np.mean(f_values) < 2: f_values = f_values * 100
+                # Adaptation échelle
+                if np.mean(f_values) < 2: 
+                    f_values = f_values * 100
                     
                 fig.add_trace(go.Scatter(
                     x=f_dates, y=f_values,
@@ -156,36 +158,51 @@ class HospitalDashboard:
             except Exception: 
                 pass
 
-        # Ligne rouge de saturation
+        # Ligne saturation
         fig.add_hline(y=100, line_dash="dash", line_color="#FF5252", annotation_text="Saturation")
         
         title = "Taux d'Occupation : Réalité vs IA" if has_forecast else "Taux d'Occupation (Historique)"
-        fig.update_layout(title=title, template="plotly_dark", height=350, margin=dict(l=20, r=20, t=40, b=20))
+        fig.update_layout(
+            title=title, 
+            template="plotly_dark", 
+            height=350, 
+            margin=dict(l=20, r=20, t=40, b=20)
+        )
         return fig
 
     def plot_service_tension(self):
-        """Top Flop des services (Graphique en barres)"""
+        """Top Flop des services"""
         if self.df_ressources is None or self.df_ressources.empty:
             return go.Figure()
 
         df = self.df_ressources.copy()
-        df['date'] = pd.to_datetime(df['date'])
-        last_date = df['date'].max()
+        df['date'] = pd.to_datetime(df['date'], errors='coerce')
+        df['taux_occupation'] = pd.to_numeric(df['taux_occupation'], errors='coerce').fillna(0)
         
-        # On filtre sur la dernière date connue
+        last_date = df['date'].max()
         df_today = df[df['date'] == last_date].copy()
         df_today['taux_pct'] = df_today['taux_occupation'] * 100
         df_sorted = df_today.sort_values('taux_pct', ascending=True)
         
         # Couleurs conditionnelles
-        colors = ['#FF5252' if x >= 100 else '#FFA726' if x >= 85 else '#66BB6A' for x in df_sorted['taux_pct']]
+        colors = ['#FF5252' if x >= 100 else '#FFA726' if x >= 85 else '#66BB6A' 
+                  for x in df_sorted['taux_pct']]
         
         fig = go.Figure(go.Bar(
-            x=df_sorted['taux_pct'], y=df_sorted['service_code'],
-            orientation='h', marker_color=colors,
-            text=df_sorted['taux_pct'].round(1).astype(str) + '%', textposition='auto'
+            x=df_sorted['taux_pct'], 
+            y=df_sorted['service_code'],
+            orientation='h', 
+            marker_color=colors,
+            text=[f"{x:.1f}%" for x in df_sorted['taux_pct']], 
+            textposition='auto'
         ))
-        fig.update_layout(title=f"État Services ({last_date.strftime('%d/%m')})", template="plotly_dark", height=350, margin=dict(l=20, r=20, t=40, b=20))
+        
+        fig.update_layout(
+            title=f"État Services ({last_date.strftime('%d/%m')})", 
+            template="plotly_dark", 
+            height=350, 
+            margin=dict(l=20, r=20, t=40, b=20)
+        )
         return fig
 
     def run_simulation(self, impact_admission, impact_lits):
@@ -196,15 +213,15 @@ class HospitalDashboard:
         forecaster = st.session_state['forecaster']
         
         try:
-            # --- CORRECTION FORECASTING (On ignore la 3ème valeur '_') ---
             f_dates, f_values, _ = forecaster.generate_future_forecast_recursive(months=3)
         except:
             return None, None, None
         
-        # Si le modèle prédit un taux (0-1), on met en %
-        if np.mean(f_values) < 2: f_values = f_values * 100
+        # Adaptation échelle
+        if np.mean(f_values) < 2: 
+            f_values = f_values * 100
             
-        # Application des modificateurs (Simulateur)
+        # Application des modificateurs
         factor_adm = 1 + (impact_admission / 100)
         factor_capa = 1 + (impact_lits / 100)
         
@@ -220,39 +237,55 @@ def show_dashboard(client, sheet_name):
     # Instanciation
     dashboard = HospitalDashboard(client, sheet_name)
     
-    # Chargement discret (appel de la méthode corrigée)
+    # Chargement
     if not dashboard.load_data():
-        st.error("Données indisponibles. Lancez l'ETL d'abord.")
+        st.error("❌ Données indisponibles. Lancez l'ETL d'abord.")
         return
 
-    # --- BANDEAU KPIs (Toujours visible) ---
+    # Bandeau KPIs
     kpis = dashboard._get_kpis()
     k1, k2, k3, k4 = st.columns(4)
     
-    k1.metric("Taux Occupation", f"{kpis['taux_global']:.1f}%", delta="Critique" if kpis['taux_global'] > 90 else "OK", delta_color="inverse")
+    k1.metric(
+        "Taux Occupation", 
+        f"{kpis['taux_global']:.1f}%", 
+        delta="Critique" if kpis['taux_global'] > 90 else "OK", 
+        delta_color="inverse"
+    )
     k2.metric("Admissions (Total)", f"{kpis['nb_adm']:,}") 
-    k3.metric("Services Tendus", f"{kpis['nb_tension']}", delta="Alertes", delta_color="inverse")
-    k4.metric("Ruptures Stock", f"{kpis['nb_ruptures']}", delta="Alertes", delta_color="inverse")
+    k3.metric(
+        "Services Tendus", 
+        f"{kpis['nb_tension']}", 
+        delta="Alertes" if kpis['nb_tension'] > 0 else "OK", 
+        delta_color="inverse"
+    )
+    k4.metric(
+        "Ruptures Stock", 
+        f"{kpis['nb_ruptures']}", 
+        delta="Alertes" if kpis['nb_ruptures'] > 0 else "OK", 
+        delta_color="inverse"
+    )
     
     st.divider()
 
-    # --- ONGLETS : SUPERVISION vs SIMULATION ---
+    # Onglets
     tab_live, tab_sim = st.tabs(["📡 Supervision Temps Réel", "🎛️ Simulateur de Crise"])
 
-    # === ONGLET 1 : SUPERVISION ===
+    # ONGLET 1 : SUPERVISION
     with tab_live:
         col_main, col_side = st.columns([2, 1])
+        
         with col_main:
             st.plotly_chart(dashboard.plot_main_chart(), use_container_width=True)
+        
         with col_side:
             st.plotly_chart(dashboard.plot_service_tension(), use_container_width=True)
             
-        # --- FLASH REPORT DYNAMIQUE ---
+        # Flash Report
         st.markdown("### ⚡ Flash Report & Recommandations")
         col_msg, col_act = st.columns([3, 1])
         
         with col_msg:
-            # Logique conditionnelle simple
             if kpis['taux_global'] > 95:
                 msg_status = "🔴 **CRITIQUE :** L'hôpital est proche de la saturation totale."
                 msg_action = "👉 **ACTION REQUISE :** Activer le Plan Blanc et délester les services d'Urgence."
@@ -271,14 +304,13 @@ def show_dashboard(client, sheet_name):
             if st.button("📊 Export PDF"):
                 st.toast("Rapport généré.", icon="📄")
 
-    # === ONGLET 2 : SIMULATEUR ===
+    # ONGLET 2 : SIMULATEUR
     with tab_sim:
         st.markdown("### 🧪 Bac à Sable (What-If Analysis)")
         
         if 'forecaster' not in st.session_state:
             st.warning("⚠️ Le module 'Simulateur' nécessite que l'IA soit activée.")
             if st.button("Activer l'IA maintenant"):
-                # Essayer de rediriger ou afficher un message
                 st.info("Allez dans le menu 'Forecasting' pour entraîner le modèle.")
         else:
             col_params, col_viz = st.columns([1, 3])
@@ -287,8 +319,18 @@ def show_dashboard(client, sheet_name):
                 st.markdown("#### 1. Paramètres")
                 st.caption("Modifiez les variables pour voir l'impact futur.")
                 
-                choc_adm = st.slider("🌊 Choc d'Admissions", -20, +50, 0, format="%+d%%", help="Ex: Grippe, Plan Blanc (+30%)")
-                choc_lits = st.slider("🛏️ Ouverture Lits", -20, +20, 0, format="%+d%%", help="Ex: Ouverture d'une aile (+10%)")
+                choc_adm = st.slider(
+                    "🌊 Choc d'Admissions", 
+                    -20, +50, 0, 
+                    format="%+d%%", 
+                    help="Ex: Grippe, Plan Blanc (+30%)"
+                )
+                choc_lits = st.slider(
+                    "🛏️ Ouverture Lits", 
+                    -20, +20, 0, 
+                    format="%+d%%", 
+                    help="Ex: Ouverture d'une aile (+10%)"
+                )
                 
                 st.markdown("---")
                 
@@ -297,31 +339,57 @@ def show_dashboard(client, sheet_name):
                 
                 if simu is not None:
                     delta_max = np.max(simu) - np.max(base)
-                    st.metric("Impact Peak", f"{delta_max:+.1f} pts", delta="Risque" if delta_max > 0 else "Gain", delta_color="inverse")
+                    st.metric(
+                        "Impact Peak", 
+                        f"{delta_max:+.1f} pts", 
+                        delta="Risque" if delta_max > 0 else "Gain", 
+                        delta_color="inverse"
+                    )
 
             with col_viz:
                 st.markdown("#### 2. Projection d'Impact (3 Mois)")
+                
                 if simu is not None:
                     fig_sim = go.Figure()
                     
                     # Courbe de base
-                    fig_sim.add_trace(go.Scatter(x=dates, y=base, name="Scénario Actuel", line=dict(color='gray', dash='dot')))
+                    fig_sim.add_trace(go.Scatter(
+                        x=dates, y=base, 
+                        name="Scénario Actuel", 
+                        line=dict(color='gray', dash='dot')
+                    ))
                     
                     # Courbe simulée
                     color_sim = '#FF5252' if np.max(simu) > 100 else '#00E676'
-                    fig_sim.add_trace(go.Scatter(x=dates, y=simu, name="Scénario Simulé", line=dict(color=color_sim, width=3), fill='tonexty'))
+                    fig_sim.add_trace(go.Scatter(
+                        x=dates, y=simu, 
+                        name="Scénario Simulé", 
+                        line=dict(color=color_sim, width=3), 
+                        fill='tonexty'
+                    ))
                     
                     # Seuil
-                    fig_sim.add_hline(y=100, line_color="white", annotation_text="Capacité Max")
+                    fig_sim.add_hline(
+                        y=100, 
+                        line_color="white", 
+                        annotation_text="Capacité Max"
+                    )
                     
-                    fig_sim.update_layout(template="plotly_dark", height=400, hovermode="x unified", title="Impact sur le Taux d'Occupation")
+                    fig_sim.update_layout(
+                        template="plotly_dark", 
+                        height=400, 
+                        hovermode="x unified", 
+                        title="Impact sur le Taux d'Occupation"
+                    )
                     st.plotly_chart(fig_sim, use_container_width=True)
                     
-                    # Conclusion automatique de simulation
+                    # Conclusion automatique
                     max_val = np.max(simu)
                     if max_val > 100:
-                        st.error(f"🚨 **ALERTE CRITIQUE :** Ce scénario entraîne une saturation à **{max_val:.1f}%**. Il faut augmenter la capacité d'au moins **{max_val-100:.1f}%**.")
+                        st.error(f"🚨 **ALERTE CRITIQUE :** Ce scénario entraîne une saturation à **{max_val:.1f}%**. "
+                                f"Il faut augmenter la capacité d'au moins **{max_val-100:.1f}%**.")
                     elif max_val > 85:
-                        st.warning(f"⚠️ **TENSION :** Ce scénario provoque une tension forte ({max_val:.1f}%). Surveillance requise.")
+                        st.warning(f"⚠️ **TENSION :** Ce scénario provoque une tension forte ({max_val:.1f}%). "
+                                  f"Surveillance requise.")
                     else:
                         st.success(f"�� **ROBUSTE :** L'hôpital tient le choc ({max_val:.1f}% max).")