Replace Wan2GP wrapper with direct LTX pipeline

app.py

@@ -1,453 +1,390 @@
-"""
-Sulphur — Image to Video (HF Spaces).
-Clones Wan2GP and downloads models on first run.
-WanGPSession is created once on the first GPU call and kept alive so the model
-stays in memory — subsequent generations skip the full reload.
-"""
-
-import io
+import json
+import logging
 import os
-import sys
-import queue
+import random
+import struct
 import subprocess
-import shutil
+import sys
 import tempfile
-import threading
-import json
-import time
 from pathlib import Path
 
+os.environ["TORCH_COMPILE_DISABLE"] = "1"
+os.environ["TORCHDYNAMO_DISABLE"] = "1"
+
 import gradio as gr
+import numpy as np
 import spaces
+import torch
+from huggingface_hub import hf_hub_download
 
-_HF_TOKEN    = os.environ.get("HF_TOKEN")
-_PERSISTENT  = Path("/data") if Path("/data").exists() else Path(tempfile.gettempdir())
-WAN2GP_ROOT  = _PERSISTENT / "Wan2GP"
-CKPTS_DIR    = WAN2GP_ROOT / "ckpts"
-LORAS_DIR    = WAN2GP_ROOT / "loras" / "ltx2"
-FINETUNES_DIR = WAN2GP_ROOT / "finetunes"
-UPLOADS_DIR  = _PERSISTENT / "sulphur_uploads"
 
-SULPHUR_ASSETS = [
-    ("SulphurAI/Sulphur-2-base", "sulphur_distil_bf16.safetensors", CKPTS_DIR),
-]
-LTX_ASSETS = [
-    ("SulphurAI/Sulphur-2-base", "experimental/sulphur_experimental_lora_v1.safetensors", LORAS_DIR),
-    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b-distilled-lora-384.safetensors",     LORAS_DIR),
-    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_vae.safetensors",                    CKPTS_DIR),
-    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_text_embedding_projection.safetensors", CKPTS_DIR),
-    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_embeddings_connector.safetensors",   CKPTS_DIR),
-]
+LTX_REPO_URL = "https://github.com/Lightricks/LTX-2.git"
+LTX_COMMIT_SHA = "ae855f8538843825f9015a419cf4ba5edaf5eec2"
 
-WAN2GP_SHARED_ASSETS = [
-    "pose/dw-ll_ucoco_384.onnx",
-    "pose/yolox_l.onnx",
-    "scribble/netG_A_latest.pth",
-    "flow/raft-things.pth",
-    "depth/depth_anything_v2_vitl.pth",
-    "wav2vec/config.json",
-    "wav2vec/feature_extractor_config.json",
-    "wav2vec/model.safetensors",
-    "wav2vec/preprocessor_config.json",
-    "wav2vec/special_tokens_map.json",
-    "wav2vec/tokenizer_config.json",
-    "wav2vec/vocab.json",
-    "chinese-wav2vec2-base/config.json",
-    "chinese-wav2vec2-base/pytorch_model.bin",
-    "chinese-wav2vec2-base/preprocessor_config.json",
-    "roformer/model_bs_roformer_ep_317_sdr_12.9755.ckpt",
-    "roformer/model_bs_roformer_ep_317_sdr_12.9755.yaml",
-    "roformer/download_checks.json",
-    "pyannote/pyannote_model_wespeaker-voxceleb-resnet34-LM.bin",
-    "pyannote/pytorch_model_segmentation-3.0.bin",
-    "det_align/detface.pt",
-    "rife4.26.pkl",
-    "mask/sam_vit_h_4b8939_fp16.safetensors",
-    "mask/matanyone.safetensors",
-    "mask/config.json",
-]
+HF_TOKEN = os.environ.get("HF_TOKEN")
+PERSISTENT = Path("/data") if Path("/data").exists() else Path(tempfile.gettempdir())
+ASSETS_DIR = PERSISTENT / "sulphur_ltx"
+LTX_REPO_DIR = PERSISTENT / "LTX-2"
+OUTPUT_DIR = PERSISTENT / "sulphur_outputs"
 
