Update app.py

app.py

@@ -2,104 +2,103 @@ import gradio as gr
 import pandas as pd
 import freesound
 
-# -------- Configuration --------
+# ========= CONFIG =========
 API_TOKEN = "zE9NjEOgUMzH9K7mjiGBaPJiNwJLjSM53LevarRK"
 
-# Initialiser le client FreeSound
 client = freesound.FreesoundClient()
 client.set_token(API_TOKEN, "token")
 
-# -------- Fonction utilitaire pour convertir listes en chaînes --------
-def list_to_str(val):
-    if val is None:
+# ========= UTILS =========
+def to_str(v):
+    if v is None:
         return ""
-    if isinstance(val, list):
-        return ",".join(map(str, val))
-    return str(val)
+    if isinstance(v, (list, dict)):
+        return str(v)
+    return v
 
-# -------- Fonction Gradio --------
-def predict_with_audio(url):
-    if not url.strip():
-        return pd.DataFrame()  # retourne un DataFrame vide si aucun URL
-    
+# ========= MAIN FUNCTION =========
+def extract_features(url):
     try:
-        # Extraire l'ID du son depuis l'URL
         sound_id = int(url.rstrip("/").split("/")[-1])
         sound = client.get_sound(sound_id)
-        
-        # Construire le dict (sans télécharger la preview)
+
+        # 🔥 C'EST ICI QUE TOUT SE PASSE
+        analysis = sound.get_analysis()
+
         sound_data = {
+            # ===== META =====
             "id": sound.id,
-            "num_downloads": getattr(sound, "num_downloads", ""),
-            "avg_rating": getattr(sound, "avg_rating", ""),
-            "amplitude_peak_ratio": list_to_str(getattr(sound, "amplitude_peak_ratio", "")),
-            "beat_count": list_to_str(getattr(sound, "beat_count", "")),
-            "beat_loudness": list_to_str(getattr(sound, "beat_loudness", "")),
-            "beat_times": list_to_str(getattr(sound, "beat_times", "")),
-            "boominess": getattr(sound, "boominess", ""),
-            "bpm": getattr(sound, "bpm", ""),
-            "bpm_confidence": getattr(sound, "bpm_confidence", ""),
-            "brightness": getattr(sound, "brightness", ""),
-            "chord_count": getattr(sound, "chord_count", ""),
-            "chord_progression": list_to_str(getattr(sound, "chord_progression", "")),
-            "decay_strength": getattr(sound, "decay_strength", ""),
-            "hpcp": list_to_str(getattr(sound, "hpcp", "")),
-            "hpcp_crest": getattr(sound, "hpcp_crest", ""),
-            "hpcp_entropy": getattr(sound, "hpcp_entropy", ""),
-            "inharmonicity": getattr(sound, "inharmonicity", ""),
-            "mfcc": list_to_str(getattr(sound, "mfcc", "")),
-            "note_confidence": list_to_str(getattr(sound, "note_confidence", "")),
-            "note_midi": list_to_str(getattr(sound, "note_midi", "")),
-            "note_name": list_to_str(getattr(sound, "note_name", "")),
-            "onset_count": getattr(sound, "onset_count", ""),
-            "onset_times": list_to_str(getattr(sound, "onset_times", "")),
-            "pitch": getattr(sound, "pitch", ""),
-            "pitch_max": getattr(sound, "pitch_max", ""),
-            "pitch_min": getattr(sound, "pitch_min", ""),
-            "pitch_salience": getattr(sound, "pitch_salience", ""),
-            "pitch_var": getattr(sound, "pitch_var", ""),
-            "silence_rate": getattr(sound, "silence_rate", ""),
-            "spectral_centroid": getattr(sound, "spectral_centroid", ""),
-            "spectral_complexity": getattr(sound, "spectral_complexity", ""),
-            "spectral_crest": getattr(sound, "spectral_crest", ""),
-            "spectral_energy": getattr(sound, "spectral_energy", ""),
-            "spectral_entropy": getattr(sound, "spectral_entropy", ""),
-            "spectral_flatness": getattr(sound, "spectral_flatness", ""),
-            "spectral_rolloff": getattr(sound, "spectral_rolloff", ""),
-            "spectral_skewness": getattr(sound, "spectral_skewness", ""),
-            "spectral_spread": getattr(sound, "spectral_spread", ""),
-            "start_time": getattr(sound, "start_time", ""),
-            "temporal_centroid": getattr(sound, "temporal_centroid", ""),
-            "temporal_centroid_ratio": getattr(sound, "temporal_centroid_ratio", ""),
-            "temporal_decrease": getattr(sound, "temporal_decrease", ""),
-            "temporal_skewness": getattr(sound, "temporal_skewness", ""),
-            "temporal_spread": getattr(sound, "temporal_spread", ""),
-            "tristimulus": getattr(sound, "tristimulus", ""),
-            "warmth": getattr(sound, "warmth", ""),
-            "zero_crossing_rate": getattr(sound, "zero_crossing_rate", "")
+            "num_downloads": sound.num_downloads,
+            "avg_rating": sound.avg_rating,
+        
+            # ===== RHYTHM =====
+            "amplitude_peak_ratio": analysis.lowlevel.get("amplitude_peak_ratio"),
+            "beat_count": analysis.rhythm.get("beats_count"),
+            "beat_loudness": list_to_str(analysis.rhythm.get("beats_loudness")),
+            "beat_times": list_to_str(analysis.rhythm.get("beats_position")),
+            "bpm": analysis.rhythm.get("bpm"),
+            "bpm_confidence": analysis.rhythm.get("bpm_confidence"),
+        
+            # ===== LOWLEVEL =====
+            "boominess": analysis.lowlevel.get("boominess"),
+            "brightness": analysis.lowlevel.get("brightness"),
+            "decay_strength": analysis.lowlevel.get("decay_strength"),
+            "inharmonicity": analysis.lowlevel.get("inharmonicity"),
+            "mfcc": list_to_str(analysis.lowlevel.get("mfcc")),
+            "onset_count": analysis.lowlevel.get("onsets_count"),
+            "onset_times": list_to_str(analysis.lowlevel.get("onsets_position")),
+            "pitch": analysis.lowlevel.get("pitch"),
+            "pitch_max": analysis.lowlevel.get("pitch_max"),
+            "pitch_min": analysis.lowlevel.get("pitch_min"),
+            "pitch_salience": analysis.lowlevel.get("pitch_salience"),
+            "pitch_var": analysis.lowlevel.get("pitch_var"),
+            "silence_rate": analysis.lowlevel.get("silence_rate"),
+        
+            "spectral_centroid": analysis.lowlevel.get("spectral_centroid"),
+            "spectral_complexity": analysis.lowlevel.get("spectral_complexity"),
+            "spectral_crest": analysis.lowlevel.get("spectral_crest"),
+            "spectral_energy": analysis.lowlevel.get("spectral_energy"),
+            "spectral_entropy": analysis.lowlevel.get("spectral_entropy"),
+            "spectral_flatness": analysis.lowlevel.get("spectral_flatness"),
+            "spectral_rolloff": analysis.lowlevel.get("spectral_rolloff"),
+            "spectral_skewness": analysis.lowlevel.get("spectral_skewness"),
+            "spectral_spread": analysis.lowlevel.get("spectral_spread"),
+            "start_time": analysis.lowlevel.get("start_time"),
+        
+            "temporal_centroid": analysis.lowlevel.get("temporal_centroid"),
+            "temporal_centroid_ratio": analysis.lowlevel.get("temporal_centroid_ratio"),
+            "temporal_decrease": analysis.lowlevel.get("temporal_decrease"),
+            "temporal_skewness": analysis.lowlevel.get("temporal_skewness"),
+            "temporal_spread": analysis.lowlevel.get("temporal_spread"),
+            "zero_crossing_rate": analysis.lowlevel.get("zerocrossingrate"),
+        
+            # ===== TONAL =====
+            "chord_count": analysis.tonal.get("chords_number_rate"),
+            "chord_progression": list_to_str(analysis.tonal.get("chords_progression")),
+            "hpcp": list_to_str(analysis.tonal.get("hpcp")),
+            "hpcp_crest": analysis.tonal.get("hpcp_crest"),
+            "hpcp_entropy": analysis.tonal.get("hpcp_entropy"),
+            "note_confidence": list_to_str(analysis.tonal.get("notes_confidence")),
+            "note_midi": list_to_str(analysis.tonal.get("notes_midi")),
+            "note_name": list_to_str(analysis.tonal.get("notes_names")),
+            "tristimulus": analysis.tonal.get("tristimulus"),
+            "warmth": analysis.lowlevel.get("warmth"),
         }
 
