Update app.py

app.py

@@ -1,243 +1,558 @@
-import os
-import threading
-import tkinter as tk
-from tkinter import simpledialog, messagebox, filedialog, ttk
-import pandas as pd
-from collections import defaultdict, deque
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
-from selenium.webdriver.chrome.service import Service
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from webdriver_manager.chrome import ChromeDriverManager
+import gradio as gr
 import requests
+import pandas as pd
+from tempfile import NamedTemporaryFile
+from openpyxl import Workbook
+import shutil
+
+# Lista de credenciales de API de Spotify
+client_ids = ['b4a2add66ffb4f1198b94b087b365c65', '9df51caba5d247dc921b21de35a47c44']
+client_secrets = ['8045eacf956a477299d2bc41752f1f73', '0e39502ec7e74fe99bb74245678d5f0d']
+current_api_index = 0
+
+# Funciones para Spotify
+def obtener_token(client_id, client_secret):
+    print(f"Obteniendo token de Spotify con client_id {client_id}...")
+    url = 'https://accounts.spotify.com/api/token'
+    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+    payload = {'grant_type': 'client_credentials'}
+    response = requests.post(url, headers=headers, data=payload, auth=(client_id, client_secret))
+    return response.json().get('access_token')
+
+def cambiar_api_key():
+    global current_api_index
+    current_api_index = (current_api_index + 1) % len(client_ids)
+    return obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
 
-api_key_lastfm = '463d87b43ca23d29f3a8d182d3f9763e'
-GENIUS_API_KEY = "4RpTijlKsKPeObCICn_ZK2eCYucI_pxiHyFOM-NxBIv1a3wF0jZg9MUGeRgU5i8T"
+def buscar_playlists_spotify(token, query, limit=50):
+    print("Buscando playlists en Spotify...")
+    url = 'https://api.spotify.com/v1/search'
+    headers = {'Authorization': f'Bearer {token}'}
+    playlists = []
 
-def iniciar_sesion(driver, usuario, contrasena, progress, root):
     try:
-        driver.get("https://producer.x5music.com/")
-        username = WebDriverWait(driver, 10).until(
-            EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div/div/div[1]/form/div/input[1]")))
-        username.send_keys(usuario)
-        password = WebDriverWait(driver, 10).until(
-            EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div/div/div[1]/form/div/input[2]")))
-        password.send_keys(contrasena)
-        password.send_keys(Keys.RETURN)
-        progress.set(20)
-        root.update_idletasks()
+        if limit <= 50:
+            params = {'q': query, 'type': 'playlist', 'limit': limit}
+            response = requests.get(url, headers=headers, params=params)
+            if response.status_code == 429:  # Límite alcanzado
+                token = cambiar_api_key()
+                response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+            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 = requests.get(url, headers=headers, params=params)
+                if response.status_code == 429:  # Límite alcanzado
+                    token = cambiar_api_key()
+                    response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+                playlists.extend(response.json().get('playlists', {}).get('items', []))
+                limit -= min(50, limit)
+                offset += 50
     except Exception as e:
-        messagebox.showerror("Error", f"Error al iniciar sesión: {str(e)}")
-        root.destroy()
-
-def obtener_generos_lastfm(isrc):
-    url = f"http://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key={api_key_lastfm}&format=json&mbid={isrc}"
-    response = requests.get(url)
-    data = response.json()
-    if 'track' in data and 'toptags' in data['track']:
-        genres = [tag['name'] for tag in data['track']['toptags']['tag']]
-        return ', '.join(genres)
-    return 'Unknown'
-
-def obtener_letras_genius(artist, title):
-    base_url = "https://api.genius.com"
-    headers = {'Authorization': f'Bearer {GENIUS_API_KEY}'}
-    search_url = f"{base_url}/search"
-    data = {'q': f"{artist} {title}"}
-    response = requests.get(search_url, data=data, headers=headers)
-    if response.status_code == 200:
-        json_data = response.json()
-        song_info = None
-        for hit in json_data['response']['hits']:
-            if artist.lower() in hit['result']['primary_artist']['name'].lower():
-                song_info = hit
-                break
-        if song_info:
-            song_api_path = song_info['result']['api_path']
-            song_url = f"{base_url}{song_api_path}"
-            song_response = requests.get(song_url, headers=headers)
-            song_json = song_response.json()
-            if 'lyrics' in song_json['response']['song']:
-                return song_json['response']['song']['lyrics']['plain']
-    return 'Lyrics not found'
-
-def procesar_isrc(driver, file_path, output_folder, progress, root):
+        print(f"Error al buscar playlists: {e}")
+    
+    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:
-        workbook = pd.read_excel(file_path, engine='openpyxl')
-        isrc_list = workbook['ISRCs'].dropna().tolist()
-        
-        # Dividir la lista de ISRCs en grupos de 1000
-        isrc_groups = [isrc_list[i:i + 1000] for i in range(0, len(isrc_list), 1000)]
-        all_data = []
-
-        for index, group in enumerate(isrc_groups):
-            isrc_string = ','.join(group)
-            print(f"Enviando grupo {index+1} de {len(group)} ISRCs.")
-            
-            isrc_input = WebDriverWait(driver, 10).until(
-                EC.presence_of_element_located((By.XPATH, "//*[@id='isrcs']")))
-            isrc_input.clear()
-            isrc_input.send_keys(isrc_string)
-            isrc_input.send_keys(Keys.RETURN)
-            
-            # Esperar que la tabla se actualice
-            WebDriverWait(driver, 30).until(
-                EC.presence_of_element_located((By.XPATH, "/html/body/div[3]/div[2]/div/ul/li/div[2]/div/div[2]/div[3]/div[1]/table/tbody")))
-            
-            tbody = driver.find_element(By.XPATH, "/html/body/div[3]/div[2]/div/ul/li/div[2]/div/div[2]/div[3]/div[1]/table/tbody")
-            rows = tbody.find_elements(By.XPATH, ".//tr")
-            group_data = [[cell.get_attribute('textContent') for cell in row.find_elements(By.XPATH, ".//td")] for row in rows]
-            
-            all_data.extend(group_data)
-            progress.set(10 + 90 * (index + 1) // len(isrc_groups))
-            root.update_idletasks()
-
-        df = pd.DataFrame(all_data)
-        if len(df.columns) >= 3:
-            df.columns = ['Column1', 'Title', 'Artist'] + df.columns[3:].tolist()
-        print(df.columns)  # Para verificar
-
-        # Eliminar duplicados
-        df.drop_duplicates(subset=['Title', 'Artist'], keep='first', inplace=True)
-
-        # Filtrar canciones que no tengan "Global" en la columna H (índice 7)
-        if len(df.columns) > 7:
-            print(f"Filtrando canciones no 'Global', total antes del filtro: {len(df)}")
-            df = df[df.iloc[:, 7].str.strip() == 'Global']
-            print(f"Total de canciones después del filtro: {len(df)}")
+        response = requests.get(url, headers=headers)
+        if response.status_code == 429:  # Límite alcanzado
+            token = cambiar_api_key()
+            response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+        if 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'])
+                    audio_analysis = obtener_analisis_audio(token, track['id'])
+                    key = obtener_clave(audio_analysis)
+                    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',
+                        'loudness': audio_analysis.get('track', {}).get('loudness', 'No disponible'),
+                        'timbre': audio_analysis.get('segments', [{}])[0].get('timbre', 'No disponible'),
+                        'acousticness': audio_features.get('acousticness', 'No disponible'),
+                        'liveness': audio_features.get('liveness', 'No disponible'),
+                        'key': key,
+                        'link': track['external_urls']['spotify'],
+                        'record_label': obtener_record_label_spotify(track['album']['id'], token),
+                        'source': 'Spotify'
+                    })
+    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 = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_analisis_audio(token, track_id):
+    url = f'https://api.spotify.com/v1/audio-analysis/{track_id}'
+    headers = {'Authorization': f'Bearer {token}'}
+    response = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_clave(audio_analysis):
+    key_map = {
+        -1: 'No Key',
+        0: 'C',
+        1: 'C#/Db',
+        2: 'D',
+        3: 'D#/Eb',
+        4: 'E',
+        5: 'F',
+        6: 'F#/Gb',
+        7: 'G',
+        8: 'G#/Ab',
+        9: 'A',
+        10: 'A#/Bb',
+        11: 'B'
+    }
+    key = audio_analysis.get('track', {}).get('key', -1)
+    return key_map.get(key, 'Unknown')
+
+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)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    album_info = response.json() if response.status_code == 200 else {}
+    return album_info.get('label', 'No disponible')
+
+# Función principal de la interfaz
+def interface(project_name, query, num_spotify_playlists=50):
+    # Obtener tokens y claves
+    token_spotify = obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
+    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
+    tmpfile = NamedTemporaryFile(delete=False, suffix='.xlsx')
+    df.to_excel(tmpfile.name, index=False)
+
+    # Renombrar el archivo con el nombre del proyecto
+    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
+import gradio as gr
+import requests
+import pandas as pd
+from tempfile import NamedTemporaryFile
+from openpyxl import Workbook
+import shutil
+
+# Lista de credenciales de API de Spotify
+client_ids = ['b4a2add66ffb4f1198b94b087b365c65', '9df51caba5d247dc921b21de35a47c44']
+client_secrets = ['8045eacf956a477299d2bc41752f1f73', '0e39502ec7e74fe99bb74245678d5f0d']
+current_api_index = 0
+
+# Funciones para Spotify
+def obtener_token(client_id, client_secret):
+    print(f"Obteniendo token de Spotify con client_id {client_id}...")
+    url = 'https://accounts.spotify.com/api/token'
+    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+    payload = {'grant_type': 'client_credentials'}
+    response = requests.post(url, headers=headers, data=payload, auth=(client_id, client_secret))
+    return response.json().get('access_token')
+
+def cambiar_api_key():
+    global current_api_index
+    current_api_index = (current_api_index + 1) % len(client_ids)
+    return obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
+
+def buscar_playlists_spotify(token, query, limit=50):
+    print("Buscando playlists en Spotify...")
+    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 = requests.get(url, headers=headers, params=params)
+            if response.status_code == 429:  # Límite alcanzado
+                token = cambiar_api_key()
+                response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+            playlists.extend(response.json().get('playlists', {}).get('items', []))
         else:
