Update src/module/Data_Exploration.py

src/module/Data_Exploration.py

@@ -1,200 +1,321 @@
 """
-MODULE DATA EXPLORATION - VORTEX SYSTEM
-========================================
-Responsabilité : Analyse exploratoire des données (EDA) avec Google Sheets
+MODULE DATA EXPLORATION - SENIOR DATA SCIENTIST EDITION
+=======================================================
+Responsabilité : EDA Avancée, Audit DQ, Analyse Temporelle & Stress-Tests
 """
 import pandas as pd
 import numpy as np
 import streamlit as st
 import plotly.express as px
 import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import gspread
-from datetime import datetime
-import json
-import time
 
 # --- DEBUG MARKER ---
-print("✅ Module Data_Exploration chargé avec succès")
+print("✅ Module Data_Exploration (Senior Edition) chargé")
 
 class DataExplorer:
-    """Classe pour l'exploration et l'analyse des données hospitalières"""
+    """Moteur d'analyse exploratoire avancé pour données hospitalières"""
     
     def __init__(self, gspread_client, sheet_name="bdd_mvp_faker"):
         self.client = gspread_client
         self.sheet_name = sheet_name
         self.dataframes = {}
-        self.kpis = {}
         
     def load_all_sheets(self):
-        """Charge tous les onglets du fichier Google Sheets"""
+        """Charge et pré-traite les données (typage dates, nettoyage basique)"""
         try:
             spreadsheet = self.client.open(self.sheet_name)
             sheet_names = [worksheet.title for worksheet in spreadsheet.worksheets()]
             
-            st.toast(f"Connexion établie : {len(sheet_names)} onglets trouvés", icon="📡")
+            progress_text = "Chargement des tables..."
+            my_bar = st.progress(0, text=progress_text)
             
-            for sheet_name in sheet_names:
-                # On ignore les feuilles de calcul temporaires ou masquées si besoin
+            for i, sheet_name in enumerate(sheet_names):
                 worksheet = spreadsheet.worksheet(sheet_name)
                 data = worksheet.get_all_records()
                 
                 if data:
-                    standardized_name = sheet_name.lower().replace('é', 'e').replace(' ', '_')
-                    self.dataframes[standardized_name] = pd.DataFrame(data)
+                    # Standardisation du nom (ex: "Ressources Jour" -> "ressources_jour")
+                    std_name = sheet_name.lower().replace('é', 'e').replace(' ', '_').replace('-', '_').split('__')[0]
+                    df = pd.DataFrame(data)
+                    
+                    # --- PRÉ-TRAITEMENT AUTOMATIQUE ---
+                    # 1. Conversion des dates
+                    for col in df.columns:
+                        if 'date' in col.lower():
+                            df[col] = pd.to_datetime(df[col], errors='coerce')
+                    
+                    # 2. Conversion numérique forcée pour les métriques clés
+                    cols_numeric = ['age', 'lits_occupes', 'lits_total', 'tension_stock', 'nb_admissions', 'duree_sejour_jours']
+                    for col in cols_numeric:
+                        if col in df.columns:
+                            df[col] = pd.to_numeric(df[col], errors='coerce')
+
+                    self.dataframes[std_name] = df
+                
+                my_bar.progress((i + 1) / len(sheet_names), text=f"Chargement : {sheet_name}")
             
+            my_bar.empty()
             return True
             
         except Exception as e:
-            st.error(f"❌ Erreur GSheets : {e}")
+            st.error(f"❌ Erreur critique GSheets : {e}")
             return False
 
-    def get_dataframe(self, sheet_key):
-        return self.dataframes.get(sheet_key)
+    def get_df(self, name):
+        """Helper sécurisé pour récupérer un DF"""
+        # Gestion des variations de noms de fichiers (avec ou sans extension)
+        for key in self.dataframes.keys():
+            if name in key:
+                return self.dataframes[key]
+        return None
 
