Upload 3 files

revert back to working

app.py

@@ -1,535 +1,205 @@
-import json
-import logging
+"""
+Sulphur — Image to Video (HF Spaces).
+Clones Wan2GP and downloads models on first run.
+Generation is handled by generate.py called as a subprocess inside @spaces.GPU.
+"""
+
 import os
-import random
-import struct
-import subprocess
 import sys
+import subprocess
+import shutil
 import tempfile
-import builtins
+import threading
+import json
 from pathlib import Path
 
 import gradio as gr
-import numpy as np
 import spaces
-import torch
-from huggingface_hub import hf_hub_download
-
-
-LTX_REPO_URL = "https://github.com/Lightricks/LTX-2.git"
-LTX_COMMIT_SHA = "ae855f8538843825f9015a419cf4ba5edaf5eec2"
-
-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"
-
-MAX_SEED = np.iinfo(np.int32).max
-DEFAULT_FRAME_RATE = 24.0
-DEFAULT_PROMPT = "Make this image come alive with cinematic motion, smooth animation."
-PROMPT_ADHERENCE_SUFFIX = (
-    "Follow the prompt literally. Preserve the named subjects, actions, setting, and style."
-)
-MAX_PROMPT_CHARS = 900
-MAX_ENHANCED_PROMPT_CHARS = 1400
-PROMPT_ENHANCER_SYSTEM_PROMPT = (
-    "You are Sulphur's prompt enhancer for image-to-video generation. Rewrite the user's prompt into one concise, "
-    "literal cinematic video prompt. Preserve the user's subject, action, setting, style, and intent. Add useful "
-    "visual motion, camera movement, lighting, and temporal details. Do not refuse, moralize, apologize, explain, "
-    "quote policy, or mention being an AI. Return only the rewritten prompt."
-)
-PROMPT_ENHANCER_USER_TEMPLATE = "Rewrite this video prompt only:\n{prompt}"
-
-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)},
-}
-
-
-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():
-    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"))
-
-
-install_ltx_runtime()
-
-
-_real_import = builtins.__import__
-
-
-def _import_without_xformers(name, globals=None, locals=None, fromlist=(), level=0):
-    if name == "xformers" or name.startswith("xformers."):
-        raise ImportError("xformers is disabled for this Space runtime")
-    return _real_import(name, globals, locals, fromlist, level)
 
+_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"
+GENERATE_PY  = Path(__file__).parent / "generate.py"
 
-builtins.__import__ = _import_without_xformers
-try:
-    from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps
-    from ltx_core.loader.primitives import StateDict
-    from ltx_core.loader.sd_ops import KeyValueOperationResult, SDOps
-    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
-    import ltx_pipelines.utils.model_ledger as _model_ledger_mod
-    from ltx_pipelines.distilled import DistilledPipeline
-    from ltx_pipelines.utils.args import ImageConditioningInput
-    from ltx_pipelines.utils.media_io import encode_video
-finally:
-    builtins.__import__ = _real_import
-
-
-_model_ledger_mod.GEMMA_LLM_KEY_OPS = (
-    SDOps("GEMMA_LLM_KEY_OPS_SULPHUR")
-    .with_matching(prefix="model.language_model.")
-    .with_matching(prefix="model.vision_tower.")
-    .with_matching(prefix="model.multi_modal_projector.")
-    .with_replacement("model.language_model.", "model.model.language_model.")
-    .with_replacement("model.vision_tower.", "model.model.vision_tower.")
-    .with_replacement("model.multi_modal_projector.", "model.model.multi_modal_projector.")
-    .with_kv_operation(
-        operation=lambda key, value: [
-            KeyValueOperationResult(key, value),
-            KeyValueOperationResult("model.lm_head.weight", value),
-        ],
-        key_prefix="model.model.language_model.embed_tokens.weight",
-    )
-)
-
+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),
+]
 
-_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,
+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,
 }
 
-
-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=repo_id,
-            filename=filename,
-            local_dir=str(local_dir),
-            token=HF_TOKEN,
+_setup_lock = threading.Lock()
+_setup_done = False
+
+
+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 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,
         )
