Update app.py

app.py

@@ -1,13 +1,15 @@
-# —————— PARCHE GRADIO_CLIENT BOOLEANS ——————
-import gradio_client.utils as client_utils
+# —————— PARCHES PARA SPACES ——————
+# 1) Alias de pydantic.Schema para evitar el ImportError en FastAPI
+import pydantic
+pydantic.Schema = pydantic.Field
 
+# 2) Monkey-patch para el bug de gradio_client.utils.get_type
+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
 # ————————————————————————————————
 
@@ -19,27 +21,25 @@ 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__)
+# Verifica la versión de Gradio
+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(',')
-
 if not client_ids or not client_secrets:
     raise ValueError("❌ Missing environment variables SPOTIFY_CLIENT_IDS or SPOTIFY_CLIENT_SECRETS")
 
-# Gestión de Rotación de Clientes
+# Rotación de clientes
 current_client_index = 0
 request_counter = 0
-MAX_REQUESTS_PER_CLIENT = 95  # Rotar antes de llegar al límite de 100
+MAX_REQUESTS_PER_CLIENT = 95
 
 def rotate_client():
     global current_client_index, request_counter
     current_client_index = (current_client_index + 1) % len(client_ids)
     request_counter = 0
-    print(f"🔄 Rotated to Spotify client #{current_client_index + 1}")
+    print(f"🔄 Rotated to Spotify client #{current_client_index+1}")
 
 def get_spotify_token():
     global current_client_index
@@ -49,182 +49,172 @@ def get_spotify_token():
         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'},
+            headers={'Content-Type':'application/x-www-form-urlencoded'},
+            data={'grant_type':'client_credentials'},
             auth=(cid, csec)
         )
         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}: {resp.text}")
-            rotate_client()
-    raise Exception("🚨 All clients failed to obtain token")
+            tok = resp.json().get('access_token')
+            print(f"✅ Token OK: {tok[:10]}…")
+            return tok
+        print(f"❌ Error token: {resp.text}")
+        rotate_client()
+    raise Exception("🚨 Todos los clientes fallaron")
 
 def make_spotify_request(url, params=None):
     global request_counter
     token = get_spotify_token()
-    print(f"🔑 Usando token: {token[:10]}…")
-    print(f"🌐 Llamando a URL: {url}")
-    if params:
-        print(f"   con params: {params}")
-    headers = {'Authorization': f'Bearer {token}'}
-    for intento in range(3):
-        print(f"🔁 intento #{intento+1}")
+    print(f"🌐 GET {url} params={params} (token {token[:10]}…)")
+    headers = {'Authorization':f'Bearer {token}'}
+    for i in range(3):
+        print(f"🔁 intento #{i+1}")
         r = requests.get(url, headers=headers, params=params)
-        print(f"➡️ Status code: {r.status_code}")
+        print(f"➡️ status {r.status_code}")
         request_counter += 1
         if r.status_code == 429:
-            retry = int(r.headers.get('Retry-After', 10))
-            print(f"⚠️ Rate limit, espero {retry}s y rotamos cliente")
+            wait = int(r.headers.get('Retry-After',10))
+            print(f"⚠️ Rate limit, espero {wait}s")
             rotate_client()
-            time.sleep(retry)
+            time.sleep(wait)
             continue
         if r.status_code == 200:
-            if request_counter >= MAX_REQUESTS_PER_CLIENT:
-                print("🔄 Límite alcanzado, roto cliente")
+            if request_counter>=MAX_REQUESTS_PER_CLIENT:
                 rotate_client()
             return r.json()
         print(f"❌ Error {r.status_code}: {r.text}")
         time.sleep(2)
-    print("🚫 make_spotify_request: fallaron los 3 intentos")
+    print("🚫 3 intentos fallidos")
     return None
 
-def extract_spotify_id(url, resource_type):
-    clean = url.strip().split('?')[0].replace("https://open.spotify.com/", "")
+def extract_spotify_id(url, resource):
+    clean = url.split('?')[0].replace("https://open.spotify.com/","")
     if "/intl-" in clean:
         return clean.split("/")[-1]
     parts = clean.split("/")
     try:
-        i = parts.index(resource_type)
-        return parts[i+1]
+        idx = parts.index(resource)
+        return parts[idx+1]
     except ValueError:
         for p in parts:
-            if len(p)==22 and resource_type in url:
+            if len(p)==22 and resource in url:
                 return p
-    print(f"❌ extract_spotify_id no pudo extraer de {url}")
+    print(f"❌ No pude extraer ID de {url}")
     return None
 
-def get_playlist_tracks(playlist_url):
-    pid = extract_spotify_id(playlist_url, "playlist")
+def get_playlist_tracks(u):
+    pid = extract_spotify_id(u, "playlist")
     if not pid: return []
-    print(f"🎧 Getting playlist: {pid}")
-    tracks = []
+    print(f"🎧 Playlist {pid}")
+    al = []
     url = f"https://api.spotify.com/v1/playlists/{pid}/tracks"
-    params = {'market':'US','limit':100}
+    p = {'market':'US','limit':100}
     while url:
-        data = make_spotify_request(url, params)
-        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 {len(tracks)} tracks")
-    return tracks
-
-def get_album_tracks(album_url):
-    aid = extract_spotify_id(album_url, "album")
+        d = make_spotify_request(url, p)
+        if not d: break
+        items = d.get('items',[])
+        print(f"   recibí {len(items)} ítems")
+        al += [it['track'] for it in items if it.get('track')]
+        url = d.get('next')
+    print(f"✅ {len(al)} tracks en lista")
+    return al
+
+def get_album_tracks(u):
+    aid = extract_spotify_id(u, "album")
     if not aid: return []
-    print(f"💿 Getting album: {aid}")
-    all_t = []
+    print(f"💿 Album {aid}")
+    al = []
     url = f"https://api.spotify.com/v1/albums/{aid}/tracks"
-    params = {'market':'US','limit':50}
+    p = {'market':'US','limit':50}
     while url:
-        d = make_spotify_request(url, params)
+        d = make_spotify_request(url, p)
         if not d: break
         for it in d.get('items',[]):
-            print(f"   Detail track {it['id']}")
+            print(f"   detalle track {it['id']}")
             td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{it['id']}")
-            if td: all_t.append(td)
+            if td: al.append(td)
         url = d.get('next')
-    print(f"✅ Found {len(all_t)} tracks")
-    return all_t
+    print(f"✅ {len(al)} tracks en álbum")
+    return al
 
 def process_tracks(urls):
-    print("🔍 process_tracks iniciado")
+    print("🔍 process_tracks")
     all_t = []
     for u in urls:
-        print(f"➡️ Procesando {u}")
+        print("➡️",u)
         try:
-            if "playlist" in u:
-                all_t += get_playlist_tracks(u)
-            elif "album" in u:
-                all_t += get_album_tracks(u)
+            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")
+                tid = extract_spotify_id(u,"track")
                 td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{tid}")
                 if td: all_t.append(td)
         except Exception as e:
             print(f"⚠️ Error en {u}: {e}")
-    print(f"🔍 process_tracks terminó con {len(all_t)} tracks")
+    print(f"🔍 total tracks: {len(all_t)}")
     return all_t
 
-def create_final_dataframe(tracks, include_all_info=True):
-    print("📊 create_final_dataframe iniciado")
-    cache = {}
-    def get_artist(aid):
+def create_final_dataframe(tracks, full=True):
+    print("📊 create_dataframe")
+    cache={}
+    def artist_details(aid):
         if aid not in cache:
-            print(f"   Artist details {aid}")
+            print("   artist",aid)
             d = make_spotify_request(f"https://api.spotify.com/v1/artists/{aid}")
-            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',[]),
+                'followers':d.get('followers',{}).get('total',0),
+                'popularity':d.get('popularity',0)
             }
         return cache[aid]
-    rows = []
+    rows=[]
     for tr in tracks:
         if not tr: continue
