testtest4

app.py

@@ -1,343 +1,228 @@
 import os
 import time
-import gradio as gr
+import requests
 import pandas as pd
-import numpy as np
+import gradio as gr
 import joblib
-import xgboost as xgb
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-
 
 # =========================
 # CONFIG
 # =========================
-API_TOKEN = "A ECRIRE"  # <-- remplace ici
-
-MIN_EFFECT, MAX_EFFECT = 0.5, 3.0
-MIN_MUSIC, MAX_MUSIC = 10.0, 60.0
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-
 FREESOUND_API_BASE = "https://freesound.org/apiv2"
+API_TOKEN = os.getenv("FREESOUND_API_TOKEN", "").strip()
+
+# Timeout: (connect, read)
+TIMEOUT = (6, 20)
 
+# Session HTTP réutilisable
+SESSION = requests.Session()
+ADAPTER = requests.adapters.HTTPAdapter(pool_connections=20, pool_maxsize=20, max_retries=0)
+SESSION.mount("https://", ADAPTER)
+SESSION.headers.update({"User-Agent": "freesound-gradio-metadata/1.0"})
 
 # =========================
-# UI (CSS)
+# CHARGE TON MODELE + FEATURES
 # =========================
-CSS = """
-.card { border:1px solid #e5e7eb; background:#fff; padding:16px; border-radius:16px; }
-.card-error{ border-color:#fca5a5; background:#fff1f2; }
-.card-title{ font-weight:950; margin-bottom:8px; }
-.badges{ display:flex; gap:10px; flex-wrap:wrap; margin-bottom:12px; }
-.badge{ padding:6px 10px; border-radius:999px; font-weight:900; font-size:13px; border:1px solid #e5e7eb; }
-.badge-type{ background:#eef2ff; color:#3730a3; }
-.badge-time{ background:#ecfeff; color:#155e75; }
-.grid{ display:grid; grid-template-columns:1fr; gap:10px; }
-.box{ border:1px solid #e5e7eb; border-radius:14px; padding:12px; background:#fafafa; }
-.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; }
-#header-title{ font-size:28px; font-weight:950; margin-bottom:6px; }
-#header-sub{ color:#6b7280; margin-top:0px; line-height:1.45; }
-"""
-
-
-def html_error(title, body_html):
-    return f"""
-<div class="card card-error">
-  <div class="card-title">❌ {title}</div>
-  <div>{body_html}</div>
-</div>
-""".strip()
-
-
-def html_result(badge_text, duration, rating_text, downloads_text, extra_html=""):
-    return f"""
-<div class="card">
-  <div class="badges">
-    <span class="badge badge-type">{badge_text}</span>
-    <span class="badge badge-time">⏱️ {duration:.2f} s</span>
-  </div>
-
-  <div class="grid">
-    <div class="box">
-      <div class="box-title">📈 Popularité de la note moyenne</div>
-      <div class="box-value">{rating_text}</div>
-    </div>
-    <div class="box">
-      <div class="box-title">⬇️ Popularité des téléchargements</div>
-      <div class="box-value">{downloads_text}</div>
-    </div>
-  </div>
-
-  {extra_html}
-
-  <div class="hint">
-    Résultats affichés en <b>niveaux</b> (faible / moyen / élevé), pas en valeurs exactes.
-  </div>
-</div>
-""".strip()
+# Adapte ces chemins à ton projet
+MODEL_PATH = "model.joblib"
+FEATURES_PATH = "features.txt"  # un fichier avec 1 feature par ligne (ordre = ordre du training)
 
+if not os.path.exists(MODEL_PATH):
+    raise FileNotFoundError(f"Modèle introuvable: {MODEL_PATH}")
+model = joblib.load(MODEL_PATH)
 