-            print("La columna en la posición 7 no está presente en los datos.")
-        
-        # Obtener la información de la base original
-        df_base = pd.read_excel(file_path, engine='openpyxl')
-        df_final = df_base[df_base['ISRCs'].isin(df['ISRCs'])]
-        
-        # Añadir columnas de género y letras
-        df_final['Genres'] = df_final['ISRCs'].apply(obtener_generos_lastfm)
-        df_final['Lyrics'] = df_final.apply(lambda row: obtener_letras_genius(row['Artist'], row['Title']), axis=1)
-
-        guardar_datos_en_excel(df_final, output_folder, os.path.basename(file_path))
-        num_songs = len(df_final)
-        messagebox.showinfo("Información", f"Se encontraron {num_songs} canciones únicas en total.")
-        return df_final
+            offset = 0
+            while limit > 0:
+                params = {'q': query, 'type': 'playlist', 'limit': min(50, limit), 'offset': offset}
+                response = requests.get(url, headers=headers, params=params)
+                if response.status_code == 429:  # Límite alcanzado
+                    token = cambiar_api_key()
+                    response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+                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}")
+    
+    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 = requests.get(url, headers=headers)
+        if response.status_code == 429:  # Límite alcanzado
+            token = cambiar_api_key()
+            response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+        if 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'])
+                    audio_analysis = obtener_analisis_audio(token, track['id'])
+                    key = obtener_clave(audio_analysis)
+                    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',
+                        'loudness': audio_analysis.get('track', {}).get('loudness', 'No disponible'),
+                        'timbre': audio_analysis.get('segments', [{}])[0].get('timbre', 'No disponible'),
+                        'acousticness': audio_features.get('acousticness', 'No disponible'),
+                        'liveness': audio_features.get('liveness', 'No disponible'),
+                        'key': key,
+                        'link': track['external_urls']['spotify'],
+                        'record_label': obtener_record_label_spotify(track['album']['id'], token),
+                        'source': 'Spotify'
+                    })
     except Exception as e:
-        messagebox.showerror("Error", f"Error al procesar ISRCs: {str(e)}")
-        root.destroy()
-        return None
-
-def guardar_datos_en_excel(df, output_folder, file_name):
-    output_file_path = os.path.join(output_folder, f"resultados-{file_name}")
-    df.to_excel(output_file_path, index=False)
-    messagebox.showinfo("Información", f"Datos extraídos y guardados en '{output_file_path}'.")
-
-def verificar_canciones_suficientes(df, num_playlists, min_songs):
-    total_unique_songs = len(df)
-    required_songs = num_playlists * min_songs
-    if total_unique_songs < required_songs:
-        return False, total_unique_songs, required_songs
-    return True, total_unique_songs, required_songs
-
-def create_playlists(data, output_folder, num_playlists, min_songs):
-    max_artist_songs = 3
+        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 = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_analisis_audio(token, track_id):
+    url = f'https://api.spotify.com/v1/audio-analysis/{track_id}'
+    headers = {'Authorization': f'Bearer {token}'}
+    response = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_clave(audio_analysis):
+    key_map = {
+        -1: 'No Key',
+        0: 'C',
+        1: 'C#/Db',
+        2: 'D',
+        3: 'D#/Eb',
+        4: 'E',
+        5: 'F',
+        6: 'F#/Gb',
+        7: 'G',
+        8: 'G#/Ab',
+        9: 'A',
+        10: 'A#/Bb',
+        11: 'B'
+    }
+    key = audio_analysis.get('track', {}).get('key', -1)
+    return key_map.get(key, 'Unknown')
+
+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)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    album_info = response.json() if response.status_code == 200 else {}
+    return album_info.get('label', 'No disponible')
+
+# Función principal de la interfaz
+def interface(project_name, query, num_spotify_playlists=50):
+    # Obtener tokens y claves
+    token_spotify = obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
+    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
+    tmpfile = NamedTemporaryFile(delete=False, suffix='.xlsx')
+    df.to_excel(tmpfile.name, index=False)
+
+    # Renombrar el archivo con el nombre del proyecto
+    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
+import gradio as gr
+import requests
+import pandas as pd
+from tempfile import NamedTemporaryFile
+from openpyxl import Workbook
+import shutil
+
+# Lista de credenciales de API de Spotify
+client_ids = ['b4a2add66ffb4f1198b94b087b365c65', '9df51caba5d247dc921b21de35a47c44']
+client_secrets = ['8045eacf956a477299d2bc41752f1f73', '0e39502ec7e74fe99bb74245678d5f0d']
+current_api_index = 0
+
+# Funciones para Spotify
+def obtener_token(client_id, client_secret):
+    print(f"Obteniendo token de Spotify con client_id {client_id}...")
+    url = 'https://accounts.spotify.com/api/token'
+    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+    payload = {'grant_type': 'client_credentials'}
+    response = requests.post(url, headers=headers, data=payload, auth=(client_id, client_secret))
+    return response.json().get('access_token')
+
+def cambiar_api_key():
+    global current_api_index
+    current_api_index = (current_api_index + 1) % len(client_ids)
+    return obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
+
+def buscar_playlists_spotify(token, query, limit=50):
+    print("Buscando playlists en Spotify...")
+    url = 'https://api.spotify.com/v1/search'
+    headers = {'Authorization': f'Bearer {token}'}
     playlists = []