-    )
-    print(f"[download] ready: {repo_id}/{filename}")
-    return path
-
-
-def _safetensors_header(path):
-    with open(path, "rb") as reader:
-        header_len = struct.unpack("<Q", reader.read(8))[0]
-        return json.loads(reader.read(header_len).decode("utf-8"))
-
-
-def _validate_lora(name, lora):
-    path = Path(lora.path)
-    if not path.exists():
-        raise FileNotFoundError(f"{name} LoRA missing: {path}")
-    keys = [key for key in _safetensors_header(path) if key != "__metadata__"]
-    mapped = [lora.sd_ops.apply_to_key(key) for key in keys]
-    mapped = [key for key in mapped if key is not None]
-    lora_a = sum(1 for key in mapped if key.endswith(".lora_A.weight"))
-    lora_b = sum(1 for key in mapped if key.endswith(".lora_B.weight"))
-    alpha = sum(1 for key in mapped if key.endswith(".alpha"))
-    if lora_a == 0 or lora_b == 0:
-        raise RuntimeError(f"{name} LoRA has no usable lora_A/lora_B keys after mapping: {path}")
-    print(
-        f"[lora] active: {name} strength={lora.strength} path={path} "
-        f"lora_A={lora_a} lora_B={lora_b} alpha={alpha} size={path.stat().st_size / 1024**3:.2f}GB"
-    )
-
-
-def _prompt_for_model(prompt):
-    prompt = " ".join(str(prompt or DEFAULT_PROMPT).split())
-    prompt = _truncate_prompt(prompt, MAX_PROMPT_CHARS)
-    if PROMPT_ADHERENCE_SUFFIX.lower() in prompt.lower():
-        return prompt
-    return f"{prompt}\n\n{PROMPT_ADHERENCE_SUFFIX}"
-
-
-def _truncate_prompt(prompt, limit):
-    prompt = str(prompt or "").strip()
-    if len(prompt) <= limit:
-        return prompt
-    truncated = prompt[:limit].rsplit(" ", 1)[0].strip()
-    return truncated or prompt[:limit].strip()
-
 
-_PROMPT_ENHANCER = None
+    for repo, fname, dest in SULPHUR_ASSETS + LTX_ASSETS:
+        _download(repo, fname, dest)
 