-# =========================
-# INTERPRETATION
-# =========================
-def interpret_results(avg_class: int, dl_class: int) -> str:
-    if avg_class == 0:
-        return (
-            "ℹ️ <b>Interprétation</b> :<br>"
-            "Aucune/peu d'évaluations utilisateurs (rating manquant).<br>"
-            "La popularité est donc probablement liée à l'usage (téléchargements) plutôt qu'à la qualité perçue."
-        )
-
-    rating_txt = {1: "faible", 2: "moyenne", 3: "élevée"}.get(avg_class, "inconnue")
-    downloads_txt = {0: "faible", 1: "modérée", 2: "élevée"}.get(dl_class, "inconnue")
-
-    if avg_class == 3 and dl_class == 2:
-        potentiel, detail = "très fort", "contenu de haute qualité et très populaire."
-    elif avg_class == 3 and dl_class == 1:
-        potentiel, detail = "fort", "contenu bien apprécié, en croissance."
-    elif avg_class == 3 and dl_class == 0:
-        potentiel, detail = "prometteur", "bonne qualité mais faible visibilité."
-    elif avg_class == 2 and dl_class == 2:
-        potentiel, detail = "modéré à fort", "populaire mais qualité perçue moyenne."
-    elif avg_class == 2 and dl_class == 1:
-        potentiel, detail = "modéré", "profil standard, popularité stable."
-    elif avg_class == 2 and dl_class == 0:
-        potentiel, detail = "limité", "engagement faible, diffusion limitée."
-    elif avg_class == 1 and dl_class == 2:
-        potentiel, detail = "contradictoire", "très téléchargé mais peu apprécié."
-    elif avg_class == 1 and dl_class == 1:
-        potentiel, detail = "faible", "peu attractif pour les utilisateurs."
-    else:
-        potentiel, detail = "très faible", "faible intérêt global."
-
-    return (
-        "🧠 <b>Interprétation</b> :<br>"
-        f"- Qualité perçue : <b>{rating_txt}</b><br>"
-        f"- Popularité : <b>{downloads_txt}</b><br><br>"
-        f"👉 Potentiel estimé : <b>{potentiel}</b> — {detail}"
-    )
-
-
-def avg_label_to_class(avg_label: str) -> int:
-    if avg_label is None:
-        return 0
-    s = str(avg_label).strip().lower()
-    if "miss" in s or "missing" in s or "none" in s or "no" in s:
-        return 0
-    if "high" in s or "élev" in s or "eleve" in s:
-        return 3
-    if "medium" in s or "moy" in s:
-        return 2
-    if "low" in s or "faibl" in s:
-        return 1
-    return 0
+if not os.path.exists(FEATURES_PATH):
+    raise FileNotFoundError(f"Liste de features introuvable: {FEATURES_PATH}")
+with open(FEATURES_PATH, "r", encoding="utf-8") as f:
+    FEATURE_NAMES = [line.strip() for line in f if line.strip()]
 
 
 # =========================
-# HTTP SESSION (retries)
+# OUTILS
 # =========================
-def make_session():
-    session = requests.Session()
-    retry = Retry(
-        total=5,
-        backoff_factor=0.8,
-        status_forcelist=[429, 500, 502, 503, 504],
-        allowed_methods=["GET"],
-        raise_on_status=False,
-    )
-    adapter = HTTPAdapter(max_retries=retry)
-    session.mount("https://", adapter)
-    session.mount("http://", adapter)
-    return session
+def safe_get_json(url, headers=None, params=None, attempts=5, backoff=1.7):
+    """
+    GET JSON robuste : retries sur erreurs réseau/5xx/429.
+    """
+    last_err = None
+    for i in range(attempts):
+        try:
+            resp = SESSION.get(url, headers=headers, params=params, timeout=TIMEOUT)
+
+            # Rate limit
+            if resp.status_code == 429:
+                retry_after = resp.headers.get("Retry-After")
+                wait = float(retry_after) if retry_after and retry_after.isdigit() else (backoff ** i)
+                time.sleep(wait)
+                continue
+
+            # Server errors
+            if 500 <= resp.status_code < 600:
+                time.sleep(backoff ** i)
+                continue
+
+            # Auth / Not found / autres erreurs client
+            if resp.status_code == 401:
+                raise RuntimeError("❌ Token FreeSound invalide ou non autorisé (401).")
+            if resp.status_code == 404:
+                raise RuntimeError("❌ Sound introuvable (404).")
+            if resp.status_code >= 400:
+                raise RuntimeError(f"❌ Erreur HTTP {resp.status_code}: {resp.text[:200]}")
+
+            return resp.json()
+
+        except (requests.exceptions.ConnectionError,
+                requests.exceptions.Timeout,
+                requests.exceptions.ChunkedEncodingError) as e:
+            last_err = e
+            time.sleep(backoff ** i)
+            continue
+        except Exception as e:
+            # autre exception : on remonte direct
+            raise
+
+    raise RuntimeError(f"❌ Échec après {attempts} tentatives. Dernière erreur: {repr(last_err)}")
+
+
+def fetch_sound_by_id(sound_id: int, fields: str) -> dict:
+    """
+    ✅ Endpoint stable : /sounds/{id}/
+    """
+    if not API_TOKEN:
+        raise RuntimeError("❌ FREESOUND_API_TOKEN manquant (variable d'environnement).")
+
+    url = f"{FREESOUND_API_BASE}/sounds/{int(sound_id)}/"
+    headers = {"Authorization": f"Token {API_TOKEN}"}
+    params = {"fields": fields}
+    return safe_get_json(url, headers=headers, params=params)
+
 
+def flatten_features(ac_analysis: dict) -> dict:
+    """
+    FreeSound renvoie souvent un dict de features (ac_analysis).
+    Ici on aplatit en {feature_name: value} en gardant uniquement
+    les clés directes (et on ignore les structures trop imbriquées).
+    """
+    flat = {}
+    if not isinstance(ac_analysis, dict):
+        return flat
+
+    for k, v in ac_analysis.items():
+        # garde les nombres simples / bool / str courts
+        if isinstance(v, (int, float, bool)):
+            flat[k] = float(v) if isinstance(v, bool) else v
+        elif isinstance(v, str):
+            # éviter d'injecter des textes énormes
+            flat[k] = v[:200]
+        # si liste/dict: on ignore (ou tu peux custom)
+    return flat
+
+
+def build_feature_df(sound_json: dict, wanted_features: list[str]) -> pd.DataFrame:
+    """
+    Construit un DataFrame avec les features réellement utilisées par ton modèle.
+    """
+    ac = sound_json.get("ac_analysis", {}) or {}
+    flat = flatten_features(ac)
 
-SESSION = make_session()
+    rows = []
+    for feat in wanted_features:
+        rows.append({"feature": feat, "value": flat.get(feat, None)})
+    return pd.DataFrame(rows)
 
 
-def fetch_sound_metadata_by_id(sound_id: int, fields: str) -> dict:
+def build_model_vector(sound_json: dict, feature_names: list[str]) -> pd.DataFrame:
     """
-    Appel API FreeSound directement (plus stable) + retries + timeout.
+    Construit un X (1 ligne) dans le bon ordre de features.
     """
-    url = f"{FREESOUND_API_BASE}/search/text/"
-    headers = {"Authorization": f"Token {API_TOKEN}"}
+    ac = sound_json.get("ac_analysis", {}) or {}
+    flat = flatten_features(ac)
+
+    x = {feat: flat.get(feat, None) for feat in feature_names}
+    X = pd.DataFrame([x])
+
+    # Option: fillna(0) si ton training le faisait (sinon enlève)
+    X = X.fillna(0)
 
-    params = {
-        "query": "",
-        "filter": f"id:{sound_id}",
-        "fields": fields,
-        "page_size": 1,
-    }
+    return X
 
-    # timeout séparé (connect, read)
-    resp = SESSION.get(url, headers=headers, params=params, timeout=(6, 20))
-    if resp.status_code == 401:
-        raise RuntimeError("Token invalide ou non autorisé (401).")
-    if resp.status_code >= 400:
-        raise RuntimeError(f"Erreur HTTP {resp.status_code}: {resp.text[:200]}")
 
-    data = resp.json()
-    results = data.get("results", [])
-    if not results:
-        raise RuntimeError("Sound not found (aucun résultat pour cet ID).")
-    return results[0]
+def predict_label(sound_json: dict):
+    X = build_model_vector(sound_json, FEATURE_NAMES)
+
+    # proba si dispo
+    label = model.predict(X)[0]
+    proba = None
+    if hasattr(model, "predict_proba"):
+        try:
+            proba = float(model.predict_proba(X).max())
+        except Exception:
+            proba = None
+    return label, proba, X
 
 
 # =========================
-# Charger modèles (NOMS EXACTS)
+# GRADIO LOGIC
 # =========================
-music_num_model = joblib.load(os.path.join(BASE_DIR, "music_model_num_downloads.joblib"))
-music_feat_list = joblib.load(os.path.join(BASE_DIR, "music_model_features_list.joblib"))
-music_avg_model = joblib.load(os.path.join(BASE_DIR, "music_xgb_avg_rating.joblib"))
-music_avg_le = joblib.load(os.path.join(BASE_DIR, "music_xgb_avg_rating_label_encoder.joblib"))
+DEFAULT_FIELDS = "id,name,username,license,tags,previews,ac_analysis"
 
-effect_num_model = joblib.load(os.path.join(BASE_DIR, "effectSound_model_num_downloads.joblib"))
-effect_feat_list = joblib.load(os.path.join(BASE_DIR, "effect_model_features_list.joblib"))
-effect_avg_model = joblib.load(os.path.join(BASE_DIR, "effectSound_xgb_avg_rating.joblib"))
-effect_avg_le = joblib.load(os.path.join(BASE_DIR, "effectSound_xgb_avg_rating_label_encoder.joblib"))
+def run(sound_id: str):
+    sound_id = str(sound_id).strip()
+    if not sound_id.isdigit():
+        raise gr.Error("Entre un ID numérique (ex: 123456).")
 
-NUM_DOWNLOADS_MAP = {0: "Faible", 1: "Moyen", 2: "Élevé"}
+    sid = int(sound_id)
 
+    sound = fetch_sound_by_id(sid, fields=DEFAULT_FIELDS)
 
-def safe_float(v):
-    try:
-        return float(v)
-    except Exception:
-        return 0.0
+    # Tableau des features utilisées
+    df_features = build_feature_df(sound, FEATURE_NAMES)
 
+    # Prediction
+    label, proba, X = predict_label(sound)
 
-def build_feature_df(sound: dict, feat_list: list) -> pd.DataFrame:
-    """
-    Tableau lisible des features utilisées (valeur API + NaN si absent).
-    """
-    rows = []
-    for col in feat_list:
-        val = sound.get(col, np.nan)
-        if val is None or isinstance(val, (list, dict)):
-            val = np.nan
-        rows.append({"feature": col, "value": val})
-    return pd.DataFrame(rows)
+    # Infos utiles à afficher
+    title = sound.get("name", "")
+    user = sound.get("username", "")
+    tags = sound.get("tags", [])
+    preview_url = (sound.get("previews", {}) or {}).get("preview-hq-mp3") or (sound.get("previews", {}) or {}).get("preview-lq-mp3")
 
