Update app.py

Added Recommendation With Spotify

app.py

@@ -1,132 +1,282 @@
 """
-Voice Mood Detector - Simple version for Hugging Face
+MoodSync AI + Spotify Recommender (Emotion labels → Spotify params)
+Single-file Gradio app for Hugging Face / local hosting.
 """
-import gradio as gr
+
+import os
+import base64
+import requests
+import warnings
 import numpy as np
 from transformers import pipeline
-import warnings
+import gradio as gr
+
 warnings.filterwarnings("ignore")
 
-# Initialize the emotion detection model
+# ------------------------
+# CONFIG - set via env or paste directly
+# ------------------------
+SPOTIFY_CLIENT_ID = os.environ.get("SPOTIFY_CLIENT_ID", "49272551bfef4203bc54777db99fabf7")
+SPOTIFY_CLIENT_SECRET = os.environ.get("SPOTIFY_CLIENT_SECRET", "87d98f227f0b4e07a28b3802a80a291a")
+
+# ------------------------
+# Load emotion model
+# ------------------------
 print("Loading emotion detection model...")
 try:
-    # Try the main model first
     pipe = pipeline(
-        "audio-classification", 
+        "audio-classification",
         model="ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
     )
-except:
-    # Fallback model if first fails
+except Exception as e:
+    print("Primary model failed, falling back:", e)
     pipe = pipeline(
         "audio-classification",
         model="superb/wav2vec2-base-superb-ers"
     )
+print("Model ready!")
+
+# ------------------------
+# Emotion -> Spotify params mapping (fine-grained)
+# ------------------------
+def emotion_to_spotify_params(emotion_label: str):
+    # emotion_label is expected uppercase like 'HAPPY', 'SADNESS', etc.
+    e = (emotion_label or "").upper()
+    mapping = {
+        "HAPPY":      {"valence": 0.9, "energy": 0.8, "tempo": 130.0},
+        "SURPRISE":   {"valence": 0.75, "energy": 0.85, "tempo": 125.0},
+        "NEUTRAL":    {"valence": 0.5, "energy": 0.45},
+        "SADNESS":    {"valence": 0.2, "energy": 0.25, "acousticness": 0.8},
+        "FEAR":       {"valence": 0.15, "energy": 0.25},
+        "ANGER":      {"valence": 0.2, "energy": 0.9, "tempo": 135.0},
+        "DISGUST":    {"valence": 0.15, "energy": 0.4}
+    }
+    return mapping.get(e, {"valence": 0.5, "energy": 0.5})
+
+# ------------------------
+# Spotify token retrieval (Client Credentials)
+# ------------------------
+def get_spotify_token():
+    client_id = SPOTIFY_CLIENT_ID
+    client_secret = SPOTIFY_CLIENT_SECRET
+    if not client_id or client_id.startswith("YOUR_") or not client_secret or client_secret.startswith("YOUR_"):
+        return None, "Spotify client id/secret not set. Please set SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET."
 
-print("Model loaded successfully!")
+    auth = f"{client_id}:{client_secret}"
+    b64 = base64.b64encode(auth.encode()).decode()
+    url = "https://accounts.spotify.com/api/token"
+    headers = {"Authorization": f"Basic {b64}"}
+    data = {"grant_type": "client_credentials"}
+
+    try:
+        r = requests.post(url, headers=headers, data=data, timeout=10)
+        r.raise_for_status()
+        token = r.json().get("access_token")
+        if not token:
+            return None, "No access token received from Spotify."
+        return token, None
+    except Exception as e:
+        return None, f"Spotify token error: {str(e)}"
 
+# ------------------------
+# Emotion analysis function
+# ------------------------
 def analyze_audio(audio):
     """
-    Analyze audio and return mood with confidence
-    audio: tuple of (sample_rate, audio_data) from Gradio
+    audio: (sample_rate, np.ndarray) from gr.Audio with type='numpy'
+    Returns: mood_display (with emoji), confidence (string), details (string), raw_label (string)
     """
     if audio is None:
-        return "🎤 No audio", "0%", "Please record or upload audio first"
-    
+        return "🎤 No audio", "0%", "Please record or upload audio first.", ""
+
     try:
-        # Get sample rate and audio data
         sample_rate, audio_data = audio
-        
-        # Convert to mono if stereo
+
+        # convert stereo -> mono
+        if audio_data is None:
+            return "🎤 Invalid audio", "0%", "Uploaded audio unreadable.", ""
         if len(audio_data.shape) > 1:
             audio_data = np.mean(audio_data, axis=0)
