Update app.py

app.py

@@ -4,54 +4,45 @@ import pandas as pd
 import time
 import shutil
 import numpy as np
+import os
 from tempfile import NamedTemporaryFile
 from openpyxl import Workbook
 
-# Lista de credenciales de API de Spotify
-client_ids = [
-    '9dfc90506fa04938b05d7913f8b13bad',
-    '0ef8df0b57864accb36251fb0b741935',
-    '066bb9a3e0ac40aba89732f9a97249bf',
-    'cfbe3754c86048d1a82542a5ab432b9a'
-]
-client_secrets = [
-    '62a96c883b564f1e8c9f3af935f9f88e',
-    '8a1bb6f0f8f14feb9be2dff4b603bb5f',
-    '9cdae5b56ec24aed91bb3958823ff39e',
-    'c55801afd5c24df3b8673cc07468c7b6'
-]
+# Spotify API credentials from environment variables
+client_ids = os.getenv("SPOTIFY_CLIENT_IDS").split(',')
+client_secrets = os.getenv("SPOTIFY_CLIENT_SECRETS").split(',')
 current_api_index = 0
 
-# Contadores de solicitudes
-solicitudes_totales = 0
+# Request counters
+total_requests = 0
 
-# Funciones para Spotify
-def obtener_token(client_id, client_secret):
+# Spotify Functions
+def get_token(client_id, client_secret):
     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))
-    global solicitudes_totales
-    solicitudes_totales += 1  # Contando solicitud
+    global total_requests
+    total_requests += 1  # Counting request
     if response.status_code == 200:
         return response.json().get('access_token')
     else:
         return None
 
-def manejar_rate_limit(response, intento):
+def handle_rate_limit(response, attempt):
     if response.status_code == 429:
         retry_after = int(response.headers.get('Retry-After', 1))
-        wait_time = retry_after + 10 * (2 ** intento)  # Retroceso exponencial
+        wait_time = retry_after + 10 * (2 ** attempt)  # Exponential backoff
         time.sleep(wait_time)
         return True
     return False
 
-def hacer_request_con_reintento(url, headers, params=None, max_retries=5):
-    global solicitudes_totales
-    for intento in range(max_retries):
+def make_request_with_retry(url, headers, params=None, max_retries=5):
+    global total_requests
+    for attempt in range(max_retries):
         response = requests.get(url, headers=headers, params=params)
-        solicitudes_totales += 1  # Contando solicitud
-        if manejar_rate_limit(response, intento):
+        total_requests += 1  # Counting request
+        if handle_rate_limit(response, attempt):
             continue
         if response.status_code == 200:
             return response
@@ -59,7 +50,7 @@ def hacer_request_con_reintento(url, headers, params=None, max_retries=5):
             break
     return None
 
-def obtener_caracteristicas_audio(token, track_ids):
+def get_audio_features(token, track_ids):
     audio_features = {}
     url = 'https://api.spotify.com/v1/audio-features'
     headers = {'Authorization': f'Bearer {token}'}
@@ -67,14 +58,14 @@ def obtener_caracteristicas_audio(token, track_ids):
     for i in range(0, len(track_ids), 100):
         batch_ids = track_ids[i:i+100]
         params = {'ids': ','.join(batch_ids)}
-        response = hacer_request_con_reintento(url, headers, params)
+        response = make_request_with_retry(url, headers, params)
         if response:
             for feature in response.json().get('audio_features', []):
                 if feature:
                     audio_features[feature['id']] = feature
     return audio_features
 
-def obtener_tracks_y_caracteristicas(token, url):
+def get_tracks_and_features(token, url):
     headers = {'Authorization': f'Bearer {token}'}
     if "track" in url:
         track_id = url.split("/")[-1].split("?")[0]
@@ -82,18 +73,18 @@ def obtener_tracks_y_caracteristicas(token, url):
     elif "playlist" in url:
         playlist_id = url.split("/")[-1].split("?")[0]
         tracks_url = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks'
-        response = hacer_request_con_reintento(tracks_url, headers)
+        response = make_request_with_retry(tracks_url, headers)
         if response:
             track_ids = [item['track']['id'] for item in response.json().get('items', []) if item['track']]
     else:
         return None, None
 
-    audio_features = obtener_caracteristicas_audio(token, track_ids)
+    audio_features = get_audio_features(token, track_ids)
     return track_ids, audio_features
 
-def buscar_canciones_similares(token, audio_features, n_songs=10):
+def find_similar_tracks(token, audio_features, n_songs=10):
     headers = {'Authorization': f'Bearer {token}'}
-    seed_tracks = list(audio_features.keys())[:5]  # Spotify solo permite hasta 5 canciones semilla
+    seed_tracks = list(audio_features.keys())[:5]  # Spotify allows up to 5 seed tracks
 
     params = {
         'seed_tracks': ','.join(seed_tracks),
@@ -101,76 +92,76 @@ def buscar_canciones_similares(token, audio_features, n_songs=10):
     }
 
     url = 'https://api.spotify.com/v1/recommendations'
