updated

app.py

@@ -12,7 +12,7 @@ from plotly.subplots import make_subplots
 import warnings
 from datasets import load_dataset
 import pandas as pd
-from huggingface_hub import HfApi
+from huggingface_hub import HfApi, hf_hub_download
 import urllib.parse
 warnings.filterwarnings('ignore')
 
@@ -31,61 +31,135 @@ class AgricultureAnalyzer:
 
     def load_data(self):
         """Charge les données du dataset Hugging Face"""
+        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 = None
+
+        # 1) Tentative de chargement direct via datasets.load_dataset
         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'}")
-            
-            # Tentative de chargement direct
             dataset = load_dataset(
-                dataset_id, 
-                split="train", 
-                token=hf_token
+                dataset_id,
+                split="train",
+                token=hf_token,
+                trust_remote_code=True,
             )
-            
             print(f"📊 Dataset chargé: {len(dataset)} exemples")
-            
-            # Conversion en pandas avec gestion d'erreur
+
             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...")
-                
-                # Conversion manuelle
                 data_list = []
                 for i, item in enumerate(dataset):
                     data_list.append(item)
-                    if i < 5:  # Afficher les 5 premiers pour debug
+                    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")
-            
-            print(f"📊 Données chargées: {len(self.df)} lignes")
-            print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
-            
-            # 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")
         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 (csv/parquet/tsv/json)
+            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 "❌ Impossible de charger les données"
+
+        print(f"📊 Données chargées: {len(self.df)} lignes")
+        print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
+
+        # 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"❌ Erreur lors du chargement du dataset : {str(e)}"
+            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")
+
+    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
+            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 f"Fallback échoué: {e}"
 
     
     def analyze_data(self):
@@ -414,7 +488,7 @@ def create_interface():
                 """)
             
             with gr.TabItem("🌾 Recommandations"):
-                gr.Markdown(analyzer.get_low_risk_recommendations())
+                reco_output = gr.Markdown(analyzer.get_low_risk_recommendations())
                 
                 gr.Markdown("""
                 ## 💡 Conseils pour la gestion des adventices
@@ -485,7 +559,7 @@ def create_interface():
         
         refresh_btn.click(
             refresh_data,
-            outputs=[stats_output, culture_plot, risk_dist_plot, risk_plot]
+            outputs=[stats_output, culture_plot, risk_dist_plot, risk_plot, reco_output]
         )
     
     return demo

requirements.txt

@@ -7,4 +7,5 @@ plotly>=5.0.0
 scipy>=1.7.0
 scikit-learn>=1.0.0
 datasets>=2.0.0
-huggingface_hub>=0.16.0
+huggingface_hub>=0.16.0
+pyarrow>=14.0.0