Fix: Switch to Native Gradio SDK for ZeroGPU stability

app.py

@@ -1,5 +1,7 @@
 import sys
 import os
+import gc
+import torch
 
 # --- PARCHES CRÍTICOS ---
 try:
@@ -9,105 +11,139 @@ try:
         if isinstance(schema, bool): return "Any"
         return old_json_schema_to_python_type(schema, defs)
     client_utils._json_schema_to_python_type = patched_json_schema_to_python_type
-    print("Gradio Patch Applied")
 except: pass
 
 import spaces
 import gradio as gr
-import torch
 from PIL import Image
 import tempfile
 
-# MODELOS PREDEFINIDOS
-MODELS = {
+# CONFIG
+SDXL_MODELS = {
     "CyberRealistic Pony (Recomendado)": "cyberdelia/CyberRealisticPony",
     "RealVisXL V4.0": "SG161222/RealVisXL_V4.0",
-    "Juggernaut XL V9": "RunDiffusion/Juggernaut-XL-v9",
-    "SDXL Base 1.0": "stabilityai/stable-diffusion-xl-base-1.0"
+    "Juggernaut XL V9": "RunDiffusion/Juggernaut-XL-v9"
+}
+
+LTX_MODELS = {
+    "LTX-Video (Standard)": "Lightricks/LTX-Video"
 }
 
-# LORAS PREDEFINIDOS
-LORAS = {
+LTX_LORAS = {
     "Ninguno": "",
-    "Detalle Extremo (XL)": "h94/IP-Adapter",
-    "Realismo Fotográfico": "latent-consistency/lcm-lora-sdxl",
-    "Estilo Pixel Art": "nerijs/pixel-art-xl"
+    "Real Nudity Alpha (NSFW)": "Lora-Daddy/Ltx2.3-real-nudity-early-alpha-30k-steps",
+    "LTX Realism Boost": "strangerzonehf/LTX-Video-LoRA"
 }
 
+# --- FUNCIONES DE CARGA ---
 def load_t2i(model_id, is_img2img=False):
     from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
     cls = StableDiffusionXLImg2ImgPipeline if is_img2img else StableDiffusionXLPipeline
-    pipe = cls.from_pretrained(
-        model_id, torch_dtype=torch.float16, use_safetensors=True, variant="fp16",
-        low_cpu_mem_usage=True
-    )
+    pipe = cls.from_pretrained(model_id, torch_dtype=torch.float16, use_safetensors=True, variant="fp16")
     return pipe
 
+def load_video(model_id):
+    from diffusers import LTXPipeline
+    pipe = LTXPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
+    return pipe
+
+# --- GENERACIÓN ---
 @spaces.GPU(duration=100)
-def generate_t2i(prompt, neg, model_name, custom_model, lora_name, custom_lora, lora_scale, steps, cfg, w, h, init_img):
-    model_id = custom_model if custom_model else MODELS.get(model_name)
-    lora_id = custom_lora if custom_lora else LORAS.get(lora_name)
-    
+def generate_t2i(prompt, neg, model_name, lora_id_custom, lora_scale, steps, cfg, w, h, init_img):
+    model_id = SDXL_MODELS.get(model_name)
     is_img2img = init_img is not None
     pipe = load_t2i(model_id, is_img2img).to("cuda")
     
-    if lora_id:
+    if lora_id_custom:
         try:
-            pipe.load_lora_weights(lora_id)
+            pipe.load_lora_weights(lora_id_custom)
             pipe.fuse_lora(lora_scale=lora_scale)
-        except Exception as e:
-            print(f"LoRA Error: {e}")
+        except: pass
             
-    kwargs = {
-        "prompt": prompt, 
-        "negative_prompt": neg, 
-        "num_inference_steps": int(steps), 
-        "guidance_scale": cfg,
-        "width": int(w),
-        "height": int(h)
-    }
-    
+    kwargs = {"prompt": prompt, "negative_prompt": neg, "num_inference_steps": int(steps), "guidance_scale": cfg, "width": int(w), "height": int(h)}
     if is_img2img:
         kwargs["image"] = Image.fromarray(init_img).convert("RGB").resize((int(w), int(h)))
         kwargs.pop("width"); kwargs.pop("height")
         kwargs["strength"] = 0.6
         
-    return pipe(**kwargs).images[0]
+    res = pipe(**kwargs).images[0]
+    # Limpieza
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+    return res
 
-# UI DESIGN
+@spaces.GPU(duration=200)
+def generate_video(prompt, model_name, lora_name, lora_custom, lora_scale, init_image, steps, cfg):
+    from diffusers.utils import export_to_video
+    model_id = LTX_MODELS.get(model_name)
+    lora_id = lora_custom if lora_custom else LTX_LORAS.get(lora_name)
+    
+    pipe = load_video(model_id).to("cuda")
+    
+    if lora_id:
+        try:
+            pipe.load_lora_weights(lora_id)
+        except: pass
+    
+    kwargs = {
+        "prompt": prompt, 
+        "negative_prompt": "low quality, blurry, static", 
+        "num_frames": 49, 
+        "num_inference_steps": int(steps),
+        "guidance_scale": cfg
+    }
+    
+    if lora_id:
+        kwargs["cross_attention_kwargs"] = {"scale": lora_scale}
+        
+    if init_image is not None:
+        kwargs["image"] = Image.fromarray(init_image).convert("RGB").resize((768, 512))
+    
+    output = pipe(**kwargs)
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    export_to_video(output.frames[0], tmp.name, fps=24)
+    
+    # Limpieza profunda
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+    return tmp.name
+
+# --- INTERFAZ ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple")) as demo:
-    gr.HTML("<h1 style='text-align:center;'>🎨 Studio Privado v2.2 PRO</h1>")
+    gr.HTML("<h1 style='text-align:center;'>🚀 Studio Privado v2.3 Pro</h1>")
     
     with gr.Tabs():
-        with gr.Tab("🖼 Generador de Imágenes"):
+        with gr.Tab("🖼 Imagen / T2I"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    prompt = gr.Textbox(label="Prompt (Descripción)", placeholder="Una mujer cyberpunk en neon city...", lines=3)
-                    neg = gr.Textbox(label="Prompt Negativo", value="blurry, ugly, low quality, deformed")
-                    
+                with gr.Column():
+                    t2i_p = gr.Textbox(label="Prompt", lines=3)
+                    t2i_n = gr.Textbox(label="Negativo", value="blurry, ugly")
+                    t2i_m = gr.Dropdown(choices=list(SDXL_MODELS.keys()), value="CyberRealistic Pony (Recomendado)", label="Modelo")
+                    t2i_lora = gr.Textbox(label="LoRA ID Personalizado (Opcional)")
+                    t2i_ls = gr.Slider(0, 1.5, 0.8, label="Peso LoRA")
                     with gr.Row():
-                        model_sel = gr.Dropdown(choices=list(MODELS.keys()), value="CyberRealistic Pony (Recomendado)", label="Seleccionar Modelo")
-                        custom_model = gr.Textbox(label="O usar ID de HF (opcional)", placeholder="usuario/modelo")
-                    
+                        t2i_w = gr.Slider(512, 1024, 1024, step=64, label="Ancho")
+                        t2i_h = gr.Slider(512, 1024, 1024, step=64, label="Alto")
+                    t2i_btn = gr.Button("GENERAR IMAGEN", variant="primary")
+                t2i_out = gr.Image(label="Resultado")
+            t2i_btn.click(generate_t2i, [t2i_p, t2i_n, t2i_m, t2i_lora, t2i_ls, gr.Number(value=30, visible=False), gr.Number(value=7, visible=False), t2i_w, t2i_h, gr.State(None)], t2i_out)
+
+        with gr.Tab("🎬 Video / M-Sequence"):
+            with gr.Row():
+                with gr.Column():
+                    v_p = gr.Textbox(label="Video Prompt", lines=3)
+                    v_m = gr.Dropdown(choices=list(LTX_MODELS.keys()), value="LTX-Video (Standard)", label="Modelo de Video")
+                    v_lora = gr.Dropdown(choices=list(LTX_LORAS.keys()), value="Real Nudity Alpha (NSFW)", label="Seleccionar LoRA Video")
+                    v_lora_c = gr.Textbox(label="O ID LoRA Video personalizado")
+                    v_ls = gr.Slider(0, 1.5, 1.0, label="Peso LoRA Video")
+                    v_img = gr.Image(label="Imagen de Inicio (Opcional)", type="numpy")
                     with gr.Row():
-                        lora_sel = gr.Dropdown(choices=list(LORAS.keys()), value="Ninguno", label="Seleccionar Extensión (LoRA)")
-                        custom_lora = gr.Textbox(label="O ID de LoRA personalizado", placeholder="usuario/lora")
-                    
-                    lora_scale = gr.Slider(0, 1.5, 0.8, label="Peso de la Extensión")
-                    
-                    with gr.Accordion("Configuración Avanzada", open=False):
-                        steps = gr.Slider(10, 50, 30, step=1, label="Pasos")
-                        cfg = gr.Slider(1, 15, 7, label="Guidance Scale")
-                        with gr.Row():
-                            w = gr.Slider(512, 1024, 1024, step=64, label="Ancho")
-                            h = gr.Slider(512, 1024, 1024, step=64, label="Alto")
-                    
-                    init_img = gr.Image(label="Imagen de Referencia (Img2Img)", type="numpy")
-                    btn = gr.Button("GENERAR IMAGEN", variant="primary")
-                
-                with gr.Column(scale=1):
-                    output = gr.Image(label="Resultado")
-            
-            btn.click(generate_t2i, [prompt, neg, model_sel, custom_model, lora_sel, custom_lora, lora_scale, steps, cfg, w, h, init_img], output)
+                        v_steps = gr.Slider(10, 50, 30, step=1, label="Pasos")
+                        v_cfg = gr.Slider(1, 10, 3.5, label="Guidance")
+                    v_btn = gr.Button("GENERAR VIDEO", variant="primary")
+                v_out = gr.Video(label="Resultado Video")
+            v_btn.click(generate_video, [v_p, v_m, v_lora, v_lora_c, v_ls, v_img, v_steps, v_cfg], v_out)
 
 demo.queue().launch(show_api=False, server_name="0.0.0.0", server_port=7860)