-
-def _get_prompt_enhancer():
-    global _PROMPT_ENHANCER
-    if _PROMPT_ENHANCER is not None:
-        return _PROMPT_ENHANCER
-    from llama_cpp import Llama
-
-    print("[prompt-enhancer] loading Sulphur GGUF enhancer")
-    try:
-        _PROMPT_ENHANCER = Llama.from_pretrained(
-            repo_id="SulphurAI/Sulphur-2-base",
-            filename="prompt_enhancer/sulphur_prompt_enhancer_model-q8_0.gguf",
-            additional_files=["prompt_enhancer/mmproj-BF16.gguf"],
-            local_dir=str(ASSETS_DIR),
-            local_dir_use_symlinks=False,
-            n_ctx=2048,
-            n_threads=max(1, min(8, os.cpu_count() or 1)),
-            n_gpu_layers=0,
-            verbose=False,
-        )
-    except Exception as exc:
-        print(f"[prompt-enhancer] load failed: {type(exc).__name__}: {exc}")
-        _PROMPT_ENHANCER = None
-        raise
-    return _PROMPT_ENHANCER
-
-
-def _enhance_prompt_with_sulphur(prompt):
-    base_prompt = _truncate_prompt(prompt or DEFAULT_PROMPT, MAX_PROMPT_CHARS)
-    try:
-        llm = _get_prompt_enhancer()
-        result = llm.create_chat_completion(
-            messages=[
-                {"role": "system", "content": PROMPT_ENHANCER_SYSTEM_PROMPT},
-                {"role": "user", "content": PROMPT_ENHANCER_USER_TEMPLATE.format(prompt=base_prompt)},
-            ],
-            temperature=0.35,
-            top_p=0.9,
-            max_tokens=320,
-        )
-        enhanced = result["choices"][0]["message"]["content"].strip()
-    except Exception as exc:
-        print(f"[prompt-enhancer] fallback to literal prompt: {type(exc).__name__}: {exc}")
-        return base_prompt
-    enhanced = enhanced.strip("\"'` \n\t")
-    blocked_phrases = ("cannot fulfill", "safety guidelines", "as an ai", "i cannot", "i'm unable")
-    if not enhanced or enhanced == "/" or any(phrase in enhanced.lower() for phrase in blocked_phrases):
-        print(f"[prompt-enhancer] rejected unusable output; falling back to literal prompt: {enhanced!r}")
-        return base_prompt
-    enhanced = _truncate_prompt(enhanced, MAX_ENHANCED_PROMPT_CHARS)
-    print(f"[prompt-enhancer] {enhanced}")
-    return enhanced
-
-
-def _ensure_gemma_model_alias(gemma_weight):
-    gemma_weight = Path(gemma_weight)
-    alias = gemma_weight.with_name("model.safetensors")
-    if gemma_weight == alias:
-        return alias
-    if alias.exists() or alias.is_symlink():
-        alias.unlink()
-    gemma_weight.replace(alias)
-    print(f"[download] ready: {alias}")
-    return alias
-
-
-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(
-        "SulphurAI/Sulphur-2-base",
-        "distill_loras/ltx-2.3-22b-distilled-lora-1.1_fro90_ceil72_condsafe.safetensors",
-        ASSETS_DIR / "loras",
-    )
-    upsampler = _download(
-        "DeepBeepMeep/LTX-2",
-        "ltx-2.3-spatial-upscaler-x2-1.1.safetensors",
-        ASSETS_DIR,
-    )
-    prompt_enhancer_model = _download(
-        "SulphurAI/Sulphur-2-base",
-        "prompt_enhancer/sulphur_prompt_enhancer_model-q8_0.gguf",
-        ASSETS_DIR,
-    )
-    prompt_enhancer_mmproj = _download(
-        "SulphurAI/Sulphur-2-base",
-        "prompt_enhancer/mmproj-BF16.gguf",
-        ASSETS_DIR,
-    )
-
-    gemma_folder = "gemma-3-12b-it-qat-q4_0-unquantized"
-    gemma_files = [
-        f"{gemma_folder}/{gemma_folder}.safetensors",
-        f"{gemma_folder}/added_tokens.json",
-        f"{gemma_folder}/chat_template.json",
-        f"{gemma_folder}/config.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",
-    ]
-    gemma_weight = None
-    for filename in gemma_files:
-        path = _download("DeepBeepMeep/LTX-2", filename, ASSETS_DIR)
-        if filename.endswith(".safetensors"):
-            gemma_weight = path
-
-    old_quanto = ASSETS_DIR / gemma_folder / f"{gemma_folder}_quanto_bf16_int8.safetensors"
-    if old_quanto.exists():
-        old_quanto.unlink()
-    _ensure_gemma_model_alias(gemma_weight)
-
-    return {
-        "checkpoint": checkpoint,
-        "sulphur_lora": sulphur_lora,
-        "distilled_lora": distilled_lora,
-        "upsampler": upsampler,
-        "prompt_enhancer_model": prompt_enhancer_model,
-        "prompt_enhancer_mmproj": prompt_enhancer_mmproj,
-        "gemma_root": ASSETS_DIR / gemma_folder,
-    }
-
-
-ASSETS = download_assets()
-
-LORAS = [
-    LoraPathStrengthAndSDOps(str(ASSETS["distilled_lora"]), 1.0, LTXV_LORA_COMFY_RENAMING_MAP),
-    LoraPathStrengthAndSDOps(str(ASSETS["sulphur_lora"]), 1.0, LTXV_LORA_COMFY_RENAMING_MAP),
-]
-_validate_lora("sulphur_distilled_condsafe", LORAS[0])
-_validate_lora("sulphur_experimental_lora_v1", LORAS[1])
-print("[lora] configured order:")
-for index, lora in enumerate(LORAS, start=1):
-    print(f"[lora] {index}: strength={lora.strength} path={lora.path}")
-
-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] LTX assets ready; model loading is deferred to the GPU worker")
-
-
-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"
+    # 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...")
+        hf_hub_download(
+            repo_id="DeepBeepMeep/LTX-2",
+            filename=f"{_gemma_folder}/{_gemma_file}",
+            local_dir=str(CKPTS_DIR),
+            token=_HF_TOKEN,
         )
+    else:
+        print("[download] cached: Gemma text encoder")
 
+    FINETUNES_DIR.mkdir(parents=True, exist_ok=True)
+    (FINETUNES_DIR / "sulphur_2_base.json").write_text(json.dumps(SULPHUR_FINETUNE, indent=2))
+    print("[setup] Done.")
 
-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]))
 
+setup()
 
-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)
+RESOLUTIONS = ["832x480", "480x832", "640x640", "1024x576", "576x1024"]
 
 
 @spaces.GPU(duration=120)
