Upload folder using huggingface_hub

app.py

@@ -380,58 +380,22 @@ def start_precache(fps: int = DEFAULT_FPS, workers: int = 4) -> None:
 
 # ── Gallery helpers ────────────────────────────────────────────────────────────
 
-# In-memory thumbnail cache keyed by (seq, overlay, alpha_bucket)
-_thumb_cache: dict[tuple, Image.Image] = {}
-
-
 def _make_thumb(seq: str, overlay: bool = False, alpha: float = 0.0) -> Image.Image:
-    """Return a fresh copy of the (cached) base thumbnail."""
-    key = (seq, overlay, round(alpha, 2))
-    if key not in _thumb_cache:
-        fps = _get_frame_paths(seq)
-        if not fps:
-            img = Image.new("RGB", (THUMB_W, THUMB_H), 30)
-        else:
-            img = (render_frame(seq, 0, overlay, alpha)
-                   if overlay else Image.open(fps[0]).convert("RGB"))
-            img.thumbnail((THUMB_W, THUMB_H), Image.LANCZOS)
-        _thumb_cache[key] = img
-    return _thumb_cache[key].copy()
-
-
-def _apply_selection_glow(img: Image.Image) -> Image.Image:
-    """Draw a multi-layer golden glow border indicating a selected thumbnail."""
-    from PIL import ImageDraw
-    draw = ImageDraw.Draw(img)
-    w, h = img.size
-    # 5-pixel layered glow: bright gold → orange → dark, outermost first
-    glow = [(255, 230, 0), (255, 195, 0), (240, 150, 0), (200, 100, 0), (140, 60, 0)]
-    for i, color in enumerate(glow):
-        draw.rectangle([i, i, w - 1 - i, h - 1 - i], outline=color)
+    fps = _get_frame_paths(seq)
+    if not fps:
+        return Image.new("RGB", (THUMB_W, THUMB_H), 30)
+    img = render_frame(seq, 0, overlay, alpha) if overlay else Image.open(fps[0]).convert("RGB")
+    img = img.copy()
+    img.thumbnail((THUMB_W, THUMB_H), Image.LANCZOS)
     return img
 
 
-def build_gallery_items(
-    seqs: list[str],
-    overlay: bool = False,
-    selected: set[str] | None = None,
-    max_reached: bool = False,
-) -> list[tuple]:
-    selected = selected or set()
+def build_gallery_items(seqs: list[str], overlay: bool = False) -> list[tuple]:
     items = []
     for seq in seqs:
         row = DF[DF["sequence"] == seq].iloc[0]
-        img = _make_thumb(seq, overlay)
-        if seq in selected:
-            img = _apply_selection_glow(img)
-            caption = f"✅ {seq}  [{row['frames']}f · {row['n_objects']}obj]"
-        elif max_reached:
-            # Dim thumbnails that can't be added
-            img = img.point(lambda p: int(p * 0.45))
-            caption = f"{seq}  [{row['frames']}f · {row['n_objects']}obj]"
-        else:
-            caption = f"{seq}  [{row['frames']}f · {row['n_objects']}obj]"
-        items.append((img, caption))
+        caption = f"{seq}  [{row['frames']}f · {row['n_objects']}obj]"
+        items.append((_make_thumb(seq, overlay), caption))
     return items
 
 
@@ -754,24 +718,19 @@ def build_ui():
                 g_f_inputs = [g_year, g_split, g_obj, g_fmin, g_fmax, g_srch]
 
                 def _on_g_filter(*args):
-                    # args: *filter_fields, ov_thumb, sel_seqs
-                    sel_seqs = list(args[-1])
-                    ov       = args[-2]
-                    fargs    = args[:-2]
-                    fdf      = filter_df(*fargs)
-                    seqs     = fdf["sequence"].tolist()
-                    sel_set  = set(sel_seqs)
-                    items    = build_gallery_items(
-                        seqs, overlay=ov,
-                        selected=sel_set, max_reached=(len(sel_seqs) == 4))
+                    ov    = args[-1]
+                    fargs = args[:-1]
+                    fdf   = filter_df(*fargs)
+                    seqs  = fdf["sequence"].tolist()
+                    items = build_gallery_items(seqs, overlay=ov)
                     return (items, seqs,
-                            f"**{len(seqs)} sequences** — toggle to select (max 4)")
+                            f"**{len(seqs)} sequences** — click thumbnails to toggle (max 4)")
 
                 for inp in g_f_inputs + [g_ov_th]:
-                    inp.change(_on_g_filter, g_f_inputs + [g_ov_th, g_selected_state],
+                    inp.change(_on_g_filter, g_f_inputs + [g_ov_th],
                                [gallery, g_seq_state, g_count_md])
 
-                # ── Shared helpers ─────────────────────────────────────────
+                # ── Toggle helpers ─────────────────────────────────────────
                 def _build_video_updates(sel_seqs, ov, a, fps):
                     """Return 4 gr.update() objects for video slots 0-3."""
                     updates = []
@@ -788,84 +747,60 @@ def build_ui():
                             updates.append(gr.update(visible=False, value=None))
                     return updates
 
-                def _rebuild_gallery(sel_seqs, g_seqs, ov_th):
-                    sel_set = set(sel_seqs)
-                    return build_gallery_items(
-                        g_seqs, overlay=ov_th,
-                        selected=sel_set, max_reached=(len(sel_seqs) == 4))
-
-                # ── Gallery click → toggle selection ──────────────────────
-                def _on_gallery_toggle(evt: gr.SelectData,
-                                       sel_seqs, g_seqs, ov, a, fps, ov_th):
+                # ── Gallery click → two-step: fast toggle, then load videos ──
+                # Step 1: update selection state + indicators only (no I/O, <1 ms).
+                # This commits the new state before any video encoding starts,
+                # preventing the "previous-click lag" caused by slow get_video.
+                def _toggle_sel(evt: gr.SelectData, sel_seqs, g_seqs):
                     if evt is None or not g_seqs:
-                        empty_gallery = _rebuild_gallery(sel_seqs, g_seqs, ov_th)
-                        return (sel_seqs, empty_gallery,
-                                gr.update(visible=True), gr.update(visible=False),
-                                gr.update(visible=False, value=None),
-                                gr.update(visible=False, value=None),
-                                gr.update(visible=False, value=None),
-                                gr.update(visible=False, value=None),
+                        return (sel_seqs,
+                                gr.update(visible=True),
+                                gr.update(visible=False, value=""),
                                 gr.update(visible=False))
-
                     seq = g_seqs[evt.index]
-                    max_before = len(sel_seqs) == 4
                     if seq in sel_seqs:
                         sel_seqs = [s for s in sel_seqs if s != seq]
-                    elif not max_before:
+                    elif len(sel_seqs) < 4:
                         sel_seqs = sel_seqs + [seq]
-                    # else: already at 4, ignore — glow state unchanged
+                    # else: already 4 selected — silently ignore
 
                     n = len(sel_seqs)
-                    new_gallery = _rebuild_gallery(sel_seqs, g_seqs, ov_th)
-                    vid_updates = _build_video_updates(sel_seqs, ov, a, fps)
-
-                    if n == 0:
-                        info_txt = ""
-                    elif n == 4:
-                        info_txt = ("▶ " + "  ·  ".join(f"**{s}**" for s in sel_seqs) +
-                                    "  — **max 4 reached**, deselect to swap")
-                    else:
-                        info_txt = ("▶ " + "  ·  ".join(f"**{s}**" for s in sel_seqs) +
-                                    "  *(click a glowing thumbnail to deselect)*")
-
+                    info_txt = ("▶ " +
+                                "  ·  ".join(f"**{s}**" for s in sel_seqs) +
+                                "  *(click a thumbnail to deselect)*") if n > 0 else ""
                     return (
                         sel_seqs,
-                        new_gallery,
                         gr.update(visible=(n == 0)),
                         gr.update(visible=(n > 0), value=info_txt),
-                        vid_updates[0],
-                        vid_updates[1],
-                        vid_updates[2],
-                        vid_updates[3],
                         gr.update(visible=(n > 0)),
                     )
 
+                # Step 2: encode / fetch videos for the now-committed selection.
+                def _load_selected(sel_seqs, ov, a, fps):
+                    return _build_video_updates(sel_seqs, ov, a, fps)
+
                 gallery.select(
-                    _on_gallery_toggle,
-                    inputs=[g_selected_state, g_seq_state,
-                            g_vid_ov, g_vid_a, g_fps, g_ov_th],
-                    outputs=[g_selected_state, gallery,
-                             g_placeholder, g_sel_info,
-                             g_vid_0, g_vid_1, g_vid_2, g_vid_3, g_clr_btn],
+                    _toggle_sel,
+                    inputs=[g_selected_state, g_seq_state],
+                    outputs=[g_selected_state, g_placeholder, g_sel_info, g_clr_btn],
+                ).then(
+                    _load_selected,
+                    inputs=[g_selected_state, g_vid_ov, g_vid_a, g_fps],
+                    outputs=[g_vid_0, g_vid_1, g_vid_2, g_vid_3],
                 )
 
                 # Re-encode when overlay / FPS settings change
-                def _reload_settings(sel_seqs, ov, a, fps):
-                    return _build_video_updates(sel_seqs, ov, a, fps)
-
                 for _inp in [g_vid_ov, g_vid_a, g_fps]:
                     _inp.change(
-                        _reload_settings,
+                        _load_selected,
                         inputs=[g_selected_state, g_vid_ov, g_vid_a, g_fps],
                         outputs=[g_vid_0, g_vid_1, g_vid_2, g_vid_3],
                     )
 
                 # Clear selection button
-                def _clear_selection(g_seqs, ov_th):
-                    fresh_gallery = build_gallery_items(g_seqs, overlay=ov_th)
+                def _clear_selection():
                     return (
                         [],
-                        fresh_gallery,
                         gr.update(visible=True),
                         gr.update(visible=False, value=""),
                         gr.update(visible=False, value=None),
@@ -877,9 +812,7 @@ def build_ui():
 
                 g_clr_btn.click(
                     _clear_selection,
-                    inputs=[g_seq_state, g_ov_th],
-                    outputs=[g_selected_state, gallery,
-                             g_placeholder, g_sel_info,
+                    outputs=[g_selected_state, g_placeholder, g_sel_info,
                              g_vid_0, g_vid_1, g_vid_2, g_vid_3, g_clr_btn],
                 )