updated

analyzer.py

@@ -391,6 +391,73 @@ class AgricultureAnalyzer:
         
         return parcels_info
     
+    def get_available_parcels_for_year(self, year):
+        """Retourne la liste des parcelles disponibles pour une année donnée"""
+        if self.df is None or len(self.df) == 0:
+            return [("Toutes les parcelles", "ALL")]
+        
+        # Filtrer par année si spécifiée
+        if year is not None:
+            year_data = self.df[self.df['millesime'] == year]
+        else:
+            year_data = self.df
+        
+        if len(year_data) == 0:
+            return [("Toutes les parcelles", "ALL")]
+        
+        # Créer une liste avec numéro et nom de parcelle si disponible
+        parcels_info = []
+        
+        if 'nomparc' in year_data.columns:
+            # Grouper par parcelle et prendre le premier nom (en cas de doublons)
+            parcels_data = year_data.groupby('numparcell')['nomparc'].first().reset_index()
+            for _, row in parcels_data.iterrows():
+                parcel_id = str(row['numparcell'])
+                parcel_name = str(row['nomparc']) if pd.notna(row['nomparc']) else ""
+                if parcel_name and parcel_name != "nan":
+                    display_name = f"{parcel_id} - {parcel_name}"
+                else:
+                    display_name = parcel_id
+                parcels_info.append((display_name, parcel_id))
+        else:
+            # Seulement les numéros de parcelles
+            unique_parcels = sorted(year_data['numparcell'].dropna().unique())
+            parcels_info = [(str(p), str(p)) for p in unique_parcels]
+        
+        # Ajouter l'option "Toutes les parcelles" en premier
+        parcels_info.insert(0, ("Toutes les parcelles", "ALL"))
+        
+        return parcels_info
+    
+    def get_available_years_for_parcel(self, parcel_id):
+        """Retourne la liste des années disponibles pour une parcelle donnée"""
+        if self.df is None or len(self.df) == 0:
+            return ["Toutes les années"]
+        
+        # Filtrer par parcelle si spécifiée
+        if parcel_id is not None and parcel_id != "ALL":
+            try:
+                # Convertir en entier si c'est une chaîne
+                if isinstance(parcel_id, str) and parcel_id.isdigit():
+                    parcel_id_converted = int(parcel_id)
+                else:
+                    parcel_id_converted = parcel_id
+                
+                parcel_data = self.df[self.df['numparcell'] == parcel_id_converted]
+            except (ValueError, TypeError):
+                parcel_data = self.df[self.df['numparcell'] == parcel_id]
+        else:
+            parcel_data = self.df
+        
+        if len(parcel_data) == 0:
+            return ["Toutes les années"]
+        
+        # Récupérer les années disponibles et les trier
+        available_years = sorted(parcel_data['millesime'].dropna().unique())
+        year_choices = ["Toutes les années"] + [str(year) for year in available_years]
+        
+        return year_choices
+    
     def filter_data_by_parcel(self, parcel_id):
         """Filtre les données par parcelle"""
         if self.df is None or parcel_id is None or parcel_id == "ALL":
@@ -421,6 +488,7 @@ class AgricultureAnalyzer:
                     parcel_id_converted = parcel_id
                 
                 filtered_data = filtered_data[filtered_data['numparcell'] == parcel_id_converted]
+                
             except (ValueError, TypeError):
                 # En cas d'erreur de conversion, essayer tel quel
                 filtered_data = filtered_data[filtered_data['numparcell'] == parcel_id]
@@ -433,10 +501,21 @@ class AgricultureAnalyzer:
             filtered_data = self.filter_data_by_year_and_parcel(year, parcel_id)
             
             if filtered_data is None or len(filtered_data) == 0:
+                # Construire un message d'erreur informatif avec les données disponibles
+                available_years = sorted(self.df['millesime'].unique()) if self.df is not None else []
+                available_parcels = sorted(self.df['numparcell'].unique()) if self.df is not None else []
+                
                 if parcel_id and parcel_id != "ALL":
-                    return None, f"❌ Aucune donnée pour l'année {year} et la parcelle {parcel_id}"
+                    error_msg = f"❌ Aucune donnée pour l'année {year} et la parcelle {parcel_id}\n\n"
+                    error_msg += f"📅 **Années disponibles**: {', '.join(map(str, available_years))}\n"
+                    error_msg += f"🏠 **Parcelles disponibles**: {', '.join(map(str, available_parcels[:10]))}"
+                    if len(available_parcels) > 10:
+                        error_msg += f" (et {len(available_parcels)-10} autres...)"
+                    return None, error_msg
                 else:
-                    return None, f"❌ Aucune donnée pour l'année {year}"
+                    error_msg = f"❌ Aucune donnée pour l'année {year}\n\n"
+                    error_msg += f"📅 **Années disponibles**: {', '.join(map(str, available_years))}"
+                    return None, error_msg
             
             # Sélectionner les colonnes les plus importantes pour l'affichage
             display_cols = []

interface.py

@@ -253,7 +253,28 @@ class AgricultureInterface:
             wrap=True
         )
         
-        # Fonction de mise à jour
+        # Fonction de mise à jour des parcelles disponibles selon l'année
+        def update_parcel_choices(selected_year):
+            year = None if selected_year == "Toutes les années" else int(selected_year)
+            parcels_for_year = self.analyzer.get_available_parcels_for_year(year)
+            parcel_choices = [choice[0] for choice in parcels_for_year]
+            return gr.Dropdown(choices=parcel_choices, value="Toutes les parcelles")
+        
+        # Fonction de mise à jour des années disponibles selon la parcelle
+        def update_year_choices(selected_parcel):
+            # Convertir la sélection de parcelle en ID
+            parcel_id = None
+            if selected_parcel != "Toutes les parcelles":
+                current_parcels = self.analyzer.get_available_parcels()
+                for choice in current_parcels:
+                    if choice[0] == selected_parcel:
+                        parcel_id = choice[1] if choice[1] != "ALL" else None
+                        break
+            
+            years_for_parcel = self.analyzer.get_available_years_for_parcel(parcel_id)
+            return gr.Dropdown(choices=years_for_parcel, value="Toutes les années")
+        
+        # Fonction de mise à jour des données
         def update_data_view(selected_year, selected_parcel):
             # Convertir les sélections
             year = None if selected_year == "Toutes les années" else int(selected_year)
@@ -261,8 +282,11 @@ class AgricultureInterface:
             # Convertir la sélection de parcelle
             parcel_id = None
             if selected_parcel != "Toutes les parcelles":
+                # Récupérer les parcelles à jour pour éviter les problèmes de cache
+                current_parcels = self.analyzer.get_available_parcels()
+                
                 # Récupérer l'ID de la parcelle depuis les données disponibles
-                for choice in available_parcels:
+                for choice in current_parcels:
                     if choice[0] == selected_parcel:
                         parcel_id = choice[1] if choice[1] != "ALL" else None
                         break
@@ -279,8 +303,12 @@ class AgricultureInterface:
                 data_table
             )
         
-        # Connecter les événements
+        # Connecter les événements pour les dropdowns dynamiques
         year_selector.change(
+            update_parcel_choices,
+            inputs=[year_selector],
+            outputs=[parcel_selector]
+        ).then(
             update_data_view,
             inputs=[year_selector, parcel_selector],
             outputs=[
@@ -292,6 +320,10 @@ class AgricultureInterface:
         )
         
         parcel_selector.change(
+            update_year_choices,
+            inputs=[parcel_selector],
+            outputs=[year_selector]
+        ).then(
             update_data_view,
             inputs=[year_selector, parcel_selector],
             outputs=[
@@ -318,12 +350,13 @@ class AgricultureInterface:
         
         - **Sélection d'année** : Filtrez les données par millésime
         - **Sélection de parcelle** : Filtrez les données par parcelle spécifique
+        - **Filtrage intelligent** : Les choix se mettent à jour automatiquement selon votre sélection
         - **Graphique des interventions** : Types d'interventions les plus fréquents
         - **Activité mensuelle** : Répartition des interventions par mois
         - **Tableau détaillé** : Données brutes avec colonnes importantes
         
         > 📝 **Note** : Le tableau est limité à 1000 lignes pour des raisons de performance
-        > 🔄 **Astuce** : Combinez année et parcelle pour un filtrage précis
+        > 🔄 **Astuce** : Les listes se mettent à jour dynamiquement - sélectionnez une année pour voir ses parcelles !
         """)
     
     def _safe_create_data_table(self, year, parcel_id=None):