-    def show_data_overview(self):
-        st.markdown("### 📋 Aperçu Général")
-        if not self.dataframes:
-            st.info("Aucune donnée chargée.")
-            return
+    # ==========================================================================
+    # 1. AUDIT QUALITÉ (DQ) & INTÉGRITÉ
+    # ==========================================================================
+    def tab_audit_dq(self):
+        st.markdown("### 🛡️ Audit de Qualité & Intégrité des Données")
+        st.caption("Détection des anomalies structurelles et métier basées sur les hypothèses du projet.")
+        
+        col1, col2 = st.columns(2)
+        
+        # --- A. Analyse des Patients (Age & Doublons) ---
+        with col1:
+            st.markdown("#### 👥 Intégrité Patients")
+            df_pat = self.get_df('patients')
+            if df_pat is not None:
+                # 1. Doublons
+                doublons = df_pat.duplicated(subset=['nom', 'prenom', 'date_naissance']).sum()
+                
+                # 2. Âges aberrants (Hypothèse: -5 ans ou > 120 ans)
+                age_aberrant = df_pat[(df_pat['age'] < 0) | (df_pat['age'] > 120)].shape[0]
+                
+                # 3. Valeurs manquantes critiques
+                missing_ville = df_pat['ville'].isnull().sum()
+                
+                # Viz KPI
+                kpi_col1, kpi_col2, kpi_col3 = st.columns(3)
+                kpi_col1.metric("Doublons stricts", doublons, delta_color="inverse")
+                kpi_col2.metric("Âges Aberrants", age_aberrant, delta_color="inverse")
+                kpi_col3.metric("Ville Manquante", missing_ville, delta_color="inverse")
+                
+                # Graphique Distribution Age
+                fig_age = px.histogram(df_pat, x='age', nbins=50, title="Distribution des Âges (Détection Outliers)", color_discrete_sequence=['#58a6ff'])
+                st.plotly_chart(fig_age, use_container_width=True)
+            else:
+                st.warning("Table 'patients' introuvable.")
 
-        overview_data = []
-        for name, df in self.dataframes.items():
-            overview_data.append({
-                "Table": name,
-                "Lignes": df.shape[0],
-                "Colonnes": df.shape[1],
-                "Manquants": df.isnull().sum().sum()
-            })
-        st.dataframe(pd.DataFrame(overview_data), use_container_width=True)
-
-    def show_detailed_inspection(self, sheet_key):
-        df = self.get_dataframe(sheet_key)
-        if df is None:
-            return
+        # --- B. Cohérence des Séjours ---
+        with col2:
+            st.markdown("#### 🏥 Cohérence Séjours")
+            df_sej = self.get_df('sejours')
+            if df_sej is not None:
+                # 1. Date Sortie < Date Entrée
+                incoherent_dates = df_sej[df_sej['date_sortie'] < df_sej['date_entree']].shape[0]
+                
+                # 2. Gravité invalide (Hypothèse: 1-5, si >5 anomalie)
+                # On suppose que la colonne est 'gravite_1_5' ou similaire
+                gravite_col = next((c for c in df_sej.columns if 'gravit' in c), None)
+                gravite_issues = 0
+                if gravite_col:
+                    gravite_issues = df_sej[(df_sej[gravite_col] < 1) | (df_sej[gravite_col] > 5)].shape[0]
+
+                st.metric("Dates Incohérentes (Sortie < Entrée)", incoherent_dates, delta_color="inverse")
+                st.metric("Score Gravité Hors Norme", gravite_issues, delta_color="inverse")
+                
+                if incoherent_dates > 0:
+                    st.error(f"🚨 Alerte : {incoherent_dates} séjours ont une date de fin antérieure au début !")
+            else:
+                st.warning("Table 'sejours' introuvable.")
+
+    # ==========================================================================
+    # 2. ANALYSE TEMPORELLE & FLUX (STL Like)
+    # ==========================================================================
+    def tab_temporal_flux(self):
+        st.markdown("### ⏳ Analyse Temporelle des Admissions")
+        st.caption("Décomposition de la tendance et de la saisonnalité pour identifier les cycles.")
         
-        st.markdown(f"#### Inspection : `{sheet_key}`")
-        tab1, tab2 = st.tabs(["Données", "Statistiques"])
-        with tab1:
-            st.dataframe(df.head(50), use_container_width=True)
-        with tab2:
-            st.dataframe(df.describe(include='all'), use_container_width=True)
-
-    def analyze_patients(self):
-        df = self.get_dataframe('patients')
-        if df is None:
-            st.warning("Table 'patients' manquante")
+        df_adm = self.get_df('admissions')
+        if df_adm is None:
+            st.warning("Table 'admissions_jour' manquante.")
             return
