Create ghostpacklora.py

ghostpacklora.py

@@ -0,0 +1,907 @@
+#!/usr/bin/env python3
+# ==========================================================
+# FILE: ghostpack.py
+# ==========================================================
+import os, sys, time, json, argparse, importlib.util, subprocess, traceback
+import torch, einops, numpy as np, gradio as gr
+from PIL import Image
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import (
+    LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer,
+    SiglipImageProcessor, SiglipVisionModel
+)
+try:
+    from diffusers_helper.hf_login import login
+    from diffusers_helper.hunyuan import (
+        encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
+    )
+    from diffusers_helper.utils import (
+        save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw,
+        resize_and_center_crop, generate_timestamp
+    )
+    from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
+    from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
+    from diffusers_helper.memory import (
+        gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation,
+        offload_model_from_device_for_memory_preservation, fake_diffusers_current_device,
+        DynamicSwapInstaller, unload_complete_models, load_model_as_complete
+    )
+    from diffusers_helper.thread_utils import AsyncStream, async_run
+    from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
+    from diffusers_helper.clip_vision import hf_clip_vision_encode
+    from diffusers_helper.bucket_tools import find_nearest_bucket
+except ImportError as e:
+    with open(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'outputs', 'install_logs.txt'), 'a') as f:
+        f.write(f"[Dependency Error] {str(e)}\n")
+    print(f"Dependency error: {str(e)}. Check outputs/install_logs.txt.")
+    sys.exit(1)
+
+try:
+    from huggingface_hub import hf_hub_download
+    from safetensors.torch import load_file
+except ImportError as e:
+    with open(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'outputs', 'install_logs.txt'), 'a') as f:
+        f.write(f"[Dependency Error] {str(e)}\n")
+    print(f"Dependency error: {str(e)}. Install huggingface_hub and safetensors: pip install huggingface_hub safetensors")
+    sys.exit(1)
+
+# ------------------------- CLI ----------------------------
+parser = argparse.ArgumentParser()
+parser.add_argument('--share', action='store_true')
+parser.add_argument('--server', type=str, default='0.0.0.0')
+parser.add_argument('--port', type=int)
+parser.add_argument('--inbrowser', action='store_true')
+parser.add_argument('--cli', action='store_true')
+args = parser.parse_args()
+
+BASE = os.path.abspath(os.path.dirname(__file__))
+os.environ['HF_HOME'] = os.path.join(BASE, 'hf_download')
+LORA_CACHE = os.path.join(BASE, 'dlora')
+os.makedirs(LORA_CACHE, exist_ok=True)
+
+# Set HF token from environment variable
+HF_TOKEN = os.getenv('HF_TOKEN', 'XXXXXXXXXXXXXXXXXXXXXXXX')
+
+if args.cli:
+    print("👻 GhostPack F1 Pro CLI\n")
+    print("python ghostpack.py           # launch UI")
+    print("python ghostpack.py --cli     # show help\n")
+    sys.exit(0)
+
+# ---------------------- Paths -----------------------------
+OUT_BASE    = os.path.join(BASE, 'outputs')
+OUT_IMG     = os.path.join(OUT_BASE, 'img')
+OUT_TMP     = os.path.join(OUT_BASE, 'tmp_vid')
+OUT_VID     = os.path.join(OUT_BASE, 'vid')
+PROMPT_LOG  = os.path.join(OUT_BASE, 'prompts.txt')
+SAVED_PROMPTS = os.path.join(OUT_BASE, 'saved_prompts.json')
+INSTALL_LOG = os.path.join(OUT_BASE, 'install_logs.txt')
+for d in (OUT_BASE, OUT_IMG, OUT_TMP, OUT_VID):
+    os.makedirs(d, exist_ok=True)
+if not os.path.exists(SAVED_PROMPTS):
+    json.dump([], open(SAVED_PROMPTS,'w'))
+if not os.path.exists(INSTALL_LOG):
+    open(INSTALL_LOG,'w').close()
+
+# ---------------- Auto-Downloader ------------------------
+def auto_download_fastvideo_lora():
+    repo_id = "Kijai/HunyuanVideo_comfy"
+    filename = "hyvideo_FastVideo_LoRA-fp8.safetensors"
+    try:
+        msg, lora_path = download_lora(repo_id, filename, HF_TOKEN)
+        return msg
+    except Exception as e:
+        with open(INSTALL_LOG, 'a') as f:
+            f.write(f"[Auto-Download Error] {repo_id}/{filename}: {str(e)}\n")
+        return f"❌ Auto-download failed: {str(e)}"
+
+# Run auto-downloader at startup
+auto_download_status = auto_download_fastvideo_lora()
+
+# ---------------- Prompt utils ---------------------------
+def get_last_prompts():
+    return json.load(open(SAVED_PROMPTS))[-5:][::-1]
+
+def save_prompt_fn(p, n):
+    if not p:
+        return "❌ No prompt"
+    data = json.load(open(SAVED_PROMPTS))
+    entry = {'prompt': p, 'negative': n}
+    if entry not in data:
+        data.append(entry)
+        json.dump(data, open(SAVED_PROMPTS,'w'))
+    return "✅ Saved"
+
+def load_prompt_fn(idx):
+    lst = get_last_prompts()
+    return lst[idx]['prompt'] if idx < len(lst) else ""
+
+# ---------------- Cleanup utils --------------------------
+def clear_temp_videos():
+    try:
+        [os.remove(os.path.join(OUT_TMP,f)) for f in os.listdir(OUT_TMP)]
+        return "✅ Temp cleared"
+    except Exception as e:
+        return f"❌ Failed to clear temp: {str(e)}"
+
+def clear_old_files():
+    try:
+        cutoff = time.time() - 7*24*3600
+        c = 0
+        for d in (OUT_TMP, OUT_IMG):
+            for f in os.listdir(d):
+                p = os.path.join(d, f)
+                if os.path.isfile(p) and os.path.getmtime(p) < cutoff:
+                    os.remove(p)
+                    c += 1
+        return f"✅ {c} old files removed"
+    except Exception as e:
+        return f"❌ Failed to clear old files: {str(e)}"
+
+def clear_images():
+    try:
+        [os.remove(os.path.join(OUT_IMG,f)) for f in os.listdir(OUT_IMG)]
+        return "✅ Images cleared"
+    except Exception as e:
+        return f"❌ Failed to clear images: {str(e)}"
+
+def clear_videos():
+    try:
+        [os.remove(os.path.join(OUT_VID,f)) for f in os.listdir(OUT_VID)]
+        return "✅ Videos cleared"
+    except Exception as e:
+        return f"❌ Failed to clear videos: {str(e)}"
+
+# ---------------- Gallery helpers ------------------------
+def list_images():
+    try:
+        return sorted(
+            [os.path.join(OUT_IMG,f) for f in os.listdir(OUT_IMG) if f.lower().endswith(('.png','.jpg'))],
+            key=os.path.getmtime
+        )
+    except Exception:
+        return []
+
+def list_videos():
+    try:
+        return sorted(
+            [os.path.join(OUT_VID,f) for f in os.listdir(OUT_VID) if f.lower().endswith('.mp4')],
+            key=os.path.getmtime
+        )
+    except Exception:
+        return []
+
+def list_loras():
+    try:
+        return sorted(
+            [os.path.join(LORA_CACHE,f) for f in os.listdir(LORA_CACHE) if f.lower().endswith('.safetensors')],
+            key=os.path.getmtime
+        )
+    except Exception:
+        return []
+
+def load_image(sel):
+    try:
+        imgs = list_images()
+        if sel in [os.path.basename(p) for p in imgs]:
+            pth = imgs[[os.path.basename(p) for p in imgs].index(sel)]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception as e:
+        return gr.update(), gr.update(value=f"❌ Error: {str(e)}")
+
+def load_video(sel):
+    try:
+        vids = list_videos()
+        if sel in [os.path.basename(p) for p in vids]:
+            pth = vids[[os.path.basename(p) for p in vids].index(sel)]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception as e:
+        return gr.update(), gr.update(value=f"❌ Error: {str(e)}")
+
+def load_lora_select(sel):
+    try:
+        loras = list_loras()
+        if sel in [os.path.basename(p) for p in loras]:
+            pth = loras[[os.path.basename(p) for p in loras].index(sel)]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception as e:
+        return gr.update(), gr.update(value=f"❌ Error: {str(e)}")
+
+def next_image_and_load(sel):
+    try:
+        imgs = list_images()
+        if not imgs:
+            return gr.update(), gr.update()
+        names = [os.path.basename(i) for i in imgs]
+        idx = (names.index(sel)+1) % len(names) if sel in names else 0
+        pth = imgs[idx]
+        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+    except Exception:
+        return gr.update(), gr.update()
+
+def next_video_and_load(sel):
+    try:
+        vids = list_videos()
+        if not vids:
+            return gr.update(), gr.update()
+        names = [os.path.basename(v) for v in vids]
+        idx = (names.index(sel)+1) % len(names) if sel in names else 0
+        pth = vids[idx]
+        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+    except Exception:
+        return gr.update(), gr.update()
+
+def next_lora_and_load(sel):
+    try:
+        loras = list_loras()
+        if not loras:
+            return gr.update(), gr.update()
+        names = [os.path.basename(l) for l in loras]
+        idx = (names.index(sel)+1) % len(names) if sel in names else 0
+        pth = loras[idx]
+        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+    except Exception:
+        return gr.update(), gr.update()
+
+def gallery_image_select(evt: gr.SelectData):
+    try:
+        imgs = list_images()
+        if evt.index is not None and evt.index < len(imgs):
+            pth = imgs[evt.index]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception:
+        return gr.update(), gr.update()
+
+def gallery_video_select(evt: gr.SelectData):
+    try:
+        vids = list_videos()
+        if evt.index is not None and evt.index < len(vids):
+            pth = vids[evt.index]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception:
+        return gr.update(), gr.update()
+
+def gallery_lora_select(evt: gr.SelectData):
+    try:
+        loras = list_loras()
+        if evt.index is not None and evt.index < len(loras):
+            pth = loras[evt.index]
+            return gr.update(value=pth), gr.update(value=os.path.basename(pth))
+        return gr.update(), gr.update()
+    except Exception:
+        return gr.update(), gr.update()
+
+# ---------------- Install status -------------------------
+def check_mod(n):
+    return importlib.util.find_spec(n) is not None
+
+def status_xformers():
+    return "✅ xformers" if check_mod("xformers") else "❌ xformers"
+
+def status_sage():
+    return "✅ sage-attn" if check_mod("sageattention") else "❌ sage-attn"
+
+def status_flash():
+    return "✅ flash-attn" if check_mod("flash_attn") else "⚠️ flash-attn"
+
+def install_pkg(pkg, warn=None):
+    try:
+        if warn:
+            print(warn)
+            time.sleep(1)
+        out = subprocess.check_output(
+            [sys.executable, "-m", "pip", "install", pkg],
+            stderr=subprocess.STDOUT, text=True
+        )
+        res = f"✅ {pkg}\n{out}\n"
+    except subprocess.CalledProcessError as e:
+        res = f"❌ {pkg}\n{e.output}\n"
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[{pkg}] {res}")
+    return res
+
+install_xformers    = lambda: install_pkg("xformers")
+install_sage_attn   = lambda: install_pkg("sage-attn")
+install_flash_attn  = lambda: install_pkg("flash-attn","⚠️ long compile")
+refresh_logs        = lambda: open(INSTALL_LOG).read()
+clear_logs          = lambda: (open(INSTALL_LOG,'w').close() or "✅ Logs cleared")
+
+# ---------------- LoRA Download and Load ------------------
+def download_lora(repo_id, filename, hf_token):
+    try:
+        lora_path = os.path.join(LORA_CACHE, filename)
+        if not os.path.exists(lora_path):
+            if get_cuda_free_memory_gb(gpu) < 2:
+                return "❌ Low VRAM (<2GB). Free up memory.", None
+            hf_hub_download(
+                repo_id=repo_id,
+                filename=filename,
+                local_dir=LORA_CACHE,
+                token=hf_token
+            )
+            with open(INSTALL_LOG, 'a') as f:
+                f.write(f"[LoRA Download] {repo_id}/{filename} downloaded to {lora_path}\n")
+        return "✅ LoRA downloaded", lora_path
+    except Exception as e:
+        with open(INSTALL_LOG, 'a') as f:
+            f.write(f"[LoRA Download Error] {repo_id}/{filename}: {str(e)}\n")
+        return f"❌ Download failed: {str(e)}", None
+
+def load_lora(transformer, lora_path, lora_weight):
+    try:
+        if lora_path and os.path.exists(lora_path):
+            if hasattr(transformer, 'load_lora_weights'):
+                transformer.load_lora_weights(
+                    lora_path,
+                    adapter_name="fastvideo",
+                    weight=lora_weight
+                )
+                with open(INSTALL_LOG, 'a') as f:
+                    f.write(f"[LoRA Load] {lora_path} loaded with standard method, weight {lora_weight}\n")
+                return "✅ LoRA loaded"
+            else:
+                # Manual LoRA loading
+                lora_weights = load_file(lora_path)
+                state_dict = transformer.state_dict()
+                for key, value in lora_weights.items():
+                    if key in state_dict:
+                        state_dict[key] = state_dict[key] + lora_weight * value.to(state_dict[key].device)
+                    else:
+                        # Try partial key matching for common transformer layers
+                        for model_key in state_dict:
+                            if key.split('.')[-1] in model_key and ('self_attn' in model_key or 'ffn' in model_key):
+                                state_dict[model_key] = state_dict[model_key] + lora_weight * value.to(state_dict[model_key].device)
+                                break
+                        else:
+                            with open(INSTALL_LOG, 'a') as f:
+                                f.write(f"[LoRA Load Warning] Key {key} not found in model state_dict\n")
+                transformer.load_state_dict(state_dict)
+                with open(INSTALL_LOG, 'a') as f:
+                    f.write(f"[LoRA Load] {lora_path} loaded manually, weight {lora_weight}\n")
+                return "✅ LoRA loaded manually"
+        return "❌ No valid LoRA path"
+    except Exception as e:
+        with open(INSTALL_LOG, 'a') as f:
+            f.write(f"[LoRA Load Error] {lora_path}: {str(e)}\n")
+        return f"⚠️ LoRA not supported, using base model: {str(e)}"
+
+def delete_lora(sel):
+    try:
+        loras = list_loras()
+        if sel in [os.path.basename(p) for p in loras]:
+            pth = loras[[os.path.basename(p) for p in loras].index(sel)]
+            os.remove(pth)
+            with open(INSTALL_LOG, 'a') as f:
+                f.write(f"[LoRA Delete] {pth} deleted\n")
+            return "✅ LoRA deleted", gr.update(choices=[os.path.basename(l) for l in list_loras()], value=None)
+        return "❌ No LoRA selected", gr.update()
+    except Exception as e:
+        return f"❌ Delete failed: {str(e)}", gr.update()
+
+# ---------------- Model load -----------------------------
+free_mem = get_cuda_free_memory_gb(gpu)
+hv       = free_mem > 60
+
+try:
+    text_encoder = LlamaModel.from_pretrained(
+        "hunyuanvideo-community/HunyuanVideo",
+        subfolder='text_encoder', torch_dtype=torch.float16, token=HF_TOKEN
+    ).cpu().eval()
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] text_encoder: {str(e)}\n")
+    raise gr.Error(f"Failed to load text_encoder: {str(e)}")
+
+try:
+    text_encoder_2 = CLIPTextModel.from_pretrained(
+        "hunyuanvideo-community/HunyuanVideo",
+        subfolder='text_encoder_2', torch_dtype=torch.float16, token=HF_TOKEN
+    ).cpu().eval()
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] text_encoder_2: {str(e)}\n")
+    raise gr.Error(f"Failed to load text_encoder_2: {str(e)}")
+
+try:
+    tokenizer = LlamaTokenizerFast.from_pretrained(
+        "hunyuanvideo-community/HunyuanVideo",
+        subfolder='tokenizer', token=HF_TOKEN
+    )
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] tokenizer: {str(e)}\n")
+    raise gr.Error(f"Failed to load tokenizer: {str(e)}")
+
+try:
+    tokenizer_2 = CLIPTokenizer.from_pretrained(
+        "hunyuanvideo-community/HunyuanVideo",
+        subfolder='tokenizer_2', token=HF_TOKEN
+    )
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] tokenizer_2: {str(e)}\n")
+    raise gr.Error(f"Failed to load tokenizer_2: {str(e)}")
+
+try:
+    vae = AutoencoderKLHunyuanVideo.from_pretrained(
+        "hunyuanvideo-community/HunyuanVideo",
+        subfolder='vae', torch_dtype=torch.float16, token=HF_TOKEN
+    ).cpu().eval()
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] vae: {str(e)}\n")
+    raise gr.Error(f"Failed to load vae: {str(e)}")
+
+try:
+    feature_extractor = SiglipImageProcessor.from_pretrained(
+        "lllyasviel/flux_redux_bfl", subfolder='feature_extractor', token=HF_TOKEN
+    )
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] feature_extractor: {str(e)}\n")
+    raise gr.Error(f"Failed to load feature_extractor: {str(e)}")
+
+try:
+    image_encoder = SiglipVisionModel.from_pretrained(
+        "lllyasviel/flux_redux_bfl",
+        subfolder='image_encoder', torch_dtype=torch.float16, token=HF_TOKEN
+    ).cpu().eval()
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] image_encoder: {str(e)}\n")
+    raise gr.Error(f"Failed to load image_encoder: {str(e)}")
+
+try:
+    transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
+        "lllyasviel/FramePack_F1_I2V_HY_20250503",
+        torch_dtype=torch.bfloat16, token=HF_TOKEN
+    ).cpu().eval()
+except Exception as e:
+    with open(INSTALL_LOG, 'a') as f:
+        f.write(f"[Model Load Error] transformer: {str(e)}\n")
+    raise gr.Error(f"Failed to load transformer: {str(e)}")
+
+if not hv:
+    vae.enable_slicing()
+    vae.enable_tiling()
+
+transformer.high_quality_fp32_output_for_inference = True
+transformer.to(dtype=torch.bfloat16)
+
+for m in (vae, image_encoder, text_encoder, text_encoder_2):
+    m.to(dtype=torch.float16)
+for m in (vae, image_encoder, text_encoder, text_encoder_2, transformer):
+    m.requires_grad_(False)
+
+if not hv:
+    DynamicSwapInstaller.install_model(transformer, device=gpu)
+    DynamicSwapInstaller.install_model(text_encoder, device=gpu)
+else:
+    for m in (text_encoder, text_encoder_2, image_encoder, vae, transformer):
+        m.to(gpu)
+
+stream = AsyncStream()
+
+# ---------------- Worker -------------------------------
+@torch.no_grad()
+def worker(img, prompt, n_p, seed, secs, win, stp, cfg, gsc, rsc, keep, tea, crf, lora_path, lora_weight, disable_prompt_mods):
+    # Download and load LoRA if specified
+    lora_msg = "No LoRA specified"
+    if lora_path:
+        try:
+            if lora_path.startswith("http") or lora_path.startswith("Kijai/"):
+                repo_id = "Kijai/HunyuanVideo_comfy"
+                filename = "hyvideo_FastVideo_LoRA-fp8.safetensors"
+                lora_msg, lora_path = download_lora(repo_id, filename, HF_TOKEN)
+                if not lora_path:
+                    raise gr.Error(lora_msg)
+            lora_msg = load_lora(transformer, lora_path, lora_weight)
+            if "⚠️" in lora_msg or "❌" in lora_msg:
+                print(lora_msg)
+            else:
+                stp = 8  # Override steps for FastVideo LoRA
+        except Exception as e:
+            with open(INSTALL_LOG, 'a') as f:
+                f.write(f"[LoRA Error] {lora_path}: {str(e)}\n")
+            lora_msg = f"⚠️ LoRA failed, using base model: {str(e)}"
+
+    # Validate prompt
+    try:
+        if not disable_prompt_mods:
+            if "stop" not in prompt.lower() and secs > 5:
+                prompt += " The subject stops moving after 5 seconds."
+            if "smooth" not in prompt.lower():
+                prompt = f"Smooth animation: {prompt}"
+            if "silent" not in prompt.lower():
+                prompt += ", silent"
+        if len(prompt.split()) > 50:
+            print("Warning: Complex prompt may slow rendering or cause instability.")
+    except Exception as e:
+        raise gr.Error(f"Prompt validation failed: {str(e)}")
+
+    # Check VRAM availability
+    if get_cuda_free_memory_gb(gpu) < 2:
+        raise gr.Error("Low VRAM (<2GB). Lower 'kee' or 'win'.")
+
+    sections = max(round((secs*30)/(win*4)), 1)
+    jid = generate_timestamp()
+    try:
+        with open(PROMPT_LOG, 'a') as f:
+            f.write(f"{jid}\t{prompt}\t{n_p}\n")
+    except Exception as e:
+        print(f"Failed to log prompt: {str(e)}")
+
+    stream.output_queue.push(('progress', (None, "", make_progress_bar_html(0, "Start"))))
+    try:
+        if not hv:
+            unload_complete_models(text_encoder, text_encoder_2, image_encoder, vae, transformer)
+            fake_diffusers_current_device(text_encoder, gpu)
+            load_model_as_complete(text_encoder_2, gpu)
+        lv, cp = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+        if cfg == 1:
+            lv_n = torch.zeros_like(lv)
+            cp_n = torch.zeros_like(cp)
+        else:
+            lv_n, cp_n = encode_prompt_conds(n_p, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+        lv, m  = crop_or_pad_yield_mask(lv, 512)
+        lv_n, m_n = crop_or_pad_yield_mask(lv_n, 512)
+        lv, cp, lv_n, cp_n = [x.to(torch.bfloat16) for x in (lv, cp, lv_n, cp_n)]
+        H, W, _ = img.shape
+        h, w    = find_nearest_bucket(H, W, 640)
+        img_np  = resize_and_center_crop(img, w, h)
+        Image.fromarray(img_np).save(os.path.join(OUT_IMG, f"{jid}.png"))
+        img_pt  = (torch.from_numpy(img_np).float()/127.5-1).permute(2,0,1)[None,:,None]
+        if not hv:
+            load_model_as_complete(vae, gpu)
+        start_lat = vae_encode(img_pt, vae)
+        if not hv:
+            load_model_as_complete(image_encoder, gpu)
+        img_emb = hf_clip_vision_encode(img_np, feature_extractor, image_encoder).last_hidden_state.to(torch.bfloat16)
+        gen = torch.Generator("cpu").manual_seed(seed)
+        hist_lat = torch.zeros((1,16,1+2+16,h//8,w//8), dtype=torch.float16).cpu()
+        hist_px = None
+        total    = 0
+        pad_seq = [3] + [2]*(sections-3) + [1,0] if sections>4 else list(reversed(range(sections)))
+        for pad in pad_seq:
+            last = pad == 0
+            if stream.input_queue.top() == "end":
+                stream.output_queue.push(("end", None))
+                return
+            pad_sz = pad * win
+            idx = torch.arange(0, sum([1,pad_sz,win,1,2,16]))[None].to(device=gpu)
+            a,b,c,d,e,f = idx.split([1,pad_sz,win,1,2,16],1)
+            clean_idx = torch.cat([a,d],1)
+            pre = start_lat.to(hist_lat)
+            post, two, four = hist_lat[:,:,:1+2+16].split([1,2,16],2)
+            clean = torch.cat([pre, post],2)
+            if not hv:
+                unload_complete_models()
+                move_model_to_device_with_memory_preservation(transformer, gpu, keep)
+            transformer.initialize_teacache(tea, stp)
+            def cb(d):
+                pv = vae_decode_fake(d["denoised"])
+                pv = (pv*255).cpu().numpy().clip(0,255).astype(np.uint8)
+                pv = einops.rearrange(pv, "b c t h w -> (b h) (t w) c")
+                cur = d["i"]+1
+                stream.output_queue.push(('progress', (pv, f"{cur}/{stp}", make_progress_bar_html(int(100*cur/stp), f"{cur}/{stp}"))))
+                if stream.input_queue.top()=="end":
+                    stream.output_queue.push(("end", None))
+                    raise KeyboardInterrupt
+            new_lat = sample_hunyuan(
+                transformer=transformer, sampler="unipc", width=w, height=h, frames=win*4-3,
+                real_guidance_scale=cfg, distilled_guidance_scale=gsc, guidance_rescale=rsc,
+                num_inference_steps=stp, generator=gen,
+                prompt_embeds=lv, prompt_embeds_mask=m, prompt_poolers=cp,
+                negative_prompt_embeds=lv_n, negative_prompt_embeds_mask=m_n, negative_prompt_poolers=cp_n,
+                device=gpu, dtype=torch.bfloat16, image_embeddings=img_emb,
+                latent_indices=c, clean_latents=clean, clean_latent_indices=clean_idx,
+                clean_latents_2x=two, clean_latent_2x_indices=e,
+                clean_latents_4x=four, clean_latent_4x_indices=f, callback=cb
+            )
+            if last:
+                new_lat = torch.cat([start_lat.to(new_lat), new_lat],2)
+            total += new_lat.shape[2]
+            hist_lat = torch.cat([new_lat.to(hist_lat), hist_lat],2)
+            if not hv:
+                offload_model_from_device_for_memory_preservation(transformer, gpu, 8)
+                load_model_as_complete(vae, gpu)
+            real = hist_lat[:,:,:total]
+            if hist_px is None:
+                hist_px = vae_decode(real, vae).cpu()
+            else:
+                overlap = win*4-3
+                curr = vae_decode(real[:,:,:win*2], vae).cpu()
+                hist_px = soft_append_bcthw(curr, hist_px, overlap)
+            if not hv:
+                unload_complete_models()
+            tmp = os.path.join(OUT_TMP, f"{jid}_{total}.mp4")
+            save_bcthw_as_mp4(hist_px, tmp, fps=30, crf=crf)
+            stream.output_queue.push(('file', tmp))
+            if last:
+                fin = os.path.join(OUT_VID, f"{jid}_{total}.mp4")
+                os.replace(tmp, fin)
+                stream.output_queue.push(('complete', fin))
+                break
+    except Exception as e:
+        traceback.print_exc()
+        with open(INSTALL_LOG, 'a') as f:
+            f.write(f"[Worker Error] {str(e)}\n")
+        stream.output_queue.push(("end", None))
+    return lora_msg
+
+# ---------------- Process Function -----------------------
+@torch.no_grad()
+def process(img, prm, npr, sd, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, lora_path, lora_weight, disable_prompt_mods):
+    global stream
+    if img is None:
+        raise gr.Error("Upload an image")
+    yield None, None, "", "", gr.update(interactive=False), gr.update(interactive=True), gr.update()
+    stream = AsyncStream()
+    lora_msg = async_run(worker, img, prm, npr, sd, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, lora_path, lora_weight, disable_prompt_mods)
+    out, log = None, ""
+    while True:
+        flag, data = stream.output_queue.next()
+        if flag == "file":
+            out = data
+            yield out, gr.update(), gr.update(), log, gr.update(interactive=False), gr.update(interactive=True), gr.update(value=lora_msg)
+        if flag == "progress":
+            pv, desc, html = data
+            log = desc
+            yield gr.update(), gr.update(visible=True, value=pv), desc, html, gr.update(interactive=False), gr.update(interactive=True), gr.update(value=lora_msg)
+        if flag in ("complete", "end"):
+            yield out, gr.update(visible=False), gr.update(), "", gr.update(interactive=True), gr.update(interactive=False), gr.update(value=lora_msg)
+            break
+
+def end_process():
+    stream.input_queue.push("end")
+
+# ------------------- UI ------------------------------
+quick_prompts = [
+    ["Smooth animation: A character waves for 3 seconds, then stands still for 2 seconds, static camera, silent."],
+    ["Smooth animation: A character moves for 5 seconds, static camera, silent."]
+]
+css = make_progress_bar_css() + """
+.orange-button{background:#ff6200;color:#fff;border-color:#ff6200;}
+.load-button{background:#4CAF50;color:#fff;border-color:#4CAF50;margin-left:10px;}
+.big-setting-button{background:#0066cc;color:#fff;border:none;padding:14px 24px;font-size:18px;width:100%;border-radius:6px;margin:8px 0;}
+.styled-dropdown{width:250px;padding:5px;border-radius:4px;}
+.viewer-column{width:100%;max-width:900px;margin:0 auto;}
+.media-preview img,.media-preview video{max-width:100%;height:380px;object-fit:contain;border:1px solid #444;border-radius:6px;}
+.media-container{display:flex;gap:20px;align-items:flex-start;}
+.control-box{min-width:220px;}
+.control-grid{display:grid;grid-template-columns:1fr 1fr;gap:10px;}
+.image-gallery{display:grid!important;grid-template-columns:repeat(auto-fit,minmax(300px,1fr))!important;gap:10px;padding:10px!important;overflow-y:auto!important;max-height:360px!important;}
+.image-gallery .gallery-item{padding:10px;height:360px!important;width:300px!important;}
+.image-gallery img{object-fit:contain;height:360px!important;width:300px!important;}
+.video-gallery{display:grid!important;grid-template-columns:repeat(auto-fit,minmax(300px,1fr))!important;gap:10px;padding:10px!important;overflow-y:auto!important;max-height:360px!important;}
+.video-gallery .gallery-item{padding:10px;height:360px!important;width:300px!important;}
+.video-gallery video{object-fit:contain;height:360px!important;width:300px!important;}
+.lora-gallery{display:grid!important;grid-template-columns:repeat(auto-fit,minmax(300px,1fr))!important;gap:10px;padding:10px!important;overflow-y:auto!important;max-height:360px!important;}
+.lora-gallery .gallery-item{padding:10px;height:360px!important;width:300px!important;}
+.lora-gallery .gallery-item div{text-align:center;font-size:16px;color:#fff;}
+"""
+
+blk = gr.Blocks(css=css).queue()
+with blk:
+    gr.Markdown("# 👻 GhostPack F1 Pro")
+    with gr.Tabs():
+
+        with gr.TabItem("👻 Generate"):
+            with gr.Row():
+                with gr.Column():
+                    img_in = gr.Image(sources="upload", type="numpy", label="Image", height=320)
+                    prm    = gr.Textbox(label="Prompt")
+                    npr    = gr.Textbox(label="Negative Prompt", value="low quality, blurry, speaking, talking, moaning, vocalizing, lip movement, mouth animation, sound, dialogue, speech, whispering, shouting, lip sync, facial animation, expressive face, verbal expression, animated mouth")
+                    save_msg = gr.Markdown("")
+                    lora_path = gr.Textbox(
+                        label="FastVideo LoRA Path or HF Repo",
+                        value="Kijai/HunyuanVideo_comfy",
+                        placeholder="e.g., Kijai/HunyuanVideo_comfy/hyvideo_FastVideo_LoRA-fp8.safetensors or /path/to/hyvideo_FastVideo_LoRA-fp8.safetensors"
+                    )
+                    lora_weight = gr.Slider(label="LoRA Weight", minimum=0.5, maximum=1.5, value=1.0, step=0.1)
+                    disable_prompt_mods = gr.Checkbox(label="Disable Prompt Modifications", value=False)
+                    lora_status_gen = gr.Markdown(value=auto_download_status)
+                    btn_save = gr.Button("Save Prompt")
+                    btn1, btn2, btn3 = gr.Button("Load Most Recent"), gr.Button("Load 2nd Recent"), gr.Button("Load 3rd Recent")
+                    ds = gr.Dataset(samples=quick_prompts, label="Quick List", components=[prm])
+                    ds.click(lambda x: x[0], [ds], [prm])
+                    btn_save.click(save_prompt_fn, [prm, npr], [save_msg])
+                    btn1.click(lambda: load_prompt_fn(0), [], [prm])
+                    btn2.click(lambda: load_prompt_fn(1), [], [prm])
+                    btn3.click(lambda: load_prompt_fn(2), [], [prm])
+                    with gr.Row():
+                        b_go, b_end = gr.Button("Start"), gr.Button("End", interactive=False)
+                    with gr.Group():
+                        tea = gr.Checkbox(label="Use TeaCache", value=True)
+                        se  = gr.Number(label="Seed", value=31337, precision=0)
+                        sec = gr.Slider(label="Video Length (s)", minimum=1, maximum=120, value=5, step=0.1)
+                        win = gr.Slider(label="Latent Window", minimum=1, maximum=33, value=5, step=1)
+                        stp = gr.Slider(label="Steps", minimum=1, maximum=100, value=8, step=1)
+                        cfg = gr.Slider(label="CFG", minimum=1, maximum=32, value=1, step=0.01, visible=False)
+                        gsc = gr.Slider(label="Distilled CFG", minimum=1, maximum=32, value=5, step=0.01)
+                        rsc = gr.Slider(label="CFG Re-Scale", minimum=0, maximum=1, value=0.5, step=0.01)
+                        kee = gr.Slider(label="GPU Keep (GB)", minimum=4, maximum=free_mem, value=6, step=0.1)
+                        crf = gr.Slider(label="MP4 CRF", minimum=0, maximum=100, value=20, step=1)
+                with gr.Column():
+                    pv  = gr.Image(label="Next Latents", height=200, visible=False)
+                    vid = gr.Video(label="Finished", autoplay=True, height=500, loop=True, show_share_button=False)
+                    log_md = gr.Markdown("")
+                    bar    = gr.HTML("")
+                b_go.click(
+                    process,
+                    [img_in, prm, npr, se, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, lora_path, lora_weight, disable_prompt_mods],
+                    [vid, pv, log_md, bar, b_go, b_end, lora_status_gen]
+                )
+                b_end.click(end_process)
+
+        with gr.TabItem("🖼️ Image Gallery"):
+            with gr.Row(elem_classes="media-container"):
+                with gr.Column(scale=3):
+                    image_preview = gr.Image(
+                        label="Viewer",
+                        value=(list_images()[0] if list_images() else None),
+                        interactive=False, elem_classes="media-preview"
+                    )
+                with gr.Column(elem_classes="control-box"):
+                    image_dropdown = gr.Dropdown(
+                        choices=[os.path.basename(i) for i in list_images()],
+                        value=(os.path.basename(list_images()[0]) if list_images() else None),
+                        label="Select", elem_classes="styled-dropdown"
+                    )
+                    with gr.Row(elem_classes="control-grid"):
+                        load_btn = gr.Button("Load", elem_classes="load-button")
+                        next_btn = gr.Button("Next", elem_classes="load-button")
+                    with gr.Row(elem_classes="control-grid"):
+                        refresh_btn = gr.Button("Refresh")
+                        delete_btn  = gr.Button("Delete", elem_classes="orange-button")
+            image_gallery = gr.Gallery(
+                value=list_images(), label="Thumbnails", columns=6, height=360,
+                allow_preview=False, type="filepath", elem_classes="image-gallery"
+            )
+            load_btn.click(load_image, [image_dropdown], [image_preview, image_dropdown])
+            next_btn.click(next_image_and_load, [image_dropdown], [image_preview, image_dropdown])
+            refresh_btn.click(lambda: (
+                gr.update(choices=[os.path.basename(i) for i in list_images()],
+                          value=os.path.basename(list_images()[0]) if list_images() else None),
+                gr.update(value=list_images()[0] if list_images() else None),
+                gr.update(value=list_images())
+            ), [], [image_dropdown, image_preview, image_gallery])
+            delete_btn.click(lambda sel: (os.remove(os.path.join(OUT_IMG, sel)) if sel else None) or load_image(""),
+                             [image_dropdown], [image_preview, image_dropdown])
+            image_gallery.select(gallery_image_select, [], [image_preview, image_dropdown])
+
+        with gr.TabItem("🎬 Video Gallery"):
+            with gr.Row(elem_classes="media-container"):
+                with gr.Column(scale=3):
+                    video_preview = gr.Video(
+                        label="Viewer",
+                        value=(list_videos()[0] if list_videos() else None),
+                        autoplay=True, loop=True, interactive=False, elem_classes="media-preview"
+                    )
+                with gr.Column(elem_classes="control-box"):
+                    video_dropdown = gr.Dropdown(
+                        choices=[os.path.basename(v) for v in list_videos()],
+                        value=(os.path.basename(list_videos()[0]) if list_videos() else None),
+                        label="Select", elem_classes="styled-dropdown"
+                    )
+                    with gr.Row(elem_classes="control-grid"):
+                        load_vbtn = gr.Button("Load", elem_classes="load-button")
+                        next_vbtn = gr.Button("Next", elem_classes="load-button")
+                    with gr.Row(elem_classes="control-grid"):
+                        refresh_v = gr.Button("Refresh")
+                        delete_v  = gr.Button("Delete", elem_classes="orange-button")
+            video_gallery = gr.Gallery(
+                value=list_videos(), label="Thumbnails", columns=6, height=360,
+                allow_preview=False, type="filepath", elem_classes="video-gallery"
+            )
+            load_vbtn.click(load_video, [video_dropdown], [video_preview, video_dropdown])
+            next_vbtn.click(next_video_and_load, [video_dropdown], [video_preview, video_dropdown])
+            refresh_v.click(lambda: (
+                gr.update(choices=[os.path.basename(v) for v in list_videos()],
+                          value=os.path.basename(list_videos()[0]) if list_videos() else None),
+                gr.update(value=list_videos()[0] if list_videos() else None),
+                gr.update(value=list_videos())
+            ), [], [video_dropdown, video_preview, video_gallery])
+            delete_v.click(lambda sel: (os.remove(os.path.join(OUT_VID, sel)) if sel else None) or load_video(""),
+                            [video_dropdown], [video_preview, video_dropdown])
+            video_gallery.select(gallery_video_select, [], [video_preview, video_dropdown])
+
+        with gr.TabItem("📦 LoRA Management"):
+            with gr.Row(elem_classes="media-container"):
+                with gr.Column(scale=3):
+                    lora_status = gr.Markdown("")
+                with gr.Column(elem_classes="control-box"):
+                    lora_dropdown = gr.Dropdown(
+                        choices=[os.path.basename(l) for l in list_loras()],
+                        value=(os.path.basename(list_loras()[0]) if list_loras() else None),
+                        label="Select LoRA", elem_classes="styled-dropdown"
+                    )
+                    with gr.Row(elem_classes="control-grid"):
+                        load_lora_btn = gr.Button("Load", elem_classes="load-button")
+                        next_lora_btn = gr.Button("Next", elem_classes="load-button")
+                    with gr.Row(elem_classes="control-grid"):
+                        refresh_lora_btn = gr.Button("Refresh")
+                        delete_lora_btn = gr.Button("Delete", elem_classes="orange-button")
+                    download_fastvideo_btn = gr.Button("Download FastVideo LoRA", elem_classes="big-setting-button")
+            lora_gallery = gr.Gallery(
+                value=[(l, os.path.basename(l)) for l in list_loras()], label="LoRA Files", columns=6, height=360,
+                allow_preview=False, elem_classes="lora-gallery"
+            )
+            load_lora_btn.click(load_lora_select, [lora_dropdown], [lora_path, lora_dropdown])
+            next_lora_btn.click(next_lora_and_load, [lora_dropdown], [lora_path, lora_dropdown])
+            refresh_lora_btn.click(lambda: (
+                gr.update(choices=[os.path.basename(l) for l in list_loras()],
+                          value=os.path.basename(list_loras()[0]) if list_loras() else None),
+                gr.update(value=[(l, os.path.basename(l)) for l in list_loras()])
+            ), [], [lora_dropdown, lora_gallery])
+            delete_lora_btn.click(delete_lora, [lora_dropdown], [lora_status, lora_dropdown])
+            download_fastvideo_btn.click(
+                lambda: auto_download_fastvideo_lora(),
+                [], [lora_status]
+            )
+            lora_gallery.select(gallery_lora_select, [], [lora_path, lora_dropdown])
+
+        with gr.TabItem("👻 About"):
+            gr.Markdown("## GhostPack F1 Pro")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**🛠️ Description**\nImage-to-Video toolkit powered by HunyuanVideo & FramePack-F1")
+                with gr.Column():
+                    gr.Markdown("**📦 Version**\n2025-05-03")
+                with gr.Column():
+                    gr.Markdown("**✍️ Author**\nGhostAI")
+                with gr.Column():
+                    gr.Markdown("**🔗 Repo**\nhttps://huggingface.co/spaces/ghostai1/GhostPack")
+
+        with gr.TabItem("⚙️ Settings"):
+            ct = gr.Button("Clear Temp", elem_classes="big-setting-button")
+            ctmsg = gr.Markdown("")
+            co = gr.Button("Clear Old", elem_classes="big-setting-button")
+            comsg= gr.Markdown("")
+            ci = gr.Button("Clear Images", elem_classes="big-setting-button")
+            cimg= gr.Markdown("")
+            cv = gr.Button("Clear Videos", elem_classes="big-setting-button")
+            cvid= gr.Markdown("")
+            ct.click(clear_temp_videos, [], ctmsg)
+            co.click(clear_old_files,   [], comsg)
+            ci.click(clear_images,      [], cimg)
+            cv.click(clear_videos,      [], cvid)
+
+        with gr.TabItem("🛠️ Install"):
+            xs = gr.Textbox(value=status_xformers(), interactive=False, label="xformers")
+            bx = gr.Button("Install xformers", elem_classes="big-setting-button")
+            ss = gr.Textbox(value=status_sage(), interactive=False, label="sage-attn")
+            bs = gr.Button("Install sage-attn", elem_classes="big-setting-button")
+            fs = gr.Textbox(value=status_flash(),interactive=False, label="flash-attn")
+            bf = gr.Button("Install flash-attn", elem_classes="big-setting-button")
+            bx.click(install_xformers,   [], xs)
+            bs.click(install_sage_attn,  [], ss)
+            bf.click(install_flash_attn, [], fs)
+
+        with gr.TabItem("📜 Logs"):
+            logs = gr.Textbox(lines=20, interactive=False, label="Install Logs")
+            rl   = gr.Button("Refresh", elem_classes="big-setting-button")
+            cl   = gr.Button("Clear",   elem_classes="big-setting-button")
+            rl.click(refresh_logs, [], logs)
+            cl.click(clear_logs,   [], logs)
+
+    # Force video previews to seek to 2s
+    gr.HTML("""<script>
+document.querySelectorAll('.video-gallery video').forEach(v => {
+  v.addEventListener('loadedmetadata', () => {
+    if (v.duration > 2) v.currentTime = 2;
+  });
+});
+</script>""")
+
+blk.launch(
+    server_name=args.server,
+    server_port=args.port,
+    share=args.share,
+    inbrowser=args.inbrowser
+)