-LTX_RUNTIME_ASSETS = [
-    "ltx-2.3-spatial-upscaler-x2-1.1.safetensors",
-    "ltx-2.3-temporal-upscaler-x2-1.0.safetensors",
-    "ltx-2.3-22b_audio_vae.safetensors",
-    "ltx-2.3-22b_vocoder.safetensors",
-    "gemma-3-12b-it-qat-q4_0-unquantized/added_tokens.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/chat_template.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/config_light.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/generation_config.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/preprocessor_config.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/processor_config.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/special_tokens_map.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/tokenizer.json",
-    "gemma-3-12b-it-qat-q4_0-unquantized/tokenizer.model",
-    "gemma-3-12b-it-qat-q4_0-unquantized/tokenizer_config.json",
-]
+MAX_SEED = np.iinfo(np.int32).max
+DEFAULT_FRAME_RATE = 24.0
+DEFAULT_PROMPT = "Make this image come alive with cinematic motion, smooth animation."
 
-SULPHUR_FINETUNE = {
-    "model": {
-        "name": "Sulphur 2 Base",
-        "visible": True,
-        "architecture": "ltx2_22B",
-        "parent_model_type": "ltx2_22B",
-        "description": "LTX-2.3 fine-tuned i2v. Distilled checkpoint.",
-        # Full distilled model — do NOT also preload the rank-768 LoRA (README: use one or the other)
-        "URLs": [str(CKPTS_DIR / "sulphur_distil_bf16.safetensors")],
-        "preload_URLs": [],
-    },
-    "num_inference_steps": 8,
-    "video_length": 81,
-    "resolution": "832x480",
-    "guidance_scale": 3.5,
-    "alt_guidance_scale": 3.5,
+RESOLUTIONS = {
+    "high": {"16:9": (1536, 1024), "9:16": (1024, 1536), "1:1": (1024, 1024)},
+    "low": {"16:9": (768, 512), "9:16": (512, 768), "1:1": (768, 768)},
 }
 
-_setup_lock = threading.Lock()
-_setup_done = False
-
-_session      = None
-_session_lock = threading.Lock()
-
-WAN2GP_PROFILE = os.environ.get("WAN2GP_PROFILE", "1")
-WAN2GP_PRELOAD_MB = os.environ.get("WAN2GP_PRELOAD_MB", "0")
-WAN2GP_PERC_RESERVED_MEM_MAX = os.environ.get("WAN2GP_PERC_RESERVED_MEM_MAX", "0.49")
-
-
-def _download(repo_id, filename, dest_dir):
-    from huggingface_hub import hf_hub_download
-    dest_dir.mkdir(parents=True, exist_ok=True)
-    dest = dest_dir / Path(filename).name  # flat — strip any subfolder
-    if dest.exists():
-        print(f"[download] cached: {dest.name}")
-        return
-    print(f"[download] {repo_id}/{filename}")
-    hf_hub_download(repo_id=repo_id, filename=filename,
-                    local_dir=str(dest_dir), token=_HF_TOKEN)
-    # hf_hub_download preserves subfolder structure; flatten to dest_dir root
-    downloaded = dest_dir / filename
-    if downloaded.exists() and not dest.exists():
-        shutil.move(str(downloaded), str(dest))
-
-
-def _download_preserve(repo_id, filename, dest_root):
-    from huggingface_hub import hf_hub_download
-    dest = dest_root / filename
-    if dest.exists():
-        print(f"[download] cached: {filename}")
-        return
-    print(f"[download] {repo_id}/{filename}")
-    hf_hub_download(repo_id=repo_id, filename=filename,
-                    local_dir=str(dest_root), token=_HF_TOKEN)
-
-
-def setup():
-    global _setup_done
-    with _setup_lock:
-        if _setup_done:
-            return
-        _setup_done = True
-
-    if not (WAN2GP_ROOT / "shared" / "api.py").exists():
-        WAN2GP_ROOT.mkdir(parents=True, exist_ok=True)
-        print("[setup] Cloning Wan2GP...")
-        subprocess.run(
-            ["git", "clone", "--depth=1",
-             "https://github.com/deepbeepmeep/Wan2GP.git", str(WAN2GP_ROOT)],
-            check=True,
-        )
 
-    for repo, fname, dest in SULPHUR_ASSETS + LTX_ASSETS:
-        _download(repo, fname, dest)
+def _run(cmd, cwd=None, check=True):
+    print("[setup]", " ".join(str(part) for part in cmd))
+    return subprocess.run(cmd, cwd=cwd, check=check)
+
+
+def install_ltx_runtime():
+    _run([sys.executable, "-m", "pip", "install", "xformers==0.0.32.post2", "--no-build-isolation"], check=False)
+
+    if not (LTX_REPO_DIR / ".git").exists():
+        LTX_REPO_DIR.parent.mkdir(parents=True, exist_ok=True)
+        if LTX_REPO_DIR.exists():
+            raise RuntimeError(f"{LTX_REPO_DIR} exists but is not a git checkout")
+        _run(["git", "init", str(LTX_REPO_DIR)])
+        _run(["git", "remote", "add", "origin", LTX_REPO_URL], cwd=LTX_REPO_DIR)
+
+    _run(["git", "fetch", "--depth", "1", "origin", LTX_COMMIT_SHA], cwd=LTX_REPO_DIR)
+    _run(["git", "checkout", LTX_COMMIT_SHA], cwd=LTX_REPO_DIR)
+
+    _run(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--force-reinstall",
+            "--no-deps",
+            "-e",
+            str(LTX_REPO_DIR / "packages" / "ltx-core"),
+            "-e",
+            str(LTX_REPO_DIR / "packages" / "ltx-pipelines"),
+        ]
+    )
+
+    sys.path.insert(0, str(LTX_REPO_DIR / "packages" / "ltx-pipelines" / "src"))
+    sys.path.insert(0, str(LTX_REPO_DIR / "packages" / "ltx-core" / "src"))
+
 