-    response = hacer_request_con_reintento(url, headers, params=params)
+    response = make_request_with_retry(url, headers, params=params)
 
     if response:
         recommended_tracks = response.json().get('tracks', [])
         track_ids = [track['id'] for track in recommended_tracks]
-        return obtener_informacion_canciones(token, track_ids)
+        return get_track_information(token, track_ids)
     
     return []
 
-def obtener_informacion_canciones(token, track_ids):
+def get_track_information(token, track_ids):
     tracks_info = []
-    audio_features = obtener_caracteristicas_audio(token, track_ids)  # Obtener características de audio
+    audio_features = get_audio_features(token, track_ids)  # Get audio features
     url = 'https://api.spotify.com/v1/tracks'
     headers = {'Authorization': f'Bearer {token}'}
 
     for i in range(0, len(track_ids), 50):
         batch_ids = track_ids[i:i+50]
         params = {'ids': ','.join(batch_ids)}
-        response = hacer_request_con_reintento(url, headers, params)
+        response = make_request_with_retry(url, headers, params)
         if response:
             tracks = response.json().get('tracks', [])
             for track in tracks:
                 features = audio_features.get(track['id'], {})
                 tracks_info.append({
-                    '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'),
-                    'release_year': track.get('album', {}).get('release_date', 'No disponible').split('-')[0] if track.get('album', {}).get('release_date') else 'No disponible',
-                    'duration': track.get('duration_ms', 'No disponible'),
-                    'danceability': features.get('danceability', 'No disponible'),
-                    'energy': features.get('energy', 'No disponible'),
-                    'tempo': features.get('tempo', 'No disponible'),
-                    'valence': features.get('valence', 'No disponible'),
+                    'artist': track['artists'][0]['name'] if track['artists'] else 'Unknown',
+                    'title': track['name'],
+                    'isrc': track['external_ids'].get('isrc', 'Not available'),
+                    'popularity': track.get('popularity', 'Not available'),
+                    'release_year': track.get('album', {}).get('release_date', 'Not available').split('-')[0] if track.get('album', {}).get('release_date') else 'Not available',
+                    'duration': track.get('duration_ms', 'Not available'),
+                    'danceability': features.get('danceability', 'Not available'),
+                    'energy': features.get('energy', 'Not available'),
+                    'tempo': features.get('tempo', 'Not available'),
+                    'valence': features.get('valence', 'Not available'),
                     'url': track['external_urls']['spotify']
                 })
     return tracks_info
 
-# Función principal de la interfaz
+# Main Interface Function
 def interface(project_name, spotify_url, num_similar_songs=10):
-    token_spotify = obtener_token(client_ids[current_api_index], client_secrets[current_api_index])
-    track_ids, audio_features = obtener_tracks_y_caracteristicas(token_spotify, spotify_url)
+    token_spotify = get_token(client_ids[current_api_index], client_secrets[current_api_index])
+    track_ids, audio_features = get_tracks_and_features(token_spotify, spotify_url)
     if not track_ids or not audio_features:
-        return "URL no válida o no se encontraron canciones.", None
+        return "Invalid URL or no songs found.", None
 
-    similar_tracks_info = buscar_canciones_similares(token_spotify, audio_features, num_similar_songs)
+    similar_tracks_info = find_similar_tracks(token_spotify, audio_features, num_similar_songs)
     
-    # Crear DataFrame
+    # Create DataFrame
     df = pd.DataFrame(similar_tracks_info)
 
-    # Guardar DataFrame en un archivo Excel
+    # Save DataFrame to an Excel file
     tmpfile = NamedTemporaryFile(delete=False, suffix='.xlsx')
     df.to_excel(tmpfile.name, index=False)
 
-    # Renombrar el archivo con el nombre del proyecto
+    # Rename the file with the project name
     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
+    return df, project_file_name  # Returns the DataFrame and the link to the Excel file
 
-# Configuración de Gradio
+# Gradio Interface Configuration
 iface = gr.Interface(
     fn=interface,
     inputs=[
-        gr.Textbox(label="Nombre del Proyecto"),
-        gr.Textbox(label="Spotify URL (Track o Playlist)"),
-        gr.Number(label="Número de Canciones Similares", value=10, minimum=1, maximum=100)
+        gr.Textbox(label="Project Name"),
+        gr.Textbox(label="Spotify URL (Track or Playlist)"),
+        gr.Number(label="Number of Similar Songs", value=10, minimum=1, maximum=100)
     ],
     outputs=[gr.Dataframe(), gr.File(label="Download Excel")],
     title="Spotify Similar Track Finder",
-    description="Ingresa una URL de Spotify para encontrar canciones similares basadas en sus características."
+    description="Enter a Spotify URL to find similar songs based on their features."
 )
 iface.launch()