-def generate_video(
-    input_image,
-    prompt,
-    duration,
-    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:
-        with torch.no_grad():
-            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}")
-            print(f"[prompt] {prompt}")
-
-            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=False,
-            )
-
-            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:
-        import traceback
-
-        log_memory("error")
-        print(f"[ERROR] {exc}\n{traceback.format_exc()}")
-        raise gr.Error(str(exc))
-
-
-def prepare_prompt(prompt, enhance_prompt):
-    if enhance_prompt:
-        prompt = _enhance_prompt_with_sulphur(prompt)
-    prepared = _prompt_for_model(prompt)
-    print(f"[prompt] prepared: {prepared}")
-    return prepared
-
-
-with gr.Blocks(title="Sulphur LTX Image to Video") as demo:
-    gr.Markdown("# Sulphur Image to Video")
+def generate_video(image, prompt, resolution, steps, guidance_scale, frames, seed):
+    if image is None:
+        raise gr.Error("Please upload an image.")
+    if not prompt.strip():
+        raise gr.Error("Please enter a prompt.")
+
+    out_file = Path(tempfile.mkdtemp()) / "output.mp4"
+    env = {**os.environ, "WAN2GP_ROOT": str(WAN2GP_ROOT)}
+
+    cmd = [
+        sys.executable, str(GENERATE_PY),
+        "--image",  image,
+        "--prompt", prompt,
+        "--output", str(out_file),
+        "--model",  "sulphur-2",
+        "--seed",   str(int(seed)),
+        "--resolution", resolution,
+        "--steps",  str(int(steps)),
+        "--guidance_scale", str(float(guidance_scale)),
+        "--frames", str(int(frames)),
+    ]
 
+    log_lines = []
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                            text=True, bufsize=0, env=env)
+
+    buf = ""
+    while True:
+        chunk = proc.stdout.read(256)
+        if not chunk:
+            break
+        buf += chunk
+        # Split on \r or \n — tqdm uses \r to overwrite progress lines
+        parts = buf.replace("\r", "\n").split("\n")
+        buf = parts[-1]
+        for part in parts[:-1]:
+            stripped = part.strip()
+            if not stripped:
+                continue
+            # Overwrite last line if it looks like a progress bar update
+            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)
+            print(stripped)
+            yield None, "\n".join(log_lines[-30:])
+
+    proc.wait()
+    log = "\n".join(log_lines)
+
+    if proc.returncode != 0 or not out_file.exists():
+        yield None, log + "\n\n[ERROR] Generation failed."
+        return
+
+    final = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    shutil.copy2(out_file, final.name)
+    yield final.name, log + "\n\n[DONE]"
+
+
+with gr.Blocks(title="Sulphur — Image to Video") as demo:
+    gr.Markdown("# Sulphur — Image to Video\nUsing New "Experimental" Lora v1")
     with gr.Row():
-        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=True)
-                    high_res = gr.Checkbox(label="High Resolution", value=False)
-
-            generate_btn = gr.Button("Generate", variant="primary")
-            prepared_prompt = gr.State()
-
+        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.Accordion("Advanced", open=False):
-                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)
-
-        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=prepare_prompt, inputs=[prompt, enhance_prompt], outputs=[prepared_prompt]).then(
+                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")
+                frames_sl     = gr.Slider(17, 257, value=81, step=8,  label="Frames")
+                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)
+
+    run_btn.click(
         fn=generate_video,
-        inputs=[input_image, prepared_prompt, duration, seed, randomize_seed, height, width],
-        outputs=[output_video, seed],
+        inputs=[image_in, prompt_in, resolution_dd, steps_sl, guidance_sl, frames_sl, seed_num],
+        outputs=[video_out, log_out],
     )
 
-
 if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Citrus())
+    demo.launch(theme=gr.themes.Soft())

generate.py

