Upload app.py with huggingface_hub

app.py

@@ -11,6 +11,7 @@ import os
 # found in __main__") instead of executing the __main__ block at the bottom.
 os.environ.setdefault("GRADIO_SSR_MODE", "false")
 
+import json
 import queue
 import re
 import threading
@@ -43,6 +44,7 @@ from model import stream_broadcast
 from stations import (
     CURSED_FREQUENCY,
     CURSED_SYSTEM_PROMPT,
+    STATION_FREQUENCIES,
     STATION_TOLERANCE,
     get_station,
     localized_system_prompt,
@@ -122,6 +124,31 @@ def _stream_fixed(text: str, char_delay: float = 0.025, should_continue=None):
 _broadcast_cache: dict[str, str] = {}
 _CACHE_MAX = 256
 
+# Pre-baked broadcasts: stations and the cursed signal are generated ahead of
+# time (see prebake.py) into broadcasts_cache.json and served instantly, so a
+# visitor never waits ~50s for a first-touch generation on the Space's CPU.
+# Per-listener variety is preserved by baking a POOL of wordings per station and
+# mapping each listener's session variant onto one of them (variant % POOL_SIZE):
+# different visitors land on different editions, but every edition is instant.
+POOL_SIZE = 6
+_PREBAKED: dict[str, str] = {}
+
+
+def _load_prebaked():
+    path = ROOT / "broadcasts_cache.json"
+    try:
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+            for key, text in data.items():
+                if isinstance(text, str) and text.strip():
+                    _PREBAKED[key] = text
+            print(f"[prebake] loaded {len(_PREBAKED)} pre-baked broadcasts")
+    except Exception as exc:  # noqa: BLE001 - never let a bad cache crash boot
+        print(f"[prebake] could not load cache: {exc}")
+
+
+_load_prebaked()
+
 # Rapid retuning: each /tune bumps this epoch. An in-flight generation that is
 # no longer the latest self-terminates at the next token, releasing the model
 # lock so the newest tune can run. Without this, a superseded generation runs to
@@ -246,6 +273,12 @@ def _stream_model_cached(cache_key: str, system_prompt: str, should_continue=Non
     def superseded():
         return should_continue is not None and not should_continue()
 
+    # Pre-baked broadcasts are served instantly, no model call, no cold wait.
+    prebaked = _PREBAKED.get(cache_key)
+    if prebaked:
+        yield from _stream_fixed(prebaked, char_delay=0.018, should_continue=should_continue)
+        return
+
     cached = _broadcast_cache.get(cache_key)
     if cached:
         yield from _stream_fixed(cached, char_delay=0.018, should_continue=should_continue)
@@ -291,12 +324,16 @@ def _norm_variant(variant) -> int:
 def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
     """Tunes a frequency and streams the broadcast (SSE).
 
-    `variant` is a per-listener session nonce: every visitor hears their own
-    edition of each station (the world re-broadcasts for every new listener).
+    `variant` is a per-listener session nonce. For the encrypted station it
+    drives that listener's unique cipher (kept fully per-session). For the
+    spoken stations and the cursed signal it selects one of POOL_SIZE pre-baked
+    editions (`pool`), so different visitors still hear different wordings while
+    every edition is served instantly from the pre-baked cache.
     """
     frequency = float(frequency)
     lang = normalize_lang(language)
     var = _norm_variant(variant)
+    pool = var % POOL_SIZE
     my_epoch = _next_tune_epoch()
 
     def still_current():
@@ -310,11 +347,11 @@ def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
     # The unsolvable station: the model broadcasts, the frontend never cleans it.
     if abs(frequency - CURSED_FREQUENCY) <= STATION_TOLERANCE:
         yield from _stream_model_cached(
-            f"cursed:{CURSED_FREQUENCY}:{lang}:{var}",
+            f"cursed:{CURSED_FREQUENCY}:{lang}:{pool}",
             localized_system_prompt(CURSED_SYSTEM_PROMPT, "es", lang),
             should_continue=still_current,
             user_prompt=localized_user_prompt(None, lang),
-            seed=_mix_seed(station_seed(CURSED_FREQUENCY), var),
+            seed=_mix_seed(station_seed(CURSED_FREQUENCY), pool),
             max_tokens=160,
         )
         return
@@ -333,11 +370,11 @@ def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
         return
 
     yield from _stream_model_cached(
-        f"station:{canonical}:{lang}:{var}",
+        f"station:{canonical}:{lang}:{pool}",
         station_system_prompt(canonical, lang),
         should_continue=still_current,
         user_prompt=localized_user_prompt(station, lang),
-        seed=_mix_seed(station_seed(canonical), var),
+        seed=_mix_seed(station_seed(canonical), pool),
     )
 
 
@@ -393,7 +430,7 @@ def _warm_up():
     so the first visitor (a judge) doesn't pay the cold-start penalty: the GGUF
     is already in memory and llama.cpp is warm before anyone turns the dial."""
     try:
-        canonical = nearest_station_frequency(95.0) or 95.0
+        canonical = STATION_FREQUENCIES[len(STATION_FREQUENCIES) // 2]
         for _ in stream_broadcast(
             station_system_prompt(canonical, "es"),
             user_prompt="hola",
@@ -407,7 +444,9 @@ def _warm_up():
 
 
 # Kick the warm-up as soon as the module is imported (HF imports app.py on boot).
-threading.Thread(target=_warm_up, daemon=True).start()
+# Skipped when prebake.py imports this module just to reuse its helpers.
+if not os.environ.get("PREBAKE"):
+    threading.Thread(target=_warm_up, daemon=True).start()
 
 
 if __name__ == "__main__":