Upload 3 files

README.md

@@ -1,21 +1,12 @@
 ---
-title: SUPIR Image Upscaler
+title: Wan 2 2 First Last Frame
+emoji: 💻
+colorFrom: purple
+colorTo: gray
 sdk: gradio
-emoji: 📷
 sdk_version: 5.29.1
 app_file: app.py
-license: mit
-colorFrom: blue
-colorTo: pink
-tags:
-- Upscaling
-- Restoring
-- Image-to-Image
-- Image-2-Image
-- Img-to-Img
-- Img-2-Img
-- language models
-- LLMs
-short_description: Restore blurred or small images with prompt
-suggested_hardware: zero-a10g
----
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,1058 +1,451 @@
 import os
+# PyTorch 2.8 (temporary hack)
+os.system('pip install --upgrade --pre --extra-index-url https://download.pytorch.org/whl/nightly/cu126 "torch<2.9" spaces')
+
+# --- 1. Model Download and Setup (Diffusers Backend) ---
+import spaces
+import torch
+from diffusers import FlowMatchEulerDiscreteScheduler
+from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
+from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
+from diffusers.utils.export_utils import export_to_video
 import gradio as gr
-import argparse
+import tempfile
+from datetime import datetime
 import numpy as np
-import torch
-import einops
-import copy
-import math
-import time
+from PIL import Image
 import random
-from datetime import datetime
+import gc
+from gradio_client import Client, handle_file # Import for API call
 
-try:
-    import spaces
-except:
-    class spaces():
-        def GPU(*args, **kwargs):
-            def decorator(function):
-                return lambda *dummy_args, **dummy_kwargs: function(*dummy_args, **dummy_kwargs)
-            return decorator
+# Import the optimization function from the separate file
+from optimization import optimize_pipeline_
 
-import re
-import uuid
-
-from gradio_imageslider import ImageSlider
-from PIL import Image
-import imageio.v3 as iio
-from SUPIR.util import HWC3, upscale_image, fix_resize, convert_dtype, create_SUPIR_model, load_QF_ckpt
-from huggingface_hub import hf_hub_download
-import pillow_heif
+# --- Constants and Model Loading ---
+MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
 
-pillow_heif.register_heif_opener()
+# --- NEW: Flexible Dimension Constants ---
+MAX_DIMENSION = 832
+MIN_DIMENSION = 480
+DIMENSION_MULTIPLE = 16
+SQUARE_SIZE = 480
 
-max_64_bit_int = np.iinfo(np.int32).max
+MAX_SEED = np.iinfo(np.int32).max
 
-hf_hub_download(repo_id="laion/CLIP-ViT-bigG-14-laion2B-39B-b160k", filename="open_clip_pytorch_model.bin", local_dir="laion_CLIP-ViT-bigG-14-laion2B-39B-b160k")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="sd_xl_base_1.0_0.9vae.safetensors", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="SUPIR-v0F.ckpt", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="SUPIR-v0Q.ckpt", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="RunDiffusion/Juggernaut-XL-Lightning", filename="Juggernaut_RunDiffusionPhoto2_Lightning_4Steps.safetensors", local_dir="RunDiffusion_Juggernaut-XL-Lightning")
+FIXED_FPS = 24
+MIN_FRAMES_MODEL = 8
+MAX_FRAMES_MODEL = 81
 
-parser = argparse.ArgumentParser()
-parser.add_argument("--opt", type=str, default='options/SUPIR_v0.yaml')
-parser.add_argument("--ip", type=str, default='127.0.0.1')
-parser.add_argument("--port", type=int, default='6688')
-parser.add_argument("--no_llava", action='store_true', default=True)#False
-parser.add_argument("--use_image_slider", action='store_true', default=False)#False
-parser.add_argument("--log_history", action='store_true', default=False)
-parser.add_argument("--loading_half_params", action='store_true', default=False)#False
-parser.add_argument("--use_tile_vae", action='store_true', default=True)#False
-parser.add_argument("--encoder_tile_size", type=int, default=512)
-parser.add_argument("--decoder_tile_size", type=int, default=64)
-parser.add_argument("--load_8bit_llava", action='store_true', default=False)
-args = parser.parse_args()
+MIN_DURATION = round(MIN_FRAMES_MODEL/FIXED_FPS, 1)
+MAX_DURATION = round(MAX_FRAMES_MODEL/FIXED_FPS, 1)
 
 input_image_debug_value = [None]
+input_video_debug_value = [None]
+end_image_debug_value = [None]
 prompt_debug_value = [None]
-upscale_debug_value = [None]
-
-if torch.cuda.device_count() > 0:
-    SUPIR_device = 'cuda:0'
+total_second_length_debug_value = [None]
+
+default_negative_prompt = "Vibrant colors, overexposure, static, blurred details, subtitles, error, style, artwork, painting, image, still, overall gray, worst quality, low quality, JPEG compression residue, ugly, mutilated, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, malformed limbs, fused fingers, still image, cluttered background, three legs, many people in the background, walking backwards, overexposure, jumpcut, crossfader, "
+
+print("Loading models into memory. This may take a few minutes...")
+
+pipe = WanImageToVideoPipeline.from_pretrained(
+    MODEL_ID,
+    transformer=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
+        subfolder='transformer',
+        torch_dtype=torch.bfloat16,
+        device_map='cuda',
+    ),
+    transformer_2=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
+        subfolder='transformer_2',
+        torch_dtype=torch.bfloat16,
+        device_map='cuda',
+    ),
+    torch_dtype=torch.bfloat16,
+)
+pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, shift=8.0)
+pipe.to('cuda')
+
+
+
+print("Optimizing pipeline...")
+for i in range(3):
+    gc.collect()
+    torch.cuda.synchronize()
+    torch.cuda.empty_cache()
 
-    # Load SUPIR
-    model, default_setting = create_SUPIR_model(args.opt, SUPIR_sign='Q', load_default_setting=True)
-    if args.loading_half_params:
-        model = model.half()
-    if args.use_tile_vae:
-        model.init_tile_vae(encoder_tile_size=args.encoder_tile_size, decoder_tile_size=args.decoder_tile_size)
-    model = model.to(SUPIR_device)
-    model.first_stage_model.denoise_encoder_s1 = copy.deepcopy(model.first_stage_model.denoise_encoder)
-    model.current_model = 'v0-Q'
-    ckpt_Q, ckpt_F = load_QF_ckpt(args.opt)
+optimize_pipeline_(pipe,
+    image=Image.new('RGB', (MAX_DIMENSION, MIN_DIMENSION)), 
+    prompt='prompt',
+    height=MIN_DIMENSION,
+    width=MAX_DIMENSION,
+    num_frames=MAX_FRAMES_MODEL,
+)
+print("All models loaded and optimized. Gradio app is ready.")
 
-def check_upload(input_image):
-    if input_image is None:
-        raise gr.Error("Please provide an image to restore.")
-    return gr.update(visible = True)
 
-def update_seed(is_randomize_seed, seed):
-    if is_randomize_seed:
-        return random.randint(0, max_64_bit_int)
-    return seed
+# --- 2. Image Processing and Application Logic ---
+def generate_end_frame(start_img, gen_prompt, progress=gr.Progress(track_tqdm=True)):
+    """Calls an external Gradio API to generate an image."""
+    if start_img is None:
+        raise gr.Error("Please provide a Start Frame first.")
 
