updated

analyzer.py

@@ -191,77 +191,161 @@ class AgricultureAnalyzer:
         return risk_analysis.sort_values(['Risk_Score', 'IFT_herbicide_approx'])
     
     def get_summary_stats(self):
-        """Retourne les statistiques de résumé"""
-        if self.df is None:
-            return "Aucune donnée disponible"
-        
-        stats_text = f"""
+        """Retourne les statistiques de résumé avec gestion d'erreur"""
+        try:
+            if self.df is None:
+                return "❌ Aucune donnée disponible"
+            
+            # Statistiques générales avec gestion d'erreur
+            try:
+                total_parcelles = self.df['numparcell'].nunique()
+                total_interventions = len(self.df)
+                surface_totale = self.df['surfparc'].sum()
+                surface_moyenne = self.df['surfparc'].mean()
+                periode_min = self.df['millesime'].min()
+                periode_max = self.df['millesime'].max()
+                
+                stats_text = f"""
         ## 📊 Statistiques Générales
-        - **Nombre total de parcelles**: {self.df['numparcell'].nunique()}
-        - **Nombre d'interventions**: {len(self.df):,}
-        - **Surface totale**: {self.df['surfparc'].sum():.2f} hectares
-        - **Surface moyenne par parcelle**: {self.df['surfparc'].mean():.2f} hectares
-        - **Période**: {self.df['millesime'].min()} - {self.df['millesime'].max()}
+        - **Nombre total de parcelles**: {total_parcelles}
+        - **Nombre d'interventions**: {total_interventions:,}
+        - **Surface totale**: {surface_totale:.2f} hectares
+        - **Surface moyenne par parcelle**: {surface_moyenne:.2f} hectares
+        - **Période**: {periode_min} - {periode_max}
         
         ## 🧪 Analyse Herbicides
         """
+            except Exception as e:
+                print(f"❌ Erreur dans les statistiques générales: {e}")
+                stats_text = """
+        ## 📊 Statistiques Générales
+        ❌ Erreur lors du calcul des statistiques générales
         
-        if 'familleprod' in self.df.columns:
-            herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
-            if len(herbicides_df) > 0:
-                stats_text += f"""
-        - **Interventions herbicides**: {len(herbicides_df)} ({(len(herbicides_df)/len(self.df)*100):.1f}%)
-        - **Parcelles traitées**: {herbicides_df['numparcell'].nunique()}
-        - **Produits herbicides différents**: {herbicides_df['produit'].nunique()}
+        ## 🧪 Analyse Herbicides
         """
-        
-        if self.risk_analysis is not None and len(self.risk_analysis) > 0:
-            risk_distribution = self.risk_analysis['Risque_adventice'].value_counts()
-            stats_text += f"""
+            
+            # Analyse des herbicides avec gestion d'erreur
+            try:
+                if 'familleprod' in self.df.columns:
+                    herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
+                    if len(herbicides_df) > 0:
+                        nb_herbicides = len(herbicides_df)
+                        pct_herbicides = (nb_herbicides/len(self.df)*100)
+                        parcelles_traitees = herbicides_df['numparcell'].nunique()
+                        
+                        if 'produit' in herbicides_df.columns:
+                            produits_uniques = herbicides_df['produit'].nunique()
+                            stats_text += f"""
+        - **Interventions herbicides**: {nb_herbicides} ({pct_herbicides:.1f}%)
+        - **Parcelles traitées**: {parcelles_traitees}
+        - **Produits herbicides différents**: {produits_uniques}
+        """
+                        else:
+                            stats_text += f"""
+        - **Interventions herbicides**: {nb_herbicides} ({pct_herbicides:.1f}%)
+        - **Parcelles traitées**: {parcelles_traitees}
+        """
+                    else:
+                        stats_text += "\n- **Aucune intervention herbicide détectée**"
+                else:
+                    stats_text += "\n- **Données d'herbicides non disponibles**"
+            except Exception as e:
+                print(f"❌ Erreur dans l'analyse des herbicides: {e}")
+                stats_text += "\n❌ Erreur lors de l'analyse des herbicides"
+            
+            # Analyse des risques avec gestion d'erreur
+            try:
+                if self.risk_analysis is not None and len(self.risk_analysis) > 0:
+                    risk_distribution = self.risk_analysis['Risque_adventice'].value_counts()
+                    stats_text += f"""
         
         ## 🎯 Répartition des Risques Adventices
         """
-            for risk_level in RISK_LEVELS:
-                if risk_level in risk_distribution:
-                    count = risk_distribution[risk_level]
-                    pct = (count / len(self.risk_analysis)) * 100
-                    stats_text += f"- **{risk_level}**: {count} parcelles ({pct:.1f}%)\n"
-        
-        return stats_text
+                    for risk_level in RISK_LEVELS:
+                        if risk_level in risk_distribution:
+                            count = risk_distribution[risk_level]
+                            pct = (count / len(self.risk_analysis)) * 100
+                            stats_text += f"- **{risk_level}**: {count} parcelles ({pct:.1f}%)\n"
+                else:
+                    stats_text += "\n\n❌ Analyse des risques non disponible"
+            except Exception as e:
+                print(f"❌ Erreur dans l'analyse des risques: {e}")
+                stats_text += "\n\n❌ Erreur lors de l'analyse des risques"
+            
+            return stats_text
+            
+        except Exception as e:
+            print(f"❌ Erreur critique dans get_summary_stats: {e}")
+            return "❌ Erreur critique lors de la génération des statistiques"
     
     def get_low_risk_recommendations(self):
-        """Retourne les recommandations pour les parcelles à faible risque"""
-        if self.risk_analysis is None:
-            return "Analyse des risques non disponible"
-        
-        low_risk = self.risk_analysis[
-            self.risk_analysis['Risque_adventice'].isin(['TRÈS FAIBLE', 'FAIBLE'])
-        ].head(10)
-        
-        recommendations = "## 🌾 TOP 10 - Parcelles Recommandées pour Cultures Sensibles (Pois, Haricot)\n\n"
-        
-        for idx, row in low_risk.iterrows():
-            if isinstance(idx, tuple) and len(idx) >= 4:
-                parcelle, nom, culture, surface = idx[:4]
-            else:
-                # Fallback si l'index n'est pas un tuple de 4 éléments
-                parcelle = str(idx)
-                nom = "N/A"
-                culture = "N/A"
-                surface = row.get('surfparc', 0) if 'surfparc' in row else 0
+        """Retourne les recommandations pour les parcelles à faible risque avec gestion d'erreur"""
+        try:
+            if self.risk_analysis is None or len(self.risk_analysis) == 0:
+                return "❌ Analyse des risques non disponible"
             
-            recommendations += f"""
+            try:
+                low_risk = self.risk_analysis[
+                    self.risk_analysis['Risque_adventice'].isin(['TRÈS FAIBLE', 'FAIBLE'])
+                ].head(10)
+                
+                if len(low_risk) == 0:
+                    return """## 🌾 Recommandations pour Cultures Sensibles
+                    
+❌ Aucune parcelle à faible risque trouvée.
+
+💡 **Suggestion**: Considérez une rotation plus longue ou des techniques alternatives pour réduire la pression adventice."""
+                
+                recommendations = "## 🌾 TOP 10 - Parcelles Recommandées pour Cultures Sensibles (Pois, Haricot)\n\n"
+                
+                for idx, row in low_risk.iterrows():
+                    try:
+                        if isinstance(idx, tuple) and len(idx) >= 4:
+                            parcelle, nom, culture, surface = idx[:4]
+                        else:
+                            # Fallback si l'index n'est pas un tuple de 4 éléments
+                            parcelle = str(idx)
+                            nom = "N/A"
+                            culture = "N/A"
+                            surface = row.get('surfparc', 0) if hasattr(row, 'get') else 0
+                        
+                        # Vérification des valeurs avec fallbacks
+                        risque = row.get('Risque_adventice', 'N/A') if hasattr(row, 'get') else 'N/A'
+                        ift = row.get('IFT_herbicide_approx', 0) if hasattr(row, 'get') else 0
+                        nb_herb = row.get('Nb_herbicides', 0) if hasattr(row, 'get') else 0
+                        
+                        recommendations += f"""
 **Parcelle {parcelle}** ({nom})
 - Culture actuelle: {culture}
 - Surface: {surface:.2f} ha
-- Niveau de risque: {row['Risque_adventice']}
-- IFT herbicide: {row['IFT_herbicide_approx']:.2f}
-- Nombre d'herbicides: {row.get('Nb_herbicides', 0)}
+- Niveau de risque: {risque}
+- IFT herbicide: {ift:.2f}
+- Nombre d'herbicides: {nb_herb}
 
 ---
 """
-        
-        return recommendations
+                    except Exception as e:
+                        print(f"❌ Erreur lors du traitement d'une parcelle: {e}")
+                        recommendations += f"""
+**Parcelle {str(idx)}**
+❌ Erreur lors du traitement des données de cette parcelle
+
+---
+"""
+                
+                return recommendations
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la génération des recommandations: {e}")
+                return """## 🌾 Recommandations pour Cultures Sensibles
+                
+❌ Erreur lors de la génération des recommandations.
+
+💡 **Suggestion**: Vérifiez la qualité des données et relancez l'analyse."""
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans get_low_risk_recommendations: {e}")
+            return "❌ Erreur critique lors de la génération des recommandations"
     
     def get_risk_analysis(self):
         """Retourne l'analyse des risques"""

data_loader.py

@@ -15,53 +15,78 @@ class DataLoader:
         self.df = None
     
     def load_data(self):
-        """Charge les données du dataset Hugging Face"""
-        print(MESSAGES["loading"])
-        print(f"📋 Dataset ID: {DATASET_ID}")
-        print(f"📋 Token disponible: {'Oui' if HF_TOKEN else 'Non'}")
-
-        self.df = None
-
-        # 1) Tentative de chargement direct via datasets.load_dataset
+        """Charge les données du dataset Hugging Face avec gestion d'erreur robuste"""
         try:
-            dataset = load_dataset(
-                DATASET_ID,
-                split="train",
-                token=HF_TOKEN,
-                trust_remote_code=True,
-            )
-            print(f"📊 Dataset chargé: {len(dataset)} exemples")
+            print(MESSAGES["loading"])
+            print(f"📋 Dataset ID: {DATASET_ID}")
+            print(f"📋 Token disponible: {'Oui' if HF_TOKEN else 'Non'}")
 
+            self.df = None
+
+            # 1) Tentative de chargement direct via datasets.load_dataset
             try:
-                self.df = dataset.to_pandas()
-                print("✅ Conversion to_pandas() réussie")
-            except Exception as pandas_error:
-                print(f"❌ Erreur to_pandas(): {pandas_error}")
-                print("🔄 Tentative de conversion manuelle...")
-                data_list = []
-                for i, item in enumerate(dataset):
-                    data_list.append(item)
-                    if i < 5:
-                        print(f"📋 Exemple {i}: {list(item.keys())}")
-                self.df = pd.DataFrame(data_list)
-                print(f"✅ Conversion manuelle réussie: {len(self.df)} lignes")
-        except Exception as e:
-            print(f"❌ Erreur lors du chargement depuis Hugging Face: {str(e)}")
-            print(f"❌ Type d'erreur: {type(e).__name__}")
-            # 2) Fallback: récupérer directement les fichiers du repo
-            fallback_msg = self._fallback_load_from_repo_files()
+                print("🔄 Tentative de chargement direct...")
+                dataset = load_dataset(
+                    DATASET_ID,
+                    split="train",
+                    token=HF_TOKEN,
+                    trust_remote_code=True,
+                )
+                print(f"📊 Dataset chargé: {len(dataset)} exemples")
+
+                try:
+                    self.df = dataset.to_pandas()
+                    print("✅ Conversion to_pandas() réussie")
+                except Exception as pandas_error:
+                    print(f"❌ Erreur to_pandas(): {pandas_error}")
+                    print("🔄 Tentative de conversion manuelle...")
+                    
+                    try:
+                        data_list = []
+                        max_examples = min(len(dataset), 1000)  # Limiter pour éviter les problèmes de mémoire
+                        
+                        for i, item in enumerate(dataset):
+                            if i >= max_examples:
+                                break
+                            data_list.append(item)
+                            if i < 5:
+                                print(f"📋 Exemple {i}: {list(item.keys())}")
+                        
+                        self.df = pd.DataFrame(data_list)
+                        print(f"✅ Conversion manuelle réussie: {len(self.df)} lignes")
+                    except Exception as manual_error:
+                        print(f"❌ Erreur lors de la conversion manuelle: {manual_error}")
+                        self.df = None
+                        
+            except Exception as e:
+                print(f"❌ Erreur lors du chargement depuis Hugging Face: {str(e)}")
+                print(f"❌ Type d'erreur: {type(e).__name__}")
+                
+                # 2) Fallback: récupérer directement les fichiers du repo
+                try:
+                    fallback_msg = self._fallback_load_from_repo_files()
+                    if self.df is None and fallback_msg:
+                        return f"❌ Erreur lors du chargement du dataset : {str(e)} | Fallback: {fallback_msg}"
+                except Exception as fallback_error:
+                    print(f"❌ Erreur dans le fallback: {fallback_error}")
+                    # Continue vers le chargement local
+
+            # Si on n'a toujours pas de dataframe, arrêter
             if self.df is None:
-                return f"❌ Erreur lors du chargement du dataset : {str(e)} | Fallback: {fallback_msg}"
+                print("⚠️ Aucune méthode de chargement n'a fonctionné")
+                return MESSAGES["no_data"]
 
-        # Si on n'a toujours pas de dataframe, arrêter
-        if self.df is None:
-            return MESSAGES["no_data"]
+            print(f"📊 Données chargées: {len(self.df)} lignes")
+            print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
 
-        print(f"📊 Données chargées: {len(self.df)} lignes")
-        print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
-
-        # Nettoyage et validation
-        return self._clean_and_validate_data()
+            # Nettoyage et validation
+            return self._clean_and_validate_data()
+            
+        except Exception as e:
+            print(f"❌ Erreur critique dans load_data: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Erreur critique lors du chargement: {str(e)}"
     
     def _clean_and_validate_data(self):
         """Nettoie et valide les données chargées"""

interface.py

@@ -22,43 +22,126 @@ class AgricultureInterface:
         self._initialize_data()
     
     def _initialize_data(self):
-        """Initialise les données au démarrage"""
-        self.data_loader.load_data()
-        if self.data_loader.has_data():
-            self.analyzer.set_data(self.data_loader.get_data())
-            self.analyzer.analyze_data()
-            self.visualizer.set_data(
-                self.data_loader.get_data(), 
-                self.analyzer.get_risk_analysis()
-            )
+        """Initialise les données au démarrage avec gestion d'erreur"""
+        try:
+            print("🔄 Initialisation des données...")
+            self.data_loader.load_data()
+            if self.data_loader.has_data():
+                self.analyzer.set_data(self.data_loader.get_data())
+                self.analyzer.analyze_data()
+                self.visualizer.set_data(
+                    self.data_loader.get_data(), 
+                    self.analyzer.get_risk_analysis()
+                )
+                print("✅ Initialisation réussie")
+            else:
+                print("⚠️ Aucune donnée disponible au démarrage")
+        except Exception as e:
+            print(f"❌ Erreur lors de l'initialisation: {e}")
+            # L'application peut continuer même si l'initialisation échoue
     
     def refresh_data(self):
-        """Rafraîchit toutes les données"""
-        self.data_loader.load_data()
-        if self.data_loader.has_data():
-            self.analyzer.set_data(self.data_loader.get_data())
-            self.analyzer.analyze_data()
-            self.visualizer.set_data(
-                self.data_loader.get_data(), 
-                self.analyzer.get_risk_analysis()
-            )
-            return (
-                self.analyzer.get_summary_stats(),
-                self.visualizer.create_culture_analysis(),
-                self.visualizer.create_risk_distribution(),
-                self.visualizer.create_risk_visualization(),
-                self.analyzer.get_low_risk_recommendations()
-            )
-        else:
-            # Retourner des valeurs par défaut si pas de données
-            empty_fig = self.visualizer.create_culture_analysis()  # Créera un graphique vide
+        """Rafraîchit toutes les données avec gestion d'erreur robuste"""
+        try:
+            print("🔄 Rafraîchissement des données...")
+            
+            # Chargement des données
+            try:
+                self.data_loader.load_data()
+            except Exception as e:
+                print(f"❌ Erreur lors du chargement: {e}")
+                return self._get_error_outputs("Erreur lors du chargement des données")
+            
+            if self.data_loader.has_data():
+                try:
+                    # Analyse des données
+                    self.analyzer.set_data(self.data_loader.get_data())
+                    self.analyzer.analyze_data()
+                    self.visualizer.set_data(
+                        self.data_loader.get_data(), 
+                        self.analyzer.get_risk_analysis()
+                    )
+                    
+                    # Génération des outputs avec gestion d'erreur individuelle
+                    return (
+                        self._safe_get_summary_stats(),
+                        self._safe_create_culture_analysis(),
+                        self._safe_create_risk_distribution(),
+                        self._safe_create_risk_visualization(),
+                        self._safe_get_recommendations()
+                    )
+                    
+                except Exception as e:
+                    print(f"❌ Erreur lors de l'analyse: {e}")
+                    return self._get_error_outputs(f"Erreur lors de l'analyse: {str(e)[:100]}...")
+            else:
+                print("⚠️ Aucune donnée disponible après chargement")
+                return self._get_error_outputs("Aucune donnée disponible")
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans refresh_data: {e}")
+            return self._get_error_outputs("Erreur critique lors du rafraîchissement")
+    
+    def _get_error_outputs(self, error_message):
+        """Retourne des outputs d'erreur standardisés"""
+        try:
+            empty_fig = self.visualizer._create_error_plot("❌ Erreur", error_message)
             return (
-                "❌ Aucune donnée disponible",
+                f"❌ {error_message}",
                 empty_fig,
                 empty_fig,
                 empty_fig,
-                "❌ Aucune recommandation disponible"
+                f"❌ {error_message}"
             )
+        except:
+            # Fallback ultime si même la création d'erreur échoue
+            return (
+                "❌ Erreur critique",
+                None,
+                None,
+                None,
+                "❌ Erreur critique"
+            )
+    
+    def _safe_get_summary_stats(self):
+        """Récupère les statistiques avec gestion d'erreur"""
+        try:
+            return self.analyzer.get_summary_stats()
+        except Exception as e:
+            print(f"❌ Erreur dans get_summary_stats: {e}")
+            return "❌ Erreur lors de la génération des statistiques"
+    
+    def _safe_create_culture_analysis(self):
+        """Crée l'analyse des cultures avec gestion d'erreur"""
+        try:
+            return self.visualizer.create_culture_analysis()
+        except Exception as e:
+            print(f"❌ Erreur dans create_culture_analysis: {e}")
+            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer l'analyse des cultures")
+    
+    def _safe_create_risk_distribution(self):
+        """Crée la distribution des risques avec gestion d'erreur"""
+        try:
+            return self.visualizer.create_risk_distribution()
+        except Exception as e:
+            print(f"❌ Erreur dans create_risk_distribution: {e}")
+            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer la distribution des risques")
+    
+    def _safe_create_risk_visualization(self):
+        """Crée la visualisation des risques avec gestion d'erreur"""
+        try:
+            return self.visualizer.create_risk_visualization()
+        except Exception as e:
+            print(f"❌ Erreur dans create_risk_visualization: {e}")
+            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer la visualisation des risques")
+    
+    def _safe_get_recommendations(self):
+        """Récupère les recommandations avec gestion d'erreur"""
+        try:
+            return self.analyzer.get_low_risk_recommendations()
+        except Exception as e:
+            print(f"❌ Erreur dans get_low_risk_recommendations: {e}")
+            return "❌ Erreur lors de la génération des recommandations"
     
     def create_interface(self):
         """Crée l'interface Gradio"""
@@ -103,37 +186,46 @@ class AgricultureInterface:
         return demo
     
     def _create_overview_tab(self):
-        """Crée l'onglet de vue d'ensemble"""
-        gr.Markdown("## Statistiques générales des données agricoles")
-        
-        self.stats_output = gr.Markdown(self.analyzer.get_summary_stats())
-        
-        with gr.Row():
-            self.culture_plot = gr.Plot(self.visualizer.create_culture_analysis())
-            self.risk_dist_plot = gr.Plot(self.visualizer.create_risk_distribution())
+        """Crée l'onglet de vue d'ensemble avec gestion d'erreur"""
+        try:
+            gr.Markdown("## Statistiques générales des données agricoles")
+            
+            self.stats_output = gr.Markdown(self._safe_get_summary_stats())
+            
+            with gr.Row():
+                self.culture_plot = gr.Plot(self._safe_create_culture_analysis())
+                self.risk_dist_plot = gr.Plot(self._safe_create_risk_distribution())
+        except Exception as e:
+            print(f"❌ Erreur lors de la création de l'onglet vue d'ensemble: {e}")
+            gr.Markdown("❌ Erreur lors de la création de l'interface")
     
     def _create_risk_analysis_tab(self):
-        """Crée l'onglet d'analyse des risques"""
-        gr.Markdown("## Cartographie des risques adventices par parcelle")
-        
-        self.risk_plot = gr.Plot(self.visualizer.create_risk_visualization())
-        
-        gr.Markdown("""
-        **Interprétation du graphique**:
-        - **Axe X**: Surface de la parcelle (hectares)
-        - **Axe Y**: IFT Herbicide approximatif 
-        - **Couleur**: Niveau de risque adventice
-        - **Taille**: Nombre d'herbicides utilisés
-        
-        Les parcelles vertes (risque faible) sont idéales pour les cultures sensibles.
-        """)
+        """Crée l'onglet d'analyse des risques avec gestion d'erreur"""
+        try:
+            gr.Markdown("## Cartographie des risques adventices par parcelle")
+            
+            self.risk_plot = gr.Plot(self._safe_create_risk_visualization())
+            
+            gr.Markdown("""
+            **Interprétation du graphique**:
+            - **Axe X**: Surface de la parcelle (hectares)
+            - **Axe Y**: IFT Herbicide approximatif 
+            - **Couleur**: Niveau de risque adventice
+            - **Taille**: Nombre d'herbicides utilisés
+            
+            Les parcelles vertes (risque faible) sont idéales pour les cultures sensibles.
+            """)
+        except Exception as e:
+            print(f"❌ Erreur lors de la création de l'onglet analyse des risques: {e}")
+            gr.Markdown("❌ Erreur lors de la création de l'interface d'analyse des risques")
     
     def _create_recommendations_tab(self):
-        """Crée l'onglet des recommandations"""
-        self.reco_output = gr.Markdown(self.analyzer.get_low_risk_recommendations())
-        
-        gr.Markdown("""
-        ## 💡 Conseils pour la gestion des adventices
+        """Crée l'onglet des recommandations avec gestion d'erreur"""
+        try:
+            self.reco_output = gr.Markdown(self._safe_get_recommendations())
+            
+            gr.Markdown("""
+            ## 💡 Conseils pour la gestion des adventices
         
         ### Parcelles à Très Faible Risque (Vertes)
         - ✅ **Idéales pour pois et haricot**
@@ -155,6 +247,9 @@ class AgricultureInterface:
         - **Techniques mécaniques**: Hersage, binage
         - **Biostimulants**: Renforcement naturel des cultures
         """)
+        except Exception as e:
+            print(f"❌ Erreur lors de la création de l'onglet recommandations: {e}")
+            gr.Markdown("❌ Erreur lors de la création de l'interface de recommandations")
     
     def _create_about_tab(self):
         """Crée l'onglet à propos"""

main.py

@@ -1,10 +1,12 @@
 """
 Point d'entrée principal de l'application d'analyse des adventices agricoles
+Avec détection automatique des problèmes et fallback
 """
 import warnings
 import matplotlib.pyplot as plt
 import seaborn as sns
-from interface import AgricultureInterface
+import sys
+import os
 
 # Suppression des warnings
 warnings.filterwarnings('ignore')
@@ -14,13 +16,77 @@ plt.style.use('default')
 sns.set_palette("husl")
 
 
+def try_gradio_interface():
+    """Essaie de lancer l'interface Gradio"""
+    try:
+        print("🔄 Tentative de lancement de l'interface Gradio...")
+        from interface import AgricultureInterface
+        
+        app = AgricultureInterface()
+        app.launch()
+        return True
+        
+    except ImportError as e:
+        print(f"❌ Erreur d'import: {e}")
+        if "pyaudioop" in str(e) or "audioop" in str(e):
+            print("🔍 Problème détecté: Dépendance audio manquante pour Gradio")
+        return False
+        
+    except Exception as e:
+        print(f"❌ Erreur lors du lancement de Gradio: {e}")
+        return False
+
+
+def run_fallback():
+    """Lance le mode fallback sans Gradio"""
+    try:
+        print("🔄 Basculement vers le mode fallback...")
+        from main_fallback import run_analysis_without_ui
+        
+        return run_analysis_without_ui()
+        
+    except Exception as e:
+        print(f"❌ Erreur dans le mode fallback: {e}")
+        return False
+
+
 def main():
-    """Fonction principale qui lance l'application"""
-    print("🌾 Démarrage de l'application d'analyse des adventices agricoles...")
+    """Fonction principale avec gestion d'erreur et fallback automatique"""
+    print("🌾 Application d'Analyse des Adventices Agricoles")
+    print("=" * 60)
+    
+    # Tentative 1: Interface Gradio complète
+    print("\n🎯 Tentative 1: Interface web avec Gradio")
+    
+    try:
+        if try_gradio_interface():
+            return  # Succès, on s'arrête ici
+    except KeyboardInterrupt:
+        print("\n⏹️  Arrêt demandé par l'utilisateur")
+        return
+    except Exception as e:
+        print(f"❌ Échec critique de l'interface Gradio: {e}")
+    
+    # Tentative 2: Mode fallback console
+    print("\n🎯 Tentative 2: Mode console (fallback)")
     
-    # Création et lancement de l'interface
-    app = AgricultureInterface()
-    app.launch()
+    try:
+        if run_fallback():
+            print("\n✅ Mode fallback exécuté avec succès")
+            print("\n💡 Pour utiliser l'interface web, résolvez les problèmes de dépendances:")
+            print("   - Installez les dépendances audio manquantes")
+            print("   - Ou utilisez une version compatible de Gradio")
+        else:
+            print("\n❌ Échec du mode fallback")
+            exit(1)
+            
+    except KeyboardInterrupt:
+        print("\n⏹️  Arrêt demandé par l'utilisateur")
+        return
+    except Exception as e:
+        print(f"\n❌ Erreur critique dans le mode fallback: {e}")
+        print("🆘 Aucun mode disponible - vérifiez vos dépendances")
+        exit(1)
 
 
 if __name__ == "__main__":

main_fallback.py

@@ -0,0 +1,147 @@
+"""
+Version alternative de main.py qui fonctionne sans Gradio
+Pour les cas où les dépendances Gradio posent problème
+"""
+import warnings
+import matplotlib.pyplot as plt
+import seaborn as sns
+from data_loader import DataLoader
+from analyzer import AgricultureAnalyzer
+from visualizations import AgricultureVisualizer
+
+# Suppression des warnings
+warnings.filterwarnings('ignore')
+
+# Configuration des graphiques
+plt.style.use('default')
+sns.set_palette("husl")
+
+
+def run_analysis_without_ui():
+    """Exécute l'analyse sans interface utilisateur"""
+    print("🌾 Analyse des Adventices Agricoles - Mode Console")
+    print("=" * 60)
+    
+    try:
+        # Initialisation des composants
+        print("🔄 Initialisation des composants...")
+        data_loader = DataLoader()
+        analyzer = AgricultureAnalyzer()
+        visualizer = AgricultureVisualizer()
+        
+        # Chargement des données
+        print("\n📊 Chargement des données...")
+        result = data_loader.load_data()
+        if isinstance(result, str) and "❌" in result:
+            print(f"Erreur: {result}")
+            return False
+        
+        if not data_loader.has_data():
+            print("❌ Aucune donnée disponible")
+            return False
+        
+        data = data_loader.get_data()
+        print(f"✅ {len(data)} enregistrements chargés")
+        
+        # Analyse des données
+        print("\n🔬 Analyse des données...")
+        analyzer.set_data(data)
+        general_stats, herbicide_stats = analyzer.analyze_data()
+        
+        if general_stats:
+            print("✅ Analyse générale terminée")
+            print(f"   - Parcelles: {general_stats['total_parcelles']}")
+            print(f"   - Interventions: {general_stats['total_interventions']}")
+            print(f"   - Surface totale: {general_stats['surface_totale']:.2f} ha")
+        
+        if herbicide_stats:
+            print("✅ Analyse herbicides terminée")
+            print(f"   - Interventions herbicides: {herbicide_stats['nb_interventions_herbicides']}")
+            print(f"   - Pourcentage: {herbicide_stats['pourcentage_herbicides']:.1f}%")
+        
+        # Génération des statistiques
+        print("\n📋 Génération des statistiques...")
+        stats = analyzer.get_summary_stats()
+        print("✅ Statistiques générées")
+        
+        # Génération des recommandations
+        print("\n🎯 Génération des recommandations...")
+        recommendations = analyzer.get_low_risk_recommendations()
+        print("✅ Recommandations générées")
+        
+        # Sauvegarde des résultats
+        print("\n💾 Sauvegarde des résultats...")
+        try:
+            # Sauvegarde des statistiques
+            with open('results/stats_console.md', 'w', encoding='utf-8') as f:
+                f.write("# Analyse des Adventices Agricoles\n\n")
+                f.write(stats)
+                f.write("\n\n")
+                f.write(recommendations)
+            
+            # Sauvegarde de l'analyse des risques si disponible
+            risk_analysis = analyzer.get_risk_analysis()
+            if risk_analysis is not None and len(risk_analysis) > 0:
+                risk_analysis.to_csv('results/risk_analysis_console.csv')
+                print("✅ Analyse des risques sauvegardée (CSV)")
+            
+            print("✅ Résultats sauvegardés dans results/")
+            
+        except Exception as e:
+            print(f"⚠️ Erreur lors de la sauvegarde: {e}")
+        
+        # Tentative de génération des graphiques
+        print("\n📈 Tentative de génération des graphiques...")
+        try:
+            visualizer.set_data(data, analyzer.get_risk_analysis())
+            
+            # Les graphiques seront créés mais ne pourront pas être affichés en mode console
+            print("⚠️ Les graphiques sont générés mais ne peuvent pas être affichés en mode console")
+            print("💡 Utilisez main.py avec Gradio pour voir les visualisations interactives")
+            
+        except Exception as e:
+            print(f"⚠️ Impossible de générer les graphiques: {e}")
+        
+        print("\n🎉 Analyse terminée avec succès!")
+        print("\n📁 Fichiers générés:")
+        print("   - results/stats_console.md : Statistiques et recommandations")
+        print("   - results/risk_analysis_console.csv : Analyse détaillée des risques")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Erreur critique: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Fonction principale en mode fallback"""
+    print("🔧 Mode Fallback - Analyse sans interface Gradio")
+    
+    try:
+        # Tentative d'import de Gradio pour vérifier la disponibilité
+        try:
+            import gradio as gr
+            print("✅ Gradio disponible - vous pouvez utiliser main.py")
+            print("⚠️ Utilisation du mode fallback forcé")
+        except ImportError as e:
+            print(f"⚠️ Gradio non disponible: {e}")
+            print("🔄 Utilisation du mode console")
+    except Exception as e:
+        print(f"⚠️ Problème avec Gradio: {e}")
+        print("🔄 Utilisation du mode console")
+    
+    # Exécution de l'analyse
+    success = run_analysis_without_ui()
+    
+    if success:
+        print("\n✅ Mode fallback exécuté avec succès")
+    else:
+        print("\n❌ Échec du mode fallback")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

visualizations.py

@@ -19,162 +19,334 @@ class AgricultureVisualizer:
         if risk_analysis is not None:
             self.risk_analysis = risk_analysis
     
-    def create_risk_visualization(self):
-        """Crée la visualisation des risques"""
-        if self.risk_analysis is None or len(self.risk_analysis) == 0:
-            # Créer un graphique vide avec message d'erreur
-            fig = px.scatter(title="❌ Aucune donnée d'analyse des risques disponible")
+    def _create_error_plot(self, title, message):
+        """Crée un graphique d'erreur standardisé"""
+        try:
+            fig = px.scatter(title=title)
             fig.add_annotation(
-                text="Veuillez charger les données d'abord", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+                text=message, 
+                xref="paper", yref="paper", 
+                x=0.5, y=0.5, 
+                showarrow=False,
+                font=dict(size=14, color="red")
+            )
+            fig.update_layout(
+                width=PLOT_CONFIG.get("width", 700), 
+                height=PLOT_CONFIG.get("height", 400)
             )
             return fig
-        
-        risk_df = self.risk_analysis.reset_index()
-        
-        # Vérifier quelles colonnes sont disponibles pour hover_data
-        available_hover_cols = []
-        for col in ['nomparc', 'libelleusag']:
-            if col in risk_df.columns:
-                available_hover_cols.append(col)
-        
-        fig = px.scatter(
-            risk_df, 
-            x='surfparc', 
-            y='IFT_herbicide_approx',
-            color='Risque_adventice',
-            size='Nb_herbicides',
-            hover_data=available_hover_cols if available_hover_cols else None,
-            color_discrete_map=RISK_COLORS,
-            title="🎯 Analyse du Risque Adventice par Parcelle",
-            labels={
-                'surfparc': 'Surface de la parcelle (ha)',
-                'IFT_herbicide_approx': 'IFT Herbicide (approximatif)',
-                'Risque_adventice': 'Niveau de risque'
-            }
-        )
-        
-        fig.update_layout(
-            width=PLOT_CONFIG["width"], 
-            height=PLOT_CONFIG["height"], 
-            title_font_size=PLOT_CONFIG["title_font_size"]
-        )
-        return fig
+        except Exception as e:
+            print(f"❌ Erreur lors de la création du graphique d'erreur: {e}")
+            # Retourner un graphique minimal en cas d'échec total
+            return go.Figure().add_annotation(text="Erreur critique", x=0.5, y=0.5)
     
-    def create_culture_analysis(self):
-        """Analyse par type de culture"""
-        if self.df is None or len(self.df) == 0:
-            # Créer un graphique vide avec message d'erreur
-            fig = px.pie(title="❌ Aucune donnée disponible")
-            fig.add_annotation(
-                text="Veuillez charger les données d'abord", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+    def create_risk_visualization(self):
+        """Crée la visualisation des risques avec gestion d'erreur robuste"""
+        try:
+            if self.risk_analysis is None or len(self.risk_analysis) == 0:
+                return self._create_error_plot(
+                    "❌ Aucune donnée d'analyse des risques disponible",
+                    "Veuillez charger et analyser les données d'abord"
+                )
+            
+            try:
+                risk_df = self.risk_analysis.reset_index()
+                
+                # Vérifier les colonnes requises
+                required_cols = ['surfparc', 'IFT_herbicide_approx', 'Risque_adventice', 'Nb_herbicides']
+                missing_cols = [col for col in required_cols if col not in risk_df.columns]
+                
+                if missing_cols:
+                    return self._create_error_plot(
+                        f"❌ Colonnes manquantes: {missing_cols}",
+                        "Les données ne contiennent pas toutes les colonnes nécessaires"
+                    )
+                
+                # Vérifier quelles colonnes sont disponibles pour hover_data
+                available_hover_cols = []
+                for col in ['nomparc', 'libelleusag']:
+                    if col in risk_df.columns:
+                        available_hover_cols.append(col)
+                
+                # Nettoyer les données pour éviter les erreurs de plotting
+                risk_df = risk_df.dropna(subset=required_cols)
+                
+                if len(risk_df) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée valide après nettoyage",
+                        "Toutes les données contiennent des valeurs manquantes"
+                    )
+                
+                fig = px.scatter(
+                    risk_df, 
+                    x='surfparc', 
+                    y='IFT_herbicide_approx',
+                    color='Risque_adventice',
+                    size='Nb_herbicides',
+                    hover_data=available_hover_cols if available_hover_cols else None,
+                    color_discrete_map=RISK_COLORS,
+                    title="🎯 Analyse du Risque Adventice par Parcelle",
+                    labels={
+                        'surfparc': 'Surface de la parcelle (ha)',
+                        'IFT_herbicide_approx': 'IFT Herbicide (approximatif)',
+                        'Risque_adventice': 'Niveau de risque'
+                    }
+                )
+                
+                fig.update_layout(
+                    width=PLOT_CONFIG["width"], 
+                    height=PLOT_CONFIG["height"], 
+                    title_font_size=PLOT_CONFIG["title_font_size"]
+                )
+                return fig
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la création du graphique de risque: {e}")
+                return self._create_error_plot(
+                    "❌ Erreur lors de la création du graphique",
+                    f"Erreur technique: {str(e)[:100]}..."
+                )
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans create_risk_visualization: {e}")
+            return self._create_error_plot(
+                "❌ Erreur critique",
+                "Impossible de créer la visualisation des risques"
             )
-            return fig
-        
-        if 'libelleusag' not in self.df.columns:
-            fig = px.pie(title="❌ Colonne 'libelleusag' non disponible")
-            fig.add_annotation(
-                text="Les données de culture ne sont pas disponibles", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+    
+    def create_culture_analysis(self):
+        """Analyse par type de culture avec gestion d'erreur robuste"""
+        try:
+            if self.df is None or len(self.df) == 0:
+                return self._create_error_plot(
+                    "❌ Aucune donnée disponible",
+                    "Veuillez charger les données d'abord"
+                )
+            
+            if 'libelleusag' not in self.df.columns:
+                return self._create_error_plot(
+                    "❌ Colonne 'libelleusag' non disponible",
+                    "Les données de culture ne sont pas disponibles"
+                )
+            
+            try:
+                # Nettoyer les données de culture
+                culture_data = self.df['libelleusag'].dropna()
+                
+                if len(culture_data) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée de culture valide",
+                        "Toutes les valeurs de culture sont manquantes"
+                    )
+                
+                culture_counts = culture_data.value_counts()
+                
+                if len(culture_counts) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune culture détectée",
+                        "Aucune donnée de culture trouvée après nettoyage"
+                    )
+                
+                fig = px.pie(
+                    values=culture_counts.values, 
+                    names=culture_counts.index,
+                    title="🌱 Répartition des Cultures"
+                )
+                
+                fig.update_layout(width=700, height=500)
+                return fig
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la création du graphique de culture: {e}")
+                return self._create_error_plot(
+                    "❌ Erreur lors de la création du graphique",
+                    f"Erreur technique: {str(e)[:100]}..."
+                )
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans create_culture_analysis: {e}")
+            return self._create_error_plot(
+                "❌ Erreur critique",
+                "Impossible de créer l'analyse des cultures"
             )
-            return fig
-        
-        culture_counts = self.df['libelleusag'].value_counts()
-        
-        fig = px.pie(
-            values=culture_counts.values, 
-            names=culture_counts.index,
-            title="🌱 Répartition des Cultures"
-        )
-        
-        fig.update_layout(width=700, height=500)
-        return fig
     
     def create_risk_distribution(self):
-        """Distribution des niveaux de risque"""
-        if self.risk_analysis is None or len(self.risk_analysis) == 0:
-            # Créer un graphique vide avec message d'erreur
-            fig = px.bar(title="❌ Aucune analyse des risques disponible")
-            fig.add_annotation(
-                text="Veuillez charger les données d'abord", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+        """Distribution des niveaux de risque avec gestion d'erreur robuste"""
+        try:
+            if self.risk_analysis is None or len(self.risk_analysis) == 0:
+                return self._create_error_plot(
+                    "❌ Aucune analyse des risques disponible",
+                    "Veuillez charger et analyser les données d'abord"
+                )
+            
+            if 'Risque_adventice' not in self.risk_analysis.columns:
+                return self._create_error_plot(
+                    "❌ Colonne 'Risque_adventice' manquante",
+                    "L'analyse des risques est incomplète"
+                )
+            
+            try:
+                # Nettoyer les données de risque
+                risk_data = self.risk_analysis['Risque_adventice'].dropna()
+                
+                if len(risk_data) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée de risque valide",
+                        "Toutes les valeurs de risque sont manquantes"
+                    )
+                
+                risk_counts = risk_data.value_counts()
+                
+                if len(risk_counts) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucun niveau de risque détecté",
+                        "Aucune donnée de risque trouvée après nettoyage"
+                    )
+                
+                fig = px.bar(
+                    x=risk_counts.index, 
+                    y=risk_counts.values,
+                    color=risk_counts.index,
+                    color_discrete_map=RISK_COLORS,
+                    title="📊 Distribution des Niveaux de Risque Adventice",
+                    labels={'x': 'Niveau de risque', 'y': 'Nombre de parcelles'}
+                )
+                
+                fig.update_layout(width=700, height=500, showlegend=False)
+                return fig
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la création du graphique de distribution: {e}")
+                return self._create_error_plot(
+                    "❌ Erreur lors de la création du graphique",
+                    f"Erreur technique: {str(e)[:100]}..."
+                )
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans create_risk_distribution: {e}")
+            return self._create_error_plot(
+                "❌ Erreur critique",
+                "Impossible de créer la distribution des risques"
             )
-            return fig
-        
-        risk_counts = self.risk_analysis['Risque_adventice'].value_counts()
-        
-        fig = px.bar(
-            x=risk_counts.index, 
-            y=risk_counts.values,
-            color=risk_counts.index,
-            color_discrete_map=RISK_COLORS,
-            title="📊 Distribution des Niveaux de Risque Adventice",
-            labels={'x': 'Niveau de risque', 'y': 'Nombre de parcelles'}
-        )
-        
-        fig.update_layout(width=700, height=500, showlegend=False)
-        return fig
     
     def create_herbicide_timeline(self):
-        """Crée un graphique de l'évolution temporelle des herbicides"""
-        if self.df is None or len(self.df) == 0:
-            fig = px.line(title="❌ Aucune donnée disponible")
-            fig.add_annotation(
-                text="Veuillez charger les données d'abord", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
-            )
-            return fig
-        
-        if 'millesime' not in self.df.columns or 'familleprod' not in self.df.columns:
-            fig = px.line(title="❌ Colonnes nécessaires non disponibles")
-            fig.add_annotation(
-                text="Les données temporelles ne sont pas disponibles", 
-                xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+        """Crée un graphique de l'évolution temporelle des herbicides avec gestion d'erreur"""
+        try:
+            if self.df is None or len(self.df) == 0:
+                return self._create_error_plot(
+                    "❌ Aucune donnée disponible",
+                    "Veuillez charger les données d'abord"
+                )
+            
+            required_cols = ['millesime', 'familleprod']
+            missing_cols = [col for col in required_cols if col not in self.df.columns]
+            
+            if missing_cols:
+                return self._create_error_plot(
+                    f"❌ Colonnes manquantes: {missing_cols}",
+                    "Les données temporelles ne sont pas disponibles"
+                )
+            
+            try:
+                # Filtrer les herbicides et grouper par année
+                herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
+                if len(herbicides_df) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée d'herbicide disponible",
+                        "Aucune intervention herbicide trouvée dans les données"
+                    )
+                
+                agg_dict = {'numparcell': 'nunique'}
+                if 'quantitetot' in herbicides_df.columns:
+                    agg_dict['quantitetot'] = 'sum'
+                
+                yearly_herbicides = herbicides_df.groupby('millesime').agg(agg_dict).reset_index()
+                
+                if len(yearly_herbicides) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée temporelle valide",
+                        "Impossible de grouper les données par année"
+                    )
+                
+                y_col = 'quantitetot' if 'quantitetot' in yearly_herbicides.columns else 'numparcell'
+                y_label = 'Quantité totale d\'herbicides' if y_col == 'quantitetot' else 'Nombre de parcelles traitées'
+                
+                fig = px.line(
+                    yearly_herbicides,
+                    x='millesime',
+                    y=y_col,
+                    title="📈 Évolution de l'Usage des Herbicides par Année",
+                    labels={
+                        'millesime': 'Année',
+                        y_col: y_label
+                    }
+                )
+                
+                fig.update_layout(width=700, height=400)
+                return fig
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la création du graphique temporel: {e}")
+                return self._create_error_plot(
+                    "❌ Erreur lors de la création du graphique",
+                    f"Erreur technique: {str(e)[:100]}..."
+                )
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans create_herbicide_timeline: {e}")
+            return self._create_error_plot(
+                "❌ Erreur critique",
+                "Impossible de créer l'évolution temporelle"
             )
