Update app.py

app.py

@@ -27,10 +27,11 @@ def get_token(client_id, client_secret):
     payload = {'grant_type': 'client_credentials'}
     response = requests.post(url, headers=headers, data=payload, auth=(client_id, client_secret))
     global total_requests
-    total_requests += 1  # Counting request
+    total_requests += 1
     if response.status_code == 200:
         return response.json().get('access_token')
     else:
+        print(f"Error getting token: {response.status_code} - {response.text}")
         return None
 
 def handle_rate_limit(response, attempt):
@@ -45,200 +46,206 @@ def make_request_with_retry(url, headers, params=None, max_retries=5):
     global total_requests
     for attempt in range(max_retries):
         response = requests.get(url, headers=headers, params=params)
-        total_requests += 1  # Counting request
+        total_requests += 1
         if handle_rate_limit(response, attempt):
             continue
         if response.status_code == 200:
             return response
         else:
-            break
+            print(f"Request failed: {response.status_code} - {response.text}")
+            time.sleep(1)  # Small delay before retrying
     return None
 
-def get_audio_features(token, track_ids):
-    audio_features = {}
-    url = 'https://api.spotify.com/v1/audio-features'
-    headers = {'Authorization': f'Bearer {token}'}
+def extract_id_from_url(url, type_keyword):
+    """Extract Spotify ID from URL for either track or playlist."""
+    parts = url.split("/")
+    for i, part in enumerate(parts):
+        if type_keyword in part and i + 1 < len(parts):
+            potential_id = parts[i + 1].split("?")[0]
+            if potential_id:
+                return potential_id
+    
+    # If above fails, try to find ID in the last part of the URL
+    last_part = parts[-1]
+    if "?" in last_part:
+        return last_part.split("?")[0]
+    return last_part
+
+def get_playlist_tracks(token, playlist_url):
+    """Get all tracks from a playlist URL."""
+    playlist_id = extract_id_from_url(playlist_url, "playlist")
+    print(f"Extracted playlist ID: {playlist_id}")
     
-    # Print track IDs for debugging
-    print(f"Getting audio features for {len(track_ids)} tracks")
-    
-    for i in range(0, len(track_ids), 100):
-        batch_ids = track_ids[i:i+100]
-        params = {'ids': ','.join(batch_ids)}
-        response = make_request_with_retry(url, headers, params)
-        if response:
-            features_list = response.json().get('audio_features', [])
-            print(f"Received {len(features_list)} audio features")
-            for feature in features_list:
-                if feature and 'id' in feature:
-                    audio_features[feature['id']] = feature
-    
-    # Print how many valid features we found
-    print(f"Found {len(audio_features)} valid audio features")
-    return audio_features
-
-def get_tracks_and_features(token, url):
     headers = {'Authorization': f'Bearer {token}'}
-    track_ids = []
-    
-    if "track" in url:
-        # Handle various URL formats
-        parts = url.split("/")
-        for part in parts:
-            if part and ("?" in part):
-                track_id = part.split("?")[0]
-                track_ids = [track_id]
-                break
-        if not track_ids and len(parts) > 0:
-            potential_id = parts[-1]
-            if potential_id:
-                track_ids = [potential_id]
-    elif "playlist" in url:
-        # Handle various URL formats
-        parts = url.split("/")
-        playlist_id = None
-        for part in parts:
-            if part and ("?" in part):
-                playlist_id = part.split("?")[0]
-                break
-        if not playlist_id and len(parts) > 0:
-            playlist_id = parts[-1]
+    tracks_url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
+    
+    all_tracks = []
+    next_url = tracks_url
+    
+    while next_url:
+        print(f"Fetching tracks from: {next_url}")
+        response = make_request_with_retry(next_url, headers)
+        if not response:
+            break
+            
+        data = response.json()
+        items = data.get('items', [])
+        for item in items:
+            if item and item.get('track'):
+                track = item['track']
+                all_tracks.append(track)
         
-        if playlist_id:
-            tracks_url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
-            response = make_request_with_retry(tracks_url, headers)
-            if response and response.json().get('items'):
-                track_ids = [item['track']['id'] for item in response.json().get('items', []) 
-                            if item.get('track') and item['track'].get('id')]
-    
-    if not track_ids:
-        return None, None
-
-    audio_features = get_audio_features(token, track_ids)
-    return track_ids, audio_features
+        next_url = data.get('next')
+    
+    print(f"Found {len(all_tracks)} tracks in playlist")
+    return all_tracks
 
-def find_similar_tracks(token, audio_features, n_songs=10):
+def get_track_info(token, track_url):
+    """Get information about a single track."""
+    track_id = extract_id_from_url(track_url, "track")
+    print(f"Extracted track ID: {track_id}")
+    
     headers = {'Authorization': f'Bearer {token}'}