-def reset():
-    return [
-        None,
-        0,
-        None,
-        None,
-        "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-        "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-        1,
-        1024,
-        1,
-        2,
-        50,
-        -1.0,
-        1.,
-        default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0,
-        True,
-        random.randint(0, max_64_bit_int),
-        5,
-        1.003,
-        "Wavelet",
-        "fp32",
-        "fp32",
-        1.0,
-        True,
-        default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0,
-        False,
-        0.,
-        "v0-Q",
-        "input",
-        179
-    ]
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        raise gr.Error("HF_TOKEN not found in environment variables. Please set it in your Space secrets.")
 
-def check_and_update(input_image):
-    if input_image is None:
-        raise gr.Error("Please provide an image to restore.")
-    return [gr.update(visible = True), gr.update(interactive = True)]
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmpfile:
+        start_img.save(tmpfile.name)
+        tmp_path = tmpfile.name
 
-@spaces.GPU(duration=180)
-def stage1_process(
-    input_image,
-    gamma_correction,
-    diff_dtype,
-    ae_dtype
-):
-    print('stage1_process ==>>')
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return None, None, gr.update(interactive = False)
-    torch.cuda.set_device(SUPIR_device)
-    LQ = HWC3(np.array(Image.open(input_image)))
-    LQ = fix_resize(LQ, 512)
-    # stage1
-    LQ = np.array(LQ) / 255 * 2 - 1
-    LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
-
-    model.ae_dtype = convert_dtype(ae_dtype)
-    model.model.dtype = convert_dtype(diff_dtype)
+    progress(0.1, desc="Connecting to image generation API...")
+    client = Client("multimodalart/nano-banana-private")
+    
+    progress(0.5, desc=f"Generating with prompt: '{gen_prompt}'...")
+    try:
+        result = client.predict(
+            prompt=gen_prompt, 
+            images=[
+                {"image": handle_file(tmp_path)}
+            ],
+            manual_token=hf_token,
+            api_name="/unified_image_generator"
+        )
+    finally:
+        os.remove(tmp_path)
 
-    LQ = model.batchify_denoise(LQ, is_stage1=True)
-    LQ = (LQ[0].permute(1, 2, 0) * 127.5 + 127.5).cpu().numpy().round().clip(0, 255).astype(np.uint8)
-    # gamma correction
-    LQ = LQ / 255.0
-    LQ = np.power(LQ, gamma_correction)
-    LQ *= 255.0
-    LQ = LQ.round().clip(0, 255).astype(np.uint8)
-    print('<<== stage1_process')
-    return LQ, gr.update(visible = True)
+    progress(1.0, desc="Done!")
+    print(result)
+    return result
 
-def stage2_process_example(*args, **kwargs):
-    [result_slider, result_gallery, restore_information, reset_btn, warning, dummy_button] = restore_in_Xmin(*args, **kwargs)
-    #outputs_folder = './outputs/'
-    outputs_folder = './tmp/'
-    os.makedirs(outputs_folder, exist_ok=True)
-    output_filename = os.path.join(outputs_folder, datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + '.png')
-    print(output_filename)
-    iio.imwrite(output_filename, result_slider[1], format="png")
-    return [gr.update(visible = True, value=output_filename), warning, dummy_button, gr.skip()]
+def switch_to_upload_tab():
+    """Returns a gr.Tabs update to switch to the first tab."""
+    return gr.Tabs(selected="upload_tab")
 
-def stage2_process(*args, **kwargs):
-    try:
-        return restore_in_Xmin(*args, **kwargs)
-    except Exception as e:
-        # NO_GPU_MESSAGE_INQUEUE
-        print("gradio.exceptions.Error 'No GPU is currently available for you after 60s'")
-        print('str(type(e)): ' + str(type(e))) # <class 'gradio.exceptions.Error'>
-        print('str(e): ' + str(e)) # You have exceeded your GPU quota...
-        try:
-            print('e.message: ' + e.message) # No GPU is currently available for you after 60s
-        except Exception as e2:
-            print('Failure')
-        if str(e).startswith("No GPU is currently available for you after 60s"):
-            print('Exception identified!!!')
-        #if str(type(e)) == "<class 'gradio.exceptions.Error'>":
-            #print('Exception of name ' + type(e).__name__)
-        raise e
 