-    for fname in WAN2GP_SHARED_ASSETS:
-        _download_preserve("DeepBeepMeep/Wan2.1", fname, CKPTS_DIR)
+install_ltx_runtime()
 
-    for fname in LTX_RUNTIME_ASSETS:
-        _download_preserve("DeepBeepMeep/LTX-2", fname, CKPTS_DIR)
+torch._dynamo.config.suppress_errors = True
+torch._dynamo.config.disable = True
 
-    # Gemma text encoder — must stay in its subfolder (Wan2GP looks there by name)
-    _gemma_folder = "gemma-3-12b-it-qat-q4_0-unquantized"
-    _gemma_file = f"{_gemma_folder}_quanto_bf16_int8.safetensors"
-    gemma_dest = CKPTS_DIR / _gemma_folder / _gemma_file
-    if not gemma_dest.exists():
-        from huggingface_hub import hf_hub_download
-        print("[download] Gemma text encoder...")
+from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps
+from ltx_core.loader.primitives import StateDict
+from ltx_core.loader.sft_loader import SafetensorsStateDictLoader
+from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number
+from ltx_core.quantization import QuantizationPolicy
+from ltx_pipelines.distilled import DistilledPipeline
+from ltx_pipelines.utils.args import ImageConditioningInput
+from ltx_pipelines.utils.media_io import encode_video
+
+
+try:
+    from ltx_core.model.transformer import attention as _attn_mod
+    from xformers.ops import memory_efficient_attention as _memory_efficient_attention
+
+    _attn_mod.memory_efficient_attention = _memory_efficient_attention
+    print("[ATTN] xformers memory_efficient_attention enabled")
+except Exception as exc:
+    print(f"[ATTN] xformers patch failed: {type(exc).__name__}: {exc}")
+
+try:
+    from xformers.ops.fmha import _set_use_fa3
+
+    _set_use_fa3(False)
+    print("[ATTN] xformers FA3 dispatch disabled")
+except Exception as exc:
+    print(f"[ATTN] FA3 disable failed: {type(exc).__name__}: {exc}")
+
+
+_SAFETENSORS_DTYPE_MAP = {
+    "F64": torch.float64,
+    "F32": torch.float32,
+    "F16": torch.float16,
+    "BF16": torch.bfloat16,
+    "F8_E5M2": torch.float8_e5m2,
+    "F8_E4M3": torch.float8_e4m3fn,
+    "I64": torch.int64,
+    "I32": torch.int32,
+    "I16": torch.int16,
+    "I8": torch.int8,
+    "U8": torch.uint8,
+    "BOOL": torch.bool,
+}
+
+
+def _patched_safetensors_load(self, path, sd_ops, device=None):
+    sd = {}
+    size = 0
+    dtype = set()
+    device = device or torch.device("cpu")
+    model_paths = path if isinstance(path, list | tuple) else [path]
+    for shard_path in model_paths:
+        with open(shard_path, "rb") as reader:
+            header_len = struct.unpack("<Q", reader.read(8))[0]
+            header = json.loads(reader.read(header_len).decode("utf-8"))
+            data_base = 8 + header_len
+            for name, meta in header.items():
+                if name == "__metadata__":
+                    continue
+                expected_name = name if sd_ops is None else sd_ops.apply_to_key(name)
+                if expected_name is None:
+                    continue
+                start, end = meta["data_offsets"]
+                reader.seek(data_base + start)
+                raw = reader.read(end - start)
+                tensor = torch.frombuffer(
+                    bytearray(raw), dtype=_SAFETENSORS_DTYPE_MAP[meta["dtype"]]
+                ).reshape(meta["shape"])
+                tensor = tensor.to(device=device, non_blocking=True, copy=False)
+                kvs = ((expected_name, tensor),) if sd_ops is None else sd_ops.apply_to_key_value(expected_name, tensor)
+                for key, value in kvs:
+                    size += value.nbytes
+                    dtype.add(value.dtype)
+                    sd[key] = value
+    return StateDict(sd=sd, device=device, size=size, dtype=dtype)
+
+
+SafetensorsStateDictLoader.load = _patched_safetensors_load
+print("[FUSE-PATCH] Safetensors loader uses chunked reads")
+
+logging.getLogger().setLevel(logging.INFO)
+
+
+def _download(repo_id, filename, local_dir):
+    local_dir = Path(local_dir)
+    local_dir.mkdir(parents=True, exist_ok=True)
+    path = Path(
         hf_hub_download(
-            repo_id="DeepBeepMeep/LTX-2",
-            filename=f"{_gemma_folder}/{_gemma_file}",
-            local_dir=str(CKPTS_DIR),
-            token=_HF_TOKEN,
+            repo_id=repo_id,
+            filename=filename,
+            local_dir=str(local_dir),
+            token=HF_TOKEN,
         )
-    else:
-        print("[download] cached: Gemma text encoder")
+    )
+    print(f"[download] ready: {repo_id}/{filename}")
+    return path
 
