app_fast_CPU.py

import os
import spaces
import torch
from diffusers import AutoencoderKLWan, WanPipeline, WanImageToVideoPipeline, UniPCMultistepScheduler
from diffusers.utils import export_to_video
import gradio as gr
import tempfile
from huggingface_hub import hf_hub_download
import numpy as np
from PIL import Image
import random

MODEL_ID = "FastVideo/FastWan2.2-TI2V-5B-FullAttn-Diffusers"
HF_MODEL = os.environ.get("HF_UPLOAD_REPO", "rahul7star/wan22TITV5B-image-analysis")

# --- CPU-only upload function ---
def upload_image_and_prompt_cpu(input_image, prompt_text) -> str:
    from datetime import datetime
    import tempfile, os, uuid, shutil
    from huggingface_hub import HfApi

    # Instantiate the HfApi class
    api = HfApi()
    print(prompt_text)

    today_str = datetime.now().strftime("%Y-%m-%d")
    unique_subfolder = f"Upload-Image-{uuid.uuid4().hex[:8]}"
    hf_folder = f"{today_str}/{unique_subfolder}"

    # Save image temporarily
    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_img:
        if isinstance(input_image, str):
            shutil.copy(input_image, tmp_img.name)
        else:
            input_image.save(tmp_img.name, format="PNG")
        tmp_img_path = tmp_img.name

    # Upload image using HfApi instance
    api.upload_file(
        path_or_fileobj=tmp_img_path,
        path_in_repo=f"{hf_folder}/input_image.png",
        repo_id=HF_MODEL,
        repo_type="model",
        token=os.environ.get("HUGGINGFACE_HUB_TOKEN")
    )

    # Save prompt as summary.txt
    summary_file = tempfile.NamedTemporaryFile(delete=False, suffix=".txt").name
    with open(summary_file, "w", encoding="utf-8") as f:
        f.write(prompt_text)

    api.upload_file(
        path_or_fileobj=summary_file,
        path_in_repo=f"{hf_folder}/summary.txt",
        repo_id=HF_MODEL,
        repo_type="model",
        token=os.environ.get("HUGGINGFACE_HUB_TOKEN")
    )

    # Cleanup
    os.remove(tmp_img_path)
    os.remove(summary_file)

    return hf_folder


# --- Load pipelines ---
vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
text_to_video_pipe = WanPipeline.from_pretrained(MODEL_ID, vae=vae, torch_dtype=torch.bfloat16)
image_to_video_pipe = WanImageToVideoPipeline.from_pretrained(MODEL_ID, vae=vae, torch_dtype=torch.bfloat16)

for pipe in [text_to_video_pipe, image_to_video_pipe]:
    pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=8.0)
    pipe.to("cuda")


### very good 
LORA_REPO_ID = "UnifiedHorusRA/Missionary_POV_Wan_2.2_5B_LoRA"
LORA_FILENAME = "missionary-pov-wan2.2_5b-v1.0-vfxai.safetensors"

causvid_path = hf_hub_download(repo_id=LORA_REPO_ID, filename=LORA_FILENAME)
pipe.load_lora_weights(causvid_path, adapter_name="causvid_lora")




# LORA_REPO_ID = "rahul7star/wan2.2Lora"
# LORA_FILENAME1 = "missionary-pov-wan2.2_5b-v1.0-vfxai.safetensors"
# LORA_FILENAME = "wan2.2_5b_c0wg1rl_72_000002500.safetensors"
# causvid_path = hf_hub_download(repo_id=LORA_REPO_ID, filename=LORA_FILENAME)
# pipe.load_lora_weights(causvid_path, adapter_name="causvid_lora")





# ## anotheer exp

# LORA_REPO_ID1 = "hjhfgfxj/wan_2.2_5B_lora_lab"
# LORA_FILENAME1 = "wan_2.2_5B_realistic_000310500.safetensors"
# causvid_path1 = hf_hub_download(repo_id=LORA_REPO_ID, filename=LORA_FILENAME)
# pipe.load_lora_weights(causvid_path1, adapter_name="causvid_lora1")



# LORA_REPO_ID1 = "hjhfgfxj/wan_2.2_5B_lora_lab"
# LORA_FILENAME1 = "wan_2.2_5B_realistic_000310500.safetensors"
# causvid_path1 = hf_hub_download(repo_id=LORA_REPO_ID1, filename=LORA_FILENAME1)
# pipe.load_lora_weights(causvid_path1, adapter_name="causvid_lora1")



