Update src/module/Data_Exploration.py

src/module/Data_Exploration.py

@@ -1,278 +1,381 @@
 """
-MODULE: DATA EXPLORATION (ADVANCED EDA) - CORRIGÉ
-=================================================
-Correction : Ajout du 'Smart Getter' pour lier l'ETL aux graphiques.
+MODULE: DATA EXPLORATION (ADVANCED EDA) - FUSION COMPLÈTE
+=========================================================
+Version complète : fusionne ton EDA existant + Quality Gates + Caching + Reporting
+Compatible avec : Validation_Contract.py, Indicateurs_DQ.py, st.session_state
 """
+
 import streamlit as st
 import pandas as pd
 import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
+from io import StringIO
 
-# Imports Data Science (avec sécurité si statsmodels n'est pas installé)
+# Stats avancées (optionnelles)
 try:
     import statsmodels.api as sm
     from statsmodels.tsa.seasonal import seasonal_decompose
     from statsmodels.graphics.tsaplots import acf, pacf
     STATS_AVAILABLE = True
-except ImportError:
+except Exception:
     STATS_AVAILABLE = False
 
-# Import du Contrat
-# AVANT : from Function.Validation_Contract import ETL_Engine
-# APRÈS :
 from module.Validation_Contract import ETL_Engine
 
-# Remplacez la définition de la classe et la méthode load_data par ceci :
 
-class AdvancedAnalyzer:  # <--- RENOMMAGE ICI
+class AdvancedAnalyzer:
+    """EDA avancée : Smart Getter, Quality Gates, Visuals, TS, Export"""
+
     def __init__(self, gspread_client, sheet_name):
         self.etl = ETL_Engine(gspread_client, sheet_name)
         self.dataframes = {}
 
+    # ------------------ A. CACHING / LOAD ------------------
+    @st.cache_data(show_spinner=False)
+    def _cached_run_etl(self):
+        return self.etl.run_etl()
+
     def load_data(self):
-        """Récupère les données depuis l'ETL (DataExplorer Container) ou lance l'ETL"""
-        # 1. Si l'ETL a déjà stocké les données dans la session 'data_explorer'
+        """Récupère DataExplorer depuis session ou lance l'ETL (cached)"""
+        # Priorité : session global
         if 'data_explorer' in st.session_state and hasattr(st.session_state.data_explorer, 'dataframes'):
             self.dataframes = st.session_state.data_explorer.dataframes
             return True
 
-        # 2. Sinon, on lance l'ETL nous-mêmes
-        success, result = self.etl.run_etl()
+        # Sinon, lancer ETL (cached)
+        success, result = self._cached_run_etl()
         if success:
-            self.dataframes = result.dataframes # result est le DataExplorer de l'ETL
+            self.dataframes = result.dataframes
             return True
         return False
 
-    # --- LE CŒUR DE LA CORRECTION : SMART GETTER ---
+    # ------------------ SMART GETTER ------------------
     def get_df(self, keyword):
-        """
-        Cherche une table qui contient le mot-clé.
-        Ex: 'stock' trouvera 'stock_materiel_jour'
-        """
+        """Trouve une table par mot-clé (exact / partiel)."""
         if not self.dataframes:
             return None
-            
-        # 1. Essai exact
+        # exact
         if keyword in self.dataframes:
             return self.dataframes[keyword]
-            
-        # 2. Essai partiel (Smart Match)
-        for key, df in self.dataframes.items():
-            if keyword in key:
+        # smart partial match
+        for k, df in self.dataframes.items():
+            if keyword in k:
+                return df
+        # case-insensitive partial
+        for k, df in self.dataframes.items():
+            if keyword.lower() in k.lower():
                 return df
-                
         return None
 
+    # ------------------ B. QUALITY GATES & REPORT ------------------
+    def quality_report(self, df, keys_to_check=None):
+        """Génère un rapport qualité sommaire et un score (0-100)."""
+        report = {}
+        report['rows'] = len(df)
+        # moyenne du pourcentage manquant par colonne
+        report['missing_pct_mean'] = float(df.isnull().mean().mean() * 100)
+        # top missing columns
+        top_missing = (df.isnull().mean() * 100).sort_values(ascending=False).head(10)
+        report['top_missing'] = top_missing.to_dict()
+        report['duplicates'] = int(df.duplicated().sum())
+        report['unique_rows'] = int(df.drop_duplicates().shape[0])
+        report['numeric_cols'] = len(df.select_dtypes(include='number').columns)
+        # referential nulls check
+        if keys_to_check:
+            for k in keys_to_check:
+                if k in df.columns:
+                    report[f'{k}_nulls'] = int(df[k].isnull().sum())
+        # Score simple
+        score = 100 - report['missing_pct_mean'] - min(report['duplicates'] * 0.02, 20)
+        report['quality_score'] = round(max(0, score), 2)
+        return report
 