+
+        # Agrégation par jour (tous services confondus)
+        df_daily = df_adm.groupby('date')['nb_admissions'].sum().reset_index().sort_values('date')
+        
+        # Calcul Moyenne Mobile (Trend)
+        df_daily['Trend (7j)'] = df_daily['nb_admissions'].rolling(window=7).mean()
+        df_daily['Trend (30j)'] = df_daily['nb_admissions'].rolling(window=30).mean()
+
+        # Viz 1: Flux Brut vs Tendance
+        fig_flux = go.Figure()
+        fig_flux.add_trace(go.Scatter(x=df_daily['date'], y=df_daily['nb_admissions'], mode='lines', name='Admissions Brutes', line=dict(color='rgba(88, 166, 255, 0.3)')))
+        fig_flux.add_trace(go.Scatter(x=df_daily['date'], y=df_daily['Trend (7j)'], mode='lines', name='Tendance Hebdo', line=dict(color='#00E676', width=2)))
+        fig_flux.add_trace(go.Scatter(x=df_daily['date'], y=df_daily['Trend (30j)'], mode='lines', name='Tendance Mensuelle', line=dict(color='#ff6b9d', width=2)))
+        
+        fig_flux.update_layout(title="Flux d'Admissions & Lissage (Trend)", xaxis_title="Date", yaxis_title="Nb Admissions")
+        st.plotly_chart(fig_flux, use_container_width=True)
+        
+        # Viz 2: Saisonnalité (Heatmap Jours/Mois)
+        col1, col2 = st.columns([1, 2])
+        with col1:
+            st.markdown("**Saisonnalité Hebdomadaire**")
+            df_daily['day_name'] = df_daily['date'].dt.day_name()
+            day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+            df_week = df_daily.groupby('day_name')['nb_admissions'].mean().reindex(day_order)
             
-        col1, col2 = st.columns(2)
+            fig_week = px.bar(df_week, title="Moyenne par Jour", color=df_week.values, color_continuous_scale="Blues")
+            st.plotly_chart(fig_week, use_container_width=True)
+
+    # ==========================================================================
+    # 3. STRESS-TEST SCÉNARIOS & DMS
+    # ==========================================================================
+    def tab_stress_scenarios(self):
+        st.markdown("### 🌪️ Impact des Scénarios de Crise")
+        st.caption("Corrélation entre les types de scénarios (Covid, Grippe) et la tension hospitalière.")
+        
+        df_res = self.get_df('ressources')
+        if df_res is None or 'scenario' not in df_res.columns:
+            st.warning("Données ressources ou scénarios manquantes.")
+            return
+
+        # 1. Boxplot Taux d'Occupation par Scénario
+        st.markdown("#### Saturation des Lits par Scénario")
+        # On filtre les scénarios 'Normal' pour voir le contraste
+        top_scenarios = df_res['scenario'].value_counts().head(5).index.tolist()
+        df_filtered = df_res[df_res['scenario'].isin(top_scenarios)]
+        
+        fig_box = px.box(df_filtered, x='scenario', y='taux_occupation', color='scenario',
+                         title="Distribution du Taux d'Occupation par Type de Crise",
+                         points="outliers")
+        st.plotly_chart(fig_box, use_container_width=True)
+        
+        # 2. Corrélation Tension Personnel vs Occupation
+        st.markdown("#### Corrélation : Occupation Lits vs Tension Personnel")
+        col1, col2 = st.columns([3, 1])
         with col1:
-            st.metric("Nombre de Patients", len(df))
-            if 'sexe' in df.columns:
-                fig = px.pie(df, names='sexe', title="Répartition Sexe", hole=0.4)
-                st.plotly_chart(fig, use_container_width=True)
+            fig_scatter = px.scatter(df_res, x='taux_occupation', y='tension_personnel', 
+                                   color='service_code', size='lits_total',
+                                   hover_data=['date', 'scenario'],
+                                   title="Zone de Danger : Tension > 80%",
+                                   trendline="ols") # Nécessite statsmodels, sinon retirer trendline
+            
+            # Ajout zones de danger
+            fig_scatter.add_hrect(y0=0.8, y1=1.5, line_width=0, fillcolor="red", opacity=0.1, annotation_text="Danger RH")
+            fig_scatter.add_vrect(x0=0.9, x1=1.5, line_width=0, fillcolor="orange", opacity=0.1, annotation_text="Saturation Lits")
+            
+            st.plotly_chart(fig_scatter, use_container_width=True)
         
         with col2:
-            if 'age' in df.columns:
-                avg_age = df['age'].mean()
-                st.metric("Âge Moyen", f"{avg_age:.1f} ans")
-                fig = px.histogram(df, x='age', nbins=20, title="Distribution des Âges")
-                st.plotly_chart(fig, use_container_width=True)
-
-    def analyze_data_quality(self):
-        st.markdown("#### 🛡️ Audit de Qualité")
-        total_issues = 0
-        for name, df in self.dataframes.items():
-            if 'dq_is_anomaly' in df.columns:
-                anomalies = df[df['dq_is_anomaly'] == 1]
-                count = len(anomalies)
-                if count > 0:
-                    total_issues += count
-                    with st.expander(f"⚠️ {name} : {count} anomalies détectées"):
-                        st.dataframe(anomalies, use_container_width=True)
-        
-        if total_issues == 0:
-            st.success("Aucune anomalie marquée (dq_is_anomaly) détectée.")
-
-    def calculate_kpis(self):
-        st.markdown("#### 🚀 KPIs en temps réel")
-        # Exemple simple
-        df_res = self.get_dataframe('ressources_jour')
-        if df_res is not None and 'lits_occupes' in df_res.columns:
-            taux = df_res['lits_occupes'].sum() / df_res['lits_total'].sum() * 100
-            st.metric("Taux d'Occupation Global", f"{taux:.1f}%")
+            st.info("""
+            **Interprétation :**
+            - **Cadran Haut-Droite** : Situation critique (Lits pleins + Manque personnel).
+            - **Points isolés** : Vérifier s'il s'agit d'événements exceptionnels ou d'erreurs de saisie.
+            """)
+
+    # ==========================================================================
+    # 4. LOGISTIQUE & LAG (STOCKS)
+    # ==========================================================================
+    def tab_logistics(self):
+        st.markdown("### 📦 Logistique & Ruptures de Stock")
+        st.caption("Identification des goulots d'étranglement matériels.")
+        
+        df_stock = self.get_df('stock')
+        if df_stock is None:
+            st.warning("Table 'stock_materiel_jour' manquante.")
+            return
+
+        # Focus sur les matériels critiques
+        critical_items = ['CONSO_O2', 'EQP_RESP', 'CONSO_EPI']
+        df_crit = df_stock[df_stock['materiel_code'].isin(critical_items)]
+        
+        # Viz : Tension Stock au cours du temps
+        fig_stock = px.line(df_crit, x='date', y='tension_stock', color='materiel_code',
+                            title="Évolution de la Tension des Stocks Critiques",
+                            facet_row='service_code', height=800)
+        
+        # Seuil d'alerte visuel
+        fig_stock.add_hline(y=0.8, line_dash="dash", line_color="red", annotation_text="Seuil Critique (80%)")
+        
+        st.plotly_chart(fig_stock, use_container_width=True)
+        
+        # Top Alertes Actuelles
+        latest_date = df_stock['date'].max()
+        ruptures = df_stock[(df_stock['date'] == latest_date) & (df_stock['tension_stock'] > 0.9)]
+        
+        if not ruptures.empty:
+            st.error(f"🚨 ALERTES CRITIQUES AU {latest_date.date()} :")
+            st.dataframe(ruptures[['service_code', 'materiel_code', 'stock_disponible', 'tension_stock']], use_container_width=True)
         else:
-            st.info("Données ressources insuffisantes pour le calcul des KPIs.")
-
-    def show_stock_alerts(self):
-        df_stock = self.get_dataframe('stock_materiel_jour') # Correction probable du nom ici selon tes fichiers précédents
-        # Si ça ne marche pas, remets 'materiel' si c'est le nom de ta table
-        if df_stock is None: 
-             df_stock = self.get_dataframe('materiel')
-
-        if df_stock is not None and 'tension_stock' in df_stock.columns:
-            alerts = df_stock[df_stock['tension_stock'] > 0.8]
-            if not alerts.empty:
-                st.error(f"🚨 {len(alerts)} Matériels en rupture imminente")
-                st.dataframe(alerts, use_container_width=True)
-            else:
-                st.success("Stock sous contrôle.")
+            st.success(f"✅ Aucun stock en tension critique au {latest_date.date()}.")
 
 
 # ==============================================================================
-# FONCTION PRINCIPALE AVEC CHARGEMENT AUTO
+# FONCTION PRINCIPALE (SHOW TERMINAL) - VERSION AUTO-LOAD
 # ==============================================================================
 def show_terminal(gspread_client, sheet_name="bdd_mvp_faker"):
