Update src/module/Indicateurs_DQ.py

src/module/Indicateurs_DQ.py

@@ -1,24 +1,8 @@
 """
-MODULE: DATA QUALITY DASHBOARD - VERSION COMPLÈTE
-==================================================
-Responsabilité : Audit complet, détection d'anomalies, analyses spécifiques hospitalières.
-Style : Gotham UI + Analyses médicales avancées
-
-Fonctionnalités :
-- ✅ Accès Google Sheets (via _client)
-- ✅ Upload fichier Excel local
-- ✅ 6 sections complètes d'analyse DQ
-- ✅ Métriques hospitalières spécifiques
-- ✅ Visualisations enrichies
-- ✅ Analyses temporelles des anomalies
-- ✅ Recommandations automatiques
-- ✅ Export rapports CSV
-
-Améliorations vs version originale :
-- Chargement direct (pas de filtrage ETL) pour voir toutes les anomalies
-- 6 sections au lieu de 2
-- Analyses spécifiques au contexte hospitalier
-- Visualisations interactives avancées
+MODULE: DATA QUALITY DASHBOARD - VERSION CORRIGÉE
+=================================================
+Responsabilité : Audit complet, détection d'anomalies.
+Correction : Gestion stricte des types numériques pour éviter les crashs (int/str).
 """
 
 import streamlit as st
@@ -41,7 +25,7 @@ def safe_int(value):
     try:
         if pd.isna(value):
             return 0
-        return int(value)
+        return int(float(value)) # Double cast pour gérer les strings '1.0'
     except (TypeError, ValueError, OverflowError):
         return 0
 
@@ -70,24 +54,12 @@ def safe_pct(num, den):
 # ================= CHARGEMENT DONNÉES ================
 # =====================================================
 
-@st.cache_data(ttl=3600)
+@st.cache_data(ttl=60) # TTL court pour voir les nouvelles données injectées
 def load_from_google_sheets(_client, sheet_name: str) -> dict:
-
-    """
-    Charge les données depuis Google Sheets SANS passer par ETL.
-    Garantit qu'aucune anomalie n'est filtrée.
-    
-    Args:
-        _client: _client Google Sheets
-        sheet_name: Nom de la feuille Google Sheets
-        
-    Returns:
-        Dictionnaire de DataFrames
-    """
+    """Charge les données depuis Google Sheets SANS passer par ETL."""
     sheets = {}
     
     try:
-        # Liste des feuilles à charger
         sheet_names = [
             'patients', 'sejours', 'ressources_jour', 
             'stock_materiel_jour', 'admissions_jour', 'scenarios_calendrier'
@@ -95,50 +67,34 @@ def load_from_google_sheets(_client, sheet_name: str) -> dict:
         
         for name in sheet_names:
             try:
-                # Récupération directe depuis Google Sheets
                 worksheet = _client.open(sheet_name).worksheet(name)
                 data = worksheet.get_all_records()
                 df = pd.DataFrame(data)
                 
                 # Conversion des dates
-                if 'date' in df.columns:
-                    df['date'] = pd.to_datetime(df['date'], errors='coerce')
-                if 'date_entree' in df.columns:
-                    df['date_entree'] = pd.to_datetime(df['date_entree'], errors='coerce')
-                if 'date_sortie' in df.columns:
-                    df['date_sortie'] = pd.to_datetime(df['date_sortie'], errors='coerce')
-                if 'date_naissance' in df.columns:
-                    df['date_naissance'] = pd.to_datetime(df['date_naissance'], errors='coerce')
+                date_cols = ['date', 'date_entree', 'date_sortie', 'date_naissance']
+                for col in date_cols:
+                    if col in df.columns:
+                        df[col] = pd.to_datetime(df[col], errors='coerce')
                 
                 sheets[name] = df
                 
             except Exception as e:
-                st.warning(f"⚠️ Impossible de charger la feuille '{name}': {str(e)}")
+                # On continue même si une feuille manque
                 continue
         
         return sheets
         
     except Exception as e:
-        st.error(f"❌ Erreur lors du chargement depuis Google Sheets : {str(e)}")
+        st.error(f"Erreur lors du chargement depuis Google Sheets : {str(e)}")
         return {}
 
 
 @st.cache_data(ttl=3600)
 def load_from_excel_file(file) -> dict:
-    """
-    Charge les données depuis un fichier Excel uploadé.
-    Garantit qu'aucune anomalie n'est filtrée.
-    
-    Args:
-        file: Fichier uploadé via st.file_uploader
-        
-    Returns:
-        Dictionnaire de DataFrames
-    """
+    """Charge les données depuis un fichier Excel uploadé."""
     sheets = {}
-    
     try:
-        # Chargement de toutes les feuilles nécessaires
         sheets['patients'] = pd.read_excel(file, sheet_name='patients')
         sheets['sejours'] = pd.read_excel(file, sheet_name='sejours')
         sheets['ressources_jour'] = pd.read_excel(file, sheet_name='ressources_jour')
@@ -146,21 +102,13 @@ def load_from_excel_file(file) -> dict:
         sheets['admissions_jour'] = pd.read_excel(file, sheet_name='admissions_jour')
         sheets['scenarios_calendrier'] = pd.read_excel(file, sheet_name='scenarios_calendrier')
         
-        # Conversion des dates
         for sheet_name, df in sheets.items():
-            if 'date' in df.columns:
-                df['date'] = pd.to_datetime(df['date'], errors='coerce')
-            if 'date_entree' in df.columns:
-                df['date_entree'] = pd.to_datetime(df['date_entree'], errors='coerce')
-            if 'date_sortie' in df.columns:
-                df['date_sortie'] = pd.to_datetime(df['date_sortie'], errors='coerce')
-            if 'date_naissance' in df.columns:
-                df['date_naissance'] = pd.to_datetime(df['date_naissance'], errors='coerce')
-        
+            for col in df.columns:
+                if 'date' in col.lower():
+                    df[col] = pd.to_datetime(df[col], errors='coerce')
         return sheets
-        
     except Exception as e:
-        st.error(f"❌ Erreur lors du chargement du fichier Excel : {str(e)}")
+        st.error(f"Erreur lors du chargement du fichier Excel : {str(e)}")
         return {}
 
 
@@ -182,20 +130,33 @@ class HospitalDataQualityAnalyzer:
         self.metrics = {}
         self._compute_all_metrics()
     
+    def _force_numeric_anomaly(self, df):
+        """Force la colonne dq_is_anomaly en numérique pour éviter les crashs"""
+        if df is not None and not df.empty and 'dq_is_anomaly' in df.columns:
+            # Conversion robuste : force tout en nombre, remplace les erreurs par 0
+            df['dq_is_anomaly'] = pd.to_numeric(df['dq_is_anomaly'], errors='coerce').fillna(0).astype(int)
+        return df
+
     def _compute_all_metrics(self):
         """Calcul de toutes les métriques DQ"""
         
+        # NETTOYAGE PRÉALABLE : Conversion des types pour éviter le crash int+str
+        self.df_pat = self._force_numeric_anomaly(self.df_pat)
+        self.df_sej = self._force_numeric_anomaly(self.df_sej)
+        self.df_res = self._force_numeric_anomaly(self.df_res)
+        self.df_stock = self._force_numeric_anomaly(self.df_stock)
+
         # ============= PATIENTS =============
         if self.df_pat is not None and not self.df_pat.empty:
             self.metrics['patients'] = {
                 'total': len(self.df_pat),
-                'anomalies': safe_int(self.df_pat['dq_is_anomaly'].sum()),
-                'doublons': safe_int(self.df_pat.duplicated(subset=['nom', 'prenom']).sum()),
-                'ages_negatifs': safe_int((self.df_pat['age'] < 0).sum()),
-                'ages_aberrants': safe_int((self.df_pat['age'] > 120).sum()),
-                'missing_birth': safe_int(self.df_pat['date_naissance'].isnull().sum()),
-                'missing_ville': safe_int(self.df_pat['ville'].isnull().sum()),
-                'missing_total': safe_int(self.df_pat.isnull().sum().sum())
+                'anomalies': int(self.df_pat['dq_is_anomaly'].sum()),
+                'doublons': int(self.df_pat.duplicated(subset=['nom', 'prenom']).sum()),
+                'ages_negatifs': int((pd.to_numeric(self.df_pat['age'], errors='coerce') < 0).sum()),
+                'ages_aberrants': int((pd.to_numeric(self.df_pat['age'], errors='coerce') > 120).sum()),
+                'missing_birth': int(self.df_pat['date_naissance'].isnull().sum()),
+                'missing_ville': int(self.df_pat['ville'].isnull().sum()),
+                'missing_total': int(self.df_pat.isnull().sum().sum())
             }
         else:
             self.metrics['patients'] = {k: 0 for k in ['total', 'anomalies', 'doublons', 'ages_negatifs', 
@@ -203,16 +164,17 @@ class HospitalDataQualityAnalyzer:
         
         # ============= SÉJOURS =============
         if self.df_sej is not None and not self.df_sej.empty:
-            dates_inversees = safe_int((self.df_sej['date_sortie'] < self.df_sej['date_entree']).sum())
-            gravite_aberrante = safe_int(((self.df_sej['gravite_1_5'] > 5) | (self.df_sej['gravite_1_5'] < 0)).sum())
+            dates_inversees = int((self.df_sej['date_sortie'] < self.df_sej['date_entree']).sum())
+            gravite = pd.to_numeric(self.df_sej['gravite_1_5'], errors='coerce').fillna(3)
+            gravite_aberrante = int(((gravite > 5) | (gravite < 0)).sum())
             
             self.metrics['sejours'] = {
                 'total': len(self.df_sej),
-                'anomalies': safe_int(self.df_sej['dq_is_anomaly'].sum()),
+                'anomalies': int(self.df_sej['dq_is_anomaly'].sum()),
                 'dates_inversees': dates_inversees,
                 'gravite_aberrante': gravite_aberrante,
-                'equipement_manquant': safe_int(self.df_sej['equipement_principal_code'].isnull().sum()),
-                'missing_total': safe_int(self.df_sej.isnull().sum().sum())
+                'equipement_manquant': int(self.df_sej['equipement_principal_code'].isnull().sum()),
+                'missing_total': int(self.df_sej.isnull().sum().sum())
             }
         else:
             self.metrics['sejours'] = {k: 0 for k in ['total', 'anomalies', 'dates_inversees', 
@@ -222,13 +184,14 @@ class HospitalDataQualityAnalyzer:
         if self.df_res is not None and not self.df_res.empty:
             df_res_temp = self.df_res.copy()
             df_res_temp['lits_occupes_num'] = pd.to_numeric(df_res_temp['lits_occupes'], errors='coerce').fillna(0)
-            suroccupation = safe_int((df_res_temp['lits_occupes_num'] > df_res_temp['lits_total']).sum())
+            df_res_temp['lits_total_num'] = pd.to_numeric(df_res_temp['lits_total'], errors='coerce').fillna(1)
+            suroccupation = int((df_res_temp['lits_occupes_num'] > df_res_temp['lits_total_num']).sum())
             
             self.metrics['ressources'] = {
                 'total': len(self.df_res),
-                'anomalies': safe_int(self.df_res['dq_is_anomaly'].sum()),
+                'anomalies': int(self.df_res['dq_is_anomaly'].sum()),
                 'suroccupation': suroccupation,
-                'missing_total': safe_int(self.df_res.isnull().sum().sum())
+                'missing_total': int(self.df_res.isnull().sum().sum())
             }
         else:
             self.metrics['ressources'] = {k: 0 for k in ['total', 'anomalies', 'suroccupation', 'missing_total']}
@@ -237,9 +200,9 @@ class HospitalDataQualityAnalyzer:
         if self.df_stock is not None and not self.df_stock.empty:
             self.metrics['stock'] = {
                 'total': len(self.df_stock),
-                'anomalies': safe_int(self.df_stock['dq_is_anomaly'].sum()),
-                'alertes': safe_int((self.df_stock['alerte_stock'] == 1).sum()),
-                'missing_total': safe_int(self.df_stock.isnull().sum().sum())
+                'anomalies': int(self.df_stock['dq_is_anomaly'].sum()),
+                'alertes': int((self.df_stock['alerte_stock'].astype(str) == '1').sum()),
+                'missing_total': int(self.df_stock.isnull().sum().sum())
             }
         else:
             self.metrics['stock'] = {k: 0 for k in ['total', 'anomalies', 'alertes', 'missing_total']}
@@ -297,25 +260,25 @@ class HospitalDataQualityAnalyzer:
         
         # Complétude
         total_rows = (self.metrics['patients']['total'] + 
-                     self.metrics['sejours']['total'] + 
-                     self.metrics['ressources']['total'])
+                      self.metrics['sejours']['total'] + 
+                      self.metrics['ressources']['total'])
         
         total_missing = (self.metrics['patients']['missing_total'] + 
-                        self.metrics['sejours']['missing_total'] + 
-                        self.metrics['ressources']['missing_total'])
+                         self.metrics['sejours']['missing_total'] + 
+                         self.metrics['ressources']['missing_total'])
         
         completeness_score = safe_pct(total_rows - total_missing, total_rows)
         
         # Exactitude
         total_all_rows = (self.metrics['patients']['total'] + 
-                         self.metrics['sejours']['total'] + 
-                         self.metrics['ressources']['total'] + 
-                         self.metrics['stock']['total'])
+                          self.metrics['sejours']['total'] + 
+                          self.metrics['ressources']['total'] + 
+                          self.metrics['stock']['total'])
         
         total_anomalies = (self.metrics['patients']['anomalies'] + 
-                          self.metrics['sejours']['anomalies'] + 
-                          self.metrics['ressources']['anomalies'] + 
-                          self.metrics['stock']['anomalies'])
+                           self.metrics['sejours']['anomalies'] + 
+                           self.metrics['ressources']['anomalies'] + 
+                           self.metrics['stock']['anomalies'])
         
         accuracy_score = safe_pct(total_all_rows - total_anomalies, total_all_rows)
         
@@ -459,11 +422,11 @@ def plot_completeness_radar(analyzer: HospitalDataQualityAnalyzer):
     patient_completeness = 100 - safe_pct(metrics['patients']['missing_total'], 
                                           metrics['patients']['total'] * len(analyzer.df_pat.columns) if analyzer.df_pat is not None else 1)
     sejour_completeness = 100 - safe_pct(metrics['sejours']['missing_total'], 
-                                        metrics['sejours']['total'] * len(analyzer.df_sej.columns) if analyzer.df_sej is not None else 1)
+                                         metrics['sejours']['total'] * len(analyzer.df_sej.columns) if analyzer.df_sej is not None else 1)
     ressource_completeness = 100 - safe_pct(metrics['ressources']['missing_total'], 
-                                           metrics['ressources']['total'] * len(analyzer.df_res.columns) if analyzer.df_res is not None else 1)
+                                            metrics['ressources']['total'] * len(analyzer.df_res.columns) if analyzer.df_res is not None else 1)
     stock_completeness = 100 - safe_pct(metrics['stock']['missing_total'], 
-                                       metrics['stock']['total'] * len(analyzer.df_stock.columns) if analyzer.df_stock is not None else 1)
+                                        metrics['stock']['total'] * len(analyzer.df_stock.columns) if analyzer.df_stock is not None else 1)
     
     categories = ['Patients', 'Séjours', 'Ressources', 'Stock']
     values = [patient_completeness, sejour_completeness, ressource_completeness, stock_completeness]
