Update app.py

app.py

@@ -6,123 +6,262 @@ import shutil
 import os
 from tempfile import NamedTemporaryFile
 
-# Spotify API credentials from environment variables
+# Configuración de Credenciales
 client_ids = os.getenv("SPOTIFY_CLIENT_IDS", "").split(',')
 client_secrets = os.getenv("SPOTIFY_CLIENT_SECRETS", "").split(',')
 
 if not client_ids or not client_secrets:
-    raise ValueError("SPOTIFY_CLIENT_IDS or SPOTIFY_CLIENT_SECRETS environment variables not set.")
+    raise ValueError("Faltan variables de entorno SPOTIFY_CLIENT_IDS o SPOTIFY_CLIENT_SECRETS")
 
-# Token rotation management
-current_api_index = 0
+# Gestión de Rotación de Clientes
+current_client_index = 0
 request_counter = 0
-MAX_REQUESTS_PER_CLIENT = 100  # Rotar cliente después de X peticiones
+MAX_REQUESTS_PER_CLIENT = 95  # Rotar antes de llegar al límite de 100
 
 def rotate_client():
-    global current_api_index, request_counter
-    current_api_index = (current_api_index + 1) % len(client_ids)
+    global current_client_index, request_counter
+    current_client_index = (current_client_index + 1) % len(client_ids)
     request_counter = 0
-    print(f"Rotando a cliente Spotify #{current_api_index + 1}")
+    print(f"🔁 Rotando a cliente Spotify #{current_client_index + 1}")
 
-def get_token():
-    global current_api_index
+def get_spotify_token():
+    global current_client_index
     for _ in range(len(client_ids)):
-        client_id = client_ids[current_api_index]
-        client_secret = client_secrets[current_api_index]
-        url = 'https://accounts.spotify.com/api/token'
-        response = requests.post(url, 
+        client_id = client_ids[current_client_index]
+        client_secret = client_secrets[current_client_index]
+        
+        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))
+            auth=(client_id, client_secret)
         
         if response.status_code == 200:
             return response.json().get('access_token')
-        else:
-            print(f"Error con cliente {current_api_index}: {response.text}")
-            rotate_client()
+        
+        print(f"❌ Error con cliente {current_client_index}: {response.text}")
+        rotate_client()
     
-    raise Exception("Todos los clientes Spotify fallaron")
+    raise Exception("🚨 Todos los clientes fallaron al obtener token")
 
-def make_request_with_retry(url, headers, params=None):
+# Funciones Principales
+def make_spotify_request(url, params=None):
     global request_counter
-    for _ in range(3):  # 3 intentos por cliente
+    token = get_spotify_token()
+    headers = {'Authorization': f'Bearer {token}'}
+    
+    for _ in range(3):  # Reintentos máximos
         response = requests.get(url, headers=headers, params=params)
         request_counter += 1
         
         if response.status_code == 429:
-            print(f"Rate limit alcanzado. Cliente actual: {current_api_index}")
+            print(f"⚠️ Límite de tasa alcanzado. Cliente: {current_client_index}")
             rotate_client()
