Update src/module/Indicateurs_DQ.py

src/module/Indicateurs_DQ.py

@@ -10,6 +10,24 @@ import plotly.express as px
 import plotly.graph_objects as go
 from Function.Validation_Contract import ETL_Engine
 
+def safe_int(value):
+    """Convertit une valeur en int de manière sûre"""
+    try:
+        if pd.isna(value):
+            return 0
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+def safe_float(value):
+    """Convertit une valeur en float de manière sûre"""
+    try:
+        if pd.isna(value):
+            return 0.0
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
+
 def show_dq_dashboard(client, sheet_name):
     st.markdown("## 🛡️ CENTRE DE CONTRÔLE DATA QUALITY")
     
@@ -38,49 +56,59 @@ def show_dq_dashboard(client, sheet_name):
     st.markdown("### 📊 Synthèse de Santé des Données")
     col1, col2, col3, col4 = st.columns(4)
     
-    # Calcul des indicateurs
-    if df_pat is not None:
-        anomalies_patients = df_pat['dq_is_anomaly'].sum()
-        doublons = df_pat.duplicated(subset=['nom', 'prenom']).sum()
-        ages_negatifs = (df_pat['age'] < 0).sum()
-        ages_aberrants = (df_pat['age'] > 120).sum()
-        missing_birth = df_pat['date_naissance'].isnull().sum()
-        missing_ville = df_pat['ville'].isnull().sum()
+    # Calcul des indicateurs avec conversion sécurisée
+    if df_pat is not None and len(df_pat) > 0:
+        anomalies_patients = safe_int(df_pat['dq_is_anomaly'].sum())
+        doublons = safe_int(df_pat.duplicated(subset=['nom', 'prenom']).sum())
+        ages_negatifs = safe_int((df_pat['age'] < 0).sum())
+        ages_aberrants = safe_int((df_pat['age'] > 120).sum())
+        missing_birth = safe_int(df_pat['date_naissance'].isnull().sum())
+        missing_ville = safe_int(df_pat['ville'].isnull().sum())
+        total_patients = len(df_pat)
     else:
-        anomalies_patients = doublons = ages_negatifs = ages_aberrants = missing_birth = missing_ville = 0
+        anomalies_patients = doublons = ages_negatifs = ages_aberrants = missing_birth = missing_ville = total_patients = 0
     
-    if df_sej is not None:
-        anomalies_sejours = df_sej['dq_is_anomaly'].sum()
-        dates_inversees = (df_sej['date_sortie'] < df_sej['date_entree']).sum()
-        gravite_aberrante = ((df_sej['gravite_1_5'] > 5) | (df_sej['gravite_1_5'] < 1)).sum()
-        equipement_manquant = df_sej['equipement_principal_code'].isnull().sum()
+    if df_sej is not None and len(df_sej) > 0:
+        anomalies_sejours = safe_int(df_sej['dq_is_anomaly'].sum())
+        dates_inversees = safe_int((df_sej['date_sortie'] < df_sej['date_entree']).sum())
+        gravite_aberrante = safe_int(((df_sej['gravite_1_5'] > 5) | (df_sej['gravite_1_5'] < 1)).sum())
+        equipement_manquant = safe_int(df_sej['equipement_principal_code'].isnull().sum())
+        total_sejours = len(df_sej)
     else:
-        anomalies_sejours = dates_inversees = gravite_aberrante = equipement_manquant = 0
+        anomalies_sejours = dates_inversees = gravite_aberrante = equipement_manquant = total_sejours = 0
     
-    if df_res is not None:
-        anomalies_ressources = df_res['dq_is_anomaly'].sum()
+    if df_res is not None and len(df_res) > 0:
+        anomalies_ressources = safe_int(df_res['dq_is_anomaly'].sum())
         # Conversion de lits_occupes en numérique (peut être string)
         df_res['lits_occupes_num'] = pd.to_numeric(df_res['lits_occupes'], errors='coerce')
-        suroccupation = (df_res['lits_occupes_num'] > df_res['lits_total']).sum()
+        suroccupation = safe_int((df_res['lits_occupes_num'] > df_res['lits_total']).sum())
+        total_ressources = len(df_res)
     else:
-        anomalies_ressources = suroccupation = 0
+        anomalies_ressources = suroccupation = total_ressources = 0
     
-    if df_stock is not None:
-        anomalies_stock = df_stock['dq_is_anomaly'].sum()
+    if df_stock is not None and len(df_stock) > 0:
+        anomalies_stock = safe_int(df_stock['dq_is_anomaly'].sum())
+        total_stock = len(df_stock)
     else:
-        anomalies_stock = 0
+        anomalies_stock = total_stock = 0
+    
+    # Calcul des pourcentages
+    pct_anom_pat = (anomalies_patients / total_patients * 100) if total_patients > 0 else 0
+    pct_anom_sej = (anomalies_sejours / total_sejours * 100) if total_sejours > 0 else 0
+    pct_anom_res = (anomalies_ressources / total_ressources * 100) if total_ressources > 0 else 0
+    pct_anom_stock = (anomalies_stock / total_stock * 100) if total_stock > 0 else 0
     
     col1.metric("🔴 Anomalies Patients", f"{anomalies_patients:,}", 
-                delta=f"{(anomalies_patients/len(df_pat)*100):.1f}%" if df_pat is not None and len(df_pat) > 0 else "N/A", 
+                delta=f"{pct_anom_pat:.1f}%", 
                 delta_color="inverse")
     col2.metric("🔴 Anomalies Séjours", f"{anomalies_sejours:,}", 
-                delta=f"{(anomalies_sejours/len(df_sej)*100):.1f}%" if df_sej is not None and len(df_sej) > 0 else "N/A",
+                delta=f"{pct_anom_sej:.1f}%",
                 delta_color="inverse")
     col3.metric("🔴 Anomalies Ressources", f"{anomalies_ressources:,}",
-                delta=f"{(anomalies_ressources/len(df_res)*100):.2f}%" if df_res is not None and len(df_res) > 0 else "N/A",
+                delta=f"{pct_anom_res:.2f}%",
                 delta_color="inverse")
     col4.metric("🔴 Anomalies Stock", f"{anomalies_stock:,}",
-                delta=f"{(anomalies_stock/len(df_stock)*100):.2f}%" if df_stock is not None and len(df_stock) > 0 else "N/A",
+                delta=f"{pct_anom_stock:.2f}%",
                 delta_color="inverse")
 
     st.divider()
@@ -91,7 +119,7 @@ def show_dq_dashboard(client, sheet_name):
     tab1, tab2, tab3, tab4 = st.tabs(["📋 Patients", "🏥 Séjours", "⚕️ Ressources", "📦 Stock"])
     
     with tab1:
-        if df_pat is not None:
+        if df_pat is not None and len(df_pat) > 0:
             st.markdown("##### Analyse de complétude - Table PATIENTS")
             col_a, col_b = st.columns(2)
             
@@ -102,14 +130,17 @@ def show_dq_dashboard(client, sheet_name):
                 missing_df.columns = ['Colonne', 'Pourcentage Manquant']
                 missing_df = missing_df.sort_values('Pourcentage Manquant', ascending=False)
                 
-                fig_miss = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant', 
-                                  title="Données manquantes - Patients",
-                                  color='Pourcentage Manquant', 
-                                  color_continuous_scale='Reds',
-                                  text='Pourcentage Manquant')
-                fig_miss.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-                fig_miss.update_layout(xaxis_tickangle=-45)
-                st.plotly_chart(fig_miss, use_container_width=True)
+                if len(missing_df) > 0:
+                    fig_miss = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant', 
+                                      title="Données manquantes - Patients",
+                                      color='Pourcentage Manquant', 
+                                      color_continuous_scale='Reds',
+                                      text='Pourcentage Manquant')
+                    fig_miss.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+                    fig_miss.update_layout(xaxis_tickangle=-45)
+                    st.plotly_chart(fig_miss, use_container_width=True)
+                else:
+                    st.success("✅ Aucune donnée manquante détectée")
             
             with col_b:
                 st.markdown("**Métriques clés :**")
@@ -119,9 +150,11 @@ def show_dq_dashboard(client, sheet_name):
                 
                 if missing_birth > 0 or missing_ville > 0:
                     st.warning(f"⚠️ {missing_birth + missing_ville:,} valeurs critiques manquantes")
+        else:
+            st.warning("Aucune donnée patient disponible")
     
     with tab2:
-        if df_sej is not None:
+        if df_sej is not None and len(df_sej) > 0:
             st.markdown("##### Analyse de complétude - Table SEJOURS")
             missing_sej = df_sej.isnull().mean() * 100
             missing_sej = missing_sej[missing_sej > 0].reset_index()
@@ -139,12 +172,14 @@ def show_dq_dashboard(client, sheet_name):
                 st.plotly_chart(fig_miss_sej, use_container_width=True)
                 
                 st.metric("Équipements principaux manquants", f"{equipement_manquant:,}",
-                         delta=f"{(equipement_manquant/len(df_sej)*100):.1f}%")
+                         delta=f"{(equipement_manquant/total_sejours*100):.1f}%" if total_sejours > 0 else "N/A")
             else:
                 st.success("✅ Aucune donnée manquante dans les colonnes critiques")