-def restore_in_Xmin(
-    noisy_image,
-    rotation,
-    denoise_image,
+def process_image_for_video(image: Image.Image) -> Image.Image:
+    """
+    Resizes an image based on the following rules for video generation:
+    1. The longest side will be scaled down to MAX_DIMENSION if it's larger.
+    2. The shortest side will be scaled up to MIN_DIMENSION if it's smaller.
+    3. The final dimensions will be rounded to the nearest multiple of DIMENSION_MULTIPLE.
+    4. Square images are resized to a fixed SQUARE_SIZE.
+    The aspect ratio is preserved as closely as possible.
+    """
+    width, height = image.size
+
+    # Rule 4: Handle square images
+    if width == height:
+        return image.resize((SQUARE_SIZE, SQUARE_SIZE), Image.Resampling.LANCZOS)
+
+    # Determine target dimensions while preserving aspect ratio
+    aspect_ratio = width / height
+    new_width, new_height = width, height
+
+    # Rule 1: Scale down if too large
+    if new_width > MAX_DIMENSION or new_height > MAX_DIMENSION:
+        if aspect_ratio > 1:  # Landscape
+            scale = MAX_DIMENSION / new_width
+        else:  # Portrait
+            scale = MAX_DIMENSION / new_height
+        new_width *= scale
+        new_height *= scale
+
+    # Rule 2: Scale up if too small
+    if new_width < MIN_DIMENSION or new_height < MIN_DIMENSION:
+        if aspect_ratio > 1:  # Landscape
+            scale = MIN_DIMENSION / new_height
+        else:  # Portrait
+            scale = MIN_DIMENSION / new_width
+        new_width *= scale
+        new_height *= scale
+
+    # Rule 3: Round to the nearest multiple of DIMENSION_MULTIPLE
+    final_width = int(round(new_width / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
+    final_height = int(round(new_height / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
+    
+    # Ensure final dimensions are at least the minimum
+    final_width = max(final_width, MIN_DIMENSION if aspect_ratio < 1 else SQUARE_SIZE)
+    final_height = max(final_height, MIN_DIMENSION if aspect_ratio > 1 else SQUARE_SIZE)
+
+
+    return image.resize((final_width, final_height), Image.Resampling.LANCZOS)
+
+def resize_and_crop_to_match(target_image, reference_image):
+    """Resizes and center-crops the target image to match the reference image's dimensions."""
+    ref_width, ref_height = reference_image.size
+    target_width, target_height = target_image.size
+    scale = max(ref_width / target_width, ref_height / target_height)
+    new_width, new_height = int(target_width * scale), int(target_height * scale)
+    resized = target_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    left, top = (new_width - ref_width) // 2, (new_height - ref_height) // 2
+    return resized.crop((left, top, left + ref_width, top + ref_height))
+
+def generate_video(
+    start_image_pil,
+    end_image_pil,
     prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
-    seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    spt_linear_CFG,
-    linear_s_stage2,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
+    negative_prompt=default_negative_prompt,
+    duration_seconds=2.1,
+    steps=8,
+    guidance_scale=1,
+    guidance_scale_2=1,
+    seed=42,
+    randomize_seed=True,
+    progress=gr.Progress(track_tqdm=True)
 ):
-    print("noisy_image:\n" + str(noisy_image))
-    print("denoise_image:\n" + str(denoise_image))
-    print("rotation: " + str(rotation))
-    print("prompt: " + str(prompt))
-    print("a_prompt: " + str(a_prompt))
-    print("n_prompt: " + str(n_prompt))
-    print("num_samples: " + str(num_samples))
-    print("min_size: " + str(min_size))
-    print("downscale: " + str(downscale))
-    print("upscale: " + str(upscale))
-    print("edm_steps: " + str(edm_steps))
-    print("s_stage1: " + str(s_stage1))
-    print("s_stage2: " + str(s_stage2))
-    print("s_cfg: " + str(s_cfg))
-    print("randomize_seed: " + str(randomize_seed))
-    print("seed: " + str(seed))
-    print("s_churn: " + str(s_churn))
-    print("s_noise: " + str(s_noise))
-    print("color_fix_type: " + str(color_fix_type))
-    print("diff_dtype: " + str(diff_dtype))
-    print("ae_dtype: " + str(ae_dtype))
-    print("gamma_correction: " + str(gamma_correction))
-    print("linear_CFG: " + str(linear_CFG))
-    print("linear_s_stage2: " + str(linear_s_stage2))
-    print("spt_linear_CFG: " + str(spt_linear_CFG))
-    print("spt_linear_s_stage2: " + str(spt_linear_s_stage2))
-    print("model_select: " + str(model_select))
-    print("GPU time allocation: " + str(allocation) + " min")
-    print("output_format: " + str(output_format))
-
-    if input_image_debug_value[0] is not None or prompt_debug_value[0] is not None or upscale_debug_value[0] is not None:
-        denoise_image = noisy_image = input_image_debug_value[0]
-        a_prompt = prompt_debug_value[0]
-        upscale = upscale_debug_value[0]
-        allocation = min(allocation * 60 * 100, 600)
-        seed = random.randint(0, max_64_bit_int)
-
-    input_format = re.sub(r"^.*\.([^\.]+)$", r"\1", noisy_image)
-
-    if input_format not in ['png', 'webp', 'jpg', 'jpeg', 'gif', 'bmp', 'avif']:
-        gr.Warning('Invalid image format. Please first convert into *.png, *.webp, *.jpg, *.jpeg, *.gif, *.bmp, *.heic or *.avif.')
-        return None, None, None, None, None, gr.update(interactive = False)
-
-    if output_format == "input":
-        if noisy_image is None:
-            output_format = "png"
-        else:
-            output_format = input_format
-    print("final output_format: " + str(output_format))
-
-    if prompt is None:
-        prompt = ""
-
-    if a_prompt is None:
-        a_prompt = ""
-
-    if n_prompt is None:
-        n_prompt = ""
-
-    if prompt != "" and a_prompt != "":
-        a_prompt = prompt + ", " + a_prompt
-    else:
-        a_prompt = prompt + a_prompt
-    print("Final prompt: " + str(a_prompt))
-
-    denoise_image = np.array(Image.open(noisy_image if denoise_image is None else denoise_image))
-
-    if rotation == 90:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == 180:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == -90:
-        denoise_image = np.array(list(zip(*denoise_image))[::-1])
-
-    if 1 < downscale:
-        input_height, input_width, input_channel = denoise_image.shape
-        denoise_image = np.array(Image.fromarray(denoise_image).resize((input_width // downscale, input_height // downscale), Image.LANCZOS))
-
-    denoise_image = HWC3(denoise_image)
-
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return [noisy_image, denoise_image], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = [denoise_image]), None, gr.update(visible=True)
-
-    if model_select != model.current_model:
-        print('load ' + model_select)
-        if model_select == 'v0-Q':
-            model.load_state_dict(ckpt_Q, strict=False)
-        elif model_select == 'v0-F':
-            model.load_state_dict(ckpt_F, strict=False)
-        model.current_model = model_select
-
-    model.ae_dtype = convert_dtype(ae_dtype)
-    model.model.dtype = convert_dtype(diff_dtype)
-
-    return restore_on_gpu(
-        noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-    )
+    allocation_time = 120
+    factor = 1
+    
+    if input_image_debug_value[0] is not None or end_image_debug_value[0] is not None or prompt_debug_value[0] is not None or total_second_length_debug_value[0] is not None:
+        start_image_pil = input_image_debug_value[0]
+        end_image_pil = end_image_debug_value[0]
+        prompt = prompt_debug_value[0]
+        duration_seconds = total_second_length_debug_value[0]
+        allocation_time = min(duration_seconds * 60 * 100, 10 * 60)
+        factor = 3.5
+
+    return generate_video_on_gpu(
+    start_image_pil,
+    end_image_pil,
+    prompt,
+    negative_prompt,
+    duration_seconds,
+    steps,
+    guidance_scale,
+    guidance_scale_2,
+    seed,
+    randomize_seed,
+    progress,
+    allocation_time,
+    factor
+)
 
 def get_duration(
-    noisy_image,
-    input_image,
+    start_image_pil,
+    end_image_pil,
     prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
+    negative_prompt,
+    duration_seconds,
+    steps,
+    guidance_scale,
+    guidance_scale_2,
     seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    spt_linear_CFG,
-    linear_s_stage2,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
+    randomize_seed,
+    progress,
+    allocation_time,
+    factor
 ):
-    return allocation
+    return allocation_time
 
 @spaces.GPU(duration=get_duration)
-def restore_on_gpu(
-    noisy_image,
-    input_image,
+def generate_video_on_gpu(
+    start_image_pil,
+    end_image_pil,
     prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
+    negative_prompt,
+    duration_seconds,
+    steps,
+    guidance_scale,
+    guidance_scale_2,
     seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    spt_linear_CFG,
-    linear_s_stage2,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
+    randomize_seed,
+    progress,
+    allocation_time,
+    factor
 ):
-    start = time.time()
-    print('restore ==>>')
-
-    torch.cuda.set_device(SUPIR_device)
-
-    with torch.no_grad():
-        input_image = upscale_image(input_image, upscale, unit_resolution=32, min_size=min_size)
-        LQ = np.array(input_image) / 255.0
-        LQ = np.power(LQ, gamma_correction)
-        LQ *= 255.0
-        LQ = LQ.round().clip(0, 255).astype(np.uint8)
-        LQ = LQ / 255 * 2 - 1
-        LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
-        captions = ['']
-
-        samples = model.batchify_sample(LQ, captions, num_steps=edm_steps, restoration_scale=s_stage1, s_churn=s_churn,
-                                    s_noise=s_noise, cfg_scale=s_cfg, control_scale=s_stage2, seed=seed,
-                                    num_samples=num_samples, p_p=a_prompt, n_p=n_prompt, color_fix_type=color_fix_type,
-                                    use_linear_CFG=linear_CFG, use_linear_control_scale=linear_s_stage2,
-                                    cfg_scale_start=spt_linear_CFG, control_scale_start=spt_linear_s_stage2)
-
-        x_samples = (einops.rearrange(samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().round().clip(
-            0, 255).astype(np.uint8)
-        results = [x_samples[i] for i in range(num_samples)]
-    torch.cuda.empty_cache()
-
-    # All the results have the same size
-    input_height, input_width, input_channel = np.array(input_image).shape
-    result_height, result_width, result_channel = np.array(results[0]).shape
-
-    print('<<== restore')
-    end = time.time()
-    secondes = int(end - start)
-    minutes = math.floor(secondes / 60)
-    secondes = secondes - (minutes * 60)
-    hours = math.floor(minutes / 60)
-    minutes = minutes - (hours * 60)
-    information = ("Start the process again if you want a different result. " if randomize_seed else "") + \
-    "If you don't get the image you wanted, add more details in the « Image description ». " + \
-    "The image" + (" has" if len(results) == 1 else "s have") + " been generated in " + \
-    ((str(hours) + " h, ") if hours != 0 else "") + \
-    ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
-    str(secondes) + " sec. " + \
-    "The new image resolution is " + str(result_width) + \
-    " pixels large and " + str(result_height) + \
-    " pixels high, so a resolution of " + f'{result_width * result_height:,}' + " pixels."
-    print(information)
-    try:
-        print("Initial resolution: " + f'{input_width * input_height:,}')
-        print("Final resolution: " + f'{result_width * result_height:,}')
-        print("edm_steps: " + str(edm_steps))
-        print("num_samples: " + str(num_samples))
-        print("downscale: " + str(downscale))
-        print("Estimated minutes: " + f'{(((result_width * result_height**(1/1.75)) * input_width * input_height * (edm_steps**(1/2)) * (num_samples**(1/2.5)))**(1/2.5)) / 25000:,}')
-    except Exception as e:
-        print('Exception of Estimation')
-
-    # Only one image can be shown in the slider
-    return [noisy_image] + [results[0]], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = results), gr.update(value = information, visible = True), gr.update(visible=True), gr.update(visible=False), gr.update(interactive = False)
-
-def load_and_reset(param_setting):
-    print('load_and_reset ==>>')
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return None, None, None, None, None, None, None, None, None, None, None, None, None, None
-    edm_steps = default_setting.edm_steps
-    s_stage2 = 1.0
-    s_stage1 = -1.0
-    s_churn = 5
-    s_noise = 1.003
-    a_prompt = 'Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - ' \
-               'realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore ' \
-               'detailing, hyper sharpness, perfect without deformations.'
-    n_prompt = 'painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, ' \
-               '3D render, unreal engine, blurring, dirty, messy, worst quality, low quality, frames, watermark, ' \
-               'signature, jpeg artifacts, deformed, lowres, over-smooth'
-    color_fix_type = 'Wavelet'
-    spt_linear_s_stage2 = 0.0
-    linear_s_stage2 = False
-    linear_CFG = True
-    if param_setting == "Quality":
-        s_cfg = default_setting.s_cfg_Quality
-        spt_linear_CFG = default_setting.spt_linear_CFG_Quality
-        model_select = "v0-Q"
-    elif param_setting == "Fidelity":
-        s_cfg = default_setting.s_cfg_Fidelity
-        spt_linear_CFG = default_setting.spt_linear_CFG_Fidelity
-        model_select = "v0-F"
-    else:
-        raise NotImplementedError
-    gr.Info('The parameters are reset.')
-    print('<<== load_and_reset')
-    return edm_steps, s_cfg, s_stage2, s_stage1, s_churn, s_noise, a_prompt, n_prompt, color_fix_type, linear_CFG, \
-        spt_linear_CFG, linear_s_stage2, spt_linear_s_stage2, model_select
-
-def log_information(result_gallery):
-    print('log_information')
-    if result_gallery is not None:
-        for i, result in enumerate(result_gallery):
-            print(result[0])
-
-def on_select_result(result_slider, result_gallery, evt: gr.SelectData):
-    print('on_select_result')
-    if result_gallery is not None:
-        for i, result in enumerate(result_gallery):
-            print(result[0])
-    return [result_slider[0], result_gallery[evt.index][0]]
-
-def on_render_image_example(result_example):
-    print('on_render_image_example')
-    return gr.update(value = result_example, visible = True)
-
-title_html = """
-    <h1><center>SUPIR</center></h1>
-    <big><center>Upscale your images up to x10 freely, without account, without watermark and download it</center></big>
-    <center><big><big>🤸<big><big><big><big><big><big>🤸</big></big></big></big></big></big></big></big></center>
-    
-    <p>This is an online demo of SUPIR, a practicing model scaling for photo-realistic image restoration.
-    The content added by SUPIR is <b><u>imagination, not real-world information</u></b>.
-    SUPIR is for beauty and illustration only.
-    Most of the processes last few minutes.
-    If you want to upscale AI-generated images, be noticed that <i>PixArt Sigma</i> space can directly generate 5984x5984 images.
-    Due to Gradio issues, the generated image is slightly less satured than the original.
-    Please leave a <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">message in discussion</a> if you encounter issues.
-    You can also use <a href="https://huggingface.co/spaces/gokaygokay/AuraSR">AuraSR</a> to upscale x4.
-    
-    <p><center><a href="https://arxiv.org/abs/2401.13627">Paper</a> &emsp; <a href="http://supir.xpixel.group/">Project Page</a> &emsp; <a href="https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai">Local Install Guide</a></center></p>
-    <p><center><a style="display:inline-block" href='https://github.com/Fanghua-Yu/SUPIR'><img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/Fanghua-Yu/SUPIR?style=social"></a></center></p>
     """
+    Generates a video by interpolating between a start and end image, guided by a text prompt,
+    using the diffusers Wan2.2 pipeline.
+    """
+    if start_image_pil is None or end_image_pil is None:
+        raise gr.Error("Please upload both a start and an end image.")
 
+    progress(0.1, desc="Preprocessing images...")
 
-claim_md = """
-## **Piracy**
-The images are not stored but the logs are saved during a month.
-## **How to get SUPIR**
-You can get SUPIR on HuggingFace by [duplicating this space](https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true) and set GPU.
-You can also install SUPIR on your computer following [this tutorial](https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai).
-You can install _Pinokio_ on your computer and then install _SUPIR_ into it. It should be quite easy if you have an Nvidia GPU.
-## **Terms of use**
-By using this service, users are required to agree to the following terms: The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research. Please submit a feedback to us if you get any inappropriate answer! We will collect those to keep improving our models. For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
-## **License**
-The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/Fanghua-Yu/SUPIR) of SUPIR.
-"""
-
-js = """
-function createGradioAnimation() {
-    window.addEventListener("beforeunload", function(e) {
-        if (document.getElementById('dummy_button_id') && !document.getElementById('dummy_button_id').disabled) {
-            var confirmationMessage = 'A process is still running. '
-                                    + 'If you leave before saving, your changes will be lost.';
+    # Step 1: Process the start image to get our target dimensions based on the new rules.
+    processed_start_image = process_image_for_video(start_image_pil)
     
-            (e || window.event).returnValue = confirmationMessage;
-        }
-        return confirmationMessage;
-    });
-    return 'Animation created';
-}
-"""
-
-# Gradio interface
-with gr.Blocks(js=js) as interface:
-    if torch.cuda.device_count() == 0:
-        with gr.Row():
-            gr.HTML("""
-    <p style="background-color: red;"><big><big><big><b>⚠️To use SUPIR, <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true">duplicate this space</a> and set a GPU with 30 GB VRAM.</b>
+    # Step 2: Make the end image match the *exact* dimensions of the processed start image.
+    processed_end_image = resize_and_crop_to_match(end_image_pil, processed_start_image)
     
-    You can't use SUPIR directly here because this space runs on a CPU, which is not enough for SUPIR. Please provide <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">feedback</a> if you have issues.
-    </big></big></big></p>
-    """)
-    gr.HTML(title_html)
-
-    input_image = gr.Image(label="Input (*.png, *.webp, *.jpeg, *.jpg, *.gif, *.bmp, *.avif)", show_label=True, type="filepath", height=600, elem_id="image-input")
-    rotation = gr.Radio([["No rotation", 0], ["⤵ Rotate +90°", 90], ["↩ Return 180°", 180], ["⤴ Rotate -90°", -90]], label="Orientation correction", info="Will apply the following rotation before restoring the image; the AI needs a good orientation to understand the content", value=0, visible=False)
-    with gr.Group():
-        prompt = gr.Textbox(label="Image description", info="Help the AI understand what the image represents; describe as much as possible, especially the details we can't see on the original image; you can write in any language", value="", placeholder="A 33 years old man, walking, in the street, Santiago, morning, Summer, photorealistic", lines=3)
-        prompt_hint = gr.HTML("You can use a <a href='"'https://huggingface.co/spaces/badayvedat/LLaVA'"'>LlaVa space</a> to auto-generate the description of your image.")
-        upscale = gr.Radio([["x1", 1], ["x2", 2], ["x3", 3], ["x4", 4], ["x5", 5], ["x6", 6], ["x7", 7], ["x8", 8], ["x9", 9], ["x10", 10]], label="Upscale factor", info="Resolution x1 to x10", value=2)
-        output_format = gr.Radio([["As input", "input"], ["*.png", "png"], ["*.webp", "webp"], ["*.jpeg", "jpeg"], ["*.gif", "gif"], ["*.bmp", "bmp"]], label="Image format for result", info="File extention", value="input")
-        allocation = gr.Slider(label="GPU allocation time (in seconds)", info='lower=May abort run, higher=Quota penalty for next runs; only useful for ZeroGPU; for instance set to 88 when you have the message "You have exceeded your GPU quota (180s requested vs. 89s left)."', value=180, minimum=60, maximum=320, step=1)
-
-    with gr.Accordion("Pre-denoising (optional)", open=False):
-        gamma_correction = gr.Slider(label="Gamma Correction", info = "lower=lighter, higher=darker", minimum=0.1, maximum=2.0, value=1.0, step=0.1)
-        denoise_button = gr.Button(value="Pre-denoise")
-        denoise_image = gr.Image(label="Denoised image", show_label=True, type="filepath", sources=[], interactive = False, height=600, elem_id="image-s1")
-        denoise_information = gr.HTML(value="If present, the denoised image will be used for the restoration instead of the input image.", visible=False)
-
-    with gr.Accordion("Advanced options", open=False):
-        a_prompt = gr.Textbox(label="Additional image description",
-                              info="Completes the main image description",
-                              value='Cinematic, High Contrast, highly detailed, taken using a Canon EOS R '
-                                    'camera, hyper detailed photo - realistic maximum detail, 32k, Color '
-                                    'Grading, ultra HD, extreme meticulous detailing, skin pore detailing, clothing fabric detailing, '
-                                    'hyper sharpness, perfect without deformations.',
-                              lines=3)
-        n_prompt = gr.Textbox(label="Negative image description",
-                              info="Disambiguate by listing what the image does NOT represent",
-                              value='painting, oil painting, illustration, drawing, art, sketch, anime, '
-                                    'cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, '
-                                    'worst quality, low quality, frames, watermark, signature, jpeg artifacts, '
-                                    'deformed, lowres, over-smooth',
-                              lines=3)
-        edm_steps = gr.Slider(label="Steps", info="lower=faster, higher=more details; too many steps create a checker effect", minimum=1, maximum=200, value=default_setting.edm_steps if torch.cuda.device_count() > 0 else 1, step=1)
-        num_samples = gr.Slider(label="Num Samples", info="Number of generated results", minimum=1, maximum=4 if not args.use_image_slider else 1
-                                , value=1, step=1)
-        min_size = gr.Slider(label="Minimum size", info="Minimum height, minimum width of the result", minimum=32, maximum=4096, value=1024, step=32)
-        downscale = gr.Radio([["/1", 1], ["/2", 2], ["/3", 3], ["/4", 4], ["/5", 5], ["/6", 6], ["/7", 7], ["/8", 8], ["/9", 9], ["/10", 10]], label="Pre-downscale factor", info="Reducing blurred image reduce the process time", value=1)
-        with gr.Row():
-            with gr.Column():
-                model_select = gr.Radio([["💃 Quality (v0-Q)", "v0-Q"], ["🎯 Fidelity (v0-F)", "v0-F"]], label="Model Selection", info="Pretrained model", value="v0-Q")
-            with gr.Column():
-                color_fix_type = gr.Radio([["None", "None"], ["AdaIn (improve as a photo)", "AdaIn"], ["Wavelet (for JPEG artifacts)", "Wavelet"]], label="Color-Fix Type", info="AdaIn=Improve following a style, Wavelet=For JPEG artifacts", value="AdaIn")
-        s_cfg = gr.Slider(label="Text Guidance Scale", info="lower=follow the image, higher=follow the prompt", minimum=1.0, maximum=15.0,
-                          value=default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.1)
-        s_stage2 = gr.Slider(label="Restoring Guidance Strength", minimum=0., maximum=1., value=1., step=0.05)
-        s_stage1 = gr.Slider(label="Pre-denoising Guidance Strength", minimum=-1.0, maximum=6.0, value=-1.0, step=1.0)
-        s_churn = gr.Slider(label="S-Churn", minimum=0, maximum=40, value=5, step=1)
-        s_noise = gr.Slider(label="S-Noise", minimum=1.0, maximum=1.1, value=1.003, step=0.001)
-        with gr.Row():
-            with gr.Column():
-                linear_CFG = gr.Checkbox(label="Linear CFG", value=True)
-                spt_linear_CFG = gr.Slider(label="CFG Start", minimum=1.0,
-                                                maximum=9.0, value=default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.5)
-            with gr.Column():
-                linear_s_stage2 = gr.Checkbox(label="Linear Restoring Guidance", value=False)
-                spt_linear_s_stage2 = gr.Slider(label="Guidance Start", minimum=0.,
-                                                maximum=1., value=0., step=0.05)
-            with gr.Column():
-                diff_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["fp16 (medium)", "fp16"], ["bf16 (speed)", "bf16"]], label="Diffusion Data Type", value="fp32")
-            with gr.Column():
-                ae_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["bf16 (speed)", "bf16"]], label="Auto-Encoder Data Type", value="fp32")
-        randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed", value = True, info = "If checked, result is always different")
-        seed = gr.Slider(label="Seed", minimum=0, maximum=max_64_bit_int, step=1, randomize=True)
-        with gr.Group():
-            param_setting = gr.Radio(["Quality", "Fidelity"], label="Presetting", value = "Quality")
-            restart_button = gr.Button(value="Apply presetting")
-
-    with gr.Accordion("Debug", open=False):
-        input_image_debug = gr.Image(label="Image Debug", type="filepath")
-        prompt_debug = gr.Textbox(label="Prompt Debug", value='')
-        upscale_debug = gr.Radio([["x1", 1], ["x2", 2], ["x3", 3], ["x4", 4], ["x5", 5], ["x6", 6], ["x7", 7], ["x8", 8], ["x9", 9], ["x10", 10]], label="Upscale factor Debug", info="Resolution x1 to x10", value=2)
-
-    with gr.Column():
-        diffusion_button = gr.Button(value="🚀 Upscale/Restore", variant = "primary", elem_id = "process_button")
-        reset_btn = gr.Button(value="🧹 Reinit page", variant="stop", elem_id="reset_button", visible = False)
-        dummy_button = gr.Button(elem_id = "dummy_button_id", visible = False, interactive = False)
-
-        warning = gr.HTML(elem_id="warning", value = "<center><big>Your computer must <u>not</u> enter into standby mode.</big><br/>On Chrome, you can force to keep a tab alive in <code>chrome://discards/</code></center>", visible = False)
-        restore_information = gr.HTML(value = "Restart the process to get another result.", visible = False)
-        result_slider = ImageSlider(label = 'Comparator', show_label = False, interactive = False, elem_id = "slider1", show_download_button = False, visible = False)
-        result_gallery = gr.Gallery(label = 'Downloadable results', show_label = True, interactive = False, elem_id = "gallery1")
-        result_example = gr.HTML(elem_id="result_example", visible = False)
-        result_image_example = gr.Image(label="Example Image", visible = False)
-
-    with gr.Row(elem_id="examples", visible = False):
-        gr.Examples(
-            label = "Examples for cache",
-            examples = [
-                    [
-                        "./Examples/Example2.jpeg",
-                        0,
-                        "./Examples/Example2.jpeg",
-                        "La cabeza de un gato atigrado, en una casa, fotorrealista, 8k, extremadamente detallada",
-                        "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                        "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                        1,         # num_samples
-                        32,        # min_size
-                        1,         # downscale
-                        1,         # upscale
-                        100,       # edm_steps
-                        -1,        # s_stage1
-                        1,         # s_stage2
-                        7.5,       # s_cfg
-                        True,     # randomize_seed
-                        42,        # seed
-                        5,         # s_churn
-                        1.003,     # s_noise
-                        "Wavelet", # color_fix_type
-                        "fp16",    # diff_dtype
-                        "bf16",    # ae_dtype
-                        1.0,       # gamma_correction
-                        True,      # linear_CFG
-                        4,         # spt_linear_CFG
-                        False,     # linear_s_stage2
-                        0.,        # spt_linear_s_stage2
-                        "v0-Q",    # model_select
-                        "input",   # output_format
-                        60         # allocation
-                    ],
-                    [
-                        "./Examples/Example2.jpeg",
-                        0,
-                        "./Examples/Example2.jpeg",
-                        "La cabeza de un gato atigrado, en una casa, fotorrealista, 8k, extremadamente detallada",
-                        "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                        "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                        4,         # num_samples
-                        32,        # min_size
-                        1,         # downscale
-                        1,         # upscale
-                        100,       # edm_steps
-                        -1,        # s_stage1
-                        1,         # s_stage2
-                        7.5,       # s_cfg
-                        True,     # randomize_seed
-                        42,        # seed
-                        5,         # s_churn
-                        1.003,     # s_noise
-                        "Wavelet", # color_fix_type
-                        "fp16",    # diff_dtype
-                        "bf16",    # ae_dtype
-                        1.0,       # gamma_correction
-                        True,      # linear_CFG
-                        4,         # spt_linear_CFG
-                        False,     # linear_s_stage2
-                        0.,        # spt_linear_s_stage2
-                        "v0-Q",    # model_select
-                        "input",   # output_format
-                        60         # allocation
-                    ]
-                ],
-            run_on_click = True,
-            fn = stage2_process_example,
-    	    inputs = [
-                input_image,
-                rotation,
-                denoise_image,
-                prompt,
-                a_prompt,
-                n_prompt,
-                num_samples,
-                min_size,
-                downscale,
-                upscale,
-                edm_steps,
-                s_stage1,
-                s_stage2,
-                s_cfg,
-                randomize_seed,
-                seed,
-                s_churn,
-                s_noise,
-                color_fix_type,
-                diff_dtype,
-                ae_dtype,
-                gamma_correction,
-                linear_CFG,
-                spt_linear_CFG,
-                linear_s_stage2,
-                spt_linear_s_stage2,
-                model_select,
-                output_format,
-                allocation
-            ],
-    	    outputs = [
-            result_example,
-                warning,
-                dummy_button,
-                prompt_hint
-            ],
-            cache_examples = True,
-        )
-
-    gr.Examples(
-        label = "Examples for demo",
-        examples = [
-                [
-                    "./Examples/Example1.png",
-                    0,
-                    "./Examples/Example1.png",
-                    "Group of people, walking, happy, in the street, photorealistic, 8k, extremely detailled",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    2,       # num_samples
-                    1024,    # min_size
-                    1,       # downscale
-                    8,       # upscale
-                    100,     # edm_steps
-                    -1,      # s_stage1
-                    1,       # s_stage2
-                    7.5,     # s_cfg
-                    False,   # randomize_seed
-                    42,      # seed
-                    5,       # s_churn
-                    1.003,   # s_noise
-                    "AdaIn", # color_fix_type
-                    "fp16",  # diff_dtype
-                    "bf16",  # ae_dtype
-                    1.0,     # gamma_correction
-                    True,    # linear_CFG
-                    4,       # spt_linear_CFG
-                    False,   # linear_s_stage2
-                    0.,      # spt_linear_s_stage2
-                    "v0-Q",  # model_select
-                    "input", # output_format
-                    180      # allocation
-                ],
-                [
-                    "./Examples/Example2.jpeg",
-                    0,
-                    "./Examples/Example2.jpeg",
-                    "La cabeza de un gato atigrado, en una casa, fotorrealista, 8k, extremadamente detallada",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,         # num_samples
-                    1024,      # min_size
-                    1,         # downscale
-                    1,         # upscale
-                    100,       # edm_steps
-                    -1,        # s_stage1
-                    1,         # s_stage2
-                    7.5,       # s_cfg
-                    False,     # randomize_seed
-                    42,        # seed
-                    5,         # s_churn
-                    1.003,     # s_noise
-                    "Wavelet", # color_fix_type
-                    "fp16",    # diff_dtype
-                    "bf16",    # ae_dtype
-                    1.0,       # gamma_correction
-                    True,      # linear_CFG
-                    4,         # spt_linear_CFG
-                    False,     # linear_s_stage2
-                    0.,        # spt_linear_s_stage2
-                    "v0-Q",    # model_select
-                    "input",   # output_format
-                    60         # allocation
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
-                    "./Examples/Example3.webp",
-                    "A red apple",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,         # num_samples
-                    1024,      # min_size
-                    1,         # downscale
-                    1,         # upscale
-                    200,       # edm_steps
-                    -1,        # s_stage1
-                    1,         # s_stage2
-                    7.5,       # s_cfg
-                    False,     # randomize_seed
-                    42,        # seed
-                    5,         # s_churn
-                    1.003,     # s_noise
-                    "Wavelet", # color_fix_type
-                    "fp16",    # diff_dtype
-                    "bf16",    # ae_dtype
-                    1.0,       # gamma_correction
-                    True,      # linear_CFG
-                    4,         # spt_linear_CFG
-                    False,     # linear_s_stage2
-                    0.,        # spt_linear_s_stage2
-                    "v0-Q",    # model_select
-                    "input",   # output_format
-                    180        # allocation
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
-                    "./Examples/Example3.webp",
-                    "A red marble",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,         # num_samples
-                    1024,      # min_size
-                    1,         # downscale
-                    1,         # upscale
-                    200,       # edm_steps
-                    -1,        # s_stage1
-                    1,         # s_stage2
-                    7.5,       # s_cfg
-                    False,     # randomize_seed
-                    42,        # seed
-                    5,         # s_churn
-                    1.003,     # s_noise
-                    "Wavelet", # color_fix_type
-                    "fp16",    # diff_dtype
-                    "bf16",    # ae_dtype
-                    1.0,       # gamma_correction
-                    True,      # linear_CFG
-                    4,         # spt_linear_CFG
-                    False,     # linear_s_stage2
-                    0.,        # spt_linear_s_stage2
-                    "v0-Q",    # model_select
-                    "input",   # output_format
-                    180        # allocation
-                ],
-            ],
-        run_on_click = True,
-        fn = stage2_process,
-	    inputs = [
-            input_image,
-            rotation,
-            denoise_image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            min_size,
-            downscale,
-            upscale,
-            edm_steps,
-            s_stage1,
-            s_stage2,
-            s_cfg,
-            randomize_seed,
-            seed,
-            s_churn,
-            s_noise,
-            color_fix_type,
-            diff_dtype,
-            ae_dtype,
-            gamma_correction,
-            linear_CFG,
-            spt_linear_CFG,
-            linear_s_stage2,
-            spt_linear_s_stage2,
-            model_select,
-            output_format,
-            allocation
-        ],
-	    outputs = [
-            result_slider,
-            result_gallery,
-            restore_information,
-            reset_btn,
-            warning,
-            dummy_button
-        ],
-        cache_examples = False,
-    )
-
-    with gr.Row():
-        gr.Markdown(claim_md)
+    target_height, target_width = processed_start_image.height, processed_start_image.width
+
+    # Handle seed and frame count
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
+
+    progress(0.2, desc=f"Generating {num_frames} frames at {target_width}x{target_height} (seed: {current_seed})...")
+
+    output_frames_list = pipe(
+        image=processed_start_image,
+        last_image=processed_end_image,
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        height=target_height,
+        width=target_width,
+        num_frames=int(num_frames * factor),
+        guidance_scale=float(guidance_scale),
+        guidance_scale_2=float(guidance_scale_2),
+        num_inference_steps=int(steps),
+        generator=torch.Generator(device="cuda").manual_seed(current_seed),
+    ).frames[0]
+
+    progress(0.9, desc="Encoding and saving video...")
     
-    input_image.upload(fn = check_upload, inputs = [
-        input_image
-    ], outputs = [
-        rotation
-    ], queue = False, show_progress = False)
-
-    denoise_button.click(fn = check_and_update, inputs = [
-        input_image
-    ], outputs = [warning, dummy_button], queue = False, show_progress = False).success(fn = stage1_process, inputs = [
-        input_image,
-        gamma_correction,
-        diff_dtype,
-        ae_dtype
-    ], outputs=[
-        denoise_image,
-        denoise_information,
-        dummy_button
-    ])
-
-    diffusion_button.click(fn = update_seed, inputs = [
-        randomize_seed,
-        seed
-    ], outputs = [
-        seed
-    ], queue = False, show_progress = False).then(fn = check_and_update, inputs = [
-        input_image
-    ], outputs = [warning, dummy_button], queue = False, show_progress = False).success(fn=stage2_process, inputs = [
-        input_image,
-        rotation,
-        denoise_image,
+    video_path = 'wan_' + datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f") + '.mp4'
+
+    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
+
+    progress(1.0, desc="Done!")
+    return video_path, gr.update(value = video_path, visible = True), current_seed
+
+
+# --- 3. Gradio User Interface ---
+
+with gr.Blocks() as app:
+    gr.Markdown("# Wan 2.2 First/Last Frame Video Fast")
+    gr.Markdown("Based on the [Wan 2.2 First/Last Frame workflow](https://www.reddit.com/r/StableDiffusion/comments/1me4306/psa_wan_22_does_first_frame_last_frame_out_of_the/), applied to 🧨 Diffusers + [lightx2v/Wan2.2-Lightning](https://huggingface.co/lightx2v/Wan2.2-Lightning) 8-step LoRA")
+
+    with gr.Row(elem_id="general_items"):
+        with gr.Column():
+            with gr.Group(elem_id="group_all"):
+                with gr.Row():
+                    start_image = gr.Image(type="pil", label="Start Frame", sources=["upload", "clipboard"])
+                    # Capture the Tabs component in a variable and assign IDs to tabs
+                    with gr.Tabs(elem_id="group_tabs") as tabs:
+                        with gr.TabItem("Upload", id="upload_tab"):
+                            end_image = gr.Image(type="pil", label="End Frame", sources=["upload", "clipboard"])
+                        with gr.TabItem("Generate", id="generate_tab"):
+                            generate_5seconds = gr.Button("Generate scene 5 seconds in the future", elem_id="fivesec")
+                            gr.Markdown("Generate a custom end-frame with an edit model like [Nano Banana](https://huggingface.co/spaces/multimodalart/nano-banana) or [Qwen Image Edit](https://huggingface.co/spaces/multimodalart/Qwen-Image-Edit-Fast)", elem_id="or_item")
+                prompt = gr.Textbox(label="Prompt", info="Describe the transition between the two images")
+
+                with gr.Accordion("Advanced Settings", open=False):
+                    duration_seconds_input = gr.Slider(minimum=MIN_DURATION, maximum=MAX_DURATION, step=0.1, value=2.1, label="Video Duration (seconds)", info=f"Clamped to model's {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps.")
+                    negative_prompt_input = gr.Textbox(label="Negative Prompt", value=default_negative_prompt, lines=3)
+                    steps_slider = gr.Slider(minimum=1, maximum=30, step=1, value=8, label="Inference Steps")
+                    guidance_scale_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1.0, label="Guidance Scale - high noise")
+                    guidance_scale_2_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1.0, label="Guidance Scale - low noise")
+                    with gr.Row():
+                        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.Accordion("Debug", elem_id="wan_accordion", open=False):
+                    input_image_debug = gr.Image(type="pil", label="Image Debug", height=320)
+                    input_video_debug = gr.Video(sources='upload', label="Input Video Debug", height=320, visible = False)
+                    end_image_debug = gr.Image(type="pil", label="End Image Debug", height=320)
+                    prompt_debug = gr.Textbox(elem_id="wan_prompt_debug", label="Prompt Debug", value='')
+                    total_second_length_debug = gr.Slider(label="Additional Video Length to Generate (seconds) Debug", minimum=1, maximum=120, value=10, step=0.1)
+
+                generate_button = gr.Button("Generate Video", variant="primary")
+
+        with gr.Column():
+            output_video = gr.Video(label="Generated Video", autoplay = True, loop = True)
+            download_button = gr.DownloadButton(label="Download", visible = True)
+
+    # Main video generation button
+    ui_inputs = [
+        start_image,
+        end_image,
         prompt,
-        a_prompt,
-        n_prompt,
-        num_samples,
-        min_size,
-        downscale,
-        upscale,
-        edm_steps,
-        s_stage1,
-        s_stage2,
-        s_cfg,
-        randomize_seed,
-        seed,
-        s_churn,
-        s_noise,
-        color_fix_type,
-        diff_dtype,
-        ae_dtype,
-        gamma_correction,
-        linear_CFG,
-        spt_linear_CFG,
-        linear_s_stage2,
-        spt_linear_s_stage2,
-        model_select,
-        output_format,
-        allocation
-    ], outputs = [
-        result_slider,
-        result_gallery,
-        restore_information,
-        reset_btn,
-        warning,
-        dummy_button
-    ]).success(fn = log_information, inputs = [
-        result_gallery
-    ], outputs = [], queue = False, show_progress = False)
-
-    result_gallery.change(on_select_result, [result_slider, result_gallery], result_slider)
-    result_gallery.select(on_select_result, [result_slider, result_gallery], result_slider)
-    result_example.change(on_render_image_example, result_example, result_image_example)
+        negative_prompt_input,
+        duration_seconds_input,
+        steps_slider,
+        guidance_scale_input,
+        guidance_scale_2_input,
+        seed_input,
+        randomize_seed_checkbox
+    ]
+    ui_outputs = [output_video, download_button, seed_input]
 
-    restart_button.click(fn = load_and_reset, inputs = [
-        param_setting
-    ], outputs = [
-        edm_steps,
-        s_cfg,
-        s_stage2,
-        s_stage1,
-        s_churn,
-        s_noise,
-        a_prompt,
-        n_prompt,
-        color_fix_type,
-        linear_CFG,
-        spt_linear_CFG,
-        linear_s_stage2,
-        spt_linear_s_stage2,
-        model_select
-    ])
+    generate_button.click(
+        fn=generate_video,
+        inputs=ui_inputs,
+        outputs=ui_outputs
+    )
 
-    reset_btn.click(fn = reset, inputs = [], outputs = [
-            input_image,
-            rotation,
-            denoise_image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            min_size,
-            downscale,
-            upscale,
-            edm_steps,
-            s_stage1,
-            s_stage2,
-            s_cfg,
-            randomize_seed,
-            seed,
-            s_churn,
-            s_noise,
-            color_fix_type,
-            diff_dtype,
-            ae_dtype,
-            gamma_correction,
-            linear_CFG,
-            spt_linear_CFG,
-            linear_s_stage2,
-            spt_linear_s_stage2,
-            model_select,
-            output_format,
-            allocation
-        ], queue = False, show_progress = False)
+    generate_5seconds.click(
+        fn=switch_to_upload_tab,
+        inputs=None,
+        outputs=[tabs]
+    ).then( 
+        fn=lambda img: generate_end_frame(img, "this image is a still frame from a movie. generate a new frame with what happens on this scene 5 seconds in the future"),
+        inputs=[start_image],
+        outputs=[end_image]
+    ).success(
+        fn=generate_video,
+        inputs=ui_inputs,
+        outputs=ui_outputs
+    )
 
-    def handle_field_debug_change(input_image_debug_data, prompt_debug_data, upscale_debug_data):
+    def handle_field_debug_change(input_image_debug_data, input_video_debug_data, end_image_debug_data, prompt_debug_data, total_second_length_debug_data):
+        print("handle_field_debug_change")
         input_image_debug_value[0] = input_image_debug_data
+        input_video_debug_value[0] = input_video_debug_data
+        end_image_debug_value[0] = end_image_debug_data
         prompt_debug_value[0] = prompt_debug_data
-        upscale_debug_value[0] = upscale_debug_data
+        total_second_length_debug_value[0] = total_second_length_debug_data
         return []
 
     input_image_debug.upload(
         fn=handle_field_debug_change,
-        inputs=[input_image_debug, prompt_debug, upscale_debug],
+        inputs=[input_image_debug, input_video_debug, end_image_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
+    input_video_debug.upload(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, end_image_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
+    end_image_debug.upload(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, end_image_debug, prompt_debug, total_second_length_debug],
         outputs=[]
     )
     
     prompt_debug.change(
         fn=handle_field_debug_change,
-        inputs=[input_image_debug, prompt_debug, upscale_debug],
+        inputs=[input_image_debug, input_video_debug, end_image_debug, prompt_debug, total_second_length_debug],
         outputs=[]
     )
     
-    upscale_debug.change(
+    total_second_length_debug.change(
         fn=handle_field_debug_change,
-        inputs=[input_image_debug, prompt_debug, upscale_debug],
+        inputs=[input_image_debug, input_video_debug, end_image_debug, prompt_debug, total_second_length_debug],
         outputs=[]
     )
-        
-    interface.queue(10).launch(mcp_server=True, ssr_mode=False)
+    
+    with gr.Row(elem_id="wan_image_examples", visible=False):
+        gr.Examples(
+        label = "Examples from images",
+        examples = [
+            ["ugly_sonic.jpeg", "squatting_sonic.png", "the character dodges the missiles"],
+            ["capyabara_zoomed.png", "capyabara.webp", "a dramatic dolly zoom"],
+            ["squatting_sonic.png", "ugly_sonic.jpeg", "the character jumps"],
+            ["poli_tower.png", "tower_takes_off.png", "the man turns around"],
+            ["capyabara.webp", "capyabara_zoomed.png", "a straight forward zoom"],
+        ],
+        inputs = [start_image, end_image, prompt],
+        outputs = ui_outputs,
+        fn = generate_video,
+        run_on_click = True,
+        cache_examples = True,
+    )
+    
+    gr.Examples(
+        examples = [
+            ["poli_tower.png", "tower_takes_off.png", "the man turns around"],
+            ["ugly_sonic.jpeg", "squatting_sonic.png", "the character dodges the missiles"],
+            ["capyabara_zoomed.png", "capyabara.webp", "a dramatic dolly zoom"],
+        ],
+        inputs = [start_image, end_image, prompt],
+        outputs = ui_outputs,
+        fn = generate_video,
+        cache_examples = False,
+    )
+
+if __name__ == "__main__":
+    app.launch(share=True)

requirements.txt

@@ -1,43 +1,11 @@
-pydantic==2.10.6 # To avoid the message "No API found" or "Internal server error"
+git+https://github.com/linoytsaban/diffusers.git@wan22-loras
 
-fastapi==0.115.13
-gradio_imageslider==0.0.20
-gradio_client==1.10.3
-numpy==1.26.4
-requests==2.32.4
-sentencepiece==0.2.0
-tokenizers==0.19.1
-torchvision==0.22.0
-uvicorn==0.34.3
-wandb==0.20.1
-httpx==0.28.1
-transformers==4.43.0
-accelerate==1.8.0
-scikit-learn==1.7.0
-einops==0.8.1
-einops-exts==0.0.4
-timm==1.0.15
-openai-clip==1.0.1
-fsspec==2025.5.1
-kornia==0.8.1
-matplotlib==3.10.3
-ninja==1.11.1.4
-omegaconf==2.3.0
-opencv-python==4.11.0.86
-pandas==2.3.0
-pillow==11.2.1
-pytorch-lightning==2.5.1.post0
-PyYAML==6.0.2
-scipy==1.15.3
-tqdm==4.67.1
-triton==3.3.0
-urllib3==2.4.0
-webdataset==0.2.111
-xformers==0.0.30
-facexlib==0.3.0
-k-diffusion==0.1.1.post1
-diffusers==0.33.1
-imageio==2.37.0
-pillow-heif==0.22.0
-
-open-clip-torch==2.24.0
+transformers
+accelerate
+safetensors
+sentencepiece
+peft
+ftfy
+imageio-ffmpeg
+opencv-python
+torchao==0.11.0