Major Tab re-write of app.py

app.py

@@ -1,6 +1,6 @@
 import spaces
 import torch
-from diffusers import AutoencoderKLWan, WanImageToVideoPipeline, UniPCMultistepScheduler
+from diffusers import AutoencoderKLWan, WanImageToVideoPipeline, WanTextToVideoPipeline, UniPCMultistepScheduler
 from diffusers.utils import export_to_video
 from transformers import CLIPVisionModel
 import gradio as gr
@@ -14,43 +14,62 @@ import numpy as np
 from PIL import Image
 import random
 
-# Base MODEL_ID (using original Wan model that's compatible with diffusers)
-MODEL_ID = "Wan-AI/Wan2.1-I2V-14B-720P-Diffusers"
+# --- I2V (Image-to-Video) Configuration ---
+I2V_MODEL_ID = "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers"
+I2V_LORA_FILENAME = "FusionX_LoRa/Wan2.1_I2V_14B_FusionX_LoRA.safetensors"
 
-# Merged FusionX enhancement LoRA
+# --- T2V (Text-to-Video) Configuration ---
+T2V_MODEL_ID = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+T2V_LORA_FILENAME = "FusionX_LoRa/Wan2.1_T2V_14B_FusionX_LoRA.safetensors"
+
+# --- Common LoRA Configuration ---
 LORA_REPO_ID = "vrgamedevgirl84/Wan14BT2VFusioniX"
