Update app.py

app.py

@@ -1,242 +1,39 @@
-# —————— PARCHE Pydantic para FastAPI ——————
-import pydantic
-# Alias Schema a Field para que fastapi.params no trunque al importar
-pydantic.Schema = pydantic.Field
-
-# —————— PARCHE GRADIO_CLIENT BOOLEANS ——————
-import gradio_client.utils as client_utils
-_original_get_type = client_utils.get_type
-def patched_get_type(schema):
-    if not isinstance(schema, dict):
-        return "Any"
-    return _original_get_type(schema)
-client_utils.get_type = patched_get_type
-# ————————————————————————————————
-
+import os
 import gradio as gr
 import requests
-import pandas as pd
-import time
-import shutil
-import os
-from tempfile import NamedTemporaryFile
-
-# Verifica la versión de Gradio cargada
-print("⚙️ Gradio version cargada:", gr.__version__)
-
-# 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("❌ Faltan SPOTIFY_CLIENT_IDS o SPOTIFY_CLIENT_SECRETS")
-
-# Rotación de clientes
-current_client_index = 0
-request_counter = 0
-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}")
-
-def get_spotify_token():
-    global current_client_index
-    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=(cid, csec)
-        )
-        print(f"➡️ get_spotify_token status={resp.status_code}")
-        if resp.status_code == 200:
-            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 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}"}
-    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))
-            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:
-                rotate_client()
-            return r.json()
-        print(f"❌ Error {r.status_code}: {r.text}")
-        time.sleep(2)
-    print("🚫 3 intentos fallidos")
-    return None
-
-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:
-        idx = parts.index(resource)
-        return parts[idx+1]
-    except ValueError:
-        for p in parts:
-            if len(p)==22 and resource in url:
-                return p
-    print(f"❌ No pude extraer ID de {url}")
-    return None
-
-def get_playlist_tracks(u):
-    pid = extract_spotify_id(u, "playlist")
-    if not pid: return []
-    print(f"🎧 Playlist {pid}")
-    all_t = []
-    url = f"https://api.spotify.com/v1/playlists/{pid}/tracks"
-    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)} 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"💿 Álbum {aid}")
-    all_t = []
-    url = f"https://api.spotify.com/v1/albums/{aid}/tracks"
-    p = {"market":"US","limit":50}
-    while url:
-        d = make_spotify_request(url, p)
-        if not d: break
-        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: 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 iniciado")
-    all_t = []
-    for u in urls:
-        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)
-            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_t.append(td)
-        except Exception as e:
-            print(f"⚠️ Error en {u}: {e}")
-    print(f"🔍 process_tracks terminó con {len(all_t)} tracks")
-    return all_t
-
-def create_final_dataframe(tracks, full=True):
-    print("📊 create_dataframe iniciado")
-    cache = {}
-    def artist_details(aid):
-        if aid not in cache:
-            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)
-            }
-        return cache[aid]
-    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","")
-        }
-        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")
-            })
-        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")
-    print("📊 dataframe listo")
-    return df
-
-def main_interface(name, urls_txt, full=True):
-    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": ["❌ 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:
-        df.to_excel(tmp.name, index=False)
-        fname = f"{name or 'spotify_tracks'}.xlsx"
-        shutil.move(tmp.name, fname)
-    print("✅ Hecho:", fname)
-    return df, fname
 
+# 1️⃣ LEE TUS CREDENCIALES DE ENV
+SPOTIFY_CLIENT_ID = os.getenv("SPOTIFY_CLIENT_IDS", "").split(',')[0]
+SPOTIFY_CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRETS", "").split(',')[0]
+
+def test_spotify_api():
+    """
+    Pide un token a Spotify y regresa 'OK' o el error que truene.
+    """
+    if not SPOTIFY_CLIENT_ID or not SPOTIFY_CLIENT_SECRET:
+        return "❌ No encontré SPOTIFY_CLIENT_IDS o SPOTIFY_CLIENT_SECRETS"
+    
+    # 2️⃣ Solicita token
+    resp = requests.post(
+        "https://accounts.spotify.com/api/token",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={"grant_type": "client_credentials"},
+        auth=(SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET)
+    )
+    if resp.status_code == 200:
+        token = resp.json().get("access_token")
+        return f"✅ Token OK: {token[:20]}…"
+    else:
+        return f"❌ Status {resp.status_code}: {resp.text}"
+
+# 3️⃣ Monta la interfaz Gradio
 iface = gr.Interface(
-    fn=main_interface,
-    inputs=[
-        gr.Textbox(label="Nombre del proyecto"),
-        gr.Textbox(label="URLs de Spotify", lines=5),
-        gr.Checkbox(label="Incluir información completa", value=True)
-    ],
-    outputs=[
-        gr.Dataframe(label="Resultados"),
-        gr.File(label="Descargar Excel")
-    ],
-    title="🎵 Spotify Track Collector PRO",
-    description="Extrae info de varias URLs de Spotify y genera un Excel unificado",
-    examples=[
-        ["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()
+    fn=test_spotify_api,
+    inputs=[],
+    outputs="text",
+    title="🛠️ Test Spotify API",
+    description="Pulsa el botón y checa si obtenemos token de Spotify"
 )
 
 if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    iface.launch()