Fix: Switch to Native Gradio SDK for ZeroGPU stability

app.py

@@ -3,13 +3,12 @@ import os
 import gc
 import torch
 
-# --- PARCHES CRÍTICOS ---
+# --- PARCHES ---
 try:
     import gradio_client.utils as client_utils
-    old_json_schema_to_python_type = client_utils._json_schema_to_python_type
     def patched_json_schema_to_python_type(schema, defs=None):
         if isinstance(schema, bool): return "Any"
-        return old_json_schema_to_python_type(schema, defs)
+        return client_utils._json_schema_to_python_type(schema, defs)
     client_utils._json_schema_to_python_type = patched_json_schema_to_python_type
 except: pass
 
@@ -20,39 +19,35 @@ import tempfile
 
 # CONFIG
 SDXL_MODELS = {
-    "CyberRealistic Pony (Recomendado)": "cyberdelia/CyberRealisticPony",
-    "RealVisXL V4.0": "SG161222/RealVisXL_V4.0",
-    "Juggernaut XL V9": "RunDiffusion/Juggernaut-XL-v9"
+    "CyberRealistic Pony (Pro)": "cyberdelia/CyberRealisticPony",
+    "RealVisXL V4.0": "SG161222/RealVisXL_V4.0"
 }
 
 LTX_MODELS = {
-    "LTX-Video (Standard)": "Lightricks/LTX-Video"
+    "LTX-Video (Optimizado)": "Lightricks/LTX-Video"
 }
 
 LTX_LORAS = {
     "Ninguno": "",
-    "Real Nudity Alpha (NSFW)": "Lora-Daddy/Ltx2.3-real-nudity-early-alpha-30k-steps",
-    "LTX Realism Boost": "strangerzonehf/LTX-Video-LoRA"
+    "Real Nudity Alpha (NSFW)": "Lora-Daddy/Ltx2.3-real-nudity-early-alpha-30k-steps"
 }
 
-# --- 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")
-    return pipe
-
-def load_video(model_id):
-    from diffusers import LTXPipeline
-    pipe = LTXPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
-    return pipe
+def flush():
+    gc.collect()
+    torch.cuda.empty_cache()
 
 # --- GENERACIÓN ---
-@spaces.GPU(duration=100)
-def generate_t2i(prompt, neg, model_name, lora_id_custom, lora_scale, steps, cfg, w, h, init_img):
+@spaces.GPU(duration=120)
+def generate_t2i(prompt, neg, model_name, lora_id_custom, lora_scale, steps, cfg, w, h):
+    flush()
+    from diffusers import StableDiffusionXLPipeline
     model_id = SDXL_MODELS.get(model_name)
-    is_img2img = init_img is not None
-    pipe = load_t2i(model_id, is_img2img).to("cuda")
+    
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        model_id, torch_dtype=torch.float16, use_safetensors=True, variant="fp16",
+        low_cpu_mem_usage=True
+    )
+    pipe.to("cuda")
     
     if lora_id_custom:
         try:
@@ -60,90 +55,88 @@ def generate_t2i(prompt, neg, model_name, lora_id_custom, lora_scale, steps, cfg
             pipe.fuse_lora(lora_scale=lora_scale)
         except: pass
             
-    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
-        
-    res = pipe(**kwargs).images[0]
-    # Limpieza
+    res = pipe(prompt=prompt, negative_prompt=neg, num_inference_steps=int(steps), guidance_scale=cfg, width=int(w), height=int(h)).images[0]
+    
     del pipe
-    gc.collect()
-    torch.cuda.empty_cache()
+    flush()
     return res
 
-@spaces.GPU(duration=200)
-def generate_video(prompt, model_name, lora_name, lora_custom, lora_scale, init_image, steps, cfg):
+@spaces.GPU(duration=250)
+def generate_video(prompt, model_name, lora_name, lora_custom, lora_scale, steps, cfg):
+    flush() # Limpiar todo antes de empezar
+    from diffusers import LTXPipeline
     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")
+    # CARGA OPTIMIZADA
+    pipe = LTXPipeline.from_pretrained(
+        model_id, torch_dtype=torch.bfloat16, 
+        low_cpu_mem_usage=True
+    )
+    pipe.to("cuda")
+    
+    # IMPORTANTE: Ahorro de memoria para video
+    pipe.enable_vae_slicing()
     
     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
-    }
+    # Generar video (Reducido a 33 frames para evitar timeout/OOM)
+    output = pipe(
+        prompt=prompt, 
+        negative_prompt="low quality, blurry, static, distorted",
+        num_frames=33, 
+        num_inference_steps=int(steps),
+        guidance_scale=cfg,
+        height=480,
+        width=704,
+        cross_attention_kwargs={"scale": lora_scale} if lora_id else None
+    )
     
-    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)
+    export_to_video(output.frames[0], tmp.name, fps=16)
     
-    # Limpieza profunda
     del pipe
-    gc.collect()
-    torch.cuda.empty_cache()
+    flush()
     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.3 Pro</h1>")
+    gr.HTML("<h1 style='text-align:center;'>🚀 Studio Privado v2.4 (Ultra-Stable)</h1>")
     
     with gr.Tabs():
-        with gr.Tab("🖼 Imagen / T2I"):
+        with gr.Tab("🖼 Imagen"):
             with gr.Row():
                 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_m = gr.Dropdown(choices=list(SDXL_MODELS.keys()), value="CyberRealistic Pony (Pro)", label="Modelo")
+                    t2i_lora = gr.Textbox(label="LoRA ID Opcional")
                     t2i_ls = gr.Slider(0, 1.5, 0.8, label="Peso LoRA")
                     with gr.Row():
                         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)
+            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], t2i_out)
 
-        with gr.Tab("🎬 Video / M-Sequence"):
+        with gr.Tab("🎬 Video (LTX)"):
             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_m = gr.Dropdown(choices=list(LTX_MODELS.keys()), value="LTX-Video (Optimizado)", label="Modelo")
+                    v_lora = gr.Dropdown(choices=list(LTX_LORAS.keys()), value="Real Nudity Alpha (NSFW)", label="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():
-                        v_steps = gr.Slider(10, 50, 30, step=1, label="Pasos")
-                        v_cfg = gr.Slider(1, 10, 3.5, label="Guidance")
+                        v_steps = gr.Slider(10, 40, 25, step=1, label="Pasos (25 recomendado)")
+                        v_cfg = gr.Slider(1, 7, 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)
+            v_btn.click(generate_video, [v_p, v_m, v_lora, v_lora_c, v_ls, v_steps, v_cfg], v_out)
 
 demo.queue().launch(show_api=False, server_name="0.0.0.0", server_port=7860)