Update app.py

app.py

@@ -22,99 +22,107 @@ def rotate_client():
     global current_client_index, request_counter
     current_client_index = (current_client_index + 1) % len(client_ids)
     request_counter = 0
-    print(f"🔄 Rotating to Spotify client #{current_client_index + 1}")
+    print(f"🔄 Rotated to Spotify client #{current_client_index + 1}")
 
 def get_spotify_token():
     global current_client_index
-    for _ in range(len(client_ids)):
+    for intento in range(len(client_ids)):
         client_id = client_ids[current_client_index]
         client_secret = client_secrets[current_client_index]
-        
+        print(f"🔑 Intentando token con cliente #{current_client_index + 1}")
         response = requests.post(
             'https://accounts.spotify.com/api/token',
             headers={'Content-Type': 'application/x-www-form-urlencoded'},
             data={'grant_type': 'client_credentials'},
             auth=(client_id, client_secret)
         )
-        
+        print(f"➡️ get_spotify_token: status_code={response.status_code}")
         if response.status_code == 200:
-            return response.json().get('access_token')
-        
-        print(f"❌ Error with client {current_client_index}: {response.text}")
-        rotate_client()
-    
+            token = response.json().get('access_token')
+            print(f"✅ Token OK (cliente #{current_client_index+1}): {token[:10]}…")
+            return token
+        else:
+            print(f"❌ Error token cliente #{current_client_index+1}: {response.text}")
+            rotate_client()
     raise Exception("🚨 All clients failed to obtain token")
 
 def make_spotify_request(url, params=None):
     global request_counter
     token = get_spotify_token()
+    print(f"🔑 Usando token: {token[:10]}…")
+    print(f"🌐 Llamando a URL: {url}")
+    if params:
+        print(f"   con params: {params}")
     headers = {'Authorization': f'Bearer {token}'}
     
-    for _ in range(3):
+    for intento in range(3):
+        print(f"🔁 make_spotify_request intento #{intento+1}")
         response = requests.get(url, headers=headers, params=params)
+        print(f"➡️ Status code: {response.status_code}")
         request_counter += 1
         
         if response.status_code == 429:
-            print(f"⚠️ Rate limit reached. Client: {current_client_index}")
+            retry = int(response.headers.get('Retry-After', 10))
+            print(f"⚠️ Rate limit. Esperando {retry}s y rotando cliente")
             rotate_client()
-            time.sleep(int(response.headers.get('Retry-After', 10)))
+            time.sleep(retry)
             continue
-            
+        
         if response.status_code == 200:
             if request_counter >= MAX_REQUESTS_PER_CLIENT:
+                print("🔄 Límite requests alcanzado, rotando cliente")
                 rotate_client()
             return response.json()
         
         print(f"❌ Error {response.status_code}: {response.text}")
         time.sleep(2)
     
+    print("🚫 make_spotify_request: todos los intentos fallaron")
     return None
 
 def extract_spotify_id(url, resource_type):
-    clean_url = url.strip().split('?')[0].replace("https://open.spotify.com/", "")
-    if "/intl-" in clean_url:
-        parts = clean_url.split("/")
+    clean = url.strip().split('?')[0].replace("https://open.spotify.com/", "")
+    if "/intl-" in clean:
+        parts = clean.split("/")
         return parts[-1]
-    parts = clean_url.split("/")
+    parts = clean.split("/")
     try:
         idx = parts.index(resource_type)
-        return parts[idx + 1] if idx + 1 < len(parts) else None
+        return parts[idx + 1]
     except ValueError:
         for part in parts:
             if len(part) == 22 and resource_type in url:
                 return part
-        return None
+    print(f"❌ extract_spotify_id no pudo extraer ID de {url}")
+    return None
 
 def get_playlist_tracks(playlist_url):
-    playlist_id = extract_spotify_id(playlist_url, "playlist")
-    if not playlist_id or len(playlist_id) != 22:
-        print(f"❌ Invalid playlist ID: {playlist_id}")
+    pid = extract_spotify_id(playlist_url, "playlist")
+    if not pid:
         return []
-    
-    print(f"🎧 Getting playlist: {playlist_id}")
+    print(f"🎧 Getting playlist: {pid}")
     tracks = []
-    url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
+    url = f'https://api.spotify.com/v1/playlists/{pid}/tracks'
     params = {'market': 'US', 'limit': 100}
     
     while url:
         data = make_spotify_request(url, params)
         if not data:
             break
-        tracks.extend([item['track'] for item in data.get('items', []) if item.get('track')])
+        items = data.get('items', [])
+        print(f"   Got {len(items)} items")
+        tracks.extend([it['track'] for it in items if it.get('track')])
         url = data.get('next')
-    
-    print(f"✅ Found {len(tracks)} tracks")
+    print(f"✅ Found total {len(tracks)} tracks in playlist")
     return tracks
 
 def get_album_tracks(album_url):
-    album_id = extract_spotify_id(album_url, "album")
-    if not album_id or len(album_id) != 22:
-        print(f"❌ Invalid album ID: {album_id}")
+    aid = extract_spotify_id(album_url, "album")
+    if not aid:
         return []
-    
-    print(f"💿 Getting album: {album_id}")
+    print(f"💿 Getting album: {aid}")
     all_tracks = []
-    url = f'https://api.spotify.com/v1/albums/{album_id}/tracks'
+    url = f'https://api.spotify.com/v1/albums/{aid}/tracks'
     params = {'market': 'US', 'limit': 50}
     
     while url:
@@ -122,17 +130,19 @@ def get_album_tracks(album_url):
         if not data:
             break
         for item in data.get('items', []):
+            print(f"   Fetching track detail for {item['id']}")
             td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{item['id']}")
             if td:
                 all_tracks.append(td)
         url = data.get('next')
-    
-    print(f"✅ Encontrados {len(all_tracks)} tracks")
+    print(f"✅ Found total {len(all_tracks)} tracks in album")
     return all_tracks
 
 def process_tracks(urls):
+    print("🔍 process_tracks iniciado")
     all_tracks = []
     for url in urls:
+        print(f"➡️ Procesando URL: {url}")
         try:
             if "playlist" in url:
                 all_tracks.extend(get_playlist_tracks(url))
@@ -144,13 +154,16 @@ def process_tracks(urls):
                 if td:
                     all_tracks.append(td)
         except Exception as e:
-            print(f"⚠️ Error processing {url}: {e}")
+            print(f"⚠️ Error procesando {url}: {e}")
+    print(f"🔍 process_tracks terminó con {len(all_tracks)} tracks")
     return all_tracks
 
 def create_final_dataframe(tracks, include_all_info=True):
+    print("📊 create_final_dataframe iniciado")
     artist_cache = {}
     def get_artist_details(aid):
         if aid not in artist_cache:
+            print(f"   Obteniendo detalles de artista {aid}")
             d = make_spotify_request(f"https://api.spotify.com/v1/artists/{aid}")
             artist_cache[aid] = {
                 'genres': d.get('genres', []) if d else [],
@@ -166,49 +179,50 @@ def create_final_dataframe(tracks, include_all_info=True):
         ma = tr['artists'][0] if tr.get('artists') else {}
         ai = get_artist_details(ma.get('id')) if ma.get('id') else {}
         dur = f"{tr['duration_ms']//60000}:{str(tr['duration_ms']%60000//1000).zfill(2)}"
-        base = {
-            'Artist': ma.get('name', 'Unknown'),
-            'Title': tr.get('name', 'No title'),
-            'Album': tr.get('album', {}).get('name', 'No album'),
-            'ISRC': tr.get('external_ids', {}).get('isrc', 'Not available'),
-            'Popularity': tr.get('popularity', 0),
+        row = {
+            'Artist': ma.get('name','Unknown'),
+            'Title': tr.get('name','No title'),
+            'Album': tr.get('album',{}).get('name',''),
+            'ISRC': tr.get('external_ids',{}).get('isrc',''),
+            'Popularity': tr.get('popularity',0),
             'Duration': dur,
-            'Release Date': tr.get('album', {}).get('release_date', 'Not available'),
-            'Spotify URI': tr.get('external_urls', {}).get('spotify', '')
+            'Release Date': tr.get('album',{}).get('release_date',''),
+            'Spotify URI': tr.get('external_urls',{}).get('spotify','')
         }
         if include_all_info:
-            base.update({
-                'Genres': ', '.join(ai.get('genres', [])),
-                'Artist Followers': ai.get('followers', 0),
-                'Artist Popularity': ai.get('popularity', 0),
+            row.update({
+                'Genres': ', '.join(ai.get('genres',[])),
+                'Artist Followers': ai.get('followers',0),
+                'Artist Popularity': ai.get('popularity',0),
                 'Explicit': 'Yes' if tr.get('explicit') else 'No',
                 'Track ID': tr.get('id'),
-                'Album ID': tr.get('album', {}).get('id')
+                'Album ID': tr.get('album',{}).get('id')
             })
-        rows.append(base)
-    
+        rows.append(row)
     df = pd.DataFrame(rows)
     df['dup_key'] = df.apply(
-        lambda x: x['ISRC'] if x['ISRC'] != 'Not available' else f"{x['Artist']}|{x['Title']}", axis=1
+        lambda x: x['ISRC'] or f"{x['Artist']}|{x['Title']}", axis=1
     )
     df = df.drop_duplicates('dup_key').drop(columns='dup_key')
+    print("📊 create_final_dataframe completado")
     return df
 
 def main_interface(project_name, spotify_urls, include_all_info=True):
-    urls = [u.strip() for u in spotify_urls.replace('\n', ',').split(',') if u.strip()]
+    print(f"\n🎬 Inicio interface con proyecto: {project_name}")
+    urls = [u.strip() for u in spotify_urls.replace('\n',',').split(',') if u.strip()]
     if not urls:
-        return pd.DataFrame({"Error": ["❌ Debes ingresar al menos una URL válida"]}), None
-    print("⏳ Processing URLs...")
+        print("❌ No hay URLs válidas")
+        return pd.DataFrame({"Error":["❌ Ingresa al menos una URL"]}), None
     tracks = process_tracks(urls)
     if not tracks:
-        return pd.DataFrame({"Error": ["❌ No se encontraron tracks"]}), None
-    print("📊 Creating dataframe...")
+        print("❌ No se encontraron tracks")
+        return pd.DataFrame({"Error":["❌ No se encontraron tracks"]}), None
     df = create_final_dataframe(tracks, include_all_info)
     with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
         df.to_excel(tmp.name, index=False)
         filename = f"{project_name or 'spotify_tracks'}.xlsx"
         shutil.move(tmp.name, filename)
-    print("✅ Process completed")
+    print(f"✅ Proceso completado. Archivo: {filename}\n")
     return df, filename
 
 # Configuración de la interfaz