Update app.py

app.py

@@ -1,190 +1,243 @@
-import gradio as gr
-import requests
+import os
+import threading
+import tkinter as tk
+from tkinter import simpledialog, messagebox, filedialog, ttk
 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 = []
+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 requests
 
+api_key_lastfm = '463d87b43ca23d29f3a8d182d3f9763e'
+GENIUS_API_KEY = "4RpTijlKsKPeObCICn_ZK2eCYucI_pxiHyFOM-NxBIv1a3wF0jZg9MUGeRgU5i8T"
+
+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()
+    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):
     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', []))
+        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)}")
         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
+            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
+
     except Exception as e:
-        print(f"Error al buscar playlists: {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
+    playlists = []
+    all_songs = data.sample(frac=1).reset_index(drop=True)
+    used_songs = set()
     
-    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 = []
+    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)
+    
+    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)
 
     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:
-        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()
+        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()