testtest5

app.py

@@ -1,4 +1,5 @@
 import os
+import glob
 import tempfile
 import numpy as np
 import pandas as pd
@@ -8,38 +9,69 @@ import joblib
 import soundfile as sf
 from pydub import AudioSegment
 import opensmile
-
 import freesound
 import xgboost as xgb
 
-from sklearn.feature_extraction.text import HashingVectorizer
-
 
-# ============================================================
+# =========================
 # CONFIG
-# ============================================================
+# =========================
 MIN_EFFECT, MAX_EFFECT = 0.5, 3.0
 MIN_MUSIC, MAX_MUSIC = 10.0, 60.0
 SR_TARGET = 16000
 
-# HF Space Secret: FREESOUND_TOKEN
 FREESOUND_TOKEN = os.getenv("FREESOUND_TOKEN", "").strip()
-
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
+
+# =========================
+# Helpers fichiers
+# =========================
 def p(*parts):
     return os.path.join(BASE_DIR, *parts)
 
-def load_local(path_rel: str):
-    full = p(path_rel)
-    if not os.path.exists(full):
-        raise FileNotFoundError(f"Fichier introuvable: {path_rel}")
-    return joblib.load(full)
-
-
-# ============================================================
-# UI
-# ============================================================
+def list_local_files():
+    files = []
+    for root, _, fnames in os.walk(BASE_DIR):
+        for f in fnames:
+            if f.lower().endswith((".pkl", ".joblib", ".json", ".bin", ".txt")):
+                rel = os.path.relpath(os.path.join(root, f), BASE_DIR)
+                files.append(rel)
+    return sorted(files)
+
+def exists(rel_path: str) -> bool:
+    return os.path.exists(p(rel_path))
+
+def load_joblib_any(candidates):
+    """
+    Essaie une liste de chemins relatifs (ou patterns glob).
+    Retourne (obj, chosen_path) ou (None, None).
+    """
+    for c in candidates:
+        if any(ch in c for ch in ["*", "?", "["]):
+            matches = sorted(glob.glob(p(c)))
+            if not matches:
+                continue
+            chosen = matches[0]
+            try:
+                obj = joblib.load(chosen)
+                return obj, os.path.relpath(chosen, BASE_DIR)
+            except Exception:
+                continue
+        else:
+            full = p(c)
+            if os.path.exists(full):
+                try:
+                    obj = joblib.load(full)
+                    return obj, c
+                except Exception:
+                    continue
+    return None, None
+
+
+# =========================
+# UI helpers
+# =========================
 CSS = """
 .card { border: 1px solid #e5e7eb; background: #ffffff; padding: 16px; border-radius: 16px; }
 .card-error{ border-color: #fca5a5; background: #fff1f2; }
@@ -53,9 +85,9 @@ CSS = """
 .box-title{ font-weight:900; margin-bottom:4px; }
 .box-value{ font-size:18px; font-weight:800; }
 .hint{ margin-top:10px; color:#6b7280; font-size:12px; }
+pre{ white-space:pre-wrap; }
 #header-title { font-size: 28px; font-weight: 950; margin-bottom: 6px; }
 #header-sub { color:#6b7280; margin-top:0px; line-height:1.45; }
-pre{ white-space:pre-wrap; }
 """
 
 def html_error(title, body_html):
@@ -137,32 +169,38 @@ def parse_sound_id(url: str):
     return int(url.rstrip("/").split("/")[-1])
 
 
-# ============================================================
-# FREESOUND CLIENT
-# ============================================================
+# =========================
+# FreeSound client
+# =========================
 def get_fs_client():
     if not FREESOUND_TOKEN:
-        raise RuntimeError("Token FreeSound manquant. Ajoute le secret FREESOUND_TOKEN dans le Space.")
+        raise RuntimeError("Token FreeSound manquant. Ajoute le secret FREESOUND_TOKEN (Settings → Secrets).")
     c = freesound.FreesoundClient()
     c.set_token(FREESOUND_TOKEN, "token")
     return c
 
 
 # ============================================================
-# PARTIE A — Upload audio → openSMILE → modèles
-# (depuis app (2).py)
+# PARTIE A — OpenSMILE (upload)
 # ============================================================
-MODEL_EFFECT_A = load_local("xgb_model_EffectSound.pkl")
-MODEL_MUSIC_A  = load_local("xgb_model_Music.pkl")
-
-RATING_DISPLAY_AUDIO = {0: "❌ Informations manquantes", 1: "⭐ Faible", 2: "⭐⭐ Moyen", 3: "⭐⭐⭐ Élevé"}
-DOWNLOADS_DISPLAY_AUDIO = {0: "⭐ Faible", 1: "⭐⭐ Moyen", 2: "⭐⭐⭐ Élevé"}
-
 SMILE = opensmile.Smile(
     feature_set=opensmile.FeatureSet.eGeMAPSv02,
     feature_level=opensmile.FeatureLevel.Functionals,
 )
 
+RATING_DISPLAY_AUDIO = {0: "❌ Informations manquantes", 1: "⭐ Faible", 2: "⭐⭐ Moyen", 3: "⭐⭐⭐ Élevé"}
+DOWNLOADS_DISPLAY_AUDIO = {0: "⭐ Faible", 1: "⭐⭐ Moyen", 2: "⭐⭐⭐ Élevé"}
+
+MODEL_EFFECT_A, PATH_EFFECT_A = load_joblib_any([
+    "xgb_model_EffectSound.pkl",
+    "xgb_model_effectsound.pkl",
+    "xgb_model_effectSound.pkl",
+])
+MODEL_MUSIC_A, PATH_MUSIC_A = load_joblib_any([
+    "xgb_model_Music.pkl",
+    "xgb_model_music.pkl",
+])
+
 def get_duration_seconds(filepath):
     ext = os.path.splitext(filepath)[1].lower()
     if ext == ".mp3":
@@ -194,68 +232,74 @@ def extract_opensmile_features(filepath):
     return feats
 
 def predict_upload_with_dmatrix(model, X_df: pd.DataFrame):
-    if hasattr(model, "estimators_"):
-        preds = []
-        for est in model.estimators_:
-            booster = est.get_booster() if hasattr(est, "get_booster") else est
-            dm = xgb.DMatrix(X_df.values, feature_names=list(X_df.columns))
-            p = booster.predict(dm)
-            preds.append(np.asarray(p).reshape(-1))
-        return np.column_stack(preds)
-
+    # sklearn wrapper or Booster
     booster = model.get_booster() if hasattr(model, "get_booster") else model
     dm = xgb.DMatrix(X_df.values, feature_names=list(X_df.columns))
     p = booster.predict(dm)
-    return np.asarray(p).reshape(1, -1)
+    p = np.asarray(p)
+    if p.ndim == 1:
+        # si ton modèle renvoie 2 outputs concat, ça ne marche pas;
+        # ton modèle A semble renvoyer 2 classes (avg, downloads) -> souvent shape (2,)
+        # on force (1, -1)
+        p = p.reshape(1, -1)
+    return p
 
 def predict_opensmile_upload(audio_file):
+    if MODEL_EFFECT_A is None or MODEL_MUSIC_A is None:
+        return html_error(
+            "Modèles OpenSMILE manquants",
+            "Il faut fournir les deux modèles OpenSMILE (effect & music) à la racine, ex: "
+            "<code>xgb_model_EffectSound.pkl</code> et <code>xgb_model_Music.pkl</code>."
+        )
+
     if audio_file is None:
         return html_error("Aucun fichier", "Veuillez importer un fichier audio (wav, mp3, flac…).")
 
     try:
         duration = get_duration_seconds(audio_file)
     except Exception as e:
-        return html_error("Audio illisible", f"Impossible de lire l'audio.<br>Détail : <code>{e}</code>")
+        return html_error("Audio illisible", f"Détail : <code>{e}</code>")
 
     if duration < MIN_EFFECT:
-        return html_error("Audio trop court",
-                          f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
+        return html_error("Audio trop court", f"Durée : <b>{duration:.2f}s</b> — attendu 0.5–3s ou 10–60s")
     if (MAX_EFFECT < duration < MIN_MUSIC) or duration > MAX_MUSIC:
-        return html_error("Audio hors plage",
-                          f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
+        return html_error("Audio hors plage", f"Durée : <b>{duration:.2f}s</b> — attendu 0.5–3s ou 10–60s")
 
     if duration <= MAX_EFFECT:
-        badge = "🔊 OpenSMILE (upload) — EffectSound"
-        model = MODEL_EFFECT_A
+        badge, model = "🔊 OpenSMILE (upload) — EffectSound", MODEL_EFFECT_A
     else:
-        badge = "🎵 OpenSMILE (upload) — Music"
-        model = MODEL_MUSIC_A
+        badge, model = "🎵 OpenSMILE (upload) — Music", MODEL_MUSIC_A
 
     try:
         X = extract_opensmile_features(audio_file)
     except Exception as e:
         return html_error("Extraction openSMILE échouée", f"Détail : <code>{e}</code>")
 
-    # Align features
+    # align features si possible
     try:
-        expected = model.estimators_[0].feature_names_in_ if hasattr(model, "estimators_") else model.feature_names_in_
-        X = X.reindex(columns=list(expected), fill_value=0)
-    except Exception as e:
-        return html_error("Alignement features échoué", f"Détail : <code>{e}</code>")
+        if hasattr(model, "feature_names_in_"):
+            expected = list(model.feature_names_in_)
+            X = X.reindex(columns=expected, fill_value=0)
+    except Exception:
+        # pas bloquant
+        pass
 
     try:
         y = predict_upload_with_dmatrix(model, X)
     except Exception as e:
         return html_error("Prédiction échouée", f"Détail : <code>{e}</code>")
 
-    y = np.array(y)
-    avg_class = int(y[0, 0])
-    dl_class = int(y[0, 1])
+    # Convention attendue : y[0,0]=avg_class, y[0,1]=dl_class
+    try:
+        avg_class = int(y[0, 0])
+        dl_class = int(y[0, 1])
+    except Exception:
+        return html_error("Sortie modèle inattendue", f"Forme sortie: <code>{getattr(y,'shape',None)}</code>")
 
     rating_text = RATING_DISPLAY_AUDIO.get(avg_class, "Inconnu")
     downloads_text = DOWNLOADS_DISPLAY_AUDIO.get(dl_class, "Inconnu")
-
     extra = f"""
+<div class="hint">Modèles chargés: <code>{PATH_EFFECT_A}</code> · <code>{PATH_MUSIC_A}</code></div>
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
 {interpret_results(avg_class, dl_class)}
 </div>
@@ -264,21 +308,94 @@ def predict_opensmile_upload(audio_file):
 
 
 # ============================================================
-# PARTIE B — FreeSound URL → “Acoustic features API fields” → modèles
-# (depuis app (2).py / PARTIE B)
+# PARTIE B — FreeSound Acoustic Features (API fields)
+#   => c’est ici que tu as l’erreur de fichier manquant
 # ============================================================
-xgb_music_num_B       = load_local("xgb_num_downloads_music_model.pkl")
-xgb_music_feat_num_B  = load_local("xgb_num_downloads_music_features.pkl")
-xgb_music_avg_B       = load_local("xgb_avg_rating_music_model.pkl")
-xgb_music_feat_avg_B  = load_local("xgb_avg_rating_music_features.pkl")
-le_music_avg_B        = load_local("xgb_avg_rating_music_label_encoder.pkl")
-
-xgb_effect_num_B      = load_local("xgb_num_downloads_effectsound_model.pkl")
-xgb_effect_feat_num_B = load_local("xgb_num_downloads_effectsound_features.pkl")
-xgb_effect_avg_B      = load_local("xgb_avg_rating_effectsound_model.pkl")
-xgb_effect_feat_avg_B = load_local("xgb_avg_rating_effectsound_features.pkl")
-le_effect_avg_B       = load_local("xgb_avg_rating_effectsound_label_encoder.pkl")
-
+def load_feature_models_B():
+    """
+    Essaie de trouver les fichiers même si tu as des variantes de nom.
+    Retourne dict + liste problèmes.
+    """
+    problems = []
+    M = {}
+
+    # MUSIC
+    M["music_num_model"], M["music_num_model_path"] = load_joblib_any([
+        "xgb_num_downloads_music_model.pkl",
+        "*num*downloads*music*model*.pkl",
+        "*num*downloads*music*model*.joblib",
+    ])
+    M["music_num_feats"], M["music_num_feats_path"] = load_joblib_any([
+        "xgb_num_downloads_music_features.pkl",
+        "*num*downloads*music*features*.pkl",
+        "*num*downloads*music*features*.joblib",
+    ])
+    M["music_avg_model"], M["music_avg_model_path"] = load_joblib_any([
+        "xgb_avg_rating_music_model.pkl",
+        "*avg*rating*music*model*.pkl",
+        "*avg*rating*music*model*.joblib",
+    ])
+    M["music_avg_feats"], M["music_avg_feats_path"] = load_joblib_any([
+        "xgb_avg_rating_music_features.pkl",
+        "*avg*rating*music*features*.pkl",
+        "*avg*rating*music*features*.joblib",
+    ])
+    M["music_avg_le"], M["music_avg_le_path"] = load_joblib_any([
+        "xgb_avg_rating_music_label_encoder.pkl",
+        "*avg*rating*music*label*encoder*.pkl",
+        "*avg*rating*music*label*encoder*.joblib",
+    ])
+
+    # EFFECTSOUND (variantes de nom)
+    M["eff_num_model"], M["eff_num_model_path"] = load_joblib_any([
+        "xgb_num_downloads_effectsound_model.pkl",
+        "xgb_num_downloads_effectSound_model.pkl",
+        "xgb_num_downloads_effect_sound_model.pkl",
+        "*num*downloads*effect*model*.pkl",
+        "*num*downloads*effect*model*.joblib",
+    ])
+    M["eff_num_feats"], M["eff_num_feats_path"] = load_joblib_any([
+        "xgb_num_downloads_effectsound_features.pkl",
+        "xgb_num_downloads_effectSound_features.pkl",
+        "xgb_num_downloads_effect_sound_features.pkl",
+        "*num*downloads*effect*features*.pkl",
+        "*num*downloads*effect*features*.joblib",
+    ])
+    M["eff_avg_model"], M["eff_avg_model_path"] = load_joblib_any([
+        "xgb_avg_rating_effectsound_model.pkl",
+        "xgb_avg_rating_effectSound_model.pkl",
+        "xgb_avg_rating_effect_sound_model.pkl",
+        "*avg*rating*effect*model*.pkl",
+        "*avg*rating*effect*model*.joblib",
+    ])
+    M["eff_avg_feats"], M["eff_avg_feats_path"] = load_joblib_any([
+        # <-- c’est exactement celui qui manque chez toi, on met plein de variantes
+        "xgb_avg_rating_effectsound_features.pkl",
+        "xgb_avg_rating_effectSound_features.pkl",
+        "xgb_avg_rating_effect_sound_features.pkl",
+        "*avg*rating*effect*features*.pkl",
+        "*avg*rating*effect*features*.joblib",
+    ])
+    M["eff_avg_le"], M["eff_avg_le_path"] = load_joblib_any([
+        "xgb_avg_rating_effectsound_label_encoder.pkl",
+        "xgb_avg_rating_effectSound_label_encoder.pkl",
+        "xgb_avg_rating_effect_sound_label_encoder.pkl",
+        "*avg*rating*effect*label*encoder*.pkl",
+        "*avg*rating*effect*label*encoder*.joblib",
+    ])
+
+    required = [
+        ("music_num_model", "music_num_feats", "music_avg_model", "music_avg_feats", "music_avg_le"),
+        ("eff_num_model", "eff_num_feats", "eff_avg_model", "eff_avg_feats", "eff_avg_le"),
+    ]
+    for group in required:
+        for k in group:
+            if M.get(k) is None:
+                problems.append(k)
+
+    return M, problems
+
+MODELS_B, PROBLEMS_B = load_feature_models_B()
 NUM_DOWNLOADS_MAP_B = {0: "Faible", 1: "Moyen", 2: "Élevé"}
 
 def predict_with_model_fs(model, features_dict, feat_list, label_encoder=None):
@@ -290,7 +407,7 @@ def predict_with_model_fs(model, features_dict, feat_list, label_encoder=None):
         row.append(safe_float(val))
 
     X = pd.DataFrame([row], columns=feat_list)
-    dmatrix = xgb.DMatrix(X.values, feature_names=feat_list)
+    dmatrix = xgb.DMatrix(X.values, feature_names=list(feat_list))
 
     booster = model.get_booster() if hasattr(model, "get_booster") else model
     pred_int = int(booster.predict(dmatrix)[0])
@@ -300,6 +417,15 @@ def predict_with_model_fs(model, features_dict, feat_list, label_encoder=None):
     return pred_int
 
 def predict_freesound_acoustic_features(url: str):
+    if PROBLEMS_B:
+        missing = ", ".join(f"<code>{k}</code>" for k in PROBLEMS_B)
+        files = "<br>".join(list_local_files()[:200])
+        return html_error(
+            "Modèles Features API incomplets",
+            f"Il manque des fichiers nécessaires au pipeline B :<br>{missing}<br><br>"
+            f"<b>Fichiers détectés dans ton Space (aperçu)</b>:<br><pre>{files}</pre>"
+        )
+
     if not url or not url.strip():
         return html_error("URL vide", "Colle une URL du type <code>https://freesound.org/s/123456/</code>")
 
@@ -313,8 +439,10 @@ def predict_freesound_acoustic_features(url: str):
     except Exception as e:
         return html_error("Token FreeSound", str(e))
 
+    # champs à récupérer
     all_features = list(set(
-        xgb_music_feat_num_B + xgb_music_feat_avg_B + xgb_effect_feat_num_B + xgb_effect_feat_avg_B
+        MODELS_B["music_num_feats"] + MODELS_B["music_avg_feats"] +
+        MODELS_B["eff_num_feats"] + MODELS_B["eff_avg_feats"]
     ))
     fields = "duration," + ",".join(all_features)
 
@@ -330,14 +458,14 @@ def predict_freesound_acoustic_features(url: str):
     duration = safe_float(sound.get("duration", 0))
 
     if MIN_EFFECT <= duration <= MAX_EFFECT:
-        badge = "🔊 FreeSound (API features acoustiques) — EffectSound"
-        dl_class = int(predict_with_model_fs(xgb_effect_num_B, sound, xgb_effect_feat_num_B))
-        avg_text = str(predict_with_model_fs(xgb_effect_avg_B, sound, xgb_effect_feat_avg_B, le_effect_avg_B))
+        badge = "🔊 FreeSound (Features acoustiques API) — EffectSound"
+        dl_class = int(predict_with_model_fs(MODELS_B["eff_num_model"], sound, MODELS_B["eff_num_feats"]))
+        avg_text = str(predict_with_model_fs(MODELS_B["eff_avg_model"], sound, MODELS_B["eff_avg_feats"], MODELS_B["eff_avg_le"]))
         dl_text = NUM_DOWNLOADS_MAP_B.get(dl_class, str(dl_class))
-
         avg_class = avg_label_to_class(avg_text)
+
         extra = f"""
-<div class="hint">ID FreeSound : <b>{sound_id}</b></div>
+<div class="hint">ID: <b>{sound_id}</b></div>
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
 {interpret_results(avg_class, dl_class)}
 </div>
@@ -345,358 +473,91 @@ def predict_freesound_acoustic_features(url: str):
         return html_result(badge, duration, avg_text, dl_text, extra_html=extra)
 
     if MIN_MUSIC <= duration <= MAX_MUSIC:
-        badge = "🎵 FreeSound (API features acoustiques) — Music"
-        dl_class = int(predict_with_model_fs(xgb_music_num_B, sound, xgb_music_feat_num_B))
-        avg_text = str(predict_with_model_fs(xgb_music_avg_B, sound, xgb_music_feat_avg_B, le_music_avg_B))
+        badge = "🎵 FreeSound (Features acoustiques API) — Music"
+        dl_class = int(predict_with_model_fs(MODELS_B["music_num_model"], sound, MODELS_B["music_num_feats"]))
+        avg_text = str(predict_with_model_fs(MODELS_B["music_avg_model"], sound, MODELS_B["music_avg_feats"], MODELS_B["music_avg_le"]))
         dl_text = NUM_DOWNLOADS_MAP_B.get(dl_class, str(dl_class))
-
         avg_class = avg_label_to_class(avg_text)
+
         extra = f"""
-<div class="hint">ID FreeSound : <b>{sound_id}</b></div>
+<div class="hint">ID: <b>{sound_id}</b></div>
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
 {interpret_results(avg_class, dl_class)}
 </div>
 """
         return html_result(badge, duration, avg_text, dl_text, extra_html=extra)
 
-    return html_error("Durée non supportée",
-                      f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
+    return html_error("Durée non supportée", f"Durée : <b>{duration:.2f}s</b> — attendu 0.5–3s ou 10–60s")
 
 
 # ============================================================
-# PARTIE C — FreeSound URL → Metadata preprocessing lourd → modèles
-# (depuis app (3).py)
+# PARTIE C — Metadata (désactivée si pas de dossiers/fichiers)
 # ============================================================
-
-# ---- objets de preprocessing (local) ----
-# Music
-scaler_samplerate_music   = load_local("music/scaler_music_samplerate.joblib")
-scaler_age_days_music     = load_local("music/scaler_music_age_days_log.joblib")
-username_freq_music       = load_local("music/username_freq_dict_music.joblib")
-est_num_downloads_music   = load_local("music/est_num_downloads_music.joblib")
-avg_rating_transformer_music = load_local("music/avg_rating_transformer_music.joblib")
-music_subcategory_cols    = load_local("music/music_subcategory_cols.joblib")
-music_onehot_cols         = load_local("music/music_onehot_cols.joblib")
-music_onehot_tags         = load_local("music/music_onehot_tags.joblib")
-
-# EffectSound
-scaler_samplerate_effect  = load_local("effectSound/scaler_effectSamplerate.joblib")
-scaler_age_days_effect    = load_local("effectSound/scaler_effectSound_age_days_log.joblib")
-username_freq_effect      = load_local("effectSound/username_freq_dict_effectSound.joblib")
-est_num_downloads_effect  = load_local("effectSound/est_num_downloads_effectSound.joblib")
-avg_rating_transformer_effect = load_local("effectSound/avg_rating_transformer_effectSound.joblib")
-effect_subcategory_cols   = load_local("effectSound/effectSound_subcategory_cols.joblib")
-effect_onehot_cols        = load_local("effectSound/effectSound_onehot_cols.joblib")
-effect_onehot_tags        = load_local("effectSound/effect_onehot_tags.joblib")
-
-# ---- modèles metadata (local) ----
-music_model_num_downloads_C = load_local("music_model_num_downloads.joblib")
-music_model_avg_rating_C    = load_local("music_xgb_avg_rating.joblib")
-music_avg_rating_le_C       = load_local("music_xgb_avg_rating_label_encoder.joblib")
-music_model_features_C      = load_local("music_model_features_list.joblib")
-
-effect_model_num_downloads_C = load_local("effectSound_model_num_downloads.joblib")
-effect_model_avg_rating_C    = load_local("effectSound_xgb_avg_rating.joblib")
-effect_avg_rating_le_C       = load_local("effectSound_xgb_avg_rating_label_encoder.joblib")
-effect_model_features_C      = load_local("effect_model_features_list.joblib")
-
-# Dedup des listes (comme ton script)
-music_model_features_C = list(dict.fromkeys(music_model_features_C))
-effect_model_features_C = list(dict.fromkeys(effect_model_features_C))
-
-# ---- GloVe local (optionnel) ----
-# Mets un fichier local et indique son chemin via GLOVE_PATH si tu veux.
-# Exemple: GLOVE_PATH="models/glove.kv"
-GLOVE_PATH = os.getenv("GLOVE_PATH", "").strip()
-glove_model = None
-
-def try_load_glove():
-    global glove_model
-    if not GLOVE_PATH:
-        glove_model = None
-        return
-    full = p(GLOVE_PATH)
-    if not os.path.exists(full):
-        glove_model = None
-        return
-    try:
-        import gensim
-        from gensim.models import KeyedVectors
-        glove_model = KeyedVectors.load(full, mmap="r")
-    except Exception:
-        glove_model = None
-
-try_load_glove()
-
-def description_to_vec(text, model, dim=100):
-    if model is None or not text:
-        return np.zeros(dim, dtype=float)
-    words = text.lower().split()
-    vecs = [model[w] for w in words if w in model]
-    if len(vecs) == 0:
-        return np.zeros(dim, dtype=float)
-    return np.mean(vecs, axis=0)
-
-def preprocess_name(df, vec_dim=8):
-    df = df.copy()
-    df["name_len"] = df["name_clean"].str.len()
-    vectorizer = HashingVectorizer(n_features=vec_dim, alternate_sign=False, norm=None)
-    name_vec_sparse = vectorizer.transform(df["name_clean"])
-    name_vec_df = pd.DataFrame(
-        name_vec_sparse.toarray(),
-        columns=[f"name_vec_{i}" for i in range(vec_dim)],
-        index=df.index
+def predict_freesound_metadata_stub(url: str):
+    return html_error(
+        "Pipeline Metadata non disponible",
+        "Tu as dit ne pas avoir les dossiers <code>music/</code> et <code>effectSound/</code> "
+        "et/ou les joblib de preprocessing. Donc je n’active pas ce pipeline pour éviter de crasher."
+        "<br><br>Si tu veux l’activer : ajoute les joblib de preprocessing + les modèles metadata, "
+        "ou dis-moi comment tu les as nommés/organisés."
     )
-    df = pd.concat([df, name_vec_df], axis=1)
-    return df
-
-def fetch_sound_metadata(fs_client, sound_url):
-    sound_id = parse_sound_id(sound_url)
-    sound = fs_client.get_sound(sound_id)
-    data = {
-        "id": sound_id,
-        "name": sound.name,
-        "num_ratings": getattr(sound, "num_ratings", 0),
-        "tags": ",".join(sound.tags) if getattr(sound, "tags", None) else "",
-        "username": getattr(sound, "username", ""),
-        "description": getattr(sound, "description", "") or "",
-        "created": getattr(sound, "created", ""),
-        "license": getattr(sound, "license", ""),
-        "num_downloads": getattr(sound, "num_downloads", 0),
-        "channels": getattr(sound, "channels", 0),
-        "filesize": getattr(sound, "filesize", 0),
-        "num_comments": getattr(sound, "num_comments", 0),
-        "category_is_user_provided": getattr(sound, "category_is_user_provided", 0),
-        "duration": getattr(sound, "duration", 0),
-        "avg_rating": getattr(sound, "avg_rating", 0),
-        "category": getattr(sound, "category", "Unknown"),
-        "subcategory": getattr(sound, "subcategory", "Other"),
-        "type": getattr(sound, "type", ""),
-        "samplerate": getattr(sound, "samplerate", 0)
-    }
-    return pd.DataFrame([data])
-
-def preprocess_sound_metadata(df):
-    df = df.copy()
-    dur = float(df["duration"].iloc[0])
-
-    if MIN_EFFECT <= dur <= MAX_EFFECT:
-        dataset_type = "effectSound"
-        scaler_samplerate = scaler_samplerate_effect
-        scaler_age = scaler_age_days_effect
-        username_freq = username_freq_effect
-        est_num_downloads = est_num_downloads_effect
-        avg_rating_transformer = avg_rating_transformer_effect
-        subcat_cols = effect_subcategory_cols
-        onehot_cols = effect_onehot_cols
-        onehot_tags = effect_onehot_tags
-    elif MIN_MUSIC <= dur <= MAX_MUSIC:
-        dataset_type = "music"
-        scaler_samplerate = scaler_samplerate_music
-        scaler_age = scaler_age_days_music
-        username_freq = username_freq_music
-        est_num_downloads = est_num_downloads_music
-        avg_rating_transformer = avg_rating_transformer_music
-        subcat_cols = music_subcategory_cols
-        onehot_cols = music_onehot_cols
-        onehot_tags = music_onehot_tags
-    else:
-        return None, f"Durée hors plage ({dur:.2f}s)."
-
-    # Category bool
-    df["category_is_user_provided"] = df["category_is_user_provided"].astype(int)
-
-    # Username frequency
-    df["username_freq"] = df["username"].map(username_freq).fillna(0)
-
-    # Numeric log1p
-    for col in ["num_ratings", "num_comments", "filesize", "duration"]:
-        df[col] = np.log1p(df[col])
-
-    # samplerate scaled
-    df["samplerate"] = scaler_samplerate.transform(df[["samplerate"]])
-
-    # age_days
-    df["created"] = pd.to_datetime(df["created"], errors="coerce").dt.tz_localize(None)
-    df["age_days"] = (pd.Timestamp.now() - df["created"]).dt.days
-    df["age_days_log"] = np.log1p(df["age_days"])
-    df["age_days_log_scaled"] = scaler_age.transform(df[["age_days_log"]])
-    df = df.drop(columns=["created", "age_days", "age_days_log"], errors="ignore")
-
-    # num_downloads_class
-    df["num_downloads_class"] = est_num_downloads.transform(df[["num_downloads"]])
-
-    # avg_rating transform
-    df["avg_rating"] = avg_rating_transformer.transform(df["avg_rating"].to_numpy())
-
-    # Subcategory one-hot
-    for col in subcat_cols:
-        df[col] = 0
-    subcat_val = df["subcategory"].iloc[0]
-    for col in subcat_cols:
-        cat_name = col.replace("subcategory_", "")
-        if subcat_val == cat_name:
-            df[col] = 1
-    df.drop(columns=["subcategory"], inplace=True, errors="ignore")
-
-    # onehot fixed columns
-    for col in onehot_cols:
-        if col not in df.columns:
-            df[col] = 0
-
-    license_val = df.loc[0, "license"]
-    category_val = df.loc[0, "category"]
-    type_val = df.loc[0, "type"]
-
-    for col_name in [f"license_{license_val}", f"category_{category_val}", f"type_{type_val}"]:
-        if col_name in df.columns:
-            df[col_name] = 1
-
-    # Tags one-hot
-    for col in ["name", "tags", "description"]:
-        if col not in df.columns:
-            df[col] = ""
-    for col in onehot_tags:
-        if col not in df.columns:
-            df[col] = 0
-
-    tags_list = df["tags"].iloc[0].lower().split(",") if df["tags"].iloc[0] else []
-    for col in onehot_tags:
-        tag_name = col.replace("tag_", "").lower()
-        if tag_name in tags_list:
-            df[col] = 1
-    df.drop(columns=["tags"], inplace=True, errors="ignore")
-
-    # Name hashing
-    df["name_clean"] = df["name"].astype(str).str.lower().str.rsplit(".", n=1).str[0]
-    df = preprocess_name(df, vec_dim=8)
-    df.drop(columns=["name", "name_clean"], inplace=True, errors="ignore")
-
-    # Description vectors (GloVe local si dispo, sinon zeros)
-    desc_vec = description_to_vec(df["description"].iloc[0], glove_model, dim=100)
-    for i in range(100):
-        df[f"description_glove_{i}"] = float(desc_vec[i])
-    df.drop(columns=["description"], inplace=True, errors="ignore")
-
-    # drop unused raw cols
-    df.drop(columns=["license","category","type","subcategory","id","num_downloads","file_path","username"],
-            inplace=True, errors="ignore")
-
-    return df, dataset_type
-
-def predict_with_model_df(model, df_input, model_features, le=None):
-    booster_feats = model.get_booster().feature_names
-    X_aligned = df_input.reindex(columns=booster_feats, fill_value=0.0).astype(float)
-    dmatrix = xgb.DMatrix(X_aligned.values, feature_names=booster_feats)
-    preds = model.get_booster().predict(dmatrix)
-    pred_val = preds[0]
-    if len(preds.shape) > 1 and preds.shape[1] > 1:
-        pred_int = int(np.argmax(pred_val))
-    else:
-        pred_int = int(round(float(pred_val)))
-    if le is not None:
-        try:
-            return le.inverse_transform([pred_int])[0]
-        except Exception:
-            return f"Classe inconnue ({pred_int})"
-    return pred_int
-
-def predict_freesound_metadata(url: str, show_debug: bool):
-    if not url or not url.strip():
-        return html_error("URL vide", "Colle une URL du type <code>https://freesound.org/s/123456/</code>")
-
-    try:
-        sound_id = parse_sound_id(url)
-    except Exception:
-        return html_error("URL invalide", "Impossible d'extraire l'ID depuis l'URL.")
-
-    try:
-        fs_client = get_fs_client()
-    except Exception as e:
-        return html_error("Token FreeSound", str(e))
 
-    try:
-        df_raw = fetch_sound_metadata(fs_client, url)
-    except Exception as e:
-        return html_error("Erreur API FreeSound", f"Détail : <code>{e}</code>")
 
-    dur = float(df_raw["duration"].iloc[0])
-    if dur < MIN_EFFECT:
-        return html_error("Son trop court", f"Durée {dur:.2f}s. Accepté: 0.5–3s ou 10–60s")
-    if (MAX_EFFECT < dur < MIN_MUSIC) or dur > MAX_MUSIC:
-        return html_error("Son hors plage", f"Durée {dur:.2f}s. Accepté: 0.5–3s ou 10–60s")
-
-    df_processed, dataset_type = preprocess_sound_metadata(df_raw)
-    if df_processed is None:
-        return html_error("Preprocessing metadata", "Impossible de prétraiter (durée hors plage).")
-
-    # Choix modèles / features selon type
-    if dataset_type == "effectSound":
-        badge = "🔊 FreeSound (metadata) — EffectSound"
-        model_nd = effect_model_num_downloads_C
-        model_ar = effect_model_avg_rating_C
-        model_features = effect_model_features_C
-        le = effect_avg_rating_le_C
-    else:
-        badge = "🎵 FreeSound (metadata) — Music"
-        model_nd = music_model_num_downloads_C
-        model_ar = music_model_avg_rating_C
-        model_features = music_model_features_C
-        le = music_avg_rating_le_C
-
-    # IMPORTANT: tu faisais drop avg_rating + num_downloads_class avant le modèle
-    cols_to_remove = ["avg_rating", "num_downloads_class"]
-    df_for_model = df_processed.drop(columns=[c for c in cols_to_remove if c in df_processed.columns], errors="ignore")
-
-    # Forcer exactement les colonnes du modèle
-    df_for_model = df_for_model.reindex(columns=model_features, fill_value=0.0).astype(float)
-
-    pred_num_downloads_val = predict_with_model_df(model_nd, df_for_model, model_features, le=None)
-    num_map = {0: "Low", 1: "Medium", 2: "High"}
-    pred_num_downloads = num_map.get(pred_num_downloads_val, str(pred_num_downloads_val))
-
-    pred_avg_rating = predict_with_model_df(model_ar, df_for_model, model_features, le=le)
-    avg_class = avg_label_to_class(pred_avg_rating)
-    dl_class_for_interp = {"Low":0,"Medium":1,"High":2}.get(pred_num_downloads, 1)
-
-    debug_html = ""
-    if show_debug:
-        raw_txt = "\n".join([f"{c}: {df_raw.loc[0,c]}" for c in df_raw.columns])
-        proc_txt = "\n".join([f"{c}: {df_processed.loc[0,c]}" for c in df_processed.columns[:120]])  # limite affichage
-        glove_note = "OK" if glove_model is not None else "ABSENT (vecteurs à 0)"
-        debug_html = f"""
-<div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-  <div class="hint"><b>Debug</b> — GloVe: <b>{glove_note}</b></div>
-  <details><summary>Voir métadonnées brutes</summary><pre>{raw_txt}</pre></details>
-  <details><summary>Voir features après preprocessing (aperçu)</summary><pre>{proc_txt}</pre></details>
-</div>
-"""
+# ============================================================
+# Page “diagnostic”
+# ============================================================
+def status_page():
+    files = list_local_files()
+    files_txt = "\n".join(files) if files else "(aucun fichier .pkl/.joblib détecté)"
+    a_ok = (MODEL_EFFECT_A is not None and MODEL_MUSIC_A is not None)
+    b_ok = (len(PROBLEMS_B) == 0)
 
-    extra = f"""
-<div class="hint">ID FreeSound : <b>{sound_id}</b></div>
-<div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-{interpret_results(avg_class, dl_class_for_interp)}
+    return f"""
+<div class="card">
+  <div class="card-title">📦 Diagnostic du Space</div>
+  <div class="grid">
+    <div class="box">
+      <div class="box-title">OpenSMILE (A)</div>
+      <div class="box-value">{'✅ OK' if a_ok else '❌ modèles manquants'}</div>
+      <div class="hint">Effect: <code>{PATH_EFFECT_A or 'non chargé'}</code><br>Music: <code>{PATH_MUSIC_A or 'non chargé'}</code></div>
+    </div>
+    <div class="box">
+      <div class="box-title">Features API (B)</div>
+      <div class="box-value">{'✅ OK' if b_ok else '❌ incomplet'}</div>
+      <div class="hint">Manquants: <code>{', '.join(PROBLEMS_B) if PROBLEMS_B else 'aucun'}</code></div>
+    </div>
+    <div class="box">
+      <div class="box-title">Metadata (C)</div>
+      <div class="box-value">⚠️ désactivé si dossiers/joblib absents</div>
+      <div class="hint">Activer seulement si preprocessing joblib présents.</div>
+    </div>
+  </div>
+  <div class="hint" style="margin-top:12px"><b>Fichiers détectés</b> :</div>
+  <pre>{files_txt}</pre>
 </div>
-{debug_html}
-"""
-    return html_result(badge, dur, str(pred_avg_rating), str(pred_num_downloads), extra_html=extra)
+""".strip()
 
 
 # ============================================================
-# GRADIO APP (3 onglets)
+# GRADIO UI
 # ============================================================
-with gr.Blocks(title="Popularité FreeSound — 3 pipelines", css=CSS, theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Popularité FreeSound — Pipelines séparés", css=CSS, theme=gr.themes.Soft()) as demo:
     gr.HTML(f"""
-<div id="header-title">Popularité FreeSound — 3 pipelines</div>
+<div id="header-title">Popularité FreeSound — Pipelines séparés</div>
 <p id="header-sub">
-<b>A)</b> Upload audio → <b>OpenSMILE</b><br>
-<b>B)</b> URL FreeSound → <b>Features acoustiques via API fields</b><br>
-<b>C)</b> URL FreeSound → <b>Metadata + preprocessing</b><br><br>
+<b>A)</b> Upload → OpenSMILE<br>
+<b>B)</b> URL → Features acoustiques FreeSound (API fields)<br>
+<b>C)</b> URL → Metadata FreeSound (désactivé si fichiers absents)<br><br>
 <b>Durées acceptées :</b> 🔊 {MIN_EFFECT}–{MAX_EFFECT}s · 🎵 {MIN_MUSIC}–{MAX_MUSIC}s
 </p>
 """)
 
     with gr.Tabs():
+        with gr.Tab("📦 Diagnostic"):
+            diag = gr.HTML(value=status_page())
+            btn_refresh = gr.Button("Rafraîchir diagnostic")
+            btn_refresh.click(lambda: status_page(), outputs=diag)
+
         with gr.Tab("A) Upload → OpenSMILE"):
             with gr.Row():
                 with gr.Column():
@@ -719,10 +580,9 @@ with gr.Blocks(title="Popularité FreeSound — 3 pipelines", css=CSS, theme=gr.
             with gr.Row():
                 with gr.Column():
                     url_in = gr.Textbox(label="URL FreeSound", placeholder="https://freesound.org/s/123456/")
-                    show_debug = gr.Checkbox(label="Afficher debug (brut + aperçu features)", value=False)
                     btn = gr.Button("🚀 Prédire (Metadata)", variant="primary")
                 with gr.Column():
                     out = gr.HTML()
-            btn.click(predict_freesound_metadata, inputs=[url_in, show_debug], outputs=out)
+            btn.click(predict_freesound_metadata_stub, inputs=url_in, outputs=out)
 
 demo.launch()