-    FINETUNES_DIR.mkdir(parents=True, exist_ok=True)
-    (FINETUNES_DIR / "sulphur_2_base.json").write_text(json.dumps(SULPHUR_FINETUNE, indent=2))
-    _write_wangp_config()
-    print("[setup] Done.")
 
-RESOLUTIONS = ["832x480", "480x832", "640x640", "1024x576", "576x1024"]
+def download_assets():
+    checkpoint = _download("SulphurAI/Sulphur-2-base", "sulphur_distil_bf16.safetensors", ASSETS_DIR)
+    sulphur_lora = _download(
+        "SulphurAI/Sulphur-2-base",
+        "experimental/sulphur_experimental_lora_v1.safetensors",
+        ASSETS_DIR / "loras",
+    )
+    distilled_lora = _download(
+        "DeepBeepMeep/LTX-2",
+        "ltx-2.3-22b-distilled-lora-384.safetensors",
+        ASSETS_DIR / "loras",
+    )
+    upsampler = _download(
+        "DeepBeepMeep/LTX-2",
+        "ltx-2.3-spatial-upscaler-x2-1.1.safetensors",
+        ASSETS_DIR,
+    )
 
+    gemma_folder = "gemma-3-12b-it-qat-q4_0-unquantized"
+    gemma_files = [
+        f"{gemma_folder}/{gemma_folder}_quanto_bf16_int8.safetensors",
+        f"{gemma_folder}/added_tokens.json",
+        f"{gemma_folder}/chat_template.json",
+        f"{gemma_folder}/config_light.json",
+        f"{gemma_folder}/generation_config.json",
+        f"{gemma_folder}/preprocessor_config.json",
+        f"{gemma_folder}/processor_config.json",
+        f"{gemma_folder}/special_tokens_map.json",
+        f"{gemma_folder}/tokenizer.json",
+        f"{gemma_folder}/tokenizer.model",
+        f"{gemma_folder}/tokenizer_config.json",
+    ]
+    for filename in gemma_files:
+        _download("DeepBeepMeep/LTX-2", filename, ASSETS_DIR)
+
+    return {
+        "checkpoint": checkpoint,
+        "sulphur_lora": sulphur_lora,
+        "distilled_lora": distilled_lora,
+        "upsampler": upsampler,
+        "gemma_root": ASSETS_DIR / gemma_folder,
+    }
 
-def _coerce_number(value, fallback):
-    try:
-        parsed = float(value)
-    except (TypeError, ValueError):
-        return fallback
-    return int(parsed) if parsed.is_integer() else parsed
 
+ASSETS = download_assets()
 