-    # --- Matrice de missing values (heatmap)
-    
-    def plot_missing_matrix(self, table_keyword=''):
-        
-        df = self.get_df(table_keyword) if table_keyword else next(iter(self.dataframes.values()))
-        
-        if df is None:
-            
-            st.warning("Table introuvable pour missing matrix.")
-            
+    # ------------------ C. EDA VISUALS ------------------
+    def plot_missing_matrix(self, df, name):
+        """Affiche bar chart des colonnes les plus manquantes.
+        Si >40 colonnes : affiche message et top 40 seulement."""
+        miss = (df.isnull().mean() * 100).sort_values(ascending=False)
+        if miss.empty or miss.max() == 0:
+            st.success('✅ Aucune valeur manquante détectée')
             return
-            
-        miss = df.isnull().astype(int)
-        
-        # réduire si trop large
-        
-        if miss.shape[1] > 40:
-            
-            st.warning("Beaucoup de colonnes (>40) — afficher un résumé des top colonnes manquantes.")
-            
-        col_missing = (miss.sum().sort_values(ascending=False) / len(df) * 100).head(40)
-        df_plot = pd.DataFrame({'col': col_missing.index, 'pct_missing': col_missing.values})
-        fig = px.bar(df_plot, x='col', y='pct_missing', title=f"Colonnes les plus manquantes ({table_keyword or 'table'})", text='pct_missing')
-        fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+        if len(miss) > 40:
+            st.warning('Beaucoup de colonnes détectées — affichage des top 40 colonnes manquantes')
+            miss = miss.head(40)
+        fig = px.bar(x=miss.index, y=miss.values, labels={'x': 'Colonne', 'y': '% manquante'},
+                     title=f'Colonnes manquantes (%) — {name}')
+        fig.update_traces(texttemplate='%{y:.1f}%', textposition='outside')
         fig.update_layout(xaxis_tickangle=-45)
         st.plotly_chart(fig, use_container_width=True)
 
-    # --- Distribution numérique + boxplot résumé
-
-    
-    def plot_numeric_summary(self, table_keyword, top_n=8):
-        df = self.get_df(table_keyword)
-        if df is None: return
+    def plot_numeric_summary(self, df, top_n=8):
+        """Histogram + box + descriptive stats pour les colonnes numériques (top_n)."""
         num_cols = df.select_dtypes(include='number').columns.tolist()
         if not num_cols:
-            st.info("Aucune colonne numérique.")
+            st.info('Aucune colonne numérique pour cette table.')
             return
         num_cols = num_cols[:top_n]
         for col in num_cols:
-            c1, c2 = st.columns([2,1])
+            c1, c2 = st.columns([3, 1])
             with c1:
-                fig = px.histogram(df, x=col, nbins=60, marginal='box', title=f"Distribution : {col}")
+                fig = px.histogram(df, x=col, nbins=60, title=f'Distribution — {col}', marginal='box')
                 st.plotly_chart(fig, use_container_width=True)
             with c2:
                 st.write(df[col].describe().to_frame().T)
 
-
-    #----Corrélation (heatmap) pour numériques
-    
-    def plot_correlation(self, table_keyword):
-        df = self.get_df(table_keyword)
-        if df is None: return
-        num = df.select_dtypes(include='number').dropna(axis=1, how='all')
+    def plot_correlation(self, df, name):
+        num = df.select_dtypes(include='number')
         if num.shape[1] < 2:
-            st.info("Pas assez de colonnes numériques pour corrélation.")
+            st.info('Pas assez de colonnes numériques pour une heatmap de corrélation')
             return
         corr = num.corr()
-        fig = px.imshow(corr, text_auto=".2f", title=f"Heatmap corrélations ({table_keyword})")
+        fig = px.imshow(corr, text_auto='.2f', title=f'Corrélations — {name}')
         st.plotly_chart(fig, use_container_width=True)
 
