Update src/module/Data_Exploration.py

src/module/Data_Exploration.py

@@ -8,22 +8,18 @@ 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
 
+# --- DEBUG MARKER ---
+# Si cette ligne s'affiche dans les logs, le module est bien lu
+print("✅ Module Data_Exploration chargé avec succès")
+
 class DataExplorer:
     """Classe pour l'exploration et l'analyse des données hospitalières"""
     
     def __init__(self, gspread_client, sheet_name="bdd_mvp_faker"):
-        """
-        Initialise l'explorateur de données
-        
-        Args:
-            gspread_client: Client gspread authentifié
-            sheet_name: Nom du fichier Google Sheets
-        """
         self.client = gspread_client
         self.sheet_name = sheet_name
         self.dataframes = {}
@@ -35,370 +31,157 @@ class DataExplorer:
             spreadsheet = self.client.open(self.sheet_name)
             sheet_names = [worksheet.title for worksheet in spreadsheet.worksheets()]
             
-            st.info(f"📊 Onglets détectés : {', '.join(sheet_names)}")
+            st.toast(f"Connexion établie : {len(sheet_names)} onglets trouvés", icon="📡")
             
             for sheet_name in sheet_names:
+                # On ignore les feuilles de calcul temporaires ou masquées si besoin
                 worksheet = spreadsheet.worksheet(sheet_name)
                 data = worksheet.get_all_records()
                 
                 if data:
-                    # Standardisation du nom pour le dictionnaire
                     standardized_name = sheet_name.lower().replace('é', 'e').replace(' ', '_')
                     self.dataframes[standardized_name] = pd.DataFrame(data)
-                    st.success(f"✅ {sheet_name} chargé ({len(data)} lignes)")
-                else:
-                    st.warning(f"⚠️ {sheet_name} est vide")
             
             return True
             
         except Exception as e:
-            st.error(f"❌ Erreur lors du chargement : {e}")
+            st.error(f"❌ Erreur GSheets : {e}")
             return False
-    
+
     def get_dataframe(self, sheet_key):
-        """Récupère un DataFrame spécifique par son nom standardisé"""
         return self.dataframes.get(sheet_key)
-    
+
     def show_data_overview(self):
-        """Affiche un aperçu général des données"""
-        st.markdown("### 📋 Aperçu Général des Données")
-        
+        st.markdown("### 📋 Aperçu Général")
         if not self.dataframes:
-            st.warning("⚠️ Aucune donnée chargée. Veuillez d'abord charger les données.")
+            st.info("Aucune donnée chargée.")
             return
-        
-        # Tableau récapitulatif
+
         overview_data = []
         for name, df in self.dataframes.items():
             overview_data.append({
-                "Onglet": name,
-                "Lignes": len(df),
-                "Colonnes": len(df.columns),
-                "Mémoire (KB)": round(df.memory_usage(deep=True).sum() / 1024, 2),
-                "Valeurs manquantes": df.isnull().sum().sum()
+                "Table": name,
+                "Lignes": df.shape[0],
+                "Colonnes": df.shape[1],
+                "Manquants": df.isnull().sum().sum()
             })
-        
-        overview_df = pd.DataFrame(overview_data)
-        st.dataframe(overview_df, use_container_width=True)
-    
+        st.dataframe(pd.DataFrame(overview_data), use_container_width=True)
+
     def show_detailed_inspection(self, sheet_key):
-        """Affiche une inspection détaillée d'un DataFrame spécifique"""
         df = self.get_dataframe(sheet_key)
-        
         if df is None:
-            st.error(f"❌ Onglet '{sheet_key}' non trouvé")
             return
         
-        st.markdown(f"### 🔍 Inspection Détaillée : `{sheet_key}`")
-        
-        # Onglets d'inspection
-        tab1, tab2, tab3, tab4 = st.tabs(["📊 Aperçu", "📈 Statistiques", "🔎 Qualité", "🧹 Colonnes"])
-        
+        st.markdown(f"#### Inspection : `{sheet_key}`")
+        tab1, tab2 = st.tabs(["Données", "Statistiques"])
         with tab1:
-            st.markdown("#### Premières lignes")
-            st.dataframe(df.head(10), use_container_width=True)
-            
-            st.markdown("#### Dernières lignes")
-            st.dataframe(df.tail(5), use_container_width=True)
-        
+            st.dataframe(df.head(50), use_container_width=True)
         with tab2:
-            st.markdown("#### Statistiques Descriptives")
-            st.dataframe(df.describe(include='all').T, use_container_width=True)
-            
-            st.markdown("#### Types de Données")
-            types_df = pd.DataFrame({
-                'Colonne': df.columns,
-                'Type': df.dtypes.values,
-                'Non-Null': df.count().values,
-                'Null': df.isnull().sum().values
-            })
-            st.dataframe(types_df, use_container_width=True)
-        
-        with tab3:
-            st.markdown("#### Analyse de Qualité")
-            
-            # Valeurs manquantes
-            missing_data = df.isnull().sum()
-            missing_percent = (missing_data / len(df)) * 100
-            
-            quality_df = pd.DataFrame({
-                'Colonne': missing_data.index,
-                'Valeurs Manquantes': missing_data.values,
-                'Pourcentage (%)': missing_percent.values.round(2)
-            })
-            quality_df = quality_df[quality_df['Valeurs Manquantes'] > 0].sort_values('Valeurs Manquantes', ascending=False)
-            
-            if not quality_df.empty:
-                st.dataframe(quality_df, use_container_width=True)
-                
-                # Graphique
-                fig = px.bar(quality_df, x='Colonne', y='Pourcentage (%)', 
-                            title='Pourcentage de Valeurs Manquantes par Colonne',
-                            color='Pourcentage (%)',
-                            color_continuous_scale='Reds')
-                st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.success("✅ Aucune valeur manquante détectée !")
-            
-            # Doublons
-            duplicates = df.duplicated().sum()
-            st.metric("Lignes Dupliquées", duplicates)
-        
-        with tab4:
-            st.markdown("#### Liste des Colonnes")
-            cols_info = []
-            for col in df.columns:
-                unique_count = df[col].nunique()
-                cols_info.append({
-                    'Colonne': col,
-                    'Type': str(df[col].dtype),
-                    'Valeurs Uniques': unique_count,
-                    'Exemple': str(df[col].iloc[0]) if len(df) > 0 else 'N/A'
-                })
-            
-            st.dataframe(pd.DataFrame(cols_info), use_container_width=True)
-    
+            st.dataframe(df.describe(include='all'), use_container_width=True)
+
     def analyze_patients(self):
-        """Analyse spécifique des patients"""
-        df_patients = self.get_dataframe('patients')
-        
-        if df_patients is None:
-            st.warning("⚠️ Onglet 'patients' non disponible")
+        df = self.get_dataframe('patients')
+        if df is None:
+            st.warning("Table 'patients' manquante")
             return
-        
-        st.markdown("### 👥 Analyse Démographique des Patients")
-        
-        col1, col2, col3 = st.columns(3)
-        
+            
+        col1, col2 = st.columns(2)
         with col1:
-            total_patients = len(df_patients)
-            st.metric("Total Patients", f"{total_patients:,}")
+            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)
         
         with col2:
-            if 'age' in df_patients.columns:
-                avg_age = df_patients['age'].mean()
+            if 'age' in df.columns:
+                avg_age = df['age'].mean()
                 st.metric("Âge Moyen", f"{avg_age:.1f} ans")