-def _write_wangp_config():
-    """Tell WanGP to preload once at runtime import and keep the model resident."""
-    config_path = WAN2GP_ROOT / "wgp_config.json"
-    try:
-        existing = json.loads(config_path.read_text()) if config_path.exists() else {}
-    except Exception:
-        existing = {}
-
-    existing.update({
-        "profile": _coerce_number(WAN2GP_PROFILE, 2),
-        "preload_model_policy": ["P"],
-        "preload_in_VRAM": _coerce_number(WAN2GP_PRELOAD_MB, 0),
-        "perc_reserved_mem_max": _coerce_number(WAN2GP_PERC_RESERVED_MEM_MAX, 0.45),
-        "transformer_filename": "sulphur_2_base",
-        "transformer_types": ["sulphur_2_base"],
-        "text_encoder_quantization": "int8",
-        "transformer_quantization": "bf16",
-        "transformer_dtype_policy": "bf16",
-        "attention_mode": existing.get("attention_mode", "sdpa"),
-        "compile": existing.get("compile", ""),
-        "vae_config": existing.get("vae_config", 0),
-        "clear_file_list": existing.get("clear_file_list", 5),
-        "UI_theme": existing.get("UI_theme", "default"),
-    })
-    config_path.write_text(json.dumps(existing, indent=2))
-
-
-def _wangp_cli_args():
-    args = [
-        "--profile", str(WAN2GP_PROFILE),
-        "--preload", str(WAN2GP_PRELOAD_MB),
-        "--perc-reserved-mem-max", str(WAN2GP_PERC_RESERVED_MEM_MAX),
-        "--lock-config",
-        "--lock-model",
-    ]
-    attention = os.environ.get("WAN2GP_ATTENTION", "").strip()
-    if attention:
-        args += ["--attention", attention]
-    return args
-
-
-setup()
-
-
-def cache_uploaded_image(image):
-    if not image:
-        return None
-    src = Path(str(image)).resolve()
-    if not src.exists():
-        raise gr.Error("Uploaded image is no longer available. Please upload it again.")
-    UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
-    suffix = src.suffix or ".png"
-    dest = UPLOADS_DIR / f"input_{time.time_ns()}{suffix}"
-    shutil.copy2(src, dest)
-    return str(dest)
-
-
-def _ensure_session():
-    """Create WanGPSession on first call; reuse on all subsequent calls."""
-    global _session
-    if _session is not None:
-        return _session
-    with _session_lock:
-        if _session is not None:
-            return _session
-        sys.path.insert(0, str(WAN2GP_ROOT))
-        os.chdir(WAN2GP_ROOT)
-        from shared.api import WanGPSession
-        out_dir = Path("/tmp/wan2gp_output")
-        out_dir.mkdir(parents=True, exist_ok=True)
-        _session = WanGPSession(
-            root=WAN2GP_ROOT,
-            output_dir=out_dir,
-            cli_args=_wangp_cli_args(),
-            console_output=True,
-        ).ensure_ready()
-    return _session
-
-
-class _QueueWriter(io.TextIOBase):
-    """Forward print() output to a queue while also passing through to real stdout."""
-    def __init__(self, q, real_out):
-        self._q = q
-        self._real = real_out
-        self._buf = ""
-
-    def write(self, s):
-        self._real.write(s)
-        self._buf += s
-        # flush complete lines (Wan2GP uses both \n and \r for progress)
-        while True:
-            for sep in ("\r\n", "\n", "\r"):
-                idx = self._buf.find(sep)
-                if idx >= 0:
-                    line = self._buf[:idx]
-                    self._buf = self._buf[idx + len(sep):]
-                    if line.strip():
-                        self._q.put(line)
-                    break
-            else:
-                break
-        return len(s)
-
-    def flush(self):
-        self._real.flush()
+LORAS = [
+    LoraPathStrengthAndSDOps(str(ASSETS["distilled_lora"]), 1.0, LTXV_LORA_COMFY_RENAMING_MAP),
+    LoraPathStrengthAndSDOps(str(ASSETS["sulphur_lora"]), 0.5, LTXV_LORA_COMFY_RENAMING_MAP),
+]
+
+pipeline = DistilledPipeline(
+    distilled_checkpoint_path=str(ASSETS["checkpoint"]),
+    spatial_upsampler_path=str(ASSETS["upsampler"]),
+    gemma_root=str(ASSETS["gemma_root"]),
+    loras=LORAS,
+    quantization=QuantizationPolicy.fp8_cast(),
+)
+
+print("[startup] Preloading LTX models")
+ledger = pipeline.model_ledger
+_transformer = ledger.transformer()
+_video_encoder = ledger.video_encoder()
+_video_decoder = ledger.video_decoder()
+_audio_decoder = ledger.audio_decoder()
+_vocoder = ledger.vocoder()
+_spatial_upsampler = ledger.spatial_upsampler()
+_text_encoder = ledger.text_encoder()
+_embeddings_processor = ledger.gemma_embeddings_processor()
+
+ledger.transformer = lambda: _transformer
+ledger.video_encoder = lambda: _video_encoder
+ledger.video_decoder = lambda: _video_decoder
+ledger.audio_decoder = lambda: _audio_decoder
+ledger.vocoder = lambda: _vocoder
+ledger.spatial_upsampler = lambda: _spatial_upsampler
+ledger.text_encoder = lambda: _text_encoder
+ledger.gemma_embeddings_processor = lambda: _embeddings_processor
+print("[startup] LTX pipeline ready")
+
+
+def log_memory(tag):
+    if torch.cuda.is_available():
+        allocated = torch.cuda.memory_allocated() / 1024**3
+        peak = torch.cuda.max_memory_allocated() / 1024**3
+        free, total = torch.cuda.mem_get_info()
+        print(
+            f"[VRAM {tag}] allocated={allocated:.2f}GB peak={peak:.2f}GB "
+            f"free={free / 1024**3:.2f}GB total={total / 1024**3:.2f}GB"
+        )
 
 
-@spaces.GPU
-def generate_video(image_path_cached, prompt, resolution, steps, guidance_scale, seconds, seed):
-    if image_path_cached is None:
-        raise gr.Error("Please upload an image.")
-    if not prompt.strip():
-        raise gr.Error("Please enter a prompt.")
-
-    frames     = int(seconds * 25 // 8) * 8 + 1
-    image_path = str(Path(str(image_path_cached)).resolve())
-    if not Path(image_path).exists():
-        raise gr.Error("Uploaded image is no longer available. Please upload it again.")
-    out_dir    = Path(tempfile.mkdtemp())
-    out_file   = out_dir / "output.mp4"
-
-    task = {
-        "model_type":           "sulphur_2_base",
-        "base_model_type":      "sulphur_2_base",
-        "prompt":               prompt,
-        "image_start":          image_path,
-        "num_inference_steps":  int(steps),
-        "guidance_scale":       float(guidance_scale),
-        "resolution":           resolution,
-        "video_length":         frames,
-        "seed":                 int(seed),
-        "image_prompt_type":    "S",
-        "input_video_strength": 1.0,
-        "activated_loras":      ["sulphur_experimental_lora_v1.safetensors"],
-        "loras_multipliers":    ["0.5"],
-    }
+def detect_aspect_ratio(image):
+    if image is None:
+        return "16:9"
+    width, height = image.size
+    ratio = width / height
+    candidates = {"16:9": 16 / 9, "9:16": 9 / 16, "1:1": 1.0}
+    return min(candidates, key=lambda key: abs(ratio - candidates[key]))
 
-    log_lines = []
-    result = None
 
-    def _append_log(line):
-        stripped = str(line or "").strip()
-        if not stripped:
-            return
-        if log_lines and ("%" in stripped or "it/s" in stripped or "step" in stripped.lower()):
-            log_lines[-1] = stripped
-        else:
-            log_lines.append(stripped)
+def update_resolution(image, high_res):
+    aspect = detect_aspect_ratio(image)
+    tier = "high" if high_res else "low"
+    width, height = RESOLUTIONS[tier][aspect]
+    return gr.update(value=width), gr.update(value=height)
 
-    _append_log("[startup] Loading WanGP session...")
-    yield None, "\n".join(log_lines[-30:])
 
+@spaces.GPU
+@torch.inference_mode()
+def generate_video(
+    input_image,
+    prompt,
+    duration,
+    enhance_prompt,
+    seed,
+    randomize_seed,
+    height,
+    width,
+    progress=gr.Progress(track_tqdm=True),
+):
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
     try:
-        session = _ensure_session()
-        _append_log("[startup] WanGP session ready. Starting generation...")
-        yield None, "\n".join(log_lines[-30:])
-
-        job = session.submit_task(task)
-        last_event_at = time.time()
-        while True:
-            event = job.events.get(timeout=0.5)
-            if event is None:
-                if job.done:
-                    break
-                if time.time() - last_event_at > 30:
-                    _append_log("[waiting] WanGP is still running...")
-                    last_event_at = time.time()
-                    yield None, "\n".join(log_lines[-30:])
-                continue
-
-            last_event_at = time.time()
-            if event.kind == "stream":
-                data = event.data
-                _append_log(getattr(data, "text", data))
-            elif event.kind == "progress":
-                progress = event.data
-                current = getattr(progress, "current_step", None)
-                total = getattr(progress, "total_steps", None)
-                phase = getattr(progress, "phase", "progress")
-                status = getattr(progress, "status", "")
-                if current is not None and total is not None:
-                    _append_log(f"[{phase}] step {current}/{total} {status}")
-                else:
-                    _append_log(f"[{phase}] {status}")
-            elif event.kind == "error":
-                _append_log(f"[ERROR] {event.data}")
-            elif event.kind == "completed":
-                result = event.data
-                break
-
-            yield None, "\n".join(log_lines[-30:])
-
-        if result is None:
-            result = job.result(timeout=1)
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+        log_memory("start")
+
+        frame_rate = DEFAULT_FRAME_RATE
+        num_frames = int(float(duration) * frame_rate) + 1
+        num_frames = ((num_frames - 1 + 7) // 8) * 8 + 1
+        height = int(height)
+        width = int(width)
+
+        print(f"[generate] {width}x{height}, frames={num_frames}, seed={current_seed}")
+
+        images = []
+        if input_image is not None:
+            OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+            input_path = OUTPUT_DIR / f"input_{current_seed}.png"
+            input_image.save(input_path)
+            images = [ImageConditioningInput(path=str(input_path), frame_idx=0, strength=1.0)]
+
+        tiling_config = TilingConfig.default()
+        chunks = get_video_chunks_number(num_frames, tiling_config)
+        log_memory("before pipeline")
+
+        video, audio = pipeline(
+            prompt=prompt,
+            seed=current_seed,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            frame_rate=frame_rate,
+            images=images,
+            tiling_config=tiling_config,
+            enhance_prompt=bool(enhance_prompt),
+        )
+
+        output_path = tempfile.mktemp(suffix=".mp4")
+        encode_video(video=video, fps=frame_rate, audio=audio, output_path=output_path, video_chunks_number=chunks)
+        log_memory("after encode")
+        return output_path, current_seed
     except Exception as exc:
-        yield None, "\n".join(log_lines) + f"\n\n[ERROR] {exc}"
-        return
-
-    output_file = None
-
-    if result and result.artifacts:
-        src = result.artifacts[0].path
-        if src and Path(src).exists():
-            output_file = str(src)
-
-    if output_file is None:
-        for search_dir in [out_dir, Path("/tmp/wan2gp_output")]:
-            candidates = sorted(search_dir.glob("**/*.mp4"),
-                                key=lambda f: f.stat().st_mtime, reverse=True)
-            if candidates:
-                output_file = str(candidates[0])
-                break
-
-    if output_file:
-        final = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-        shutil.copy2(output_file, final.name)
-        yield final.name, "\n".join(log_lines) + "\n\n[DONE]"
-    else:
-        errors = getattr(result, "errors", None)
-        yield None, "\n".join(log_lines) + f"\n\n[ERROR] No output found. Errors: {errors}"
-
-
-with gr.Blocks(title="Sulphur — Image to Video") as demo:
-    gr.Markdown("# Sulphur — Image to Video\nUsing New 'Experimental' Lora v1")
-    image_state = gr.State(None)
+        import traceback
+
+        log_memory("error")
+        print(f"[ERROR] {exc}\n{traceback.format_exc()}")
+        raise gr.Error(str(exc))
+
+
+with gr.Blocks(title="Sulphur LTX Image to Video") as demo:
+    gr.Markdown("# Sulphur Image to Video")
+
     with gr.Row():
-        with gr.Column(scale=1):
-            image_in  = gr.Image(type="filepath", label="Input Image")
-            prompt_in = gr.Textbox(label="Prompt", placeholder="Describe the motion…", lines=3)
+        with gr.Column():
+            input_image = gr.Image(label="Input Image", type="pil")
+            prompt = gr.Textbox(
+                label="Prompt",
+                value=DEFAULT_PROMPT,
+                lines=3,
+                placeholder="Describe the motion and animation...",
+            )
+            with gr.Row():
+                duration = gr.Slider(1.0, 5.0, value=3.0, step=0.1, label="Duration")
+                with gr.Column():
+                    enhance_prompt = gr.Checkbox(label="Enhance Prompt", value=False)
+                    high_res = gr.Checkbox(label="High Resolution", value=False)
+
+            generate_btn = gr.Button("Generate", variant="primary")
+
             with gr.Accordion("Advanced", open=False):
-                resolution_dd = gr.Dropdown(RESOLUTIONS, value="832x480", label="Resolution")
-                steps_sl      = gr.Slider(1, 50, value=8,   step=1,   label="Steps")
-                guidance_sl   = gr.Slider(1.0, 10.0, value=5.0, step=0.5, label="Guidance Scale")
-                seconds_sl    = gr.Slider(1, 5, value=3, step=1, label="Seconds")
-                seed_num      = gr.Number(value=-1, label="Seed (-1 = random)", precision=0)
-            run_btn = gr.Button("Generate", variant="primary")
-        with gr.Column(scale=1):
-            video_out = gr.Video(label="Output Video")
-            log_out   = gr.Textbox(label="Log", lines=10, interactive=False)
-
-    image_in.change(
-        fn=cache_uploaded_image,
-        inputs=[image_in],
-        outputs=[image_state],
-    )
+                seed = gr.Slider(0, MAX_SEED, value=10, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+                with gr.Row():
+                    width = gr.Number(label="Width", value=768, precision=0)
+                    height = gr.Number(label="Height", value=512, precision=0)
 
-    run_btn.click(
+        with gr.Column():
+            output_video = gr.Video(label="Output Video", autoplay=True)
+
+    input_image.change(fn=update_resolution, inputs=[input_image, high_res], outputs=[width, height])
+    high_res.change(fn=update_resolution, inputs=[input_image, high_res], outputs=[width, height])
+
+    generate_btn.click(
         fn=generate_video,
-        inputs=[image_state, prompt_in, resolution_dd, steps_sl, guidance_sl, seconds_sl, seed_num],
-        outputs=[video_out, log_out],
+        inputs=[input_image, prompt, duration, enhance_prompt, seed, randomize_seed, height, width],
+        outputs=[output_video, seed],
     )
 
+
 if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+    demo.launch(theme=gr.themes.Citrus())

requirements.txt

@@ -1,74 +1,16 @@
-# HF Spaces runtime
-gradio>=6.0.0
+gradio>=5.29.0
 spaces
 huggingface_hub>=0.24.0
 
-# Wan2GP deps (from requirements.txt — all packages that install on Linux)
-mmgp==3.7.6
-diffusers==0.36.0
-transformers==4.54.0
-tokenizers>=0.20.3
-accelerate>=1.1.1
+einops
+numpy
+transformers>=4.52
+safetensors
+accelerate
+scipy>=1.14
+av
 tqdm
+Pillow
 imageio
 imageio-ffmpeg
-einops
 sentencepiece
-open_clip_torch>=2.29.0
-numpy==2.1.2
-num2words==0.5.14
-moviepy==1.0.3
-av
-ffmpeg-python
-pygame>=2.1.0
-sounddevice>=0.4.0
-soundfile
-mutagen
-pyloudnorm
-librosa==0.11.0
-speechbrain==1.0.3
-openai-whisper==20250625
-audio-separator==0.36.1
-pyannote.audio==3.3.2
-loguru
-dashscope
-s3tokenizer
-conformer==0.3.2
-spacy_pkuseg
-spacy
-opencv-python-headless>=4.12.0.88
-pycocotools
-segment-anything
-rembg==2.0.65
-onnxruntime>=1.20.0
-decord
-timm
-iopath>=0.1.10
-insightface==0.7.3
-facexlib==0.3.0
-vector_quantize_pytorch==1.27.19
-omegaconf
-hydra-core
-easydict
-torchdiffeq>=0.2.5
-tensordict>=0.6.1
-peft==0.17.0
-vector-quantize-pytorch
-matplotlib
-gguf==0.17.1
-flash-linear-attention==0.4.1
-ftfy
-piexif
-nvidia-ml-py
-misaki
-gitdb==4.0.12
-gitpython==3.1.45
-stringzilla==4.0.14
-xxhash
-munch
-wetext==0.1.2
-markdown
-Pillow
-safetensors
-https://github.com/deepbeepmeep/smplfitter/releases/download/v0.2.10/smplfitter-0.2.10-py3-none-any.whl
-https://github.com/deepbeepmeep/chumpy/releases/download/v0.71/chumpy-0.71-py3-none-any.whl