Upload folder using huggingface_hub

app.py

@@ -72,6 +72,16 @@ CACHE_DIR = Path(os.environ.get(
 ))
 CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
+def _cleanup_stale_tmp() -> None:
+    """Remove any leftover _tmp_* directories left by interrupted encode runs."""
+    stale = list(CACHE_DIR.glob("_tmp_*"))
+    if stale:
+        print(f"  Removing {len(stale)} stale tmp dir(s) from previous run…")
+        for d in stale:
+            shutil.rmtree(d, ignore_errors=True)
+
+_cleanup_stale_tmp()
+
 DAVIS_PALETTE = np.array([
     [  0,   0,   0], [128,   0,   0], [  0, 128,   0], [128, 128,   0],
     [  0,   0, 128], [128,   0, 128], [  0, 128, 128], [128, 128, 128],
@@ -395,13 +405,21 @@ def get_legend(seq: str) -> str:
     return "\n".join(lines)
 
 
+def _is_cache_complete() -> bool:
+    with _cache_lock:
+        return (len(_cache_progress) >= len(ALL_SEQUENCES)
+                and all(v == "done" for v in _cache_progress.values()))
+
+
 def cache_status_md() -> str:
     with _cache_lock:
-        done  = sum(1 for v in _cache_progress.values() if v == "done")
+        done   = sum(1 for v in _cache_progress.values() if v == "done")
+        errors = sum(1 for v in _cache_progress.values() if v.startswith("error"))
     total = len(ALL_SEQUENCES)
     pct   = done / total * 100 if total else 0
     bar   = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
-    return f"`[{bar}]` **{done}/{total}** cached ({pct:.0f}%)"
+    err   = f" · ⚠️ {errors} errors" if errors else ""
+    return f"`[{bar}]` **{done}/{total}** cached ({pct:.0f}%){err}"
 
 
 # ── Stats plots ────────────────────────────────────────────────────────────────
@@ -688,43 +706,58 @@ def build_ui():
             with gr.TabItem("📺 Multi-Video"):
                 gr.Markdown(
                     f"Watch **{PAGE_SIZE} sequences at once** in a 3×3 grid. "
-                    "Use Prev/Next to page through all {len(ALL_SEQUENCES)} sequences, "
-                    "or filter first. Videos are encoded once and cached permanently."
+                    f"Page through all {len(ALL_SEQUENCES)} sequences. "
+                    "Videos are served from the permanent MP4 cache."
                 )
-                with gr.Row():
-                    mv_year  = gr.Dropdown(["All years","2016 only","2017 only"],
-                                            value="All years", label="Year", scale=1)
-                    mv_split = gr.Dropdown(["All splits","Train only","Val only"],
-                                            value="All splits", label="Split", scale=1)
-                    mv_obj   = gr.Dropdown(["Any # objects","1 object","2 objects","3+ objects"],
-                                            value="Any # objects", label="Objects", scale=1)
-                    mv_srch  = gr.Textbox(placeholder="Search…", label="Search", scale=2)
-                with gr.Row():
-                    mv_fps  = gr.Slider(1, 30, DEFAULT_FPS, step=1, label="FPS", scale=2)
-                    mv_ov   = gr.Checkbox(value=True, label="Burn overlay", scale=1)
-                    mv_a    = gr.Slider(0.1, 1.0, DEFAULT_ALPHA, step=0.05,
-                                         label="Opacity", scale=2)
-                    mv_load = gr.Button("▶  Load Page", variant="primary", scale=1)
-
-                with gr.Row():
-                    mv_prev = gr.Button("◀  Prev", scale=1)
-                    with gr.Column(scale=3):
-                        mv_page_lbl = gr.Markdown(f"**Page 1 / {total_pages}**")
-                    mv_next = gr.Button("Next  ▶", scale=1)
 
-                mv_status = gr.Markdown("")
+                # ── Caching-in-progress overlay (hidden once done) ────────
+                _initially_done = _is_cache_complete()
+                with gr.Column(visible=not _initially_done) as mv_wait_col:
+                    gr.Markdown("### ⏳ Building MP4 cache — please wait…")
+                    mv_wait_status = gr.Markdown(cache_status_md())
+                    gr.Markdown(
+                        "All 90 sequences are being encoded as MP4s in the background "
+                        "(raw + overlay variant each). The grid will unlock automatically "
+                        "when encoding finishes. You can watch other tabs in the meantime."
+                    )
+                    mv_refresh_btn = gr.Button("↻  Refresh status", size="sm")
+
+                # ── Main grid (hidden until cache ready) ──────────────────
+                with gr.Column(visible=_initially_done) as mv_grid_col:
+                    with gr.Row():
+                        mv_year  = gr.Dropdown(["All years","2016 only","2017 only"],
+                                                value="All years", label="Year", scale=1)
+                        mv_split = gr.Dropdown(["All splits","Train only","Val only"],
+                                                value="All splits", label="Split", scale=1)
+                        mv_obj   = gr.Dropdown(["Any # objects","1 object","2 objects","3+ objects"],
+                                                value="Any # objects", label="Objects", scale=1)
+                        mv_srch  = gr.Textbox(placeholder="Search…", label="Search", scale=2)
+                    with gr.Row():
+                        mv_fps  = gr.Slider(1, 30, DEFAULT_FPS, step=1, label="FPS", scale=2)
+                        mv_ov   = gr.Checkbox(value=True, label="Burn overlay", scale=1)
+                        mv_a    = gr.Slider(0.1, 1.0, DEFAULT_ALPHA, step=0.05,
+                                             label="Opacity", scale=2)
+                        mv_load = gr.Button("▶  Load Page", variant="primary", scale=1)
 
-                # 9 fixed video slots, 3 rows × 3 cols
-                mv_vids  = []
-                mv_lbls  = []
-                for row_i in range(3):
                     with gr.Row():
-                        for col_i in range(3):
-                            with gr.Column():
-                                lbl = gr.Markdown("—")
-                                vid = gr.Video(height=260, autoplay=True, label="")
-                                mv_lbls.append(lbl)
-                                mv_vids.append(vid)
+                        mv_prev = gr.Button("◀  Prev", scale=1)
+                        with gr.Column(scale=3):
+                            mv_page_lbl = gr.Markdown(f"**Page 1 / {total_pages}**")
+                        mv_next = gr.Button("Next  ▶", scale=1)
+
+                    mv_status = gr.Markdown("")
+
+                    # 9 fixed video slots, 3 rows × 3 cols
+                    mv_vids  = []
+                    mv_lbls  = []
+                    for row_i in range(3):
+                        with gr.Row():
+                            for col_i in range(3):
+                                with gr.Column():
+                                    lbl = gr.Markdown("—")
+                                    vid = gr.Video(height=260, autoplay=True, label="")
+                                    mv_lbls.append(lbl)
+                                    mv_vids.append(vid)
 
                 # State: list of sequences currently matching filter, page index
                 mv_seq_state  = gr.State(ALL_SEQUENCES.copy())
@@ -757,36 +790,44 @@ def build_ui():
                                [mv_seq_state, mv_page_state, mv_page_lbl])
 
                 def _load_page(seqs, page, ov, a, fps):
-                    start = page * PAGE_SIZE
-                    chunk = seqs[start: start + PAGE_SIZE]
-                    tp    = max(1, (len(seqs) + PAGE_SIZE - 1) // PAGE_SIZE)
+                    # Block if pre-cache not yet finished
+                    if not _is_cache_complete():
+                        with _cache_lock:
+                            done = sum(1 for v in _cache_progress.values() if v == "done")
+                        total = len(ALL_SEQUENCES)
+                        pct   = int(done / total * 100) if total else 0
+                        bar   = "█" * (pct // 5) + "░" * (20 - pct // 5)
+                        status = (f"⏳ `[{bar}]` {done}/{total} sequences cached ({pct}%) — "
+                                  "please wait for caching to finish then click Load Page again.")
+                        out = []
+                        for _ in range(PAGE_SIZE):
+                            out.append("—")
+                            out.append(None)
+                        out.append(status)
+                        out.append(f"**Page {page + 1} / ?**")
+                        return out
+
+                    start  = page * PAGE_SIZE
+                    chunk  = seqs[start: start + PAGE_SIZE]
+                    tp     = max(1, (len(seqs) + PAGE_SIZE - 1) // PAGE_SIZE)
                     pg_lbl = f"**Page {page + 1} / {tp}**"
-                    vids   = []
-                    labels = []
-
-                    def _enc(seq):
-                        p, _ = get_video(seq, ov, a, fps)
-                        return seq, str(p) if p else None
-
-                    with ThreadPoolExecutor(max_workers=PAGE_SIZE) as pool:
-                        futs   = {pool.submit(_enc, s): i for i, s in enumerate(chunk)}
-                        res    = [None] * PAGE_SIZE
-                        lbs    = [""] * PAGE_SIZE
-                        for fut in as_completed(futs):
-                            i = futs[fut]
-                            seq, path = fut.result()
-                            res[i] = path
-                            lbs[i] = seq
 
-                    # Pad to PAGE_SIZE
-                    while len(res) < PAGE_SIZE:
-                        res.append(None)
-                        lbs.append("—")
+                    # Sequential — encode_sequence() returns in <1 ms when already cached
+                    res, lbs = [], []
+                    for s in chunk:
+                        try:
+                            p, _ = get_video(s, ov, a, fps)
+                            res.append(str(p) if p else None)
+                        except Exception:
+                            res.append(None)
+                        lbs.append(s)
+
+                    while len(res) < PAGE_SIZE:   # pad
+                        res.append(None); lbs.append("—")
 
                     n_loaded = sum(1 for r in res if r)
-                    status   = f"✅ Loaded {n_loaded}/{len(chunk)} videos (page {page+1}/{tp})"
+                    status   = f"✅ {n_loaded}/{len(chunk)} videos loaded (page {page+1}/{tp})"
 
-                    # Build flat output: [lbl0, vid0, lbl1, vid1, …, status, pg_lbl]
                     out = []
                     for lb, r in zip(lbs, res):
                         out.append(f"**{lb}**" if lb and lb != "—" else "—")
@@ -823,6 +864,27 @@ def build_ui():
                 mv_next.click(_next, [mv_seq_state, mv_page_state],
                               [mv_page_state, mv_page_lbl])
 
+                # ── Cache progress wiring (timer + manual refresh) ────────
+                def _mv_cache_tick():
+                    """Auto-refresh: hides the wait panel and shows the grid when done."""
+                    done_now = _is_cache_complete()
+                    status   = cache_status_md()
+                    return (
+                        status,                                 # mv_wait_status
+                        gr.update(visible=not done_now),        # mv_wait_col
+                        gr.update(visible=done_now),            # mv_grid_col
+                        gr.update(active=not done_now),         # timer — stop when done
+                    )
+
+                mv_refresh_btn.click(_mv_cache_tick,
+                                     outputs=[mv_wait_status, mv_wait_col,
+                                              mv_grid_col, gr.State()])
+
+                mv_timer = gr.Timer(value=4, active=not _initially_done)
+                mv_timer.tick(_mv_cache_tick,
+                              outputs=[mv_wait_status, mv_wait_col,
+                                       mv_grid_col, mv_timer])
+
             # ──────────────────────────────────────────────────────────────
             # Tab 5 · Compare  (up to 6 side-by-side)
             # ──────────────────────────────────────────────────────────────
@@ -872,23 +934,22 @@ def build_ui():
                     res   = [None] * MAX_COMPARE
                     lbs   = [""] * MAX_COMPARE
 
-                    def _enc(i, seq):
+                    # Sequential — fast when pre-cached, safe in all environments
+                    for i, seq in enumerate(slots):
                         if seq:
-                            p, _ = get_video(seq, ov, a, fps)
-                            res[i] = str(p) if p else None
+                            try:
+                                p, _ = get_video(seq, ov, a, fps)
+                                res[i] = str(p) if p else None
+                            except Exception:
+                                res[i] = None
                             lbs[i] = seq
 
-                    with ThreadPoolExecutor(max_workers=MAX_COMPARE) as pool:
-                        futs = [pool.submit(_enc, i, s) for i, s in enumerate(slots)]
-                        for f in as_completed(futs):
-                            f.result()
-
                     n_ok = sum(1 for r in res if r)
                     out  = []
                     for r, l in zip(res, lbs):
                         out.append(r)
                         out.append(f"**{l}**" if l else "*empty*")
-                    out.append(f"✅ Loaded {n_ok}/{len([s for s in slots if s])} slots")
+                    out.append(f"✅ {n_ok}/{len([s for s in slots if s])} slots loaded")
                     return out
 
                 cmp_btn.click(_load_all,
@@ -971,10 +1032,14 @@ demo = build_ui()
 start_precache(fps=DEFAULT_FPS, workers=4)
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="DAVIS Dataset Explorer")
-    parser.add_argument("--share",  action="store_true")
-    parser.add_argument("--port",   type=int, default=7860)
-    parser.add_argument("--host",   default="0.0.0.0")
-    args = parser.parse_args()
-    demo.launch(server_name=args.host, server_port=args.port,
-                share=args.share, theme=gr.themes.Soft())
+    if IS_HF_SPACE:
+        # HF Spaces manages routing — just launch without binding params.
+        demo.launch(theme=gr.themes.Soft())
+    else:
+        parser = argparse.ArgumentParser(description="DAVIS Dataset Explorer")
+        parser.add_argument("--share", action="store_true")
+        parser.add_argument("--port",  type=int, default=7860)
+        parser.add_argument("--host",  default="0.0.0.0")
+        args = parser.parse_args()
+        demo.launch(server_name=args.host, server_port=args.port,
+                    share=args.share, theme=gr.themes.Soft())