+        else:
+            st.warning("Aucune donnée séjour disponible")
     
     with tab3:
-        if df_res is not None:
+        if df_res is not None and len(df_res) > 0:
             st.markdown("##### Analyse de complétude - Table RESSOURCES_JOUR")
             missing_res = df_res.isnull().mean() * 100
             missing_res = missing_res[missing_res > 0].reset_index()
@@ -161,9 +196,11 @@ def show_dq_dashboard(client, sheet_name):
                 st.plotly_chart(fig_miss_res, use_container_width=True)
             else:
                 st.success("✅ Aucune donnée manquante détectée")
+        else:
+            st.warning("Aucune donnée ressource disponible")
     
     with tab4:
-        if df_stock is not None:
+        if df_stock is not None and len(df_stock) > 0:
             st.markdown("##### Analyse de complétude - Table STOCK_MATERIEL_JOUR")
             missing_stock = df_stock.isnull().mean() * 100
             missing_stock = missing_stock[missing_stock > 0].reset_index()
@@ -173,6 +210,8 @@ def show_dq_dashboard(client, sheet_name):
                 st.dataframe(missing_stock, use_container_width=True)
             else:
                 st.success("✅ Aucune donnée manquante dans le stock")
+        else:
+            st.warning("Aucune donnée stock disponible")
 
     st.divider()
 
@@ -182,7 +221,7 @@ def show_dq_dashboard(client, sheet_name):
     tab_acc1, tab_acc2, tab_acc3 = st.tabs(["👤 Patients", "🏥 Séjours", "🛏️ Ressources"])
     
     with tab_acc1:
-        if df_pat is not None:
+        if df_pat is not None and len(df_pat) > 0:
             st.markdown("##### Détection d'outliers - PATIENTS")
             c1, c2 = st.columns(2)
             
@@ -191,14 +230,20 @@ def show_dq_dashboard(client, sheet_name):
                 fig_age = px.box(df_pat, y='age', 
                                  title="Distribution des Âges (Détection Outliers)",
                                  points="outliers")
-                fig_age.add_hrect(y0=120, y1=df_pat['age'].max() + 10, 
-                                  fillcolor="red", opacity=0.2, 
-                                  annotation_text="🚨 Âge > 120 ans", 
-                                  annotation_position="top left")
-                fig_age.add_hrect(y0=df_pat['age'].min() - 10, y1=0, 
-                                  fillcolor="red", opacity=0.2, 
-                                  annotation_text="🚨 Âge négatif",
-                                  annotation_position="bottom left")
+                
+                age_max = safe_float(df_pat['age'].max())
+                age_min = safe_float(df_pat['age'].min())
+                
+                if age_max > 120:
+                    fig_age.add_hrect(y0=120, y1=age_max + 10, 
+                                      fillcolor="red", opacity=0.2, 
+                                      annotation_text="🚨 Âge > 120 ans", 
+                                      annotation_position="top left")
+                if age_min < 0:
+                    fig_age.add_hrect(y0=age_min - 10, y1=0, 
+                                      fillcolor="red", opacity=0.2, 
+                                      annotation_text="🚨 Âge négatif",
+                                      annotation_position="bottom left")
                 fig_age.update_layout(height=400)
                 st.plotly_chart(fig_age, use_container_width=True)
                 
@@ -210,29 +255,32 @@ def show_dq_dashboard(client, sheet_name):
                 if 'dq_anomaly_type' in df_pat.columns:
                     anomalies_by_type = df_pat[df_pat['dq_is_anomaly'] == 1]['dq_anomaly_type'].value_counts()
                     
-                    fig_anom = px.pie(values=anomalies_by_type.values, 
-                                      names=anomalies_by_type.index,
-                                      title="Répartition des Types d'Anomalies Patients",
-                                      color_discrete_sequence=px.colors.sequential.Reds_r)
-                    fig_anom.update_traces(textposition='inside', textinfo='percent+label')
-                    st.plotly_chart(fig_anom, use_container_width=True)
-                    
-                    # Affichage des détails
-                    st.markdown("**Détail par type :**")
-                    for anom_type, count in anomalies_by_type.items():
-                        st.write(f"- **{anom_type}** : {count:,} cas")
+                    if len(anomalies_by_type) > 0:
+                        fig_anom = px.pie(values=anomalies_by_type.values, 
+                                          names=anomalies_by_type.index,
+                                          title="Répartition des Types d'Anomalies Patients",
+                                          color_discrete_sequence=px.colors.sequential.Reds_r)
+                        fig_anom.update_traces(textposition='inside', textinfo='percent+label')
+                        st.plotly_chart(fig_anom, use_container_width=True)
+                        
+                        # Affichage des détails
+                        st.markdown("**Détail par type :**")
+                        for anom_type, count in anomalies_by_type.items():
+                            st.write(f"- **{anom_type}** : {safe_int(count):,} cas")
             
             # Top 10 des anomalies les plus critiques
