Update src/module/Indicateurs_DQ.py

src/module/Indicateurs_DQ.py

@@ -13,7 +13,7 @@ from Function.Validation_Contract import ETL_Engine
 def show_dq_dashboard(client, sheet_name):
     st.markdown("## 🛡️ CENTRE DE CONTRÔLE DATA QUALITY")
     
-    # On charge via l'ETL mais on va surtout analyser les NaN et les outliers
+    # On charge via l'ETL
     etl = ETL_Engine(client, sheet_name)
     
     # On vérifie si les données sont déjà en session, sinon on charge
@@ -21,8 +21,6 @@ def show_dq_dashboard(client, sheet_name):
         st.info("Chargement des données pour Audit...")
         success, data = etl.run_etl()
         if success:
-            # Astuce: on stocke quand même dans le session_state global pour partager
-            # Mais ici on s'en sert pour la DQ
             pass
         else:
             st.error(f"Erreur chargement : {data}")
@@ -30,67 +28,372 @@ def show_dq_dashboard(client, sheet_name):
     else:
         data = st.session_state.data_explorer.dataframes
 
+    # Récupération des DataFrames
+    df_pat = data.get('patients')
+    df_sej = data.get('sejours')
+    df_res = data.get('ressources_jour')
+    df_stock = data.get('stock_materiel_jour')
+    
     # --- KPI GLOBAL ---
     st.markdown("### 📊 Synthèse de Santé des Données")
     col1, col2, col3, col4 = st.columns(4)
     
-    df_pat = data.get('patients')
-    df_sej = data.get('sejours')
-    df_res = data.get('ressources')
-    
-    # Calcul des indicateurs inspirés du notebook
-    missing_birth = df_pat['date_naissance'].isnull().sum() if df_pat is not None else 0
-    inverted_dates = df_sej[df_sej['date_sortie'] < df_sej['date_entree']].shape[0] if df_sej is not None else 0
-    capa_overflow = df_res[df_res['lits_occupes'] > df_res['lits_total']].shape[0] if df_res is not None else 0
-    duplicates = df_pat.duplicated(subset=['nom', 'prenom']).sum() if df_pat is not None else 0
-    
-    col1.metric("Doublons Patients", duplicates, delta=None, delta_color="inverse")
-    col2.metric("Dates Inversées (Séjours)", inverted_dates, delta="Bloquant", delta_color="inverse")
-    col3.metric("Violations Capacité", capa_overflow, delta="Critique", delta_color="inverse")
-    col4.metric("Dates Naissance Manquantes", missing_birth, delta="Qualité", delta_color="inverse")
+    # 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()
+    else:
+        anomalies_patients = doublons = ages_negatifs = ages_aberrants = missing_birth = missing_ville = 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()
+    else:
+        anomalies_sejours = dates_inversees = gravite_aberrante = equipement_manquant = 0
+    
+    if df_res is not None:
+        anomalies_ressources = 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()
+    else:
+        anomalies_ressources = suroccupation = 0
+    
+    if df_stock is not None:
+        anomalies_stock = df_stock['dq_is_anomaly'].sum()
+    else:
+        anomalies_stock = 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_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_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_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_color="inverse")
 
     st.divider()
 
     # --- SECTION 1 : COMPLETENESS (Remplissage) ---
