updated

interface.py

@@ -22,126 +22,73 @@ class AgricultureInterface:
         self._initialize_data()
     
     def _initialize_data(self):
-        """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
+        """Initialise les données au démarrage"""
+        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")
     
     def refresh_data(self):
-        """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")
+        """Rafraîchit toutes les données"""
+        print("🔄 Rafraîchissement 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()
+            )
             
-            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")
+            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()
+            )
+        else:
+            return self._get_error_outputs("Aucune donnée disponible")
     
     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 (
-                f"❌ {error_message}",
-                empty_fig,
-                empty_fig,
-                empty_fig,
-                f"❌ {error_message}"
-            )
-        except:
-            # Fallback ultime si même la création d'erreur échoue
-            return (
-                "❌ Erreur critique",
-                None,
-                None,
-                None,
-                "❌ Erreur critique"
-            )
+        empty_fig = self.visualizer._create_error_plot("❌ Erreur", error_message)
+        return (
+            f"❌ {error_message}",
+            empty_fig,
+            empty_fig,
+            empty_fig,
+            f"❌ {error_message}"
+        )
     
     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"
+        return self.analyzer.get_summary_stats()
     
     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")
+        return self.visualizer.create_culture_analysis()
     
     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")
+        return self.visualizer.create_risk_distribution()
     
     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")
+        return self.visualizer.create_risk_visualization()
     
     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"
+        return self.analyzer.get_low_risk_recommendations()
     
     def create_interface(self):
         """Crée l'interface Gradio"""
@@ -189,219 +136,176 @@ class AgricultureInterface:
         return demo
     
     def _create_overview_tab(self):
-        """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")
+        """Crée l'onglet de vue d'ensemble"""
+        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())
     
     def _create_risk_analysis_tab(self):
-        """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 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**
-        - ✅ Historique d'usage herbicide minimal
-        - ✅ Pression adventice faible attendue
+        """Crée l'onglet d'analyse des risques"""
+        gr.Markdown("## Cartographie des risques adventices par parcelle")
         
-        ### Parcelles à Faible Risque (Vert clair)
-        - ⚠️ Surveillance légère recommandée
-        - ✅ Conviennent aux cultures sensibles avec précautions
+        self.risk_plot = gr.Plot(self._safe_create_risk_visualization())
         
-        ### Parcelles à Risque Modéré/Élevé (Orange/Rouge)
-        - ❌ Éviter pour cultures sensibles
-        - 🔍 Rotation nécessaire avant implantation
-        - 📈 Surveillance renforcée des adventices
+        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
         
-        ### Stratégies alternatives
-        - **Rotation longue**: 3-4 ans avant cultures sensibles
-        - **Cultures intermédiaires**: CIPAN pour réduire la pression
-        - **Techniques mécaniques**: Hersage, binage
-        - **Biostimulants**: Renforcement naturel des cultures
+        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 recommandations: {e}")
-            gr.Markdown("❌ Erreur lors de la création de l'interface de recommandations")
+    
+    def _create_recommendations_tab(self):
+        """Crée l'onglet des recommandations"""
+        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**
+    - ✅ Historique d'usage herbicide minimal
+    - ✅ Pression adventice faible attendue
+    
+    ### Parcelles à Faible Risque (Vert clair)
+    - ⚠️ Surveillance légère recommandée
+    - ✅ Conviennent aux cultures sensibles avec précautions
+    
+    ### Parcelles à Risque Modéré/Élevé (Orange/Rouge)
+    - ❌ Éviter pour cultures sensibles
+    - 🔍 Rotation nécessaire avant implantation
+    - 📈 Surveillance renforcée des adventices
+    
+    ### Stratégies alternatives
+    - **Rotation longue**: 3-4 ans avant cultures sensibles
+    - **Cultures intermédiaires**: CIPAN pour réduire la pression
+    - **Techniques mécaniques**: Hersage, binage
+    - **Biostimulants**: Renforcement naturel des cultures
+    """)
     
     def _create_data_viewer_tab(self):
         """Crée l'onglet de visualisation des données par année"""
-        try:
-            gr.Markdown("## 📋 Exploration des Données par Année")
-            
-            # Récupérer les années disponibles
-            available_years = self.visualizer.get_available_years()
-            
-            if not available_years:
-                gr.Markdown("❌ Aucune année disponible dans les données")
-                return
-            
-            # Ajouter une option "Toutes années"
-            year_choices = ["Toutes les années"] + [str(year) for year in available_years]
-            
-            # Interface de sélection
-            with gr.Row():
-                with gr.Column(scale=1):
-                    year_selector = gr.Dropdown(
-                        choices=year_choices,
-                        value="Toutes les années",
-                        label="🗓️ Sélectionnez une année",
-                        interactive=True
-                    )
-                
-                with gr.Column(scale=1):
-                    update_btn = gr.Button(
-                        "🔄 Actualiser la vue",
-                        variant="primary"
-                    )
-            
-            # Informations sur la sélection
-            self.data_info = gr.Markdown("📊 Sélectionnez une année pour voir les données")
+        gr.Markdown("## 📋 Exploration des Données par Année")
+        
+        # Récupérer les années disponibles
+        available_years = self.visualizer.get_available_years()
+        
+        if not available_years:
+            gr.Markdown("❌ Aucune année disponible dans les données")
+            return
+        
+        # Ajouter une option "Toutes années"
+        year_choices = ["Toutes les années"] + [str(year) for year in available_years]
+        
+        # Interface de sélection
+        with gr.Row():
+            with gr.Column(scale=1):
+                year_selector = gr.Dropdown(
+                    choices=year_choices,
+                    value="Toutes les années",
+                    label="🗓️ Sélectionnez une année",
+                    interactive=True
+                )
             
-            # Graphiques de résumé
-            with gr.Row():
-                with gr.Column():
-                    self.yearly_summary_plot = gr.Plot(
-                        self._safe_create_yearly_summary(None)
-                    )
-                
-                with gr.Column():
-                    self.monthly_activity_plot = gr.Plot(
-                        self._safe_create_monthly_activity(None)
-                    )
+            with gr.Column(scale=1):
+                update_btn = gr.Button(
+                    "🔄 Actualiser la vue",
+                    variant="primary"
+                )
+        
+        # Informations sur la sélection
+        self.data_info = gr.Markdown("📊 Sélectionnez une année pour voir les données")
+        
+        # Graphiques de résumé
+        with gr.Row():
+            with gr.Column():
+                self.yearly_summary_plot = gr.Plot(
+                    self._safe_create_yearly_summary(None)
+                )
             
-            # Tableau des données
-            gr.Markdown("### 📋 Tableau des Données")
-            self.data_table = gr.Dataframe(
-                value=self._safe_create_data_table(None)[0],
-                label="Données de la période sélectionnée",
-                interactive=False,
-                wrap=True,
-                max_rows=100
-            )
+            with gr.Column():
+                self.monthly_activity_plot = gr.Plot(
+                    self._safe_create_monthly_activity(None)
+                )
+        
+        # Tableau des données
+        gr.Markdown("### 📋 Tableau des Données")
+        self.data_table = gr.Dataframe(
+            value=self._safe_create_data_table(None)[0],
+            label="Données de la période sélectionnée",
+            interactive=False,
+            wrap=True,
+            max_rows=100
+        )
+        
+        # Fonction de mise à jour
+        def update_data_view(selected_year):
+            # Convertir la sélection
+            year = None if selected_year == "Toutes les années" else int(selected_year)
             
-            # Fonction de mise à jour
-            def update_data_view(selected_year):
-                try:
-                    # Convertir la sélection
-                    year = None if selected_year == "Toutes les années" else int(selected_year)
-                    
-                    # Générer les nouvelles vues
-                    data_table, info_msg = self._safe_create_data_table(year)
-                    summary_plot = self._safe_create_yearly_summary(year)
-                    monthly_plot = self._safe_create_monthly_activity(year)
-                    
-                    return (
-                        info_msg,
-                        summary_plot,
-                        monthly_plot,
-                        data_table
-                    )
-                    
-                except Exception as e:
-                    print(f"❌ Erreur lors de la mise à jour de la vue: {e}")
-                    error_plot = self.visualizer._create_error_plot(
-                        "❌ Erreur", 
-                        f"Impossible de mettre à jour: {str(e)[:50]}..."
-                    )
-                    return (
-                        f"❌ Erreur: {str(e)[:100]}...",
-                        error_plot,
-                        error_plot,
-                        None
-                    )
+            # Générer les nouvelles vues
+            data_table, info_msg = self._safe_create_data_table(year)
+            summary_plot = self._safe_create_yearly_summary(year)
+            monthly_plot = self._safe_create_monthly_activity(year)
             
-            # Connecter les événements
-            year_selector.change(
-                update_data_view,
-                inputs=[year_selector],
-                outputs=[
-                    self.data_info,
-                    self.yearly_summary_plot,
-                    self.monthly_activity_plot,
-                    self.data_table
-                ]
-            )
-            
-            update_btn.click(
-                update_data_view,
-                inputs=[year_selector],
-                outputs=[
-                    self.data_info,
-                    self.yearly_summary_plot,
-                    self.monthly_activity_plot,
-                    self.data_table
-                ]
+            return (
+                info_msg,
+                summary_plot,
+                monthly_plot,
+                data_table
             )
-            
-            gr.Markdown("""
-            ### 💡 Utilisation de l'onglet Données
-            
-            - **Sélection d'année** : Filtrez les données par millésime
-            - **Graphique des interventions** : Types d'interventions les plus fréquents
-            - **Activité mensuelle** : Répartition des interventions par mois
-            - **Tableau détaillé** : Données brutes avec colonnes importantes
-            
-            > 📝 **Note** : Le tableau est limité à 1000 lignes pour des raisons de performance
-            """)
-            
-        except Exception as e:
-            print(f"❌ Erreur lors de la création de l'onglet données: {e}")
-            gr.Markdown("❌ Erreur lors de la création de l'interface de données")
+        
+        # Connecter les événements
+        year_selector.change(
+            update_data_view,
+            inputs=[year_selector],
+            outputs=[
+                self.data_info,
+                self.yearly_summary_plot,
+                self.monthly_activity_plot,
+                self.data_table
+            ]
+        )
+        
+        update_btn.click(
+            update_data_view,
+            inputs=[year_selector],
+            outputs=[
+                self.data_info,
+                self.yearly_summary_plot,
+                self.monthly_activity_plot,
+                self.data_table
+            ]
+        )
+        
+        gr.Markdown("""
+        ### 💡 Utilisation de l'onglet Données
+        
+        - **Sélection d'année** : Filtrez les données par millésime
+        - **Graphique des interventions** : Types d'interventions les plus fréquents
+        - **Activité mensuelle** : Répartition des interventions par mois
+        - **Tableau détaillé** : Données brutes avec colonnes importantes
+        
+        > 📝 **Note** : Le tableau est limité à 1000 lignes pour des raisons de performance
+        """)
     
     def _safe_create_data_table(self, year):
-        """Crée le tableau de données avec gestion d'erreur"""
-        try:
-            return self.visualizer.create_data_table_by_year(year)
-        except Exception as e:
-            print(f"❌ Erreur dans create_data_table: {e}")
-            return None, f"❌ Erreur: {str(e)[:100]}..."
+        """Crée le tableau de données"""
+        return self.visualizer.create_data_table_by_year(year)
     
     def _safe_create_yearly_summary(self, year):
-        """Crée le résumé annuel avec gestion d'erreur"""
-        try:
-            return self.visualizer.create_yearly_summary_chart(year)
-        except Exception as e:
-            print(f"❌ Erreur dans create_yearly_summary: {e}")
-            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer le résumé")
+        """Crée le résumé annuel"""
+        return self.visualizer.create_yearly_summary_chart(year)
     
     def _safe_create_monthly_activity(self, year):
-        """Crée l'activité mensuelle avec gestion d'erreur"""
-        try:
-            return self.visualizer.create_monthly_activity_chart(year)
-        except Exception as e:
-            print(f"❌ Erreur dans create_monthly_activity: {e}")
-            return self.visualizer._create_error_plot("❌ Erreur", "Impossible de créer l'activité mensuelle")
+        """Crée l'activité mensuelle"""
+        return self.visualizer.create_monthly_activity_chart(year)
     
     def _create_about_tab(self):
         """Crée l'onglet à propos"""

main.py

@@ -1,12 +1,10 @@
 """
 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
-import sys
-import os
+from interface import AgricultureInterface
 
 # Suppression des warnings
 warnings.filterwarnings('ignore')
@@ -16,77 +14,13 @@ 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 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)")
+    """Fonction principale qui lance l'application"""
+    print("🌾 Démarrage de l'application d'analyse des adventices agricoles...")
     
-    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)
+    # Création et lancement de l'interface
+    app = AgricultureInterface()
+    app.launch()
 
 
 if __name__ == "__main__":

main_fallback.py

@@ -1,151 +0,0 @@
-"""
-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:
-            # Créer le dossier results s'il n'existe pas
-            import os
-            os.makedirs('results', exist_ok=True)
-            
-            # 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()