-LORA_FILENAME = "FusionX_LoRa/Wan2.1_I2V_14B_FusionX_LoRA.safetensors"
-
-# Load enhanced model components
-print("🚀 Loading FusionX Enhanced Wan2.1 I2V Model...")
-image_encoder = CLIPVisionModel.from_pretrained(MODEL_ID, subfolder="image_encoder", torch_dtype=torch.float32)
-vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
-pipe = WanImageToVideoPipeline.from_pretrained(
-    MODEL_ID, vae=vae, image_encoder=image_encoder, torch_dtype=torch.bfloat16
+
+# --- Load I2V Pipeline ---
+print("🚀 Loading FusionX Enhanced Wan2.1 I2V Pipeline...")
+i2v_image_encoder = CLIPVisionModel.from_pretrained(I2V_MODEL_ID, subfolder="image_encoder", torch_dtype=torch.float32)
+i2v_vae = AutoencoderKLWan.from_pretrained(I2V_MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+i2v_pipe = WanImageToVideoPipeline.from_pretrained(
+    I2V_MODEL_ID, vae=i2v_vae, image_encoder=i2v_image_encoder, torch_dtype=torch.bfloat16
 )
+i2v_pipe.scheduler = UniPCMultistepScheduler.from_config(i2v_pipe.scheduler.config, flow_shift=8.0)
+i2v_pipe.to("cuda")
 
-# FusionX optimized scheduler settings
-pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=8.0)
-pipe.to("cuda")
+try:
+    i2v_lora_path = hf_hub_download(repo_id=LORA_REPO_ID, filename=I2V_LORA_FILENAME)
+    print("✅ I2V LoRA downloaded to:", i2v_lora_path)
+    i2v_pipe.load_lora_weights(i2v_lora_path, adapter_name="fusionx_lora")
+    i2v_pipe.set_adapters(["fusionx_lora"], adapter_weights=[0.75])
+    i2v_pipe.fuse_lora()
+    print("✅ I2V FusionX LoRA loaded and fused with a weight of 0.75.")
+except Exception as e:
+    print("❌ Error during I2V LoRA loading:")
+    traceback.print_exc()
 
-# Load and fuse the single merged FusionX LoRA
+# --- Load T2V Pipeline ---
+print("\n🚀 Loading FusionX Enhanced Wan2.1 T2V Pipeline...")
+t2v_pipe = None
 try:
-    lora_path = hf_hub_download(
-        repo_id=LORA_REPO_ID, 
-        filename=LORA_FILENAME
-    )
-    print("✅ LoRA downloaded to:", lora_path)
-    
-    # Load, set weight, and fuse the LoRA into the pipeline
-    pipe.load_lora_weights(lora_path, adapter_name="fusionx_lora")
-    pipe.set_adapters(["fusionx_lora"], adapter_weights=[0.75])
-    pipe.fuse_lora()
-    print("✅ FusionX LoRA loaded and fused with a weight of 0.75.")
+    t2v_pipe = WanTextToVideoPipeline.from_pretrained(T2V_MODEL_ID, torch_dtype=torch.bfloat16)
+    t2v_pipe.scheduler = UniPCMultistepScheduler.from_config(t2v_pipe.scheduler.config, flow_shift=8.0)
+    t2v_pipe.to("cuda")
 
+    try:
+        t2v_lora_path = hf_hub_download(repo_id=LORA_REPO_ID, filename=T2V_LORA_FILENAME)
+        print("✅ T2V LoRA downloaded to:", t2v_lora_path)
+        t2v_pipe.load_lora_weights(t2v_lora_path, adapter_name="fusionx_lora")
+        t2v_pipe.set_adapters(["fusionx_lora"], adapter_weights=[0.75])
+        t2v_pipe.fuse_lora()
+        print("✅ T2V FusionX LoRA loaded and fused with a weight of 0.75.")
+    except Exception as e:
+        print("❌ Error during T2V LoRA loading:")
+        traceback.print_exc()
 except Exception as e:
-    print("❌ Error during LoRA loading:")
+    print("❌ Critical Error: T2V Pipeline failed to load. The Text-to-Video tab will be disabled.")
     traceback.print_exc()
 
+
+# --- Constants and Configuration ---
 MOD_VALUE = 32
 DEFAULT_H_SLIDER_VALUE = 640
 DEFAULT_W_SLIDER_VALUE = 1024
@@ -64,11 +83,12 @@ FIXED_FPS = 24
 MIN_FRAMES_MODEL = 8
 MAX_FRAMES_MODEL = 81
 
-# Enhanced prompts for FusionX-style output
+# --- Default Prompts ---
 default_prompt_i2v = "Cinematic motion, smooth animation, detailed textures, dynamic lighting, professional cinematography"
+default_prompt_t2v = "A breathtaking landscape with a flowing river, cinematic, 8k, photorealistic"
 default_negative_prompt = "Static image, no motion, blurred details, overexposed, underexposed, low quality, worst quality, JPEG artifacts, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, watermark, text, signature, three legs, many people in the background, walking backwards"
 
-# Enhanced CSS for FusionX theme
+# --- Enhanced CSS for FusionX theme ---
 custom_css = """
 /* Enhanced FusionX theme with cinematic styling */
 .gradio-container {
@@ -237,75 +257,56 @@ video {
     box-shadow: 0 8px 30px rgba(0, 0, 0, 0.4) !important;
     border: 2px solid rgba(106, 76, 147, 0.3) !important;
 }
-/* Enhanced examples section */
-.gr-examples {
-    background: rgba(255, 255, 255, 0.04) !important;
-    border-radius: 20px !important;
-    padding: 25px !important;
-    margin-top: 25px !important;
+/* Tab styling */
+.gr-tabs { 
+    border-radius: 15px !important; 
+    overflow: hidden;
     border: 1px solid rgba(255, 255, 255, 0.1) !important;
 }
-/* Enhanced checkbox */
-input[type="checkbox"] {
-    accent-color: #6a4c93 !important;
-    transform: scale(1.2) !important;
-}
-/* Responsive enhancements */
-@media (max-width: 768px) {
-    h1 { font-size: 2.2rem !important; }
-    .main-container { padding: 25px !important; }
-    .generate-btn { padding: 12px 30px !important; font-size: 1.1rem !important; }
+.gr-tabs .tabs {
+    background-color: rgba(255, 255, 255, 0.05) !important;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1) !important;
 }
-/* Badge container styling */
-.badge-container {
-    display: flex;
-    justify-content: center;
-    gap: 15px;
-    margin: 20px 0;
-    flex-wrap: wrap;
-}
-.badge-container img {
-    border-radius: 8px;
-    transition: transform 0.3s ease;
+.gr-tabs .tab-item {
+    background: transparent !important;
+    color: #a9a9d8 !important;
+    border-radius: 10px 10px 0 0 !important;
+    transition: all 0.3s ease !important;
+    padding: 12px 20px !important;
 }
-.badge-container img:hover {
-    transform: scale(1.05);
+.gr-tabs .tab-item.selected {
+    background: rgba(255, 255, 255, 0.1) !important;
+    color: #ffffff !important;
+    border-bottom: 2px solid #6a4c93 !important;
 }
 """
 
+# --- Helper Functions ---
 def sanitize_prompt_for_filename(prompt: str, max_len: int = 60) -> str:
     """Sanitizes a prompt string to be used as a valid filename."""
     if not prompt:
         prompt = "video"
-    # Remove non-alphanumeric characters (except spaces, hyphens, underscores)
     sanitized = re.sub(r'[^\w\s_-]', '', prompt).strip()
-    # Replace spaces and multiple hyphens/underscores with a single underscore
     sanitized = re.sub(r'[\s_-]+', '_', sanitized)
-    # Truncate to max_len
     return sanitized[:max_len]
 
 def _calculate_new_dimensions_wan(pil_image, mod_val, calculation_max_area,
-                                 min_slider_h, max_slider_h,
-                                 min_slider_w, max_slider_w,
-                                 default_h, default_w):
+                                  min_slider_h, max_slider_h,
+                                  min_slider_w, max_slider_w,
+                                  default_h, default_w):
     orig_w, orig_h = pil_image.size
     if orig_w <= 0 or orig_h <= 0:
         return default_h, default_w
