Create app2.py

app2.py

@@ -0,0 +1,582 @@
+import gradio as gr
+from PIL import Image
+from moviepy.editor import VideoFileClip, AudioFileClip
+import os
+from openai import OpenAI
+import subprocess
+from pathlib import Path
+import uuid
+import tempfile
+import shlex
+import shutil
+import logging # 添加日志记录
+
+# 配置日志记录
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Supported models configuration
+MODELS = {
+    "deepseek-ai/DeepSeek-V3": {
+        "base_url": "https://api.deepseek.com/v1",
+        "env_key": "DEEPSEEK_API_KEY",
+    },
+    "Qwen/Qwen2.5-Coder-32B-Instruct": {
+        "base_url": "https://api-inference.huggingface.co/v1/",
+        "env_key": "HF_TOKEN",
+    },
+    # Add more models here if needed
+}
+
+# Function to get the first available API key
+def get_first_available_key_config():
+    for model, config in MODELS.items():
+        if config["env_key"] in os.environ and os.environ[config["env_key"]]:
+            logging.info(f"Using API key for model: {model}")
+            return config
+    return None
+
+# Initialize client with first available model configuration
+initial_config = get_first_available_key_config()
+if initial_config:
+    client = OpenAI(
+        base_url=initial_config["base_url"],
+        api_key=os.environ[initial_config["env_key"]],
+    )
+    initial_model_choice = next(iter(MODELS.keys())) # Keep track of which model config was used initially
+else:
+    logging.warning("No API keys found in environment variables for configured models. API calls will fail.")
+    # Initialize with placeholder values or handle error as appropriate
+    client = None # Or raise an error, or use a default config if applicable
+    initial_model_choice = list(MODELS.keys())[0] # Default UI selection
+
+allowed_medias = [
+    ".png", ".jpg", ".webp", ".jpeg", ".tiff", ".bmp", ".gif", ".svg",
+    ".mp3", ".wav", ".ogg", ".aac", ".flac", # Added more audio types
+    ".mp4", ".avi", ".mov", ".mkv", ".flv", ".wmv", ".webm", ".mpg", ".mpeg", ".m4v",
+    ".3gp", ".3g2", ".3gpp",
+]
+
+
+def get_files_infos(files):
+    results = []
+    if not files:
+        return results
+
+    for file_obj in files:
+        file_path = Path(file_obj.name)
+        info = {"error": None} # Initialize error as None
+        try:
+            info["size"] = os.path.getsize(file_path)
+            # Sanitize filename by replacing spaces with underscores
+            original_name = file_path.name
+            info["name"] = original_name.replace(" ", "_")
+            info["original_name"] = original_name # Keep original name for user display if needed
+            file_extension = file_path.suffix.lower() # Use lower case for consistency
+
+            if file_extension in (".mp4", ".avi", ".mkv", ".mov", ".webm", ".flv", ".wmv", ".mpg", ".mpeg", ".m4v", ".3gp", ".3g2", ".3gpp"):
+                info["type"] = "video"
+                try:
+                    video = VideoFileClip(str(file_path)) # Use string path
+                    info["duration"] = video.duration
+                    info["dimensions"] = f"{video.size[0]}x{video.size[1]}"
+                    if video.audio:
+                        info["type"] = "video/audio"
+                        info["audio_channels"] = video.audio.nchannels
+                    video.close()
+                except UnicodeDecodeError as ude:
+                    info["error"] = f"Metadata decoding error ({ude}). Basic info might be missing."
+                    logging.warning(f"UnicodeDecodeError processing video {info['name']}: {ude}")
+                except Exception as e:
+                    info["error"] = f"Error reading video metadata ({type(e).__name__})."
+                    logging.warning(f"Error processing video {info['name']}: {e}", exc_info=True) # Log full traceback
+
+            elif file_extension in (".mp3", ".wav", ".ogg", ".aac", ".flac"):
+                info["type"] = "audio"
+                try:
+                    audio = AudioFileClip(str(file_path)) # Use string path
+                    info["duration"] = audio.duration
+                    info["audio_channels"] = audio.nchannels
+                    audio.close()
+                except UnicodeDecodeError as ude:
+                    info["error"] = f"Metadata decoding error ({ude}). Basic info might be missing."
+                    logging.warning(f"UnicodeDecodeError processing audio {info['name']}: {ude}")
+                except Exception as e:
+                    info["error"] = f"Error reading audio metadata ({type(e).__name__})."
+                    logging.warning(f"Error processing audio {info['name']}: {e}", exc_info=True) # Log full traceback
+
+            elif file_extension in (".png", ".jpg", ".jpeg", ".tiff", ".bmp", ".gif", ".svg", ".webp"):
+                info["type"] = "image"
+                try:
+                    with Image.open(file_path) as img:
+                        info["dimensions"] = f"{img.size[0]}x{img.size[1]}"
+                except Exception as e:
+                    info["error"] = f"Error reading image metadata ({type(e).__name__})."
+                    logging.warning(f"Error processing image {info['name']}: {e}", exc_info=True)
+
+            else:
+                 info["type"] = "unknown"
+                 info["error"] = "Unsupported file type."
+                 logging.warning(f"Unsupported file type: {info['name']}")
+
+        except OSError as ose:
+             info["error"] = f"File system error: {ose}"
+             logging.error(f"OSError accessing file {file_path}: {ose}", exc_info=True)
+             if "name" not in info: info["name"] = file_path.name # Ensure name is present even on early error
+        except Exception as e:
+             info["error"] = f"Unexpected error processing file: {e}"
+             logging.error(f"Unexpected error processing file {file_path}: {e}", exc_info=True)
+             if "name" not in info: info["name"] = file_path.name
+
+        results.append(info)
+
+    return results
+
+
+def get_completion(prompt, files_info, top_p, temperature, model_choice):
+    global client # Ensure we are using the global client object
+
+    if client is None:
+        raise gr.Error("API Client not initialized. Please check API key configuration.")
+
+    # --- Create files info table ---
+    files_info_string = "| Type | Name | Dimensions | Duration | Audio Channels | Status |\n"
+    files_info_string += "|------|------|------------|----------|----------------|--------|\n"
+
+    for file_info in files_info:
+        # Use sanitized name for the command context
+        name = file_info.get("name", "N/A")
+        # Use original name or sanitized name for display in the table, decide which is better
+        display_name = file_info.get("original_name", name) # Prefer original name for user readability
+
+        file_type = file_info.get("type", "N/A")
+        dimensions = file_info.get("dimensions", "-")
+        duration = f"{file_info.get('duration', '-'):.2f}s" if "duration" in file_info and file_info['duration'] is not None else "-"
+        audio = f"{file_info.get('audio_channels', '-')}" if "audio_channels" in file_info and file_info['audio_channels'] is not None else "-"
+        status = "Error" if file_info.get("error") else "OK"
+
+        files_info_string += f"| {file_type} | {display_name} | {dimensions} | {duration} | {audio} | {status} |\n"
+        if file_info.get("error"):
+             files_info_string += f"| `Error Details` | `{file_info['error']}` | - | - | - | - |\n" # Add error details row
+
+    # --- Construct Messages ---
+    messages = [
+        {
+            "role": "system",
+            "content": """
+You are a very experienced media engineer, controlling a UNIX terminal.
+You are an FFMPEG expert with years of experience and multiple contributions to the FFMPEG project.
+
+You are given:
+(1) A list of media assets (video, audio, images) with details like name, type, dimensions, duration, and status (including potential errors reading metadata). Use the 'Name' column from the table as the input filename in your command.
+(2) A user's objective describing a new video to be created from these assets.
+
+Your objective is to generate the SIMPLEST POSSIBLE, SINGLE ffmpeg command to achieve the user's goal.
+
+Key requirements:
+    - Output exactly ONE ffmpeg command.
+    - The command MUST be on a single line (no line breaks).
+    - Use the absolute minimum number of ffmpeg options needed.
+    - Avoid complex filter chains (`-filter_complex`) unless absolutely necessary. Prefer simpler filters, concatenation, scaling etc.
+    - The final output file MUST be named exactly `output.mp4`.
+    - Input filenames in the command MUST match the 'Name' column provided in the asset list (which uses underscores instead of spaces).
+    - If the user asks for waveform visualization: use `-filter_complex "[0:a]showwaves=s=WxH:mode=line,format=pix_fmts=yuv420p[v]" -map "[v]" -map 0:a?` (replace WxH with desired video dimensions), and ensure audio is mono (`-ac 1`). Assume full video width if not specified.
+    - For image sequences: Prefer `-framerate` and pattern matching (e.g., `img%03d.png`) if inputs suggest a sequence. Otherwise, use `-loop 1 -t duration` for single images.
+    - Handle potential errors noted in the asset list gracefully if possible (e.g., if metadata is missing, use sensible defaults or inform the user if the task is impossible).
+    - NEVER output multiple commands chained with `&&` or `;`.
+    - NEVER use wildcards like `*` in filenames. Use specific filenames from the list.
+
+Remember: Simplicity and correctness are key. Generate only the ffmpeg command itself, no explanations.
+""",
+        },
+        {
+            "role": "user",
+            "content": f"""Provide only the single-line FFMPEG shell command to achieve the objective.
+
+AVAILABLE ASSETS LIST:
+
+{files_info_string}
+
+OBJECTIVE: {prompt}
+Make sure the final output file is named exactly "output.mp4".
+
+YOUR FFMPEG COMMAND:
+""",
+        },
+    ]
+    try:
+        # Print the complete prompt for debugging
+        logging.info("\n=== COMPLETE PROMPT ===\n")
+        for msg in messages:
+            logging.info(f"\n[{msg['role'].upper()}]:\n{msg['content']}")
+        logging.info("=====================\n")
+
+        if model_choice not in MODELS:
+            raise ValueError(f"Model {model_choice} is not supported")
+
+        model_config = MODELS[model_choice]
+        api_key = os.environ.get(model_config["env_key"])
+
+        if not api_key:
+             raise gr.Error(f"API Key ({model_config['env_key']}) not found in environment variables for model {model_choice}.")
+
+        # Update client configuration for the selected model
+        client.base_url = model_config["base_url"]
+        client.api_key = api_key
+        # Determine model name based on provider convention
+        model_name = "deepseek-chat" if "deepseek" in model_choice.lower() else model_choice
+
+        completion = client.chat.completions.create(
+            model=model_name,
+            messages=messages,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=2048,
+        )
+        content = completion.choices[0].message.content.strip() # Strip leading/trailing whitespace
+
+        # Extract command: prioritize code blocks, then raw content
+        command = content
+        if "```" in content:
+            import re
+            match = re.search(r"```(?:sh|bash)?\s*(ffmpeg.*?)\s*```", content, re.DOTALL | re.IGNORECASE)
+            if match:
+                command = match.group(1).strip()
+                logging.info(f"Extracted command from code block: {command}")
+            else:
+                # Fallback if block markers exist but pattern fails
+                command = content.replace("```sh", "").replace("```bash", "").replace("```", "").strip()
+                logging.warning(f"Could not extract command reliably from code block, using fallback: {command}")
+        else:
+             logging.info(f"No code block detected, using raw content as command: {command}")
+
+        # Basic validation: ensure it starts with ffmpeg
+        if not command.lower().startswith("ffmpeg "):
+             logging.error(f"Generated content does not start with ffmpeg: {command}")
+             raise ValueError("AI did not generate a valid ffmpeg command.")
+
+        # Remove potential leading/trailing quotes if the AI wrapped the whole command
+        command = command.strip('\'"')
+
+        return command
+
+    except Exception as e:
+        logging.error(f"API Error or processing error in get_completion: {e}", exc_info=True)
+        # Re-raise specific Gradio error for UI display
+        raise gr.Error(f"Failed to get command from AI: {e}")
+
+
+def update(
+    files,
+    prompt,
+    top_p=1,
+    temperature=1,
+    model_choice=initial_model_choice, # Use the initial model as default
+):
+    if not files:
+        raise gr.Error("Please upload at least one media file.")
+    if not prompt:
+        raise gr.Error("Please enter editing instructions (prompt).")
+    if client is None and model_choice in MODELS:
+         # Check again if client wasn't initialized but a model is chosen
+         env_key = MODELS[model_choice]["env_key"]
+         if env_key not in os.environ or not os.environ[env_key]:
+             raise gr.Error(f"API Key ({env_key}) for the selected model '{model_choice}' is missing. Please set it as an environment variable.")
+         # Try to re-initialize (or update if partially initialized)
+         global client
+         try:
+            client = OpenAI(
+                base_url=MODELS[model_choice]["base_url"],
+                api_key=os.environ[env_key],
+            )
+            logging.info(f"API Client initialized/updated for model: {model_choice}")
+         except Exception as e:
+            raise gr.Error(f"Failed to initialize API client: {e}")
+
+
+    # 1. Get File Infos and Check for Initial Errors
+    files_info = get_files_infos(files)
+    file_errors = [f"- {f.get('original_name', f.get('name', 'Unknown file'))}: {f['error']}" for f in files_info if f.get("error")]
+    if file_errors:
+        error_message = "Errors occurred while processing uploaded files:\n" + "\n".join(file_errors)
+        logging.error(error_message)
+        raise gr.Error(error_message)
+
+    # 2. Validate File Sizes and Durations (optional, based on your constraints)
+    for file_info in files_info:
+        if file_info["size"] > 1000 * 1024 * 1024: # 100MB limit
+            raise gr.Error(f"File '{file_info.get('original_name', file_info['name'])}' exceeds the 100MB size limit.")
+        if file_info.get("type", "").startswith("video") and file_info.get("duration", 0) > 120: # 2 minute limit for videos
+             raise gr.Error(f"Video '{file_info.get('original_name', file_info['name'])}' exceeds the 2-minute duration limit.")
+
+    # 3. Get FFMPEG Command from AI (with retries if needed)
+    command_string = None
+    attempts = 0
+    max_attempts = 2 # Allow one retry
+    last_exception = None
+
+    while attempts < max_attempts:
+        logging.info(f"Attempt {attempts + 1} to generate FFMPEG command.")
+        try:
+            command_string = get_completion(
+                prompt, files_info, top_p, temperature, model_choice
+            )
+            logging.info(
+                f"Generated FFMPEG command string:\n{command_string}\n"
+            )
+            break # Success, exit loop
+        except Exception as e:
+            last_exception = e
+            logging.warning(f"Attempt {attempts + 1} failed: {e}")
+            attempts += 1
+            if attempts >= max_attempts:
+                logging.error("Max attempts reached. Failed to generate valid command.")
+                raise gr.Error(f"Failed to generate FFMPEG command after {max_attempts} attempts. Last error: {last_exception}")
+
+    # 4. Prepare Temporary Directory and Files
+    temp_dir_obj = tempfile.TemporaryDirectory()
+    temp_dir = temp_dir_obj.name
+    logging.info(f"Created temporary directory: {temp_dir}")
+    try:
+        copied_file_paths = {}
+        for i, file_obj in enumerate(files):
+            original_path = Path(file_obj.name)
+            # Use the sanitized name consistent with files_info sent to AI
+            sanitized_name = original_path.name.replace(" ", "_")
+            destination_path = Path(temp_dir) / sanitized_name
+            shutil.copy(original_path, destination_path)
+            logging.info(f"Copied '{original_path.name}' to '{destination_path}'")
+            copied_file_paths[i] = destination_path # Keep track if needed
+
+        # 5. Validate and Execute FFMPEG Command
+        try:
+            # Split command string safely for shell execution
+            args = shlex.split(command_string)
+        except ValueError as e:
+             raise gr.Error(f"Generated command has syntax errors (e.g., unbalanced quotes): {e}\nCommand: {command_string}")
+
+
+        if not args or args[0].lower() != "ffmpeg":
+            raise gr.Error(f"Generated command does not start with 'ffmpeg'. Command: {command_string}")
+
+        # IMPORTANT: Check and remove the placeholder 'output.mp4' if it's the last argument
+        if args[-1] == "output.mp4":
+            logging.info("Removing placeholder 'output.mp4' from the end of the command.")
+            args.pop()
+        elif "output.mp4" in args:
+             logging.warning("Placeholder 'output.mp4' found but not at the end of the command. Execution might fail.")
+             # Decide if you want to raise an error here or let ffmpeg handle it
+
+
+        # Define the actual output path
+        output_file_name = f"output_{uuid.uuid4()}.mp4"
+        output_file_path = str(Path(temp_dir) / output_file_name)
+
+        # Dry Run (optional but recommended)
+        # Note: Dry run might fail for complex commands even if they are valid for execution
+        # Consider making dry run optional or improving its robustness if needed
+        # dry_run_args = args + ["-f", "null", "-"]
+        # logging.info(f"Performing dry run: {' '.join(dry_run_args)}")
+        # ffmpg_dry_run = subprocess.run(
+        #     dry_run_args,
+        #     stderr=subprocess.PIPE,
+        #     stdout=subprocess.PIPE, # Capture stdout too
+        #     text=True,
+        #     encoding='utf-8', errors='replace', # Handle potential weird output
+        #     cwd=temp_dir,
+        #     timeout=30 # Add a timeout
+        # )
+        # if ffmpg_dry_run.returncode != 0:
+        #     error_output = ffmpg_dry_run.stderr or ffmpg_dry_run.stdout
+        #     logging.error(f"FFMPEG dry run failed. Return code: {ffmpg_dry_run.returncode}\nOutput:\n{error_output}")
+        #     raise gr.Error(f"Generated FFMPEG command seems invalid (Dry Run Failed). Please check the command or try different instructions.\nError: {error_output[:500]}...") # Show partial error
+
+
+        # Final Execution
+        final_command = args + ["-y", output_file_path] # Add overwrite flag and final output path
+        logging.info(f"Executing FFMPEG command: ffmpeg {' '.join(final_command[1:])}")
+
+        try:
+            process = subprocess.run(
+                final_command,
+                cwd=temp_dir,
+                stderr=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                text=True,
+                encoding='utf-8', errors='replace',
+                check=True, # Raise CalledProcessError if return code is non-zero
+                timeout=3000 # Set a reasonable timeout (e.g., 5 minutes)
+            )
+            logging.info("FFMPEG command executed successfully.")
+            logging.info(f"FFMPEG stdout:\n{process.stdout}")
+            logging.info(f"FFMPEG stderr:\n{process.stderr}")
+
+        except subprocess.CalledProcessError as e:
+            error_output = e.stderr or e.stdout
+            logging.error(f"FFMPEG execution failed! Return code: {e.returncode}\nCommand: {' '.join(e.cmd)}\nOutput:\n{error_output}")
+            raise gr.Error(f"FFMPEG execution failed.\nCommand: ffmpeg {' '.join(final_command[1:])}\nError: {error_output[:1000]}...") # Show more error context
+        except subprocess.TimeoutExpired as e:
+            logging.error(f"FFMPEG command timed out after {e.timeout} seconds.\nCommand: {' '.join(e.cmd)}")
+            raise gr.Error(f"FFMPEG command timed out after {e.timeout} seconds. The operation might be too complex or the files too large.")
+
+
+        # 6. Prepare Output
+        # Display the command used (using the originally generated args + output)
+        display_command_args = args + ["-y", "output.mp4"] # Reconstruct for display
+        generated_command_markdown = f"### Generated Command\n```bash\nffmpeg {' '.join(display_command_args[1:])}\n```"
+
+        # Return the path to the generated video and the command markdown
+        # Gradio needs the actual path; it will handle cleanup if temp_dir_obj goes out of scope
+        # However, explicitly returning the temp dir object might be safer depending on Gradio version
+        # For simplicity, returning the path and relying on Gradio's handling of temp files.
+        return output_file_path, gr.update(value=generated_command_markdown)
+
+    except Exception as e:
+        # Catch any other unexpected errors during setup or execution
+        logging.error(f"Error in update function: {e}", exc_info=True)
+        # Clean up the temp directory manually if an error occurred before returning
+        temp_dir_obj.cleanup()
+        raise gr.Error(f"An unexpected error occurred: {e}")
+
+    # No finally block needed for temp_dir_obj.cleanup() if using 'with TemporaryDirectory()'
+    # If not using 'with', ensure cleanup happens in try/except/finally
+
+
+# --- Gradio Interface ---
+with gr.Blocks(title="AI Video Editor - Edit with Natural Language", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🏞 AI Video Editor: Your Smart Editing Assistant 🎬
+
+        Welcome to the AI Video Editor! This powerful tool leverages advanced AI models like **Qwen2.5-Coder** and **DeepSeek-V3** to understand your editing needs expressed in plain English. Simply upload your video, audio, or image files, describe the desired outcome, and watch as the AI generates the necessary **FFMPEG command** to create your final video.
+
+        **No complex software or coding required!** Perfect for quick edits, batch processing ideas, learning FFMPEG syntax, or automating simple video tasks. Whether you need to trim, merge, add text, change speed, apply filters, or combine different media types, just tell the AI what you want.
+
+        **Get started now:** Upload your files, type your instructions, and hit "Run"!
+        """,
+        elem_id="header",
+    )
+
+    with gr.Accordion("📋 Usage Instructions & Examples", open=False):
+        gr.Markdown(
+            """
+            ### How to Use AI Video Editor
+
+            1.  **Upload Media Files**: Drag & drop or click to upload your video, image, or audio files (`.mp4`, `.mov`, `.mp3`, `.wav`, `.jpg`, `.png`, etc.) into the "Media files" area. Multiple files are allowed.
+            2.  **Write Instructions**: Clearly describe the editing task in the "Instructions" textbox. Be specific for best results.
+            3.  **(Optional) Adjust Parameters**:
+                *   **Model**: Choose the AI model you want to use. Different models might have varying strengths in understanding instructions or FFMPEG knowledge.
+                *   **Top-p & Temperature**: Fine-tune the AI's creativity and randomness. Lower temperature (e.g., 0.1) leads to more predictable results, higher values increase randomness. Top-p controls the diversity of the AI's choices. Default values are usually good starting points.
+            4.  **Generate**: Click the **"Run"** button. The AI will generate an FFMPEG command, which will then be executed to produce your video.
+            5.  **Review**: The resulting video will appear in the "Generated Video" player. The exact FFMPEG command used will be shown below it.
+
+            ### Example Instructions
+
+            *   `Trim the video to keep only the segment from 10 seconds to 25 seconds.`
+            *   `Concatenate video1.mp4 and video2.mp4 into a single video.`
+            *   `Add a text overlay "My Vacation 2024" at the bottom center with a white font.`
+            *   `Convert the input video to black and white.`
+            *   `Create a slideshow from image1.png and image2.png, each shown for 5 seconds, with background_music.mp3.`
+            *   `Resize the video to 1280x720 pixels.`
+            *   `Speed up the video by 2x.`
+            *   `Extract the audio track from the video as an mp3 file.` (Note: Current setup forces mp4 output, adjust system prompt if other outputs needed)
+            *   `Create a picture-in-picture effect with small_video.mp4 overlaid on the top right corner of main_video.mp4.`
+            *   `Generate a waveform visualization for the audio file.`
+
+            ### Tips for Better Results
+
+            *   **Be Specific**: Instead of "make it shorter," say "remove the first 5 seconds."
+            *   **Use Filenames**: Refer to files by their names (e.g., `Combine intro.mp4 and main.mp4`). The AI uses names with spaces replaced by underscores.
+            *   **Specify Details**: For text, mention font size, color, position (e.g., `top_left`, `center`, `bottom_right`). For effects, specify parameters (e.g., `fade duration of 1 second`).
+            *   **Keep it Simple**: Aim for one primary goal per instruction. Complex multi-step edits might require breaking down the task or might exceed the AI's ability to generate a single, simple command.
+            """
+        )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            user_files = gr.File(
+                file_count="multiple",
+                label="Upload Media Files",
+                file_types=allowed_medias,
+                # Consider adding interactive=True if needed, default is True
+            )
+            user_prompt = gr.Textbox(
+                placeholder="e.g., 'Combine video1.mp4 and video2.mp4'",
+                label="Instructions / Editing Objective",
+                lines=3,
+            )
+            with gr.Accordion("Advanced Parameters", open=False):
+                model_choice = gr.Radio(
+                    choices=list(MODELS.keys()),
+                    value=initial_model_choice, # Use the determined initial model
+                    label="Select AI Model",
+                )
+                top_p = gr.Slider(
+                    minimum=0.0, maximum=1.0, value=0.7, step=0.05,
+                    label="Top-p (Controls diversity)",
+                )
+                temperature = gr.Slider(
+                    minimum=0.0, maximum=2.0, value=0.1, step=0.1, # Max temp usually 1.0 or 2.0
+                    label="Temperature (Controls randomness)",
+                )
+            btn = gr.Button("🚀 Run Edit", variant="primary")
+
+        with gr.Column(scale=1):
+            generated_video = gr.Video(
+                label="Generated Video Output",
+                interactive=False, # User cannot change the video here
+                include_audio=True,
+            )
+            generated_command = gr.Markdown(label="Generated FFMPEG Command")
+
+    # Link button click to the update function
+    btn.click(
+        fn=update,
+        inputs=[user_files, user_prompt, top_p, temperature, model_choice],
+        outputs=[generated_video, generated_command],
+        api_name="generate_edit" # Optional: Define API endpoint name
+    )
+
+    # Examples Section
+    gr.Examples(
+        examples=[
+            [
+                ["./examples/Jiangnan_Rain.mp4"], # Make sure this path exists or adjust
+                "Add a text watermark 'Sample Video' to the upper right corner of the video with white text and semi-transparent background.",
+                0.7, 0.1, list(MODELS.keys())[0],
+            ],
+            [
+                ["./examples/Jiangnan_Rain.mp4"],
+                "Cut the video to extract only the middle 30 seconds (starting at 00:30 and ending at 01:00).",
+                0.7, 0.1, list(MODELS.keys())[min(1, len(MODELS)-1)], # Use second model if available
+            ],
+            [
+                ["./examples/Lotus_Pond01.mp4"], # Make sure this path exists or adjust
+                "Convert the video to black and white (grayscale) while maintaining the original audio.",
+                0.7, 0.1, list(MODELS.keys())[0],
+            ],
+            [
+                ["./examples/Lotus_Pond01.mp4"],
+                "Create a slow-motion version of the video by reducing the speed to 0.5x.",
+                0.7, 0.1, list(MODELS.keys())[min(1, len(MODELS)-1)],
+            ],
+             [
+                ["./examples/image1.jpg", "./examples/image2.png", "./examples/background.mp3"], # Example with images and audio
+                "Create a video slideshow from image1.jpg and image2.png, showing each image for 4 seconds. Use background.mp3 as the audio track.",
+                0.7, 0.1, list(MODELS.keys())[0],
+            ],
+        ],
+        inputs=[user_files, user_prompt, top_p, temperature, model_choice],
+        outputs=[generated_video, generated_command],
+        fn=update,
+        cache_examples=False, # Set to True if example files are stable and processing is slow
+        label="Example Use Cases (Click to Run)",
+        run_on_click=True,
+    )
+
+    # Removed the footer markdown about pull requests
+
+# --- Launch the App ---
+# Consider adding concurrency limits based on your hosting capabilities
+demo.queue(default_concurrency_limit=50)
+# demo.launch(show_api=False, server_name="0.0.0.0") # Allow external access if needed
+demo.launch(show_api=False,enable_analytics=False) # Default launch for local/Hugging Face Spaces