Initial Edit Anything LTX-2.3 Space

GOAL.md

@@ -0,0 +1,123 @@
+# Goal: Build a HuggingFace Space for "Edit Anything" — LTX-2.3 Video Editing LoRAs
+
+## Context
+
+The model repo is at https://huggingface.co/Alissonerdx/EditAnything — it hosts experimental LTX-2.3 (22B) video editing LoRAs by Alissonerdx. There are THREE training tracks:
+
+### 1. Edit Anything v0.1 (motion transfer) — Standard LoRA
+- `edit_anything_30k_v0.1_motion_transfer_r128.safetensors` (1.31 GB, rank 128)
+- `edit_anything_30k_v0.1_motion_transfer_r256.safetensors` (2.62 GB, rank 256)
+- Two-stage training: image-only pretraining (~30k pairs) then video fine-tune with first_frame_conditioning > 0
+- Motion transfer: replace first frame with edited still, model copies motion from guide video
+- Load through regular ComfyUI LoraLoader before LoopingSampler
+- On sampler: editanything_module disconnected, ref_image = edited first frame, guide_frames = guide video, all enable_* flags OFF
+
+### 2. Edit Anything v1.1 (no-reference multitask) — Standard LoRA
+- `edit_anything_v1.1_r256.safetensors` (rank 256)
+- Prompt-only multitask editing: Add, Remove, Replace, Style
+- No reference image, no first-frame conditioning
+- Standalone — load as regular LoRA on vanilla LTX-2.3
+- Prompt patterns:
+  - Add: 15-30+ words, "Add <detailed subject>, <position>, <context>"
+  - Remove: 4-10 words, "Remove the <object>"
+  - Replace: 20-35 words, "Replace <original+location> with <new subject>"
+  - Style: "Convert the video into a <STYLE> style" (300+ styles in training)
+- NO compositional prompts (no "Add X and remove Y")
+- NO "change background" as a standalone task
+- NO global color grade / lighting change (only Style template)
+
+### 3. Reference V2V — Experimental IC-LoRA + sidecar modules (TWO builds)
+- Build 1 (2-extras): `edit_anything_reference_v0.1_r128_ref_adaln_proj-role_embedding.{standard,module}.safetensors`
+- Build 2 (4-extras): `...-ref_attn-ref_visual_proj.{standard,module}.safetensors`
+- *.standard.safetensors = LoRA on attn1/attn2/ff → standard ComfyUI LoRA loader
+- *.module.safetensors = role_embedding, ref_adaln_proj, ref_visual_proj, ref_attn → needs LTXVEditAnythingModuleLoader (BFSnodes custom nodes)
+- Both files of a pair must be loaded together
+- Ref V2V uses reference image for identity transfer (Add/Replace)
+- Trained on ~1600 Add/Replace video pairs (very small, often fails)
+- enable_adaln: on, enable_visual_crossattn: on for 4-extras build, enable_role_embedding: off for 4-extras
+
+## CRITICAL: Research Existing LTX-2.3 LoRA Spaces
+
+Before writing any code, you MUST research the existing official LTX-2.3 LoRA spaces in the ltx-community org on HuggingFace. These are the reference implementations for how to run LTX-2.3 LoRAs on ZeroGPU HuggingFace Spaces.
+
+### Spaces to study (fetch their app.py source code):
+
+1. **LTX-2.3 Video Inpainting** — https://huggingface.co/spaces/ltx-community/ltx-2.3-inpaint
+   - Raw app.py: https://huggingface.co/spaces/ltx-community/ltx-2.3-inpaint/raw/main/app.py
+   - Uses `diffusers.LTX2InContextPipeline` with `LTX2ReferenceCondition` and `conditioning_attention_mask`
+   - IC-LoRA from `Lightricks/LTX-2.3-22b-IC-LoRA-In-Outpainting`
+   - Two-stage inference: Stage 1 (IC-LoRA + attention mask) → Stage 2a (spatial x2 latent upsample) → Stage 2b (refine on bare distilled model)
+   - Uses SAM3 for video mask generation
+
+2. **LTX-2.3 Video Outpaint** — https://huggingface.co/spaces/ltx-community/ltx-2.3-outpaint
+   - Raw app.py: https://huggingface.co/spaces/ltx-community/ltx-2.3-outpaint/raw/main/app.py
+   - Same diffusers pipeline as inpaint but with margin masking for outpainting
+
+3. **LTX-2.3 Day to Night** — https://huggingface.co/spaces/ltx-community/ltx-2.3-day-to-night
+   - Raw app.py: https://huggingface.co/spaces/ltx-community/ltx-2.3-day-to-night/raw/main/app.py
+   - Uses NATIVE LTX-2 codebase (`ltx_core` + `ltx_pipelines`) cloned from github.com/Lightricks/LTX-2
+   - Uses `ICLoraPipeline` from `ltx_pipelines.ic_lora`
+   - Has ZeroGPU patches for safetensors loader and attention backend
+   - Uses AOTI compiled transformer for acceleration
+
+4. **LTX-2.3 LoRA Trainer** — https://huggingface.co/spaces/ltx-community/ltx2-lora-trainer
+
+### Official Lightricks IC-LoRAs (for reference on how IC-LoRAs work with diffusers):
+- `Lightricks/LTX-2.3-22b-IC-LoRA-In-Outpainting` — used by inpaint/outpaint spaces
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Day-To-Night` — used by day-to-night space
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Colorization`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Deblur`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Decompression`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Water-Simulation`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Ingredients`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-HDR`
+- `Lightricks/LTX-2.3-22b-IC-LoRA-Motion-Track-Control`
+
+### Base model:
+- diffusers: `diffusers/LTX-2.3-Distilled-Diffusers`
+- native: `Lightricks/LTX-2.3`
+
+## Key Technical Decisions
+
+The EditAnything LoRAs are NOT IC-LoRAs (except the Ref V2V build). They are standard LoRAs that load through `pipe.load_lora_weights()`. The v0.1 and v1.1 LoRAs should work with the diffusers `LTX2InContextPipeline`:
+
+```python
+from diffusers import LTX2InContextPipeline
+pipe = LTX2InContextPipeline.from_pretrained("diffusers/LTX-2.3-Distilled-Diffusers", torch_dtype=torch.bfloat16)
+pipe.load_lora_weights("Alissonerdx/EditAnything", weight_name="edit_anything_v1.1_r256.safetensors")
+```
+
+For the v0.1 motion transfer, you need first_frame_conditioning — look at how the existing spaces handle reference conditions (`LTX2ReferenceCondition` with frames).
+
+For Ref V2V, the sidecar modules are NOT standard LoRA adapters — they need custom loading. This is the hardest part. You may need to study the BFSnodes ComfyUI code to understand how the modules are loaded, then adapt that logic for a diffusers-based Space. Consider whether the Ref V2V track is feasible in a diffusers-only Space, and if not, focus on v0.1 + v1.1 first.
+
+## What to Build
+
+A HuggingFace Space (Gradio app) that provides a UI for the EditAnything LoRAs. The Space should:
+
+1. Let users upload a video and choose an edit mode:
+   - **Motion Transfer** (v0.1): upload guide video + edited first frame → model copies motion
+   - **Prompt Edit** (v1.1): upload video + choose edit type (Add/Remove/Replace/Style) + prompt → model edits
+   - **Ref V2V** (if feasible): upload video + reference image + prompt → model adds/replaces using reference
+
+2. Load the appropriate LoRA based on the selected mode
+
+3. Use the diffusers `LTX2InContextPipeline` with two-stage inference (matching the inpaint/outpaint spaces)
+
+4. Run on ZeroGPU with proper `@spaces.GPU(duration=...)` decorators
+
+5. Follow all HF Spaces best practices (README.md with SDK: gradio, proper requirements.txt, etc.)
+
+## Implementation Notes
+
+- Use `diffusers/LTX-2.3-Distilled-Diffusers` as the base model
+- Use `LTX2InContextPipeline` and `LTX2LatentUpsamplePipeline` from diffusers
+- Use `DISTILLED_SIGMA_VALUES` and `STAGE_2_DISTILLED_SIGMA_VALUES` from `diffusers.pipelines.ltx2.utils`
+- Download LoRA weights from `Alissonerdx/EditAnything` repo via `hf_hub_download`
+- The v0.1 LoRA uses first_frame_conditioning (pass edited first frame as reference condition)
+- The v1.1 LoRA is standalone, no reference needed — just prompt + guide video
+- Handle both landscape and portrait videos
+- Include prompt templates/guidance for each edit type
+- Resolution presets: Fast (768×448), Quality (960×544)
+- Frame choices: 49, 73, 97, 121
+- FPS: 24

README.md

@@ -1,13 +1,29 @@
 ---
-title: Edit Anything Ltx23
-emoji: 🏆
-colorFrom: pink
-colorTo: gray
+title: Edit Anything LTX-2.3
+emoji: 🎬
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.12'
+sdk_version: 6.10.0
 app_file: app.py
-pinned: false
+short_description: Edit Anything LTX-2.3 video LoRAs
+startup_duration_timeout: 1h
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Edit Anything LTX-2.3
+
+Gradio Space for the experimental Edit Anything LTX-2.3 video editing LoRAs by
+Alisson Pereira dos Anjos.
+
+Implemented:
+
+- Motion Transfer v0.1 using `edit_anything_30k_v0.1_motion_transfer_r128.safetensors`
+- Prompt Edit v1.1 using `edit_anything_v1.1_r256.safetensors`
+- Two-stage LTX-2.3 diffusers inference, following the ltx-community inpaint/outpaint pattern
+
+Ref V2V is listed but disabled. Its `.module.safetensors` sidecars contain
+non-standard AdaLN, role embedding, visual projection, and reference-attention
+branches consumed by BFSnodes. Those branches are not standard diffusers LoRA
+adapters.
+
+Model source: https://huggingface.co/Alissonerdx/EditAnything

app.py

@@ -0,0 +1,435 @@
+import os
+
+os.environ.setdefault("HF_HOME", "/tmp/.cache/huggingface")
+os.environ.setdefault("HF_MODULES_CACHE", "/tmp/hf_modules")
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib")
+os.environ.setdefault("GRADIO_SSR_MODE", "false")
+os.environ.setdefault("TORCH_COMPILE_DISABLE", "1")
+os.environ.setdefault("TORCHDYNAMO_DISABLE", "1")
+
+for _path in (
+    os.environ["HF_HOME"],
+    os.environ["HF_MODULES_CACHE"],
+    os.environ["MPLCONFIGDIR"],
+):
+    os.makedirs(_path, exist_ok=True)
+
+import random
+import tempfile
+import time
+
+import gradio as gr
+import imageio.v3 as iio
+import numpy as np
+import spaces
+import torch
+from huggingface_hub import hf_hub_download
+from PIL import Image, ImageOps
+from safetensors.torch import load_file
+
+from diffusers import LTX2InContextPipeline, LTX2LatentUpsamplePipeline
+from diffusers.pipelines.ltx2.latent_upsampler import LTX2LatentUpsamplerModel
+from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
+from diffusers.pipelines.ltx2.pipeline_ltx2_ic_lora import LTX2ReferenceCondition
+from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
+from diffusers.utils import encode_video, load_video
+
+
+BASE_MODEL = "diffusers/LTX-2.3-Distilled-Diffusers"
+EDIT_REPO = "Alissonerdx/EditAnything"
+MOTION_LORA = "edit_anything_30k_v0.1_motion_transfer_r128.safetensors"
+PROMPT_LORA = "edit_anything_v1.1_r256.safetensors"
+UPSAMPLER_REPO = "dg845/LTX-2.3-Spatial-Upsampler-Diffusers"
+
+FPS = 24
+NUM_STEPS = len(DISTILLED_SIGMA_VALUES)
+MAX_SEED = np.iinfo(np.int32).max
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+MODE_MOTION = "Motion Transfer (v0.1)"
+MODE_PROMPT = "Prompt Edit (v1.1)"
+MODE_REF = "Ref V2V (experimental, not enabled)"
+
+ADAPTERS = {
+    MODE_MOTION: ("motion_v01_r128", MOTION_LORA),
+    MODE_PROMPT: ("prompt_v11_r256", PROMPT_LORA),
+}
+
+RES_PRESETS = {
+    "Fast (768x448)": (768, 448),
+    "Quality (960x544)": (960, 544),
+}
+FRAME_CHOICES = [49, 73, 97, 121]
+
+
+@spaces.GPU(duration=1)
+def _zerogpu_probe():
+    return "ready"
+
+
+print("Loading LTX-2.3 distilled diffusers pipeline...", flush=True)
+pipe = LTX2InContextPipeline.from_pretrained(BASE_MODEL, torch_dtype=torch.bfloat16)
+pipe.to("cuda")
+pipe.vae.enable_tiling()
+
+print("Loading Edit Anything standard LoRAs...", flush=True)
+for adapter_name, filename in ADAPTERS.values():
+    lora_path = hf_hub_download(EDIT_REPO, filename, token=HF_TOKEN)
+    pipe.load_lora_weights(load_file(lora_path), adapter_name=adapter_name)
+pipe.set_adapters(ADAPTERS[MODE_PROMPT][0], 1.0)
+
+print("Loading stage-2 spatial latent upsampler...", flush=True)
+_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
+    UPSAMPLER_REPO,
+    subfolder="latent_upsampler",
+    torch_dtype=torch.bfloat16,
+)
+_upsampler.to("cuda")
+upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=_upsampler)
+print("Pipeline ready.", flush=True)
+
+
+def _src_fps(path, default=FPS):
+    try:
+        return float(iio.immeta(path, plugin="pyav").get("fps", default)) or default
+    except Exception:
+        return default
+
+
+def _probe_video(path):
+    frames = load_video(path)
+    if not frames:
+        raise gr.Error("Could not read frames from the uploaded video.")
+    return frames
+
+
+def _pick_resolution(first_frame, preset):
+    width, height = RES_PRESETS[preset]
+    if first_frame.height > first_frame.width:
+        width, height = height, width
+    return width, height
+
+
+def _load_frames(path, num_frames, width, height):
+    frames = _probe_video(path)
+    source_fps = _src_fps(path)
+    out = []
+    for i in range(num_frames):
+        idx = min(int(round(i / FPS * source_fps)), len(frames) - 1)
+        frame = frames[idx].convert("RGB")
+        out.append(ImageOps.fit(frame, (width, height), Image.LANCZOS))
+    return out
+
+
+def _prepare_first_frame(image, width, height):
+    if image is None:
+        raise gr.Error("Motion Transfer needs an externally edited first frame.")
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(np.asarray(image))
+    return ImageOps.fit(image.convert("RGB"), (width, height), Image.LANCZOS)
+
+
+def _compose_prompt(mode, edit_type, prompt, style_name):
+    prompt = (prompt or "").strip()
+    style_name = (style_name or "").strip()
+
+    if mode == MODE_REF:
+        raise gr.Error(
+            "Ref V2V is not enabled in this diffusers Space. Its .module.safetensors "
+            "sidecar installs custom AdaLN, role embedding, and ref-attention branches "
+            "through BFSnodes; those branches are not standard diffusers LoRA adapters."
+        )
+
+    if mode == MODE_PROMPT and edit_type == "Style":
+        style = style_name or prompt
+        if not style:
+            raise gr.Error("Style mode needs a style name, for example 'Watercolor Painting'.")
+        if style.lower().startswith("convert the video into"):
+            return style
+        return f"Convert the video into a {style} style."
+
+    if not prompt:
+        raise gr.Error("Enter an edit prompt.")
+    return prompt
+
+
+def _duration(*args, **kwargs):
+    preset = next((a for a in args if isinstance(a, str) and a in RES_PRESETS), "Fast (768x448)")
+    num_frames = next((a for a in args if isinstance(a, int) and a in FRAME_CHOICES), 73)
+    per_frame = 1.75 if "Quality" in str(preset) else 1.35
+    return int(120 + int(num_frames) * per_frame)
+
+
+def _export(video_np, audio, path):
+    kwargs = {}
+    if audio is not None:
+        kwargs = {
+            "audio": audio[0].float().cpu(),
+            "audio_sample_rate": pipe.vocoder.config.output_sampling_rate,
+        }
+    encode_video(video_np, fps=FPS, output_path=path, **kwargs)
+
+
+def _set_adapter(mode, scale):
+    adapter_name = ADAPTERS[mode][0]
+    pipe.set_adapters(adapter_name, float(scale))
+    return adapter_name
+
+
+def _run_two_stage(
+    prompt,
+    reference_conditions,
+    conditions,
+    width,
+    height,
+    num_frames,
+    seed,
+    adapter_name,
+    lora_scale,
+    conditioning_attention_strength,
+):
+    pipe.set_adapters(adapter_name, float(lora_scale))
+    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    video_latent, audio_latent = pipe(
+        prompt=prompt,
+        negative_prompt="",
+        reference_conditions=reference_conditions,
+        conditions=conditions,
+        reference_downscale_factor=1,
+        conditioning_attention_strength=float(conditioning_attention_strength),
+        width=width,
+        height=height,
+        num_frames=num_frames,
+        frame_rate=FPS,
+        num_inference_steps=NUM_STEPS,
+        sigmas=DISTILLED_SIGMA_VALUES,
+        guidance_scale=1.0,
+        stg_scale=0.0,
+        audio_guidance_scale=1.0,
+        audio_stg_scale=0.0,
+        generator=generator,
+        output_type="latent",
+        return_dict=False,
+    )
+
+    up_latent = upsample_pipe(latents=video_latent, output_type="latent", return_dict=False)[0]
+
+    pipe.disable_lora()
+    try:
+        video_out, audio_out = pipe(
+            prompt=prompt,
+            negative_prompt="",
+            latents=up_latent,
+            audio_latents=audio_latent,
+            width=width * 2,
+            height=height * 2,
+            num_frames=num_frames,
+            frame_rate=FPS,
+            num_inference_steps=len(STAGE_2_DISTILLED_SIGMA_VALUES),
+            sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
+            noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
+            guidance_scale=1.0,
+            stg_scale=0.0,
+            audio_guidance_scale=1.0,
+            audio_stg_scale=0.0,
+            generator=generator,
+            output_type="np",
+            return_dict=False,
+        )
+    finally:
+        pipe.set_adapters(adapter_name, float(lora_scale))
+
+    return video_out, audio_out
+
+
+@spaces.GPU(duration=_duration, size="xlarge")
+@torch.inference_mode()
+def edit_anything(
+    mode,
+    video,
+    edited_first_frame,
+    edit_type,
+    prompt,
+    style_name,
+    preset,
+    num_frames,
+    seed,
+    randomize_seed,
+    lora_scale,
+    guide_strength,
+    source_attention,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if video is None:
+        raise gr.Error("Upload a source video.")
+    if mode not in ADAPTERS and mode != MODE_REF:
+        raise gr.Error("Choose a supported edit mode.")
+
+    final_prompt = _compose_prompt(mode, edit_type, prompt, style_name)
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    seed = int(seed)
+    num_frames = int(num_frames)
+
+    progress(0.03, desc="Preparing source frames")
+    first = _probe_video(video)[0].convert("RGB")
+    width, height = _pick_resolution(first, preset)
+    guide_frames = _load_frames(video, num_frames, width, height)
+
+    reference_conditions = [
+        LTX2ReferenceCondition(frames=guide_frames, strength=float(guide_strength))
+    ]
+    conditions = None
+    edited_anchor = None
+
+    if mode == MODE_MOTION:
+        edited_anchor = _prepare_first_frame(edited_first_frame, width, height)
+        conditions = [LTX2VideoCondition(frames=edited_anchor, index=0, strength=1.0)]
+
+    adapter_name = _set_adapter(mode, lora_scale)
+    started = time.perf_counter()
+
+    progress(0.12, desc="Running LTX-2.3 stage 1")
+    video_out, audio_out = _run_two_stage(
+        prompt=final_prompt,
+        reference_conditions=reference_conditions,
+        conditions=conditions,
+        width=width,
+        height=height,
+        num_frames=num_frames,
+        seed=seed,
+        adapter_name=adapter_name,
+        lora_scale=lora_scale,
+        conditioning_attention_strength=source_attention,
+    )
+
+    progress(0.92, desc="Encoding output video")
+    result = (np.clip(video_out[0], 0, 1) * 255).astype(np.uint8)
+    if edited_anchor is not None and len(result) > 0:
+        result[0] = np.array(edited_anchor.resize((width * 2, height * 2), Image.LANCZOS))
+
+    out_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+    _export(result, audio_out, out_path)
+
+    elapsed = time.perf_counter() - started
+    print(
+        f"[METRIC] mode={mode!r} frames={num_frames} preset={preset!r} "
+        f"seed={seed} elapsed_s={elapsed:.2f}",
+        flush=True,
+    )
+    details = (
+        f"Seed: {seed}\n"
+        f"Prompt: {final_prompt}\n"
+        f"Mode: {mode}\n"
+        f"Elapsed seconds: {elapsed:.2f}"
+    )
+    return out_path, seed, details
+
+
+def _mode_hint(mode):
+    if mode == MODE_MOTION:
+        return (
+            "Upload a guide video and an externally edited first frame. "
+            "The first frame anchors appearance; the video supplies motion."
+        )
+    if mode == MODE_PROMPT:
+        return (
+            "Upload a source video and use a single Add, Remove, Replace, or Style prompt. "
+            "Avoid multi-action prompts."
+        )
+    return (
+        "Ref V2V is shown for completeness but disabled in this diffusers build; "
+        "it requires BFSnodes sidecar module injection."
+    )
+
+
+def _edit_type_hint(edit_type):
+    if edit_type == "Add":
+        return "Pattern: Add <detailed subject>, <position>, <context>."
+    if edit_type == "Remove":
+        return "Pattern: Remove the <object>. Keep it short."
+    if edit_type == "Replace":
+        return "Pattern: Replace <original subject and location> with <new subject>."
+    return "Pattern: Convert the video into a <STYLE> style."
+
+
+with gr.Blocks(title="Edit Anything LTX-2.3") as demo:
+    gr.Markdown(
+        "# Edit Anything LTX-2.3\n"
+        "Experimental video editing with the Edit Anything standard LoRAs on LTX-2.3 Distilled."
+    )
+    mode_hint = gr.Markdown(_mode_hint(MODE_PROMPT))
+
+    with gr.Row():
+        with gr.Column():
+            mode = gr.Dropdown(
+                [MODE_PROMPT, MODE_MOTION, MODE_REF],
+                value=MODE_PROMPT,
+                label="Edit mode",
+            )
+            video_in = gr.Video(label="Source / guide video")
+            edited_frame = gr.Image(
+                label="Edited first frame for Motion Transfer",
+                type="pil",
+                image_mode="RGB",
+            )
+            edit_type = gr.Radio(
+                ["Add", "Remove", "Replace", "Style"],
+                value="Replace",
+                label="Prompt Edit task",
+            )
+            edit_hint = gr.Markdown(_edit_type_hint("Replace"))
+            prompt = gr.Textbox(
+                label="Edit prompt",
+                lines=4,
+                placeholder="Replace the bronze statue on the left with a tall man wearing a navy raincoat and brown boots.",
+            )
+            style_name = gr.Textbox(
+                label="Style name",
+                placeholder="Watercolor Painting",
+            )
+            with gr.Accordion("Settings", open=False):
+                preset = gr.Dropdown(list(RES_PRESETS), value="Fast (768x448)", label="Resolution")
+                num_frames = gr.Dropdown(FRAME_CHOICES, value=73, label="Frames at 24 fps")
+                randomize_seed = gr.Checkbox(True, label="Randomize seed")
+                seed = gr.Slider(0, MAX_SEED, value=42, step=1, label="Seed")
+                lora_scale = gr.Slider(0.2, 1.4, value=1.0, step=0.05, label="LoRA scale")
+                guide_strength = gr.Slider(0.2, 1.0, value=1.0, step=0.05, label="Guide video strength")
+                source_attention = gr.Slider(
+                    0.2,
+                    1.0,
+                    value=1.0,
+                    step=0.05,
+                    label="Source/reference attention",
+                )
+            run = gr.Button("Generate", variant="primary")
+        with gr.Column():
+            video_out = gr.Video(label="Edited result")
+            details = gr.Textbox(label="Run details", lines=6)
+
+    mode.change(_mode_hint, inputs=mode, outputs=mode_hint)
+    edit_type.change(_edit_type_hint, inputs=edit_type, outputs=edit_hint)
+    run.click(
+        edit_anything,
+        inputs=[
+            mode,
+            video_in,
+            edited_frame,
+            edit_type,
+            prompt,
+            style_name,
+            preset,
+            num_frames,
+            seed,
+            randomize_seed,
+            lora_scale,
+            guide_strength,
+            source_attention,
+        ],
+        outputs=[video_out, seed, details],
+        api_name="generate",
+    )
+
+if __name__ == "__main__":
+    demo.launch(show_error=True)

requirements.txt

@@ -0,0 +1,13 @@
+git+https://github.com/huggingface/diffusers@ea802951f5fb235b6af8fe9247f56187d49748b2
+gradio==6.10.0
+spaces==0.41.1
+transformers==4.57.6
+accelerate==1.12.0
+peft==0.18.1
+safetensors==0.7.0
+sentencepiece==0.2.1
+torchvision
+imageio[ffmpeg]==2.37.3
+imageio-ffmpeg==0.6.0
+av==16.0.1
+pillow==12.0.0