-    seed_tracks = list(audio_features.keys())[:5]  # Spotify allows up to 5 seed tracks
-
-    params = {
-        'seed_tracks': ','.join(seed_tracks),
-        'limit': n_songs
-    }
-
-    url = 'https://api.spotify.com/v1/recommendations'
-    response = make_request_with_retry(url, headers, params=params)
-
-    if response:
-        recommended_tracks = response.json().get('tracks', [])
-        track_ids = [track['id'] for track in recommended_tracks]
-        return get_track_information(token, track_ids)
+    url = f'https://api.spotify.com/v1/tracks/{track_id}'
     
+    response = make_request_with_retry(url, headers)
+    if response:
+        return [response.json()]
     return []
 
-def get_track_information(token, track_ids):
+def extract_track_details(tracks):
+    """Extract relevant information from track objects."""
     tracks_info = []
-    audio_features = get_audio_features(token, track_ids)  # Get audio features
-    url = 'https://api.spotify.com/v1/tracks'
-    headers = {'Authorization': f'Bearer {token}'}
-
-    for i in range(0, len(track_ids), 50):
-        batch_ids = track_ids[i:i+50]
-        params = {'ids': ','.join(batch_ids)}
-        response = make_request_with_retry(url, headers, params)
-        if response:
-            tracks = response.json().get('tracks', [])
-            for track in tracks:
-                features = audio_features.get(track['id'], {})
-                tracks_info.append({
-                    'artist': track['artists'][0]['name'] if track['artists'] else 'Unknown',
-                    'title': track['name'],
-                    'isrc': track['external_ids'].get('isrc', 'Not available'),
-                    'popularity': track.get('popularity', 'Not available'),
-                    'release_year': track.get('album', {}).get('release_date', 'Not available').split('-')[0] if track.get('album', {}).get('release_date') else 'Not available',
-                    'duration': track.get('duration_ms', 'Not available'),
-                    'danceability': features.get('danceability', 'Not available'),
-                    'energy': features.get('energy', 'Not available'),
-                    'tempo': features.get('tempo', 'Not available'),
-                    'valence': features.get('valence', 'Not available'),
-                    'url': track['external_urls']['spotify']
-                })
+    for track in tracks:
+        if not track:
+            continue
+            
+        tracks_info.append({
+            'artist': track['artists'][0]['name'] if track.get('artists') else 'Unknown',
+            'title': track.get('name', 'Unknown'),
+            'album': track.get('album', {}).get('name', 'Unknown'),
+            'isrc': track.get('external_ids', {}).get('isrc', 'Not available'),
+            'popularity': track.get('popularity', 'Not available'),
+            'release_date': track.get('album', {}).get('release_date', 'Not available'),
+            'duration_ms': track.get('duration_ms', 'Not available'),
+            'spotify_url': track.get('external_urls', {}).get('spotify', 'Not available'),
+            'preview_url': track.get('preview_url', 'Not available'),
+            'playlist_source': getattr(track, 'playlist_source', 'Direct Track')
+        })
     return tracks_info
 
 # Main Interface Function
-def interface(project_name, spotify_url, num_similar_songs=10):
-    # Input validation
-    if not spotify_url or not ("spotify.com" in spotify_url and ("track" in spotify_url or "playlist" in spotify_url)):
-        error_message = "Invalid URL format. Please enter a valid Spotify track or playlist URL."
-        # Return empty DataFrame with error message and None for file
+def interface(project_name, spotify_urls, include_all_info=True):
+    """Process multiple Spotify URLs (tracks or playlists) and combine results."""
+    if not project_name:
+        project_name = "spotify_tracks"
+    
+    # Split and clean URLs
+    urls_list = [url.strip() for url in spotify_urls.strip().split('\n') if url.strip()]
+    
+    if not urls_list:
+        error_message = "Please enter at least one Spotify URL (track or playlist)."
         return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
-        
-    # Log the URL for debugging
-    print(f"Processing Spotify URL: {spotify_url}")
     
+    # Validate URLs
+    valid_urls = []
+    for url in urls_list:
+        if "spotify.com" in url and ("track" in url or "playlist" in url):
+            valid_urls.append(url)
+        else:
+            print(f"Invalid URL format, skipping: {url}")
+    
+    if not valid_urls:
+        error_message = "No valid Spotify URLs found. Please enter valid track or playlist URLs."
+        return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
+    
+    print(f"Processing {len(valid_urls)} valid Spotify URLs")
+    
+    # Get token
     token_spotify = get_token(client_ids[current_api_index], client_secrets[current_api_index])
     if not token_spotify:
         error_message = "Failed to authenticate with Spotify API. Please try again later."
         return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
     
