Spaces:
Sleeping
Sleeping
| """ | |
| 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) | |