Delete app-backup-60s.py

app-backup-60s.py

@@ -1,724 +0,0 @@
-import os
-
-os.environ['HF_HOME'] = os.path.abspath(
-    os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download'))
-)
-
-import gradio as gr
-import torch
-import traceback
-import einops
-import safetensors.torch as sf
-import numpy as np
-import math
-import spaces
-
-from PIL import Image
-from diffusers import AutoencoderKLHunyuanVideo
-from transformers import (
-    LlamaModel, CLIPTextModel,
-    LlamaTokenizerFast, CLIPTokenizer
-)
-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,
-    state_dict_weighted_merge, state_dict_offset_merge,
-    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 (
-    cpu, 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 transformers import SiglipImageProcessor, SiglipVisionModel
-from diffusers_helper.clip_vision import hf_clip_vision_encode
-from diffusers_helper.bucket_tools import find_nearest_bucket
-
-# Check GPU memory
-free_mem_gb = get_cuda_free_memory_gb(gpu)
-high_vram = free_mem_gb > 60
-
-print(f'Free VRAM {free_mem_gb} GB')
-print(f'High-VRAM Mode: {high_vram}')
-
-# Load models
-text_encoder = LlamaModel.from_pretrained(
-    "hunyuanvideo-community/HunyuanVideo",
-    subfolder='text_encoder',
-    torch_dtype=torch.float16
-).cpu()
-text_encoder_2 = CLIPTextModel.from_pretrained(
-    "hunyuanvideo-community/HunyuanVideo",
-    subfolder='text_encoder_2',
-    torch_dtype=torch.float16
-).cpu()
-tokenizer = LlamaTokenizerFast.from_pretrained(
-    "hunyuanvideo-community/HunyuanVideo",
-    subfolder='tokenizer'
-)
-tokenizer_2 = CLIPTokenizer.from_pretrained(
-    "hunyuanvideo-community/HunyuanVideo",
-    subfolder='tokenizer_2'
-)
-vae = AutoencoderKLHunyuanVideo.from_pretrained(
-    "hunyuanvideo-community/HunyuanVideo",
-    subfolder='vae',
-    torch_dtype=torch.float16
-).cpu()
-
-feature_extractor = SiglipImageProcessor.from_pretrained(
-    "lllyasviel/flux_redux_bfl",
-    subfolder='feature_extractor'
-)
-image_encoder = SiglipVisionModel.from_pretrained(
-    "lllyasviel/flux_redux_bfl",
-    subfolder='image_encoder',
-    torch_dtype=torch.float16
-).cpu()
-
-transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
-    'lllyasviel/FramePack_F1_I2V_HY_20250503',
-    torch_dtype=torch.bfloat16
-).cpu()
-
-# Evaluation mode
-vae.eval()
-text_encoder.eval()
-text_encoder_2.eval()
-image_encoder.eval()
-transformer.eval()
-
-# Slicing/Tiling for low VRAM
-if not high_vram:
-    vae.enable_slicing()
-    vae.enable_tiling()
-
-transformer.high_quality_fp32_output_for_inference = True
-print('transformer.high_quality_fp32_output_for_inference = True')
-
-# Move to correct dtype
-transformer.to(dtype=torch.bfloat16)
-vae.to(dtype=torch.float16)
-image_encoder.to(dtype=torch.float16)
-text_encoder.to(dtype=torch.float16)
-text_encoder_2.to(dtype=torch.float16)
-
-# No gradient
-vae.requires_grad_(False)
-text_encoder.requires_grad_(False)
-text_encoder_2.requires_grad_(False)
-image_encoder.requires_grad_(False)
-transformer.requires_grad_(False)
-
-# DynamicSwap if low VRAM
-if not high_vram:
-    DynamicSwapInstaller.install_model(transformer, device=gpu)
-    DynamicSwapInstaller.install_model(text_encoder, device=gpu)
-else:
-    text_encoder.to(gpu)
-    text_encoder_2.to(gpu)
-    image_encoder.to(gpu)
-    vae.to(gpu)
-    transformer.to(gpu)
-
-stream = AsyncStream()
-
-outputs_folder = './outputs/'
-os.makedirs(outputs_folder, exist_ok=True)
-
-examples = [
-    ["img_examples/1.png", "The girl dances gracefully, with clear movements, full of charm."],
-    ["img_examples/2.jpg", "The man dances flamboyantly, swinging his hips and striking bold poses with dramatic flair."],
-    ["img_examples/3.png", "The woman dances elegantly among the blossoms, spinning slowly with flowing sleeves and graceful hand movements."]
-]
-
-# Example generation (optional)
-def generate_examples(input_image, prompt):
-    t2v=False
-    n_prompt=""
-    seed=31337
-    total_second_length=60
-    latent_window_size=9
-    steps=25
-    cfg=1.0
-    gs=10.0
-    rs=0.0
-    gpu_memory_preservation=6
-    use_teacache=True
-    mp4_crf=16
-
-    global stream
-
-    if t2v:
-        default_height, default_width = 640, 640
-        input_image = np.ones((default_height, default_width, 3), dtype=np.uint8) * 255
-        print("No input image provided. Using a blank white image.")
-
-    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
-
-    stream = AsyncStream()
-
-    async_run(
-        worker, input_image, prompt, n_prompt, seed,
-        total_second_length, latent_window_size, steps,
-        cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf
-    )
-
-    output_filename = None
-
-    while True:
-        flag, data = stream.output_queue.next()
-
-        if flag == 'file':
-            output_filename = data
-            yield (
-                output_filename,
-                gr.update(),
-                gr.update(),
-                gr.update(),
-                gr.update(interactive=False),
-                gr.update(interactive=True)
-            )
-
-        if flag == 'progress':
-            preview, desc, html = data
-            yield (
-                gr.update(),
-                gr.update(visible=True, value=preview),
-                desc,
-                html,
-                gr.update(interactive=False),
-                gr.update(interactive=True)
-            )
-
-        if flag == 'end':
-            yield (
-                output_filename,
-                gr.update(visible=False),
-                gr.update(),
-                '',
-                gr.update(interactive=True),
-                gr.update(interactive=False)
-            )
-            break
-
-@torch.no_grad()
-def worker(
-    input_image, prompt, n_prompt, seed,
-    total_second_length, latent_window_size, steps,
-    cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf
-):
-    # Calculate total sections
-    total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
-    total_latent_sections = int(max(round(total_latent_sections), 1))
-
-    job_id = generate_timestamp()
-
-    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
-
-    try:
-        # Unload if VRAM is low
-        if not high_vram:
-            unload_complete_models(
-                text_encoder, text_encoder_2, image_encoder, vae, transformer
-            )
-
-        # Text encoding
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))
-
-        if not high_vram:
-            fake_diffusers_current_device(text_encoder, gpu)
-            load_model_as_complete(text_encoder_2, target_device=gpu)
-
-        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
-
-        if cfg == 1:
-            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
-        else:
-            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
-
-        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
-        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
-
-        # Process image
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))
-
-        H, W, C = input_image.shape
-        height, width = find_nearest_bucket(H, W, resolution=640)
-        input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
-
-        Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
-
-        input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
-        input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
-
-        # VAE encoding
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
-
-        if not high_vram:
-            load_model_as_complete(vae, target_device=gpu)
-        start_latent = vae_encode(input_image_pt, vae)
-
-        # CLIP Vision
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
-
-        if not high_vram:
-            load_model_as_complete(image_encoder, target_device=gpu)
-        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
-        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
-
-        # Convert dtype
-        llama_vec = llama_vec.to(transformer.dtype)
-        llama_vec_n = llama_vec_n.to(transformer.dtype)
-        clip_l_pooler = clip_l_pooler.to(transformer.dtype)
-        clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
-        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
-
-        # Start sampling
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))
-
-        rnd = torch.Generator("cpu").manual_seed(seed)
-
-        history_latents = torch.zeros(
-            size=(1, 16, 16 + 2 + 1, height // 8, width // 8),
-            dtype=torch.float32
-        ).cpu()
-        history_pixels = None
-
-        # Add start_latent
-        history_latents = torch.cat([history_latents, start_latent.to(history_latents)], dim=2)
-        total_generated_latent_frames = 1
-
-        for section_index in range(total_latent_sections):
-            if stream.input_queue.top() == 'end':
-                stream.output_queue.push(('end', None))
-                return
-
-            print(f'section_index = {section_index}, total_latent_sections = {total_latent_sections}')
-
-            if not high_vram:
-                unload_complete_models()
-                move_model_to_device_with_memory_preservation(
-                    transformer, target_device=gpu,
-                    preserved_memory_gb=gpu_memory_preservation
-                )
-
-            if use_teacache:
-                transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
-            else:
-                transformer.initialize_teacache(enable_teacache=False)
-
-            def callback(d):
-                preview = d['denoised']
-                preview = vae_decode_fake(preview)
-                preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
-                preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')
-
-                if stream.input_queue.top() == 'end':
-                    stream.output_queue.push(('end', None))
-                    raise KeyboardInterrupt('User ends the task.')
-
-                current_step = d['i'] + 1
-                percentage = int(100.0 * current_step / steps)
-                hint = f'Sampling {current_step}/{steps}'
-                desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}'
-                stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
-                return
-
-            indices = torch.arange(
-                0, sum([1, 16, 2, 1, latent_window_size])
-            ).unsqueeze(0)
-            (
-                clean_latent_indices_start,
-                clean_latent_4x_indices,
-                clean_latent_2x_indices,
-                clean_latent_1x_indices,
-                latent_indices
-            ) = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
-
-            clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
-
-            clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents[
-                :, :, -sum([16, 2, 1]):, :, :
-            ].split([16, 2, 1], dim=2)
-
-            clean_latents = torch.cat(
-                [start_latent.to(history_latents), clean_latents_1x],
-                dim=2
-            )
-
-            generated_latents = sample_hunyuan(
-                transformer=transformer,
-                sampler='unipc',
-                width=width,
-                height=height,
-                frames=latent_window_size * 4 - 3,
-                real_guidance_scale=cfg,
-                distilled_guidance_scale=gs,
-                guidance_rescale=rs,
-                num_inference_steps=steps,
-                generator=rnd,
-                prompt_embeds=llama_vec,
-                prompt_embeds_mask=llama_attention_mask,
-                prompt_poolers=clip_l_pooler,
-                negative_prompt_embeds=llama_vec_n,
-                negative_prompt_embeds_mask=llama_attention_mask_n,
-                negative_prompt_poolers=clip_l_pooler_n,
-                device=gpu,
-                dtype=torch.bfloat16,
-                image_embeddings=image_encoder_last_hidden_state,
-                latent_indices=latent_indices,
-                clean_latents=clean_latents,
-                clean_latent_indices=clean_latent_indices,
-                clean_latents_2x=clean_latents_2x,
-                clean_latent_2x_indices=clean_latent_2x_indices,
-                clean_latents_4x=clean_latents_4x,
-                clean_latent_4x_indices=clean_latent_4x_indices,
-                callback=callback,
-            )
-
-            total_generated_latent_frames += int(generated_latents.shape[2])
-            history_latents = torch.cat([history_latents, generated_latents.to(history_latents)], dim=2)
-
-            if not high_vram:
-                offload_model_from_device_for_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=8)
-                load_model_as_complete(vae, target_device=gpu)
-
-            real_history_latents = history_latents[:, :, -total_generated_latent_frames:, :, :]
-
-            if history_pixels is None:
-                history_pixels = vae_decode(real_history_latents, vae).cpu()
-            else:
-                section_latent_frames = latent_window_size * 2
-                overlapped_frames = latent_window_size * 4 - 3
-
-                current_pixels = vae_decode(
-                    real_history_latents[:, :, -section_latent_frames:], vae
-                ).cpu()
-                history_pixels = soft_append_bcthw(
-                    history_pixels, current_pixels, overlapped_frames
-                )
-
-            if not high_vram:
-                unload_complete_models()
-
-            output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
-
-            save_bcthw_as_mp4(history_pixels, output_filename, fps=30)
-
-            print(f'Decoded. Latent shape {real_history_latents.shape}; pixel shape {history_pixels.shape}')
-
-            stream.output_queue.push(('file', output_filename))
-
-    except:
-        traceback.print_exc()
-        if not high_vram:
-            unload_complete_models(text_encoder, text_encoder_2, image_encoder, vae, transformer)
-
-    stream.output_queue.push(('end', None))
-    return
-
-def get_duration(
-    input_image, prompt, t2v, n_prompt,
-    seed, total_second_length, latent_window_size,
-    steps, cfg, gs, rs, gpu_memory_preservation,
-    use_teacache, mp4_crf
-):
-    return total_second_length * 60
-
-@spaces.GPU(duration=get_duration)
-def process(
-    input_image, prompt, t2v=False, n_prompt="", seed=31337,
-    total_second_length=60, latent_window_size=9, steps=25,
-    cfg=1.0, gs=10.0, rs=0.0, gpu_memory_preservation=6,
-    use_teacache=True, mp4_crf=16
-):
-    global stream
-    if t2v:
-        default_height, default_width = 640, 640
-        input_image = np.ones((default_height, default_width, 3), dtype=np.uint8) * 255
-        print("No input image provided. Using a blank white image.")
-    else:
-        composite_rgba_uint8 = input_image["composite"]
-
-        rgb_uint8 = composite_rgba_uint8[:, :, :3]
-        mask_uint8 = composite_rgba_uint8[:, :, 3]
-
-        h, w = rgb_uint8.shape[:2]
-        background_uint8 = np.full((h, w, 3), 255, dtype=np.uint8)
-
-        alpha_normalized_float32 = mask_uint8.astype(np.float32) / 255.0
-        alpha_mask_float32 = np.stack([alpha_normalized_float32]*3, axis=2)
-
-        blended_image_float32 = rgb_uint8.astype(np.float32) * alpha_mask_float32 + \
-                                background_uint8.astype(np.float32) * (1.0 - alpha_mask_float32)
-
-        input_image = np.clip(blended_image_float32, 0, 255).astype(np.uint8)
-
-    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
-
-    stream = AsyncStream()
-
-    async_run(
-        worker, input_image, prompt, n_prompt, seed,
-        total_second_length, latent_window_size, steps,
-        cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf
-    )
-
-    output_filename = None
-
-    while True:
-        flag, data = stream.output_queue.next()
-
-        if flag == 'file':
-            output_filename = data
-            yield (
-                output_filename,
-                gr.update(),
-                gr.update(),
-                gr.update(),
-                gr.update(interactive=False),
-                gr.update(interactive=True)
-            )
-
-        elif flag == 'progress':
-            preview, desc, html = data
-            yield (
-                gr.update(),
-                gr.update(visible=True, value=preview),
-                desc,
-                html,
-                gr.update(interactive=False),
-                gr.update(interactive=True)
-            )
-
-        elif flag == 'end':
-            yield (
-                output_filename,
-                gr.update(visible=False),
-                gr.update(),
-                '',
-                gr.update(interactive=True),
-                gr.update(interactive=False)
-            )
-            break
-
-def end_process():
-    stream.input_queue.push('end')
-
-
-quick_prompts = [
-    'The girl dances gracefully, with clear movements, full of charm.',
-    'A character doing some simple body movements.'
-]
-quick_prompts = [[x] for x in quick_prompts]
-
-
-def make_custom_css():
-    base_progress_css = make_progress_bar_css()
-    extra_css = """
-    body {
-        background: #fafbfe !important;
-        font-family: "Noto Sans", sans-serif;
-    }
-    #title-container {
-        text-align: center;
-        padding: 20px 0;
-        background: linear-gradient(135deg, #a8c0ff 0%, #fbc2eb 100%);
-        border-radius: 0 0 10px 10px;
-        margin-bottom: 20px;
-    }
-    #title-container h1 {
-        color: white;
-        font-size: 2rem;
-        margin: 0;
-        font-weight: 800;
-        text-shadow: 1px 2px 2px rgba(0,0,0,0.1);
-    }
-    .gr-panel {
-        background: #ffffffcc;
-        backdrop-filter: blur(4px);
-        border: 1px solid #dcdcf7;
-        border-radius: 12px;
-        padding: 16px;
-        margin-bottom: 8px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    }
-    .gr-box > label {
-        font-size: 0.9rem;
-        font-weight: 600;
-        color: #333;
-    }
-    .button-container button {
-        min-height: 48px;
-        font-size: 1rem;
-        font-weight: 600;
-        border-radius: 8px;
-        border: none !important;
-    }
-    .button-container button#start-button {
-        background-color: #4b9ffa !important;
-        color: #fff;
-    }
-    .button-container button#stop-button {
-        background-color: #ef5d84 !important;
-        color: #fff;
-    }
-    .button-container button:hover {
-        filter: brightness(0.97);
-    }
-    .no-generating-animation {
-        margin-top: 10px;
-        margin-bottom: 10px;
-    }
-    """
-    return base_progress_css + extra_css
-
-css = make_custom_css()
-
-block = gr.Blocks(css=css).queue()
-with block:
-    # Title (use gr.Group instead of gr.Box for older Gradio versions)
-    with gr.Group(elem_id="title-container"):
-        gr.Markdown("<h1>FramePack I2V</h1>")
-
-    gr.Markdown("""
-    ### Video diffusion, but feels like image diffusion
-    FramePack I2V - a model that predicts future frames from past frames,
-    letting you generate short animations from a single image plus text prompt.
-    """)
-
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.ImageEditor(
-                type="numpy",
-                label="Image Editor (use Brush for mask)",
-                height=320,
-                brush=gr.Brush(colors=["#ffffff"])
-            )
-            prompt = gr.Textbox(label="Prompt", value='')
-            t2v = gr.Checkbox(label="Only Text to Video (ignore image)?", value=False)
-
-            example_quick_prompts = gr.Dataset(
-                samples=quick_prompts,
-                label="Quick Prompts",
-                samples_per_page=1000,
-                components=[prompt]
-            )
-            example_quick_prompts.click(
-                fn=lambda x: x[0],
-                inputs=[example_quick_prompts],
-                outputs=prompt,
-                show_progress=False,
-                queue=False
-            )
-
-            with gr.Row(elem_classes="button-container"):
-                start_button = gr.Button(value="Start Generation", elem_id="start-button")
-                end_button = gr.Button(value="Stop Generation", elem_id="stop-button", interactive=False)
-
-            total_second_length = gr.Slider(
-                label="Total Video Length (Seconds)",
-                minimum=1,
-                maximum=60,
-                value=2,
-                step=0.1
-            )
-
-            with gr.Group():
-                with gr.Accordion("Advanced Settings", open=False):
-                    use_teacache = gr.Checkbox(
-                        label='Use TeaCache',
-                        value=True,
-                        info='Faster speed, but may worsen hands/fingers.'
-                    )
-                    n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=False)
-                    seed = gr.Number(label="Seed", value=31337, precision=0)
-                    latent_window_size = gr.Slider(
-                        label="Latent Window Size",
-                        minimum=1, maximum=33,
-                        value=9, step=1,
-                        visible=False
-                    )
-                    steps = gr.Slider(
-                        label="Steps",
-                        minimum=1, maximum=100,
-                        value=25, step=1,
-                        info='Not recommended to change drastically.'
-                    )
-                    cfg = gr.Slider(
-                        label="CFG Scale",
-                        minimum=1.0, maximum=32.0,
-                        value=1.0, step=0.01,
-                        visible=False
-                    )
-                    gs = gr.Slider(
-                        label="Distilled CFG Scale",
-                        minimum=1.0, maximum=32.0,
-                        value=10.0, step=0.01,
-                        info='Not recommended to change drastically.'
-                    )
-                    rs = gr.Slider(
-                        label="CFG Re-Scale",
-                        minimum=0.0, maximum=1.0,
-                        value=0.0, step=0.01,
-                        visible=False
-                    )
-                    gpu_memory_preservation = gr.Slider(
-                        label="GPU Memory Preservation (GB)",
-                        minimum=6, maximum=128,
-                        value=6, step=0.1,
-                        info="Increase if OOM occurs, but slower."
-                    )
-                    mp4_crf = gr.Slider(
-                        label="MP4 Compression (CRF)",
-                        minimum=0, maximum=100,
-                        value=16, step=1,
-                        info="Lower = better quality. 16 recommended."
-                    )
-
-        with gr.Column():
-            preview_image = gr.Image(
-                label="Preview Latents",
-                height=200,
-                visible=False
-            )
-            result_video = gr.Video(
-                label="Finished Frames",
-                autoplay=True,
-                show_share_button=False,
-                height=512,
-                loop=True
-            )
-            progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
-            progress_bar = gr.HTML('', elem_classes='no-generating-animation')
-
-
-    ips = [
-        input_image, prompt, t2v, n_prompt, seed,
-        total_second_length, latent_window_size,
-        steps, cfg, gs, rs, gpu_memory_preservation,
-        use_teacache, mp4_crf
-    ]
-    start_button.click(
-        fn=process,
-        inputs=ips,
-        outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button]
-    )
-    end_button.click(fn=end_process)
-
-
-block.launch(share=True)