# LORA_REPO_ID1 = "UnifiedHorusRA/Cowgirl_WAN2.2_5B"
# LORA_FILENAME1 = "wan2.2_5b_c0wg1rl_72_000002500.safetensors"
# causvid_path1 = hf_hub_download(repo_id=LORA_REPO_ID1, filename=LORA_FILENAME1)
# pipe.load_lora_weights(causvid_path1, adapter_name="causvid_lora1")

# LORA_REPO_ID1 = "UnifiedHorusRA/Lora_Anal_WAN2.2_5B_TI2V"
# LORA_FILENAME1 = "wan2.2_5B_it2v_greek.safetensors"
# causvid_path1 = hf_hub_download(repo_id=LORA_REPO_ID1, filename=LORA_FILENAME1)
# pipe.load_lora_weights(causvid_path1, adapter_name="causvid_lora1")



#pipe.set_adapters(["causvid_lora","causvid_lora1"], adapter_weights=[0.95,0.95])


pipe.set_adapters(["causvid_lora"], adapter_weights=[0.95])

pipe.fuse_lora()



# --- Constants ---
MOD_VALUE = 32
DEFAULT_H_SLIDER_VALUE = 896
DEFAULT_W_SLIDER_VALUE = 896
NEW_FORMULA_MAX_AREA = 720 * 1024
SLIDER_MIN_H, SLIDER_MAX_H = 256, 1024
SLIDER_MIN_W, SLIDER_MAX_W = 256, 1024
MAX_SEED = np.iinfo(np.int32).max
FIXED_FPS = 24
MIN_FRAMES_MODEL = 25
MAX_FRAMES_MODEL = 193

default_prompt_i2v = "make this image come alive, cinematic motion, smooth animation"
default_negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards, watermark, text, signature"