-    st.subheader("1. Complétude des Données (Missing Values)")
-    if df_pat is not None:
-        # Calcul du taux de remplissage par colonne
-        missing_df = df_pat.isnull().mean() * 100
-        missing_df = missing_df[missing_df > 0].reset_index()
-        missing_df.columns = ['Colonne', 'Pourcentage Manquant']
-        
-        fig_miss = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant', 
-                          title="Données manquantes - Table Patients",
-                          color='Pourcentage Manquant', color_continuous_scale='Reds')
-        st.plotly_chart(fig_miss, use_container_width=True)
+    st.subheader("1️⃣ Complétude des Données (Missing Values)")
+    
+    tab1, tab2, tab3, tab4 = st.tabs(["📋 Patients", "🏥 Séjours", "⚕️ Ressources", "📦 Stock"])
+    
+    with tab1:
+        if df_pat is not None:
+            st.markdown("##### Analyse de complétude - Table PATIENTS")
+            col_a, col_b = st.columns(2)
+            
+            with col_a:
+                # Taux de remplissage par colonne
+                missing_df = df_pat.isnull().mean() * 100
+                missing_df = missing_df[missing_df > 0].reset_index()
+                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)
+            
+            with col_b:
+                st.markdown("**Métriques clés :**")
+                st.metric("Dates de naissance manquantes", f"{missing_birth:,}")
+                st.metric("Villes manquantes", f"{missing_ville:,}")
+                st.metric("Doublons nom+prénom", f"{doublons:,}", delta="⚠️ Risque identité")
+                
+                if missing_birth > 0 or missing_ville > 0:
+                    st.warning(f"⚠️ {missing_birth + missing_ville:,} valeurs critiques manquantes")
+    
+    with tab2:
+        if df_sej is not None:
+            st.markdown("##### Analyse de complétude - Table SEJOURS")
+            missing_sej = df_sej.isnull().mean() * 100
+            missing_sej = missing_sej[missing_sej > 0].reset_index()
+            missing_sej.columns = ['Colonne', 'Pourcentage Manquant']
+            missing_sej = missing_sej.sort_values('Pourcentage Manquant', ascending=False)
+            
+            if len(missing_sej) > 0:
+                fig_miss_sej = px.bar(missing_sej, x='Colonne', y='Pourcentage Manquant',
+                                      title="Données manquantes - Séjours",
+                                      color='Pourcentage Manquant',
+                                      color_continuous_scale='Oranges',
+                                      text='Pourcentage Manquant')
+                fig_miss_sej.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+                fig_miss_sej.update_layout(xaxis_tickangle=-45)
+                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}%")
+            else:
+                st.success("✅ Aucune donnée manquante dans les colonnes critiques")
+    
+    with tab3:
+        if df_res is not None:
+            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()
+            missing_res.columns = ['Colonne', 'Pourcentage Manquant']
+            
+            if len(missing_res) > 0:
+                fig_miss_res = px.bar(missing_res, x='Colonne', y='Pourcentage Manquant',
+                                      title="Données manquantes - Ressources",
+                                      color='Pourcentage Manquant',
+                                      color_continuous_scale='Blues',
+                                      text='Pourcentage Manquant')
+                fig_miss_res.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+                fig_miss_res.update_layout(xaxis_tickangle=-45)
+                st.plotly_chart(fig_miss_res, use_container_width=True)
+            else:
+                st.success("✅ Aucune donnée manquante détectée")
+    
+    with tab4:
+        if df_stock is not None:
+            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()
+            missing_stock.columns = ['Colonne', 'Pourcentage Manquant']
+            
+            if len(missing_stock) > 0:
+                st.dataframe(missing_stock, use_container_width=True)
+            else:
+                st.success("✅ Aucune donnée manquante dans le stock")
+
+    st.divider()
 
-    # --- SECTION 2 : ACCURACY (Outliers) ---
-    st.subheader("2. Exactitude & Valeurs Aberrantes")
-    c1, c2 = st.columns(2)
+    # --- SECTION 2 : ACCURACY (Outliers & Anomalies) ---
+    st.subheader("2️⃣ Exactitude & Valeurs Aberrantes")
+    
+    tab_acc1, tab_acc2, tab_acc3 = st.tabs(["👤 Patients", "🏥 Séjours", "🛏️ Ressources"])
     
-    with c1:
+    with tab_acc1:
         if df_pat is not None:
-            # Visualisation des âges > 100 ans ou < 0
-            fig_age = px.box(df_pat, y='age', title="Distribution des Âges (Détection Outliers)",
-                             points="all") # Affiche tous les points
-            # Zone rouge pour les âges impossibles
-            fig_age.add_hrect(y0=120, y1=200, fillcolor="red", opacity=0.1, annotation_text="Erreur > 120 ans")
-            fig_age.add_hrect(y0=-10, y1=0, fillcolor="red", opacity=0.1, annotation_text="Négatif")
-            st.plotly_chart(fig_age, use_container_width=True)
-            
-    with c2:
+            st.markdown("##### Détection d'outliers - PATIENTS")
+            c1, c2 = st.columns(2)
+            
+            with c1:
+                # Distribution des âges avec zones d'alerte
+                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")
+                fig_age.update_layout(height=400)
+                st.plotly_chart(fig_age, use_container_width=True)
+                
+                st.metric("Âges négatifs", ages_negatifs, delta="🚨 Critique" if ages_negatifs > 0 else "✅")
+                st.metric("Âges > 120 ans", ages_aberrants, delta="🚨 Impossible" if ages_aberrants > 0 else "✅")
+            
+            with c2:
+                # Répartition des types d'anomalies
+                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")
+            
+            # Top 10 des anomalies les plus critiques
+            if df_pat['dq_is_anomaly'].sum() > 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)
+    
+    with tab_acc2:
+        if df_sej is not None:
+            st.markdown("##### Détection d'anomalies - SEJOURS")
+            c1, c2 = st.columns(2)
+            
+            with c1:
+                # Distribution de la gravité
+                fig_grav = px.histogram(df_sej, x='gravite_1_5',
+                                        title="Distribution Gravité (Échelle 1-5)",
+                                        nbins=15,
+                                        color_discrete_sequence=['#1f77b4'])
+                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")
+                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())
+            
+            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)
+            
+            # Anomalies critiques
+            if df_sej['dq_is_anomaly'].sum() > 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)
+    
+    with tab_acc3:
         if df_res is not None:
-            # Visualisation Occupation > 100%
-            df_res['taux_pct'] = df_res['taux_occupation'] * 100
-            fig_capa = px.scatter(df_res, x='date', y='taux_pct', color='service_code',
-                                  title="Anomalies de Capacité (>100%)")
-            fig_capa.add_hline(y=100, line_dash="dash", line_color="red", annotation_text="Saturation Théorique")
-            st.plotly_chart(fig_capa, use_container_width=True)
+            st.markdown("##### Détection d'anomalies - RESSOURCES")
+            c1, c2 = st.columns(2)
+            
+            with c1:
+                # Taux d'occupation dans le temps
+                fig_tx = px.scatter(df_res, x='date', y='taux_occupation',
+                                    color='service_code',
+                                    title="Taux d'Occupation par Service",
+                                    opacity=0.6)
+                fig_tx.add_hline(y=1.0, line_dash="dash", line_color="red",
+                                 annotation_text="⚠️ Saturation 100%",
+                                 annotation_position="right")
+                st.plotly_chart(fig_tx, use_container_width=True)
+            
+            with c2:
+                # Cas de suroccupation
+                if suroccupation > 0:
+                    st.error(f"🚨 {suroccupation} cas de SUROCCUPATION détectés !")
+                    suroccup_df = df_res[df_res['lits_occupes_num'] > df_res['lits_total']][
+                        ['date', 'service_code', 'lits_total', 'lits_occupes', 'taux_occupation']
+                    ].head(10)
+                    st.dataframe(suroccup_df, use_container_width=True)
+                else:
+                    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:
+                    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")
 
-    # --- SECTION 3 : CONSISTENCY (Intégrité) ---
-    st.subheader("3. Cohérence Temporelle")
-    if inverted_dates > 0:
-        st.error(f"🚨 ALERT : {inverted_dates} séjours ont une date de sortie antérieure à la date d'entrée.")
-        st.dataframe(df_sej[df_sej['date_sortie'] < df_sej['date_entree']].head(10), use_container_width=True)
+    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:
+        st.markdown("##### Incohérences Temporelles - SEJOURS")
+        
+        if dates_inversees > 0:
+            st.error(f"🚨 ALERTE CRITIQUE : {dates_inversees} séjours ont une date de sortie antérieure à la date d'entrée !")
+            
+            # Affichage des cas problématiques
+            inversions = df_sej[df_sej['date_sortie'] < df_sej['date_entree']][
+                ['stay_id', 'patient_id', 'service_code', 'date_entree', 'date_sortie', 'duree_sejour_jours']
+            ].head(20)
+            
+            st.dataframe(inversions, use_container_width=True)
+            
+            # Visualisation
+            inversions_temp = df_sej[df_sej['date_sortie'] < df_sej['date_entree']].copy()
+            inversions_temp['delta_jours'] = (inversions_temp['date_sortie'] - inversions_temp['date_entree']).dt.days
+            
+            fig_inv = px.histogram(inversions_temp, x='delta_jours',
+                                   title="Distribution des Écarts Temporels (Dates Inversées)",
+                                   nbins=20,
+                                   color_discrete_sequence=['red'])
+            fig_inv.update_layout(xaxis_title="Écart en jours (négatif)", yaxis_title="Nombre de cas")
+            st.plotly_chart(fig_inv, use_container_width=True)
+        else:
+            st.success("✅ Aucune incohérence temporelle détectée dans les séjours.")
+    
+    # --- SECTION 4 : RESUME GLOBAL ---
+    st.divider()
+    st.subheader("4️⃣ Résumé Exécutif Data Quality")
+    
+    col_resume1, col_resume2, col_resume3 = st.columns(3)
+    
+    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()
+        
+        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
+        st.metric("Score de complétude", f"{completeness_score:.1f}%")
+    
+    with col_resume2:
+        st.markdown("##### 🎯 Exactitude")
+        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
+        st.metric("Score d'exactitude", f"{accuracy_score:.2f}%")
+    
+    with col_resume3:
+        st.markdown("##### 🎯 Cohérence")
+        consistency_issues = dates_inversees + suroccupation
+        st.metric("Violations de cohérence", f"{consistency_issues:,}")
+        
+        if consistency_issues == 0:
+            st.success("✅ Données cohérentes")
+        else:
+            st.error(f"🚨 {consistency_issues} violations détectées")
+    
+    # Score global
+    st.markdown("---")
+    global_score = (completeness_score + accuracy_score) / 2 if completeness_score > 0 and accuracy_score > 0 else 0
+    
+    if global_score >= 95:
+        status = "🟢 EXCELLENT"
+        color = "green"
+    elif global_score >= 85:
+        status = "🟡 BON"
+        color = "orange"
+    elif global_score >= 70:
+        status = "🟠 MOYEN"
+        color = "orange"
     else:
-        st.success("✅ Aucune incohérence temporelle détectée dans les séjours.")
+        status = "🔴 CRITIQUE"
+        color = "red"
+    
+    st.markdown(f"### Score Global Data Quality : {global_score:.1f}% - {status}")
+    st.progress(global_score / 100)