Update to v2.2 Pro - All files

Dockerfile

@@ -0,0 +1,30 @@
+# Usamos Python 3.10 que es el estándar más estable para IA
+FROM python:3.10-slim
+
+# Instalamos dependencias del sistema (FFMPEG para video y herramientas de compilación)
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Creamos un usuario para Hugging Face (requerido por seguridad)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:${PATH}"
+
+WORKDIR /app
+
+# Copiamos e instalamos requerimientos
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiamos el código de la aplicación
+COPY --chown=user . .
+
+# Exponemos el puerto de Gradio
+EXPOSE 7860
+
+# Comando para arrancar
+CMD ["python", "app.py"]

app.py

@@ -1,136 +1,113 @@
 import sys
 import os
 
-# --- PARCHE QUIRÚRGICO PARA EL BUG 'BOOL' (ERROR REAL DETECTADO) ---
+# --- PARCHES CRÍTICOS ---
 try:
     import gradio_client.utils as client_utils
-    # Parcheamos la función que causa el TypeError: argument of type 'bool' is not iterable
     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"
+        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
-
-    if hasattr(client_utils, "get_type"):
-        old_get_type = client_utils.get_type
-        def patched_get_type(schema):
-            if isinstance(schema, bool):
-                return "Any"
-            return old_get_type(schema)
-        client_utils.get_type = patched_get_type
-    print("Gradio Client 'bool' patch applied successfully.")
-except Exception as e:
-    print(f"Failed to apply Gradio Client patch: {e}")
-
-# --- PARCHES DE COMPATIBILIDAD (HfFolder + audioop) ---
-try:
-    import huggingface_hub
-    class MockHfFolder:
-        @staticmethod
-        def get_token(): return os.getenv("HF_TOKEN")
-        @staticmethod
-        def save_token(token): pass
-        @staticmethod
-        def delete_token(): pass
-    huggingface_hub.HfFolder = MockHfFolder
-    sys.modules["huggingface_hub.HfFolder"] = MockHfFolder
+    print("Gradio Patch Applied")
 except: pass
 
-try:
-    import audioop_lts
-    sys.modules["audioop"] = audioop_lts
-except:
-    from unittest.mock import MagicMock
-    sys.modules["audioop"] = MagicMock()
-# -----------------------------------------------------------------
-
 import spaces
 import gradio as gr
 import torch
-import numpy as np
 from PIL import Image
 import tempfile
 
-# CONFIG
-BASE_MODEL = "cyberdelia/CyberRealisticPony"
-LTX_MODEL  = "Lightricks/LTX-Video"
-LTX_NSFW_LORA = "Lora-Daddy/Ltx2.3-real-nudity-early-alpha-30k-steps"
-NEG_DEFAULT = "blurry, low quality, bad anatomy, deformed, ugly, watermark, text"
+# MODELOS PREDEFINIDOS
+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"
+}
+
+# LORAS PREDEFINIDOS
+LORAS = {
+    "Ninguno": "",
+    "Detalle Extremo (XL)": "h94/IP-Adapter",
+    "Realismo Fotográfico": "latent-consistency/lcm-lora-sdxl",
+    "Estilo Pixel Art": "nerijs/pixel-art-xl"
+}
 
-def load_t2i(is_img2img=False):
+def load_t2i(model_id, is_img2img=False):
     from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
     cls = StableDiffusionXLImg2ImgPipeline if is_img2img else StableDiffusionXLPipeline
     pipe = cls.from_pretrained(
-        BASE_MODEL, torch_dtype=torch.float16, use_safetensors=True, variant="fp16"
+        model_id, torch_dtype=torch.float16, use_safetensors=True, variant="fp16",
+        low_cpu_mem_usage=True
     )
     return pipe
 
-def load_video():
-    from diffusers import LTXPipeline
-    pipe = LTXPipeline.from_pretrained(LTX_MODEL, torch_dtype=torch.bfloat16)
-    try:
-        pipe.load_lora_weights(LTX_NSFW_LORA)
-    except: pass
-    return pipe
-
 @spaces.GPU(duration=100)