+    info_md = f"""
+### 🎧 Sound
+- **ID**: `{sid}`
+- **Nom**: {title}
+- **Auteur**: {user}
+- **Tags**: {", ".join(tags[:25])}{' …' if len(tags) > 25 else ''}
 
-def predict_with_model(model, sound: dict, feat_list: list, le=None):
-    row = []
-    for col in feat_list:
-        val = sound.get(col, 0)
-        if val is None or isinstance(val, (list, dict)):
-            val = 0
-        row.append(safe_float(val))
-
-    X = pd.DataFrame([row], columns=feat_list)
-    dm = xgb.DMatrix(X.values, feature_names=feat_list)
-    pred_int = int(model.get_booster().predict(dm)[0])
-
-    if le is not None:
-        return le.inverse_transform([pred_int])[0]
-    return pred_int
-
-
-def extract_and_predict(url: str):
-    if not url or not url.strip():
-        return html_error("URL vide", "Collez une URL FreeSound du type <code>https://freesound.org/s/123456/</code>"), pd.DataFrame()
-
-    # Parse ID
-    try:
-        sound_id = int(url.rstrip("/").split("/")[-1])
-    except Exception:
-        return html_error("URL invalide", "Impossible d'extraire l'ID depuis l'URL."), pd.DataFrame()
-
-    # Fields nécessaires : union music/effect + duration
-    all_features = sorted(list(set(music_feat_list + effect_feat_list)))
-    fields = "duration," + ",".join(all_features)
-
-    # Fetch API (avec retries)
-    try:
-        sound = fetch_sound_metadata_by_id(sound_id, fields=fields)
-    except Exception as e:
-        return html_error(
-            "Erreur API FreeSound",
-            f"Détail : <code>{e}</code><br><br>"
-            "Astuce : si ça arrive aléatoirement, c'est souvent un souci réseau/rate limit → réessayez."
-        ), pd.DataFrame()
-
-    duration = safe_float(sound.get("duration", 0))
-
-    # Vérif durées
-    if duration < MIN_EFFECT:
-        return html_error(
-            "Audio trop court",
-            f"Durée : <b>{duration:.2f}s</b><br><br>"
-            f"Plages : Effet sonore <b>{MIN_EFFECT}-{MAX_EFFECT}s</b> | Musique <b>{MIN_MUSIC}-{MAX_MUSIC}s</b>"
-        ), pd.DataFrame()
-
-    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><br>"
-            f"Plages : Effet sonore <b>{MIN_EFFECT}-{MAX_EFFECT}s</b> | Musique <b>{MIN_MUSIC}-{MAX_MUSIC}s</b>"
-        ), pd.DataFrame()
-
-    # Effect
-    if MIN_EFFECT <= duration <= MAX_EFFECT:
-        badge = "🔊 Effet sonore (metadata FreeSound)"
-        dl_class = int(predict_with_model(effect_num_model, sound, effect_feat_list))
-        avg_text = str(predict_with_model(effect_avg_model, sound, effect_feat_list, effect_avg_le))
-        dl_text = NUM_DOWNLOADS_MAP.get(dl_class, str(dl_class))
-
-        avg_class = avg_label_to_class(avg_text)
-        conclusion = interpret_results(avg_class, dl_class)
-
-        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">{conclusion}</div>
-"""
-        df_feat = build_feature_df(sound, effect_feat_list)
-        return html_result(badge, duration, avg_text, dl_text, extra_html=extra), df_feat
-
-    # Music
-    badge = "🎵 Musique (metadata FreeSound)"
-    dl_class = int(predict_with_model(music_num_model, sound, music_feat_list))
-    avg_text = str(predict_with_model(music_avg_model, sound, music_feat_list, music_avg_le))
-    dl_text = NUM_DOWNLOADS_MAP.get(dl_class, str(dl_class))
-
-    avg_class = avg_label_to_class(avg_text)
-    conclusion = interpret_results(avg_class, dl_class)
-
-    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">{conclusion}</div>
-"""
-    df_feat = build_feature_df(sound, music_feat_list)
-    return html_result(badge, duration, avg_text, dl_text, extra_html=extra), df_feat
+### 🔮 Prédiction
+- **Classe prédite**: **{label}**
+""" + (f"- **Confiance (max proba)**: `{proba:.3f}`\n" if proba is not None else "")
+
+    audio = preview_url if preview_url else None
+
+    # Option: montrer aussi le vecteur X (1 ligne) si tu veux
+    # df_x = X.T.reset_index().rename(columns={"index": "feature", 0: "value"})
+    # return info_md, audio, df_features, df_x
+
+    return info_md, audio, df_features
 
 
 # =========================
 # UI
 # =========================
-theme = gr.themes.Soft()
-
-with gr.Blocks(title="Test — Metadata FreeSound", css=CSS) as demo:
-    gr.HTML(
-        f"""
-<div id="header-title">🔎 Test — Prédiction via Metadata FreeSound</div>
-<p id="header-sub">
-Collez une URL FreeSound. L'app récupère les <b>metadata</b> via l'API et prédit la popularité (avg_rating, num_downloads).
-<br><br>
-<b>Durées acceptées :</b> 🔊 Effet sonore {MIN_EFFECT}–{MAX_EFFECT}s · 🎵 Musique {MIN_MUSIC}–{MAX_MUSIC}s
-</p>
-"""
-    )
-
-    url = gr.Textbox(label="URL FreeSound", placeholder="https://freesound.org/s/123456/")
-    btn = gr.Button("🚀 Tester la prédiction", variant="primary")
+with gr.Blocks(title="FreeSound ID → Metadata + Prediction") as demo:
+    gr.Markdown("# FreeSound : Métadonnées → Features → Prédiction")
 
     with gr.Row():
-        out_html = gr.HTML(label="Résultat")
-        out_df = gr.Dataframe(label="Features utilisées (metadata)", interactive=False)
+        sound_id_in = gr.Textbox(label="Sound ID", placeholder="ex: 123456", scale=2)
+        btn = gr.Button("Récupérer & prédire", scale=1)
+
+    info_out = gr.Markdown()
+    audio_out = gr.Audio(label="Preview (si dispo)", interactive=False)
+    features_out = gr.Dataframe(label="Features utilisées (valeurs FreeSound)", interactive=False)
 
-    btn.click(extract_and_predict, inputs=url, outputs=[out_html, out_df])
+    btn.click(fn=run, inputs=[sound_id_in], outputs=[info_out, audio_out, features_out])
+    sound_id_in.submit(fn=run, inputs=[sound_id_in], outputs=[info_out, audio_out, features_out])
 
-demo.launch(theme=theme)
+if __name__ == "__main__":
+    demo.launch()