""" Module d'interface utilisateur avec Gradio """ import os # Désactiver les analytics Gradio dès le début os.environ["GRADIO_ANALYTICS_ENABLED"] = "False" import gradio as gr from data_loader import DataLoader from analyzer import AgricultureAnalyzer from visualizations import AgricultureVisualizer from config import GRADIO_CONFIG class AgricultureInterface: """Classe responsable de l'interface utilisateur Gradio""" def __init__(self): self.data_loader = DataLoader() self.analyzer = AgricultureAnalyzer() self.visualizer = AgricultureVisualizer() 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 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") 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 ( 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" ) 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""" with gr.Blocks(title="🌾 Analyse Adventices Agricoles CRA", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🌾 Analyse des Adventices Agricoles - CRA Bretagne **Objectif**: Anticiper et réduire la pression des adventices dans les parcelles agricoles bretonnes Cette application analyse les données historiques pour identifier les parcelles les plus adaptées à la culture de plantes sensibles comme le pois ou le haricot. """) with gr.Tabs(): with gr.TabItem("📊 Vue d'ensemble"): self._create_overview_tab() with gr.TabItem("🎯 Analyse des Risques"): self._create_risk_analysis_tab() with gr.TabItem("🌾 Recommandations"): self._create_recommendations_tab() with gr.TabItem("ℹ️ À propos"): self._create_about_tab() # Bouton de rafraîchissement refresh_btn = gr.Button("🔄 Actualiser les données", variant="secondary") # Connecter le bouton de rafraîchissement refresh_btn.click( self.refresh_data, outputs=[ self.stats_output, self.culture_plot, self.risk_dist_plot, self.risk_plot, self.reco_output ] ) 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") 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 ### 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 """) 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""" gr.Markdown(""" ## 🎯 Méthodologie Cette analyse se base sur : ### Calcul de l'IFT (Indice de Fréquence de Traitement) - **IFT ≈ Quantité appliquée / Surface de parcelle** - Indicateur de l'intensité des traitements herbicides ### Classification des risques - **TRÈS FAIBLE**: IFT = 0, aucun herbicide - **FAIBLE**: IFT < 1, usage minimal - **MODÉRÉ**: IFT < 3, usage modéré - **ÉLEVÉ**: IFT < 5, usage important - **TRÈS ÉLEVÉ**: IFT ≥ 5, usage intensif ### Données analysées - **Source**: Station Expérimentale de Kerguéhennec - **Période**: Campagne 2025 - **Variables**: Interventions, produits, quantités, surfaces --- **Développé pour le Hackathon CRA Bretagne** 🏆 *Application d'aide à la décision pour une agriculture durable* """) def launch(self): """Lance l'interface""" demo = self.create_interface() demo.launch(**GRADIO_CONFIG)