Upload folder using huggingface_hub

app.py

@@ -1,9 +1,11 @@
 import traceback
 import numpy as np
+import spaces
 from backend.orchestrator import run_pipeline
 from backend.presets import list_presets
 from frontend.layout import build_app
 
+@spaces.GPU
 def _warmup() -> None:
     sr = 16000
     dummy = np.zeros(sr, dtype=np.float32)
@@ -12,9 +14,9 @@ def _warmup() -> None:
             continue
         try:
             run_pipeline(preset['config'], dummy, sample_rate=sr, preset_label=preset['label'])
-            print(f"[warmup] ready: {preset['label']}")
+            print(f'[warmup] ready: {preset['label']}')
         except Exception as exc:
-            print(f"[warmup] skipped {preset['label']}: {exc}")
+            print(f'[warmup] skipped {preset['label']}: {exc}')
             traceback.print_exc()
     print('[warmup] done')
 if __name__ == '__main__':

frontend/layout.py

@@ -24,21 +24,32 @@ def _sample_clip_choices() -> list[tuple[str, str]]:
     choices = []
     for bucket in BUCKET_ORDER:
         for i, entry in enumerate(by_bucket.get(bucket, []), start=1):
-            label = f"{BUCKET_LABEL.get(bucket, bucket.title())} {i} - {entry['duration_seconds']}s"
+            label = f'{BUCKET_LABEL.get(bucket, bucket.title())} {i} - {entry['duration_seconds']}s'
             choices.append((label, entry['filename']))
     for bucket, entries in by_bucket.items():
         if bucket in BUCKET_ORDER:
             continue
         for i, entry in enumerate(entries, start=1):
-            choices.append((f"{bucket.title()} {i} - {entry['duration_seconds']}s", entry['filename']))
+            choices.append((f'{bucket.title()} {i} - {entry['duration_seconds']}s', entry['filename']))
     return choices
 
-def _preset_choices() -> list[str]:
-    return [live.DISPLAY_NAME.get(p['label'], p['label']) for p in live.public_presets()]
+def _all_public_presets() -> list[dict]:
+    return live.all_public_presets()
 
-def _default_active() -> list[str]:
-    choices = _preset_choices()
-    return [choices[0]] if choices else []
+def _preset_display_order() -> list[str]:
+    return [live.DISPLAY_NAME.get(p['label'], p['label']) for p in _all_public_presets()]
+
+def _default_active_display_names() -> list[str]:
+    target = 'Whisper-Tiny + Mean-Pool + Linear (trained)'
+    name = live.DISPLAY_NAME.get(target, target)
+    names = _preset_display_order()
+    return [name] if name in names else [names[0]] if names else []
+
+def _on_preset_change(*values: bool) -> tuple[list[str], dict, dict]:
+    names = _preset_display_order()
+    active = [n for n, v in zip(names, values) if v]
+    ac, se = _param_relevance(active)
+    return (active, gr.update(interactive=ac), gr.update(interactive=se))
 
 def _param_relevance(active_display_names: list[str]) -> tuple[bool, bool]:
     display_to_internal = {v: k for k, v in live.DISPLAY_NAME.items()}
@@ -51,8 +62,19 @@ def build_app() -> gr.Blocks:
     with gr.Blocks(title='Turn Detection - Live Dashboard') as demo:
         gr.Markdown('# Turn Detection - Live Dashboard\nSpeak, or replay a clip, and watch how different models judge whether the speaker is **done talking** vs. **still going** - plotted directly against the waveform as audio arrives.')
         session_state = gr.State(live.new_session_state)
+        active_state = gr.State(_default_active_display_names())
         with gr.Row():
-            active_presets = gr.CheckboxGroup(choices=_preset_choices(), value=_default_active(), label='Models to compare')
+            with gr.Column(scale=1, min_width=280):
+                gr.Markdown('### Models to compare')
+                gr.Markdown('*Greyed models are not built yet (future work).*')
+                default_active = _default_active_display_names()
+                preset_checkboxes = []
+                for preset in _all_public_presets():
+                    label = preset['label']
+                    disp = live.DISPLAY_NAME.get(label, label)
+                    available = bool(preset.get('available'))
+                    cb_label = disp if available else f'{disp}  (future)'
+                    preset_checkboxes.append(gr.Checkbox(label=cb_label, value=disp in default_active, interactive=available))
         with gr.Row():
             threshold_slider = gr.Slider(0.0, 1.0, value=live.DEFAULT_DECISION_THRESHOLD, step=0.01, label='Decision threshold - probability above this = "complete"')
             cadence_slider = gr.Slider(0, 5000, value=live.DEFAULT_CADENCE_MS, step=100, label='Update cadence (ms) - how often each model re-checks (slower models may still lag behind this)')