-    # ----- Vérification d'intégrité référentielle (join rates)
-    
+    def plot_outliers_iqr(self, df, name, max_plots=6):
+        """Détecte outliers via IQR et affiche boxplots des top numeric cols."""
+        num = df.select_dtypes(include='number')
+        if num.shape[1] == 0:
+            st.info('Pas de colonnes numériques pour détection outliers.')
+            return
+        cols = num.columns.tolist()[:max_plots]
+        for col in cols:
+            q1 = df[col].quantile(0.25)
+            q3 = df[col].quantile(0.75)
+            iqr = q3 - q1
+            low = q1 - 1.5 * iqr
+            high = q3 + 1.5 * iqr
+            num_out = ((df[col] < low) | (df[col] > high)).sum()
+            st.markdown(f'**{col}** — outliers IQR: {int(num_out):,}')
+            fig = px.box(df, y=col, title=f'Outliers (IQR) — {col}')
+            st.plotly_chart(fig, use_container_width=True)
+
+    # ------------------ Referential / Duplicates / Top values ------------------
     def referential_check(self, left_table, right_table, key='patient_id'):
-        left = self.get_df(left_table); right = self.get_df(right_table)
+        left = self.get_df(left_table)
+        right = self.get_df(right_table)
         if left is None or right is None:
-            st.warning("Tables introuvables pour check référentiel.")
+            st.warning('Tables introuvables pour vérification référentielle')
+            return
+        if key not in left.columns or key not in right.columns:
+            st.warning(f'Clé {key} absente dans l une des tables')
             return
         left_keys = set(left[key].dropna().unique())
         right_keys = set(right[key].dropna().unique())
         in_left_not_right = len(left_keys - right_keys)
         in_right_not_left = len(right_keys - left_keys)
-        st.write(f"- Clés {key} dans {left_table}: {len(left_keys):,}")
-        st.write(f"- Clés {key} dans {right_table}: {len(right_keys):,}")
-        st.metric("Dans left mais pas right", f"{in_left_not_right:,}")
-        st.metric("Dans right mais pas left", f"{in_right_not_left:,}")
+        st.write(f'- Clés {key} dans {left_table}: {len(left_keys):,}')
+        st.write(f'- Clés {key} dans {right_table}: {len(right_keys):,}')
+        st.metric('Dans left mais pas right', f'{in_left_not_right:,}')
+        st.metric('Dans right mais pas left', f'{in_right_not_left:,}')
 
+    def duplicates_and_top_values(self, table_keyword, cat_top=5):
+        df = self.get_df(table_keyword)
+        if df is None:
+            st.warning('Table introuvable')
+            return
+        st.markdown('### 🔎 Doublons et top valeurs')
+        full_dups = df.duplicated().sum()
+        st.write(f'Doublons lignes exactes: {int(full_dups):,}')
+        if 'patient_id' in df.columns:
+            pid_dups = df['patient_id'].duplicated().sum()
+            st.write(f'Doublons patient_id: {int(pid_dups):,}')
 
-    # --- VUES ANALYTIQUES AVANCÉES ---
+        # Top valeurs pour catégories
+        cats = df.select_dtypes(include=['object', 'category']).columns.tolist()[:cat_top]
+        for col in cats:
+            st.write(f'**{col}**')
+            st.dataframe(df[col].value_counts().head(10).to_frame(name='count'))
 
+    # ------------------ TIME SERIES ADVANCED ------------------
     def tab_time_series_advanced(self):
-        st.markdown("### 📈 Analyse Avancée des Séries Temporelles (STL)")
-        
-        # UTILISATION DU SMART GETTER
+        st.markdown('### 📈 Analyse Avancée des Séries Temporelles (STL)')
         df_adm = self.get_df('admissions')
-        
-        if df_adm is None: 
-            st.warning("⚠️ Table 'admissions' introuvable.")
+        if df_adm is None:
+            st.warning("Table 'admissions' introuvable.")
             return
-
         if not STATS_AVAILABLE:
-            st.error("Module 'statsmodels' manquant. Installez-le pour voir la décomposition STL.")
+            st.error("Module 'statsmodels' manquant. Installez-le pour la décomposition STL.")
             return
-
-        # Préparation TS : Aggrégation par jour
         try:
-            df_ts = df_adm.groupby('date')['nb_admissions'].sum().asfreq('D').fillna(0)
-            
-            if len(df_ts) < 30:
-                st.warning("Pas assez de données pour une décomposition STL (min 30 jours).")
+            df_ts = df_adm.set_index('date').sort_index()
+            # ensure numeric target exists
+            if 'nb_admissions' not in df_ts.columns:
+                st.warning('Colonne nb_admissions manquante')
                 return
-
-            # DÉCOMPOSITION STL
-            decomposition = seasonal_decompose(df_ts, model='additive', period=7)
-            
+            series = df_ts['nb_admissions'].resample('D').sum().fillna(0)
+            if len(series) < 30:
+                st.warning('Pas assez de points pour STL (min 30)')
+                return
+            decomposition = seasonal_decompose(series, model='additive', period=7)
             fig = make_subplots(rows=4, cols=1, shared_xaxes=True,
                                 subplot_titles=("Observé", "Tendance", "Saisonnalité", "Résidus"))
-            
-            fig.add_trace(go.Scatter(x=df_ts.index, y=decomposition.observed, name='Observé', line=dict(color='#58a6ff')), row=1, col=1)
-            fig.add_trace(go.Scatter(x=df_ts.index, y=decomposition.trend, name='Tendance', line=dict(color='#00E676', width=2)), row=2, col=1)
-            fig.add_trace(go.Scatter(x=df_ts.index, y=decomposition.seasonal, name='Saisonnalité', line=dict(color='#ff6b9d')), row=3, col=1)
-            fig.add_trace(go.Scatter(x=df_ts.index, y=decomposition.resid, name='Bruit', mode='markers', marker=dict(color='gray', size=3)), row=4, col=1)
-            
-            fig.update_layout(height=800, title_text="Décomposition STL des Admissions")
+            fig.add_trace(go.Scatter(x=series.index, y=decomposition.observed, name='Observé'), row=1, col=1)
+            fig.add_trace(go.Scatter(x=series.index, y=decomposition.trend, name='Tendance'), row=2, col=1)
+            fig.add_trace(go.Scatter(x=series.index, y=decomposition.seasonal, name='Saisonnalité'), row=3, col=1)
+            fig.add_trace(go.Scatter(x=series.index, y=decomposition.resid, name='Résidus', mode='markers'), row=4, col=1)
+            fig.update_layout(height=800, title_text='Décomposition STL des Admissions')
             st.plotly_chart(fig, use_container_width=True)
-            
         except Exception as e:
-            st.error(f"Erreur calcul STL : {e}")
+            st.error(f'Erreur calcul STL : {e}')
 
     def tab_stationarity(self):
-        st.markdown("### 📊 Analyse de Stationnarité (ACF/PACF)")
-        
+        st.markdown('### 📊 Stationnarité (ACF / PACF)')
         df_adm = self.get_df('admissions')
-        if df_adm is None: return
-        
+        if df_adm is None:
+            return
         if not STATS_AVAILABLE:
-            st.warning("Statsmodels requis.")
+            st.warning('Statsmodels requis pour ACF/PACF')
             return
-
-        df_ts = df_adm.groupby('date')['nb_admissions'].sum().fillna(0)
-
         try:
-            lag_count = 40
-            acf_vals = acf(df_ts, nlags=lag_count)
-            pacf_vals = pacf(df_ts, nlags=lag_count)
-            
+            series = df_adm.set_index('date')['nb_admissions'].resample('D').sum().fillna(0)
+            lag_count = min(60, max(20, int(len(series) / 2)))
+            acf_vals = acf(series, nlags=lag_count)
+            pacf_vals = pacf(series, nlags=lag_count)
             col1, col2 = st.columns(2)
             with col1:
                 fig_acf = go.Figure()
-                fig_acf.add_trace(go.Bar(x=list(range(len(acf_vals))), y=acf_vals, name='ACF', marker_color='#58a6ff'))
-                fig_acf.update_layout(title="Autocorrélation (ACF)", xaxis_title="Lag (Jours)")
+                fig_acf.add_trace(go.Bar(x=list(range(len(acf_vals))), y=acf_vals, name='ACF'))
+                fig_acf.update_layout(title='Autocorrélation (ACF)', xaxis_title='Lag')
                 st.plotly_chart(fig_acf, use_container_width=True)
-                
             with col2:
                 fig_pacf = go.Figure()
