updated

.gitignore

@@ -1,3 +1,6 @@
 .env
 __pycache__/
-sample_data/
+sample_data/
+.venv/
+mcp/
+mcp-example/

GUIDE_REQUETES_HERBICIDES.md

@@ -0,0 +1,177 @@
+# 🔍 Guide des Requêtes Herbicides
+
+## Nouvelles Fonctionnalités Intégrées
+
+L'application d'analyse des adventices agricoles a été enrichie avec un système de requêtes avancées pour l'analyse des herbicides. Voici comment utiliser ces nouvelles fonctionnalités :
+
+## 📋 Accès aux Fonctionnalités
+
+Dans l'interface Gradio, vous trouverez un nouvel onglet **"🔍 Requêtes Herbicides"** qui contient 4 sous-onglets spécialisés :
+
+---
+
+## 🏆 Top IFT par Année
+
+**Objectif :** Identifier les parcelles avec les Indices de Fréquence de Traitement (IFT) herbicides les plus élevés pour une année donnée.
+
+### Utilisation :
+1. Sélectionnez l'année à analyser dans la liste déroulante
+2. Choisissez le nombre de parcelles à afficher (5 à 50)
+3. Cliquez sur "🔍 Analyser les IFT"
+
+### Résultats :
+- **Graphique en barres** : Classement visuel des parcelles par IFT décroissant
+- **Tableau détaillé** : Numéro de parcelle, surface, IFT, quantité totale, nombre de produits
+
+### Cas d'usage :
+- **Surveillance prioritaire** : Identifier les parcelles nécessitant une attention particulière
+- **Benchmarking** : Comparer les pratiques entre parcelles
+- **Audit réglementaire** : Suivre les parcelles à forte intensité de traitement
+
+---
+
+## 📖 Historique Parcelle
+
+**Objectif :** Tracer l'historique complet des herbicides utilisés sur une parcelle spécifique.
+
+### Utilisation :
+1. Saisissez le numéro de la parcelle (ex: 21, 22, etc.)
+2. Définissez le nombre d'années à analyser (1 à 15)
+3. Cliquez sur "🔍 Analyser l'historique"
+
+### Résultats :
+- **Graphique chronologique** : Évolution des produits et quantités par année
+- **Tableau historique** : Détail par année avec produits, quantités et dates
+
+### Cas d'usage :
+- **Planification de rotation** : Voir l'historique avant d'implanter une culture sensible
+- **Traçabilité** : Documenter les pratiques passées
+- **Analyse tendances** : Observer l'évolution des pratiques sur une parcelle
+
+---
+
+## 🎯 Recherche de Produits
+
+**Objectif :** Trouver les parcelles ayant reçu (ou n'ayant PAS reçu) des produits spécifiques.
+
+### Utilisation :
+1. Saisissez les noms de produits séparés par des virgules
+   - Exemple : `Minarex, Chardex, Aligator`
+   - Supporte la recherche partielle (ex: "Chardex" trouve "Chardex 500")
+2. Définissez la période d'analyse (1 à 15 années)
+3. Choisissez votre type de recherche :
+   - **"✅ Parcelles AVEC ces produits"** : Trouve les parcelles qui ont reçu au moins un des produits
+   - **"❌ Parcelles SANS ces produits"** : Trouve les parcelles qui n'ont reçu aucun de ces produits
+
+### Résultats :
+- **Message de statut** : Nombre de parcelles trouvées
+- **Tableau des résultats** : Liste des parcelles avec détails (années, quantités, dates)
+
+### Cas d'usage :
+- **Rotation Chardex** : `Chardex` → Trouver les parcelles sans Chardex pour cultures sensibles
+- **Évitement de résidus** : Identifier les parcelles sans produits persistants
+- **Conformité réglementaire** : Tracer l'usage de produits spécifiques
+
+### Exemples de Requêtes Utiles :
+
+#### Pour cultures sensibles (pois, haricot) :
+```
+Recherche "SANS" : Chardex, Minarex
+→ Trouve les parcelles adaptées aux légumineuses
+```
+
+#### Pour audit d'un produit :
+```
+Recherche "AVEC" : Aligator
+→ Trace tous les usages d'Aligator
+```
+
+#### Pour éviter les résistances :
+```
+Recherche "AVEC" : Glyphosate, Round
+→ Identifie les parcelles à forte pression glyphosate
+```
+
+---
+
+## 🗓️ Périodes d'Intervention
+
+**Objectif :** Analyser les patterns temporels d'application des herbicides par parcelle.
+
+### Utilisation :
+1. Définissez la période d'analyse (1 à 15 années)
+2. Cliquez sur "🔍 Analyser les périodes"
+
+### Résultats :
+- **Graphique scatter** : Position des interventions dans l'année vs intensité
+  - X = Mois de début d'intervention
+  - Y = Nombre d'interventions
+  - Taille = Quantité totale utilisée
+  - Couleur = Nombre de produits différents
+
+- **Heatmap** : Répartition mensuelle des interventions par année
+  - Visualise les pics d'activité saisonniers
+  - Compare l'évolution temporelle entre années
+
+- **Tableau détaillé** : Analyse par parcelle avec :
+  - Période d'activité (année début/fin)
+  - Nombre total d'interventions
+  - Mois de début/fin des traitements
+  - Liste des mois d'intervention
+  - Nombre de produits uniques
+  - Quantité totale
+
+### Cas d'usage :
+- **Optimisation temporelle** : Identifier les meilleures fenêtres d'intervention
+- **Planification cultural** : Éviter les conflits avec les périodes de traitement
+- **Analyse climatique** : Corréler les interventions avec les conditions météo
+- **Benchmarking temporel** : Comparer les strategies temporelles entre parcelles
+
+---
+
+## 💡 Conseils d'Utilisation
+
+### Recherche de Produits Efficace :
+- Utilisez des **noms partiels** : "Chardex" trouve "Chardex 500", "Chardex WG", etc.
+- **Combinez plusieurs produits** : "Chardex, Minarex" pour une recherche large
+- **Soyez spécifique** : "Round" vs "Roundup" selon vos besoins
+
+### Interprétation des IFT :
+- **IFT < 1** : Usage faible, parcelles intéressantes pour cultures sensibles
+- **IFT 1-3** : Usage modéré, surveillance recommandée
+- **IFT > 3** : Usage intensif, rotation conseillée avant cultures sensibles
+
+### Analyse Temporelle :
+- **Mars-Avril** : Période classique de désherbage de printemps
+- **Septembre-Octobre** : Traitements d'automne (colza, céréales)
+- **Heatmap** : Rouge = forte activité, Bleu = période calme
+
+---
+
+## 🔧 Support Technique
+
+- **Données manquantes** : Les requêtes s'adaptent automatiquement aux colonnes disponibles
+- **Recherche insensible à la casse** : "chardex" = "CHARDEX"
+- **Gestion des erreurs** : Messages explicites en cas de problème
+- **Performance** : Optimisé pour des datasets de plusieurs milliers de lignes
+
+---
+
+## 📞 Questions Fréquentes
+
+**Q: Que faire si aucune parcelle n'est trouvée ?**
+R: Vérifiez l'orthographe des produits et élargissez la période de recherche.
+
+**Q: Comment interpréter un IFT élevé ?**
+R: IFT élevé = forte pression herbicide. Considérez une rotation ou des techniques alternatives.
+
+**Q: Puis-je rechercher plusieurs produits à la fois ?**
+R: Oui, séparez-les par des virgules. La recherche trouve les parcelles avec AU MOINS UN des produits.
+
+**Q: Comment identifier les parcelles pour pois/haricot ?**
+R: Recherchez les parcelles "SANS" Chardex sur 10 ans, puis vérifiez leur historique.
+
+---
+
+*Développé pour le Hackathon CRA Bretagne 🏆*
+*Application d'aide à la décision pour une agriculture durable*

app.py

@@ -16,6 +16,7 @@ from datasets import load_dataset
 import pandas as pd
 from huggingface_hub import HfApi, hf_hub_download
 import urllib.parse
+from herbicide_analyzer import HerbicideAnalyzer
 warnings.filterwarnings('ignore')
 
 # Configuration Hugging Face
@@ -644,6 +645,9 @@ analyzer = AgricultureAnalyzer()
 analyzer.load_data()
 analyzer.analyze_data()  # Analyse des données après chargement
 
+# Initialisation de l'analyseur d'herbicides
+herbicide_analyzer = HerbicideAnalyzer(analyzer.df)
+
 # Interface Gradio
 def create_interface():
     with gr.Blocks(title="🌾 Analyse Adventices Agricoles CRA", theme=gr.themes.Soft()) as demo:
@@ -708,6 +712,264 @@ def create_interface():
                 - **Biostimulants**: Renforcement naturel des cultures
                 """)
             
+            with gr.TabItem("📅 Analyse par Année"):
+                gr.Markdown("## Visualisation des données par année")
+                
+                # Liste déroulante pour sélectionner l'année
+                available_years = analyzer.get_available_years()
+                if available_years:
+                    default_year = available_years[-1]  # Dernière année par défaut
+                    year_dropdown = gr.Dropdown(
+                        choices=available_years,
+                        value=default_year,
+                        label="🗓️ Sélectionner une année",
+                        info="Choisissez l'année à analyser dans la liste déroulante"
+                    )
+                else:
+                    year_dropdown = gr.Dropdown(
+                        choices=[],
+                        value=None,
+                        label="🗓️ Sélectionner une année",
+                        info="Aucune année disponible"
+                    )
+                
+                # Statistiques pour l'année sélectionnée
+                year_stats = gr.Markdown("")
+                
+                # Graphiques pour l'année sélectionnée
+                with gr.Row():
+                    year_culture_plot = gr.Plot()
+                    year_timeline_plot = gr.Plot()
+                
+                with gr.Row():
+                    year_herbicide_plot = gr.Plot()
+                
+                # Fonction de mise à jour quand l'année change
+                def update_year_analysis(selected_year):
+                    if selected_year is None:
+                        empty_fig = px.bar(title="❌ Aucune année sélectionnée")
+                        return (
+                            "❌ Veuillez sélectionner une année",
+                            empty_fig, empty_fig, empty_fig
+                        )
+                    
+                    stats = analyzer.get_year_summary_stats(selected_year)
+                    culture_fig = analyzer.create_year_culture_analysis(selected_year)
+                    timeline_fig = analyzer.create_year_interventions_timeline(selected_year)
+                    herbicide_fig = analyzer.create_year_herbicide_analysis(selected_year)
+                    
+                    return stats, culture_fig, timeline_fig, herbicide_fig
+                
+                # Connecter la liste déroulante aux mises à jour
+                year_dropdown.change(
+                    update_year_analysis,
+                    inputs=[year_dropdown],
+                    outputs=[year_stats, year_culture_plot, year_timeline_plot, year_herbicide_plot]
+                )
+                
+                # Initialiser avec l'année par défaut
+                if available_years:
+                    initial_stats, initial_culture, initial_timeline, initial_herbicide = update_year_analysis(default_year)
+                    year_stats.value = initial_stats
+                    year_culture_plot.value = initial_culture
+                    year_timeline_plot.value = initial_timeline
+                    year_herbicide_plot.value = initial_herbicide
+                
+                gr.Markdown("""
+                **Informations sur cet onglet:**
+                - 📊 **Statistiques**: Résumé pour l'année sélectionnée
+                - 🌱 **Cultures**: Répartition des types de cultures
+                - 📅 **Timeline**: Répartition temporelle des interventions
+                - 🧪 **Herbicides**: Top 10 des herbicides utilisés
+                """)
+            
+            with gr.TabItem("🔍 Requêtes Herbicides"):
+                gr.Markdown("## Requêtes avancées pour l'analyse des herbicides")
+                
+                with gr.Tabs():
+                    with gr.TabItem("🏆 Top IFT par Année"):
+                        gr.Markdown("### Parcelles avec les IFT herbicides les plus élevés")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                year_select_ift = gr.Dropdown(
+                                    choices=analyzer.get_available_years(),
+                                    value=analyzer.get_available_years()[-1] if analyzer.get_available_years() else None,
+                                    label="📅 Année à analyser"
+                                )
+                                n_parcels_ift = gr.Slider(
+                                    minimum=5,
+                                    maximum=50,
+                                    value=10,
+                                    step=5,
+                                    label="🔢 Nombre de parcelles à afficher"
+                                )
+                                btn_ift = gr.Button("🔍 Analyser les IFT", variant="primary")
+                            
+                            with gr.Column():
+                                ift_chart = gr.Plot()
+                        
+                        ift_table = gr.Dataframe(
+                            headers=["Parcelle", "Surface", "IFT Herbicide", "Quantité Totale", "Nb Produits"],
+                            label="📊 Détail des parcelles avec IFT élevé"
+                        )
+                        
+                        def analyze_ift(year, n_parcels):
+                            if year is None:
+                                return None, "❌ Veuillez sélectionner une année"
+                            
+                            data, message = herbicide_analyzer.get_top_ift_parcels_by_year(year, n_parcels)
+                            chart = herbicide_analyzer.create_ift_ranking_chart(year, n_parcels)
+                            
+                            return chart, data
+                        
+                        btn_ift.click(
+                            analyze_ift,
+                            inputs=[year_select_ift, n_parcels_ift],
+                            outputs=[ift_chart, ift_table]
+                        )
+                    
+                    with gr.TabItem("📖 Historique Parcelle"):
+                        gr.Markdown("### Produits utilisés sur une parcelle spécifique")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                parcel_id_input = gr.Textbox(
+                                    label="🏠 Numéro de parcelle",
+                                    placeholder="Ex: 21, 22, etc."
+                                )
+                                n_years_history = gr.Slider(
+                                    minimum=1,
+                                    maximum=15,
+                                    value=5,
+                                    step=1,
+                                    label="📅 Nombre d'années à analyser"
+                                )
+                                btn_history = gr.Button("🔍 Analyser l'historique", variant="primary")
+                            
+                            with gr.Column():
+                                history_chart = gr.Plot()
+                        
+                        history_table = gr.Dataframe(
+                            headers=["Année", "Produit", "Quantité", "Date début", "Date fin"],
+                            label="📊 Historique des produits utilisés"
+                        )
+                        
+                        def analyze_parcel_history(parcel_id, n_years):
+                            if not parcel_id or parcel_id.strip() == "":
+                                return None, "❌ Veuillez entrer un numéro de parcelle"
+                            
+                            data, message = herbicide_analyzer.get_parcel_products_history(parcel_id.strip(), n_years)
+                            chart = herbicide_analyzer.create_product_timeline_chart(parcel_id.strip(), n_years)
+                            
+                            return chart, data
+                        
+                        btn_history.click(
+                            analyze_parcel_history,
+                            inputs=[parcel_id_input, n_years_history],
+                            outputs=[history_chart, history_table]
+                        )
+                    
+                    with gr.TabItem("🎯 Recherche de Produits"):
+                        gr.Markdown("### Parcelles ayant reçu des produits spécifiques")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                products_input = gr.Textbox(
+                                    label="🧪 Noms de produits (séparés par des virgules)",
+                                    placeholder="Ex: Minarex, Chardex, Aligator",
+                                    lines=2
+                                )
+                                n_years_search = gr.Slider(
+                                    minimum=1,
+                                    maximum=15,
+                                    value=10,
+                                    step=1,
+                                    label="📅 Période d'analyse (années)"
+                                )
+                                with gr.Row():
+                                    btn_with_products = gr.Button("✅ Parcelles AVEC ces produits", variant="primary")
+                                    btn_without_products = gr.Button("❌ Parcelles SANS ces produits", variant="secondary")
+                        
+                        search_results_table = gr.Dataframe(
+                            label="📊 Résultats de la recherche"
+                        )
+                        search_message = gr.Markdown("")
+                        
+                        def search_with_products(products_text, n_years):
+                            if not products_text or products_text.strip() == "":
+                                return "❌ Veuillez entrer au moins un nom de produit", None
+                            
+                            products_list = [p.strip() for p in products_text.split(",") if p.strip()]
+                            data, message = herbicide_analyzer.find_parcels_with_products(products_list, n_years)
+                            
+                            return message, data
+                        
+                        def search_without_products(products_text, n_years):
+                            if not products_text or products_text.strip() == "":
+                                return "❌ Veuillez entrer au moins un nom de produit", None
+                            
+                            products_list = [p.strip() for p in products_text.split(",") if p.strip()]
+                            data, message = herbicide_analyzer.find_parcels_without_products(products_list, n_years)
+                            
+                            return message, data
+                        
+                        btn_with_products.click(
+                            search_with_products,
+                            inputs=[products_input, n_years_search],
+                            outputs=[search_message, search_results_table]
+                        )
+                        
+                        btn_without_products.click(
+                            search_without_products,
+                            inputs=[products_input, n_years_search],
+                            outputs=[search_message, search_results_table]
+                        )
+                    
+                    with gr.TabItem("🗓️ Périodes d'Intervention"):
+                        gr.Markdown("### Analyse des périodes d'interventions herbicides")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                n_years_periods = gr.Slider(
+                                    minimum=1,
+                                    maximum=15,
+                                    value=10,
+                                    step=1,
+                                    label="📅 Période d'analyse (années)"
+                                )
+                                btn_periods = gr.Button("🔍 Analyser les périodes", variant="primary")
+                            
+                            with gr.Column():
+                                periods_chart = gr.Plot()
+                        
+                        with gr.Row():
+                            heatmap_chart = gr.Plot()
+                        
+                        periods_table = gr.Dataframe(
+                            label="📊 Analyse des périodes par parcelle"
+                        )
+                        
+                        def analyze_periods(n_years):
+                            data, message = herbicide_analyzer.analyze_intervention_periods(n_years)
+                            chart = herbicide_analyzer.create_intervention_periods_chart(n_years)
+                            heatmap = herbicide_analyzer.create_monthly_interventions_heatmap(n_years)
+                            
+                            return chart, heatmap, data
+                        
+                        btn_periods.click(
+                            analyze_periods,
+                            inputs=[n_years_periods],
+                            outputs=[periods_chart, heatmap_chart, periods_table]
+                        )
+                        
+                        gr.Markdown("""
+                        **Guide d'interprétation :**
+                        - 🎯 **Graphique scatter** : Position des interventions dans l'année vs intensité
+                        - 🔥 **Heatmap** : Répartition mensuelle des interventions par année
+                        - 📊 **Tableau** : Détail par parcelle avec périodes et quantités
+                        """)
+            
             with gr.TabItem("ℹ️ À propos"):
                 gr.Markdown("""
                 ## 🎯 Méthodologie
@@ -730,6 +992,34 @@ def create_interface():
                 - **Période**: Campagne 2025
                 - **Variables**: Interventions, produits, quantités, surfaces
                 
+                ## 🔍 Nouvelles Fonctionnalités - Requêtes Herbicides
+                
+                ### 🏆 Top IFT par Année
+                - Identifie les parcelles avec les IFT herbicides les plus élevés
+                - Aide à cibler les parcelles à surveiller prioritairement
+                - Graphique de classement et tableau détaillé
+                
+                ### 📖 Historique Parcelle
+                - Trace l'historique complet des herbicides sur une parcelle
+                - Permet de voir l'évolution des pratiques
+                - Graphique chronologique des utilisations
+                
+                ### 🎯 Recherche de Produits
+                - **Recherche positive**: Trouve les parcelles ayant reçu des produits spécifiques
+                - **Recherche négative**: Identifie les parcelles n'ayant PAS reçu certains produits
+                - Supporte la recherche partielle (ex: "Chardex" trouve "Chardex 500")
+                
+                ### 🗓️ Périodes d'Intervention
+                - Analyse les patterns temporels d'application des herbicides
+                - Graphique scatter des périodes vs intensité
+                - Heatmap mensuelle/annuelle des interventions
+                
+                ### 💡 Exemples d'utilisation
+                - **Rotation des cultures**: Identifier les parcelles sans Chardex pour y planter des cultures sensibles
+                - **Suivi réglementaire**: Tracer l'usage de produits spécifiques
+                - **Optimisation temporelle**: Analyser les meilleures périodes d'intervention
+                - **Benchmarking**: Comparer les IFT entre parcelles similaires
+                
                 ---
                 
                 **Développé pour le Hackathon CRA Bretagne** 🏆
@@ -743,6 +1033,16 @@ def create_interface():
         def refresh_data():
             analyzer.load_data()
             analyzer.analyze_data()  # Recalculer l'analyse après rechargement
+            
+            # Mettre à jour l'analyseur d'herbicides avec les nouvelles données
+            herbicide_analyzer.set_data(analyzer.df)
+            
+            # Mettre à jour la liste des années disponibles
+            updated_years = analyzer.get_available_years()
+            year_dropdown.choices = updated_years
+            if updated_years:
+                year_dropdown.value = updated_years[-1]
+            
             return (
                 analyzer.get_summary_stats(),
                 analyzer.create_culture_analysis(),

herbicide_analyzer.py

@@ -0,0 +1,520 @@
+"""
+Module d'analyse avancée des herbicides
+Contient les fonctions de requête spécialisées pour l'analyse des herbicides
+"""
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+from datetime import datetime, timedelta
+
+
+class HerbicideAnalyzer:
+    """Classe spécialisée dans l'analyse avancée des herbicides"""
+    
+    def __init__(self, data=None):
+        self.df = data
+    
+    def set_data(self, data):
+        """Définit les données à analyser"""
+        self.df = data
+    
+    def get_top_ift_parcels_by_year(self, year, n_parcels=10):
+        """
+        Retourne les N parcelles avec les IFT herbicides les plus élevés pour une année donnée
+        
+        Args:
+            year (int): Année à analyser
+            n_parcels (int): Nombre de parcelles à retourner (défaut: 10)
+            
+        Returns:
+            tuple: (DataFrame des résultats, message de statut)
+        """
+        try:
+            if self.df is None or len(self.df) == 0:
+                return None, "❌ Aucune donnée disponible"
+            
+            # Filtrer par année et herbicides
+            year_data = self.df[
+                (self.df['millesime'] == year) & 
+                (self.df['familleprod'] == 'Herbicides')
+            ].copy()
+            
+            if len(year_data) == 0:
+                return None, f"❌ Aucune donnée d'herbicides pour l'année {year}"
+            
+            # Calculer l'IFT par parcelle
+            if 'quantitetot' not in year_data.columns:
+                return None, "❌ Colonne 'quantitetot' manquante pour le calcul de l'IFT"
+            
+            # Grouper par parcelle et calculer l'IFT approximatif
+            group_cols = ['numparcell', 'surfparc']
+            if 'nomparc' in year_data.columns:
+                group_cols.append('nomparc')
+            if 'libelleusag' in year_data.columns:
+                group_cols.append('libelleusag')
+            
+            ift_data = year_data.groupby(group_cols).agg({
+                'quantitetot': 'sum',
+                'produit': 'count',
+                'produit': lambda x: len(x.unique())  # Nombre de produits différents
+            }).reset_index()
+            
+            # Renommer les colonnes pour plus de clarté
+            ift_data.columns = list(group_cols) + ['quantite_totale', 'nb_produits_uniques']
+            
+            # Calculer l'IFT approximatif (quantité / surface)
+            ift_data['IFT_herbicide'] = (ift_data['quantite_totale'] / ift_data['surfparc']).round(2)
+            
+            # Trier par IFT décroissant et prendre les N premiers
+            top_parcels = ift_data.sort_values('IFT_herbicide', ascending=False).head(n_parcels)
+            
+            return top_parcels, f"✅ Top {len(top_parcels)} parcelles avec IFT herbicide le plus élevé en {year}"
+            
+        except Exception as e:
+            return None, f"❌ Erreur lors du calcul des IFT: {str(e)}"
+    
+    def get_parcel_products_history(self, parcel_id, n_years=5):
+        """
+        Retourne tous les produits utilisés sur une parcelle sur les N dernières années
+        
+        Args:
+            parcel_id (str): Identifiant de la parcelle
+            n_years (int): Nombre d'années à analyser (défaut: 5)
+            
+        Returns:
+            tuple: (DataFrame des résultats, message de statut)
+        """
+        try:
+            if self.df is None or len(self.df) == 0:
+                return None, "❌ Aucune donnée disponible"
+            
+            # Filtrer par parcelle et herbicides
+            parcel_data = self.df[
+                (self.df['numparcell'] == parcel_id) & 
+                (self.df['familleprod'] == 'Herbicides')
+            ].copy()
+            
+            if len(parcel_data) == 0:
+                return None, f"❌ Aucune donnée d'herbicides pour la parcelle {parcel_id}"
+            
+            # Calculer les N dernières années disponibles
+            max_year = parcel_data['millesime'].max()
+            min_year = max_year - n_years + 1
+            
+            recent_data = parcel_data[parcel_data['millesime'] >= min_year].copy()
+            
+            if len(recent_data) == 0:
+                return None, f"❌ Aucune donnée pour la parcelle {parcel_id} sur les {n_years} dernières années"
+            
+            # Grouper par année et produit
+            products_history = recent_data.groupby(['millesime', 'produit']).agg({
+                'quantitetot': 'sum',
+                'datedebut': 'first',
+                'datefin': 'first'
+            }).reset_index()
+            
+            # Trier par année et produit
+            products_history = products_history.sort_values(['millesime', 'produit'])
+            
+            return products_history, f"✅ Historique des produits pour la parcelle {parcel_id} sur {n_years} ans"
+            
+        except Exception as e:
+            return None, f"❌ Erreur lors de la récupération de l'historique: {str(e)}"
+    
+    def find_parcels_with_products(self, product_names, n_years=10):
+        """
+        Trouve toutes les parcelles qui ont reçu des produits spécifiques sur les N dernières années
+        
+        Args:
+            product_names (list): Liste des noms de produits à rechercher
+            n_years (int): Nombre d'années à analyser (défaut: 10)
+            
+        Returns:
+            tuple: (DataFrame des résultats, message de statut)
+        """
+        try:
+            if self.df is None or len(self.df) == 0:
+                return None, "❌ Aucune donnée disponible"
+            
+            if not product_names or len(product_names) == 0:
+                return None, "❌ Aucun nom de produit fourni"
+            
+            # Filtrer par herbicides et période
+            max_year = self.df['millesime'].max()
+            min_year = max_year - n_years + 1
+            
+            herbicides_data = self.df[
+                (self.df['familleprod'] == 'Herbicides') &
+                (self.df['millesime'] >= min_year)
+            ].copy()
+            
+            if len(herbicides_data) == 0:
+                return None, f"❌ Aucune donnée d'herbicides sur les {n_years} dernières années"
+            
+            # Recherche des produits (recherche insensible à la casse et partielle)
+            pattern = '|'.join([f".*{name}.*" for name in product_names])
+            matching_data = herbicides_data[
+                herbicides_data['produit'].str.contains(pattern, na=False, regex=True, case=False)
+            ].copy()
+            
+            if len(matching_data) == 0:
+                return None, f"❌ Aucune parcelle trouvée avec les produits: {', '.join(product_names)}"
+            
+            # Grouper par parcelle et produit
+            group_cols = ['numparcell', 'millesime', 'produit']
+            if 'nomparc' in matching_data.columns:
+                group_cols.insert(1, 'nomparc')
+            if 'surfparc' in matching_data.columns:
+                group_cols.insert(-2, 'surfparc')
+            
+            results = matching_data.groupby(group_cols).agg({
+                'quantitetot': 'sum',
+                'datedebut': 'first',
+                'datefin': 'first'
+            }).reset_index()
+            
+            # Trier par parcelle et année
+            results = results.sort_values(['numparcell', 'millesime'])
+            
+            return results, f"✅ {len(results)} utilisations trouvées pour les produits: {', '.join(product_names)}"
+            
+        except Exception as e:
+            return None, f"❌ Erreur lors de la recherche de produits: {str(e)}"
+    
+    def find_parcels_without_products(self, product_names, n_years=10):
+        """
+        Trouve toutes les parcelles qui N'ONT PAS reçu des produits spécifiques sur les N dernières années
+        
+        Args:
+            product_names (list): Liste des noms de produits à exclure
+            n_years (int): Nombre d'années à analyser (défaut: 10)
+            
+        Returns:
+            tuple: (DataFrame des résultats, message de statut)
+        """
+        try:
+            if self.df is None or len(self.df) == 0:
+                return None, "❌ Aucune donnée disponible"
+            
+            if not product_names or len(product_names) == 0:
+                return None, "❌ Aucun nom de produit fourni"
+            
+            # Filtrer par herbicides et période
+            max_year = self.df['millesime'].max()
+            min_year = max_year - n_years + 1
+            
+            recent_data = self.df[self.df['millesime'] >= min_year].copy()
+            
+            if len(recent_data) == 0:
+                return None, f"❌ Aucune donnée sur les {n_years} dernières années"
+            
+            # Obtenir toutes les parcelles de la période
+            all_parcels = recent_data[['numparcell']].drop_duplicates()
+            if 'nomparc' in recent_data.columns:
+                all_parcels = recent_data[['numparcell', 'nomparc']].drop_duplicates()
+            if 'surfparc' in recent_data.columns:
+                parcels_info = recent_data[['numparcell', 'nomparc', 'surfparc']].drop_duplicates() if 'nomparc' in recent_data.columns else recent_data[['numparcell', 'surfparc']].drop_duplicates()
+                all_parcels = parcels_info
+            
+            # Trouver les parcelles qui ONT reçu les produits
+            pattern = '|'.join([f".*{name}.*" for name in product_names])
+            herbicides_data = recent_data[recent_data['familleprod'] == 'Herbicides']
+            
+            parcels_with_products = set()
+            if len(herbicides_data) > 0:
+                matching_data = herbicides_data[
+                    herbicides_data['produit'].str.contains(pattern, na=False, regex=True, case=False)
+                ]
+                parcels_with_products = set(matching_data['numparcell'].unique())
+            
+            # Parcelles qui N'ONT PAS reçu les produits
+            all_parcel_ids = set(all_parcels['numparcell'].unique())
+            parcels_without = all_parcel_ids - parcels_with_products
+            
+            if len(parcels_without) == 0:
+                return None, f"❌ Toutes les parcelles ont reçu au moins un des produits: {', '.join(product_names)}"
+            
+            # Créer le DataFrame des résultats
+            results = all_parcels[all_parcels['numparcell'].isin(parcels_without)].copy()
+            
+            # Ajouter des informations sur l'usage
+            if 'libelleusag' in recent_data.columns:
+                usage_info = recent_data.groupby('numparcell')['libelleusag'].first().reset_index()
+                results = results.merge(usage_info, on='numparcell', how='left')
+            
+            # Trier par numéro de parcelle
+            results = results.sort_values('numparcell')
+            
+            return results, f"✅ {len(results)} parcelles trouvées sans les produits: {', '.join(product_names)}"
+            
+        except Exception as e:
+            return None, f"❌ Erreur lors de la recherche de parcelles sans produits: {str(e)}"
+    
+    def analyze_intervention_periods(self, n_years=10):
+        """
+        Analyse les périodes d'interventions herbicides par parcelle sur les N dernières années
+        
+        Args:
+            n_years (int): Nombre d'années à analyser (défaut: 10)
+            
+        Returns:
+            tuple: (DataFrame des résultats, message de statut)
+        """
+        try:
+            if self.df is None or len(self.df) == 0:
+                return None, "❌ Aucune donnée disponible"
+            
+            # Filtrer par herbicides et période
+            max_year = self.df['millesime'].max()
+            min_year = max_year - n_years + 1
+            
+            herbicides_data = self.df[
+                (self.df['familleprod'] == 'Herbicides') &
+                (self.df['millesime'] >= min_year)
+            ].copy()
+            
+            if len(herbicides_data) == 0:
+                return None, f"❌ Aucune donnée d'herbicides sur les {n_years} dernières années"
+            
+            # Convertir les dates en format datetime
+            herbicides_data['datedebut_parsed'] = pd.to_datetime(
+                herbicides_data['datedebut'], 
+                format='%d/%m/%y', 
+                errors='coerce'
+            )
+            
+            # Filtrer les données avec des dates valides
+            valid_dates = herbicides_data.dropna(subset=['datedebut_parsed'])
+            
+            if len(valid_dates) == 0:
+                return None, "❌ Aucune date d'intervention valide trouvée"
+            
+            # Extraire le mois et analyser les patterns
+            valid_dates['mois'] = valid_dates['datedebut_parsed'].dt.month
+            valid_dates['mois_nom'] = valid_dates['datedebut_parsed'].dt.strftime('%B')
+            
+            # Grouper par parcelle et analyser les périodes
+            group_cols = ['numparcell']
+            if 'nomparc' in valid_dates.columns:
+                group_cols.append('nomparc')
+            
+            periods_analysis = valid_dates.groupby(group_cols).agg({
+                'millesime': ['min', 'max', 'count'],
+                'mois': ['min', 'max'],
+                'mois_nom': lambda x: ', '.join(sorted(x.unique())),
+                'produit': 'nunique',
+                'quantitetot': 'sum'
+            }).round(2)
+            
+            # Aplatir les colonnes multi-niveaux
+            periods_analysis.columns = [
+                'annee_debut', 'annee_fin', 'nb_interventions',
+                'mois_debut', 'mois_fin', 'mois_interventions',
+                'nb_produits_uniques', 'quantite_totale'
+            ]
+            
+            periods_analysis = periods_analysis.reset_index()
+            
+            # Trier par nombre d'interventions décroissant
+            periods_analysis = periods_analysis.sort_values('nb_interventions', ascending=False)
+            
+            return periods_analysis, f"✅ Analyse des périodes d'interventions pour {len(periods_analysis)} parcelles"
+            
+        except Exception as e:
+            return None, f"❌ Erreur lors de l'analyse des périodes: {str(e)}"
+    
+    def create_ift_ranking_chart(self, year, n_parcels=10):
+        """Crée un graphique des parcelles avec les IFT les plus élevés"""
+        try:
+            data, message = self.get_top_ift_parcels_by_year(year, n_parcels)
+            
+            if data is None or len(data) == 0:
+                fig = px.bar(title=f"❌ {message}")
+                fig.add_annotation(text=message, xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+                return fig
+            
+            # Créer le nom d'affichage pour les parcelles
+            if 'nomparc' in data.columns:
+                data['parcelle_display'] = data['numparcell'].astype(str) + ' (' + data['nomparc'].astype(str) + ')'
+            else:
+                data['parcelle_display'] = data['numparcell'].astype(str)
+            
+            fig = px.bar(
+                data,
+                x='IFT_herbicide',
+                y='parcelle_display',
+                orientation='h',
+                title=f"🏆 Top {n_parcels} Parcelles - IFT Herbicide {year}",
+                labels={
+                    'IFT_herbicide': 'IFT Herbicide',
+                    'parcelle_display': 'Parcelle'
+                },
+                hover_data=['quantite_totale', 'nb_produits_uniques', 'surfparc'] if 'surfparc' in data.columns else ['quantite_totale', 'nb_produits_uniques']
+            )
+            
+            fig.update_layout(
+                width=800,
+                height=600,
+                yaxis={'categoryorder': 'total ascending'}
+            )
+            
+            return fig
+            
+        except Exception as e:
+            fig = px.bar(title=f"❌ Erreur lors de la création du graphique")
+            fig.add_annotation(text=str(e)[:100], xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+    
+    def create_product_timeline_chart(self, parcel_id, n_years=5):
+        """Crée un graphique chronologique des produits utilisés sur une parcelle"""
+        try:
+            data, message = self.get_parcel_products_history(parcel_id, n_years)
+            
+            if data is None or len(data) == 0:
+                fig = px.timeline(title=f"❌ {message}")
+                fig.add_annotation(text=message, xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+                return fig
+            
+            # Créer un graphique en barres empilées par année
+            fig = px.bar(
+                data,
+                x='millesime',
+                y='quantitetot',
+                color='produit',
+                title=f"📈 Historique des Herbicides - Parcelle {parcel_id}",
+                labels={
+                    'millesime': 'Année',
+                    'quantitetot': 'Quantité utilisée',
+                    'produit': 'Produit'
+                }
+            )
+            
+            fig.update_layout(width=800, height=500)
+            return fig
+            
+        except Exception as e:
+            fig = px.bar(title=f"❌ Erreur lors de la création du graphique")
+            fig.add_annotation(text=str(e)[:100], xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+    
+    def create_intervention_periods_chart(self, n_years=10):
+        """Crée un graphique des périodes d'interventions herbicides"""
+        try:
+            data, message = self.analyze_intervention_periods(n_years)
+            
+            if data is None or len(data) == 0:
+                fig = px.scatter(title=f"❌ {message}")
+                fig.add_annotation(text=message, xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+                return fig
+            
+            # Créer le nom d'affichage pour les parcelles
+            if 'nomparc' in data.columns:
+                data['parcelle_display'] = data['numparcell'].astype(str) + ' (' + data['nomparc'].astype(str) + ')'
+            else:
+                data['parcelle_display'] = data['numparcell'].astype(str)
+            
+            # Graphique scatter avec le nombre d'interventions vs période d'intervention
+            fig = px.scatter(
+                data.head(20),  # Limiter à 20 parcelles pour la lisibilité
+                x='mois_debut',
+                y='nb_interventions',
+                size='quantite_totale',
+                color='nb_produits_uniques',
+                hover_name='parcelle_display',
+                title=f"🗓️ Périodes d'Interventions Herbicides (Top 20 parcelles)",
+                labels={
+                    'mois_debut': 'Mois de début d\'intervention',
+                    'nb_interventions': 'Nombre d\'interventions',
+                    'quantite_totale': 'Quantité totale',
+                    'nb_produits_uniques': 'Nb produits différents'
+                }
+            )
+            
+            # Ajouter les noms des mois sur l'axe X
+            fig.update_xaxis(
+                tickvals=list(range(1, 13)),
+                ticktext=['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun',
+                         'Jul', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc']
+            )
+            
+            fig.update_layout(width=800, height=600)
+            return fig
+            
+        except Exception as e:
+            fig = px.scatter(title=f"❌ Erreur lors de la création du graphique")
+            fig.add_annotation(text=str(e)[:100], xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+    
+    def create_monthly_interventions_heatmap(self, n_years=10):
+        """Crée une heatmap des interventions herbicides par mois et par année"""
+        try:
+            if self.df is None or len(self.df) == 0:
+                fig = go.Figure()
+                fig.add_annotation(text="❌ Aucune donnée disponible", x=0.5, y=0.5)
+                return fig
+            
+            # Filtrer par herbicides et période
+            max_year = self.df['millesime'].max()
+            min_year = max_year - n_years + 1
+            
+            herbicides_data = self.df[
+                (self.df['familleprod'] == 'Herbicides') &
+                (self.df['millesime'] >= min_year)
+            ].copy()
+            
+            if len(herbicides_data) == 0:
+                fig = go.Figure()
+                fig.add_annotation(text="❌ Aucune donnée d'herbicides", x=0.5, y=0.5)
+                return fig
+            
+            # Convertir les dates et extraire le mois
+            herbicides_data['datedebut_parsed'] = pd.to_datetime(
+                herbicides_data['datedebut'], 
+                format='%d/%m/%y', 
+                errors='coerce'
+            )
+            
+            valid_dates = herbicides_data.dropna(subset=['datedebut_parsed'])
+            if len(valid_dates) == 0:
+                fig = go.Figure()
+                fig.add_annotation(text="❌ Aucune date valide", x=0.5, y=0.5)
+                return fig
+            
+            valid_dates['mois'] = valid_dates['datedebut_parsed'].dt.month
+            
+            # Créer la matrice mois x année
+            heatmap_data = valid_dates.groupby(['millesime', 'mois']).size().reset_index()
+            heatmap_data.columns = ['annee', 'mois', 'nb_interventions']
+            
+            # Pivoter pour créer la matrice
+            heatmap_matrix = heatmap_data.pivot(index='mois', columns='annee', values='nb_interventions').fillna(0)
+            
+            # Créer la heatmap
+            fig = px.imshow(
+                heatmap_matrix,
+                title="🗓️ Heatmap des Interventions Herbicides par Mois et Année",
+                labels={
+                    'x': 'Année',
+                    'y': 'Mois',
+                    'color': 'Nb interventions'
+                },
+                aspect="auto"
+            )
+            
+            # Personnaliser les étiquettes des mois
+            month_labels = ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun',
+                           'Jul', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc']
+            fig.update_yaxis(
+                tickvals=list(range(1, 13)),
+                ticktext=[month_labels[i-1] for i in range(1, 13) if i in heatmap_matrix.index]
+            )
+            
+            fig.update_layout(width=800, height=500)
+            return fig
+            
+        except Exception as e:
+            fig = go.Figure()
+            fig.add_annotation(text=f"❌ Erreur: {str(e)[:100]}", x=0.5, y=0.5)
+            return fig