Update app.py

app.py

@@ -1,3 +1,16 @@
+# —————— PARCHE GRADIO_CLIENT BOOLEANS ——————
+import gradio_client.utils as client_utils
+
+_original_get_type = client_utils.get_type
+def patched_get_type(schema):
+    # Si el schema no es dict (e.g. un bool), devolvemos Any pa' que no truene
+    if not isinstance(schema, dict):
+        return "Any"
+    return _original_get_type(schema)
+
+client_utils.get_type = patched_get_type
+# ————————————————————————————————
+
 import gradio as gr
 import requests
 import pandas as pd
@@ -6,6 +19,10 @@ import shutil
 import os
 from tempfile import NamedTemporaryFile
 
+# Imprime versión pa' checar que ya cargue Gradio correcto
+import gradio as _gr
+print("⚙️ Gradio version cargada:", _gr.__version__)
+
 # Configuración de Credenciales
 client_ids = os.getenv("SPOTIFY_CLIENT_IDS", "").split(',')
 client_secrets = os.getenv("SPOTIFY_CLIENT_SECRETS", "").split(',')
@@ -26,23 +43,23 @@ def rotate_client():
 
 def get_spotify_token():
     global current_client_index
-    for intento in range(len(client_ids)):
-        client_id = client_ids[current_client_index]
-        client_secret = client_secrets[current_client_index]
-        print(f"🔑 Intentando token con cliente #{current_client_index + 1}")
-        response = requests.post(
+    for _ in range(len(client_ids)):
+        cid = client_ids[current_client_index]
+        csec = client_secrets[current_client_index]
+        print(f"🔑 Intentando token con cliente #{current_client_index+1}")
+        resp = 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=(cid, csec)
         )
-        print(f"➡️ get_spotify_token: status_code={response.status_code}")
-        if response.status_code == 200:
-            token = response.json().get('access_token')
+        print(f"➡️ get_spotify_token status={resp.status_code}")
+        if resp.status_code == 200:
+            token = resp.json().get('access_token')
             print(f"✅ Token OK (cliente #{current_client_index+1}): {token[:10]}…")
             return token
         else:
-            print(f"❌ Error token cliente #{current_client_index+1}: {response.text}")
+            print(f"❌ Error token cliente #{current_client_index+1}: {resp.text}")
             rotate_client()
     raise Exception("🚨 All clients failed to obtain token")
 
@@ -54,132 +71,116 @@ def make_spotify_request(url, params=None):
     if params:
         print(f"   con params: {params}")
     headers = {'Authorization': f'Bearer {token}'}
-    
     for intento in range(3):
-        print(f"🔁 make_spotify_request intento #{intento+1}")
-        response = requests.get(url, headers=headers, params=params)
-        print(f"➡️ Status code: {response.status_code}")
+        print(f"🔁 intento #{intento+1}")
+        r = requests.get(url, headers=headers, params=params)
+        print(f"➡️ Status code: {r.status_code}")
         request_counter += 1
-        
-        if response.status_code == 429:
-            retry = int(response.headers.get('Retry-After', 10))
-            print(f"⚠️ Rate limit. Esperando {retry}s y rotando cliente")
+        if r.status_code == 429:
+            retry = int(r.headers.get('Retry-After', 10))
+            print(f"⚠️ Rate limit, espero {retry}s y rotamos cliente")
             rotate_client()
             time.sleep(retry)
             continue
-        
-        if response.status_code == 200:
+        if r.status_code == 200:
             if request_counter >= MAX_REQUESTS_PER_CLIENT:
-                print("🔄 Límite requests alcanzado, rotando cliente")
+                print("🔄 Límite alcanzado, roto cliente")
                 rotate_client()
-            return response.json()
-        
-        print(f"❌ Error {response.status_code}: {response.text}")
+            return r.json()
+        print(f"❌ Error {r.status_code}: {r.text}")
         time.sleep(2)
-    
-    print("🚫 make_spotify_request: todos los intentos fallaron")
+    print("🚫 make_spotify_request: fallaron los 3 intentos")
     return None
 
 def extract_spotify_id(url, resource_type):
     clean = url.strip().split('?')[0].replace("https://open.spotify.com/", "")
     if "/intl-" in clean:
-        parts = clean.split("/")
-        return parts[-1]
+        return clean.split("/")[-1]
     parts = clean.split("/")
     try:
-        idx = parts.index(resource_type)
-        return parts[idx + 1]
+        i = parts.index(resource_type)
+        return parts[i+1]
     except ValueError:
-        for part in parts:
-            if len(part) == 22 and resource_type in url:
-                return part
-    print(f"❌ extract_spotify_id no pudo extraer ID de {url}")
+        for p in parts:
+            if len(p)==22 and resource_type in url:
+                return p
+    print(f"❌ extract_spotify_id no pudo extraer de {url}")
     return None
 
 def get_playlist_tracks(playlist_url):
     pid = extract_spotify_id(playlist_url, "playlist")
-    if not pid:
-        return []
+    if not pid: return []
     print(f"🎧 Getting playlist: {pid}")
     tracks = []
-    url = f'https://api.spotify.com/v1/playlists/{pid}/tracks'
-    params = {'market': 'US', 'limit': 100}
-    
+    url = f"https://api.spotify.com/v1/playlists/{pid}/tracks"
+    params = {'market':'US','limit':100}
     while url:
         data = make_spotify_request(url, params)
-        if not data:
-            break
-        items = data.get('items', [])
-        print(f"   Got {len(items)} items")
-        tracks.extend([it['track'] for it in items if it.get('track')])
+        if not data: break
+        items = data.get('items',[])
+        print(f"   Recibí {len(items)} items")
+        tracks += [it['track'] for it in items if it.get('track')]
         url = data.get('next')
-    print(f"✅ Found total {len(tracks)} tracks in playlist")
+    print(f"✅ Found {len(tracks)} tracks")
     return tracks
 
 def get_album_tracks(album_url):
     aid = extract_spotify_id(album_url, "album")
-    if not aid:
-        return []
+    if not aid: return []
     print(f"💿 Getting album: {aid}")
-    all_tracks = []
-    url = f'https://api.spotify.com/v1/albums/{aid}/tracks'
-    params = {'market': 'US', 'limit': 50}
-    
+    all_t = []
+    url = f"https://api.spotify.com/v1/albums/{aid}/tracks"
+    params = {'market':'US','limit':50}
     while url:
-        data = make_spotify_request(url, params)
-        if not data:
-            break
-        for item in data.get('items', []):
-            print(f"   Fetching track detail for {item['id']}")
-            td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{item['id']}")
-            if td:
-                all_tracks.append(td)
-        url = data.get('next')
-    print(f"✅ Found total {len(all_tracks)} tracks in album")
-    return all_tracks
+        d = make_spotify_request(url, params)
+        if not d: break
+        for it in d.get('items',[]):
+            print(f"   Detail track {it['id']}")
+            td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{it['id']}")
+            if td: all_t.append(td)
+        url = d.get('next')
+    print(f"✅ Found {len(all_t)} tracks")
+    return all_t
 
 def process_tracks(urls):
     print("🔍 process_tracks iniciado")
-    all_tracks = []
-    for url in urls:
-        print(f"➡️ Procesando URL: {url}")
+    all_t = []
+    for u in urls:
+        print(f"➡️ Procesando {u}")
         try:
-            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:
-                tid = extract_spotify_id(url, "track")
+            if "playlist" in u:
+                all_t += get_playlist_tracks(u)
+            elif "album" in u:
+                all_t += get_album_tracks(u)
+            elif "track" in u:
+                tid = extract_spotify_id(u, "track")
                 td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{tid}")
-                if td:
-                    all_tracks.append(td)
+                if td: all_t.append(td)
         except Exception as e:
-            print(f"⚠️ Error procesando {url}: {e}")
-    print(f"🔍 process_tracks terminó con {len(all_tracks)} tracks")
-    return all_tracks
+            print(f"⚠️ Error en {u}: {e}")
+    print(f"🔍 process_tracks terminó con {len(all_t)} tracks")
+    return all_t
 
 def create_final_dataframe(tracks, include_all_info=True):
     print("📊 create_final_dataframe iniciado")