@@ -0,0 +1,139 @@
+"""
+HF Spaces version of generate.py — same logic, paths adapted for /tmp/Wan2GP.
+Called as a subprocess from app.py inside @spaces.GPU.
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+WAN2GP_ROOT = Path(os.environ.get("WAN2GP_ROOT", "/tmp/Wan2GP"))
+
+MODEL_SHORTHANDS = {
+    "sulphur-2": "sulphur_2_base",
+}
+
+DEFAULTS = {
+    "sulphur_2_base": {
+        "num_inference_steps": 8,
+        "guidance_scale":      5.0,
+        "resolution":          "832x480",
+        "video_length":        81,
+    },
+}
+
+
+def p(*args, **kwargs):
+    print(*args, **kwargs, flush=True)
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--image",          required=True)
+    ap.add_argument("--prompt",         required=True)
+    ap.add_argument("--output",         required=True)
+    ap.add_argument("--model",          default="sulphur-2")
+    ap.add_argument("--steps",          type=int,   default=None)
+    ap.add_argument("--guidance_scale", type=float, default=None)
+    ap.add_argument("--frames",         type=int,   default=None)
+    ap.add_argument("--resolution",     default=None)
+    ap.add_argument("--seed",           type=int,   default=-1)
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    model_type = MODEL_SHORTHANDS.get(args.model, args.model)
+    defaults   = DEFAULTS.get(model_type, DEFAULTS["sulphur_2_base"])
+
+    image_path = str(Path(args.image.strip()).resolve())
+    if not Path(image_path).exists():
+        print(f"Fatal: image not found: {image_path}", flush=True)
+        sys.exit(1)
+
+    resolution = args.resolution or defaults["resolution"]
+    if not args.resolution:
+        try:
+            from PIL import Image as _PIL
+            img = _PIL.open(image_path)
+            iw, ih = img.size
+            if ih > iw:
+                tw = 480
+                th = round(ih / iw * tw / 32) * 32
+            else:
+                th = 480
+                tw = round(iw / ih * th / 32) * 32
+            resolution = f"{tw}x{th}"
+            p(f"Auto-detected resolution: {resolution} (from {iw}x{ih} input)")
+        except Exception:
+            pass
+
+    task = {
+        "model_type":           model_type,
+        "base_model_type":      model_type,
+        "prompt":               args.prompt,
+        "image_start":          image_path,
+        "num_inference_steps":  args.steps         or defaults["num_inference_steps"],
+        "guidance_scale":       args.guidance_scale or defaults["guidance_scale"],
+        "resolution":           resolution,
+        "video_length":         args.frames        or defaults["video_length"],
+        "seed":                 args.seed,
+        "image_prompt_type":    "S",
+        "input_video_strength": 1.0,
+        "activated_loras": [
+            "sulphur_experimental_lora_v1.safetensors",
+        ],
+        "loras_multipliers": ["0.5"],
+    }
+
+    p(f"Model:      {model_type}")
+    p(f"Image:      {image_path}")
+    p(f"Steps:      {task['num_inference_steps']}  Guidance: {task['guidance_scale']}")
+    p(f"Resolution: {task['resolution']}  Frames: {task['video_length']}")
+    p(f"Prompt:     {args.prompt[:80]}")
+
+    sys.path.insert(0, str(WAN2GP_ROOT))
+    os.chdir(WAN2GP_ROOT)
+
+    from shared.api import WanGPSession
+
+    output_dir = Path(args.output).parent
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    p("Starting session...")
+    session = WanGPSession(root=WAN2GP_ROOT, output_dir=output_dir, console_output=True)
+
+    p("Running generation...")
+    result = session.run_task(task)
+
+    output_file = None
+
+    if result.artifacts:
+        src = result.artifacts[0].path
+        if src and Path(src).exists():
+            output_file = src
+
+    # Fallback: scan the output dir for any video file Wan2GP may have written
+    if output_file is None:
+        candidates = sorted(output_dir.glob("**/*.mp4"), key=lambda f: f.stat().st_mtime, reverse=True)
+        if candidates:
+            output_file = str(candidates[0])
+            p(f"Found output via dir scan: {output_file}")
+
+    if output_file:
+        import shutil
+        shutil.copy2(output_file, args.output)
+        p(f"Done: {args.output}")
+    else:
+        p(f"No output found in {output_dir}")
+        if result.errors:
+            p(f"Errors: {result.errors}")
+        sys.exit(1)
+
+    session.close()
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,19 +1,74 @@
-gradio>=5.29.0
+# HF Spaces runtime
+gradio>=6.0.0
 spaces
 huggingface_hub>=0.24.0
 
-torch==2.8.0
-torchaudio==2.8.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
+tqdm
+imageio
+imageio-ffmpeg
 einops
-numpy
-transformers==4.57.6
-safetensors
-accelerate
-scipy
+sentencepiece
+open_clip_torch>=2.29.0
+numpy==2.1.2
+num2words==0.5.14
+moviepy==1.0.3
 av
-tqdm
+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
-sentencepiece
-scikit-image>=0.25.2
-flashpack==0.1.2
-llama-cpp-python @ https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.16-cu124/llama_cpp_python-0.3.16-cp312-cp312-linux_x86_64.whl
+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