Update app.py

app.py

@@ -3,74 +3,105 @@ import torch
 import spaces
 import os
 import shutil
+import glob
 from diffusers import DiffusionPipeline
 from huggingface_hub import snapshot_download
 
 # -----------------------------------------------------------------------------
-# 1. FUNCIÓN DE REPARACIÓN DE ESTRUCTURA (LA SOLUCIÓN)
+# 1. FUNCIÓN DE DIAGNÓSTICO Y REPARACIÓN PROFUNDA
 # -----------------------------------------------------------------------------
 MODEL_ID = "NewBie-AI/NewBie-image-Exp0.1"
 LOCAL_DIR = "./newbie_fixed_model"
 
-def load_patched_pipeline():
-    print(f"🛠️ Iniciando protocolo de reparación v3 para {MODEL_ID}...")
+def list_all_files(directory):
+    """Función auxiliar para ver qué rayos se descargó"""
+    print(f"\n📂 LISTADO DE ARCHIVOS EN {directory}:")
+    for root, dirs, files in os.walk(directory):
+        level = root.replace(directory, '').count(os.sep)
+        indent = ' ' * 4 * (level)
+        print(f"{indent}{os.path.basename(root)}/")
+        subindent = ' ' * 4 * (level + 1)
+        for f in files:
+            print(f"{subindent}{f}")
+    print("------------------------------------------------\n")
+
+def load_deep_fixed_pipeline():
+    print(f"🛠️ Iniciando protocolo de Búsqueda Profunda para {MODEL_ID}...")
     
     # 1. Descargar repositorio completo
     if not os.path.exists(LOCAL_DIR):
-        print("   ⬇️ Descargando snapshot (esto puede tardar unos minutos)...")
+        print("   ⬇️ Descargando snapshot...")
         snapshot_download(repo_id=MODEL_ID, local_dir=LOCAL_DIR)
     
-    # 2. CREAR CARPETA TRANSFORMER (El error original)
+    # 2. IMPRIMIR ESTRUCTURA (Para depuración si falla)
+    list_all_files(LOCAL_DIR)
+
+    # 3. BUSCAR ARCHIVOS DE CÓDIGO (.py) EN CUALQUIER SUBDIRECTORIO
+    all_py_files = []
+    for root, dirs, files in os.walk(LOCAL_DIR):
+        for file in files:
+            if file.endswith(".py"):
+                full_path = os.path.join(root, file)
+                all_py_files.append(full_path)
+    
+    print(f"   🔎 Se encontraron {len(all_py_files)} archivos Python: {all_py_files}")
+
+    if not all_py_files:
+        raise RuntimeError("❌ ERROR FATAL: No se encontró NINGÚN archivo .py en el repositorio. El modelo no se puede ejecutar.")
+
+    # 4. PREPARAR CARPETA TRANSFORMER (Donde el config busca el código)
     transformer_folder = os.path.join(LOCAL_DIR, "transformer")
     os.makedirs(transformer_folder, exist_ok=True)
     
-    # 3. BUSCAR Y MOVER ARCHIVOS PERDIDOS
-    # El config dice que el código está en 'transformer/transformer.py', pero suele estar en la raíz.
-    # Vamos a copiar TODOS los archivos .py de la raíz a la carpeta transformer por si acaso.
-    root_files = [f for f in os.listdir(LOCAL_DIR) if f.endswith(".py")]
-    
-    candidate_found = False
-    for f in root_files:
-        src = os.path.join(LOCAL_DIR, f)
+    # Crear __init__.py vacío para que sea un módulo
+    with open(os.path.join(transformer_folder, "__init__.py"), "w") as f: f.write("")
+
+    # 5. ESTRATEGIA DE COPIA INTELIGENTE
+    # Copiamos TODOS los archivos .py encontrados a la carpeta 'transformer/'
+    # y también a la raíz, para asegurar que se encuentren.
+    for py_file in all_py_files:
+        filename = os.path.basename(py_file)
         
-        # Copia de seguridad: Copiamos todo .py a la carpeta transformer
-        shutil.copy(src, os.path.join(transformer_folder, f))
+        # Copiar a transformer/
+        shutil.copy(py_file, os.path.join(transformer_folder, filename))
         