-    """Fonction principale du Dashboard"""
+    """Orchestrateur de l'interface Data Explorer"""
     
-    # Initialisation unique de l'objet DataExplorer
+    # Singleton Pattern pour éviter de recharger à chaque interaction
     if 'data_explorer' not in st.session_state:
         st.session_state.data_explorer = DataExplorer(gspread_client, sheet_name)
     
     explorer = st.session_state.data_explorer
     
-    st.markdown("## 🔬 DATA EXPLORER & MONITORING")
+    # 1. HEADER
+    st.markdown("## 🔬 DATA EXPLORER : CENTRE D'ANALYSE")
     
-    # --- LOGIQUE DE CHARGEMENT AUTOMATIQUE ---
-    # Si les données ne sont pas chargées, on lance le chargement immédiatement
+    # 2. CHARGEMENT AUTOMATIQUE (Plus de bouton)
     if not explorer.dataframes:
-        with st.spinner("🔄 Connexion automatique à Google Sheets en cours..."):
+        # On lance le chargement directement
+        with st.spinner("🔄 Initialisation et chargement des données..."):
             success = explorer.load_all_sheets()
             
-            if success:
-                st.success("✅ Données chargées avec succès !")
-                time.sleep(0.5) # Petit délai pour voir le message
-                st.rerun() # On recharge la page pour afficher le dashboard
-            else:
-                st.error("🛑 Le chargement a échoué. Vérifiez votre connexion ou la clé API.")
-                return # On arrête l'exécution ici si ça plante
+        if success:
+            st.toast("Données chargées avec succès !", icon="✅")
+            st.rerun() # On rafraîchit la page pour afficher le dashboard
+        else:
+            st.error("❌ Échec du chargement automatique. Vérifiez la connexion GSheets.")
+            # On arrête l'exécution ici pour ne pas faire planter la suite
+            return
     
-    # --- DASHBOARD (S'affiche seulement si les données sont là) ---
+    # 3. DASHBOARD ANALYTIQUE (S'affiche une fois les données chargées)
     else:
-        # Barre d'outils
-        col_actions, _ = st.columns([1, 4])
-        with col_actions:
-            if st.button("🔄 Rafraîchir Données"):
-                explorer.dataframes = {} # On vide le cache
-                st.rerun() # On relance, ce qui déclenchera le chargement auto ci-dessus
-
-        # Onglets de navigation
-        tabs = st.tabs(["Vue Globale", "Patients", "Qualité & Stock", "Inspection"])
+        # Barre d'actions
+        col_refresh, col_info = st.columns([1, 5])
+        with col_refresh:
+            # Le bouton reload permet de forcer un nouveau téléchargement si besoin
+            if st.button("🔄 Reload"):
+                explorer.dataframes = {}
+                st.rerun()
+        
+        # NAVIGATION PAR ONGLETS MÉTIER
+        tabs = st.tabs([
+            "🛡️ 1. Audit Qualité (DQ)", 
+            "⏳ 2. Analyse Temporelle", 
+            "🌪️ 3. Stress-Tests Scénarios", 
+            "📦 4. Logistique & Stocks",
+            "📋 Inspection Brute"
+        ])
         
         with tabs[0]:
-            explorer.show_data_overview()
-            explorer.calculate_kpis()
+            explorer.tab_audit_dq()
             
         with tabs[1]:
-            explorer.analyze_patients()
+            explorer.tab_temporal_flux()
             
         with tabs[2]:
-            col1, col2 = st.columns(2)
-            with col1:
-                explorer.analyze_data_quality()
-            with col2:
-                explorer.show_stock_alerts()
-                
+            explorer.tab_stress_scenarios()
+            
         with tabs[3]:
-            # Sélecteur de table sécurisé
-            if explorer.dataframes:
-                sheet = st.selectbox("Choisir une table", list(explorer.dataframes.keys()))
-                explorer.show_detailed_inspection(sheet)
+            explorer.tab_logistics()
+            
+        with tabs[4]:
+            # Inspection brute simple
+            st.markdown("#### 🔎 Explorateur de Tables Brutes")
+            table_choice = st.selectbox("Choisir une table", list(explorer.dataframes.keys()))
+            if table_choice:
+                df_view = explorer.dataframes[table_choice]
+                st.write(f"Dimensions : {df_view.shape}")
+                st.dataframe(df_view, use_container_width=True)