-        # Convertir en DataFrame pour Gradio
-        df = pd.DataFrame([sound_data])
-        return df
-    
+        return pd.DataFrame([data])
+
     except Exception as e:
         return pd.DataFrame([{"Erreur": str(e)}])
 
-# -------- Interface Gradio --------
-with gr.Blocks(title="FreeSound Audio Features") as demo:
-    gr.Markdown("# 🎧 FreeSound Audio Features Extractor")
-    gr.Markdown("Collez l'URL d'un son FreeSound pour récupérer ses features audio internes.")
-    
-    url_input = gr.Textbox(
-        label="URL du son FreeSound",
-        placeholder="https://freesound.org/people/..."
-    )
+# ========= GRADIO UI =========
+with gr.Blocks(title="FreeSound Audio Feature Extractor") as demo:
+    gr.Markdown("## 🎧 FreeSound – Audio Feature Extractor (REAL)")
+    gr.Markdown("Colle une URL FreeSound → toutes les features audio s'affichent")
 
-    btn_audio = gr.Button("🎼 Extraire features audio")
-    output = gr.Dataframe(headers=None)  # accepte automatiquement toutes les colonnes du DataFrame
+    url = gr.Textbox(label="URL du son", placeholder="https://freesound.org/s/123456/")
+    btn = gr.Button("🎼 Extraire features")
+    out = gr.Dataframe()
 
-    btn_audio.click(fn=predict_with_audio, inputs=url_input, outputs=output)
+    btn.click(extract_features, url, out)
 
 demo.launch()
-