Update src/module/AIP.py

src/module/AIP.py

@@ -1,9 +1,14 @@
 """
-MODULE JASMINE AGENT - VERSION OMNISCIENTE & PROACTIVE
-======================================================
-Responsabilité : Agent IA centralisé.
-Capacités : ETL, Dashboard, Data Lab, Data Quality.
-Ajout : Moteur de diagnostic proactif (Seuils d'alerte & Recommandations).
+MODULE JASMINE AGENT - VERSION ULTIME (FULL STACK INTEGRATION)
+==============================================================
+Responsabilité : Agent IA centralisé avec contrôle total sur la chaîne de données.
+Capacités : 
+1. ETL (Nettoyage)
+2. Dashboard (KPIs Présent)
+3. Data Lab (Exploration Passé)
+4. Data Quality (Audit Fiabilité)
+5. Feature Engineering (Préparation ML)
+6. Forecasting (Prédiction Futur & Alertes)
 """
 
 import google.generativeai as genai
@@ -16,16 +21,18 @@ import pandas as pd
 import numpy as np
 import traceback
 
-# --- IMPORT DES MODULES ---
+# --- IMPORT DES 6 MODULES CIBLES ---
 try:
     from module.Validation_Contract import ETL_Engine
     from module.Dashboard import HospitalDashboard
     from module.Data_Exploration import HospitalAdvancedAnalyzer
     from module.Indicateurs_DQ import HospitalDataQualityAnalyzer, load_from_google_sheets
+    from module.Features import FeatureEngineer
+    from module.Forecasting import HospitalForecaster
 except ImportError as e:
-    st.error(f"❌ Erreur d'importation des modules : {str(e)}")
+    st.error(f"❌ Erreur critique d'importation : {str(e)}")
 
-# --- STYLE GOTHAM (INCHANGÉ) ---
+# --- STYLE GOTHAM ---
 def apply_custom_styles():
     st.markdown("""
     <style>
@@ -57,6 +64,7 @@ class JasmineAgent:
         self.google_key = os.environ.get("GOOGLE_API_KEY")
         self.groq_key = os.environ.get("GROQ_API_KEY")
         
+        # Fallbacks
         if not self.google_key:
             try: self.google_key = st.secrets.get("GOOGLE_API_KEY")
             except: pass
@@ -74,14 +82,40 @@ class JasmineAgent:
             "llama-3.1-8b-instant"
         ]
         
+        # --- CARTE DES OUTILS ---
         self.tools_map = {
-            "run_etl_pipeline": {"func": self._run_etl_wrapper, "desc": "Mise à jour et nettoyage."},
-            "get_hospital_kpis": {"func": self._get_kpis_wrapper, "desc": "KPIs (Lits, RH, Stocks)."},
-            "analyze_patient_stats": {"func": self._get_data_exploration_wrapper, "desc": "Data Lab (Âge, Pathos)."},
-            "get_data_quality_report": {"func": self._get_dq_stats_wrapper, "desc": "Audit Qualité/Erreurs."}
+            "run_etl_pipeline": {
+                "func": self._run_etl_wrapper, 
+                "desc": "1. ETL : Nettoyage et mise à jour des données."
+            },
+            "run_feature_engineering": {
+                "func": self._run_features_wrapper,
+                "desc": "2. ML Prep : Transformation des données pour l'IA (Lags, Rolling)."
+            },
+            "train_forecasting_models": {
+                "func": self._train_models_wrapper,
+                "desc": "3. Training : Entraînement des modèles prédictifs (XGBoost/LightGBM)."
+            },
+            "get_future_forecast": {
+                "func": self._get_forecast_wrapper,
+                "desc": "4. Prédiction : Obtenir les prévisions futures et les alertes de saturation."
+            },
+            "get_hospital_kpis": {
+                "func": self._get_kpis_wrapper, 
+                "desc": "5. Dashboard : KPIs actuels (Lits, RH, Stocks)."
+            },
+            "analyze_patient_stats": {
+                "func": self._get_data_exploration_wrapper, 
+                "desc": "6. Data Lab : Stats patients passées."
+            },
+            "get_data_quality_report": {
+                "func": self._get_dq_stats_wrapper, 
+                "desc": "7. Audit : Qualité et fiabilité des données."
+            }
         }
 
-    # --- WRAPPERS TECHNIQUES (INCHANGÉS) ---
+    # --- WRAPPERS TECHNIQUES (LES BRAS DE L'IA) ---
+
     def _run_etl_wrapper(self, args=None):
         try:
             engine = ETL_Engine(self.gspread_client, sheet_name="bdd_mvp_faker")
@@ -89,13 +123,64 @@ class JasmineAgent:
             if success:
                 st.session_state.data_explorer = result
                 return {"status": "succès", "details": result.get_summary()}
-            return {"status": "erreur", "message": "Échec de l'exécution ETL."}
+            return {"status": "erreur", "message": "Échec ETL."}
+        except Exception as e: return {"status": "crash", "message": str(e)}
+
+    def _run_features_wrapper(self, args=None):
+        try:
+            if 'data_explorer' not in st.session_state:
+                return {"status": "erreur", "message": "Lancez l'ETL d'abord."}
+            
+            engineer = FeatureEngineer(st.session_state.data_explorer)
+            df_final, msg = engineer.build_full_dataset()
+            
+            if df_final is not None:
+                st.session_state['ml_features'] = df_final
+                return {"status": "succès", "details": {"lignes": len(df_final), "features": len(df_final.columns)}}
+            return {"status": "erreur", "message": msg}
+        except Exception as e: return {"status": "crash", "message": str(e)}
+
+    def _train_models_wrapper(self, args=None):
+        try:
+            if 'ml_features' not in st.session_state:
+                return {"status": "erreur", "message": "Aucune feature ML. Lancez 'run_feature_engineering'."}
+            
+            forecaster = HospitalForecaster(st.session_state['ml_features'])
+            forecaster.prepare_data(target_col='nb_admissions') # Cible par défaut
+            metrics = forecaster.train_all_models()
+            
+            st.session_state['forecaster'] = forecaster
+            st.session_state['metrics'] = metrics
+            
+            best_model = forecaster.best_model_name
+            return {"status": "succès", "details": {"best_model": best_model, "r2": metrics[best_model]['R²'], "mae": metrics[best_model]['MAE']}}
+        except Exception as e: return {"status": "crash", "message": str(e)}
+
+    def _get_forecast_wrapper(self, args=None):
+        try:
+            if 'forecaster' not in st.session_state:
+                return {"status": "erreur", "message": "Modèles non entraînés. Lancez 'train_forecasting_models'."}
+            
+            forecaster = st.session_state['forecaster']
+            # Prédiction sur 3 mois
+            dates, values, _ = forecaster.generate_future_forecast_recursive(months=3)
+            alerts = forecaster.detect_future_anomalies(values)
+            
+            return {
+                "status": "succès", 
+                "details": {
+                    "tendance": "Hausse" if values[-1] > values[0] else "Baisse",
+                    "max_prevu": float(np.max(values)),
+                    "alerte_count": len(alerts),
+                    "prochaine_alerte": alerts[0] if alerts else None
+                }
+            }
         except Exception as e: return {"status": "crash", "message": str(e)}
 
     def _get_kpis_wrapper(self, args=None):
         try:
             dash = HospitalDashboard(self.gspread_client, "bdd_mvp_faker")
-            if not dash.load_data(): return {"status": "erreur", "message": "Données Dashboard indisponibles."}
+            if not dash.load_data(): return {"status": "erreur", "message": "Data non chargées."}
             return {"status": "succès", "details": dash._get_kpis()}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
@@ -106,14 +191,11 @@ class JasmineAgent:
             df_pat = analyzer.get_df('patients')
             df_sej = analyzer.get_df('sejours')
             stats = {}
-            if df_pat is not None and not df_pat.empty:
+            if df_pat is not None:
                 df_pat['age'] = pd.to_numeric(df_pat['age'], errors='coerce')
                 stats['age_moyen'] = round(df_pat['age'].mean(), 1)
                 stats['total_patients'] = len(df_pat)
-                counts = df_pat['sexe'].value_counts(normalize=True)
-                stats['ratio_hommes'] = round(counts.get('M', 0) * 100, 1)
-                stats['ratio_femmes'] = round(counts.get('F', 0) * 100, 1)
-            if df_sej is not None and not df_sej.empty:
+            if df_sej is not None:
                 stats['pathologie_top'] = df_sej['pathologie_code'].mode()[0]
             return {"status": "succès", "details": stats}
         except Exception as e: return {"status": "crash", "message": str(e)}
@@ -121,61 +203,53 @@ class JasmineAgent:
     def _get_dq_stats_wrapper(self, args=None):
         try:
             raw_data = load_from_google_sheets(self.gspread_client, "bdd_mvp_faker")
-            dq_analyzer = HospitalDataQualityAnalyzer(raw_data)
-            scores = dq_analyzer.compute_global_score()
-            metrics = dq_analyzer.metrics
-            return {"status": "succès", "details": {"score": scores['global'], "completude": scores['completeness'], "anomalies": metrics['patients']['anomalies']}}
+            dq = HospitalDataQualityAnalyzer(raw_data)
+            scores = dq.compute_global_score()
+            return {"status": "succès", "details": {"score": scores['global'], "anomalies": dq.metrics['patients']['anomalies']}}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
-    # --- MOTEUR DE DIAGNOSTIC PROACTIF (NOUVEAU) ---
+    # --- MOTEUR DE DIAGNOSTIC ---
     def _generate_diagnostic(self, tool_name, data):
-        """Analyse les données pour générer des alertes et conseils automatiques"""
+        """Génère des insights basés sur les résultats"""
         alerts = []
         
         if tool_name == "get_hospital_kpis":
-            # 1. Occupation
             taux = float(data.get('taux_global', 0))
-            if taux >= 95:
-                alerts.append("🔴 **ALERTE CRITIQUE :** Saturation imminente (>95%). Activez le Plan Blanc et délestez les urgences.")
-            elif taux >= 85:
-                alerts.append("🟠 **ATTENTION :** Tensions fortes (>85%). Préparez des lits d'aval.")
-            
-            # 2. Stocks
-            ruptures = int(data.get('nb_ruptures', 0))
-            if ruptures > 0:
-                alerts.append(f"📦 **LOGISTIQUE :** {ruptures} matériels en rupture critique. Vérifiez les commandes urgentes.")
-            
-            # 3. RH (Correction visuelle des valeurs négatives si nécessaire)
-            tension_rh = float(data.get('tension_rh', 0))
-            if tension_rh > 20: # Seuil arbitraire de tension
-                alerts.append("🩺 **PERSONNEL :** Manque d'effectif critique. Rappel de personnel nécessaire.")
+            if taux >= 95: alerts.append("🔴 **CRITIQUE :** Saturation > 95%. Plan Blanc recommandé.")
+            elif taux >= 85: alerts.append("🟠 **ATTENTION :** Tensions fortes sur les lits.")
+            if int(data.get('nb_ruptures', 0)) > 0: alerts.append("📦 **STOCK :** Ruptures détectées.")
 
-        elif tool_name == "get_data_quality_report":
-            score = float(data.get('score', 0))
-            if score < 80:
-                alerts.append("📉 **FIABILITÉ :** Score de qualité faible (<80%). Les KPIs financiers risquent d'être faussés.")
-                if int(data.get('anomalies', 0)) > 100:
-                    alerts.append("👉 **ACTION :** Nettoyer la base Patients (nombreux doublons/erreurs détectés).")
+        elif tool_name == "get_future_forecast":
+            if data.get('alerte_count', 0) > 0:
+                next_alert = data['prochaine_alerte']
+                alerts.append(f"🔮 **PRÉVISION :** Pic d'activité anormal prévu à J+{next_alert['day']} (Valeur: {next_alert['value']:.0f}).")
+            if data.get('tendance') == "Hausse":
+                alerts.append("📈 **TENDANCE :** Les admissions sont sur une pente ascendante pour le trimestre à venir.")
 
-        if alerts:
-            return "\n\n" + "\n".join(alerts)
+        elif tool_name == "train_forecasting_models":
+            r2 = data.get('r2', 0)
+            if r2 > 0.8: alerts.append("✅ **IA PERFORMANCE :** Le modèle est très fiable (>80%).")
+            else: alerts.append("⚠️ **IA PERFORMANCE :** Fiabilité moyenne, prudence sur les prédictions.")
+
+        if alerts: return "\n\n" + "\n".join(alerts)
         return ""
 
-    # --- CORE LOGIC ---
+    # --- LOGIQUE PRINCIPALE ---
 
     def build_system_prompt(self):
         tools_desc = "\n".join([f"- {k}: {v['desc']}" for k, v in self.tools_map.items()])
         return f"""
-        ROLE: Tu es Jasmine, l'IA de supervision.
-        OUTILS DISPONIBLES :
+        ROLE: Tu es Jasmine, l'IA de supervision Hospitalière.
+        OUTILS :
         {tools_desc}
         RÈGLES :
-        1. Utilise les outils pour répondre aux faits.
-        2. Réponds TOUJOURS au format JSON :
+        1. Utilise 'get_future_forecast' pour les questions sur l'avenir.
+        2. Utilise 'train_forecasting_models' si l'utilisateur veut mettre à jour l'IA.
+        3. Réponds TOUJOURS en JSON :
         {{
-          "thought": "Ton analyse...",
+          "thought": "Raisonnement...",
           "tool": "nom_outil" (ou "none"),
-          "answer": "Ta réponse directe si tool=none",
+          "answer": "Réponse directe si tool=none",
           "args": {{}} 
         }}
         """
@@ -200,7 +274,7 @@ class JasmineAgent:
                 break 
             except: continue
 
-        if not response_payload: return "❌ Erreur de connexion API.", None, None
+        if not response_payload: return "❌ Erreur API.", None, None
 
         try:
             decision = json.loads(re.sub(r'```json\s*|\s*```', '', response_payload).strip())
@@ -211,32 +285,32 @@ class JasmineAgent:
                 res = self.tools_map[tool_name]["func"]({})
                 if res["status"] == "succès":
                     d = res["details"]
-                    
-                    # Génération du Diagnostic Proactif
                     diagnostic = self._generate_diagnostic(tool_name, d)
-
-                    # Affichage des Résultats
+                    
+                    # --- AFFICHAGE DES RÉSULTATS ---
                     if tool_name == "run_etl_pipeline":
-                        final_response = f"✅ **ETL Terminé.**\n🔹 Tables : {d['tables_loaded']}\n🔹 Lignes : {d['total_rows_clean']:,}"
+                        final_response = f"✅ **ETL :** {d['tables_loaded']} tables chargées | {d['total_rows_clean']:,} lignes."
+                    elif tool_name == "run_feature_engineering":
+                        final_response = f"⚙️ **Features :** {d['lignes']:,} vecteurs créés avec {d['features']} variables."
+                    elif tool_name == "train_forecasting_models":
+                        final_response = f"🧠 **Training :** Champion = {d['best_model']} (R²: {d['r2']*100:.1f}% | Erreur moy: {d['mae']:.1f})."
+                    elif tool_name == "get_future_forecast":
+                        final_response = f"🔮 **Oracle :** Tendance {d['tendance']} | Max prévu: {d['max_prevu']:.0f} admissions."
                     elif tool_name == "get_hospital_kpis":
-                        # Protection affichage RH (max pour éviter les -1700%)
-                        rh_display = max(0, d['tension_rh']) 
-                        final_response = f"📊 **KPIs Direction :**\n🔹 Occupation : {d['taux_global']:.1f}%\n🔹 Tension RH : {rh_display:.1f}%\n🔹 Admissions : {d['nb_adm']}\n🔹 Ruptures : {d['nb_ruptures']}"
+                        rh = max(0, d['tension_rh'])
+                        final_response = f"📊 **KPIs :** Lits {d['taux_global']:.1f}% | RH {rh:.1f}% | Stocks {d['nb_ruptures']} ruptures."
                     elif tool_name == "analyze_patient_stats":
-                        final_response = f"🔬 **Data Lab :**\n🔹 Pop : {d['total_patients']}\n🔹 Âge moy : {d['age_moyen']} ans\n🔹 H {d['ratio_hommes']}% | F {d['ratio_femmes']}%\n🔹 Top Patho : {d['pathologie_top']}"
+                        final_response = f"🔬 **Stats :** {d['total_patients']} patients | Âge {d['age_moyen']} ans | Top Patho: {d['pathologie_top']}."
                     elif tool_name == "get_data_quality_report":
-                        icon = "🟢" if d['score'] > 90 else "🔴"
-                        final_response = f"🛡️ **Qualité :** {icon} {d['score']}/100\n🔹 Complétude : {d['completude']}%\n🔹 Anomalies : {d['anomalies']}"
+                        final_response = f"🛡️ **Qualité :** Score {d['score']}/100 | {d['anomalies']} anomalies détectées."
                     
-                    # Injection du diagnostic s'il existe
-                    if diagnostic:
-                        final_response += diagnostic
-
-                else: final_response = f"⚠️ {res.get('message')}"
+                    if diagnostic: final_response += diagnostic
+                else:
+                    final_response = f"⚠️ **Erreur :** {res.get('message')}"
                 return final_response, thought, res
             
-            return decision.get("answer", "Analyse effectuée."), thought, None
-        except Exception as e: return f"Erreur décodage: {str(e)}", None, None
+            return decision.get("answer", "Je suis à l'écoute."), thought, None
+        except Exception as e: return f"Erreur système : {str(e)}", None, None
 
 def show_terminal(client, sheet_name="bdd_mvp_faker"):
     apply_custom_styles()
@@ -252,7 +326,7 @@ def show_terminal(client, sheet_name="bdd_mvp_faker"):
         if msg.get("data"):
             with st.expander("💾 SYSTEM PAYLOAD"): st.json(msg["data"])
     
-    user_input = st.chat_input("Ex: 'Audit Qualité' ou 'État des Urgences'...")
+    user_input = st.chat_input("Ex: 'Entraîne les modèles' ou 'Prévisions pour le mois prochain'...")
     if user_input:
         st.session_state.chat_history.append({"role": "user", "content": user_input})
         st.rerun()