# --- Utility functions ---
def _calculate_new_dimensions_wan(pil_image, mod_val, calculation_max_area, min_slider_h, max_slider_h, min_slider_w, max_slider_w, default_h, default_w):
    orig_w, orig_h = pil_image.size
    if orig_w <= 0 or orig_h <= 0:
        return default_h, default_w
    aspect_ratio = orig_h / orig_w
    calc_h = round(np.sqrt(calculation_max_area * aspect_ratio))
    calc_w = round(np.sqrt(calculation_max_area / aspect_ratio))
    calc_h = max(mod_val, (calc_h // mod_val) * mod_val)
    calc_w = max(mod_val, (calc_w // mod_val) * mod_val)
    new_h = int(np.clip(calc_h, min_slider_h, (max_slider_h // mod_val) * mod_val))
    new_w = int(np.clip(calc_w, min_slider_w, (max_slider_w // mod_val) * mod_val))
    return new_h, new_w

def handle_image_upload_for_dims_wan(uploaded_pil_image, current_h_val, current_w_val):
    if uploaded_pil_image is None:
        return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)
    try:
        new_h, new_w = _calculate_new_dimensions_wan(
            uploaded_pil_image, MOD_VALUE, NEW_FORMULA_MAX_AREA,
            SLIDER_MIN_H, SLIDER_MAX_H, SLIDER_MIN_W, SLIDER_MAX_W,
            DEFAULT_H_SLIDER_VALUE, DEFAULT_W_SLIDER_VALUE
        )
        return gr.update(value=new_h), gr.update(value=new_w)
    except Exception as e:
        return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)

def get_duration(*args, **kwargs):
    return 60  # simplified for example

# --- GPU video generation ---
@spaces.GPU(duration=get_duration)
def generate_video(input_image, prompt, height, width,
                   negative_prompt=default_negative_prompt,
                   duration_seconds=2, guidance_scale=0, steps=4,
                   seed=44, randomize_seed=False,
                   progress=gr.Progress(track_tqdm=True)):

    target_h = max(MOD_VALUE, (int(height) // MOD_VALUE) * MOD_VALUE)
    target_w = max(MOD_VALUE, (int(width) // MOD_VALUE) * MOD_VALUE)
    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
    if "child" in prompt.lower():
        print("Found 'child' in prompt. Exiting loop.")
        return

    if input_image is not None:
        resized_image = input_image.resize((target_w, target_h))
        with torch.inference_mode():
            output_frames_list = image_to_video_pipe(
                image=resized_image, prompt=prompt, negative_prompt=negative_prompt,
                height=target_h, width=target_w, num_frames=num_frames,
                guidance_scale=float(guidance_scale), num_inference_steps=int(steps),
                generator=torch.Generator(device="cuda").manual_seed(current_seed)
            ).frames[0]
    else:
        with torch.inference_mode():
            output_frames_list = text_to_video_pipe(
                prompt=prompt, negative_prompt=negative_prompt,
                height=target_h, width=target_w, num_frames=num_frames,
                guidance_scale=float(guidance_scale), num_inference_steps=int(steps),
                generator=torch.Generator(device="cuda").manual_seed(current_seed)
            ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
        video_path = tmpfile.name
    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
    return video_path, current_seed

# --- Wrapper to upload image/prompt on CPU before GPU generation ---
def generate_video_with_upload(input_image, prompt, height, width,
                               negative_prompt=default_negative_prompt,
                               duration_seconds=2, guidance_scale=0, steps=4,
                               seed=44, randomize_seed=False):
    # Upload on CPU (hidden, no UI)
    try:
        upload_image_and_prompt_cpu(input_image, prompt)
    except Exception as e:
        print("Upload failed:", e)

    # Proceed with GPU video generation
    return generate_video(input_image, prompt, height, width,
                          negative_prompt, duration_seconds,
                          guidance_scale, steps, seed, randomize_seed)

# --- Gradio UI ---
with gr.Blocks() as demo:
    gr.Markdown("# Fast Wan 2.2 TI2V 5B Demo")
    gr.Markdown("""This Demo is using [FastWan2.2-TI2V-5B](https://huggingface.co/FastVideo/FastWan2.2-TI2V-5B-FullAttn-Diffusers) fine-tuned with Sparse-distill for fast high-quality video generation.""")

    with gr.Row():
        with gr.Column():
            input_image_component = gr.Image(type="pil", label="Input Image (optional, auto-resized to target H/W)")
            prompt_input = gr.Textbox(label="Prompt", value=default_prompt_i2v)
            duration_seconds_input = gr.Slider(minimum=round(MIN_FRAMES_MODEL/FIXED_FPS,1),
                                               maximum=round(MAX_FRAMES_MODEL/FIXED_FPS,1),
                                               step=0.1, value=2, label="Duration (seconds)")
            with gr.Accordion("Advanced Settings", open=False):
                negative_prompt_input = gr.Textbox(label="Negative Prompt", value=default_negative_prompt, lines=3)
                seed_input = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=42)
                randomize_seed_checkbox = gr.Checkbox(label="Randomize seed", value=True)
                with gr.Row():
                    height_input = gr.Slider(minimum=SLIDER_MIN_H, maximum=SLIDER_MAX_H, step=MOD_VALUE, value=DEFAULT_H_SLIDER_VALUE, label=f"Output Height")
                    width_input = gr.Slider(minimum=SLIDER_MIN_W, maximum=SLIDER_MAX_W, step=MOD_VALUE, value=DEFAULT_W_SLIDER_VALUE, label=f"Output Width")
                steps_slider = gr.Slider(minimum=1, maximum=8, step=1, value=4, label="Inference Steps")
                guidance_scale_input = gr.Slider(minimum=0.0, maximum=5.0, step=0.01, value=0.0, label="Guidance Scale")
            generate_button = gr.Button("Generate Video", variant="primary")
        with gr.Column():
            video_output = gr.Video(label="Generated Video", autoplay=True, interactive=False)

    input_image_component.upload(
        fn=handle_image_upload_for_dims_wan,
        inputs=[input_image_component, height_input, width_input],
        outputs=[height_input, width_input]
    )
    input_image_component.clear(
        fn=handle_image_upload_for_dims_wan,
        inputs=[input_image_component, height_input, width_input],
        outputs=[height_input, width_input]
    )

    ui_inputs = [
        input_image_component, prompt_input, height_input, width_input,
        negative_prompt_input, duration_seconds_input,
        guidance_scale_input, steps_slider, seed_input, randomize_seed_checkbox
    ]
    generate_button.click(fn=generate_video_with_upload, inputs=ui_inputs, outputs=[video_output, seed_input])

    gr.Examples(
        examples=[
            [None, "A person eating spaghetti", 1024, 720],
            ["cat.png", "The cat removes the glasses from its eyes.", 1088, 800],
            [None, "A penguin playfully dancing in the snow, Antarctica", 1024, 720],
            ["peng.png", "A penguin running towards camera joyfully, Antarctica", 896, 512],
        ],
        inputs=[input_image_component, prompt_input, height_input, width_input],
        outputs=[video_output, seed_input],
        fn=generate_video_with_upload,
        cache_examples="lazy"
    )

if __name__ == "__main__":
    demo.queue().launch()