-                fig_pacf.add_trace(go.Bar(x=list(range(len(pacf_vals))), y=pacf_vals, name='PACF', marker_color='#ff6b9d'))
-                fig_pacf.update_layout(title="Autocorrélation Partielle (PACF)", xaxis_title="Lag (Jours)")
+                fig_pacf.add_trace(go.Bar(x=list(range(len(pacf_vals))), y=pacf_vals, name='PACF'))
+                fig_pacf.update_layout(title='Autocorrélation partielle (PACF)', xaxis_title='Lag')
                 st.plotly_chart(fig_pacf, use_container_width=True)
-                
         except Exception as e:
-            st.error(f"Erreur ACF/PACF : {e}")
+            st.error(f'Erreur ACF/PACF : {e}')
 
     def tab_heatmap_flux(self):
-        st.markdown("### 🔥 Heatmap des Flux d'Entrée")
-        
+        st.markdown('### 🔥 Heatmap des Flux d\'Entrée')
         df_adm = self.get_df('admissions')
-        if df_adm is None: return
-        
+        if df_adm is None:
+            return
         try:
-            df_adm['day_name'] = df_adm['date'].dt.day_name()
-            df_adm['month'] = df_adm['date'].dt.month_name()
-            
-            heatmap_data = df_adm.pivot_table(index='day_name', columns='month', values='nb_admissions', aggfunc='mean')
-            
-            days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
-            heatmap_data = heatmap_data.reindex(days)
-            
-            fig = px.imshow(heatmap_data, 
-                            labels=dict(x="Mois", y="Jour", color="Moyenne Adm."),
-                            color_continuous_scale="Viridis",
-                            title="Intensité Hebdo vs Mensuelle")
+            tmp = df_adm.copy()
+            tmp['day_name'] = tmp['date'].dt.day_name()
+            tmp['month'] = tmp['date'].dt.month_name()
+            heat = tmp.pivot_table(index='day_name', columns='month', values='nb_admissions', aggfunc='mean')
+            days = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
+            # try both cases for month ordering
+            heat = heat.reindex(days)
+            fig = px.imshow(heat, labels=dict(x='Mois', y='Jour', color='Moyenne Adm.'), title='Intensité Hebdo vs Mensuelle')
             st.plotly_chart(fig, use_container_width=True)
         except Exception as e:
-            st.error(f"Erreur Heatmap : {e}")
+            st.error(f'Erreur Heatmap : {e}')
+
+    # ------------------ D. EXPORTS & REPORTS ------------------
+    def export_csv(self, df):
+        return df.to_csv(index=False)
+
+    def export_quality_report(self, report):
+        # report est dict ; on transforme en csv simple
+        rows = []
+        for k, v in report.items():
+            if isinstance(v, dict):
+                rows.append({ 'metric': k, 'value': str(v) })
+            else:
+                rows.append({ 'metric': k, 'value': v })
+        df = pd.DataFrame(rows)
+        return df.to_csv(index=False)
+
 
-# Remplacez toute la fonction show_terminal par ceci :
+# ------------------ UI ENTRYPOINT ------------------
 
-def show_terminal(client, sheet_name):
-    """Point d'entrée principal"""
-    
-    # ON UTILISE UNE CLÉ DIFFÉRENTE ICI ('advanced_analyzer')
+def show_terminal(client, sheet_name, gates_blocking=False):
+    """Affiche l'UI EDA complète en onglets.
+    gates_blocking: si True, bloque certaines vues si quality_score < threshold
+    """
     if 'advanced_analyzer' not in st.session_state:
         st.session_state.advanced_analyzer = AdvancedAnalyzer(client, sheet_name)
-    
-    explorer = st.session_state.advanced_analyzer
-    
-    st.markdown("## 🔬 DATA LAB : ANALYSE AVANCÉE")
-    
-    # CHARGEMENT AUTO
-    if not explorer.dataframes:
-        with st.spinner("🔄 Liaison avec les données ETL..."):
-            success = explorer.load_data()
-            if success:
-                st.rerun()
-            else:
-                st.error("Échec du chargement. Lancez d'abord 'ETL Control'.")
+
+    analyzer = st.session_state.advanced_analyzer
+    st.markdown('## 🔬 DATA LAB : ANALYSE AVANCÉE')
+
+    # LOAD
+    if not analyzer.dataframes:
+        with st.spinner('🔄 Liaison avec l ETL...'):
+            if not analyzer.load_data():
+                st.error('❌ Échec ETL — vérifiez Validation_Contract')
                 return
