Update app.py

app.py

@@ -1,15 +1,11 @@
-import gradio as gr
+
 import requests
-import pandas as pd
 import time
-from tempfile import NamedTemporaryFile
-from openpyxl import Workbook
-import shutil
 from collections import deque
 from datetime import datetime, timedelta
 
 # Lista de credenciales de API de Spotify
-client_ids = [
+client_ids =[
     '37492f29c7fe478391e8fd8fe66f3f1b',
     'ac3c1dd6252740e68aeb0d7dd4e6e37d',
     '807008cb2ce041178c1871973fc81716',
@@ -19,7 +15,7 @@ client_ids = [
     '9df51caba5d247dc921b21de35a47c44',
     '191227c66e0d4be692bc8ee73ea6eb3d',
     'e272c0705c7c4fd68937c58adaa446ed'
-]
+ ]   
 client_secrets = [
     'b61fa17afff64c8693ea5147b79562be',
     'ff49073ebd324e8cac2d997a8e34644c',
@@ -31,9 +27,12 @@ client_secrets = [
     '2d2a895d85874c088897dd9894dc64ad',
     '9fdfa58ea0a94ce7a0cb34fa19fb7d74'
 ]
+
 current_api_index = 0
 session = requests.Session()
-requests_queue = deque(maxlen=100)
+
+# Registro de peticiones en los últimos 60 minutos
+request_log = deque()
 
 def obtener_token(client_id, client_secret):
     print(f"Obteniendo token de Spotify con client_id: {client_id}")
@@ -69,143 +68,50 @@ def obtener_nuevo_token():
     print(f"Nuevo token obtenido: {token}")
     return token
 
-def manejar_limite_peticiones():
-    now = datetime.now()
-    while requests_queue and now - requests_queue[0] > timedelta(minutes=1):
-        requests_queue.popleft()
-    if len(requests_queue) >= 100:
-        print("Límite de 100 peticiones por minuto alcanzado, esperando...")
-        time.sleep(60 - (now - requests_queue[0]).seconds)
-    requests_queue.append(now)
-
-def realizar_solicitud(url, headers, params, reintentos=5):
-    manejar_limite_peticiones()
-    espera = 1  # Inicializar tiempo de espera en 1 segundo
-    for i in range(reintentos):
-        response = session.get(url, headers=headers, params=params)
+def registrar_peticion():
+    ahora = datetime.now()
+    request_log.append(ahora)
+    # Remover peticiones que tienen más de 60 minutos
+    while request_log and (ahora - request_log[0]) > timedelta(minutes=60):
+        request_log.popleft()
+
+def realizar_solicitud(url, params, token):
+    headers = {'Authorization': f'Bearer {token}'}
+    response = session.get(url, headers=headers, params=params)
+    registrar_peticion()
+    return response
+
+def realizar_solicitud_con_reintento(url, params):
+    token = obtener_nuevo_token()
+    espera = 1
+
+    while True:
+        response = realizar_solicitud(url, params, token)
+        print(f"Solicitud realizada. Código de estado: {response.status_code}")
+
         if response.status_code == 429:
-            print(f"Límite de peticiones alcanzado, esperando {espera} segundos antes de reintentar...")
-            time.sleep(espera)
-            espera *= 2  # Incrementar espera de manera exponencial
-            cerrar_y_reiniciar_sesion()
-            headers['Authorization'] = f'Bearer {obtener_nuevo_token()}'
+            retry_after = int(response.headers.get('Retry-After', espera))
+            espera *= 2  # Incremento exponencial
+            print(f"Límite de peticiones alcanzado, esperando {retry_after} segundos antes de reintentar...")
+            time.sleep(retry_after)
+            token = obtener_nuevo_token()  # Obtener un nuevo token después de esperar
         else:
             return response
-    print("Límite de reintentos alcanzado.")
-    return None
 
-def buscar_playlists_spotify(token, query, limit=50):
-    print("Buscando playlists en Spotify...")
+# Ejemplo de uso
+def main():
     url = 'https://api.spotify.com/v1/search'
-    headers = {'Authorization': f'Bearer {token}'}
-    playlists = []
-
-    try:
-        if limit <= 50:
-            params = {'q': query, 'type': 'playlist', 'limit': limit}
-            response = realizar_solicitud(url, headers, params)
-            if response:
-                playlists.extend(response.json().get('playlists', {}).get('items', []))
-        else:
-            offset = 0
-            while limit > 0:
-                params = {'q': query, 'type': 'playlist', 'limit': min(50, limit), 'offset': offset}
-                response = realizar_solicitud(url, headers, params)
-                if response:
-                    playlists.extend(response.json().get('playlists', {}).get('items', []))
-                    limit -= min(50, limit)
-                    offset += 50
-    except Exception as e:
-        print(f"Error al buscar playlists: {e}")
+    params = {'q': 'rancheras', 'type': 'playlist', 'limit': 40}
     
-    return [{'playlist_id': playlist['id'], 'playlist_name': playlist['name']} for playlist in playlists]
-
-def obtener_canciones_playlist_spotify(token, playlist_id, playlist_name):
-    print(f"Obteniendo canciones de la playlist {playlist_id} ({playlist_name}) de Spotify...")
-    url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
-    headers = {'Authorization': f'Bearer {token}'}
-    canciones = []
-
-    try:
-        response = realizar_solicitud(url, headers, {})
-        if response and response.status_code == 200:
-            tracks = response.json().get('items')
-            for item in tracks:
-                track = item.get('track')
-                if track:
-                    audio_features = obtener_caracteristicas_audio(token, track['id'])
-                    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'),
-                        'popularity': track.get('popularity', 'No disponible'),
-                        'valence': audio_features.get('valence', 'No disponible'),
-                        'danceability': audio_features.get('danceability', 'No disponible'),
-                        'energy': audio_features.get('energy', 'No disponible'),
-                        'tempo': audio_features.get('tempo', 'No disponible'),
-                        'speechiness': audio_features.get('speechiness', 'No disponible'),
-                        'instrumentalness': audio_features.get('instrumentalness', 'No disponible'),
-                        'duration': track.get('duration_ms', 'No disponible'),
-                        'release_year': track.get('album', {}).get('release_date', 'No disponible').split('-')[0] if track.get('album', {}).get('release_date') else 'No disponible',
-                        'record_label': obtener_record_label_spotify(track['album']['id'], token)
-                    })
-    except Exception as e:
-        print(f"Error al obtener canciones de la playlist: {e}")
-
-    return canciones
-
-def obtener_caracteristicas_audio(token, track_id):
-    url = f'https://api.spotify.com/v1/audio-features/{track_id}'
-    headers = {'Authorization': f'Bearer {token}'}
-    response = realizar_solicitud(url, headers, {})
-    return response.json() if response and 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 = realizar_solicitud(url, headers, {})
-    album_info = response.json() if response and response.status_code == 200 else {}
-    return album_info.get('label', 'No disponible')
-
-def interface(project_name, query, num_spotify_playlists=50):
-    # Obtener tokens y claves
-    token_spotify = obtener_nuevo_token()
-    if not token_spotify:
-        return pd.DataFrame(), "Error obteniendo el token de Spotify. Intenta de nuevo."
-
-    playlists_spotify = buscar_playlists_spotify(token_spotify, query, num_spotify_playlists)
-    canciones_spotify = []
-    for playlist in playlists_spotify:
-        songs = obtener_canciones_playlist_spotify(token_spotify, playlist['playlist_id'], playlist['playlist_name'])
-        canciones_spotify.extend(songs)
-
-    # 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)
-
-    # Guardar DataFrame en un archivo Excel
-    with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmpfile:
-        df.to_excel(tmpfile.name, index=False)
-        project_file_name = f"{project_name}.xlsx"
-        shutil.move(tmpfile.name, project_file_name)
-
-    return df, project_file_name  # Devuelve el DataFrame y el enlace al archivo Excel
-
-# Configuración de Gradio
-iface = gr.Interface(
-    fn=interface,
-    inputs=[
-        gr.Textbox(label="Nombre del Proyecto"),
-        gr.Textbox(label="Keywords - Palabras Clave para tu búsqueda"),
-        gr.Number(label="Numero de Playlists que vamos a buscar con estas Keywords", value=50, minimum=1, maximum=1000)
-    ],
-    outputs=[gr.Dataframe(), gr.File(label="Download Excel")],
-    title="Spotify Playlist Fetcher",
-    description="Introduce una consulta de búsqueda para obtener playlists y sus canciones de Spotify. Las credenciales del cliente están preconfiguradas."
-)
-
-iface.launch()
+    print("Realizando primera solicitud...")
+    response = realizar_solicitud_con_reintento(url, params)
+    print("Respuesta de la primera solicitud:", response.json())
+
+    # Simular cambio de API key después de recibir un código 429
+    if response.status_code == 429:
+        print("Límite de peticiones alcanzado, cambiando API key y realizando una nueva solicitud...")
+        response = realizar_solicitud_con_reintento(url, params)
+        print("Respuesta de la segunda solicitud:", response.json())
+
+if __name__ == "__main__":
+    main()