-def generate_t2i(prompt, neg, lora_id, lora_scale, w, h, init_img):
+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)
+    
     is_img2img = init_img is not None
-    pipe = load_t2i(is_img2img).to("cuda")
-    if lora_id and len(lora_id.strip()) > 5:
+    pipe = load_t2i(model_id, is_img2img).to("cuda")
+    
+    if lora_id:
         try:
-            pipe.load_lora_weights(lora_id.strip())
+            pipe.load_lora_weights(lora_id)
             pipe.fuse_lora(lora_scale=lora_scale)
-        except: pass
-    kwargs = {"prompt": prompt, "negative_prompt": neg, "num_inference_steps": 30, "guidance_scale": 7.0}
+        except Exception as e:
+            print(f"LoRA Error: {e}")
+            
+    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
-    else:
-        kwargs["width"], kwargs["height"] = int(w), int(h)
+        
     return pipe(**kwargs).images[0]
 
-@spaces.GPU(duration=200)
-def generate_video(prompt, init_image, lora_scale):
-    from diffusers.utils import export_to_video
-    pipe = load_video().to("cuda")
-    kwargs = {"prompt": prompt, "negative_prompt": NEG_DEFAULT, "num_frames": 49, "num_inference_steps": 30}
-    if init_image is not None:
-        kwargs["image"] = Image.fromarray(init_image).convert("RGB").resize((768, 512))
-    if lora_scale > 0:
-        kwargs["cross_attention_kwargs"] = {"scale": lora_scale}
-    output = pipe(**kwargs)
-    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-    export_to_video(output.frames[0], tmp.name, fps=24)
-    return tmp.name
-
-with gr.Blocks(title="Image Utility v2.1") as demo:
-    gr.HTML("<h1 style='text-align:center;'>🛠 Image Processing Utility v2.1.4</h1>")
+# UI DESIGN
+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>")
+    
     with gr.Tabs():
-        with gr.Tab("D-Processor (Image/T2I)"):
+        with gr.Tab("🖼 Generador de Imágenes"):
             with gr.Row():
-                with gr.Column():
-                    t2i_p = gr.Textbox(label="Input Data String", lines=3)
-                    t2i_img = gr.Image(label="Base Reference (Optional)", type="numpy")
-                    t2i_n = gr.Textbox(label="Excluded Data", value=NEG_DEFAULT)
-                    t2i_lora = gr.Textbox(label="Extension ID")
-                    t2i_ls = gr.Slider(0, 1.5, 0.8, label="Extension Weight")
+                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.Row():
-                        t2i_w = gr.Slider(512, 1024, 1024, step=64, label="X-Axis")
-                        t2i_h = gr.Slider(512, 1024, 1024, step=64, label="Y-Axis")
-                    t2i_btn = gr.Button("Execute Process", variant="primary")
-                t2i_out = gr.Image(label="Output Preview")
-            t2i_btn.click(generate_t2i, [t2i_p, t2i_n, t2i_lora, t2i_ls, t2i_w, t2i_h, t2i_img], t2i_out)
-        with gr.Tab("M-Sequence (Video)"):
-            with gr.Row():
-                with gr.Column():
-                    v_p = gr.Textbox(label="Motion Vector String", lines=3)
-                    v_img = gr.Image(label="Source Buffer", type="numpy")
-                    v_ls = gr.Slider(0, 1.5, 0.8, label="Motion Weight")
-                    v_btn = gr.Button("Process Sequence", variant="primary")
-                v_out = gr.Video(label="Sequence Output")
-            v_btn.click(generate_video, [v_p, v_img, v_ls], v_out)
+                        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")
+                    
+                    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)
 
-# server_name 0.0.0.0 es clave para evitar el error de localhost en HF
 demo.queue().launch(show_api=False, server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -4,9 +4,10 @@ fastapi==0.112.2
 starlette==0.38.2
 huggingface-hub==0.24.2
 audioop-lts
-diffusers>=0.30.0
-transformers>=4.42.0
+diffusers>=0.31.0
+transformers>=4.44.0
 accelerate>=0.33.0
+peft
 torch
 sentencepiece
 imageio[ffmpeg]