@@ -501,10 +464,6 @@ def plot_completeness_radar(analyzer: HospitalDataQualityAnalyzer):
 def show_dq_dashboard(_client=None, sheet_name=None):
     """
     Dashboard Data Quality complet avec support Google Sheets et Upload Fichier.
-    
-    Args:
-        _client: _client Google Sheets (optionnel)
-        sheet_name: Nom de la feuille Google Sheets (optionnel)
     """
     st.markdown("## 🛡️ CENTRE DE CONTRÔLE DATA QUALITY")
     st.caption("Analyse complète de la qualité des données hospitalières")
@@ -513,16 +472,13 @@ def show_dq_dashboard(_client=None, sheet_name=None):
     
     # ================= MODE DE CHARGEMENT =================
     if _client is not None and sheet_name is not None:
-        # Mode Google Sheets (prioritaire si _client fourni)
         st.info("📊 **Mode : Google Sheets**")
         
         with st.spinner("🔄 Chargement depuis Google Sheets..."):
             dataframes = load_from_google_sheets(_client, sheet_name)
     
     else:
-        # Mode Upload Fichier
         st.sidebar.header("⚙️ Configuration")
-        
         uploaded_file = st.sidebar.file_uploader(
             "Charger le fichier Excel",
             type=['xlsx'],
@@ -531,7 +487,6 @@ def show_dq_dashboard(_client=None, sheet_name=None):
         
         if uploaded_file is not None:
             st.info("📁 **Mode : Fichier Excel Local**")
-            
             with st.spinner("🔄 Chargement du fichier Excel..."):
                 dataframes = load_from_excel_file(uploaded_file)
         else:
@@ -556,40 +511,14 @@ def show_dq_dashboard(_client=None, sheet_name=None):
     st.markdown("### 📊 Synthèse de Santé des Données")
     
     col1, col2, col3, col4 = st.columns(4)
-    
     metrics = analyzer.metrics
     
-    col1.metric(
-        "🔴 Anomalies Patients", 
-        f"{metrics['patients']['anomalies']:,}",
-        f"{safe_pct(metrics['patients']['anomalies'], metrics['patients']['total'])}%",
-        delta_color="inverse"
-    )
-    
-    col2.metric(
-        "🔴 Anomalies Séjours",
-        f"{metrics['sejours']['anomalies']:,}",
-        f"{safe_pct(metrics['sejours']['anomalies'], metrics['sejours']['total'])}%",
-        delta_color="inverse"
-    )
-    
-    col3.metric(
-        "🔴 Anomalies Ressources",
-        f"{metrics['ressources']['anomalies']:,}",
-        f"{safe_pct(metrics['ressources']['anomalies'], metrics['ressources']['total'])}%",
-        delta_color="inverse"
-    )
-    
-    col4.metric(
-        "🔴 Anomalies Stock",
-        f"{metrics['stock']['anomalies']:,}",
-        f"{safe_pct(metrics['stock']['anomalies'], metrics['stock']['total'])}%",
-        delta_color="inverse"
-    )
+    col1.metric("🔴 Anomalies Patients", f"{metrics['patients']['anomalies']:,}", delta_color="inverse")
+    col2.metric("🔴 Anomalies Séjours", f"{metrics['sejours']['anomalies']:,}", delta_color="inverse")
+    col3.metric("🔴 Anomalies Ressources", f"{metrics['ressources']['anomalies']:,}", delta_color="inverse")
+    col4.metric("🔴 Anomalies Stock", f"{metrics['stock']['anomalies']:,}", delta_color="inverse")
     
-    # Graphique distribution anomalies
     st.plotly_chart(plot_anomalies_distribution(analyzer), use_container_width=True)
-    
     st.divider()
     
     # ==================================================
@@ -611,16 +540,10 @@ def show_dq_dashboard(_client=None, sheet_name=None):
                 
                 if not missing_df.empty:
                     st.caption(f"📊 {len(missing_df)} colonnes avec données manquantes")
-                    
-                    fig = px.bar(
-                        missing_df.sort_values('Pourcentage Manquant', ascending=False),
-                        x='Colonne', 
-                        y='Pourcentage Manquant',
-                        title=f"Données manquantes - {df_name}",
-                        color='Pourcentage Manquant',
-                        color_continuous_scale='Reds',
-                        text='Pourcentage Manquant'
-                    )
+                    fig = px.bar(missing_df.sort_values('Pourcentage Manquant', ascending=False),
+                                 x='Colonne', y='Pourcentage Manquant',
+                                 title=f"Données manquantes - {df_name}",
+                                 color='Pourcentage Manquant', color_continuous_scale='Reds', text='Pourcentage Manquant')
                     fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
                     fig.update_layout(xaxis_tickangle=-45, height=400)
                     st.plotly_chart(fig, use_container_width=True)
@@ -629,226 +552,126 @@ def show_dq_dashboard(_client=None, sheet_name=None):
             else:
                 st.warning(f"⚠️ Aucune donnée {df_name} disponible")
     
-    # Radar de complétude
     st.plotly_chart(plot_completeness_radar(analyzer), use_container_width=True)
-    
     st.divider()
     
     # ==================================================
     # ========== 2️⃣ COHÉRENCE DES DONNÉES =============
     # ==================================================
     st.subheader("2️⃣ Cohérence et Validité des Données")
-    
     col1, col2 = st.columns(2)
-    
     with col1:
         st.markdown("#### 👥 Cohérence Patients")
         st.metric("Âges négatifs", metrics['patients']['ages_negatifs'], delta_color="inverse")
         st.metric("Âges aberrants (>120 ans)", metrics['patients']['ages_aberrants'], delta_color="inverse")
         st.metric("Doublons (nom+prénom)", metrics['patients']['doublons'], delta_color="inverse")
-    
     with col2:
         st.markdown("#### 🏥 Cohérence Séjours")
         st.metric("Dates inversées (sortie < entrée)", metrics['sejours']['dates_inversees'], delta_color="inverse")
         st.metric("Gravité aberrante (<0 ou >5)", metrics['sejours']['gravite_aberrante'], delta_color="inverse")
         st.metric("Équipement manquant", metrics['sejours']['equipement_manquant'], delta_color="inverse")
     
-    # Graphique qualité par service
     fig_service = plot_service_quality_heatmap(analyzer)
-    if fig_service:
-        st.plotly_chart(fig_service, use_container_width=True)
-    
+    if fig_service: st.plotly_chart(fig_service, use_container_width=True)
     st.divider()
     
     # ==================================================
     # ========== 3️⃣ ANALYSE DES ANOMALIES =============
     # ==================================================
     st.subheader("3️⃣ Analyse Détaillée des Anomalies")
-    
     tab1, tab2, tab3, tab4 = st.tabs(["📋 Patients", "🏥 Séjours", "⚕️ Ressources", "📦 Stock"])
-    
     for tab, df_label in [(tab1, 'pat'), (tab2, 'sej'), (tab3, 'res'), (tab4, 'stock')]:
         with tab:
             anomaly_details = analyzer.get_anomalies_by_type(df_label)
-            
             if not anomaly_details.empty:
                 st.dataframe(anomaly_details, use_container_width=True)
-                
-                fig = px.pie(
-                    anomaly_details,
-                    values='Nombre',
-                    names='Type Anomalie',
-                    title=f"Répartition des Types d'Anomalies"
-                )
+                fig = px.pie(anomaly_details, values='Nombre', names='Type Anomalie', title=f"Répartition des Types d'Anomalies")
                 st.plotly_chart(fig, use_container_width=True)
             else:
                 st.success(f"✅ Aucune anomalie détectée")
     
-    # Évolution temporelle
     fig_temporal = plot_temporal_anomalies(analyzer)
-    if fig_temporal:
-        st.plotly_chart(fig_temporal, use_container_width=True)
-    
+    if fig_temporal: st.plotly_chart(fig_temporal, use_container_width=True)
     st.divider()
     
     # ==================================================
     # ========== 4️⃣ SPÉCIFICITÉS HOSPITALIÈRES ========
     # ==================================================
     st.subheader("4️⃣ Analyses Spécifiques Hospitalières")
-    
     col1, col2 = st.columns(2)
-    
     with col1:
         st.markdown("#### 🛏️ Ressources")
         if analyzer.df_res is not None:
             st.metric("Cas de suroccupation", metrics['ressources']['suroccupation'], delta_color="inverse")
-            
-            # Taux occupation moyen par service
             if 'service_code' in analyzer.df_res.columns and 'taux_occupation' in analyzer.df_res.columns:
                 taux_moy = analyzer.df_res.groupby('service_code')['taux_occupation'].mean().reset_index()
                 taux_moy.columns = ['Service', 'Taux Occupation Moyen']
-                taux_moy = taux_moy.sort_values('Taux Occupation Moyen', ascending=False)
-                
-                fig = px.bar(
-                    taux_moy.head(10),
-                    x='Service',
-                    y='Taux Occupation Moyen',
-                    title="Top 10 Services - Taux Occupation",
-                    color='Taux Occupation Moyen',
-                    color_continuous_scale='RdYlGn_r'
-                )
+                fig = px.bar(taux_moy.head(10), x='Service', y='Taux Occupation Moyen', title="Top 10 Services - Taux Occupation", color='Taux Occupation Moyen', color_continuous_scale='RdYlGn_r')
                 st.plotly_chart(fig, use_container_width=True)
-    
     with col2:
         st.markdown("#### 📦 Stock")
         st.metric("Alertes stock actives", metrics['stock']['alertes'], delta_color="inverse")
-        
-        # Distribution des alertes par matériel
         if analyzer.df_stock is not None and 'alerte_stock' in analyzer.df_stock.columns:
-            alertes = analyzer.df_stock[analyzer.df_stock['alerte_stock'] == 1]
+            alertes = analyzer.df_stock[analyzer.df_stock['alerte_stock'].astype(str) == '1']
             if not alertes.empty and 'materiel_code' in alertes.columns:
                 alert_counts = alertes['materiel_code'].value_counts().reset_index()
                 alert_counts.columns = ['Matériel', 'Nombre Alertes']
-                
-                fig = px.bar(
-                    alert_counts.head(10),
-                    x='Matériel',
-                    y='Nombre Alertes',
-                    title="Top 10 Matériels en Alerte",
-                    color='Nombre Alertes',
-                    color_continuous_scale='Oranges'
-                )
+                fig = px.bar(alert_counts.head(10), x='Matériel', y='Nombre Alertes', title="Top 10 Matériels en Alerte", color='Nombre Alertes', color_continuous_scale='Oranges')
                 st.plotly_chart(fig, use_container_width=True)
-    
     st.divider()
     
     # ==================================================
     # ========== 5️⃣ RÉSUMÉ EXÉCUTIF ===================
     # ==================================================
     st.subheader("5️⃣ Résumé Exécutif Data Quality")
-    
     col1, col2, col3 = st.columns(3)
-    
     col1.metric("Score de Complétude", f"{scores['completeness']:.2f}%")
     col2.metric("Score d'Exactitude", f"{scores['accuracy']:.2f}%")
-    
     global_score = scores['global']
-    
-    if global_score >= 95:
-        status = "🟢 EXCELLENT"
-        color = "green"
-    elif global_score >= 85:
-        status = "🟡 BON"
-        color = "blue"
-    elif global_score >= 70:
-        status = "🟠 MOYEN"
-        color = "orange"
-    else:
-        status = "🔴 CRITIQUE"
-        color = "red"
-    
+    if global_score >= 95: status, color = "🟢 EXCELLENT", "green"
+    elif global_score >= 85: status, color = "🟡 BON", "blue"
+    elif global_score >= 70: status, color = "🟠 MOYEN", "orange"
+    else: status, color = "🔴 CRITIQUE", "red"
     col3.markdown(f"**Score Global**")
     col3.markdown(f"<h2 style='color: {color};'>{global_score:.2f}%</h2>", unsafe_allow_html=True)
-    
     st.markdown(f"### {status}")
     st.progress(global_score / 100)
     
-    # Recommandations
     st.markdown("#### 💡 Recommandations")
-    
     recommendations = []
-    
-    if metrics['patients']['anomalies'] > 0:
-        recommendations.append(f"⚠️ **{metrics['patients']['anomalies']} anomalies patients** détectées - Vérifier les données de naissance et villes manquantes")
-    
-    if metrics['sejours']['dates_inversees'] > 0:
-        recommendations.append(f"🔴 **{metrics['sejours']['dates_inversees']} séjours avec dates inversées** - Corriger les dates d'entrée/sortie")
-    
-    if metrics['ressources']['suroccupation'] > 0:
-        recommendations.append(f"🚨 **{metrics['ressources']['suroccupation']} cas de suroccupation** - Revoir la capacité des services")
-    
-    if metrics['stock']['alertes'] > 0:
-        recommendations.append(f"📦 **{metrics['stock']['alertes']} alertes stock** - Réapprovisionner les matériels critiques")
-    
-    if global_score < 85:
-        recommendations.append("📊 **Score global < 85%** - Lancer un plan d'action Data Quality urgent")
+    if metrics['patients']['anomalies'] > 0: recommendations.append(f"⚠️ **{metrics['patients']['anomalies']} anomalies patients** détectées")
+    if metrics['sejours']['dates_inversees'] > 0: recommendations.append(f"🔴 **{metrics['sejours']['dates_inversees']} séjours avec dates inversées**")
+    if metrics['ressources']['suroccupation'] > 0: recommendations.append(f"🚨 **{metrics['ressources']['suroccupation']} cas de suroccupation**")
+    if metrics['stock']['alertes'] > 0: recommendations.append(f"📦 **{metrics['stock']['alertes']} alertes stock**")
+    if global_score < 85: recommendations.append("📊 **Score global < 85%** - Plan Data Quality requis")
     
     if recommendations:
-        for rec in recommendations:
-            st.markdown(rec)
-    else:
-        st.success("✅ Aucune action critique nécessaire - Qualité des données satisfaisante")
-    
+        for rec in recommendations: st.markdown(rec)
+    else: st.success("✅ Qualité des données satisfaisante")
     st.divider()
     
     # ==================================================
     # ========== 6️⃣ EXPORT DES RÉSULTATS ==============
     # ==================================================
     st.subheader("6️⃣ Export et Documentation")
-    
-    # Création du rapport
-    report_data = {
-        'Métrique': [],
-        'Valeur': []
-    }
-    
+    report_data = {'Métrique': [], 'Valeur': []}
     for category, cat_metrics in analyzer.metrics.items():
         for metric_name, value in cat_metrics.items():
             report_data['Métrique'].append(f"{category}_{metric_name}")
             report_data['Valeur'].append(value)
-    
-    # Ajout scores
     report_data['Métrique'].extend(['score_completeness', 'score_accuracy', 'score_global'])
     report_data['Valeur'].extend([scores['completeness'], scores['accuracy'], scores['global']])
-    
     report_df = pd.DataFrame(report_data)
     
     col1, col2 = st.columns(2)
-    
     with col1:
         csv = report_df.to_csv(index=False).encode('utf-8')
-        st.download_button(
-            label="📥 Télécharger Rapport DQ (CSV)",
-            data=csv,
-            file_name=f'data_quality_report_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv',
-            mime='text/csv'
-        )
-    
+        st.download_button(label="📥 Télécharger Rapport DQ (CSV)", data=csv, file_name=f'dq_report_{datetime.now().strftime("%Y%m%d")}.csv', mime='text/csv')
     with col2:
-        # Export des anomalies détectées
         if metrics['patients']['anomalies'] > 0 and analyzer.df_pat is not None:
-            anomalies_df = analyzer.df_pat[analyzer.df_pat['dq_is_anomaly'] == 1][
-                ['patient_id', 'nom', 'prenom', 'dq_anomaly_type', 'dq_anomaly_detail']
-            ]
+            anomalies_df = analyzer.df_pat[analyzer.df_pat['dq_is_anomaly'] == 1][['patient_id', 'nom', 'prenom', 'dq_anomaly_type']]
             anomalies_csv = anomalies_df.to_csv(index=False).encode('utf-8')
-            st.download_button(
-                label="📥 Télécharger Anomalies Patients (CSV)",
-                data=anomalies_csv,
-                file_name=f'anomalies_patients_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv',
-                mime='text/csv'
-            )
-
+            st.download_button(label="📥 Télécharger Anomalies Patients (CSV)", data=anomalies_csv, file_name=f'anomalies_pat_{datetime.now().strftime("%Y%m%d")}.csv', mime='text/csv')
 
-# Point d'entrée
 if __name__ == "__main__":
     show_dq_dashboard()