Update app.py

app.py

@@ -23,17 +23,39 @@ def buscar_playlists_spotify(token, query, limit=50):
     if limit <= 50:
         params = {'q': query, 'type': 'playlist', 'limit': limit}
         response = requests.get(url, headers=headers, params=params)
-        playlists.extend(response.json().get('playlists', {}).get('items', []))
+        if response.status_code != 200:
+            print(f"Error en la solicitud a Spotify: {response.status_code}")
+            print(response.json())
+            return []
+        items = response.json().get('playlists', {}).get('items', [])
+        items = [item for item in items if item is not None]
+        playlists.extend(items)
     else:
         offset = 0
         while limit > 0:
             params = {'q': query, 'type': 'playlist', 'limit': min(50, limit), 'offset': offset}
             response = requests.get(url, headers=headers, params=params)
-            playlists.extend(response.json().get('playlists', {}).get('items', []))
-            limit -= min(50, limit)
-            offset += 50
-
-    return [{'playlist_id': playlist['id'], 'playlist_name': playlist['name']} for playlist in playlists]
+            if response.status_code != 200:
+                print(f"Error en la solicitud a Spotify: {response.status_code}")
+                print(response.json())
+                break
+            items = response.json().get('playlists', {}).get('items', [])
+            items = [item for item in items if item is not None]
+            playlists.extend(items)
+            fetched = len(items)
+            limit -= fetched
+            offset += fetched
+            if fetched == 0:
+                break
+
+    valid_playlists = []
+    for playlist in playlists:
+        if playlist is not None and 'id' in playlist and 'name' in playlist:
+            valid_playlists.append({
+                'playlist_id': playlist['id'],
+                'playlist_name': playlist['name']
+            })
+    return valid_playlists
 
 def obtener_canciones_playlist_spotify(token, playlist_id, playlist_name):
     print(f"Obteniendo canciones de la playlist {playlist_id} de Spotify...")
@@ -42,22 +64,25 @@ def obtener_canciones_playlist_spotify(token, playlist_id, playlist_name):
     response = requests.get(url, headers=headers)
     canciones = []
     if response.status_code == 200:
-        tracks = response.json().get('items')
+        tracks = response.json().get('items', [])
         for item in tracks:
             track = item.get('track')
             if track:
-                artista_info = obtener_info_artista(track['artists'][0]['id'], token) if track['artists'] else {}
+                artista_info = {}
+                if track['artists']:
+                    artista_info = obtener_info_artista(track['artists'][0]['id'], token)
+                record_label = obtener_record_label_spotify(track['album']['id'], token) if track.get('album') else 'No disponible'
                 canciones.append({
                     'playlist_name': playlist_name,
                     'artista': track['artists'][0]['name'] if track['artists'] else 'Desconocido',
                     'titulo': track['name'],
-                    'isrc': track['external_ids'].get('isrc', 'No disponible'),
+                    'isrc': track.get('external_ids', {}).get('isrc', 'No disponible'),
                     'popularity': track.get('popularity', 'No disponible'),
                     'track_id': track['id'],
-                    'link': track['external_urls']['spotify'],
-                    'record_label': obtener_record_label_spotify(track['album']['id'], token),
+                    'link': track.get('external_urls', {}).get('spotify', 'No disponible'),
+                    'record_label': record_label,
                     'source': 'Spotify',
-                    'genero_artista': ', '.join(artista_info.get('genres', []))
+                    'genero_artista': ', '.join(artista_info.get('genres', [])) if artista_info else 'No disponible'
                 })
     return canciones
 
@@ -67,49 +92,39 @@ def obtener_caracteristicas_audio(token, track_ids):
     headers = {'Authorization': f'Bearer {token}'}
     params = {'ids': ','.join(track_ids)}
     response = requests.get(url, headers=headers, params=params)
-    if response.status_code == 200:
-        return response.json().get('audio_features', [])
-    else:
-        print(f"No se pudieron obtener las características de audio para las pistas {track_ids}")
-        return []
+    return response.json().get('audio_features', []) if response.status_code == 200 else []
 
 def obtener_record_label_spotify(album_id, token):
     url = f'https://api.spotify.com/v1/albums/{album_id}'
     headers = {'Authorization': f'Bearer {token}'}
     response = requests.get(url, headers=headers)
-    album_info = response.json() if response.status_code == 200 else {}
-    return album_info.get('label', 'No disponible')
+    return response.json().get('label', 'No disponible') if response.status_code == 200 else 'No disponible'
 
 def obtener_info_artista(artista_id, token):
     url = f'https://api.spotify.com/v1/artists/{artista_id}'
     headers = {'Authorization': f'Bearer {token}'}
     response = requests.get(url, headers=headers)
-    artista_info = response.json() if response.status_code == 200 else {}
-    return {
-        'genres': artista_info.get('genres', [])
-    }
+    return response.json() if response.status_code == 200 else {}
 
-# Función principal de la interfaz
 def interface(query, num_spotify_playlists=50, project_name="Proyecto"):
-    # Obtener tokens y claves
     client_id = os.getenv('Spotify_ID')
     client_secret = os.getenv('Spotify_client')
 
-    # Spotify
     token_spotify = obtener_token(client_id, client_secret)
+    if not token_spotify:
+        raise gr.Error("Failed to obtain Spotify token. Check client ID and secret.")
+
     playlists_spotify = buscar_playlists_spotify(token_spotify, query, num_spotify_playlists)
     canciones_spotify = []
     track_ids = []
     for playlist in playlists_spotify:
         songs = obtener_canciones_playlist_spotify(token_spotify, playlist['playlist_id'], playlist['playlist_name'])
         canciones_spotify.extend(songs)
-        track_ids.extend([song['track_id'] for song in songs])
+        track_ids.extend([song['track_id'] for song in songs if song.get('track_id')])
 
-    # Obtener características de audio en un solo paso
     audio_features_list = obtener_caracteristicas_audio(token_spotify, track_ids)
     audio_features_dict = {af['id']: af for af in audio_features_list if af}
 
-    # Añadir características de audio a las canciones
     for song in canciones_spotify:
         audio_features = audio_features_dict.get(song['track_id'], {})
         song.update({
@@ -121,20 +136,16 @@ def interface(query, num_spotify_playlists=50, project_name="Proyecto"):
             'instrumentalness': audio_features.get('instrumentalness', 'No disponible')
         })
 
-    # Crear DataFrame
     df = pd.DataFrame(canciones_spotify)
     df.rename(columns={'isrc': 'ISRCs'}, inplace=True)
-
-    # Ordenar por popularidad
     df.sort_values(by=['popularity'], ascending=False, inplace=True)
 
     with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmpfile:
         df.to_excel(tmpfile.name, index=False)
         project_filename = f"{project_name}.xlsx"
         shutil.move(tmpfile.name, project_filename)
-        return df, project_filename  # Devuelve el DataFrame y el enlace al archivo Excel con el nombre del proyecto
+        return df, project_filename
 
-# Configuración de Gradio
 iface = gr.Interface(
     fn=interface,
     inputs=[
@@ -146,4 +157,4 @@ iface = gr.Interface(
     title="Busca Playlists con Keywords",
     description="Ingresa tu búsqueda para encontrar playlists en Spotify con esas palabras en sus títulos."
 )
-iface.launch()
+iface.launch()