-        
-        with col3:
-            if 'sexe' in df_patients.columns:
-                gender_dist = df_patients['sexe'].value_counts()
-                st.metric("Répartition H/F", f"{gender_dist.get('M', 0)}/{gender_dist.get('F', 0)}")
-        
-        # Pyramide des âges
-        if 'age' in df_patients.columns:
-            st.markdown("#### 📊 Pyramide des Âges")
-            
-            # Détection des outliers
-            q1 = df_patients['age'].quantile(0.25)
-            q3 = df_patients['age'].quantile(0.75)
-            iqr = q3 - q1
-            outlier_threshold = q3 + 1.5 * iqr
-            
-            outliers = df_patients[df_patients['age'] > outlier_threshold]
-            if not outliers.empty:
-                st.warning(f"⚠️ {len(outliers)} outliers détectés (âge > {outlier_threshold:.0f} ans)")
-            
-            fig = px.histogram(df_patients, x='age', nbins=30,
-                             title='Distribution des Âges',
-                             labels={'age': 'Âge', 'count': 'Nombre de patients'},
-                             color_discrete_sequence=['#58a6ff'])
-            st.plotly_chart(fig, use_container_width=True)
-        
-        # Répartition par sexe
-        if 'sexe' in df_patients.columns:
-            st.markdown("#### ⚥ Répartition par Sexe")
-            
-            gender_counts = df_patients['sexe'].value_counts()
-            fig = px.pie(values=gender_counts.values, names=gender_counts.index,
-                        title='Répartition Hommes/Femmes',
-                        color_discrete_sequence=['#58a6ff', '#ff6b9d'])
-            st.plotly_chart(fig, use_container_width=True)
-    
+                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):
-        """Analyse la qualité des données (colonnes dq_)"""
-        st.markdown("### 🔬 Audit de Qualité des Données")
-        
-        dq_results = {}
-        
+        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]
-                
-                dq_results[name] = {
-                    "total_rows": len(df),
-                    "anomaly_count": len(anomalies),
-                    "anomaly_rate": (len(anomalies) / len(df) * 100) if len(df) > 0 else 0
-                }
-                
-                if 'dq_anomaly_type' in df.columns and not anomalies.empty:
-                    dq_results[name]["types"] = anomalies['dq_anomaly_type'].value_counts().to_dict()
-        
-        if not dq_results:
-            st.info("ℹ️ Aucune colonne de qualité (dq_) détectée dans les données")
-            return
-        
-        # Affichage des résultats
-        for sheet_name, results in dq_results.items():
-            with st.expander(f"📋 {sheet_name.upper()}", expanded=True):
-                col1, col2, col3 = st.columns(3)
-                
-                with col1:
-                    st.metric("Total Lignes", f"{results['total_rows']:,}")
-                with col2:
-                    st.metric("Anomalies", results['anomaly_count'])
-                with col3:
-                    st.metric("Taux d'Anomalies", f"{results['anomaly_rate']:.2f}%")
-                
-                if "types" in results and results["types"]:
-                    st.markdown("**Types d'Anomalies :**")
-                    types_df = pd.DataFrame(list(results["types"].items()), 
-                                          columns=['Type', 'Count'])
-                    st.dataframe(types_df, use_container_width=True)
-    
+                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):
-        """Calcule les KPIs par service"""
-        st.markdown("### 📊 Indicateurs de Performance (KPIs)")
-        
-        # Exemple de KPIs - à adapter selon vos données réelles
-        kpis = {}
-        
-        # KPI 1: Taux d'occupation
-        df_ressources = self.get_dataframe('ressources_jour')
-        if df_ressources is not None and 'lits_total' in df_ressources.columns:
-            total_lits = df_ressources['lits_total'].sum()
-            lits_occupes = df_ressources['lits_occupes'].sum() if 'lits_occupes' in df_ressources.columns else 0
-            kpis['taux_occupation'] = (lits_occupes / total_lits * 100) if total_lits > 0 else 0
-        
-        # KPI 2: Durée moyenne de séjour
-        df_sejours = self.get_dataframe('sejours')
-        if df_sejours is not None and 'duree_sejour' in df_sejours.columns:
-            kpis['duree_moyenne_sejour'] = df_sejours['duree_sejour'].mean()
-        
-        # KPI 3: Nombre de patients
-        df_patients = self.get_dataframe('patients')
-        if df_patients is not None:
-            kpis['total_patients'] = len(df_patients)
-        
-        # Affichage
-        if kpis:
-            cols = st.columns(len(kpis))
-            for idx, (key, value) in enumerate(kpis.items()):
-                with cols[idx]:
-                    st.metric(key.replace('_', ' ').title(), f"{value:.2f}")
-            
-            # Export JSON
-            if st.button("💾 Exporter les KPIs (JSON)"):
-                kpis_json = json.dumps(kpis, indent=2)
-                st.download_button(
-                    label="Télécharger KPIs.json",
-                    data=kpis_json,
-                    file_name=f"kpis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-                    mime="application/json"
-                )
+        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}%")
         else:
-            st.info("ℹ️ Impossible de calculer les KPIs avec les données actuelles")
-    
+            st.info("Données ressources insuffisantes pour le calcul des KPIs.")
+
     def show_stock_alerts(self):
-        """Affiche les alertes de stock"""
         df_stock = self.get_dataframe('materiel')
-        
-        if df_stock is None:
-            st.warning("⚠️ Onglet 'materiel' non disponible")
-            return
-        
-        st.markdown("### 🚨 Alertes Stock & Matériel")
-        
-        if 'tension_stock' in df_stock.columns:
+        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)} alertes de tension de stock détectées !")
-                
-                # Colonnes à afficher
-                display_cols = [col for col in ['date', 'service_code', 'materiel_code', 'tension_stock'] 
-                              if col in alerts.columns]
-                st.dataframe(alerts[display_cols], use_container_width=True)
+                st.error(f"🚨 {len(alerts)} Matériels en rupture imminente")
+                st.dataframe(alerts, use_container_width=True)
             else:
-                st.success("✅ Aucune alerte de stock")
-        else:
-            st.info("ℹ️ Colonne 'tension_stock' non trouvée dans les données")
+                st.success("Stock sous contrôle.")
 
 
-# ... (Le reste de la classe DataExplorer reste identique) ...
-
+# ==============================================================================
+# ⚠️ C'EST ICI QUE SE JOUE VOTRE PROBLÈME
+# La fonction show_terminal DOIT être collée à gauche (pas d'indentation)
+# ==============================================================================
 def show_terminal(gspread_client, sheet_name="bdd_mvp_faker"):
-    """
-    Fonction d'affichage optimisée "Dashboard" pour Streamlit
-    """
-    # 1. Initialisation persistante
+    """Fonction principale du Dashboard"""
+    
+    # Initialisation unique de l'objet DataExplorer
     if 'data_explorer' not in st.session_state:
         st.session_state.data_explorer = DataExplorer(gspread_client, sheet_name)
     
     explorer = st.session_state.data_explorer
     
-    # 2. Auto-chargement des données (Si vide, on charge direct)
+    # Layout Dashboard
+    st.markdown("## 🔬 DATA EXPLORER & MONITORING")
+    
+    # Bouton de chargement intelligent (n'apparait que si vide)
     if not explorer.dataframes:
-        with st.spinner("🔄 Initialisation du Dashboard Data... Récupération GSheets..."):
-            success = explorer.load_all_sheets()
-            if not success:
-                st.error("Impossible de récupérer les données.")
-                return
-
-    # 3. Interface DASHBOARD (Vue immédiate via Tabs)
-    if explorer.dataframes:
-        # Titre avec bouton de rafraîchissement discret à droite
-        col_titre, col_refresh = st.columns([6, 1])
-        with col_titre:
-            st.markdown("## 🔬 MONITORING & EXPLORATION")
-        with col_refresh:
-            if st.button("🔄 Actualiser"):
-                explorer.dataframes = {} # Force le reload
+        if st.button("📥 Initialiser la connexion aux données", type="primary"):
+            with st.spinner("Téléchargement des données Google Sheets..."):
+                explorer.load_all_sheets()
+                st.rerun()
+    else:
+        # Barre d'outils
+        col_actions, _ = st.columns([1, 4])
+        with col_actions:
+            if st.button("🔄 Rafraîchir"):
+                explorer.dataframes = {}
                 st.rerun()
 
-        # Création des onglets principaux
-        tab_overview, tab_patients, tab_quality, tab_business = st.tabs([
-            "📊 Vue Globale", 
-            "👥 Analyse Patients", 
-            "🛡️ Qualité & Santé Données", 
-            "💼 Business & KPIs"
-        ])
+        # Onglets de navigation
+        tabs = st.tabs(["Vue Globale", "Patients", "Qualité & Stock", "Inspection"])
         
-        # --- ONGLET 1 : VUE GLOBALE ---
-        with tab_overview:
-            st.markdown("### 🩻 Radiographie des Données")
+        with tabs[0]:
             explorer.show_data_overview()
+            explorer.calculate_kpis()
             
-            st.divider()
-            st.caption("Sélectionnez un onglet ci-dessus pour entrer dans le détail.")
-
-        # --- ONGLET 2 : PATIENTS ---
-        with tab_patients:
+        with tabs[1]:
             explorer.analyze_patients()
-
-        # --- ONGLET 3 : QUALITÉ (Regroupement Qualité + Stock) ---
-        with tab_quality:
-            col_q1, col_q2 = st.columns(2)
             
-            with col_q1:
-                st.markdown("#### 📉 Anomalies Détectées")
+        with tabs[2]:
+            col1, col2 = st.columns(2)
+            with col1:
                 explorer.analyze_data_quality()
-            
-            with col_q2:
-                st.markdown("#### 📦 Tensions Logistiques")
+            with col2:
                 explorer.show_stock_alerts()
-
-        # --- ONGLET 4 : KPIs BUSINESS ---
-        with tab_business:
-            explorer.calculate_kpis()
-            
-            # Ajout d'une zone d'inspection manuelle ici si besoin
-            st.divider()
-            with st.expander("🔍 Inspection brute d'une table spécifique"):
-                sheet_choice = st.selectbox("Choisir la table", list(explorer.dataframes.keys()))
-                explorer.show_detailed_inspection(sheet_choice)
-
-    else:
-        # Fallback si le chargement a échoué mais sans erreur critique
-        st.warning("Aucune donnée n'a pu être chargée pour le moment.")
-        if st.button("Réessayer le chargement"):
-            st.rerun()
+                
+        with tabs[3]:
+            sheet = st.selectbox("Choisir une table", list(explorer.dataframes.keys()))
+            explorer.show_detailed_inspection(sheet)