feat: h3-{task_id}.mp4 + community dropdown fixes

- Output video basename is h3-<task_id>.mp4 (Gradio download shows task id)
- Rewrite _community_lora_choices: no nested loops; skip cache only on exact basename
- Community dropdown interactive=True; use .change (not broken .select+SelectData)
- Page load/focus return full interactive Dropdown

Addresses PR review: select handler, repo-prefix cache filter, rebase on main.

lora/registry.py

@@ -126,38 +126,63 @@ def _community_lora_choices():
     Sources: the JSON registry **plus** any ``.safetensors`` files already cached
     in ``/data/loras/`` that aren't in the registry yet.  Cached files get a
     ``cache:`` prefixed value so the download/load path can load them directly
-    without going through the URL → download flow."""
+    without going through the URL → download flow.
+
+    Cache skip logic matches ``_lora_cache_path`` naming
+    ``{repo}__rev_{revision}__{file}`` so multiple files from the same repo stay visible.
+    """
+    from state import _LORA_CACHE_DIR
+
     registry = _load_community_registry()
-    known_urls = {e.get("url", "") for e in registry}
-    known_keys = {(e.get("repo", ""), e.get("file", "")) for e in registry}
     choices = []
+
+    # Exact basenames we already cover via registry entries (with/without revision).
+    registered_basenames: set[str] = set()
     for entry in registry:
-        repo = entry.get("repo", "")
-        desc = entry.get("description", "")
-        tags = entry.get("tags", [])
-        name = repo.split("/")[-1]
-        from state import _LORA_CACHE_DIR
-        try:
-            cache_files = sorted(
-                f for f in os.listdir(_LORA_CACHE_DIR)
-                if f.endswith(".safetensors") and not f.startswith(".")
-            )
-        except OSError:
-            cache_files = []
-        for f in cache_files:
-            if f not in known_urls and not any(f.startswith(f"{r.replace('/', '__')}__{fi.split('/')[-1]}") for r, fi in known_keys):
-                choices.append((f"{f} (cached)", f"cache:{os.path.join(_LORA_CACHE_DIR, f)}"))
-        for entry in registry:
-            repo = entry.get("repo", "")
-            desc = entry.get("description", "")
-            tags = entry.get("tags", [])
-            name = repo.split("/")[-1]
+        repo = str(entry.get("repo") or "")
+        file = str(entry.get("file") or "")
+        rev = str(entry.get("revision") or "").strip()
+        if not repo or not file:
+            continue
+        safe_repo = repo.replace("/", "__")
+        safe_file = file.replace("/", "__")
+        if rev:
+            registered_basenames.add(f"{safe_repo}__rev_{rev}__{safe_file}")
+        # Also mark revision-agnostic forms used by older cache keys.
+        registered_basenames.add(f"{safe_repo}__{safe_file}")
+        registered_basenames.add(safe_file)
+
+        desc = str(entry.get("description") or "")
+        tags = entry.get("tags") or []
+        name = repo.split("/")[-1] or repo or "LoRA"
         label = f"{name}"
         if desc:
             label += f" — {desc[:60]}{'…' if len(desc) > 60 else ''}"
         elif tags:
-            label += f" ({', '.join(tags[:3])})"
-        choices.append((label, entry.get("url", "")))
+            label += f" ({', '.join(str(t) for t in tags[:3])})"
+        url = entry.get("url") or f"https://huggingface.co/{repo}/resolve/main/{file}"
+        choices.append((label, url))
+
+    try:
+        cache_files = sorted(
+            f for f in os.listdir(_LORA_CACHE_DIR)
+            if f.endswith(".safetensors") and not f.startswith(".")
+        )
+    except OSError:
+        cache_files = []
+
+    for f in cache_files:
+        # Skip only when this exact cache basename is already represented.
+        if f in registered_basenames:
+            continue
+        # Strip optional __rev_<sha>__ middle for a softer match on repo+file only
+        # when the registry entry omitted revision.
+        stem = f
+        if "__rev_" in f:
+            # {repo}__rev_{rev}__{file} → compare full key only (already handled above)
+            pass
+        choices.append((f"{f} (cached)", f"cache:{os.path.join(_LORA_CACHE_DIR, f)}"))
+
     return choices
 
 