-        # DETECTIVE: Leemos el archivo para ver si es el modelo principal
-        with open(src, "r", encoding="utf-8", errors="ignore") as file_content:
-            content = file_content.read()
-            # Si el archivo define un Transformer o un Modelo, es nuestro candidato
-            if "class" in content and ("Transformer" in content or "Model" in content):
-                # Lo copiamos como 'transformer.py' que es lo que pide el json
-                shutil.copy(src, os.path.join(transformer_folder, "transformer.py"))
-                print(f"   ✅ Candidato detectado y renombrado: {f} -> transformer/transformer.py")
-                candidate_found = True
-
-    # Crear __init__.py obligatorio
-    with open(os.path.join(transformer_folder, "__init__.py"), "w") as f: f.write("")
+        # Copiar a raíz (si no está ya ahí)
+        root_dest = os.path.join(LOCAL_DIR, filename)
+        if not os.path.exists(root_dest):
+            shutil.copy(py_file, root_dest)
+
+        # DETECTAR EL CANDIDATO PRINCIPAL PARA 'transformer.py'
+        # Buscamos archivos que contengan "Transformer" o "Model" en su contenido
+        # O que se llamen 'modeling_...'
+        if "modeling" in filename or "transformer" in filename.lower():
+            print(f"   ✅ Posible archivo de modelado detectado: {filename}")
+            # Lo forzamos como transformer.py
+            shutil.copy(py_file, os.path.join(transformer_folder, "transformer.py"))
 
-    if not candidate_found:
-        print("   ⚠�� No se detectó un modelo obvio. Copiando el archivo .py más grande como transformer.py")
-        # Fallback: Copiar el archivo .py más grande
-        largest_py = max(root_files, key=lambda x: os.path.getsize(os.path.join(LOCAL_DIR, x)))
-        shutil.copy(os.path.join(LOCAL_DIR, largest_py), os.path.join(transformer_folder, "transformer.py"))
+    # Si después de todo no existe transformer.py, usamos el archivo más grande encontrado
+    if not os.path.exists(os.path.join(transformer_folder, "transformer.py")):
+        print("   ⚠️ No se detectó un nombre obvio. Usando el archivo .py más grande como transformer.py")
+        largest_py = max(all_py_files, key=os.path.getsize)
+        shutil.copy(largest_py, os.path.join(transformer_folder, "transformer.py"))
 
-    # 4. CARGAR MODELO DESDE CARPETA LOCAL ARREGLADA
-    print("   🚀 Cargando pipeline...")
+    # 6. CARGAR
+    print("   🚀 Intentando cargar pipeline...")
+    # Usamos local_files_only para obligarlo a usar nuestra estructura hackeada
     pipe = DiffusionPipeline.from_pretrained(
         LOCAL_DIR,
         torch_dtype=torch.bfloat16,
-        trust_remote_code=True, # Necesario para ejecutar el código que acabamos de mover
+        trust_remote_code=True,
         local_files_only=True
     )
     return pipe
 
-# Carga inicial
+# Carga inicial protegida
+pipe = None
 try:
-    pipe = load_patched_pipeline()
+    pipe = load_deep_fixed_pipeline()
 except Exception as e:
-    print(f"❌ Error fatal: {e}")
-    pipe = None
+    print(f"❌ Error durante la carga: {e}")
+    # No detenemos el script para que Gradio pueda mostrar el error en pantalla si es necesario
 
 # -----------------------------------------------------------------------------
 # 2. LÓGICA ZEROGPU
@@ -78,7 +109,7 @@ except Exception as e:
 @spaces.GPU(duration=120)
 def generate_image(prompt, negative_prompt, steps, cfg, width, height):
     if pipe is None:
-        raise gr.Error("El modelo no se cargó correctamente. Revisa los logs.")
+        raise gr.Error("El modelo falló al cargar. Revisa los logs de la consola (Files listed above).")
     
     print("🎨 Generando...")
     pipe.to("cuda")
@@ -94,16 +125,13 @@ def generate_image(prompt, negative_prompt, steps, cfg, width, height):
         ).images[0]
         return image
     except Exception as e:
-        return None
+        raise gr.Error(f"Error de inferencia: {e}")
 
 # -----------------------------------------------------------------------------
-# 3. INTERFAZ (Corrección de CSS para Gradio 5.0)
+# 3. INTERFAZ (SIN ARGUMENTO THEME)
 # -----------------------------------------------------------------------------
-# Inyectamos CSS usando Markdown HTML en lugar del argumento 'css' que daba error
-custom_css = """
-<style>
+css = """
 .container { max-width: 900px; margin: auto; }
-</style>
 """
 
 DEFAULT_PROMPT = """<character_1>
@@ -119,10 +147,10 @@ DEFAULT_PROMPT = """<character_1>
 
 DEFAULT_NEG = "low quality, bad anatomy, worst quality, watermark, text"
 
-# Quitamos el argumento css=css aquí para evitar el TypeError
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.HTML(custom_css) # Solución al error de CSS
-    gr.Markdown("# ⛩️ NewBie Anime Generator (Fixed)")
+# ELIMINADO theme=... y css=... del constructor para compatibilidad total
+with gr.Blocks() as demo:
+    gr.HTML(f"<style>{css}</style>") # CSS inyectado manualmente
+    gr.Markdown("# ⛩️ NewBie Anime Generator (Deep Fix)")
     
     with gr.Row():
         with gr.Column():