-            if df_pat['dq_is_anomaly'].sum() > 0:
+            if anomalies_patients > 0:
                 st.markdown("##### 🔍 Top 10 Anomalies Patients")
                 anomalies_patients_df = df_pat[df_pat['dq_is_anomaly'] == 1][
                     ['patient_id', 'nom', 'prenom', 'age', 'date_naissance', 'ville', 
                      'dq_anomaly_type', 'dq_anomaly_detail']
                 ].head(10)
                 st.dataframe(anomalies_patients_df, use_container_width=True)
+        else:
+            st.warning("Aucune donnée patient disponible")
     
     with tab_acc2:
-        if df_sej is not None:
+        if df_sej is not None and len(df_sej) > 0:
             st.markdown("##### Détection d'anomalies - SEJOURS")
             c1, c2 = st.columns(2)
             
@@ -242,41 +290,48 @@ def show_dq_dashboard(client, sheet_name):
                                         title="Distribution Gravité (Échelle 1-5)",
                                         nbins=15,
                                         color_discrete_sequence=['#1f77b4'])
+                
+                grav_max = safe_float(df_sej['gravite_1_5'].max())
+                
                 fig_grav.add_vrect(x0=-0.5, x1=0.5, fillcolor="red", opacity=0.2,
                                    annotation_text="Hors norme", annotation_position="top left")
-                fig_grav.add_vrect(x0=5.5, x1=df_sej['gravite_1_5'].max() + 1, 
-                                   fillcolor="red", opacity=0.2,
-                                   annotation_text="Hors norme", annotation_position="top right")
+                if grav_max > 5:
+                    fig_grav.add_vrect(x0=5.5, x1=grav_max + 1, 
+                                       fillcolor="red", opacity=0.2,
+                                       annotation_text="Hors norme", annotation_position="top right")
                 st.plotly_chart(fig_grav, use_container_width=True)
                 
-                st.metric("Gravité < 1", (df_sej['gravite_1_5'] < 1).sum())
-                st.metric("Gravité > 5", (df_sej['gravite_1_5'] > 5).sum())
+                st.metric("Gravité < 1", safe_int((df_sej['gravite_1_5'] < 1).sum()))
+                st.metric("Gravité > 5", safe_int((df_sej['gravite_1_5'] > 5).sum()))
             
             with c2:
                 # Types d'anomalies séjours
                 if 'dq_anomaly_type' in df_sej.columns:
                     anomalies_sej = df_sej[df_sej['dq_is_anomaly'] == 1]['dq_anomaly_type'].value_counts()
                     
-                    fig_anom_sej = px.bar(x=anomalies_sej.index, y=anomalies_sej.values,
-                                          title="Types d'Anomalies Séjours",
-                                          color=anomalies_sej.values,
-                                          color_continuous_scale='Reds',
-                                          text=anomalies_sej.values)
-                    fig_anom_sej.update_traces(texttemplate='%{text}', textposition='outside')
-                    fig_anom_sej.update_layout(showlegend=False, xaxis_title="Type", yaxis_title="Nombre")
-                    st.plotly_chart(fig_anom_sej, use_container_width=True)
+                    if len(anomalies_sej) > 0:
+                        fig_anom_sej = px.bar(x=anomalies_sej.index, y=anomalies_sej.values,
+                                              title="Types d'Anomalies Séjours",
+                                              color=anomalies_sej.values,
+                                              color_continuous_scale='Reds',
+                                              text=anomalies_sej.values)
+                        fig_anom_sej.update_traces(texttemplate='%{text}', textposition='outside')
+                        fig_anom_sej.update_layout(showlegend=False, xaxis_title="Type", yaxis_title="Nombre")
+                        st.plotly_chart(fig_anom_sej, use_container_width=True)
             
             # Anomalies critiques