-
     aspect_ratio = orig_h / orig_w
-    
     calc_h = round(np.sqrt(calculation_max_area * aspect_ratio))
     calc_w = round(np.sqrt(calculation_max_area / aspect_ratio))
-
     calc_h = max(mod_val, (calc_h // mod_val) * mod_val)
     calc_w = max(mod_val, (calc_w // mod_val) * mod_val)
-    
     new_h = int(np.clip(calc_h, min_slider_h, (max_slider_h // mod_val) * mod_val))
     new_w = int(np.clip(calc_w, min_slider_w, (max_slider_w // mod_val) * mod_val))
-    
     return new_h, new_w
 
-def handle_image_upload_for_dims_wan(uploaded_pil_image, current_h_val, current_w_val):
+def handle_image_upload_for_dims_wan(uploaded_pil_image):
     if uploaded_pil_image is None:
         return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)
     try:
@@ -316,180 +317,201 @@ def handle_image_upload_for_dims_wan(uploaded_pil_image, current_h_val, current_
         )
         return gr.update(value=new_h), gr.update(value=new_w)
     except Exception as e:
-        gr.Warning("Error attempting to calculate new dimensions")
+        gr.Warning("Error calculating new dimensions. Resetting to default.")
         return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)
 
-def get_duration(input_image, prompt, height, width, 
-                   negative_prompt, duration_seconds,
-                   guidance_scale, steps,
-                   seed, randomize_seed, 
-                   progress):
-    # FusionX optimized duration calculation
-    if steps > 8 and duration_seconds > 3:
-        return 600
-    elif steps > 8 or duration_seconds > 3:
-        return 300
-    else:
-        return 150
-
-@spaces.GPU(duration=get_duration)
-def generate_video(input_image, prompt, height, width, 
-                   negative_prompt=default_negative_prompt, duration_seconds=3,
-                   guidance_scale=1, steps=8,
-                   seed=42, randomize_seed=False, 
-                   progress=gr.Progress(track_tqdm=True)):
-    
+# --- GPU Duration Estimators for @spaces.GPU ---
+def get_i2v_duration(steps, duration_seconds):
+    """Estimates GPU time for Image-to-Video generation."""
+    if steps > 8 and duration_seconds > 3: return 600
+    elif steps > 8 or duration_seconds > 3: return 300
+    else: return 150
+
+def get_t2v_duration(steps, duration_seconds):
+    """Estimates GPU time for Text-to-Video generation."""
+    if steps > 15 and duration_seconds > 4: return 700
+    elif steps > 15 or duration_seconds > 4: return 400
+    else: return 200
+
+# --- Core Generation Functions ---
+
+@spaces.GPU(duration_from_args=get_i2v_duration)
+def generate_i2v_video(input_image, prompt, height, width,
+                      negative_prompt, duration_seconds,
+                      guidance_scale, steps,
+                      seed, randomize_seed,
+                      progress=gr.Progress(track_tqdm=True)):
+    """Generates a video from an initial image and a prompt."""
     if input_image is None:
-        raise gr.Error("Please upload an input image.")
+        raise gr.Error("Please upload an input image for Image-to-Video generation.")
 
     target_h = max(MOD_VALUE, (int(height) // MOD_VALUE) * MOD_VALUE)
     target_w = max(MOD_VALUE, (int(width) // MOD_VALUE) * MOD_VALUE)
-    
     num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
-    
     current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-
     resized_image = input_image.resize((target_w, target_h))
-
-    # Enhanced prompt for FusionX-style output
     enhanced_prompt = f"{prompt}, cinematic quality, smooth motion, detailed animation, dynamic lighting"
 
     with torch.inference_mode():
-        output_frames_list = pipe(
-            image=resized_image, 
-            prompt=enhanced_prompt, 
+        output_frames_list = i2v_pipe(
+            image=resized_image,
+            prompt=enhanced_prompt,
             negative_prompt=negative_prompt,
-            height=target_h, 
-            width=target_w, 
+            height=target_h,
+            width=target_w,
             num_frames=num_frames,
-            guidance_scale=float(guidance_scale), 
+            guidance_scale=float(guidance_scale),
             num_inference_steps=int(steps),
             generator=torch.Generator(device="cuda").manual_seed(current_seed)
         ).frames[0]
 
-    # Create a unique filename for download
     sanitized_prompt = sanitize_prompt_for_filename(prompt)
-    filename = f"{sanitized_prompt}_{current_seed}.mp4"
-    
+    filename = f"i2v_{sanitized_prompt}_{current_seed}.mp4"
     temp_dir = tempfile.mkdtemp()
     video_path = os.path.join(temp_dir, filename)
+    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
     
+    return video_path, current_seed, gr.File(value=video_path, visible=True, label=f"📥 Download: {filename}")
+
+
+@spaces.GPU(duration_from_args=get_t2v_duration)
+def generate_t2v_video(prompt, height, width,
+                      negative_prompt, duration_seconds,
+                      guidance_scale, steps,
+                      seed, randomize_seed,
+                      progress=gr.Progress(track_tqdm=True)):
+    """Generates a video from a text prompt."""
+    if t2v_pipe is None:
+         raise gr.Error("Text-to-Video pipeline is not available due to a loading error.")
+    if not prompt:
+        raise gr.Error("Please enter a prompt for Text-to-Video generation.")
+
+    target_h = max(MOD_VALUE, (int(height) // MOD_VALUE) * MOD_VALUE)
+    target_w = max(MOD_VALUE, (int(width) // MOD_VALUE) * MOD_VALUE)
+    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    enhanced_prompt = f"{prompt}, cinematic, high detail, photorealistic, professional lighting"
+
+    with torch.inference_mode():
+        output_frames_list = t2v_pipe(
+            prompt=enhanced_prompt,
+            negative_prompt=negative_prompt,
+            height=target_h,
+            width=target_w,
+            num_frames=num_frames,
+            guidance_scale=float(guidance_scale),
+            num_inference_steps=int(steps),
+            generator=torch.Generator(device="cuda").manual_seed(current_seed)
+        ).frames[0]
+
+    sanitized_prompt = sanitize_prompt_for_filename(prompt)
+    filename = f"t2v_{sanitized_prompt}_{current_seed}.mp4"
+    temp_dir = tempfile.mkdtemp()
+    video_path = os.path.join(temp_dir, filename)
     export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
+    
     return video_path, current_seed, gr.File(value=video_path, visible=True, label=f"📥 Download: {filename}")
 
-with gr.Blocks() as demo:
-    with gr.Column(elem_classes=["main-container"]):
-        gr.Markdown("# ⚡ FusionX Enhanced Wan 2.1 I2V (14B)")
 
-     
-        
-        
+# --- Gradio UI Layout ---
+with gr.Blocks(css=custom_css) as demo:
+    with gr.Column(elem_classes=["main-container"]):
+        gr.Markdown("# ⚡ FusionX Enhanced Wan 2.1 Video Suite")
         
-        with gr.Row():
-            with gr.Column(elem_classes=["input-container"]):
-                input_image_component = gr.Image(
-                    type="pil", 
-                    label="🖼️ Input Image (auto-resized to target H/W)",
-                    elem_classes=["image-upload"]
-                )
-                prompt_input = gr.Textbox(
-                    label="✏️ Enhanced Prompt (FusionX-style enhancements applied)", 
-                    value=default_prompt_i2v,
-                    lines=3
-                )
-                duration_seconds_input = gr.Slider(
-                    minimum=round(MIN_FRAMES_MODEL/FIXED_FPS,1), 
-                    maximum=round(MAX_FRAMES_MODEL/FIXED_FPS,1), 
-                    step=0.1, 
-                    value=2, 
-                    label="⏱️ Duration (seconds)", 
-                    info=f"FusionX Enhanced supports {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps. Recommended: 2-5 seconds"
-                )
-                
-                with gr.Accordion("⚙️ Advanced FusionX Settings", open=False):
-                    negative_prompt_input = gr.Textbox(
-                        label="❌ Negative Prompt (FusionX Enhanced)", 
-                        value=default_negative_prompt, 
-                        lines=4
-                    )
-                    seed_input = gr.Slider(
-                        label="🎲 Seed", 
-                        minimum=0, 
-                        maximum=MAX_SEED, 
-                        step=1, 
-                        value=42, 
-                        interactive=True
-                    )
-                    randomize_seed_checkbox = gr.Checkbox(
-                        label="🔀 Randomize seed", 
-                        value=True, 
-                        interactive=True
-                    )
-                    with gr.Row():
-                        height_input = gr.Slider(
-                            minimum=SLIDER_MIN_H, 
-                            maximum=SLIDER_MAX_H, 
-                            step=MOD_VALUE, 
-                            value=DEFAULT_H_SLIDER_VALUE, 
-                            label=f"📏 Output Height (FusionX optimized: {MOD_VALUE} multiples)"
+        with gr.Tabs(elem_classes=["gr-tabs"]):
+            # --- Image-to-Video Tab ---
+            with gr.TabItem("🖼️ Image-to-Video", id="i2v_tab"):
+                with gr.Row():
+                    with gr.Column(elem_classes=["input-container"]):
+                        i2v_input_image = gr.Image(
+                            type="pil",
+                            label="🖼️ Input Image (auto-resizes H/W sliders)",
+                            elem_classes=["image-upload"]
                         )
-                        width_input = gr.Slider(
-                            minimum=SLIDER_MIN_W, 
-                            maximum=SLIDER_MAX_W, 
-                            step=MOD_VALUE, 
-                            value=DEFAULT_W_SLIDER_VALUE, 
-                            label=f"📐 Output Width (FusionX optimized: {MOD_VALUE} multiples)"
+                        i2v_prompt = gr.Textbox(
+                            label="✏️ Prompt",
+                            value=default_prompt_i2v, lines=3
                         )
-                    steps_slider = gr.Slider(
-                        minimum=1, 
-                        maximum=20, 
-                        step=1, 
-                        value=8,  # FusionX optimized
-                        label="🚀 Inference Steps (FusionX Enhanced: 8-10 recommended)", 
-                        info="FusionX Enhanced delivers excellent results in just 8-10 steps!"
-                    ) 
-                    guidance_scale_input = gr.Slider(
-                        minimum=0.0, 
-                        maximum=20.0, 
-                        step=0.5, 
-                        value=1.0, 
-                        label="🎯 Guidance Scale (FusionX optimized)", 
-                        visible=False
-                    )
-
-                generate_button = gr.Button(
-                    "🎬 Generate FusionX Enhanced Video", 
-                    variant="primary",
-                    elem_classes=["generate-btn"]
-                )
-                
-            with gr.Column(elem_classes=["output-container"]):
-                video_output = gr.Video(
-                    label="🎥 FusionX Enhanced Generated Video", 
-                    autoplay=True, 
-                    interactive=False
-                )
-                download_output = gr.File(label="📥 Download Video", visible=False)
-
-        input_image_component.upload(
-            fn=handle_image_upload_for_dims_wan,
-            inputs=[input_image_component, height_input, width_input],
-            outputs=[height_input, width_input]
-        )
-        
-        input_image_component.clear( 
-            fn=handle_image_upload_for_dims_wan,
-            inputs=[input_image_component, height_input, width_input],
-            outputs=[height_input, width_input]
-        )
-        
-        ui_inputs = [
-            input_image_component, prompt_input, height_input, width_input,
-            negative_prompt_input, duration_seconds_input,
-            guidance_scale_input, steps_slider, seed_input, randomize_seed_checkbox
-        ]
-        generate_button.click(fn=generate_video, inputs=ui_inputs, outputs=[video_output, seed_input, download_output])
+                        i2v_duration = gr.Slider(
+                            minimum=round(MIN_FRAMES_MODEL/FIXED_FPS,1),
+                            maximum=round(MAX_FRAMES_MODEL/FIXED_FPS,1),
+                            step=0.1, value=2, label="⏱️ Duration (seconds)",
+                            info=f"Generates {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps."
+                        )
+                        with gr.Accordion("⚙️ Advanced Settings", open=False):
+                            i2v_neg_prompt = gr.Textbox(label="❌ Negative Prompt", value=default_negative_prompt, lines=4)
+                            i2v_seed = gr.Slider(label="🎲 Seed", minimum=0, maximum=MAX_SEED, step=1, value=42, interactive=True)
+                            i2v_rand_seed = gr.Checkbox(label="🔀 Randomize seed", value=True, interactive=True)
+                            with gr.Row():
+                                i2v_height = gr.Slider(minimum=SLIDER_MIN_H, maximum=SLIDER_MAX_H, step=MOD_VALUE, value=DEFAULT_H_SLIDER_VALUE, label=f"📏 Height ({MOD_VALUE}px steps)")
+                                i2v_width = gr.Slider(minimum=SLIDER_MIN_W, maximum=SLIDER_MAX_W, step=MOD_VALUE, value=DEFAULT_W_SLIDER_VALUE, label=f"📐 Width ({MOD_VALUE}px steps)")
+                            i2v_steps = gr.Slider(minimum=1, maximum=20, step=1, value=8, label="🚀 Inference Steps", info="8-10 recommended for great results.")
+                            i2v_guidance = gr.Slider(minimum=0.0, maximum=20.0, step=0.5, value=1.0, label="🎯 Guidance Scale", visible=False)
+                        
+                        i2v_generate_btn = gr.Button("🎬 Generate I2V", variant="primary", elem_classes=["generate-btn"])
 
+                    with gr.Column(elem_classes=["output-container"]):
+                        i2v_output_video = gr.Video(label="🎥 Generated Video", autoplay=True, interactive=False)
+                        i2v_download = gr.File(label="📥 Download Video", visible=False)
+
+            # --- Text-to-Video Tab ---
+            with gr.TabItem("✍️ Text-to-Video", id="t2v_tab", interactive=t2v_pipe is not None):
+                if t2v_pipe is None:
+                    gr.Markdown("<h3 style='color: #ff9999; text-align: center;'>⚠️ Text-to-Video Pipeline Failed to Load. This tab is disabled.</h3>")
+                else:
+                    with gr.Row():
+                        with gr.Column(elem_classes=["input-container"]):
+                            t2v_prompt = gr.Textbox(
+                                label="✏️ Prompt",
+                                value=default_prompt_t2v, lines=4
+                            )
+                            t2v_duration = gr.Slider(
+                                minimum=round(MIN_FRAMES_MODEL/FIXED_FPS,1),
+                                maximum=round(MAX_FRAMES_MODEL/FIXED_FPS,1),
+                                step=0.1, value=2, label="⏱️ Duration (seconds)",
+                                info=f"Generates {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps."
+                            )
+                            with gr.Accordion("⚙️ Advanced Settings", open=False):
+                                t2v_neg_prompt = gr.Textbox(label="❌ Negative Prompt", value=default_negative_prompt, lines=4)
+                                t2v_seed = gr.Slider(label="🎲 Seed", minimum=0, maximum=MAX_SEED, step=1, value=1234, interactive=True)
+                                t2v_rand_seed = gr.Checkbox(label="🔀 Randomize seed", value=True, interactive=True)
+                                with gr.Row():
+                                    t2v_height = gr.Slider(minimum=SLIDER_MIN_H, maximum=SLIDER_MAX_H, step=MOD_VALUE, value=DEFAULT_H_SLIDER_VALUE, label=f"📏 Height ({MOD_VALUE}px steps)")
+                                    t2v_width = gr.Slider(minimum=SLIDER_MIN_W, maximum=SLIDER_MAX_W, step=MOD_VALUE, value=DEFAULT_W_SLIDER_VALUE, label=f"📐 Width ({MOD_VALUE}px steps)")
+                                t2v_steps = gr.Slider(minimum=1, maximum=25, step=1, value=15, label="🚀 Inference Steps", info="15-20 recommended for quality.")
+                                t2v_guidance = gr.Slider(minimum=0.0, maximum=20.0, step=0.5, value=7.5, label="🎯 Guidance Scale")
+                            
+                            t2v_generate_btn = gr.Button("🎬 Generate T2V", variant="primary", elem_classes=["generate-btn"])
+
+                        with gr.Column(elem_classes=["output-container"]):
+                            t2v_output_video = gr.Video(label="🎥 Generated Video", autoplay=True, interactive=False)
+                            t2v_download = gr.File(label="📥 Download Video", visible=False)
+
+    # --- Event Handlers ---
+    # I2V Handlers
+    i2v_input_image.upload(
+        fn=handle_image_upload_for_dims_wan,
+        inputs=[i2v_input_image],
+        outputs=[i2v_height, i2v_width]
+    )
+    i2v_input_image.clear(
+        fn=lambda: (DEFAULT_H_SLIDER_VALUE, DEFAULT_W_SLIDER_VALUE),
+        inputs=[],
+        outputs=[i2v_height, i2v_width]
+    )
+    i2v_generate_btn.click(
+        fn=generate_i2v_video,
+        inputs=[i2v_input_image, i2v_prompt, i2v_height, i2v_width, i2v_neg_prompt, i2v_duration, i2v_guidance, i2v_steps, i2v_seed, i2v_rand_seed],
+        outputs=[i2v_output_video, i2v_seed, i2v_download]
+    )
+
+    # T2V Handlers
+    if t2v_pipe is not None:
+        t2v_generate_btn.click(
+            fn=generate_t2v_video,
+            inputs=[t2v_prompt, t2v_height, t2v_width, t2v_neg_prompt, t2v_duration, t2v_guidance, t2v_steps, t2v_seed, t2v_rand_seed],
+            outputs=[t2v_output_video, t2v_seed, t2v_download]
+        )
 
 if __name__ == "__main__":
     demo.queue().launch()