@@ -75,7 +97,8 @@ def build_app() -> gr.Blocks:
                 chart = gr.Plot(value=live.render_chart(live.new_session_state(), [], live.DEFAULT_DECISION_THRESHOLD), label=None)
         with gr.Accordion('History (this session)', open=False):
             log_table = gr.Dataframe(headers=LOG_HEADERS, value=[], label=None)
-        active_presets.change(lambda active: (gr.update(interactive=_param_relevance(active)[0]), gr.update(interactive=_param_relevance(active)[1])), inputs=active_presets, outputs=[acoustic_weight_slider, temperature_slider])
+        for cb in preset_checkboxes:
+            cb.change(_on_preset_change, inputs=preset_checkboxes, outputs=[active_state, acoustic_weight_slider, temperature_slider])
 
         def replay_clip(clip_filename, uploaded_path, active_display_names, acoustic_weight, temperature, threshold, cadence_ms, smoothing):
             path = uploaded_path or (str(config.SAMPLE_CLIPS_DIR / clip_filename) if clip_filename else None)
@@ -91,7 +114,7 @@ def build_app() -> gr.Blocks:
                 state, fig, log_rows = live.process_chunk(state, (sr, chunk), active_display_names, acoustic_weight, temperature, threshold, cadence_ms, smoothing)
                 yield (state, fig, log_rows)
                 time.sleep(chunk_duration_s)
-        replay_btn.click(replay_clip, inputs=[replay_clip_dropdown, replay_upload, active_presets, acoustic_weight_slider, temperature_slider, threshold_slider, cadence_slider, smoothing_slider], outputs=[session_state, chart, log_table])
-        mic.stream(fn=live.process_chunk, inputs=[session_state, mic, active_presets, acoustic_weight_slider, temperature_slider, threshold_slider, cadence_slider, smoothing_slider], outputs=[session_state, chart, log_table], stream_every=1.0, time_limit=None)
+        replay_btn.click(replay_clip, inputs=[replay_clip_dropdown, replay_upload, active_state, acoustic_weight_slider, temperature_slider, threshold_slider, cadence_slider, smoothing_slider], outputs=[session_state, chart, log_table])
+        mic.stream(fn=live.process_chunk, inputs=[session_state, mic, active_state, acoustic_weight_slider, temperature_slider, threshold_slider, cadence_slider, smoothing_slider], outputs=[session_state, chart, log_table], stream_every=1.0, time_limit=None)
         clear_btn.click(live.clear_session, inputs=session_state, outputs=[session_state, chart, log_table])
     return demo

frontend/live.py

@@ -25,6 +25,10 @@ def public_presets() -> list[dict]:
     by_label = {p['label']: p for p in list_presets()}
     return [by_label[label] for label in PUBLIC_PRESET_ORDER if label in by_label and by_label[label]['available']]
 
+def all_public_presets() -> list[dict]:
+    by_label = {p['label']: p for p in list_presets()}
+    return [by_label[label] for label in PUBLIC_PRESET_ORDER if label in by_label]
+
 def uses_acoustic_weight(label: str) -> bool:
     by_label = {p['label']: p for p in list_presets()}
     preset = by_label.get(label)
@@ -123,7 +127,7 @@ def render_chart(state: dict[str, Any], active_labels: list[str], threshold: flo
         has_probability = any((e['probability'] is not None for e in history))
         if not has_probability:
             last = history[-1]
-            verdict_only_lines.append(f"{display_name}: {(last['decision'] or '-').upper()}")
+            verdict_only_lines.append(f'{display_name}: {(last['decision'] or '-').upper()}')
             continue
         xs = [e['buffer_seconds'] for e in history if e['probability'] is not None]
         ys_raw = [e['probability'] for e in history if e['probability'] is not None]