-            headers['Authorization'] = f'Bearer {get_token()}'
-            time.sleep(int(response.headers.get('Retry-After', 10)))
+            time.sleep(int(response.headers.get('Retry-After', 10))  # Espera mínima de 10 segundos
             continue
             
         if response.status_code == 200:
             if request_counter >= MAX_REQUESTS_PER_CLIENT:
                 rotate_client()
-                headers['Authorization'] = f'Bearer {get_token()}'  # Actualizar token
-            return response
-            
-        print(f"Error {response.status_code}: {response.text}")
+            return response.json()
+        
+        print(f"❌ Error {response.status_code}: {response.text}")
         time.sleep(2)
     
     return None
 
-# ... (keep your existing functions like get_playlist_tracks, get_album_tracks, etc.) ...
+def extract_spotify_id(url, type_keyword):
+    """Extrae ID de diferentes formatos de URLs de Spotify"""
+    if type_keyword in url:
+        parts = url.split(f"/{type_keyword}/")
+        if len(parts) > 1:
+            return parts[1].split("?")[0].split("/")[0]
+    
+    # Manejo de URLs complejas
+    parts = [p for p in url.split("/") if p]
+    for i, part in enumerate(parts):
+        if part == type_keyword and i < len(parts)-1:
+            return parts[i+1].split("?")[0]
+    
+    return url.split("/")[-1].split("?")[0]
 
-def interface(project_name, spotify_urls, include_all_info=True):
-    global current_api_index, request_counter
-    current_api_index = 0
-    request_counter = 0
+def get_playlist_tracks(playlist_url):
+    playlist_id = extract_spotify_id(playlist_url, "playlist")
+    print(f"🎧 Obteniendo playlist: {playlist_id}")
+    
+    all_tracks = []
+    url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
+    
+    while url:
+        data = make_spotify_request(url)
+        if not data:
+            break
+            
+        all_tracks.extend([item['track'] for item in data.get('items', []) if item.get('track')])
+        url = data.get('next')
+    
+    print(f"✅ Encontrados {len(all_tracks)} tracks")
+    return all_tracks
+
+def get_album_tracks(album_url):
+    album_id = extract_spotify_id(album_url, "album")
+    print(f"💿 Obteniendo álbum: {album_id}")
     
-    # Validación de URLs mejorada
-    urls_list = []
-    for url in spotify_urls.strip().split('\n'):
-        url = url.strip()
-        if not url: continue
+    # Obtener información básica del álbum
+    album_data = make_spotify_request(f'https://api.spotify.com/v1/albums/{album_id}')
+    if not album_data:
+        return []
+    
+    all_tracks = []
+    url = f'https://api.spotify.com/v1/albums/{album_id}/tracks'
+    
+    while url:
+        data = make_spotify_request(url)
+        if not data:
+            break
+            
+        # Obtener detalles completos de cada track
+        for item in data.get('items', []):
+            track_data = make_spotify_request(f"https://api.spotify.com/v1/tracks/{item['id']}")
+            if track_data:
+                track_data['album'] = {  # Añadir info del álbum
+                    'name': album_data.get('name'),
+                    'release_date': album_data.get('release_date'),
+                    'id': album_id
+                }
+                all_tracks.append(track_data)
         
-        # Extraer tipo correctamente
-        if "spotify.com" in url:
-            if "/playlist/" in url:
-                url_type = "playlist"
-            elif "/album/" in url:
-                url_type = "album"
-            elif "/track/" in url:
-                url_type = "track"
-            else:
-                print(f"URL no soportada: {url}")
-                continue
-            urls_list.append((url, url_type))
-    
-    if not urls_list:
-        return gr.Dataframe(value=pd.DataFrame({"Error": ["No valid URLs provided"]})), None
-    
-    token = get_token()
+        url = data.get('next')
+    
+    print(f"✅ Encontrados {len(all_tracks)} tracks")
+    return all_tracks
+
+def process_tracks(urls):
     all_tracks = []
     
-    for url, url_type in urls_list:
+    for url in urls:
         try:
-            if url_type == "playlist":
-                print(f"Procesando playlist: {url}")
-                tracks = get_playlist_tracks(token, url)
-                all_tracks.extend(tracks)
-                
-            elif url_type == "album":
-                print(f"Procesando álbum: {url}")
-                tracks = get_album_tracks(token, url)
-                all_tracks.extend(tracks)
-                
-            elif url_type == "track":
-                print(f"Procesando track: {url}")
-                track = get_track_info(token, url)
-                if track:
-                    all_tracks.extend(track)
-                    
+            if "playlist" in url:
+                all_tracks.extend(get_playlist_tracks(url))
+            elif "album" in url:
+                all_tracks.extend(get_album_tracks(url))
+            elif "track" in url:
+                track_id = extract_spotify_id(url, "track")
+                track_data = make_spotify_request(f"https://api.spotify.com/v1/tracks/{track_id}")
+                if track_data:
+                    all_tracks.append(track_data)
         except Exception as e:
-            print(f"Error procesando {url}: {str(e)}")
+            print(f"⚠️ Error procesando {url}: {str(e)}")
+    
+    return all_tracks
+
+# Procesamiento de Datos
+def create_final_dataframe(tracks, include_all_info=True):
+    artist_cache = {}
+    
+    def get_artist_details(artist_id):
+        if artist_id not in artist_cache:
+            data = make_spotify_request(f"https://api.spotify.com/v1/artists/{artist_id}")
+            artist_cache[artist_id] = {
+                'genres': data.get('genres', []) if data else [],
+                'followers': data.get('followers', {}).get('total', 0) if data else 0,
+                'popularity': data.get('popularity', 0) if data else 0
+            }
+        return artist_cache[artist_id]
+    
+    processed = []
+    for track in tracks:
+        if not track:
             continue
+        
+        main_artist = track['artists'][0] if track.get('artists') else {}
+        artist_info = get_artist_details(main_artist.get('id')) if main_artist.get('id') else {}
+        
+        duration_min = f"{track['duration_ms']//60000}:{str(track['duration_ms']%60000//1000).zfill(2)}"
+        
+        track_data = {
+            'Artista': main_artist.get('name', 'Desconocido'),
+            'Título': track.get('name', 'Sin título'),
+            'Álbum': track.get('album', {}).get('name', 'Sin álbum'),
+            'ISRC': track.get('external_ids', {}).get('isrc', 'No disponible'),
+            'Popularidad': track.get('popularity', 0),
+            'Duración': duration_min,
+            'Fecha Lanzamiento': track.get('album', {}).get('release_date', 'No disponible'),
+            'Enlace Spotify': track.get('external_urls', {}).get('spotify', '')
+        }
+        
+        if include_all_info:
+            track_data.update({
+                'Géneros': ', '.join(artist_info.get('genres', [])),
+                'Seguidores Artista': artist_info.get('followers', 0),
+                'Popularidad Artista': artist_info.get('popularity', 0),
+                'Explicit': 'Sí' if track.get('explicit') else 'No',
+                'ID Track': track.get('id'),
+                'ID Álbum': track.get('album', {}).get('id')
+            })
+        
+        processed.append(track_data)
     
-    # ... (resto del procesamiento igual) ...
+    df = pd.DataFrame(processed)
+    
+    # Eliminar duplicados usando ISRC o combinación artista-título
+    df['dup_key'] = df.apply(
+        lambda x: x['ISRC'] if x['ISRC'] != 'No disponible' else f"{x['Artista']}|{x['Título']}", 
+        axis=1
+    )
+    df = df.drop_duplicates('dup_key').drop(columns='dup_key')
+    
+    return df
+
+# Interfaz Gradio
+def main_interface(project_name, spotify_urls, include_all_info=True):
+    urls = [url.strip() for url in spotify_urls.strip().split('\n') if url.strip()]
+    
+    if not urls:
+        return pd.DataFrame({"Error": ["Ingresa al menos una URL válida"]}), None
+    
+    print("⏳ Procesando URLs...")
+    tracks = process_tracks(urls)
+    
+    if not tracks:
+        return pd.DataFrame({"Error": ["No se encontraron tracks"]}), None
+    
+    print("📊 Creando dataframe...")
+    df = create_final_dataframe(tracks, include_all_info)
+    
+    with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
+        df.to_excel(tmp.name, index=False)
+        final_filename = f"{project_name}.xlsx" if project_name else "spotify_tracks.xlsx"
+        shutil.move(tmp.name, final_filename)
+    
+    print("✅ Proceso completado")
+    return df, final_filename
+
+# Configuración de la UI
+iface = gr.Interface(
+    fn=main_interface,
+    inputs=[
+        gr.Textbox(label="Nombre del Proyecto", placeholder="Mi Colección Musical"),
+        gr.Textbox(
+            label="URLs de Spotify (1 por línea)",
+            placeholder="Pega aquí URLs de playlists, álbumes o canciones...",
+            lines=5
+        ),
+        gr.Checkbox(label="Incluir toda la información", value=True)
+    ],
+    outputs=[
+        gr.Dataframe(label="Resultados"),
+        gr.File(label="Descargar Excel")
+    ],
+    title="🟢 Spotify Track Collector PRO",
+    description="Extrae información detallada de múltiples URLs de Spotify (playlists, álbumes, canciones) y genera un Excel unificado.",
+    examples=[
+        ["Mi Playlist", "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M", True],
+        ["Álbum Clásico", "https://open.spotify.com/album/1R5BORZZxNUg8QMgbqt0nd", False]
+    ],
+    allow_flagging="never",
+    theme=gr.themes.Soft()
+)
 
-# Mantén la interfaz de Gradio igual
-iface = gr.Interface(...) 
-iface.launch()
+if __name__ == "__main__":
+    iface.launch(server_name="0.0.0.0", server_port=7860)