-    all_songs = data.sample(frac=1).reset_index(drop=True)
-    used_songs = set()
-    
-    for _ in range(num_playlists):
-        playlist = []
-        artist_count = defaultdict(int)
-        last_artist = None
-        artist_queue = deque()  # Para asegurar que el mismo artista no aparezca con menos de 4 filas de diferencia
-        available_songs = all_songs[~all_songs.index.isin(used_songs)]
-        
-        for index, row in available_songs.iterrows():
-            artist = row['Artist']
-            if artist_count[artist] < max_artist_songs and (artist_queue.count(artist) == 0):
-                playlist.append(index)
-                artist_count[artist] += 1
-                if len(artist_queue) == 4:
-                    artist_queue.popleft()  # Mantener el tamaño del queue a 4
-                artist_queue.append(artist)
-                if len(playlist) == min_songs:
-                    break
-        
-        used_songs.update(playlist)
-        playlists.append(all_songs.loc[playlist])
-        
-        if len(available_songs) < min_songs:
-            used_songs.clear()  # Resetear los used_songs si no hay suficientes canciones disponibles para una nueva playlist
-        
-    output_filepath = os.path.join(output_folder, "Playlists_final.xlsx")
-    with pd.ExcelWriter(output_filepath) as writer:
-        for i, pl in enumerate(playlists, 1):
-            pl.to_excel(writer, sheet_name=f'Playlist {i}', index=False)
+
+    try:
+        if limit <= 50:
+            params = {'q': query, 'type': 'playlist', 'limit': limit}
+            response = requests.get(url, headers=headers, params=params)
+            if response.status_code == 429:  # Límite alcanzado
+                token = cambiar_api_key()
+                response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+            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 = requests.get(url, headers=headers, params=params)
+                if response.status_code == 429:  # Límite alcanzado
+                    token = cambiar_api_key()
+                    response = requests.get(url, headers={'Authorization': f'Bearer {token}'}, params=params)
+                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}")
     
