Update app.py

app.py

@@ -1,12 +1,15 @@
 import os
 import shutil
+import random
 import sys
-import subprocess
-import asyncio
-import uuid
+import tempfile
 from typing import Sequence, Mapping, Any, Union
-from huggingface_hub import hf_hub_download
+
 import spaces
+import torch
+import gradio as gr
+from PIL import Image
+from huggingface_hub import hf_hub_download
 
 def hf_hub_download_local(repo_id, filename, local_dir, **kwargs):
     downloaded_path = hf_hub_download(repo_id=repo_id, filename=filename, **kwargs)
@@ -32,156 +35,322 @@ hf_hub_download_local(repo_id="Kijai/WanVideo_comfy", filename="Wan22-Lightning/
 hf_hub_download_local(repo_id="Kijai/WanVideo_comfy", filename="Wan22-Lightning/Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors", local_dir="models/loras")
 print("Downloads complete.")
 
-# --- 2. Let ComfyUI's main.py handle all initial setup ---
-print("Importing ComfyUI's main.py for setup...")
-import main
-print("ComfyUI main imported.")
+# --- Boilerplate code from the original script ---
 
-# --- 3. Now we can import the rest of the necessary modules ---
-import torch
-import gradio as gr
-from comfy import model_management
-from PIL import Image
-import random
-import nodes
+def get_value_at_index(obj: Union[Sequence, Mapping], index: int) -> Any:
+    """Returns the value at the given index of a sequence or mapping.
 
-# --- 4. Manually trigger the node initialization ---
-print("Initializing ComfyUI nodes...")
-loop = asyncio.new_event_loop()
-asyncio.set_event_loop(loop)
-loop.run_until_complete(nodes.init_extra_nodes())
-print("Nodes initialized.")
+    If the object is a sequence (like list or string), returns the value at the given index.
+    If the object is a mapping (like a dictionary), returns the value at the index-th key.
 
-# --- Helper function ---
-def get_value_at_index(obj: Union[Sequence, Mapping], index: int) -> Any:
+    Some return a dictionary, in these cases, we look for the "results" key
+
+    Args:
+        obj (Union[Sequence, Mapping]): The object to retrieve the value from.
+        index (int): The index of the value to retrieve.
+
+    Returns:
+        Any: The value at the given index.
+
+    Raises:
+        IndexError: If the index is out of bounds for the object and the object is not a mapping.
+    """
     try:
         return obj[index]
     except KeyError:
-        return obj["result"][index]
-
-
-# --- ZeroGPU: Pre-load models and instantiate nodes globally ---
-cliploader = nodes.NODE_CLASS_MAPPINGS["CLIPLoader"]()
-cliptextencode = nodes.NODE_CLASS_MAPPINGS["CLIPTextEncode"]()
-unetloader = nodes.NODE_CLASS_MAPPINGS["UNETLoader"]()
-vaeloader = nodes.NODE_CLASS_MAPPINGS["VAELoader"]()
-clipvisionloader = nodes.NODE_CLASS_MAPPINGS["CLIPVisionLoader"]()
-loadimage = nodes.NODE_CLASS_MAPPINGS["LoadImage"]()
-clipvisionencode = nodes.NODE_CLASS_MAPPINGS["CLIPVisionEncode"]()
-loraloadermodelonly = nodes.NODE_CLASS_MAPPINGS["LoraLoaderModelOnly"]()
-modelsamplingsd3 = nodes.NODE_CLASS_MAPPINGS["ModelSamplingSD3"]()
-pathchsageattentionkj = nodes.NODE_CLASS_MAPPINGS["PathchSageAttentionKJ"]()
-wanfirstlastframetovideo = nodes.NODE_CLASS_MAPPINGS["WanFirstLastFrameToVideo"]()
-ksampleradvanced = nodes.NODE_CLASS_MAPPINGS["KSamplerAdvanced"]()
-vaedecode = nodes.NODE_CLASS_MAPPINGS["VAEDecode"]()
-createvideo = nodes.NODE_CLASS_MAPPINGS["CreateVideo"]()
-savevideo = nodes.NODE_CLASS_MAPPINGS["SaveVideo"]()
-
-cliploader_38 = cliploader.load_clip(clip_name="umt5_xxl_fp8_e4m3fn_scaled.safetensors", type="wan", device="cpu")
-unetloader_37_low_noise = unetloader.load_unet(unet_name="wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors", weight_dtype="default")
-unetloader_91_high_noise = unetloader.load_unet(unet_name="wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors", weight_dtype="default")
-vaeloader_39 = vaeloader.load_vae(vae_name="wan_2.1_vae.safetensors")
-clipvisionloader_49 = clipvisionloader.load_clip(clip_name="clip_vision_h.safetensors")
-
-loraloadermodelonly_94_high = loraloadermodelonly.load_lora_model_only(lora_name="Wan2.2-Lightning_I2V-A14B-4steps-lora_HIGH_fp16.safetensors", strength_model=0.8, model=get_value_at_index(unetloader_91_high_noise, 0))
-loraloadermodelonly_95_low = loraloadermodelonly.load_lora_model_only(lora_name="Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors", strength_model=0.8, model=get_value_at_index(unetloader_37_low_noise, 0))
-modelsamplingsd3_93_low = modelsamplingsd3.patch(shift=8, model=get_value_at_index(loraloadermodelonly_95_low, 0))
-pathchsageattentionkj_98_low = pathchsageattentionkj.patch(sage_attention="auto", model=get_value_at_index(modelsamplingsd3_93_low, 0))
-modelsamplingsd3_79_high = modelsamplingsd3.patch(shift=8, model=get_value_at_index(loraloadermodelonly_94_high, 0))
-pathchsageattentionkj_96_high = pathchsageattentionkj.patch(sage_attention="auto", model=get_value_at_index(modelsamplingsd3_79_high, 0))
-
-model_loaders = [cliploader_38, unetloader_37_low_noise, unetloader_91_high_noise, vaeloader_39, clipvisionloader_49, loraloadermodelonly_94_high, loraloadermodelonly_95_low]
-valid_models = [getattr(loader[0], 'patcher', loader[0]) for loader in model_loaders if not isinstance(loader[0], dict) and not isinstance(getattr(loader[0], 'patcher', None), dict)]
-model_management.load_models_gpu(valid_models)
-
-# --- App Logic ---
-def calculate_dimensions(width, height):
-    if width == height: return 480, 480
-    if width > height: new_width, new_height = 832, int(height * (832 / width))
-    else: new_height, new_width = 832, int(width * (832 / height))
-    return (new_width // 16) * 16, (new_height // 16) * 16
+        # This is a fallback for custom node outputs that might be dictionaries
+        if isinstance(obj, Mapping) and "result" in obj:
+            return obj["result"][index]
+        raise
+
+def find_path(name: str, path: str = None) -> str:
+    """
+    Recursively looks at parent folders starting from the given path until it finds the given name.
+    Returns the path as a Path object if found, or None otherwise.
+    """
+    if path is None:
+        path = os.getcwd()
+
+    if name in os.listdir(path):
+        path_name = os.path.join(path, name)
+        print(f"'{name}' found: {path_name}")
+        return path_name
+
+    parent_directory = os.path.dirname(path)
+    if parent_directory == path:
+        return None
+
+    return find_path(name, parent_directory)
+
+
+def add_comfyui_directory_to_sys_path() -> None:
+    """
+    Add 'ComfyUI' to the sys.path
+    """
+    # Use a more robust name to find the ComfyUI directory
+    comfyui_path = find_path("ComfyUI")
+    if comfyui_path is not None and os.path.isdir(comfyui_path):
+        sys.path.append(comfyui_path)
+        print(f"'{comfyui_path}' added to sys.path")
+    else:
+        print("Could not find ComfyUI directory. Please run from a parent folder of ComfyUI.")
+
+def add_extra_model_paths() -> None:
+    """
+    Parse the optional extra_model_paths.yaml file and add the parsed paths to the sys.path.
+    """
+    try:
+        from main import load_extra_path_config
+    except ImportError:
+        print(
+            "Could not import load_extra_path_config from main.py. This might be okay if you don't use it."
+        )
+        return
+
+    extra_model_paths = find_path("extra_model_paths.yaml")
+    if extra_model_paths is not None:
+        load_extra_path_config(extra_model_paths)
+    else:
+        print("Could not find an optional 'extra_model_paths.yaml' config file.")
+
+def import_custom_nodes() -> None:
+    """Find all custom nodes in the custom_nodes folder and add those node objects to NODE_CLASS_MAPPINGS
+    This function sets up a new asyncio event loop, initializes the PromptServer,
+    creates a PromptQueue, and initializes the custom nodes.
+    """
+    import asyncio
+    import execution
+    from nodes import init_extra_nodes
+    import server
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    server_instance = server.PromptServer(loop)
+    execution.PromptQueue(server_instance)
+    loop.run_until_complete(init_extra_nodes(init_custom_nodes=True))
+
+
+# --- Model Loading and Caching ---
+
+# Dictionary to hold all loaded models and node instances
+MODELS_AND_NODES = {}
+
+print("Setting up ComfyUI paths...")
+add_comfyui_directory_to_sys_path()
+add_extra_model_paths()
 
+print("Importing custom nodes...")
+import_custom_nodes()
+
+# Now that paths are set up, we can import from nodes
+from nodes import NODE_CLASS_MAPPINGS
+global folder_paths # Make folder_paths globally accessible
+import folder_paths
+
+print("Loading models into memory. This may take a few minutes...")
+
+# Load Text-to-Image models (CLIP, UNETs, VAE)
+cliploader = NODE_CLASS_MAPPINGS["CLIPLoader"]()
+MODELS_AND_NODES["clip"] = cliploader.load_clip(
+    clip_name="umt5_xxl_fp8_e4m3fn_scaled.safetensors", type="wan", device="cpu"
+)
+
+unetloader = NODE_CLASS_MAPPINGS["UNETLoader"]()
+unet_low_noise = unetloader.load_unet(
+    unet_name="wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors",
+    weight_dtype="default",
+)
+unet_high_noise = unetloader.load_unet(
+    unet_name="wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors",
+    weight_dtype="default",
+)
+
+vaeloader = NODE_CLASS_MAPPINGS["VAELoader"]()
+MODELS_AND_NODES["vae"] = vaeloader.load_vae(vae_name="wan_2.1_vae.safetensors")
+
+# Load LoRAs
+loraloadermodelonly = NODE_CLASS_MAPPINGS["LoraLoaderModelOnly"]()
+MODELS_AND_NODES["model_low_noise"] = loraloadermodelonly.load_lora_model_only(
+    lora_name="Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors",
+    strength_model=0.8,
+    model=get_value_at_index(unet_low_noise, 0),
+)
+MODELS_AND_NODES["model_high_noise"] = loraloadermodelonly.load_lora_model_only(
+    lora_name="Wan2.2-Lightning_I2V-A14B-4steps-lora_HIGH_fp16.safetensors",
+    strength_model=0.8,
+    model=get_value_at_index(unet_high_noise, 0),
+)
+
+# Load Vision model
+clipvisionloader = NODE_CLASS_MAPPINGS["CLIPVisionLoader"]()
+MODELS_AND_NODES["clip_vision"] = clipvisionloader.load_clip(
+    clip_name="clip_vision_h.safetensors"
+)
+
+# Instantiate all required node classes
+MODELS_AND_NODES["CLIPTextEncode"] = NODE_CLASS_MAPPINGS["CLIPTextEncode"]()
+MODELS_AND_NODES["LoadImage"] = NODE_CLASS_MAPPINGS["LoadImage"]()
+MODELS_AND_NODES["CLIPVisionEncode"] = NODE_CLASS_MAPPINGS["CLIPVisionEncode"]()
+MODELS_AND_NODES["ModelSamplingSD3"] = NODE_CLASS_MAPPINGS["ModelSamplingSD3"]()
+MODELS_AND_NODES["PathchSageAttentionKJ"] = NODE_CLASS_MAPPINGS["PathchSageAttentionKJ"]()
+MODELS_AND_NODES["WanFirstLastFrameToVideo"] = NODE_CLASS_MAPPINGS["WanFirstLastFrameToVideo"]()
+MODELS_AND_NODES["KSamplerAdvanced"] = NODE_CLASS_MAPPINGS["KSamplerAdvanced"]()
+MODELS_AND_NODES["VAEDecode"] = NODE_CLASS_MAPPINGS["VAEDecode"]()
+MODELS_AND_NODES["CreateVideo"] = NODE_CLASS_MAPPINGS["CreateVideo"]()
+MODELS_AND_NODES["SaveVideo"] = NODE_CLASS_MAPPINGS["SaveVideo"]()
+
+print("All models loaded successfully!")
+
+# --- Main Video Generation Logic ---
 @spaces.GPU(duration=120)
-def generate_video(prompt, first_image_path, last_image_path, duration_seconds, progress=gr.Progress(track_tqdm=True)):
-    # Create a temporary directory for resized images
-    temp_dir = "input"
-    os.makedirs(temp_dir, exist_ok=True)
+def generate_video(start_image_pil: Image.Image, end_image_pil: Image.Image, prompt: str, negative_prompt: str, progress=gr.Progress(track_tqdm=True)):
+    """
+    The main function to generate a video based on user inputs.
+    This function is called every time the user clicks the 'Generate' button.
+    """
+    # Use pre-loaded models and nodes from the global dictionary
+    clip = MODELS_AND_NODES["clip"]
+    vae = MODELS_AND_NODES["vae"]
+    model_low_noise = MODELS_AND_NODES["model_low_noise"]
+    model_high_noise = MODELS_AND_NODES["model_high_noise"]
+    clip_vision = MODELS_AND_NODES["clip_vision"]
     
-    with torch.inference_mode():
-        
-        # --- Python Image Preprocessing using Pillow ---
-        print("Preprocessing images with Pillow...")
-        with Image.open(first_image_path) as img:
-            orig_width, orig_height = img.size
-        
-        target_width, target_height = calculate_dimensions(orig_width, orig_height)
+    cliptextencode = MODELS_AND_NODES["CLIPTextEncode"]
+    loadimage = MODELS_AND_NODES["LoadImage"]
+    clipvisionencode = MODELS_AND_NODES["CLIPVisionEncode"]
+    modelsamplingsd3 = MODELS_AND_NODES["ModelSamplingSD3"]
+    pathchsageattentionkj = MODELS_AND_NODES["PathchSageAttentionKJ"]
+    wanfirstlastframetovideo = MODELS_AND_NODES["WanFirstLastFrameToVideo"]
+    ksampleradvanced = MODELS_AND_NODES["KSamplerAdvanced"]
+    vaedecode = MODELS_AND_NODES["VAEDecode"]
+    createvideo = MODELS_AND_NODES["CreateVideo"]
+    savevideo = MODELS_AND_NODES["SaveVideo"]
+
+    # Save uploaded images to temporary files
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as start_file, \
+         tempfile.NamedTemporaryFile(suffix=".png", delete=False) as end_file:
+        start_image_pil.save(start_file.name)
+        end_image_pil.save(end_file.name)
+        start_image_path = start_file.name
+        end_image_path = end_file.name
+
+    try:
+        with torch.inference_mode():
+            progress(0.1, desc="Encoding text and images...")
+            # --- Workflow execution ---
+            positive_conditioning = cliptextencode.encode(text=prompt, clip=get_value_at_index(clip, 0))
+            negative_conditioning = cliptextencode.encode(text=negative_prompt, clip=get_value_at_index(clip, 0))
+
+            start_image_loaded = loadimage.load_image(image=start_image_path)
+            end_image_loaded = loadimage.load_image(image=end_image_path)
+            
+            clip_vision_encoded_start = clipvisionencode.encode(
+                crop="none", clip_vision=get_value_at_index(clip_vision, 0), image=get_value_at_index(start_image_loaded, 0)
+            )
+            clip_vision_encoded_end = clipvisionencode.encode(
+                crop="none", clip_vision=get_value_at_index(clip_vision, 0), image=get_value_at_index(end_image_loaded, 0)
+            )
+
+            progress(0.2, desc="Preparing initial latents...")
+            initial_latents = wanfirstlastframetovideo.EXECUTE_NORMALIZED(
+                width=480, height=480, length=33, batch_size=1,
+                positive=get_value_at_index(positive_conditioning, 0),
+                negative=get_value_at_index(negative_conditioning, 0),
+                vae=get_value_at_index(vae, 0),
+                clip_vision_start_image=get_value_at_index(clip_vision_encoded_start, 0),
+                clip_vision_end_image=get_value_at_index(clip_vision_encoded_end, 0),
+                start_image=get_value_at_index(start_image_loaded, 0),
+                end_image=get_value_at_index(end_image_loaded, 0),
+            )
+
+            progress(0.3, desc="Patching models...")
+            model_low_patched = modelsamplingsd3.patch(shift=8, model=get_value_at_index(model_low_noise, 0))
+            model_low_final = pathchsageattentionkj.patch(sage_attention="auto", model=get_value_at_index(model_low_patched, 0))
+
+            model_high_patched = modelsamplingsd3.patch(shift=8, model=get_value_at_index(model_high_noise, 0))
+            model_high_final = pathchsageattentionkj.patch(sage_attention="auto", model=get_value_at_index(model_high_patched, 0))
+
+            progress(0.5, desc="Running KSampler (Step 1/2)...")
+            latent_step1 = ksampleradvanced.sample(
+                add_noise="enable", noise_seed=random.randint(1, 2**64), steps=8, cfg=1,
+                sampler_name="euler", scheduler="simple", start_at_step=0, end_at_step=4,
+                return_with_leftover_noise="enable", model=get_value_at_index(model_high_final, 0),
+                positive=get_value_at_index(initial_latents, 0),
+                negative=get_value_at_index(initial_latents, 1),
+                latent_image=get_value_at_index(initial_latents, 2),
+            )
+            
+            progress(0.7, desc="Running KSampler (Step 2/2)...")
+            latent_step2 = ksampleradvanced.sample(
+                add_noise="disable", noise_seed=random.randint(1, 2**64), steps=8, cfg=1,
+                sampler_name="euler", scheduler="simple", start_at_step=4, end_at_step=10000,
+                return_with_leftover_noise="disable", model=get_value_at_index(model_low_final, 0),
+                positive=get_value_at_index(initial_latents, 0),
+                negative=get_value_at_index(initial_latents, 1),
+                latent_image=get_value_at_index(latent_step1, 0),
+            )
+
+            progress(0.8, desc="Decoding VAE...")
+            decoded_images = vaedecode.decode(samples=get_value_at_index(latent_step2, 0), vae=get_value_at_index(vae, 0))
+
+            progress(0.9, desc="Creating and saving video...")
+            video_data = createvideo.create_video(fps=16, images=get_value_at_index(decoded_images, 0))
+            
+            # Save the video to ComfyUI's output directory
+            save_result = savevideo.save_video(
+                filename_prefix="GradioVideo", format="mp4", codec="h264",
+                video=get_value_at_index(video_data, 0),
+            )
+
+            progress(1.0, desc="Done!")
+            return f"output/{save_result['ui']['images'][0]['filename']}"
+
+    finally:
+        # Clean up the temporary image files
+        os.unlink(start_image_path)
+        os.unlink(end_image_path)
+
+# --- Gradio UI ---
+
+def create_gradio_app():
+    with gr.Blocks(theme=gr.themes.Soft()) as app:
+        gr.Markdown("# Image-to-Video Generation App")
+        gr.Markdown("Upload a start and end frame, provide a prompt, and let the AI generate a video transitioning between them.")
+
+        with gr.Row():
+            start_image = gr.Image(type="pil", label="Start Frame")
+            end_image = gr.Image(type="pil", label="End Frame")
         
-        # Resize first image
-        with Image.open(first_image_path) as img:
-            img_resized = img.resize((target_width, target_height), Image.Resampling.LANCZOS)
-            resized_first_path = os.path.join(temp_dir, f"first_frame_resized_{uuid.uuid4().hex}.png")
-            print(resized_first_path)
-            img_resized.save(resized_first_path)
-
-        # Resize second image to match the target dimensions
-        with Image.open(last_image_path) as img:
-            img_resized = img.resize((target_width, target_height), Image.Resampling.LANCZOS)
-            resized_last_path = os.path.join(temp_dir, f"last_frame_resized_{uuid.uuid4().hex}.png")
-            print(resized_last_path)
-            img_resized.save(resized_last_path)
-        print(f"Images resized to {target_width}x{target_height} and saved temporarily.")
-        # --- End Preprocessing ---
-
-        FPS, MAX_FRAMES = 16, 81
-        length_in_frames = max(1, min(int(duration_seconds * FPS), MAX_FRAMES))
-        print(f"Requested duration: {duration_seconds}s. Calculated frames: {length_in_frames}")
+        prompt = gr.Textbox(label="Prompt", value="the guy turns")
+        negative_prompt = gr.Textbox(
+            label="Negative Prompt", 
+            value="色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走,过曝，"
+        )
         
-        # Load the pre-processed images into ComfyUI
-        loaded_first_image = loadimage.load_image(image=os.path.basename(resized_first_path))
-        loaded_last_image = loadimage.load_image(image=os.path.basename(resized_last_path))
+        generate_button = gr.Button("Generate Video", variant="primary")
         
-        cliptextencode_6 = cliptextencode.encode(text=prompt, clip=get_value_at_index(cliploader_38, 0))
-        cliptextencode_7_negative = cliptextencode.encode(text="low quality, worst quality, jpeg artifacts, ugly, deformed, blurry", clip=get_value_at_index(cliploader_38, 0))
-        clipvisionencode_51 = clipvisionencode.encode(crop="none", clip_vision=get_value_at_index(clipvisionloader_49, 0), image=get_value_at_index(loaded_first_image, 0))
-        clipvisionencode_87 = clipvisionencode.encode(crop="none", clip_vision=get_value_at_index(clipvisionloader_49, 0), image=get_value_at_index(loaded_last_image, 0))
+        output_video = gr.Video(label="Generated Video")
 
-        wanfirstlastframetovideo_83 = wanfirstlastframetovideo.EXECUTE_NORMALIZED(width=target_width, height=target_height, length=length_in_frames, batch_size=1, positive=get_value_at_index(cliptextencode_6, 0), negative=get_value_at_index(cliptextencode_7_negative, 0), vae=get_value_at_index(vaeloader_39, 0), clip_vision_start_image=get_value_at_index(clipvisionencode_51, 0), clip_vision_end_image=get_value_at_index(clipvisionencode_87, 0), start_image=get_value_at_index(loaded_first_image, 0), end_image=get_value_at_index(loaded_last_image, 0))
+        generate_button.click(
+            fn=generate_video,
+            inputs=[start_image, end_image, prompt, negative_prompt],
+            outputs=output_video
+        )
+
+        gr.Examples(
+            examples=[
+                ["examples/start.png", "examples/end.png", "a beautiful woman smiling"],
+                ["examples/start.png", "examples/end.png", "a robot walking through a futuristic city"],
+            ],
+            inputs=[start_image, end_image, prompt],
+            outputs=output_video,
+            fn=generate_video,
+            cache_examples=False, # Set to True if you want to pre-compute examples
+        )
+
+    return app
 
-        ksampler_positive = get_value_at_index(wanfirstlastframetovideo_83, 0)
-        ksampler_negative = get_value_at_index(wanfirstlastframetovideo_83, 1)
-        ksampler_latent = get_value_at_index(wanfirstlastframetovideo_83, 2)
-        
-        ksampleradvanced_101 = ksampleradvanced.sample(add_noise="enable", noise_seed=random.randint(1, 2**64), steps=8, cfg=1, sampler_name="euler", scheduler="simple", start_at_step=0, end_at_step=4, return_with_leftover_noise="enable", model=get_value_at_index(pathchsageattentionkj_96_high, 0), positive=ksampler_positive, negative=ksampler_negative, latent_image=ksampler_latent)
-        ksampleradvanced_102 = ksampleradvanced.sample(add_noise="disable", noise_seed=random.randint(1, 2**64), steps=8, cfg=1, sampler_name="euler", scheduler="simple", start_at_step=4, end_at_step=10000, return_with_leftover_noise="disable", model=get_value_at_index(pathchsageattentionkj_98_low, 0), positive=ksampler_positive, negative=ksampler_negative, latent_image=get_value_at_index(ksampleradvanced_101, 0))
-
-        vaedecode_8 = vaedecode.decode(samples=get_value_at_index(ksampleradvanced_102, 0), vae=get_value_at_index(vaeloader_39, 0))
-        createvideo_104 = createvideo.create_video(fps=16, images=get_value_at_index(vaedecode_8, 0))
-        savevideo_103 = savevideo.save_video(filename_prefix="ComfyUI_Video", format="mp4", codec="h264", video=get_value_at_index(createvideo_104, 0))
-        print("** DEBUG ** ", savevideo_103)
-        return f"output/{savevideo_103['ui']['images'][0]['filename']}"
-
-# --- Gradio Interface ---
-with gr.Blocks() as app:
-    gr.Markdown("# Wan 2.2 First/Last Frame Video Fast")
-    gr.Markdown("Running the [Wan 2.2 First/Last Frame ComfyUI workflow](https://www.reddit.com/r/StableDiffusion/comments/1me4306/psa_wan_22_does_first_frame_last_frame_out_of_the/) on ZeroGPU")
-    with gr.Row():
-        with gr.Column(scale=1):
-            prompt_input = gr.Textbox(label="Prompt", value="a man dancing in the street, cinematic")
-            duration_slider = gr.Slider(minimum=1.0, maximum=5.0, value=2.0, step=0.1, label="Video Duration (seconds)")
-            with gr.Row():
-                first_image = gr.Image(label="First Frame", type="filepath")
-                last_image = gr.Image(label="Last Frame", type="filepath")
-            generate_btn = gr.Button("Generate Video")
-        with gr.Column(scale=2):
-            output_video = gr.Video(label="Generated Video")
-    generate_btn.click(fn=generate_video, inputs=[prompt_input, first_image, last_image, duration_slider], outputs=[output_video])
-    gr.Examples(examples=[["a beautiful woman, cinematic", "examples/start.png", "examples/end.png", 2.5]], inputs=[prompt_input, first_image, last_image, duration_slider])
 
 if __name__ == "__main__":
-    if not os.path.exists("examples"): os.makedirs("examples")
-    if not os.path.exists("examples/start.png"): Image.new('RGB', (512, 512), color='red').save('examples/start.png')
-    if not os.path.exists("examples/end.png"): Image.new('RGB', (512, 512), color='blue').save('examples/end.png')
-    # Set the input directory for LoadImage to find the temp files
-    import folder_paths
-    folder_paths.add_model_folder_path("input", "temp_resized")
-    app.launch()
+    app = create_gradio_app()
+    app.launch(share=True)