Update app.py

app.py

@@ -1,12 +1,12 @@
-# —————— PARCHES PARA SPACES ——————
-# 1) Alias de pydantic.Schema para evitar el ImportError en FastAPI
-import pydantic
-pydantic.Schema = pydantic.Field
+# —————— PARCHE FASTAPI + GRADIO_CLIENT ——————
+import fastapi.params
+# Creamos un Schema dummy para que FastAPI no explote al hacer `class Param(Schema):`
+fastapi.params.Schema = type("Schema", (object,), {})
 
-# 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 (p. ej. un bool), devolvemos "Any" en lugar de crashear
     if not isinstance(schema, dict):
         return "Any"
     return _original_get_type(schema)
@@ -24,11 +24,11 @@ from tempfile import NamedTemporaryFile
 # Verifica la versión de Gradio
 print("⚙️ Gradio version cargada:", gr.__version__)
 
-# Configuración de Credenciales
+# Configuración de credenciales Spotify
 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")
+    raise ValueError("❌ Faltan SPOTIFY_CLIENT_IDS o SPOTIFY_CLIENT_SECRETS")
 
 # Rotación de clientes
 current_client_index = 0
@@ -48,38 +48,38 @@ def get_spotify_token():
         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'},
+            "https://accounts.spotify.com/api/token",
+            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:
-            tok = resp.json().get('access_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")
+    raise Exception("🚨 Todos los clientes fallaron al obtener token")
 
 def make_spotify_request(url, params=None):
     global request_counter
     token = get_spotify_token()
     print(f"🌐 GET {url} params={params} (token {token[:10]}…)")
-    headers = {'Authorization':f'Bearer {token}'}
+    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 {r.status_code}")
         request_counter += 1
         if r.status_code == 429:
-            wait = int(r.headers.get('Retry-After',10))
+            wait = int(r.headers.get("Retry-After",10))
             print(f"⚠️ Rate limit, espero {wait}s")
             rotate_client()
             time.sleep(wait)
             continue
         if r.status_code == 200:
-            if request_counter>=MAX_REQUESTS_PER_CLIENT:
+            if request_counter >= MAX_REQUESTS_PER_CLIENT:
                 rotate_client()
             return r.json()
         print(f"❌ Error {r.status_code}: {r.text}")
@@ -88,7 +88,7 @@ def make_spotify_request(url, params=None):
     return None
 
 def extract_spotify_id(url, resource):
-    clean = url.split('?')[0].replace("https://open.spotify.com/","")
+    clean = url.split("?")[0].replace("https://open.spotify.com/","")
     if "/intl-" in clean:
         return clean.split("/")[-1]
     parts = clean.split("/")
@@ -106,113 +106,115 @@ def get_playlist_tracks(u):
     pid = extract_spotify_id(u, "playlist")
     if not pid: return []
     print(f"🎧 Playlist {pid}")
-    al = []
+    all_t = []
     url = f"https://api.spotify.com/v1/playlists/{pid}/tracks"
-    p = {'market':'US','limit':100}
+    p = {"market":"US","limit":100}
     while url:
         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
+        items = d.get("items",[])
+        print(f"   recibí {len(items)} items")
+        all_t += [it["track"] for it in items if it.get("track")]
+        url = d.get("next")
+    print(f"✅ {len(all_t)} tracks en la lista")
+    return all_t
 
 def get_album_tracks(u):
     aid = extract_spotify_id(u, "album")
     if not aid: return []
-    print(f"💿 Album {aid}")
-    al = []
+    print(f"💿 Álbum {aid}")
+    all_t = []
     url = f"https://api.spotify.com/v1/albums/{aid}/tracks"
-    p = {'market':'US','limit':50}
+    p = {"market":"US","limit":50}
     while url:
         d = make_spotify_request(url, p)
         if not d: break
-        for it in d.get('items',[]):
+        for it in d.get("items",[]):
             print(f"   detalle track {it['id']}")
             td = make_spotify_request(f"https://api.spotify.com/v1/tracks/{it['id']}")
-            if td: al.append(td)
-        url = d.get('next')
-    print(f"✅ {len(al)} tracks en álbum")
-    return al
+            if td: all_t.append(td)
+        url = d.get("next")
+    print(f"✅ {len(all_t)} tracks en el álbum")
+    return all_t
 
 def process_tracks(urls):
-    print("🔍 process_tracks")
+    print("🔍 process_tracks iniciado")
     all_t = []
     for u in urls:
-        print("➡️",u)
+        print(f"➡️ Procesando {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"🔍 total tracks: {len(all_t)}")
+    print(f"🔍 process_tracks terminó con {len(all_t)} tracks")
     return all_t
 
 def create_final_dataframe(tracks, full=True):
-    print("📊 create_dataframe")
-    cache={}
+    print("📊 create_dataframe iniciado")
+    cache = {}
     def artist_details(aid):
         if aid not in cache:
-            print("   artist",aid)
+            print(f"   artist {aid}")
             d = make_spotify_request(f"https://api.spotify.com/v1/artists/{aid}")
-            cache[aid]={
-                'genres':d.get('genres',[]),
-                'followers':d.get('followers',{}).get('total',0),
-                'popularity':d.get('popularity',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 {}
-        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','')
+        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 full:
             base.update({
-                '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')
+                "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'] = df.apply(lambda x: x['ISRC'] or f"{x['Artist']}|{x['Title']}",axis=1)
-    df=df.drop_duplicates('dup').drop(columns='dup')
+    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(name, urls_txt, full=True):
-    print(f"\n🎬 Inicio: {name}")
-    urls=[u.strip() for u in urls_txt.replace('\n',',').split(',') if u.strip()]
+    print(f"\n🎬 Inicio proyecto: {name}")
+    urls = [u.strip() for u in urls_txt.replace("\n",",").split(",") if u.strip()]
     if not urls:
-        return pd.DataFrame({"Error":["❌ Mete al menos una URL"]}), None
-    tr=process_tracks(urls)
+        return pd.DataFrame({"Error": ["❌ Ingresa 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(tr, full)
-    with NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
+        return pd.DataFrame({"Error": ["❌ No se encontraron tracks"]}), None
+    df = create_final_dataframe(tr, full)
+    with NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
         df.to_excel(tmp.name, index=False)
-        fname=f"{name or 'spotify_tracks'}.xlsx"
-        shutil.move(tmp.name,fname)
-    print("✅ Hecho:",fname)
+        fname = f"{name or 'spotify_tracks'}.xlsx"
+        shutil.move(tmp.name, fname)
+    print("✅ Hecho:", fname)
     return df, fname
 
 iface = gr.Interface(