-        
-        # Run prediction
-        predictions = pipe({
+
+        preds = pipe({
             "raw": audio_data,
-            "sampling_rate": sample_rate
+            "sampling_rate": int(sample_rate)
         })
-        
-        # Get top result
-        top = predictions[0]
-        mood = top['label'].upper()
-        confidence = f"{top['score']*100:.1f}%"
-        
-        # Mood emoji mapping
+
+        if not preds:
+            return "🎤 No prediction", "0%", "Model returned no predictions.", ""
+
+        top = preds[0]
+        label = top.get("label", "UNKNOWN").upper()
+        confidence = f"{top.get('score', 0.0)*100:.1f}%"
+
         emoji_map = {
             "ANGER": "😠 Anger",
-            "DISGUST": "🤢 Disgust", 
+            "DISGUST": "🤢 Disgust",
             "FEAR": "😨 Fear",
             "HAPPY": "😊 Happy",
             "NEUTRAL": "😐 Neutral",
             "SADNESS": "😢 Sad",
             "SURPRISE": "😲 Surprise"
         }
-        
-        mood_display = emoji_map.get(mood, f"🎤 {mood}")
-        
-        # Create details
-        details = "All Predictions:\n"
-        for i, pred in enumerate(predictions[:5], 1):
-            details += f"{i}. {pred['label'].upper()}: {pred['score']*100:.1f}%\n"
-        
-        return mood_display, confidence, details
-        
+        mood_display = emoji_map.get(label, f"🎤 {label}")
+
+        # build details
+        details = ""
+        for i, p in enumerate(preds[:6], start=1):
+            lab = p.get("label", "unknown").upper()
+            sc = p.get("score", 0.0)
+            details += f"{i}. {lab}: {sc*100:.1f}%\n"
+
+        return mood_display, confidence, details, label
+
     except Exception as e:
-        return f"❌ Error", "0%", f"Analysis failed: {str(e)}"
+        return "❌ Error", "0%", f"Analysis failed: {str(e)}", ""
 
-# Create Gradio interface
-with gr.Blocks(title="MoodSync AI Detector", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎤 MoodSync AI  Detector")
-    gr.Markdown("Record your voice or upload audio to detect emotional state")
-    
-    with gr.Row():
-        with gr.Column():
-            # audio_input = gr.Audio(
-            #     sources=["microphone", "upload"],
-            #     type="numpy",
-            #     label="Speak or Upload Audio",
-            #     waveform_options={"show_controls": True}
-            # )
-            audio_input = gr.Audio(
-                sources=["microphone", "upload"],
-                type="numpy",
-                label="Speak or Upload Audio"
-                # The 'waveform_options' parameter has been removed entirely.
-            )
-            btn = gr.Button("Analyze Mood 🎯", variant="primary")
-        
-        with gr.Column():
-            mood_output = gr.Textbox(label="Detected Mood", interactive=False)
-            confidence_output = gr.Textbox(label="Confidence", interactive=False)
-            details_output = gr.Textbox(
-                label="Detailed Results", 
-                lines=6,
-                interactive=False
+# ------------------------
+# Spotify recommendation function (returns HTML)
+# ------------------------
+def recommend_music(emotion_label, genre, limit=5):
+    """
+    emotion_label: raw detected label (e.g., 'SADNESS')
+    genre: user-selected genre (string)
+    limit: number of tracks to fetch (max 20)
+    """
+    # Basic validation
+    if not emotion_label:
+        return "❌ Please analyze audio first (click Analyze Mood)."
+    if not genre:
+        return "❌ Please select a genre."
+
+    token, err = get_spotify_token()
+    if err:
+        return f"❌ {err}"
+
+    params = emotion_to_spotify_params(emotion_label)
+    # Build query for Spotify recommendations endpoint
+    url = "https://api.spotify.com/v1/recommendations"
+
+    query = {
+        "limit": int(limit),
+        "seed_genres": genre
+    }
+
+    # Add target params where available
+    if "valence" in params:
+        query["target_valence"] = params["valence"]
+    if "energy" in params:
+        query["target_energy"] = params["energy"]
+    if "acousticness" in params:
+        query["target_acousticness"] = params["acousticness"]
+    if "tempo" in params:
+        query["target_tempo"] = params["tempo"]
+
+    headers = {"Authorization": f"Bearer {token}"}
+
+    try:
+        r = requests.get(url, headers=headers, params=query, timeout=10)
+        # handle non-200
+        if r.status_code != 200:
+            try:
+                msg = r.json()
+            except:
+                msg = r.text
+            return f"❌ Spotify API error (status {r.status_code}): {msg}"
+
+        data = r.json()
+        tracks = data.get("tracks", [])
+        if not tracks:
+            return "❌ No tracks found for that genre+emotion combination. Try another genre."
+
+        # Build HTML for top results
+        html_lines = []
+        html_lines.append(f"<h3>🎧 Recommendations for <em>{emotion_label.title()}</em> + <strong>{genre}</strong></h3>")
+        html_lines.append("<div style='display:flex;flex-wrap:wrap;gap:12px;'>")
+
+        for t in tracks[:limit]:
+            name = t.get("name", "Unknown")
+            artists = ", ".join([a.get("name", "Unknown") for a in t.get("artists", [])])
+            spotify_url = t.get("external_urls", {}).get("spotify", "#")
+            album_images = t.get("album", {}).get("images", [])
+            img_url = album_images[0]["url"] if album_images else ""
+            # card HTML
+            card = (
+                "<div style='width:220px;border-radius:8px;padding:8px;"
+                "box-shadow:0 2px 8px rgba(0,0,0,0.08);background:#fff;'>"
             )
-    
-    # Instructions
-    with gr.Accordion("📖 Instructions", open=False):
-        gr.Markdown("""
-        **How to use:**
-        1. Click microphone icon and speak for 3-5 seconds
-        2. OR upload an audio file (WAV/MP3)
-        3. Click "Analyze Mood"
-        4. View your emotional state
-        
-        **Tips for best results:**
-        - Speak clearly in English
-        - Keep background noise minimal
-        - Optimal length: 3-5 seconds
-        - Use mono audio if possible
-        """)
-    
-    # Set up button action
-    btn.click(
+            if img_url:
+                card += f"<a href='{spotify_url}' target='_blank' rel='noopener noreferrer'><img src='{img_url}' alt='cover' style='width:100%;height:120px;object-fit:cover;border-radius:6px;'/></a>"
+            card += f"<div style='padding-top:8px;font-size:14px;'><strong>{name}</strong><br/><em style='font-size:13px;color:#555'>{artists}</em></div>"
+            card += f"<div style='padding-top:8px'><a href='{spotify_url}' target='_blank' rel='noopener noreferrer'>Open in Spotify ▶</a></div>"
+            card += "</div>"
+            html_lines.append(card)
+
+        html_lines.append("</div>")
+
+        return "\n".join(html_lines)
+
+    except Exception as e:
+        return f"❌ Recommendation error: {str(e)}"
+
+# ------------------------
+# Build Gradio UI
+# ------------------------
+with gr.Blocks(title="MoodSync AI + Spotify Recommender") as demo:
+    gr.Markdown("# 🎤 MoodSync AI + Spotify Recommender")
+    gr.Markdown("Record or upload a short audio clip (2–10s). The app will detect emotion and then suggest music based on that emotion + your chosen genre.")
+
+    with gr.Row():
+        with gr.Column(scale=6):
+            audio_input = gr.Audio(source="microphone", type="numpy", label="Speak or Upload Audio (2-10s)")
+            analyze_btn = gr.Button("Analyze Mood 🎯", variant="primary")
+            gr.Markdown("**Tips:** Speak clearly, 2–10 seconds, minimal background noise.")
+        with gr.Column(scale=4):
+            mood_display = gr.Textbox(label="Detected Mood (with emoji)", interactive=False)
+            confidence_display = gr.Textbox(label="Confidence", interactive=False)
+            details_display = gr.Textbox(label="Detailed Predictions", lines=6, interactive=False)
+            # hidden/aux label to carry raw emotion label for recommendation
+            raw_label = gr.Textbox(label="EmotionLabel", visible=False)
+
+    gr.Markdown("---")
+    gr.Markdown("## 🎶 Music Recommendation (Spotify)")
+    genre_dropdown = gr.Dropdown(
+        choices=[
+            "pop", "rock", "jazz", "hip-hop", "afrobeat", "classical", "rnb", "gospel", "electronic", "reggae"
+        ],
+        label="Choose a Genre (seed_genres)",
+        value="pop"
+    )
+
+    with gr.Row():
+        recommend_btn = gr.Button("Recommend Music 🎵", variant="secondary")
+        # Use HTML to display album covers nicely
+        recommendation_html = gr.HTML()
+
+    # Wire actions
+    analyze_btn.click(
         fn=analyze_audio,
         inputs=audio_input,
-        outputs=[mood_output, confidence_output, details_output]
+        outputs=[mood_display, confidence_display, details_display, raw_label]
     )
 
-# Launch the app
+    # Recommend uses raw emotion label + genre
+    recommend_btn.click(
+        fn=recommend_music,
+        inputs=[raw_label, genre_dropdown],
+        outputs=[recommendation_html]
+    )
+
+    # Accordion with small notes
+    with gr.Accordion("How this works (technical)", open=False):
+        gr.Markdown(
+            """
+            - We use a wav2vec2-based model to detect emotion from the audio (tone, not words).  
+            - The raw emotion label (e.g., HAPPY, SADNESS) maps to Spotify 'target' parameters like `valence` and `energy`.  
+            - We call Spotify's Recommendations endpoint using Client Credentials to fetch tracks seeded by the chosen genre.  
+            - No user login is required (server-side client credentials).  
+            """
+        )
+
+# Launch (suitable for Hugging Face space or local)
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)