+            st.rerun()
+
+    # Tabs
+    tabs = st.tabs(["📈 STL Décomposition", "📊 Stationnarité (ACF)", "🔥 Heatmap Flux", "📋 Table & DQ", "🧾 Export & Rapport"]) 
+
+    # Tab 0: STL
+    with tabs[0]:
+        analyzer.tab_time_series_advanced()
+
+    # Tab 1: Stationnarité
+    with tabs[1]:
+        analyzer.tab_stationarity()
+
+    # Tab 2: Heatmap Flux
+    with tabs[2]:
+        analyzer.tab_heatmap_flux()
+
+    # Tab 3: Table & DQ
+    with tabs[3]:
+        st.markdown('### 📋 Exploration par table')
+        table_choice = st.selectbox('Choisir une table', list(analyzer.dataframes.keys()))
+        df = analyzer.dataframes[table_choice]
+
+        # Quality
+        q = analyzer.quality_report(df, keys_to_check=['patient_id'] if 'patient_id' in df.columns else None)
+        st.metric('Quality Score', f"{q['quality_score']:.1f} / 100")
+        st.json({k: v for k, v in q.items() if k not in ['top_missing']})
+        if q.get('top_missing'):
+            st.markdown('**Top colonnes manquantes :**')
+            st.write(pd.Series(q['top_missing']).to_frame('pct_missing'))
+
+        # Gates informative
+        if gates_blocking and q['quality_score'] < 50:
+            st.error('⚠️ Quality gates critiques — affichage limité')
+        # Visuals
+        analyzer.plot_missing_matrix(df, table_choice)
+        analyzer.plot_numeric_summary(df)
+        analyzer.plot_correlation(df, table_choice)
+        analyzer.plot_outliers_iqr(df, table_choice)
+        analyzer.duplicates_and_top_values(table_choice)
+
+        # Referential checks quick buttons
+        cols = list(analyzer.dataframes.keys())
+        if 'patients' in cols and 'sejours' in cols:
+            if st.button('Vérifier référentiel patients <-> sejours'):
+                analyzer.referential_check('patients', 'sejours', key='patient_id')
+
+    # Tab 4: Export & Report
+    with tabs[4]:
+        st.markdown('### 🧾 Export & Rapports')
+        table_choice = st.selectbox('Table à exporter', list(analyzer.dataframes.keys()), key='export_table')
+        df = analyzer.dataframes[table_choice]
+        csv = analyzer.export_csv(df)
+        st.download_button('📥 Télécharger CSV (table)', csv, f'{table_choice}.csv', 'text/csv')
+
+        # quality report
+        qrep = analyzer.quality_report(df)
+        qcsv = analyzer.export_quality_report(qrep)
+        st.download_button('📥 Télécharger rapport qualité', qcsv, f'{table_choice}_quality_report.csv', 'text/csv')
+
+        # small EDA snapshot
+        if st.button('Générer snapshot EDA (top columns)'):
+            # build a small summary
+            summary = {
+                'table': table_choice,
+                'rows': len(df),
+                'cols': df.shape[1],
+                'quality_score': qrep['quality_score']
+            }
+            st.json(summary)
+
+    # Debugging panel (always accessible)
+    st.markdown('---')
+    with st.expander('Debug : tables disponibles'):
+        st.write(list(analyzer.dataframes.keys()))
+        for k, v in analyzer.dataframes.items():
+            st.write(f"- {k}: {v.shape[0]:,} lignes, {v.shape[1]} colonnes")
+
 
-    # Tabs Senior Data Scientist
-    tabs = st.tabs(["📈 STL Décomposition", "📊 Stationnarité (ACF)", "🔥 Heatmap Flux", "📋 Données Propres"])
-    
-    with tabs[0]: explorer.tab_time_series_advanced()
-    with tabs[1]: explorer.tab_stationarity()
-    with tabs[2]: explorer.tab_heatmap_flux()
-    
-    # Onglet Debug
-    with tabs[3]: 
-        st.info(f"Tables disponibles : {list(explorer.dataframes.keys())}")
-        if explorer.dataframes:
-            table_choice = st.selectbox("Choisir une table", list(explorer.dataframes.keys()))
-            st.dataframe(explorer.dataframes[table_choice], use_container_width=True)
+# EOF