Update app.py

app.py

@@ -1,21 +1,21 @@
 #!/usr/bin/env python3
 """
-AI Video Generator with Gradio
+AI Video Generator with Gradio - WaveSpeed API Version
 Single file application - app.py
 """
 
 import os
 import gradio as gr
-import replicate
+import requests
+import json
+import time
 import base64
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
 import io
-import requests
 from datetime import datetime
 import tempfile
-import time
 
-# Try to import video processing libraries
+# Try to import video processing libraries for watermark
 try:
     import cv2
     import numpy as np
@@ -24,10 +24,14 @@ except ImportError:
     VIDEO_PROCESSING_AVAILABLE = False
     print("Warning: cv2 not available. Watermark feature will be disabled.")
 
-# API token setup
-api_token = os.getenv("RAPI_TOKEN")
-if api_token:
-    os.environ["REPLICATE_API_TOKEN"] = api_token
+# API keys setup from environment variables
+API_KEY_T2V = os.getenv("WS_API_KEY_T2V", "946b77acd6a456dfde349aa0bac7b6d2bdf9c0c995fff072898c6d8734f866c4")
+API_KEY_I2V = os.getenv("WS_API_KEY_I2V", "5a90eaa7ded95066c07adf55b91185a83abfa8db3fdc74d12ba5ad66db1d68fe")
+
+# API endpoints
+API_BASE_URL = "https://api.wavespeed.ai/api/v3"
+T2V_ENDPOINT = f"{API_BASE_URL}/bytedance/seedance-v1-lite-t2v-480p"
+I2V_ENDPOINT = f"{API_BASE_URL}/bytedance/seedance-v1-lite-i2v-480p"
 
 # Aspect ratio options
 ASPECT_RATIOS = {
@@ -50,39 +54,29 @@ def add_watermark_cv2(input_video_path, output_video_path):
         return False
     
     try:
-        # Open the video
         cap = cv2.VideoCapture(input_video_path)
-        
-        # Get video properties
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Define codec and create VideoWriter
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
         
-        # Watermark settings
         watermark_text = "ginigen.com"
         font = cv2.FONT_HERSHEY_SIMPLEX
-        font_scale = max(0.4, height * 0.001)  # Scale based on video height
+        font_scale = max(0.4, height * 0.001)
         font_thickness = max(1, int(height * 0.002))
         
-        # Get text size
         (text_width, text_height), baseline = cv2.getTextSize(watermark_text, font, font_scale, font_thickness)
-        
-        # Position (bottom right with padding)
         padding = int(width * 0.02)
         x = width - text_width - padding
         y = height - padding
         
-        # Process each frame
         while True:
             ret, frame = cap.read()
             if not ret:
                 break
             
-            # Add semi-transparent background for text
             overlay = frame.copy()
             cv2.rectangle(overlay, 
                          (x - 5, y - text_height - 5), 
@@ -90,43 +84,32 @@ def add_watermark_cv2(input_video_path, output_video_path):
                          (0, 0, 0), 
                          -1)
             frame = cv2.addWeighted(frame, 0.7, overlay, 0.3, 0)
-            
-            # Add text
             cv2.putText(frame, watermark_text, (x, y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
-            
-            # Write frame
             out.write(frame)
         
-        # Release everything
         cap.release()
         out.release()
         cv2.destroyAllWindows()
-        
         return True
         
     except Exception as e:
         print(f"Watermark error: {str(e)}")
         return False
 
-def add_watermark_simple(input_video_path, output_video_path):
-    """Simple fallback - just copy the video without watermark"""
-    try:
-        import shutil
-        shutil.copy2(input_video_path, output_video_path)
-        return False
-    except Exception as e:
-        print(f"Copy error: {str(e)}")
-        return False
-
 def add_watermark(input_video_path, output_video_path):
-    """Add watermark to video - tries cv2 first, then fallback"""
+    """Add watermark to video"""
     if VIDEO_PROCESSING_AVAILABLE:
         success = add_watermark_cv2(input_video_path, output_video_path)
         if success:
             return True
     
     # Fallback - just copy without watermark
-    return add_watermark_simple(input_video_path, output_video_path)
+    try:
+        import shutil
+        shutil.copy2(input_video_path, output_video_path)
+        return False
+    except:
+        return False
 
 def update_prompt_placeholder(mode):
     """Update prompt placeholder based on mode"""
@@ -148,69 +131,44 @@ def update_image_input(mode):
     else:
         return gr.update(visible=False)
 
-def warmup_model(api_key_input, progress=gr.Progress()):
-    """Warm up the model with a simple request"""
-    token = api_key_input or api_token
-    if not token:
-        return gr.update(visible=True, value="❌ API token required. Please set it in API Settings.")
-    
-    replicate.api_token = token
+def poll_for_result(request_id, api_key, progress_callback=None):
+    """Poll WaveSpeed API for video generation result"""
+    url = f"{API_BASE_URL}/predictions/{request_id}/result"
+    headers = {"Authorization": f"Bearer {api_key}"}
     
-    try:
-        progress(0, desc="Starting model warm-up...")
-        
-        # Very simple warm-up request with minimal parameters
-        warm_up_params = {
-            "prompt": "red",  # Extremely simple prompt
-            "duration": 1,    # Minimum duration
-            "resolution": "480p",
-            "aspect_ratio": "16:9",
-            "seed": 42
-        }
-        
-        progress(0.5, desc="Sending warm-up request (this may fail, that's normal)...")
-        
+    start_time = time.time()
+    while True:
         try:
-            output = replicate.run("bytedance/seedance-1-lite", input=warm_up_params)
-            if output:
-                return gr.update(visible=True, value="""✅ **Warm-up successful!** 
-
-The model is now awake. You can generate videos normally.
-Note: The model stays active for ~5 minutes, so generate quickly!""")
-        except Exception as e:
-            if "PA" in str(e) or "interrupted" in str(e).lower():
-                return gr.update(visible=True, value="""⏰ **Warm-up request sent!**
-
-The model is waking up. This is normal for a cold start.
-
-**Next steps:**
-1. Wait 2-3 minutes for the model to fully initialize
-2. Try a simple prompt: "a cat walking"
-3. Once that works, use your actual prompt
-
-The wake-up process takes time, but subsequent generations will be fast!""")
-            else:
-                return gr.update(visible=True, value=f"""⚠️ **Warm-up attempted**
-
-Error: {str(e)[:200]}...
-
-**What to do:**
-1. Wait 2-3 minutes
-2. Try generating with a simple prompt
-3. The model might already be warming up!""")
+            response = requests.get(url, headers=headers, timeout=30)
             
-    except Exception as e:
-        return gr.update(visible=True, value=f"❌ Warm-up error: {str(e)[:200]}... Try generating anyway after waiting a minute.")
+            if response.status_code == 200:
+                result = response.json()["data"]
+                status = result["status"]
+                
+                elapsed = time.time() - start_time
+                if progress_callback:
+                    progress_val = min(0.3 + (elapsed / 120) * 0.6, 0.9)
+                    progress_callback(progress_val, desc=f"Processing... Status: {status} ({int(elapsed)}s)")
+                
+                if status == "completed":
+                    video_url = result["outputs"][0]
+                    return True, video_url
+                elif status == "failed":
+                    error_msg = result.get('error', 'Unknown error')
+                    return False, f"Generation failed: {error_msg}"
+                elif elapsed > 300:  # 5 minute timeout
+                    return False, "Timeout: Generation took too long"
+                
+                # Continue polling
+                time.sleep(2)
+            else:
+                return False, f"API Error: {response.status_code} - {response.text}"
+                
+        except Exception as e:
+            return False, f"Connection error: {str(e)}"
 
-def generate_video(mode, prompt, image, aspect_ratio, seed, api_key_input, progress=gr.Progress()):
-    """Main video generation function"""
-    
-    # API token check
-    token = api_key_input or api_token
-    if not token:
-        return None, "❌ API token required. Please set RAPI_TOKEN environment variable or enter your API key."
-    
-    os.environ["REPLICATE_API_TOKEN"] = token
+def generate_video(mode, prompt, image, aspect_ratio, seed, api_key_override_t2v, api_key_override_i2v, progress=gr.Progress()):
+    """Main video generation function using WaveSpeed API"""
     
     # Input validation
     if not prompt:
@@ -220,147 +178,83 @@ def generate_video(mode, prompt, image, aspect_ratio, seed, api_key_input, progr
         return None, "❌ Please upload an image."
     
     try:
-        progress(0, desc="Preparing video generation...")
-        
-        # Input parameters setup
-        input_params = {
-            "prompt": prompt,
-            "duration": 5,  # Fixed at 5 seconds
-            "resolution": "480p",
-            "aspect_ratio": aspect_ratio,
-            "seed": seed
-        }
+        progress(0, desc="Preparing request...")
         
-        # Image to video mode
-        if mode == "Image to Video" and image is not None:
-            progress(0.1, desc="Processing image...")
+        # Determine which API to use
+        if mode == "Text to Video":
+            api_key = api_key_override_t2v or API_KEY_T2V
+            endpoint = T2V_ENDPOINT
             
-            # Convert PIL Image to base64
-            if isinstance(image, str):  # File path
-                with Image.open(image) as img:
+            payload = {
+                "aspect_ratio": aspect_ratio,
+                "duration": 5,
+                "prompt": prompt,
+                "seed": seed if seed >= 0 else -1
+            }
+        else:  # Image to Video
+            api_key = api_key_override_i2v or API_KEY_I2V
+            endpoint = I2V_ENDPOINT
+            
+            # Handle image upload
+            if isinstance(image, str) and (image.startswith('http://') or image.startswith('https://')):
+                # If it's already a URL
+                image_url = image
+            else:
+                # Convert PIL Image to base64 for upload
+                progress(0.1, desc="Processing image...")
+                if isinstance(image, str):
+                    with Image.open(image) as img:
+                        buffered = io.BytesIO()
+                        img.save(buffered, format="PNG")
+                        image_base64 = base64.b64encode(buffered.getvalue()).decode()
+                else:
                     buffered = io.BytesIO()
-                    img.save(buffered, format="PNG")
+                    image.save(buffered, format="PNG")
                     image_base64 = base64.b64encode(buffered.getvalue()).decode()
-            else:  # PIL Image object
-                buffered = io.BytesIO()
-                image.save(buffered, format="PNG")
-                image_base64 = base64.b64encode(buffered.getvalue()).decode()
+                
+                # For this demo, we'll assume the image needs to be uploaded somewhere
+                # In production, you'd upload to a CDN and get a URL
+                return None, "❌ Image upload to CDN not implemented. Please use an image URL."
             
-            input_params["image"] = f"data:image/png;base64,{image_base64}"
+            payload = {
+                "duration": 5,
+                "image": image_url,
+                "prompt": prompt,
+                "seed": seed if seed >= 0 else -1
+            }
+        
+        # Submit request
+        progress(0.2, desc="Submitting request to WaveSpeed AI...")
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
         
-        progress(0.2, desc="Preparing API request...")
+        response = requests.post(endpoint, headers=headers, data=json.dumps(payload), timeout=30)
         
-        # Set up Replicate with the API token
-        replicate.api_token = token
+        if response.status_code == 200:
+            result = response.json()["data"]
+            request_id = result["id"]
+            progress(0.3, desc=f"Request submitted. ID: {request_id}")
+        else:
+            return None, f"❌ API Error: {response.status_code} - {response.text}"
         
-        # Skip model availability check to avoid delays
-        # The actual run will handle cold start retries
+        # Poll for result
+        success, result = poll_for_result(request_id, api_key, lambda p, desc: progress(p, desc=desc))
         
-        progress(0.3, desc="Calling Replicate API...")
+        if not success:
+            return None, f"❌ {result}"
         
-        # Run Replicate with retry logic and cold start handling
-        max_attempts = 3  # Reduced attempts, focus on user guidance
-        output = None
+        video_url = result
+        progress(0.9, desc="Downloading video...")
         
-        for attempt in range(max_attempts):
-            try:
-                # Run the actual request
-                progress(0.3 + attempt * 0.1, desc=f"Generating video... (Attempt {attempt + 1}/{max_attempts})")
-                
-                # Run the model
-                output = replicate.run(
-                    "bytedance/seedance-1-lite",
-                    input=input_params
-                )
-                
-                # If we got output, break the retry loop
-                if output:
-                    break
-                    
-            except Exception as e:
-                error_str = str(e)
-                print(f"Attempt {attempt + 1} error: {error_str}")  # Debug logging
-                
-                # Check for cold start indicators
-                if "Prediction interrupted" in error_str or "code: PA" in error_str or "PA" in error_str:
-                    if attempt == 0:
-                        # First cold start - provide immediate guidance
-                        return None, """❌ **Model is cold starting (code: PA)**
-
-**Quick Fix - Follow these steps:**
-
-1️⃣ Click the **"🔥 Warm Up Model"** button above
-2️⃣ Wait for the warm-up to complete (it may also fail, that's OK)
-3️⃣ **Wait 2-3 minutes** for the model to fully initialize
-4️⃣ Try this simple prompt first: **"a cat walking"**
-5️⃣ Once that works, try your original prompt
-
-**Why this happens:** The model goes to sleep after inactivity to save resources. The first request wakes it up, which takes time.
-
-**Alternative:** Try again in 5 minutes when the model should be fully awake."""
-                    elif attempt < max_attempts - 1:
-                        # Subsequent attempts - wait and retry
-                        wait_time = 30 + (attempt * 15)
-                        progress(0.3, desc=f"Model still warming up. Waiting {wait_time}s... (Attempt {attempt + 2}/{max_attempts})")
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        return None, """❌ Model is taking longer than usual to start. 
-
-**Please try one of these options:**
-1. Use the "🔥 Warm Up Model" button first
-2. Wait 5 minutes and try again
-3. Try a very simple prompt: "a red circle"
-4. Try during off-peak hours (evening/night US time)
-
-The model needs to 'warm up' after being idle."""
-                        
-                elif "cold boot" in error_str.lower() or "starting" in error_str.lower():
-                    if attempt < max_attempts - 1:
-                        progress(0.3, desc=f"Model is booting up, waiting 60s...")
-                        time.sleep(60)
-                        continue
-                        
-                elif "timeout" in error_str.lower():
-                    if attempt < max_attempts - 1:
-                        progress(0.3, desc=f"Request timed out, retrying... (Attempt {attempt + 2}/{max_attempts})")
-                        time.sleep(15)
-                        continue
-                        
-                else:
-                    # For any other error, still retry a few times
-                    if attempt < max_attempts - 1:
-                        wait_time = 10 + (attempt * 5)
-                        progress(0.3, desc=f"Error occurred, retrying in {wait_time}s... (Attempt {attempt + 2}/{max_attempts})")
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        return None, f"❌ Error after {max_attempts} attempts: {error_str}"
-        
-        # Check if we got output
-        if not output:
-            return None, """❌ Failed to generate video after multiple attempts.
-
-**This usually happens when:**
-- The model is cold starting (hasn't been used recently)
-- The server is under heavy load
-
-**Please try:**
-1. Wait 3-5 minutes for the model to warm up
-2. Start with a simple prompt: "a cat walking" or "a ball bouncing"
-3. Once that works, try your original prompt
-
-The first generation often takes longer, but subsequent ones will be faster."""
-        
-        progress(0.7, desc="Downloading video...")
+        # Download video
+        video_response = requests.get(video_url, timeout=60)
+        if video_response.status_code != 200:
+            return None, f"❌ Failed to download video from {video_url}"
         
-        # Get video data
-        if hasattr(output, 'read'):
-            video_data = output.read()
-        else:
-            # Download from URL with timeout
-            response = requests.get(output, timeout=60)
-            video_data = response.content
+        video_data = video_response.content
         
         # Save to temporary file
         with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
@@ -372,7 +266,7 @@ The first generation often takes longer, but subsequent ones will be faster."""
         final_video_path = temp_video_path
         
         if VIDEO_PROCESSING_AVAILABLE:
-            progress(0.8, desc="Adding watermark...")
+            progress(0.95, desc="Adding watermark...")
             final_video_path = tempfile.mktemp(suffix='.mp4')
             watermark_added = add_watermark(temp_video_path, final_video_path)
             
@@ -405,67 +299,54 @@ The first generation often takes longer, but subsequent ones will be faster."""
 - Duration: 5 seconds
 - Resolution: 480p
 - Watermark: {watermark_status}
+- API: WaveSpeed AI
+- Cost: $0.06
 - File: output.mp4"""
         
         return final_video_path, info
         
     except requests.exceptions.Timeout:
-        return None, "⏱️ Request timed out. The server might be under heavy load. Please try again in a few minutes."
+        return None, "⏱️ Request timed out. Please try again."
     except Exception as e:
-        error_msg = f"❌ Error occurred: {str(e)}"
-        if "timeout" in str(e).lower():
-            error_msg += "\n\n💡 Tip: The model might be cold starting. Please wait a minute and try again."
-        return None, error_msg
+        return None, f"❌ Error occurred: {str(e)}"
 
 # Gradio interface
 with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
     # 🎬 Bytedance Seedance Video' Free
     
-    Generate videos from text or images using **Replicate API**.
+    Generate videos from text or images using **WaveSpeed AI API**.
     
-    [![Powered by Ginigen](https://img.shields.io/badge/Powered%20by-Replicate-blue)](https://ginigen.com/)
-    """)
+    [![Powered by Ginigen](https://img.shields.io/badge/Powered%20by-WaveSpeed%20AI-blue)](https://ginigen.com/)
     
-    # Cold start warning box
-    with gr.Accordion("⚠️ Getting 'Prediction interrupted (PA)' error? Click here!", open=False):
-        gr.Markdown("""
-        ### ���� Model Cold Start Guide
-        
-        If you're getting **"Prediction interrupted (code: PA)"** errors, the model is sleeping and needs to wake up.
-        
-        **Quick Solution:**
-        1. Click the **"🔥 Warm Up Model"** button
-        2. Wait 2-3 minutes after warm-up
-        3. Try a simple prompt: **"a cat walking"**
-        4. Once that works, use your actual prompt
-        
-        **Why this happens:** Free tier models sleep after ~5 minutes of inactivity to save resources.
-        The first request wakes them up, which can take 2-5 minutes.
-        
-        **Pro tip:** Once warmed up, the model stays active for ~5 minutes. Generate multiple videos quickly!
-        """)
+    ⚠️ **Note**: Each generation costs $0.06
+    """)
     
     with gr.Row():
         with gr.Column(scale=1):
             # API Settings
-            with gr.Accordion("⚙️ API Settings", open=not bool(api_token)):
-                if api_token:
-                    gr.Markdown("✅ API token loaded from environment variable.")
-                    api_key_input = gr.Textbox(
-                        label="Replicate API Token (Optional)",
-                        type="password",
-                        placeholder="Enter to override environment variable",
-                        value=""
-                    )
-                else:
-                    gr.Markdown("⚠️ RAPI_TOKEN environment variable not set.")
-                    api_key_input = gr.Textbox(
-                        label="Replicate API Token (Required)",
-                        type="password",
-                        placeholder="Enter your Replicate API token",
-                        value=""
-                    )
+            with gr.Accordion("⚙️ API Settings", open=False):
+                gr.Markdown("""
+                API keys are loaded from environment variables:
+                - `WAVESPEED_API_KEY_T2V` for Text-to-Video
+                - `WAVESPEED_API_KEY_I2V` for Image-to-Video
+                
+                You can override them below if needed.
+                """)
+                
+                api_key_override_t2v = gr.Textbox(
+                    label="Text-to-Video API Key (Optional Override)",
+                    type="password",
+                    placeholder="Leave empty to use environment variable",
+                    value=""
+                )
+                
+                api_key_override_i2v = gr.Textbox(
+                    label="Image-to-Video API Key (Optional Override)",
+                    type="password",
+                    placeholder="Leave empty to use environment variable",
+                    value=""
+                )
             
             # Generation mode
             mode = gr.Radio(
@@ -476,12 +357,12 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
             
             # Image upload
             image_input = gr.Image(
-                label="📷 Upload Image",
+                label="📷 Upload Image or Provide URL",
                 type="pil",
                 visible=False
             )
             
-            # Aspect ratio
+            # Aspect ratio (only for T2V)
             aspect_ratio = gr.Dropdown(
                 label="📐 Aspect Ratio",
                 choices=list(ASPECT_RATIOS.keys()),
@@ -495,9 +376,9 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
             # Seed setting
             seed = gr.Number(
                 label="🎲 Random Seed",
-                value=42,
+                value=-1,
                 precision=0,
-                info="Use same seed value to reproduce same results"
+                info="Use -1 for random, or set a specific value for reproducible results"
             )
             
             # Fixed settings display
@@ -506,6 +387,7 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
             ### 📋 Fixed Settings
             - **Duration**: 5 seconds
             - **Resolution**: 480p
+            - **Cost**: $0.06 per video
             - **Watermark**: {watermark_info}
             """)
         
@@ -518,23 +400,18 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
                 value=""
             )
             
-            # Generate and warm-up buttons
-            with gr.Row():
-                generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg", scale=2)
-                warmup_btn = gr.Button("🔥 Warm Up Model First", variant="secondary", size="lg", scale=1)
-            
-            gr.Markdown("*Use Warm Up if you're getting PA errors or it's your first generation today*")
+            # Generate button
+            generate_btn = gr.Button("🎬 Generate Video ($0.06)", variant="primary", size="lg")
             
             # Results display
             with gr.Column():
-                warmup_status = gr.Textbox(label="Status", visible=False)
                 output_video = gr.Video(
                     label="📹 Generated Video",
                     autoplay=True
                 )
                 output_info = gr.Textbox(
                     label="Information",
-                    lines=8,
+                    lines=10,
                     interactive=False
                 )
     
@@ -545,7 +422,7 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         
         1. **Install required packages**:
         ```bash
-        pip install gradio replicate pillow requests
+        pip install gradio requests pillow
         ```
         
         2. **For watermark support (optional)**:
@@ -553,9 +430,10 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         pip install opencv-python
         ```
         
-        3. **Set environment variable** (optional):
+        3. **Set environment variables**:
         ```bash
-        export RAPI_TOKEN="your-replicate-api-token"
+        export WAVESPEED_API_KEY_T2V="your-t2v-api-key"
+        export WAVESPEED_API_KEY_I2V="your-i2v-api-key"
         ```
         
         4. **Run**:
@@ -566,52 +444,36 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         ### Features
         
         - **Text to Video**: Generate video from text description only
-        - **Image to Video**: Transform uploaded image into animated video
+        - **Image to Video**: Transform uploaded image into animated video (requires image URL)
         - **Aspect Ratios**: Choose ratios optimized for various social media platforms
-        - **Seed Value**: Use same seed to reproduce identical results
+        - **Seed Value**: Use -1 for random or set specific value for reproducible results
         - **Watermark**: Automatically adds "ginigen.com" watermark (requires opencv-python)
         
+        ### API Information
+        
+        - **Provider**: WaveSpeed AI
+        - **Models**: ByteDance Seedance v1 Lite
+        - **Cost**: $0.06 per 5-second video
+        - **Resolution**: 480p
+        
         ### Prompt Writing Tips
         
         - Use specific and detailed descriptions
         - Specify camera movements (e.g., zoom in, pan left, tracking shot)
         - Describe lighting and atmosphere (e.g., golden hour, dramatic lighting)
         - Indicate movement speed (e.g., slowly, rapidly, gently)
-        
-        ### Troubleshooting
-        
-        #### If you get "Prediction interrupted (code: PA)":
-        
-        This means the model is cold starting. Follow these steps:
-        
-        1. **First Try**: Click the "🔥 Warm Up Model" button and wait for completion
-        2. **Wait**: After warm-up, wait 2-3 minutes for the model to fully initialize
-        3. **Simple Test**: Try generating with a very simple prompt: "a cat walking"
-        4. **Your Prompt**: Once the simple test works, try your actual prompt
-        
-        **Other Issues:**
-        - **Repeated failures**: The model may be under heavy load. Try during off-peak hours
-        - **Timeout errors**: Increase wait time between attempts
-        - **Watermark not showing**: Install opencv-python for watermark support
-        
-        **Pro Tips:**
-        - First generation of the day always takes longer
-        - Keep prompts under 100 words for best results
-        - Simple prompts work better for warming up the model
-        - Once warmed up, generate multiple videos quickly before the model sleeps again!
         """)
     
     # Examples
     gr.Examples(
         examples=[
-            ["Text to Video", "a red ball bouncing", None, "16:9", 42],  # Very simple warm-up
-            ["Text to Video", "a cat walking", None, "16:9", 42],  # Simple warm-up prompt
+            ["Text to Video", "A cat walking gracefully across a sunlit room", None, "16:9", -1],
             ["Text to Video", "A serene lake at sunrise with mist rolling over the water. Camera slowly pans across the landscape as birds fly overhead.", None, "16:9", 42],
             ["Text to Video", "Urban street scene at night with neon lights reflecting on wet pavement. People walking with umbrellas, camera tracking forward.", None, "9:16", 123],
             ["Text to Video", "Close-up of a flower blooming in time-lapse, soft natural lighting, shallow depth of field.", None, "1:1", 789],
         ],
         inputs=[mode, prompt, image_input, aspect_ratio, seed],
-        label="Example Prompts (⚡ Start with 'red ball' or 'cat walking' if model is cold)"
+        label="Example Prompts"
     )
     
     # Event handlers
@@ -633,15 +495,9 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         outputs=[ratio_info]
     )
     
-    warmup_btn.click(
-        fn=warmup_model,
-        inputs=[api_key_input],
-        outputs=[warmup_status]
-    )
-    
     generate_btn.click(
         fn=generate_video,
-        inputs=[mode, prompt, image_input, aspect_ratio, seed, api_key_input],
+        inputs=[mode, prompt, image_input, aspect_ratio, seed, api_key_override_t2v, api_key_override_i2v],
         outputs=[output_video, output_info]
     )