Update app.py

app.py

@@ -1,91 +1,30 @@
 import os
 import requests
+from flask import Flask, redirect, request, jsonify
 import gradio as gr
-from flask import redirect
+import threading
+import time
 
-# Spotify API credentials (set in HF Space secrets)
-CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")
-CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")
-REDIRECT_URI = os.getenv("REDIRECT_URI", "https://lenpanda-spotify-mcp.hf.space/callback")
+# Spotify API credentials (set these in your HF Space's Environment Variables)
+CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")  # Add to HF Space secrets
+CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")  # Add to HF Space secrets
+REDIRECT_URI = os.getenv("REDIRECT_URI", "https://lenpanda-spotify-mcp.hf.space/callback")  # Update with your Space URL
 SPOTIFY_AUTH_URL = "https://accounts.spotify.com/authorize"
 SPOTIFY_TOKEN_URL = "https://accounts.spotify.com/api/token"
-SCOPE = "playlist-modify-public playlist-modify-private"
+SCOPE = "playlist-modify-public playlist-modify-private user-read-private"
 
-# Store access token (for demo; use a session store in production)
+# Initialize Flask app
+app = Flask(__name__)
+
+# Store access token and user info (for demo purposes; use proper session store in production)
 access_token = None
+user_info = None
 
-# Flask-like route handlers
+@app.route('/')
 def home():
-    return """
-    <a href="/login">Login with Spotify</a><br><br>
-    <div id="song-form">
-        <input id="song-name" placeholder="Song Name" type="text">
-        <input id="artist-name" placeholder="Artist Name (optional)" type="text">
-        <button onclick="addSong()">Add Song to Playlist</button>
-        <div id="result"></div>
-    </div>
-    <script>
-        async function getTrackUri(songName, accessToken, artistName = null) {
-            let query = `track:${songName}`;
-            if (artistName) query += ` artist:${artistName}`;
-            const url = `https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=track&limit=1`;
-            const headers = { "Authorization": `Bearer ${accessToken}` };
-            try {
-                const response = await fetch(url, { headers });
-                const data = await response.json();
-                if (data.tracks && data.tracks.items.length > 0) {
-                    return data.tracks.items[0].uri;
-                }
-                throw new Error("Song not found");
-            } catch (error) {
-                throw new Error(`Search error: ${error.message}`);
-            }
-        }
-
-        async function addSongToPlaylist(playlistId, trackUri, accessToken) {
-            const url = `https://api.spotify.com/v1/playlists/${playlistId}/tracks`;
-            const headers = {
-                "Authorization": `Bearer ${accessToken}`,
-                "Content-Type": "application/json",
-            };
-            const body = { uris: [trackUri], position: 0 };
-            try {
-                const response = await fetch(url, {
-                    method: "POST",
-                    headers,
-                    body: JSON.stringify(body),
-                });
-                const data = await response.json();
-                if (response.status === 201) {
-                    return "Song added to playlist!";
-                }
-                throw new Error(`Error adding song: ${data.error?.message || "Unknown error"}`);
-            } catch (error) {
-                throw new Error(`Playlist error: ${error.message}`);
-            }
-        }
-
-        async function addSong() {
-            const songName = document.getElementById("song-name").value;
-            const artistName = document.getElementById("artist-name").value;
-            const resultDiv = document.getElementById("result");
-            const accessToken = "{{ACCESS_TOKEN}}"; // Replaced server-side
-            const playlistId = "YOUR_PLAYLIST_ID"; // Replace with actual ID
-            if (!accessToken || accessToken === "Not authenticated") {
-                resultDiv.innerText = "Please authenticate with Spotify first.";
-                return;
-            }
-            try {
-                const trackUri = await getTrackUri(songName, accessToken, artistName);
-                const result = await addSongToPlaylist(playlistId, trackUri, accessToken);
-                resultDiv.innerText = result;
-            } catch (error) {
-                resultDiv.innerText = error.message;
-            }
-        }
-    </script>
-    """.replace("{{ACCESS_TOKEN}}", access_token or "Not authenticated")
+    return '<a href="/login">Login with Spotify</a>'
 
+@app.route('/login')
 def login():
     auth_url = (
         f"{SPOTIFY_AUTH_URL}?client_id={CLIENT_ID}&response_type=code"
@@ -93,11 +32,14 @@ def login():
     )
     return redirect(auth_url)
 
-def callback(code=None):
-    global access_token
+@app.route('/callback')
+def callback():
+    global access_token, user_info
+    code = request.args.get('code')
     if not code:
         return "Error: No authorization code provided", 400