-    artist_cache = {}
-    def get_artist_details(aid):
-        if aid not in artist_cache:
-            print(f"   Obteniendo detalles de artista {aid}")
+    cache = {}
+    def get_artist(aid):
+        if aid not in cache:
+            print(f"   Artist details {aid}")
             d = make_spotify_request(f"https://api.spotify.com/v1/artists/{aid}")
-            artist_cache[aid] = {
-                'genres': d.get('genres', []) if d else [],
-                'followers': d.get('followers', {}).get('total', 0) if d else 0,
-                'popularity': d.get('popularity', 0) if d else 0
+            cache[aid] = {
+                'genres':d.get('genres',[]) if d else [],
+                'followers':d.get('followers',{}).get('total',0) if d else 0,
+                'popularity':d.get('popularity',0) if d else 0
             }
-        return artist_cache[aid]
-    
+        return cache[aid]
     rows = []
     for tr in tracks:
-        if not tr:
-            continue
+        if not tr: continue
         ma = tr['artists'][0] if tr.get('artists') else {}
-        ai = get_artist_details(ma.get('id')) if ma.get('id') else {}
+        ai = get_artist(ma.get('id')) if ma.get('id') else {}
         dur = f"{tr['duration_ms']//60000}:{str(tr['duration_ms']%60000//1000).zfill(2)}"
-        row = {
+        base = {
             'Artist': ma.get('name','Unknown'),
             'Title': tr.get('name','No title'),
             'Album': tr.get('album',{}).get('name',''),
@@ -190,7 +191,7 @@ def create_final_dataframe(tracks, include_all_info=True):
             'Spotify URI': tr.get('external_urls',{}).get('spotify','')
         }
         if include_all_info:
-            row.update({
+            base.update({
                 'Genres': ', '.join(ai.get('genres',[])),
                 'Artist Followers': ai.get('followers',0),
                 'Artist Popularity': ai.get('popularity',0),
@@ -198,21 +199,19 @@ def create_final_dataframe(tracks, include_all_info=True):
                 'Track ID': tr.get('id'),
                 'Album ID': tr.get('album',{}).get('id')
             })
-        rows.append(row)
+        rows.append(base)
     df = pd.DataFrame(rows)
-    df['dup_key'] = df.apply(
-        lambda x: x['ISRC'] or f"{x['Artist']}|{x['Title']}", axis=1
-    )
+    df['dup_key'] = df.apply(lambda x: x['ISRC'] or f"{x['Artist']}|{x['Title']}", axis=1)
     df = df.drop_duplicates('dup_key').drop(columns='dup_key')
     print("📊 create_final_dataframe completado")
     return df
 
 def main_interface(project_name, spotify_urls, include_all_info=True):
-    print(f"\n🎬 Inicio interface con proyecto: {project_name}")
+    print(f"\n🎬 Inicio interface proyecto: {project_name}")
     urls = [u.strip() for u in spotify_urls.replace('\n',',').split(',') if u.strip()]
     if not urls:
         print("❌ No hay URLs válidas")
-        return pd.DataFrame({"Error":["❌ Ingresa al menos una URL"]}), None
+        return pd.DataFrame({"Error":["❌ Ingresa al menos una URL válida"]}), None
     tracks = process_tracks(urls)
     if not tracks:
         print("❌ No se encontraron tracks")
@@ -220,10 +219,10 @@ def main_interface(project_name, spotify_urls, include_all_info=True):
     df = create_final_dataframe(tracks, include_all_info)
     with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
         df.to_excel(tmp.name, index=False)
-        filename = f"{project_name or 'spotify_tracks'}.xlsx"
-        shutil.move(tmp.name, filename)
-    print(f"✅ Proceso completado. Archivo: {filename}\n")
-    return df, filename
+        fname = f"{project_name or 'spotify_tracks'}.xlsx"
+        shutil.move(tmp.name, fname)
+    print(f"✅ Proceso completado. Archivo: {fname}\n")
+    return df, fname
 
 # Configuración de la interfaz
 iface = gr.Interface(