-    print(f"Successfully obtained token")
-        
-    try:
-        track_ids, audio_features = get_tracks_and_features(token_spotify, spotify_url)
-        print(f"Track IDs: {track_ids[:5]}{'...' if len(track_ids) > 5 else ''}")
-        
-        if not track_ids:
-            error_message = "No valid tracks found for the provided URL. Please check the URL and try again."
-            return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
-            
-        if not audio_features:
-            error_message = "Could not retrieve audio features for the tracks. Please try again."
-            return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
-            
-        if len(audio_features) == 0:
-            error_message = "Received empty audio features. The track might not be available in your region."
-            return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
-    except Exception as e:
-        error_message = f"An error occurred: {str(e)}"
-        print(f"Error: {str(e)}")
-        return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
-
-    similar_tracks_info = find_similar_tracks(token_spotify, audio_features, num_similar_songs)
+    all_tracks = []
+    
+    # Process each URL
+    for url in valid_urls:
+        try:
+            print(f"Processing URL: {url}")
+            if "playlist" in url:
+                tracks = get_playlist_tracks(token_spotify, url)
+                # Add source information
+                for track in tracks:
+                    track['playlist_source'] = url
+                all_tracks.extend(tracks)
+            elif "track" in url:
+                track = get_track_info(token_spotify, url)
+                if track:
+                    track[0]['playlist_source'] = url
+                    all_tracks.extend(track)
+        except Exception as e:
+            print(f"Error processing URL {url}: {str(e)}")
+            continue
     
-    if not similar_tracks_info:
-        error_message = "Could not find similar tracks. Please try with a different track or playlist."
+    if not all_tracks:
+        error_message = "Could not find any tracks in the provided URLs."
         return gr.Dataframe(value=pd.DataFrame({"Error": [error_message]})), None
     
-    # Create DataFrame
-    df = pd.DataFrame(similar_tracks_info)
-
+    # Extract track details
+    tracks_info = extract_track_details(all_tracks)
+    
+    # Remove duplicate tracks (based on ISRC or title+artist if ISRC not available)
+    df = pd.DataFrame(tracks_info)
+    
+    # Create a key for deduplication
+    df['dedup_key'] = df.apply(
+        lambda row: row['isrc'] if row['isrc'] != 'Not available' else f"{row['artist']}_{row['title']}", 
+        axis=1
+    )
+    
+    # Drop duplicates
+    df = df.drop_duplicates(subset='dedup_key')
+    df = df.drop(columns=['dedup_key'])
+    
+    print(f"Found {len(df)} unique tracks after deduplication")
+    
+    # Filter columns if not include_all_info
+    if not include_all_info:
+        columns_to_keep = ['artist', 'title', 'album', 'release_date', 'popularity', 'spotify_url']
+        df = df[columns_to_keep]
+    
     # Save DataFrame to an Excel file
     tmpfile = NamedTemporaryFile(delete=False, suffix='.xlsx')
     df.to_excel(tmpfile.name, index=False)
-
+    
     # Rename the file with the project name
-    project_file_name = f"{project_name if project_name else 'spotify_similar_tracks'}.xlsx"
+    project_file_name = f"{project_name}.xlsx"
     shutil.move(tmpfile.name, project_file_name)
-
-    return df, project_file_name  # Returns the DataFrame and the link to the Excel file
+    
+    return df, project_file_name
 
 # Gradio Interface Configuration
 iface = gr.Interface(
     fn=interface,
     inputs=[
-        gr.Textbox(label="Project Name", placeholder="Enter a name for your project"),
-        gr.Textbox(label="Spotify URL (Track or Playlist)", placeholder="https://open.spotify.com/track/... or https://open.spotify.com/playlist/..."),
-        gr.Slider(label="Number of Similar Songs", minimum=1, maximum=100, value=10, step=1)
+        gr.Textbox(label="Project Name", placeholder="Enter a name for your export"),
+        gr.Textbox(
+            label="Spotify URLs (Tracks or Playlists)", 
+            placeholder="Enter one Spotify URL per line (tracks or playlists)",
+            lines=5
+        ),
+        gr.Checkbox(label="Include All Track Information", value=True)
     ],
     outputs=[
         gr.Dataframe(),
         gr.File(label="Download Excel")
     ],
-    title="Spotify Similar Track Finder",
-    description="Enter a Spotify URL to find similar songs based on their audio features.",
+    title="Spotify Track Collector",
+    description="Extract tracks from multiple Spotify playlists and tracks into a single Excel file.",
     examples=[
-        ["Pop Hits", "https://open.spotify.com/track/1mWdTewIgB3gtBM3TOSFhB", 10],
-        ["Rock Classics", "https://open.spotify.com/playlist/37i9dQZF1DWXRqgorJj26U", 15]
+        ["Pop Collection", "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M\nhttps://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT", True],
+        ["Rock Collection", "https://open.spotify.com/playlist/37i9dQZF1DWXRqgorJj26U", False]
     ],
     allow_flagging="never"
 )