-        ma = tr['artists'][0] if tr.get('artists') 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)}"
-        base = {
-            'Artist': ma.get('name','Unknown'),
-            'Title': tr.get('name','No title'),
-            'Album': tr.get('album',{}).get('name',''),
-            'ISRC': tr.get('external_ids',{}).get('isrc',''),
-            'Popularity': tr.get('popularity',0),
-            'Duration': dur,
-            'Release Date': tr.get('album',{}).get('release_date',''),
-            'Spotify URI': tr.get('external_urls',{}).get('spotify','')
+        ma=tr['artists'][0] if tr.get('artists') else {}
+        ad=artist_details(ma.get('id')) if ma.get('id') else {}
+        dur=f"{tr['duration_ms']//60000}:{(tr['duration_ms']%60000//1000):02d}"
+        base={
+            'Artist':ma.get('name',''),
+            'Title':tr.get('name',''),
+            'Album':tr.get('album',{}).get('name',''),
+            'ISRC':tr.get('external_ids',{}).get('isrc',''),
+            'Popularity':tr.get('popularity',0),
+            'Duration':dur,
+            'Release Date':tr.get('album',{}).get('release_date',''),
+            'Spotify URI':tr.get('external_urls',{}).get('spotify','')
         }
-        if include_all_info:
+        if full:
             base.update({
-                'Genres': ', '.join(ai.get('genres',[])),
-                'Artist Followers': ai.get('followers',0),
-                'Artist Popularity': ai.get('popularity',0),
-                'Explicit': 'Yes' if tr.get('explicit') else 'No',
-                'Track ID': tr.get('id'),
-                'Album ID': tr.get('album',{}).get('id')
+                'Genres':', '.join(ad.get('genres',[])),
+                'Artist Followers':ad.get('followers',0),
+                'Artist Popularity':ad.get('popularity',0),
+                'Explicit':'Yes' if tr.get('explicit') else 'No',
+                'Track ID':tr.get('id'),
+                'Album ID':tr.get('album',{}).get('id')
             })
         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 = df.drop_duplicates('dup_key').drop(columns='dup_key')
-    print("📊 create_final_dataframe completado")
+    df=pd.DataFrame(rows)
+    df['dup'] = df.apply(lambda x: x['ISRC'] or f"{x['Artist']}|{x['Title']}",axis=1)
+    df=df.drop_duplicates('dup').drop(columns='dup')
+    print("📊 dataframe listo")
     return df
 
-def main_interface(project_name, spotify_urls, include_all_info=True):
-    print(f"\n🎬 Inicio interface proyecto: {project_name}")
-    urls = [u.strip() for u in spotify_urls.replace('\n',',').split(',') if u.strip()]
+def main_interface(name, urls_txt, full=True):
+    print(f"\n🎬 Inicio: {name}")
+    urls=[u.strip() for u in urls_txt.replace('\n',',').split(',') if u.strip()]
     if not urls:
-        print("❌ No hay URLs válidas")
-        return pd.DataFrame({"Error":["❌ Ingresa al menos una URL válida"]}), None
-    tracks = process_tracks(urls)
-    if not tracks:
-        print("❌ No se encontraron tracks")
+        return pd.DataFrame({"Error":["❌ Mete al menos una URL"]}), None
+    tr=process_tracks(urls)
+    if not tr:
         return pd.DataFrame({"Error":["❌ No se encontraron tracks"]}), None
-    df = create_final_dataframe(tracks, include_all_info)
+    df=create_final_dataframe(tr, full)
     with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
         df.to_excel(tmp.name, index=False)
-        fname = f"{project_name or 'spotify_tracks'}.xlsx"
-        shutil.move(tmp.name, fname)
-    print(f"✅ Proceso completado. Archivo: {fname}\n")
+        fname=f"{name or 'spotify_tracks'}.xlsx"
+        shutil.move(tmp.name,fname)
+    print("✅ Hecho:",fname)
     return df, fname
 
-# Configuración de la interfaz
 iface = gr.Interface(
     fn=main_interface,
     inputs=[
@@ -237,10 +227,10 @@ iface = gr.Interface(
         gr.File(label="Descargar Excel")
     ],
     title="🎵 Spotify Track Collector PRO",
-    description="Extrae info detallada de múltiples URLs de Spotify y genera un archivo Excel unificado",
+    description="Extrae info de varias URLs de Spotify y genera un Excel unificado",
     examples=[
-        ["Classic Rock", "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M\nhttps://open.spotify.com/album/1R5BORZZxNUg8QMgbqt0nd", True],
-        ["Current Hits", "https://open.spotify.com/playlist/37i9dQZEtDXc8QFRQ4qegR", False]
+        ["Classic Rock", "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M", True],
+        ["Current Hits", "https://open.spotify.com/playlist/37i9dQZEtDXc8QFRQ4qegR", False],
     ],
     allow_flagging="never",
     theme=gr.themes.Soft()