updated

README.md

@@ -5,7 +5,7 @@ colorFrom: green
 colorTo: blue
 sdk: gradio
 sdk_version: "4.31.0"
-app_file: app.py
+app_file: main.py
 pinned: false
 license: mit
 ---
@@ -14,6 +14,61 @@ license: mit
 
 Application Gradio pour analyser et prédire la pression des adventices dans les parcelles agricoles bretonnes, développée pour le hackathon CRA.
 
+## 🏗️ Architecture du Projet
+
+### Structure des fichiers
+
+```
+data/
+├── __init__.py                 # Package Python
+├── main.py                     # Point d'entrée principal
+├── config.py                   # Configuration et constantes
+├── data_loader.py             # Chargement des données HuggingFace
+├── analyzer.py                # Analyse des données et calcul des risques
+├── visualizations.py          # Création des graphiques et visualisations
+├── interface.py               # Interface utilisateur Gradio
+├── app.py                     # [LEGACY] Ancien fichier monolithique
+├── app_simple.py              # Version simplifiée
+├── requirements.txt           # Dépendances Python
+├── sample_data.csv           # Données d'exemple
+└── results/                  # Résultats d'analyse
+    ├── risk_analysis.csv
+    └── risk_visualization.html
+```
+
+### Modules
+
+#### 🔧 `config.py`
+- Configuration centrale (tokens, URLs, constantes)
+- Paramètres des graphiques et de l'interface
+- Messages et textes de l'application
+
+#### 📊 `data_loader.py`
+- Classe `DataLoader` pour le chargement des données
+- Gestion des fallbacks (repo HF → fichiers locaux)
+- Nettoyage et validation des données
+
+#### 🧮 `analyzer.py`
+- Classe `AgricultureAnalyzer` pour l'analyse des données
+- Calcul des statistiques et de l'IFT herbicides
+- Classification des risques par parcelle
+- Génération des recommandations
+
+#### 📈 `visualizations.py`
+- Classe `AgricultureVisualizer` pour les graphiques
+- Visualisations Plotly interactives
+- Graphiques de risques, cultures, distributions
+
+#### 🖥️ `interface.py`
+- Classe `AgricultureInterface` pour l'UI Gradio
+- Organisation en onglets
+- Gestion des interactions utilisateur
+
+#### 🚀 `main.py`
+- Point d'entrée principal
+- Orchestration des composants
+- Lancement de l'application
+
 ## 🎯 Objectifs
 
 - Prédire la pression adventice sur chaque parcelle pour les 3 prochaines campagnes
@@ -26,4 +81,27 @@ Application Gradio pour analyser et prédire la pression des adventices dans les
 - Calcul de l'IFT herbicides approximatif
 - Classification des parcelles par niveau de risque
 - Visualisations interactives
-- Recommandations pour cultures sensibles
+- Recommandations pour cultures sensibles
+
+## 🚀 Utilisation
+
+### Lancement avec la nouvelle architecture
+
+```bash
+python main.py
+```
+
+### Lancement avec l'ancien fichier (rétrocompatibilité)
+
+```bash
+python app.py
+```
+
+## 🔄 Migration
+
+L'ancienne version monolithique (`app.py`) reste disponible pour la rétrocompatibilité. La nouvelle architecture modulaire offre :
+
+- **Meilleure maintenabilité** : Code séparé par responsabilité
+- **Réutilisabilité** : Modules indépendants
+- **Testabilité** : Tests unitaires plus faciles
+- **Extensibilité** : Ajout de nouvelles fonctionnalités simplifié

__init__.py

@@ -0,0 +1,7 @@
+"""
+Package d'analyse des adventices agricoles pour le CRA Bretagne
+"""
+
+__version__ = "1.0.0"
+__author__ = "CRA Bretagne"
+__description__ = "Application d'analyse des risques adventices pour l'agriculture durable"

analyzer.py

@@ -0,0 +1,268 @@
+"""
+Module d'analyse des données agricoles et calcul des risques
+"""
+import pandas as pd
+from config import OPTIONAL_GROUP_COLS, REQUIRED_COLUMNS, RISK_LEVELS
+
+
+class AgricultureAnalyzer:
+    """Classe responsable de l'analyse des données agricoles"""
+    
+    def __init__(self, data=None):
+        self.df = data
+        self.risk_analysis = None
+    
+    def set_data(self, data):
+        """Définit les données à analyser"""
+        self.df = data
+    
+    def analyze_data(self):
+        """Analyse des données et calcul des risques"""
+        if self.df is None or len(self.df) == 0:
+            print("❌ Pas de données à analyser")
+            return "Erreur: Aucune donnée chargée"
+        
+        try:
+            print(f"🔄 Début de l'analyse sur {len(self.df)} enregistrements...")
+            
+            # Analyse générale
+            general_stats = self._calculate_general_stats()
+            
+            # Analyse des herbicides
+            herbicide_stats = self._calculate_herbicide_stats()
+            
+            # Calcul de l'analyse des risques
+            self.calculate_risk_analysis()
+            
+            print("✅ Analyse terminée avec succès")
+            return general_stats, herbicide_stats
+            
+        except Exception as e:
+            print(f"❌ Erreur lors de l'analyse: {str(e)}")
+            return None, None
+    
+    def _calculate_general_stats(self):
+        """Calcule les statistiques générales"""
+        return {
+            'total_parcelles': self.df['numparcell'].nunique(),
+            'total_interventions': len(self.df),
+            'surface_totale': self.df['surfparc'].sum(),
+            'surface_moyenne': self.df['surfparc'].mean(),
+            'periode': f"{self.df['millesime'].min()} - {self.df['millesime'].max()}"
+        }
+    
+    def _calculate_herbicide_stats(self):
+        """Calcule les statistiques sur les herbicides"""
+        if 'familleprod' in self.df.columns:
+            herbicides_df = self.df[self.df['familleprod'] == 'Herbicides'].copy()
+            return {
+                'nb_interventions_herbicides': len(herbicides_df),
+                'pourcentage_herbicides': (len(herbicides_df) / len(self.df)) * 100,
+                'parcelles_traitees': herbicides_df['numparcell'].nunique()
+            }
+        else:
+            return {
+                'nb_interventions_herbicides': 0,
+                'pourcentage_herbicides': 0,
+                'parcelles_traitees': 0
+            }
+    
+    def calculate_risk_analysis(self):
+        """Calcule l'analyse des risques par parcelle"""
+        try:
+            print("🔄 Calcul de l'analyse des risques...")
+            
+            # Vérifier les colonnes nécessaires
+            required_group_cols = ['numparcell', 'surfparc']
+            
+            # Construire la liste des colonnes de groupement disponibles
+            group_cols = [col for col in required_group_cols if col in self.df.columns]
+            group_cols.extend([col for col in OPTIONAL_GROUP_COLS if col in self.df.columns])
+            
+            if len(group_cols) < 2:
+                print(f"❌ Colonnes insuffisantes pour le groupement: {group_cols}")
+                self.risk_analysis = pd.DataFrame()
+                return
+            
+            # Construire l'agrégation selon les colonnes disponibles
+            agg_dict = self._build_aggregation_dict()
+            
+            if not agg_dict:
+                print("❌ Aucune colonne disponible pour l'agrégation")
+                self.risk_analysis = pd.DataFrame()
+                return
+                
+            # Groupement des données par parcelle
+            risk_analysis = self.df.groupby(group_cols).agg(agg_dict).round(2)
+            
+            # Ajout des quantités d'herbicides spécifiques
+            risk_analysis = self._add_herbicide_quantities(risk_analysis, group_cols)
+            
+            # Renommage des colonnes
+            risk_analysis = self._rename_columns(risk_analysis, agg_dict)
+            
+            # Calcul de l'IFT approximatif
+            risk_analysis = self._calculate_ift(risk_analysis, group_cols)
+            
+            # Classification du risque
+            risk_analysis['Risque_adventice'] = risk_analysis.apply(self._classify_risk, axis=1)
+            
+            # Tri par risque
+            risk_analysis = self._sort_by_risk(risk_analysis)
+            
+            self.risk_analysis = risk_analysis
+            print(f"✅ Analyse des risques terminée: {len(self.risk_analysis)} parcelles analysées")
+            
+        except Exception as e:
+            print(f"❌ Erreur lors du calcul des risques: {str(e)}")
+            self.risk_analysis = pd.DataFrame()
+    
+    def _build_aggregation_dict(self):
+        """Construit le dictionnaire d'agrégation selon les colonnes disponibles"""
+        agg_dict = {}
+        if 'familleprod' in self.df.columns:
+            agg_dict['familleprod'] = lambda x: (x == 'Herbicides').sum()
+        if 'libevenem' in self.df.columns:
+            agg_dict['libevenem'] = lambda x: len(x.unique())
+        if 'produit' in self.df.columns:
+            agg_dict['produit'] = lambda x: len(x.unique())
+        if 'quantitetot' in self.df.columns:
+            agg_dict['quantitetot'] = 'sum'
+        return agg_dict
+    
+    def _add_herbicide_quantities(self, risk_analysis, group_cols):
+        """Ajoute les quantités d'herbicides spécifiques"""
+        if 'familleprod' in self.df.columns and 'quantitetot' in self.df.columns:
+            herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
+            if len(herbicides_df) > 0:
+                herbicide_quantities = herbicides_df.groupby(group_cols)['quantitetot'].sum().fillna(0)
+                risk_analysis['Quantite_herbicides'] = herbicide_quantities.reindex(risk_analysis.index, fill_value=0)
+            else:
+                risk_analysis['Quantite_herbicides'] = 0
+        else:
+            risk_analysis['Quantite_herbicides'] = 0
+        return risk_analysis
+    
+    def _rename_columns(self, risk_analysis, agg_dict):
+        """Renomme les colonnes de façon sécurisée"""
+        new_column_names = {}
+        if 'familleprod' in agg_dict:
+            new_column_names['familleprod'] = 'Nb_herbicides'
+        if 'libevenem' in agg_dict:
+            new_column_names['libevenem'] = 'Diversite_evenements'
+        if 'produit' in agg_dict:
+            new_column_names['produit'] = 'Diversite_produits'
+        if 'quantitetot' in agg_dict:
+            new_column_names['quantitetot'] = 'Quantite_totale'
+            
+        return risk_analysis.rename(columns=new_column_names)
+    
+    def _calculate_ift(self, risk_analysis, group_cols):
+        """Calcule l'IFT approximatif"""
+        if 'surfparc' in group_cols:
+            risk_analysis['IFT_herbicide_approx'] = (
+                risk_analysis['Quantite_herbicides'] / 
+                risk_analysis.index.get_level_values('surfparc')
+            ).round(2)
+        else:
+            risk_analysis['IFT_herbicide_approx'] = 0
+        return risk_analysis
+    
+    def _classify_risk(self, row):
+        """Classification du risque pour une parcelle"""
+        ift = row.get('IFT_herbicide_approx', 0)
+        nb_herb = row.get('Nb_herbicides', 0)
+        
+        if ift == 0 and nb_herb == 0:
+            return 'TRÈS FAIBLE'
+        elif ift < 1 and nb_herb <= 1:
+            return 'FAIBLE'
+        elif ift < 3 and nb_herb <= 3:
+            return 'MODÉRÉ'
+        elif ift < 5 and nb_herb <= 5:
+            return 'ÉLEVÉ'
+        else:
+            return 'TRÈS ÉLEVÉ'
+    
+    def _sort_by_risk(self, risk_analysis):
+        """Trie les résultats par niveau de risque"""
+        risk_order = {r: i for i, r in enumerate(RISK_LEVELS)}
+        risk_analysis['Risk_Score'] = risk_analysis['Risque_adventice'].map(risk_order)
+        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"""
+        ## 📊 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()}
+        
+        ## 🧪 Analyse Herbicides
+        """
+        
+        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()}
+        """
+        
+        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
+    
+    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
+            
+            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)}
+
+---
+"""
+        
+        return recommendations
+    
+    def get_risk_analysis(self):
+        """Retourne l'analyse des risques"""
+        return self.risk_analysis

config.py

@@ -0,0 +1,45 @@
+"""
+Configuration pour l'application d'analyse des adventices agricoles
+"""
+import os
+
+# Configuration Hugging Face
+HF_TOKEN = os.environ.get("HF_TOKEN")
+DATASET_ID = "HackathonCRA/2024"
+
+# Configuration des données
+REQUIRED_COLUMNS = ["numparcell", "surfparc", "millesime"]
+OPTIONAL_GROUP_COLS = ["nomparc", "libelleusag"]
+
+# Configuration des risques
+RISK_LEVELS = ['TRÈS FAIBLE', 'FAIBLE', 'MODÉRÉ', 'ÉLEVÉ', 'TRÈS ÉLEVÉ']
+RISK_COLORS = {
+    'TRÈS FAIBLE': 'green',
+    'FAIBLE': 'lightgreen', 
+    'MODÉRÉ': 'orange',
+    'ÉLEVÉ': 'red',
+    'TRÈS ÉLEVÉ': 'darkred'
+}
+
+# Configuration Gradio
+GRADIO_CONFIG = {
+    "server_name": "0.0.0.0",
+    "server_port": 7860,
+    "share": False
+}
+
+# Configuration des graphiques
+PLOT_CONFIG = {
+    "width": 800,
+    "height": 600,
+    "title_font_size": 16
+}
+
+# Messages de l'application
+MESSAGES = {
+    "loading": "🔄 Chargement des données depuis Hugging Face...",
+    "success": "✅ Données chargées avec succès",
+    "error_loading": "❌ Erreur lors du chargement du dataset",
+    "no_data": "❌ Aucune donnée disponible",
+    "analysis_complete": "✅ Analyse terminée avec succès"
+}

data_loader.py

@@ -0,0 +1,164 @@
+"""
+Module de chargement des données depuis Hugging Face
+"""
+import os
+import pandas as pd
+from datasets import load_dataset
+from huggingface_hub import HfApi, hf_hub_download
+from config import HF_TOKEN, DATASET_ID, REQUIRED_COLUMNS, MESSAGES
+
+
+class DataLoader:
+    """Classe responsable du chargement des données depuis différentes sources"""
+    
+    def __init__(self):
+        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
+        try:
+            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...")
+                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()
+            if self.df is None:
+                return f"❌ Erreur lors du chargement du dataset : {str(e)} | Fallback: {fallback_msg}"
+
+        # 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)}")
+
+        # Nettoyage et validation
+        return self._clean_and_validate_data()
+    
+    def _clean_and_validate_data(self):
+        """Nettoie et valide les données chargées"""
+        missing_cols = [col for col in REQUIRED_COLUMNS if col not in self.df.columns]
+
+        if missing_cols:
+            print(f"❌ Colonnes manquantes: {missing_cols}")
+            self.df = None
+            return f"❌ Colonnes manquantes: {missing_cols}"
+
+        # Nettoyage
+        initial_len = len(self.df)
+        self.df = self.df.dropna(subset=REQUIRED_COLUMNS)
+
+        print(f"📊 Avant nettoyage: {initial_len} lignes")
+        print(f"📊 Après nettoyage: {len(self.df)} lignes")
+        
+        return MESSAGES["success"]
+    
+    def _fallback_load_from_repo_files(self):
+        """Fallback pour charger les données en téléchargeant directement les fichiers du repo HF."""
+        try:
+            print("🔄 Tentative de chargement alternatif via fichiers du dépôt Hugging Face...")
+            api = HfApi()
+            files = api.list_repo_files(repo_id=DATASET_ID, repo_type="dataset", token=HF_TOKEN)
+            if not files:
+                print("❌ Aucun fichier dans le dépôt")
+                return "Aucun fichier trouvé dans le dépôt."
+
+            data_files = [
+                f for f in files if f.lower().endswith((".parquet", ".csv", ".tsv", ".json"))
+            ]
+            if not data_files:
+                print("❌ Aucun fichier de données exploitable (csv/tsv/parquet/json)")
+                return "Aucun fichier exploitable (csv/tsv/parquet/json)."
+
+            # Priorité: parquet > csv > tsv > json
+            for ext in [".parquet", ".csv", ".tsv", ".json"]:
+                selected = [f for f in data_files if f.lower().endswith(ext)]
+                if selected:
+                    chosen_ext = ext
+                    selected_files = selected
+                    break
+
+            print(f"📂 Fichiers détectés ({chosen_ext}): {selected_files[:5]}{' ...' if len(selected_files) > 5 else ''}")
+
+            local_paths = []
+            for f in selected_files:
+                local_path = hf_hub_download(
+                    repo_id=DATASET_ID,
+                    repo_type="dataset",
+                    filename=f,
+                    token=HF_TOKEN,
+                )
+                local_paths.append(local_path)
+
+            frames = []
+            if chosen_ext == ".parquet":
+                for p in local_paths:
+                    frames.append(pd.read_parquet(p))
+            elif chosen_ext == ".csv":
+                for p in local_paths:
+                    frames.append(pd.read_csv(p))
+            elif chosen_ext == ".tsv":
+                for p in local_paths:
+                    frames.append(pd.read_csv(p, sep="\t"))
+            elif chosen_ext == ".json":
+                for p in local_paths:
+                    try:
+                        frames.append(pd.read_json(p, lines=True))
+                    except Exception:
+                        frames.append(pd.read_json(p))
+
+            self.df = pd.concat(frames, ignore_index=True) if len(frames) > 1 else frames[0]
+            print(f"✅ Fallback réussi: {len(self.df)} lignes chargées depuis les fichiers du dépôt")
+            return None
+        except Exception as e:
+            print(f"❌ Fallback échoué: {e}")
+            # Dernier recours: fichier local d'exemple
+            return self._load_local_sample()
+    
+    def _load_local_sample(self):
+        """Charge un fichier local de secours"""
+        sample_path = os.path.join(os.path.dirname(__file__), "sample_data.csv")
+        if os.path.exists(sample_path):
+            try:
+                self.df = pd.read_csv(sample_path)
+                print(f"✅ Chargement du fichier local 'sample_data.csv' ({len(self.df)} lignes)")
+                return "Chargement via fichier local de secours."
+            except Exception as e2:
+                print(f"❌ Échec du chargement du fichier local: {e2}")
+        return "Aucune source de données disponible."
+    
+    def get_data(self):
+        """Retourne les données chargées"""
+        return self.df
+    
+    def has_data(self):
+        """Vérifie si des données sont disponibles"""
+        return self.df is not None and len(self.df) > 0

interface.py

@@ -0,0 +1,192 @@
+"""
+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"""
+        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()
+            )
+    
+    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
+            return (
+                "❌ Aucune donnée disponible",
+                empty_fig,
+                empty_fig,
+                empty_fig,
+                "❌ Aucune recommandation disponible"
+            )
+    
+    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"""
+        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())
+    
+    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.
+        """)
+    
+    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
+        
+        ### 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_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)

main.py

@@ -0,0 +1,27 @@
+"""
+Point d'entrée principal de l'application d'analyse des adventices agricoles
+"""
+import warnings
+import matplotlib.pyplot as plt
+import seaborn as sns
+from interface import AgricultureInterface
+
+# Suppression des warnings
+warnings.filterwarnings('ignore')
+
+# Configuration des graphiques
+plt.style.use('default')
+sns.set_palette("husl")
+
+
+def main():
+    """Fonction principale qui lance l'application"""
+    print("🌾 Démarrage de l'application d'analyse des adventices agricoles...")
+    
+    # Création et lancement de l'interface
+    app = AgricultureInterface()
+    app.launch()
+
+
+if __name__ == "__main__":
+    main()

sample_data.csv

@@ -1,22 +1,5 @@
-Station Expérimentale de Kerguéhennec - Données d'intervention 2025
 millesime,raisonsoci,siret,pacage,refca,numilot,numparcell,nomparc,surfparc,rang,estpac,libelleusag,datedebut,datefin,libperiode,libregroupe,libevenem,dureeeffect,familleprod,produit,quantitetot,unite,neffqte,peffqte,kqte,teneurn,teneurp,teneurk,keq,volumebo,codeamm,codegnis,materiel,mainoeuvre
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1102,Bourg bas,6.73,1,True,blé tendre hiver,15/03/25,15/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,LUMEO,0.20,L,,,,,,,,,,,Pulvérisateur,2.5
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1301,Bois Guillemin,5.97,1,True,blé tendre hiver,20/03/25,20/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,PEAK,0.01,L,,,,,,,,,,,Pulvérisateur,2.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1101,Bourg Haut,5.55,1,True,maïs grain,25/04/25,25/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,GLISTER ULTRA 360,3.50,L,,,,,,,,,,,Pulvérisateur,3.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1001,Carancier Ht,5.46,1,True,colza hiver,10/04/25,10/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,BISCOTO,1.20,L,,,,,,,,,,,Pulvérisateur,2.5
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,48,Etang Bois,3.36,1,True,haricot vert industrie,05/05/25,05/05/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,ISARD,2.40,L,,,,,,,,,,,Pulvérisateur,4.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,44,La Défriche,3.25,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,2,Kersuzan Bas,3.05,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,81,Charbonnerie Entrée,3.01,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,11,Cléhury,2.97,1,True,orge hiver,12/04/25,12/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,FREEWAY 480,0.80,L,,,,,,,,,,,Pulvérisateur,2.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,5,Etang Moulin,2.85,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,50,Lann Chebot Le Roch,2.20,1,True,blé tendre hiver,18/03/25,18/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,NISSHIN PREMIUM 6 OD,1.50,L,,,,,,,,,,,Pulvérisateur,3.5
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,16,Champ ferme W du sol parking,1.95,1,True,maïs grain,28/04/25,28/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,ALABAMA,1.20,L,,,,,,,,,,,Pulvérisateur,2.5
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,39,Champ ferme transfert,1.85,1,True,blé tendre hiver,22/03/25,22/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,CENT-7,0.15,L,,,,,,,,,,,Pulvérisateur,2.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1201,Champ Robert,1.75,1,True,blé tendre hiver,25/03/25,25/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,CORUM,0.95,L,,,,,,,,,,,Pulvérisateur,2.5
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,38,Champ ferme W du sol,1.65,1,True,colza hiver,15/04/25,15/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,LUMEO,0.18,L,,,,,,,,,,,Pulvérisateur,2.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,14,Grand-Champ 1 essai soja 25,0.53,1,True,soja,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,10,Penderff 7 analytique,1.56,1,True,avoine printemps,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,33,Penderff Luzerne,2.10,1,True,luzerne,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,4,Penderff 1,0.37,1,True,feverole printemps,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
-2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,6,Lann Chebot chemin,0.11,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2014,Station Expérimentale de Kerguéhennec,18560001000016,056021200,70000308,2,21,Champ ferme Bas,1.97,1,true,blé tendre hiver,15/11/13,15/11/13,,Plantation et Semis,Semis classique,120,BLE TENDRE.,RUBISKO dose ,11.82,Dose,,,,,,,,,,512C771,"TASSE-AVANT, Vibro/tasse-Avant - TRACTEURS CLASSIQUES, Tracteur JOHN DEERE 6530 Premium - SEMOIRS & ACCESSOIRES, Semoir 3 m Combiné HR LEMKEN Solitair 9 - HERSES, Herse Rotative LEMKEN Zirkon 3m - ",
+2014,Station Expérimentale de Kerguéhennec,18560001000016,056021200,70000308,2,21,Champ ferme Bas,1.97,1,true,blé tendre hiver,25/2/14,25/2/14,,Fertilisation,Ferti minérale amendement et foliaire,44,Engrais et amendements mineraux,Solution Liquide N 39,197.0,L,76.83000183105469,0.0,0.0,39.0,0.0,0.0,,,,,"PULVERISATEURS, Porté 1200 l 21 m DPA - TRACTEURS CLASSIQUES, Arion 410 CIS - ",
+2014,Station Expérimentale de Kerguéhennec,18560001000016,056021200,70000308,2,21,Champ ferme Bas,1.97,1,true,blé tendre hiver,12/3/14,12/3/14,,Protection des cultures,Traitement et protection des cultures,46,Herbicides,ALIGATOR,0.04104167,Kg,,,,,,,,,8400255,,"PULVERISATEURS, Porté 1200 l 21 m DPA - TRACTEURS CLASSIQUES, ARION 530 CIS - ",
+2014,Station Expérimentale de Kerguéhennec,18560001000016,056021200,70000308,2,21,Champ ferme Bas,1.97,1,true,blé tendre hiver,12/3/14,12/3/14,,Protection des cultures,Traitement et protection des cultures,46,Herbicides,CHARADE,2.5651042,l,,,,,,,,,9600293,,"PULVERISATEURS, Porté 1200 l 21 m DPA - TRACTEURS CLASSIQUES, ARION 530 CIS - ",

visualizations.py

@@ -0,0 +1,180 @@
+"""
+Module de visualisation des données agricoles
+"""
+import plotly.express as px
+import plotly.graph_objects as go
+from config import RISK_COLORS, PLOT_CONFIG
+
+
+class AgricultureVisualizer:
+    """Classe responsable de la création des visualisations"""
+    
+    def __init__(self, data=None, risk_analysis=None):
+        self.df = data
+        self.risk_analysis = risk_analysis
+    
+    def set_data(self, data, risk_analysis=None):
+        """Définit les données à visualiser"""
+        self.df = data
+        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")
+            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
+        
+        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
+    
+    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
+            )
+            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
+            )
+            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
+            )
+            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
+            )
+            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