-
+    
+    # Exchange code for access token
     token_data = {
         "grant_type": "authorization_code",
         "code": code,
@@ -105,68 +47,183 @@ def callback(code=None):
         "client_id": CLIENT_ID,
         "client_secret": CLIENT_SECRET
     }
+    
     response = requests.post(SPOTIFY_TOKEN_URL, data=token_data)
     token_json = response.json()
-
+    
     if response.status_code == 200:
         access_token = token_json.get("access_token")
-        return redirect("/")
+        
+        # Get user info
+        headers = {"Authorization": f"Bearer {access_token}"}
+        user_response = requests.get("https://api.spotify.com/v1/me", headers=headers)
+        if user_response.status_code == 200:
+            user_info = user_response.json()
+        
+        return f"Authorization successful! You can now use the Gradio interface. <br><a href='http://localhost:7860'>Go to Gradio Interface</a>"
     else:
         return f"Error: {token_json.get('error_description', 'Failed to get access token')}", 400
 
-# Gradio interface for server-side song addition (optional fallback)
-def gradio_interface(song_name="", artist_name=""):
+@app.route('/status')
+def status():
+    return jsonify({
+        "authenticated": access_token is not None,
+        "user": user_info.get("display_name") if user_info else None
+    })
+
+# Gradio functions
+def get_auth_status():
+    if access_token and user_info:
+        return f"✅ Authenticated as: {user_info.get('display_name', 'Unknown')}"
+    else:
+        return "❌ Not authenticated. Please visit the Flask login page first."
+
+def search_songs(query):
     if not access_token:
-        return "Error: Not authenticated. Please log in via /login."
-    if not song_name:
-        return "Please enter a song name."
-    try:
-        query = f"track:{song_name}"
-        if artist_name:
-            query += f" artist:{artist_name}"
-        url = f"https://api.spotify.com/v1/search?q={query}&type=track&limit=1"
-        headers = {"Authorization": f"Bearer {access_token}"}
-        response = requests.get(url, headers=headers)
+        return "Please authenticate first!"
+    
+    if not query.strip():
+        return "Please enter a search query."
+    
+    headers = {"Authorization": f"Bearer {access_token}"}
+    params = {"q": query, "type": "track", "limit": 10}
+    
+    response = requests.get("https://api.spotify.com/v1/search", headers=headers, params=params)
+    
+    if response.status_code == 200:
         data = response.json()
-        if not data.get("tracks", {}).get("items"):
-            return "Error: Song not found."
-        track_uri = data["tracks"]["items"][0]["uri"]
-
-        playlist_id = "YOUR_PLAYLIST_ID"  # Replace with actual ID
-        url = f"https://api.spotify.com/v1/playlists/{playlist_id}/tracks"
-        headers = {
-            "Authorization": f"Bearer {access_token}",
-            "Content-Type": "application/json",
-        }
-        data = {"uris": [track_uri], "position": 0}
-        response = requests.post(url, headers=headers, json=data)
-        if response.status_code == 201:
-            return f"Added '{song_name}' to playlist!"
-        return f"Error adding song: {response.json().get('error', {}).get('message', 'Unknown error')}"
-    except Exception as e:
-        return f"Error: {str(e)}"
+        tracks = data.get("tracks", {}).get("items", [])
+        
+        if not tracks:
+            return "No tracks found."
+        
+        result = "🎵 Search Results:\n\n"
+        for i, track in enumerate(tracks, 1):
+            artists = ", ".join([artist["name"] for artist in track["artists"]])
+            result += f"{i}. **{track['name']}** by {artists}\n"
+            result += f"   Album: {track['album']['name']}\n"
+            result += f"   URI: `{track['uri']}`\n\n"
+        
+        return result
+    else:
+        return f"Error searching: {response.json().get('error', {}).get('message', 'Unknown error')}"
 
-# Create Gradio Blocks
-demo = gr.Blocks()
+def get_user_playlists():
+    if not access_token:
+        return "Please authenticate first!"
+    
+    headers = {"Authorization": f"Bearer {access_token}"}
+    response = requests.get("https://api.spotify.com/v1/me/playlists", headers=headers)
+    
+    if response.status_code == 200:
+        data = response.json()
+        playlists = data.get("items", [])
+        
+        if not playlists:
+            return "No playlists found."
+        
+        result = "📋 Your Playlists:\n\n"
+        for playlist in playlists:
+            result += f"**{playlist['name']}**\n"
+            result += f"ID: `{playlist['id']}`\n"
+            result += f"Tracks: {playlist['tracks']['total']}\n\n"
+        
+        return result
+    else:
+        return f"Error getting playlists: {response.json().get('error', {}).get('message', 'Unknown error')}"
 