-            if df_sej['dq_is_anomaly'].sum() > 0:
+            if anomalies_sejours > 0:
                 st.markdown("##### 🔍 Top 10 Anomalies Séjours")
                 anomalies_sejours_df = df_sej[df_sej['dq_is_anomaly'] == 1][
                     ['stay_id', 'patient_id', 'date_entree', 'date_sortie', 'duree_sejour_jours',
                      'gravite_1_5', 'dq_anomaly_type', 'dq_anomaly_detail']
                 ].head(10)
                 st.dataframe(anomalies_sejours_df, use_container_width=True)
+        else:
+            st.warning("Aucune donnée séjour disponible")
     
     with tab_acc3:
-        if df_res is not None:
+        if df_res is not None and len(df_res) > 0:
             st.markdown("##### Détection d'anomalies - RESSOURCES")
             c1, c2 = st.columns(2)
             
@@ -303,18 +358,20 @@ def show_dq_dashboard(client, sheet_name):
                     st.success("✅ Aucune suroccupation détectée")
                 
                 # Types d'anomalies ressources
-                if 'dq_anomaly_type' in df_res.columns and df_res['dq_is_anomaly'].sum() > 0:
+                if 'dq_anomaly_type' in df_res.columns and anomalies_ressources > 0:
                     st.markdown("**Types d'anomalies ressources :**")
                     anom_res = df_res[df_res['dq_is_anomaly'] == 1]['dq_anomaly_type'].value_counts()
                     for anom_type, count in anom_res.items():
-                        st.write(f"- **{anom_type}** : {count} cas")
+                        st.write(f"- **{anom_type}** : {safe_int(count)} cas")
+        else:
+            st.warning("Aucune donnée ressource disponible")
 
     st.divider()
 
     # --- SECTION 3 : CONSISTENCY (Cohérence Temporelle) ---
     st.subheader("3️⃣ Cohérence Temporelle & Intégrité Référentielle")
     
-    if df_sej is not None:
+    if df_sej is not None and len(df_sej) > 0:
         st.markdown("##### Incohérences Temporelles - SEJOURS")
         
         if dates_inversees > 0:
@@ -339,6 +396,8 @@ def show_dq_dashboard(client, sheet_name):
             st.plotly_chart(fig_inv, use_container_width=True)
         else:
             st.success("✅ Aucune incohérence temporelle détectée dans les séjours.")
+    else:
+        st.warning("Aucune donnée séjour disponible pour l'analyse de cohérence")
     
     # --- SECTION 4 : RESUME GLOBAL ---
     st.divider()
@@ -349,15 +408,17 @@ def show_dq_dashboard(client, sheet_name):
     with col_resume1:
         st.markdown("##### 🎯 Complétude")
         total_missing = 0
-        if df_pat is not None:
-            total_missing += df_pat.isnull().sum().sum()
-        if df_sej is not None:
-            total_missing += df_sej.isnull().sum().sum()
-        if df_res is not None:
-            total_missing += df_res.isnull().sum().sum()
+        if df_pat is not None and len(df_pat) > 0:
+            total_missing += safe_int(df_pat.isnull().sum().sum())
+        if df_sej is not None and len(df_sej) > 0:
+            total_missing += safe_int(df_sej.isnull().sum().sum())
+        if df_res is not None and len(df_res) > 0:
+            total_missing += safe_int(df_res.isnull().sum().sum())
         
         st.metric("Total valeurs manquantes", f"{total_missing:,}")
-        completeness_score = 100 - (total_missing / (len(df_pat) + len(df_sej) + len(df_res)) * 100) if all([df_pat is not None, df_sej is not None, df_res is not None]) else 0
+        
+        total_rows = total_patients + total_sejours + total_ressources
+        completeness_score = 100 - (total_missing / total_rows * 100) if total_rows > 0 else 0
         st.metric("Score de complétude", f"{completeness_score:.1f}%")
     
     with col_resume2:
@@ -365,7 +426,8 @@ def show_dq_dashboard(client, sheet_name):
         total_anomalies = anomalies_patients + anomalies_sejours + anomalies_ressources + anomalies_stock
         st.metric("Total anomalies détectées", f"{total_anomalies:,}")
         
-        accuracy_score = 100 - (total_anomalies / (len(df_pat) + len(df_sej) + len(df_res) + len(df_stock)) * 100) if all([df_pat is not None, df_sej is not None, df_res is not None, df_stock is not None]) else 0
+        total_all_rows = total_patients + total_sejours + total_ressources + total_stock
+        accuracy_score = 100 - (total_anomalies / total_all_rows * 100) if total_all_rows > 0 else 0
         st.metric("Score d'exactitude", f"{accuracy_score:.2f}%")
     
     with col_resume3: