updated

debug_parcelles.py

@@ -0,0 +1,38 @@
+"""
+Debug des noms de parcelles
+"""
+
+from data_loader import AgriculturalDataLoader
+
+def debug_plot_names():
+    loader = AgriculturalDataLoader()
+    df = loader.load_all_files()
+    
+    print("🔍 Analyse des noms de parcelles...")
+    
+    # Toutes les parcelles uniques
+    all_plots = df['plot_name'].unique()
+    print(f"Nombre total de parcelles: {len(all_plots)}")
+    
+    # Chercher des variations de "Champ ferme Bas"
+    champ_ferme_variants = [p for p in all_plots if 'champ' in p.lower() and 'ferme' in p.lower()]
+    print(f"\nVariantes de 'Champ ferme':")
+    for variant in sorted(champ_ferme_variants):
+        count = len(df[df['plot_name'] == variant])
+        print(f"  '{variant}': {count} interventions")
+    
+    # Parcelles les plus fréquentes
+    plot_counts = df['plot_name'].value_counts().head(10)
+    print(f"\nTop 10 des parcelles par nombre d'interventions:")
+    for plot, count in plot_counts.items():
+        print(f"  '{plot}': {count} interventions")
+    
+    # Vérifier les herbicides par parcelle
+    herbicide_df = df[df['is_herbicide'] == True]
+    herbicide_plots = herbicide_df['plot_name'].value_counts().head(10)
+    print(f"\nTop 10 des parcelles avec herbicides:")
+    for plot, count in herbicide_plots.items():
+        print(f"  '{plot}': {count} applications herbicides")
+
+if __name__ == "__main__":
+    debug_plot_names()

mcp_server.py

@@ -92,44 +92,93 @@ analyzer = WeedPressureAnalyzer()
 def analyze_herbicide_trends(years_range, plot_filter):
     """Analyze herbicide usage trends over time."""
     try:
-        if len(years_range) == 2:
+        # Gestion du slider Gradio qui peut retourner différents formats
+        if isinstance(years_range, list) and len(years_range) == 2:
             years = list(range(int(years_range[0]), int(years_range[1]) + 1))
+        elif isinstance(years_range, (int, float)):
+            years = [int(years_range)]
         else:
-            years = [int(y) for y in years_range]
+            years = list(range(2014, 2025))  # Par défaut
+        
+# Debug line removed for production
         
         ift_data = analyzer.calculate_herbicide_ift(years=years)
         
         if len(ift_data) == 0:
-            return None, "Aucune donnée d'herbicides trouvée."
+            return None, "Aucune donnée d'herbicides trouvée pour la période sélectionnée."
         
-        if plot_filter != "Toutes":
+        # Filtrage par parcelle si nécessaire
+        if plot_filter and plot_filter != "Toutes":
             ift_data = ift_data[ift_data['plot_name'] == plot_filter]
         
+        if len(ift_data) == 0:
+            return None, f"Aucune donnée trouvée pour la parcelle '{plot_filter}' sur la période {years[0]}-{years[-1]}."
+        
+        # Création du graphique
         fig = px.line(ift_data, 
                      x='year', 
                      y='ift_herbicide',
                      color='plot_name',
-                     title=f'Évolution de l\'IFT Herbicides',
-                     labels={'ift_herbicide': 'IFT Herbicides', 'year': 'Année'})
+                     title=f'Évolution de l\'IFT Herbicides ({years[0]}-{years[-1]})',
+                     labels={'ift_herbicide': 'IFT Herbicides', 'year': 'Année'},
+                     markers=True)
+        
+        fig.update_layout(
+            height=500,
+            xaxis_title="Année",
+            yaxis_title="IFT Herbicides",
+            legend_title="Parcelle"
+        )
+        
+        # Ajout d'une ligne de référence IFT = 2.0
+        fig.add_hline(y=2.0, line_dash="dash", line_color="red", 
+                     annotation_text="Seuil IFT élevé (2.0)", annotation_position="top right")
+        fig.add_hline(y=1.0, line_dash="dash", line_color="orange", 
+                     annotation_text="Seuil IFT modéré (1.0)", annotation_position="bottom right")
+        
+        # Calcul des statistiques
+        ift_mean = ift_data['ift_herbicide'].mean()
+        ift_max = ift_data['ift_herbicide'].max()
+        ift_min = ift_data['ift_herbicide'].min()
+        n_plots = ift_data['plot_name'].nunique()
+        n_records = len(ift_data)
+        
+        # Classification des niveaux de risque
+        low_risk = len(ift_data[ift_data['ift_herbicide'] < 1.0])
+        moderate_risk = len(ift_data[(ift_data['ift_herbicide'] >= 1.0) & (ift_data['ift_herbicide'] < 2.0)])
+        high_risk = len(ift_data[ift_data['ift_herbicide'] >= 2.0])
         
         summary = f"""
-📊 **Analyse de l'IFT Herbicides**
+📊 **Analyse de l'IFT Herbicides ({years[0]}-{years[-1]})**
 
-**Statistiques:**
-- IFT moyen: {ift_data['ift_herbicide'].mean():.2f}
-- IFT maximum: {ift_data['ift_herbicide'].max():.2f}
-- Nombre de parcelles: {ift_data['plot_name'].nunique()}
+**Période analysée:** {years[0]} à {years[-1]}
+**Parcelle(s):** {plot_filter if plot_filter != "Toutes" else "Toutes les parcelles"}
+
+**Statistiques globales:**
+- IFT moyen: {ift_mean:.2f}
+- IFT minimum: {ift_min:.2f}
+- IFT maximum: {ift_max:.2f}
+- Nombre de parcelles: {n_plots}
+- Nombre d'observations: {n_records}
+
+**Répartition des niveaux de pression:**
+- 🟢 Faible (IFT < 1.0): {low_risk} observations ({low_risk/n_records*100:.1f}%)
+- 🟡 Modérée (1.0 ≤ IFT < 2.0): {moderate_risk} observations ({moderate_risk/n_records*100:.1f}%)
+- 🔴 Élevée (IFT ≥ 2.0): {high_risk} observations ({high_risk/n_records*100:.1f}%)
 
 **Interprétation:**
-- IFT < 1.0: Pression faible ✅
-- IFT 1.0-2.0: Pression modérée ⚠️
-- IFT > 2.0: Pression élevée ❌
+- IFT < 1.0: Pression adventices faible ✅
+- 1.0 ≤ IFT < 2.0: Pression adventices modérée ⚠️
+- IFT ≥ 2.0: Pression adventices élevée ❌
         """
         
         return fig, summary
         
     except Exception as e:
-        return None, f"Erreur: {str(e)}"
+        import traceback
+        error_msg = f"Erreur dans l'analyse: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return None, error_msg
 
 def predict_future_weed_pressure():
     """Predict weed pressure for the next 3 years."""
@@ -236,10 +285,12 @@ def generate_technical_alternatives(herbicide_family):
 def get_available_plots():
     """Get available plots."""
     try:
-        plots = analyzer.data_loader.get_plots_available()
+        df = analyzer.load_data()
+        plots = sorted(df['plot_name'].dropna().unique().tolist())
         return ["Toutes"] + plots
-    except:
-        return ["Toutes"]
+    except Exception as e:
+        print(f"Erreur lors du chargement des parcelles: {e}")
+        return ["Toutes", "Champ ferme Bas", "Etang Milieu", "Lann Chebot"]
 
 # Create Gradio Interface
 def create_mcp_interface():
@@ -252,17 +303,37 @@ def create_mcp_interface():
         
         with gr.Tabs():
             with gr.Tab("📈 Analyse Tendances"):
-                with gr.Row():
-                    years_slider = gr.Slider(2014, 2024, value=[2020, 2024], step=1, label="Période")
-                    plot_dropdown = gr.Dropdown(choices=get_available_plots(), value="Toutes", label="Parcelle")
+                gr.Markdown("### Analyser l'évolution de l'IFT herbicides par parcelle et période")
                 
-                analyze_btn = gr.Button("🔍 Analyser", variant="primary")
+                with gr.Row():
+                    with gr.Column():
+                        years_slider = gr.Slider(
+                            minimum=2014, 
+                            maximum=2025, 
+                            value=[2020, 2025], 
+                            step=1, 
+                            label="Période d'analyse",
+                            info="Sélectionnez la plage d'années à analyser"
+                        )
+                        plot_dropdown = gr.Dropdown(
+                            choices=get_available_plots(), 
+                            value="Toutes", 
+                            label="Filtrer par parcelle",
+                            info="Choisissez une parcelle spécifique ou toutes"
+                        )
+                        analyze_btn = gr.Button("🔍 Analyser les Tendances", variant="primary", size="lg")
                 
                 with gr.Row():
-                    trends_plot = gr.Plot()
-                    trends_summary = gr.Markdown()
+                    with gr.Column(scale=2):
+                        trends_plot = gr.Plot(label="Graphique d'évolution")
+                    with gr.Column(scale=1):
+                        trends_summary = gr.Markdown(label="Résumé statistique")
                 
-                analyze_btn.click(analyze_herbicide_trends, [years_slider, plot_dropdown], [trends_plot, trends_summary])
+                analyze_btn.click(
+                    analyze_herbicide_trends, 
+                    inputs=[years_slider, plot_dropdown], 
+                    outputs=[trends_plot, trends_summary]
+                )
             
             with gr.Tab("🔮 Prédictions"):
                 predict_btn = gr.Button("🎯 Prédire 2025-2027", variant="primary")

quick_test.py

@@ -0,0 +1,29 @@
+"""
+Test rapide de l'interface complète
+"""
+
+import gradio as gr
+from mcp_server import create_mcp_interface
+
+if __name__ == "__main__":
+    print("🚀 Test de l'interface Gradio complète...")
+    
+    try:
+        demo = create_mcp_interface()
+        print("✅ Interface créée avec succès")
+        
+        # Test de lancement (sans vraiment lancer)
+        print("✅ Interface prête pour le déploiement")
+        
+        # Test d'une fonction
+        from mcp_server import analyze_herbicide_trends
+        fig, summary = analyze_herbicide_trends([2022, 2024], "Toutes")
+        if fig is not None:
+            print("✅ Fonction d'analyse fonctionnelle")
+        else:
+            print("❌ Problème avec l'analyse")
+            
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        import traceback
+        traceback.print_exc()

requirements.txt

@@ -1,5 +1,4 @@
-gradio>=4.44.0
-pandas>=2.0.0
+gradio[mcp]>=5.46.0pandas>=2.0.0
 numpy>=1.24.0
 plotly>=5.0.0
 datasets>=2.14.0

test_analysis.py

@@ -0,0 +1,109 @@
+"""
+Script de test pour diagnostiquer les problèmes d'analyse des tendances
+"""
+
+import pandas as pd
+import numpy as np
+from data_loader import AgriculturalDataLoader
+
+def test_data_loading():
+    """Test du chargement des données"""
+    print("🔍 Test du chargement des données...")
+    
+    try:
+        loader = AgriculturalDataLoader()
+        df = loader.load_all_files()
+        
+        print(f"✅ Données chargées: {len(df)} lignes")
+        print(f"📋 Colonnes disponibles: {list(df.columns)}")
+        print(f"📊 Types de données:")
+        print(df.dtypes)
+        
+        return df
+    except Exception as e:
+        print(f"❌ Erreur lors du chargement: {e}")
+        return None
+
+def test_herbicide_analysis(df):
+    """Test de l'analyse des herbicides"""
+    print("\n🧪 Test de l'analyse des herbicides...")
+    
+    if df is None:
+        return
+    
+    # Vérifier les colonnes nécessaires
+    required_cols = ['is_herbicide', 'plot_name', 'year', 'crop_type', 'produit', 'plot_surface']
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    
+    if missing_cols:
+        print(f"❌ Colonnes manquantes: {missing_cols}")
+        return
+    
+    # Filtrer les herbicides
+    herbicide_df = df[df['is_herbicide'] == True].copy()
+    print(f"📊 Nombre d'applications herbicides: {len(herbicide_df)}")
+    
+    if len(herbicide_df) == 0:
+        print("❌ Aucune donnée d'herbicides trouvée")
+        print("🔍 Vérification des valeurs 'is_herbicide':")
+        print(df['is_herbicide'].value_counts())
+        
+        print("🔍 Vérification des familles de produits:")
+        if 'familleprod' in df.columns:
+            print(df['familleprod'].value_counts())
+        
+        return
+    
+    print(f"✅ Données herbicides trouvées: {len(herbicide_df)} applications")
+    
+    # Test du calcul IFT
+    print("\n📈 Test du calcul IFT...")
+    
+    try:
+        ift_summary = herbicide_df.groupby(['plot_name', 'year', 'crop_type']).agg({
+            'produit': 'count',
+            'plot_surface': 'first',
+            'quantitetot': 'sum'
+        }).reset_index()
+        
+        ift_summary['ift_herbicide'] = ift_summary['produit'] / ift_summary['plot_surface']
+        
+        print(f"✅ IFT calculé pour {len(ift_summary)} combinaisons parcelle/année/culture")
+        print(f"📊 IFT moyen: {ift_summary['ift_herbicide'].mean():.2f}")
+        print(f"📊 IFT max: {ift_summary['ift_herbicide'].max():.2f}")
+        
+        print("\n📋 Échantillon des données IFT:")
+        print(ift_summary.head())
+        
+        return ift_summary
+        
+    except Exception as e:
+        print(f"❌ Erreur dans le calcul IFT: {e}")
+        return None
+
+def test_years_and_plots(df):
+    """Test des années et parcelles disponibles"""
+    print("\n📅 Test des années et parcelles...")
+    
+    if df is None:
+        return
+    
+    years = sorted(df['year'].dropna().unique())
+    plots = sorted(df['plot_name'].dropna().unique())
+    
+    print(f"📅 Années disponibles: {years}")
+    print(f"🏞️ Parcelles disponibles: {plots}")
+    
+    # Test par année
+    print("\n📊 Données par année:")
+    year_counts = df.groupby('year').size()
+    print(year_counts)
+
+if __name__ == "__main__":
+    print("🚜 Test de l'analyse des tendances herbicides\n")
+    
+    df = test_data_loading()
+    test_herbicide_analysis(df)
+    test_years_and_plots(df)
+    
+    print("\n✅ Tests terminés")

test_gradio.py

@@ -0,0 +1,45 @@
+"""
+Script de test pour l'interface Gradio
+"""
+
+from mcp_server import analyze_herbicide_trends, get_available_plots
+
+def test_function_calls():
+    """Test des fonctions individuelles"""
+    print("🧪 Test des fonctions...")
+    
+    # Test get_available_plots
+    print("\n📋 Test get_available_plots():")
+    plots = get_available_plots()
+    print(f"Parcelles disponibles: {len(plots)} - {plots[:5]}...")
+    
+    # Test analyze_herbicide_trends avec différents paramètres
+    print("\n📈 Test analyze_herbicide_trends():")
+    
+    # Test 1: Période normale
+    print("Test 1: Période 2020-2024, toutes parcelles")
+    fig, summary = analyze_herbicide_trends([2020, 2024], "Toutes")
+    if fig is not None:
+        print("✅ Graphique généré avec succès")
+        print("📊 Résumé:", summary[:200] + "...")
+    else:
+        print("❌ Erreur:", summary)
+    
+    # Test 2: Parcelle spécifique
+    print("\nTest 2: Période 2020-2024, parcelle spécifique")
+    fig, summary = analyze_herbicide_trends([2020, 2024], "Champ ferme W du sol")
+    if fig is not None:
+        print("✅ Graphique généré avec succès")
+    else:
+        print("❌ Erreur:", summary)
+    
+    # Test 3: Format année simple
+    print("\nTest 3: Année simple")
+    fig, summary = analyze_herbicide_trends(2023, "Toutes")
+    if fig is not None:
+        print("✅ Graphique généré avec succès")
+    else:
+        print("❌ Erreur:", summary)
+
+if __name__ == "__main__":
+    test_function_calls()