-    print("Playlists created and saved successfully.")
-
-def run_app():
-    root = tk.Tk()
-    root.withdraw()
-
-    progress = tk.DoubleVar()
-    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
-    progress_bar.pack(fill=tk.X, expand=True)
-    root.deiconify()
-
-    usuario = simpledialog.askstring("Iniciar Sesión", "Usuario:", parent=root)
-    contrasena = simpledialog.askstring("Iniciar Sesión", "Contraseña:", parent=root, show='*')
-    if not usuario or not contrasena:
-        messagebox.showerror("Error", "Usuario o contraseña no proporcionados.")
-        root.destroy()
-        return
-
-    file_path = filedialog.askopenfilename(title="Selecciona el archivo Excel con ISRCs", filetypes=[("Excel files", "*.xlsx *.xls")])
-    if not file_path:
-        messagebox.showerror("Error", "No se seleccionó ningún archivo.")
-        root.destroy()
-        return
-
-    output_folder = filedialog.askdirectory(title="Selecciona la carpeta de salida para los datos de Excel")
-    if not output_folder:
-        messagebox.showerror("Error", "No se seleccionó ninguna carpeta de salida.")
-        root.destroy()
-        return
-
-    service = Service(ChromeDriverManager().install())
-    driver = webdriver.Chrome(service=service)
+    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:
-        iniciar_sesion(driver, usuario, contrasena, progress, root)
-        all_data = procesar_isrc(driver, file_path, output_folder, progress, root)
-        if not all_data.empty:
-            num_playlists = simpledialog.askinteger("Número de Playlists", "Introduce el número de playlists:", parent=root)
-            min_songs = simpledialog.askinteger("Mínimo de Canciones", "Introduce el mínimo de canciones por playlist:", parent=root)
-            
-            suficientes_canciones, total_canciones, requeridas_canciones = verificar_canciones_suficientes(all_data, num_playlists, min_songs)
-            
-            if not suficientes_canciones:
-                respuesta = messagebox.askyesnocancel("Canciones Insuficientes", f"No hay suficientes canciones únicas para crear {num_playlists} playlists de {min_songs} canciones cada una.\n"
-                                                    f"Total de canciones únicas: {total_canciones}\n"
-                                                    f"Canciones requeridas: {requeridas_canciones}\n\n"
-                                                    "¿Deseas continuar con las playlists completas posibles y una incompleta (Sí)?\n"
-                                                    "¿Deseas continuar solo con las playlists completas posibles (No)?\n"
-                                                    "¿Deseas cancelar la operación (Cancelar)?")
-                
-                if respuesta is None:
-                    root.destroy()
-                    return
-                elif respuesta:
-                    num_playlists = total_canciones // min_songs
-                else:
-                    num_playlists = total_canciones // min_songs
-            
-            create_playlists(all_data, output_folder, num_playlists, min_songs)
-    finally:
-        driver.quit()
-
-    root.mainloop()
-
-if __name__ == "__main__":
-    run_app()
+        response = requests.get(url, headers=headers)
+        if response.status_code == 429:  # Límite alcanzado
+            token = cambiar_api_key()
+            response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+        if 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'])
+                    audio_analysis = obtener_analisis_audio(token, track['id'])
+                    key = obtener_clave(audio_analysis)
+                    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',
+                        'loudness': audio_analysis.get('track', {}).get('loudness', 'No disponible'),
+                        'timbre': audio_analysis.get('segments', [{}])[0].get('timbre', 'No disponible'),
+                        'acousticness': audio_features.get('acousticness', 'No disponible'),
+                        'liveness': audio_features.get('liveness', 'No disponible'),
+                        'key': key,
+                        'link': track['external_urls']['spotify'],
+                        'record_label': obtener_record_label_spotify(track['album']['id'], token),
+                        'source': 'Spotify'
+                    })
+    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 = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_analisis_audio(token, track_id):
+    url = f'https://api.spotify.com/v1/audio-analysis/{track_id}'
+    headers = {'Authorization': f'Bearer {token}'}
+    response = requests.get(url, headers=headers)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    return response.json() if response.status_code == 200 else {}
+
+def obtener_clave(audio_analysis):
+    key_map = {
+        -1: 'No Key',
+        0: 'C',
+        1: 'C#/Db',
+        2: 'D',
+        3: 'D#/Eb',
+        4: 'E',
+        5: 'F',
+        6: 'F#/Gb',
+        7: 'G',
+        8: 'G#/Ab',
+        9: 'A',
+        10: 'A#/Bb',
+        11: 'B'
+    }
+    key = audio_analysis.get('track', {}).get('key', -1)
+    return key_map.get(key, 'Unknown')
+
+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)
+    if response.status_code == 429:  # Límite alcanzado
+        token = cambiar_api_key()
+        response = requests.get(url, headers={'Authorization': f'Bearer {token}'})
+    album_info = response.json() if response.status_code == 200 else {}
+    return album_info.get('label', 'No disponible')
+
+# Función principal de la interfaz
+def interface(project_name, query, num_spotify_playlists=50):
+    # Obtener tokens y claves
+    token_spotify = obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
+    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
+    tmpfile = NamedTemporaryFile(delete=False, suffix='.xlsx')
+    df.to_excel(tmpfile.name, index=False)
+
+    # Renombrar el archivo con el nombre del proyecto
+    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="Enter a search query to fetch playlists and their songs from Spotify. Client credentials are pre-configured."
+)
+iface.launch()