-            return fig
-        
-        # Filtrer les herbicides et grouper par année
-        herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
-        if len(herbicides_df) == 0:
-            fig = px.line(title="❌ Aucune donnée d'herbicide disponible")
-            return fig
-        
-        yearly_herbicides = herbicides_df.groupby('millesime').agg({
-            'numparcell': 'nunique',
-            'quantitetot': 'sum'
-        }).reset_index()
-        
-        fig = px.line(
-            yearly_herbicides,
-            x='millesime',
-            y='quantitetot',
-            title="📈 Évolution de l'Usage des Herbicides par Année",
-            labels={
-                'millesime': 'Année',
-                'quantitetot': 'Quantité totale d\'herbicides'
-            }
-        )
-        
-        fig.update_layout(width=700, height=400)
-        return fig
     
     def create_surface_analysis(self):
-        """Analyse de la distribution des surfaces"""
-        if self.df is None or len(self.df) == 0:
-            fig = px.histogram(title="❌ Aucune donnée disponible")
-            return fig
-        
-        fig = px.histogram(
-            self.df,
-            x='surfparc',
-            nbins=20,
-            title="📏 Distribution des Surfaces de Parcelles",
-            labels={
-                'surfparc': 'Surface (ha)',
-                'count': 'Nombre de parcelles'
-            }
-        )
-        
-        fig.update_layout(width=700, height=400)
-        return fig
+        """Analyse de la distribution des surfaces avec gestion d'erreur"""
+        try:
+            if self.df is None or len(self.df) == 0:
+                return self._create_error_plot(
+                    "❌ Aucune donnée disponible",
+                    "Veuillez charger les données d'abord"
+                )
+            
+            if 'surfparc' not in self.df.columns:
+                return self._create_error_plot(
+                    "❌ Colonne 'surfparc' manquante",
+                    "Les données de surface ne sont pas disponibles"
+                )
+            
+            try:
+                # Nettoyer les données de surface
+                surface_data = self.df['surfparc'].dropna()
+                
+                if len(surface_data) == 0:
+                    return self._create_error_plot(
+                        "❌ Aucune donnée de surface valide",
+                        "Toutes les valeurs de surface sont manquantes"
+                    )
+                
+                fig = px.histogram(
+                    x=surface_data,
+                    nbins=20,
+                    title="📏 Distribution des Surfaces de Parcelles",
+                    labels={
+                        'x': 'Surface (ha)',
+                        'count': 'Nombre de parcelles'
+                    }
+                )
+                
+                fig.update_layout(width=700, height=400)
+                return fig
+                
+            except Exception as e:
+                print(f"❌ Erreur lors de la création du graphique de surface: {e}")
+                return self._create_error_plot(
+                    "❌ Erreur lors de la création du graphique",
+                    f"Erreur technique: {str(e)[:100]}..."
+                )
+                
+        except Exception as e:
+            print(f"❌ Erreur critique dans create_surface_analysis: {e}")
+            return self._create_error_plot(
+                "❌ Erreur critique",
+                "Impossible de créer l'analyse des surfaces"
+            )