updated

app.py

@@ -32,66 +32,132 @@ class AgricultureAnalyzer:
     def load_data(self):
         """Charge les données du dataset Hugging Face"""
         try:
+            print("🔄 Chargement des données depuis Hugging Face...")
+            print(f"📋 Dataset ID: {dataset_id}")
+            print(f"📋 Token disponible: {'Oui' if hf_token else 'Non'}")
+            
             self.df = load_dataset(
                 dataset_id, 
                 split="train", 
-                token=hf_token  # ou use_auth_token=hf_token selon la version
+                token=hf_token
             ).to_pandas()
             
-            print(f"📊 Données brutes chargées: {len(self.df)} lignes")
+            print(f"📊 Données chargées: {len(self.df)} lignes")
             print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
             
-            # Nettoyage éventuel (ex: suppression NA)
-            self.df = self.df.dropna(subset=["numparcell", "surfparc", "millesime"])
+            # Nettoyage et validation
+            required_columns = ["numparcell", "surfparc", "millesime"]
+            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")
-            if len(self.df) > 0:
-                print(f"📊 Herbicides présents: {(self.df['familleprod'] == 'Herbicides').sum()} interventions")
-                print(f"📊 Cultures: {self.df['libelleusag'].nunique()} types différents")
             
-            return f"✅ Données chargées avec succès : {len(self.df)} enregistrements"
-        
+            if len(self.df) > 0:
+                herbicides_count = (self.df['familleprod'] == 'Herbicides').sum() if 'familleprod' in self.df.columns else 0
+                cultures_count = self.df['libelleusag'].nunique() if 'libelleusag' in self.df.columns else 0
+                print(f"📊 Herbicides présents: {herbicides_count} interventions")
+                print(f"📊 Cultures: {cultures_count} types différents")
+                
+                return f"✅ Données chargées avec succès : {len(self.df)} enregistrements"
+            else:
+                self.df = None
+                return "❌ Aucune donnée valide après nettoyage"
+                
         except Exception as e:
-            print(f"❌ Erreur détaillée: {str(e)}")
+            print(f"❌ Erreur lors du chargement depuis Hugging Face: {str(e)}")
+            print(f"❌ Type d'erreur: {type(e).__name__}")
+            self.df = None
             return f"❌ Erreur lors du chargement du dataset : {str(e)}"
 
     
     def analyze_data(self):
         """Analyse des données et calcul des risques"""
-        if self.df is None:
+        if self.df is None or len(self.df) == 0:
+            print("❌ Pas de données à analyser")
             return "Erreur: Aucune donnée chargée"
         
-        # Analyse générale
-        general_stats = {
-            '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()}"
-        }
-        
-        # Analyse des herbicides
-        herbicides_df = self.df[self.df['familleprod'] == 'Herbicides'].copy()
-        herbicide_stats = {
-            'nb_interventions_herbicides': len(herbicides_df),
-            'pourcentage_herbicides': (len(herbicides_df) / len(self.df)) * 100,
-            'parcelles_traitees': herbicides_df['numparcell'].nunique()
-        }
-        
-        # Calcul de l'analyse des risques
-        self.calculate_risk_analysis()
-        
-        return general_stats, herbicide_stats
+        try:
+            print(f"🔄 Début de l'analyse sur {len(self.df)} enregistrements...")
+            
+            # Analyse générale
+            general_stats = {
+                '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()}"
+            }
+            
+            # Analyse des herbicides
+            if 'familleprod' in self.df.columns:
+                herbicides_df = self.df[self.df['familleprod'] == 'Herbicides'].copy()
+                herbicide_stats = {
+                    'nb_interventions_herbicides': len(herbicides_df),
+                    'pourcentage_herbicides': (len(herbicides_df) / len(self.df)) * 100,
+                    'parcelles_traitees': herbicides_df['numparcell'].nunique()
+                }
+            else:
+                herbicide_stats = {
+                    'nb_interventions_herbicides': 0,
+                    'pourcentage_herbicides': 0,
+                    'parcelles_traitees': 0
+                }
+            
+            # 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_risk_analysis(self):
         """Calcule l'analyse des risques par parcelle"""
-        # Groupement des données par parcelle
-        risk_analysis = self.df.groupby(['numparcell', 'nomparc', 'libelleusag', 'surfparc']).agg({
-            'familleprod': lambda x: (x == 'Herbicides').sum(),  # Nb traitements herbicides
-            'libevenem': lambda x: len(x.unique()),  # Diversité des événements
-            'produit': lambda x: len(x.unique()),  # Diversité des produits
-            'quantitetot': 'sum'  # Quantité totale
-        }).round(2)
+        try:
+            print("🔄 Calcul de l'analyse des risques...")
+            
+            # Vérifier les colonnes nécessaires
+            required_group_cols = ['numparcell', 'surfparc']
+            optional_group_cols = ['nomparc', 'libelleusag']
+            
+            # 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 = {}
+            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'
+            
+            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)
         
         # Quantités d'herbicides spécifiques
         herbicide_quantities = self.df[self.df['familleprod'] == 'Herbicides'].groupby(