-# Define routes outside Blocks context
-demo.route("/", home)
-demo.route("/login", login)
-demo.route("/callback", callback)
+def add_song_to_playlist(playlist_id, track_uri):
+    if not access_token:
+        return "Please authenticate first!"
+    
+    if not playlist_id.strip() or not track_uri.strip():
+        return "Please provide both playlist ID and track URI."
+    
+    # Ensure track_uri is in correct format
+    if not track_uri.startswith("spotify:track:"):
+        if track_uri.startswith("https://open.spotify.com/track/"):
+            track_uri = f"spotify:track:{track_uri.split('/')[-1].split('?')[0]}"
+        else:
+            track_uri = f"spotify:track:{track_uri}"
+    
+    url = f"https://api.spotify.com/v1/playlists/{playlist_id}/tracks"
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Content-Type": "application/json"
+    }
+    data = {"uris": [track_uri]}
+    
+    response = requests.post(url, headers=headers, json=data)
+    
+    if response.status_code == 201:
+        return "✅ Song added to playlist successfully!"
+    else:
+        error_msg = response.json().get('error', {}).get('message', 'Unknown error')
+        return f"❌ Error adding song: {error_msg}"
 
-# Define Gradio UI
-with demo:
-    gr.Markdown("## Spotify Playlist Manager")
+# Create Gradio interface
+with gr.Blocks(title="Spotify Playlist Manager") as demo:
+    gr.Markdown("# 🎵 Spotify Playlist Manager")
+    gr.Markdown("First, authenticate with Spotify using the Flask login page, then use the tools below.")
+    
+    # Authentication status
+    with gr.Row():
+        auth_status = gr.Textbox(label="Authentication Status", interactive=False)
+        refresh_btn = gr.Button("🔄 Refresh Status")
+    
+    refresh_btn.click(get_auth_status, outputs=auth_status)
+    
+    # Search songs
+    gr.Markdown("## 🔍 Search Songs")
+    with gr.Row():
+        search_input = gr.Textbox(label="Search for songs", placeholder="Enter song name, artist, or album")
+        search_btn = gr.Button("Search")
+    search_output = gr.Textbox(label="Search Results", lines=10)
+    
+    search_btn.click(search_songs, inputs=search_input, outputs=search_output)
+    
+    # Get playlists
+    gr.Markdown("## 📋 Your Playlists")
     with gr.Row():
-        song_input = gr.Textbox(label="Song Name")
-        artist_input = gr.Textbox(label="Artist Name (optional)")
-        submit_button = gr.Button("Add Song to Playlist")
-    output = gr.Textbox(label="Result")
-    submit_button.click(
-        fn=gradio_interface,
-        inputs=[song_input, artist_input],
-        outputs=output
+        get_playlists_btn = gr.Button("Get My Playlists")
+    playlists_output = gr.Textbox(label="Your Playlists", lines=8)
+    
+    get_playlists_btn.click(get_user_playlists, outputs=playlists_output)
+    
+    # Add song to playlist
+    gr.Markdown("## ➕ Add Song to Playlist")
+    with gr.Row():
+        playlist_id_input = gr.Textbox(label="Playlist ID", placeholder="Enter playlist ID from above")
+        track_uri_input = gr.Textbox(label="Track URI", placeholder="spotify:track:... or Spotify URL")
+    with gr.Row():
+        add_song_btn = gr.Button("Add Song to Playlist")
+    add_song_output = gr.Textbox(label="Result")
+    
+    add_song_btn.click(
+        add_song_to_playlist, 
+        inputs=[playlist_id_input, track_uri_input], 
+        outputs=add_song_output
     )
+    
+    # Load initial status
+    demo.load(get_auth_status, outputs=auth_status)
+
+# Run Flask and Gradio
+def run_flask():
+    app.run(host="0.0.0.0", port=5000, debug=False)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    # Start Flask in a separate thread
+    flask_thread = threading.Thread(target=run_flask, daemon=True)
+    flask_thread.start()
+    
+    # Give Flask time to start
+    time.sleep(2)
+    
+    # Launch Gradio on port 7860 (HF Spaces default)
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=False,
+        show_error=True
+    )