Update src/module/Data_Exploration.py

src/module/Data_Exploration.py

@@ -0,0 +1,380 @@
+"""
+MODULE DATA EXPLORATION - VORTEX SYSTEM
+========================================
+Responsabilité : Analyse exploratoire des données (EDA) avec Google Sheets
+"""
+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
+
+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 = {}
+        self.kpis = {}
+        
+    def load_all_sheets(self):
+        """Charge tous les onglets du fichier Google Sheets"""
+        try:
+            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)}")
+            
+            for sheet_name in sheet_names:
+                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}")
+            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")
+        
+        if not self.dataframes:
+            st.warning("⚠️ Aucune donnée chargée. Veuillez d'abord charger les données.")
+            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()
+            })
+        
+        overview_df = pd.DataFrame(overview_data)
+        st.dataframe(overview_df, 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"])
+        
+        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)
+        
+        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)
+    
+    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")
+            return
+        
+        st.markdown("### 👥 Analyse Démographique des Patients")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            total_patients = len(df_patients)
+            st.metric("Total Patients", f"{total_patients:,}")
+        
+        with col2:
+            if 'age' in df_patients.columns:
+                avg_age = df_patients['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)
+    
+    def analyze_data_quality(self):
+        """Analyse la qualité des données (colonnes dq_)"""
+        st.markdown("### 🔬 Audit de Qualité des Données")
+        
+        dq_results = {}
+        
+        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)
+    
+    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"
+                )
+        else:
+            st.info("ℹ️ Impossible de calculer les KPIs avec les données actuelles")
+    
+    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:
+            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)
+            else:
+                st.success("✅ Aucune alerte de stock")
+        else:
+            st.info("ℹ️ Colonne 'tension_stock' non trouvée dans les données")
+
+
+def show_terminal(gspread_client, sheet_name="bdd_mvp_faker"):
+    """
+    Fonction principale à appeler depuis Streamlit pour afficher l'interface EDA
+    
+    Args:
+        gspread_client: Client gspread authentifié
+        sheet_name: Nom du fichier Google Sheets
+    """
+    st.markdown("## 🔬 EXPLORATEUR DE DONNÉES")
+    
+    # Initialisation
+    if 'data_explorer' not in st.session_state:
+        st.session_state.data_explorer = DataExplorer(gspread_client, sheet_name)
+    
+    explorer = st.session_state.data_explorer
+    
+    # Bouton de chargement
+    if st.button("📥 Charger les Données", type="primary"):
+        with st.spinner("Chargement en cours..."):
+            success = explorer.load_all_sheets()
+            if success:
+                st.success("✅ Données chargées avec succès !")
+    
+    # Menu d'analyse
+    if explorer.dataframes:
+        st.divider()
+        
+        analysis_mode = st.selectbox(
+            "Mode d'Analyse",
+            ["Aperçu Général", "Inspection Détaillée", "Analyse Patients", 
+             "Qualité des Données", "KPIs", "Alertes Stock"]
+        )
+        
+        if analysis_mode == "Aperçu Général":
+            explorer.show_data_overview()
+        
+        elif analysis_mode == "Inspection Détaillée":
+            sheet_to_inspect = st.selectbox(
+                "Sélectionner un onglet",
+                list(explorer.dataframes.keys())
+            )
+            explorer.show_detailed_inspection(sheet_to_inspect)
+        
+        elif analysis_mode == "Analyse Patients":
+            explorer.analyze_patients()
+        
+        elif analysis_mode == "Qualité des Données":
+            explorer.analyze_data_quality()
+        
+        elif analysis_mode == "KPIs":
+            explorer.calculate_kpis()
+        
+        elif analysis_mode == "Alertes Stock":
+            explorer.show_stock_alerts()