@@ -182,15 +207,15 @@ def _download_custom_lora(url, scale=1.0, trigger="", description="", tags="", a
                 active_val.append(enc)
         return (
             gr.update(value=msg, visible=True),
-            gr.update(choices=choices_c or None, value=community_value),
-            gr.update(choices=choices_a or None, value=active_val),
+            gr.update(choices=choices_c or [], interactive=True, value=community_value),
+            gr.update(choices=choices_a or [], interactive=True, value=active_val),
         )
 
     def _err(msg):
         return (
             gr.update(value=msg, visible=True),
-            gr.update(),
-            gr.update(choices=_active_custom_choices() or None),
+            gr.update(interactive=True),
+            gr.update(choices=_active_custom_choices() or [], interactive=True),
         )
 
     if not url:
@@ -318,13 +343,18 @@ def _submit_community_lora(url, scale, trigger, description, tags):
     return gr.update(choices=choices, value=full_url), "✅ Added to community registry."
 
 
-def _load_selected_community_lora(evt: gr.SelectData):
-    """When a community LoRA is selected from the dropdown, return its URL / scale / trigger.
+def _load_selected_community_lora(evt):
+    """When a community LoRA is selected, return URL / scale / trigger.
 
-    For cached LoRAs (value starts with ``cache:``) the URL field is set to the
-    cache path so the Download & Apply button can detect it."""
+    Bound via ``.change(dropdown)`` so the value is passed explicitly (Gradio does
+    not inject SelectData without a type hint + inputs=None). Accepts a plain
+    value or ``gr.SelectData``.
+    """
     registry = _load_community_registry()
-    url = evt.value
+    if evt is None:
+        return "", 1.0, ""
+    url = evt.value if hasattr(evt, "value") else evt
+    url = "" if url is None else str(url)
     # Cached LoRAs use cache:path — pass through so _download_custom_lora picks them up.
     if url.startswith("cache:"):
         return url, 1.0, ""

pipeline.py

@@ -436,8 +436,12 @@ def _generate_impl(prompt, image_path=None, last_image_path=None, canvas=DEFAULT
     _task_log(_task, f"_generate_impl: condition={condition_seconds:.0f}s, total={(time.time() - conditioned):.0f}s")
     progress(0.95, desc="Muxing the soundtrack ...")
 
-    # Write the video to a task-scoped output path so the file is unique per request.
-    output_path = os.path.join(_task.work_dir, "output.mp4") if _task is not None else os.path.join(tempfile.gettempdir(), f"h3-output-{int(time.time())}.mp4")
+    # Task-scoped dir + task-id filename so Gradio download shows h3-<task_id>.mp4
+    # (not a generic "output.mp4" basename).
+    if _task is not None:
+        output_path = os.path.join(_task.work_dir, f"h3-{_task.task_id}.mp4")
+    else:
+        output_path = os.path.join(tempfile.gettempdir(), f"h3-output-{int(time.time())}.mp4")
     # encode_video expects a (T,H,W,C) array/list of frames — not frames[None]
     # (that only works on numpy and was crashing when videos came back as a list).
     if hasattr(frames, "detach"):

tests/test_task_isolation.py

@@ -59,9 +59,9 @@ def test_task_filesystem_isolation(tmp_path, monkeypatch):
     assert os.path.isdir(a.work_dir)
     assert os.path.isdir(os.path.join(a.work_dir, "intermediates"))
     # no collision
-    open(os.path.join(a.work_dir, "output.mp4"), "w").write("a")
-    open(os.path.join(b.work_dir, "output.mp4"), "w").write("b")
-    assert open(os.path.join(a.work_dir, "output.mp4")).read() == "a"
+    open(os.path.join(a.work_dir, f"h3-{a.task_id}.mp4"), "w").write("a")
+    open(os.path.join(b.work_dir, f"h3-{b.task_id}.mp4"), "w").write("b")
+    assert open(os.path.join(a.work_dir, f"h3-{a.task_id}.mp4")).read() == "a"
 
 
 def test_model_mutation_lock_is_reentrant():

ui.py

@@ -366,6 +366,7 @@ def build_ui():
                         multiselect=False,
                         filterable=True,
                         allow_custom_value=True,
+                        interactive=True,
                         info="Pick one to auto-fill the link, then Download & Verify (or it loads into Active above).",
                     )
                     custom_lora_url = gr.Textbox(
@@ -429,9 +430,11 @@ def build_ui():
             [custom_lora_status, community_lora_dropdown, active_custom_loras],
         )
 
-        community_lora_dropdown.select(
+        # Use .change with the dropdown as an input — Gradio injects SelectData only when
+        # the handler is type-hinted and inputs=None; that path was broken. .change is enough.
+        community_lora_dropdown.change(
             _load_selected_community_lora,
-            None,
+            [community_lora_dropdown],
             [custom_lora_url, custom_lora_scale, custom_lora_trigger],
         )
 
@@ -475,7 +478,15 @@ def build_ui():
         # ── Refresh community dropdown / status after page connect ──────────────
         def _refresh_community_dd():
             choices = _community_lora_choices() or []
-            return gr.update(choices=choices)
+            return gr.Dropdown(
+                choices=choices,
+                value=None,
+                interactive=True,
+                multiselect=False,
+                filterable=True,
+                allow_custom_value=True,
+            )
+
         def _on_page_load():
             choices = _community_lora_choices() or []
             try:
@@ -483,11 +494,17 @@ def build_ui():
                 banner = f"**{_st()}**"
             except Exception as _e:
                 banner = f"Status unavailable: {_e}"
-            return gr.update(choices=choices), banner
+            dd = gr.Dropdown(
+                choices=choices,
+                value=None,
+                interactive=True,
+                multiselect=False,
+                filterable=True,
+                allow_custom_value=True,
+            )
+            return dd, banner
 
         demo.load(_on_page_load, None, [community_lora_dropdown, status_banner], api_name=False)
-        # Also refresh when the user opens (focuses) the dropdown — covers cases
-        # where demo.load() fires before the bucket is fully listed.
         community_lora_dropdown.focus(
             _refresh_community_dd, None, community_lora_dropdown, api_name=False,
         )