Clarify prompt modes and diversify fallbacks

app.py

@@ -75,7 +75,7 @@ MOODS = [
     "futuristic and strange",
     "relaxed and intimate",
 ]
-PROMPT_MODES = ["English prompt for best stability", "Selected language prompt", "Bilingual prompt"]
+PROMPT_MODES = ["Best stability (English)", "Broadcast language", "English + broadcast language"]
 VOCAL_MODES = ["Instrumental only", "Wordless vocal texture", "Original micro-lyrics"]
 DURATIONS = [10, 15, 20]
 
@@ -355,7 +355,7 @@ with gr.Blocks(title="Turntable Time Machine", css=CSS) as demo:
                     broadcast_language = gr.Dropdown(list(LANGUAGE_LABEL_TO_ID.keys()), value="English", label="Broadcast language", elem_classes=["compact-control"])
                     vocal_mode = gr.Dropdown(VOCAL_MODES, value="Instrumental only", label="Vocal mode", elem_classes=["compact-control"])
                 lyric_theme = gr.Dropdown(list(THEME_LABEL_TO_ID.keys()), value=list(THEME_LABEL_TO_ID.keys())[0], label="Lyric theme", visible=False, elem_classes=["compact-control"])
-                prompt_language_mode = gr.Dropdown(PROMPT_MODES, value=PROMPT_MODES[0], label="Prompt language mode", elem_classes=["compact-control"])
+                prompt_language_mode = gr.Dropdown(PROMPT_MODES, value=PROMPT_MODES[0], label="Music prompt language", elem_classes=["compact-control"])
                 mood = gr.Dropdown(MOODS, value=MOODS[0], label="Mood", elem_classes=["compact-control"])
                 audio_texture = gr.Dropdown(list(TEXTURE_LABEL_TO_ID.keys()), value=list(TEXTURE_LABEL_TO_ID.keys())[-1], label="Audio texture", elem_classes=["compact-control"])
                 with gr.Row():

src/music_generator.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+import hashlib
 import os
 
 import numpy as np
@@ -34,36 +35,79 @@ def _tone(freq: float, t: np.ndarray, wave: str = "sine") -> np.ndarray:
     return np.sin(phase).astype(np.float32)
 
 
+def _prompt_rng(prompt: str, seed: int | None) -> np.random.Generator:
+    digest = hashlib.sha256(f"{seed or 0}:{prompt}".encode("utf-8")).digest()
+    route_seed = int.from_bytes(digest[:8], "little") % (2**32)
+    return np.random.default_rng(route_seed)
+
+
 def generate_fallback_music(prompt: str, duration: int, bpm: int, seed: int | None, output_path: str) -> dict:
     sr = 44100
-    rng = np.random.default_rng(seed)
+    rng = _prompt_rng(prompt, seed)
     total = int(duration * sr)
     audio = np.zeros(total, dtype=np.float32)
     beat = 60.0 / max(bpm, 1)
     samples_per_beat = int(beat * sr)
-    key = int(rng.integers(0, 7))
-    root = 110.0 * (2 ** (key / 12))
-    chords = [root, root * 2 ** (3 / 12), root * 2 ** (7 / 12), root * 2 ** (10 / 12)]
+    prompt_lower = prompt.lower()
+    key = int(rng.integers(0, 12))
+    root = 82.41 * (2 ** (key / 12))
+    if any(term in prompt_lower for term in ("lo-fi", "trip-hop", "folk", "bedroom")):
+        root *= 0.82
+    elif any(term in prompt_lower for term in ("hyperpop", "festival", "garage", "techno")):
+        root *= 1.18
+
+    chord_shapes = [
+        [0, 3, 7, 10],
+        [0, 4, 7, 11],
+        [0, 5, 7, 12],
+        [0, 2, 7, 9],
+    ]
+    chord_shape = chord_shapes[int(rng.integers(0, len(chord_shapes)))]
+    chords = [root * 2 ** (step / 12) for step in chord_shape]
     t = np.arange(total) / sr
+    beat_accent = 0.62
+    bass_wave = "square"
+    chord_wave = "saw"
+    swing = 1.0
+    hat_divider = 2
+
+    if any(term in prompt_lower for term in ("disco", "house", "club", "garage", "amapiano")):
+        beat_accent = 0.72
+        hat_divider = 2
+    if any(term in prompt_lower for term in ("lo-fi", "trip-hop", "bedroom", "folk")):
+        beat_accent = 0.42
+        bass_wave = "sine"
+        chord_wave = "sine"
+        swing = 1.18
+    if any(term in prompt_lower for term in ("techno", "hyperpop", "future", "ai-era")):
+        bass_wave = "saw"
+        chord_wave = "square"
+        hat_divider = 1
 
     bass_notes = [root / 2, root * 2 ** (5 / 12) / 2, root * 2 ** (7 / 12) / 2, root * 2 ** (3 / 12) / 2]
     for i in range(0, total, samples_per_beat):
         n = min(samples_per_beat, total - i)
         local_t = np.arange(n) / sr
-        kick = np.sin(2 * np.pi * (62 * np.exp(-local_t * 24)) * local_t) * np.exp(-local_t * 18)
-        audio[i : i + n] += kick.astype(np.float32) * 0.55
-        bass = _tone(bass_notes[(i // samples_per_beat) % len(bass_notes)], local_t, "square")
-        audio[i : i + n] += bass * _env(n, sr, 0.005, 0.12) * 0.12
+        beat_index = i // samples_per_beat
+        kick_freq = 48 + int(rng.integers(0, 24))
+        kick = np.sin(2 * np.pi * (kick_freq * np.exp(-local_t * 24)) * local_t) * np.exp(-local_t * 18)
+        audio[i : i + n] += kick.astype(np.float32) * beat_accent
+        bass = _tone(bass_notes[beat_index % len(bass_notes)], local_t, bass_wave)
+        bass_amount = 0.08 + float(rng.random()) * 0.08
+        audio[i : i + n] += bass * _env(n, sr, 0.005, 0.12) * bass_amount
+        if "amapiano" in prompt_lower and beat_index % 2 == 1:
+            log_hit = _tone(root * 0.74, local_t, "sine") * np.exp(-local_t * 9)
+            audio[i : i + n] += log_hit.astype(np.float32) * 0.18
 
     bar = max(samples_per_beat * 4, 1)
     for i in range(0, total, bar):
         n = min(bar, total - i)
         local_t = np.arange(n) / sr
-        chord = sum(_tone(freq, local_t, "saw") for freq in chords) / len(chords)
-        audio[i : i + n] += chord * _env(n, sr, 0.4, 0.4) * 0.09
+        chord = sum(_tone(freq, local_t, chord_wave) for freq in chords) / len(chords)
+        audio[i : i + n] += chord * _env(n, sr, 0.25, 0.5) * (0.06 + float(rng.random()) * 0.05)
         chords = chords[1:] + chords[:1]
 
-    hat_interval = max(samples_per_beat // 2, 1)
+    hat_interval = max(int(samples_per_beat / hat_divider * swing), 1)
     noise = rng.normal(0, 1, total).astype(np.float32)
     if butter is not None and lfilter is not None:
         b, a = butter(1, 7000 / (sr / 2), btype="high")
@@ -72,9 +116,14 @@ def generate_fallback_music(prompt: str, duration: int, bpm: int, seed: int | No
         noise = (noise - np.convolve(noise, np.ones(64, dtype=np.float32) / 64, mode="same")).astype(np.float32)
     for i in range(0, total, hat_interval):
         n = min(int(0.045 * sr), total - i)
-        audio[i : i + n] += noise[i : i + n] * _env(n, sr, 0.001, 0.035) * 0.055
-
-    shimmer = _tone(root * 4, t, "sine") * 0.018 + _tone(root * 6, t, "sine") * 0.011
+        audio[i : i + n] += noise[i : i + n] * _env(n, sr, 0.001, 0.035) * (0.035 + float(rng.random()) * 0.04)
+
+    lead_ratio = float(rng.choice([3, 4, 5, 6, 7]))
+    shimmer = _tone(root * lead_ratio, t, "sine") * 0.014 + _tone(root * (lead_ratio + 2), t, "sine") * 0.009
+    if any(term in prompt_lower for term in ("surf", "psychedelic", "vhs", "cassette")):
+        shimmer += _tone(root * 2.5, t, "saw") * 0.014
+    if "hyperpop" in prompt_lower:
+        shimmer += _tone(root * 8, t, "square") * 0.012
     audio += shimmer.astype(np.float32)
     stereo = np.stack([audio, np.roll(audio, int(0.009 * sr))], axis=1)
     save_audio(output_path, stereo, sr)

src/prompt_builder.py

@@ -76,15 +76,15 @@ def build_music_prompt(
     duration,
     bpm,
     language_id="en",
-    prompt_language_mode="English prompt for best stability",
+    prompt_language_mode="Best stability (English)",
     vocal_mode="Instrumental only",
     lyrics=None,
 ) -> str:
     english = _english_prompt(source_era, source_genre, remix_era, remix_genre, texture, mood, duration, bpm)
     localized, _ = _localized_prompt(language_id, source_era, source_genre, remix_era, remix_genre, texture, mood, duration, bpm)
-    if prompt_language_mode == "Selected language prompt":
+    if prompt_language_mode in ("Broadcast language", "Selected language prompt"):
         prompt = localized
-    elif prompt_language_mode == "Bilingual prompt" and language_id != "en":
+    elif prompt_language_mode in ("English + broadcast language", "Bilingual prompt") and language_id != "en":
         prompt = f"{english}\n{localized}"
     else:
         prompt = english
@@ -159,4 +159,3 @@ def build_mixtape_card(
       {kv}
     </div>
     """
-

src/tts.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+import hashlib
 import os
 
 import numpy as np
@@ -8,6 +9,32 @@ import numpy as np
 from .audio_utils import save_audio
 
 
+def generate_fallback_dj_signal(text: str, output_path: str) -> dict:
+    sr = 24000
+    words = max(4, min(28, len((text or "").split())))
+    duration = min(4.0, max(1.0, words * 0.16))
+    total = int(sr * duration)
+    t = np.arange(total) / sr
+    digest = hashlib.sha256((text or "timeline radio").encode("utf-8")).digest()
+    base = 150 + digest[0]
+    carrier = np.sin(2 * np.pi * base * t) * 0.045
+    radio = np.sin(2 * np.pi * (base * 1.5) * t) * 0.025
+    envelope = 0.6 + 0.4 * np.sin(2 * np.pi * (2.2 + digest[1] / 128) * t)
+    audio = (carrier + radio) * envelope
+    for index in range(words):
+        start = int((index / words) * total)
+        stop = min(total, start + int(sr * 0.055))
+        if stop > start:
+            audio[start:stop] += np.sin(2 * np.pi * (base + 120 + (index % 5) * 38) * t[: stop - start]) * 0.055
+    save_audio(output_path, audio.astype(np.float32), sr)
+    return {
+        "path": output_path,
+        "sample_rate": sr,
+        "tts_succeeded": False,
+        "fallback_audio": True,
+    }
+
+
 def generate_dj_voice(
     text: str,
     language_id: str,
@@ -37,11 +64,13 @@ def generate_dj_voice(
 
         raise RuntimeError("Kokoro wrapper hook is present, but local TTS inference is not configured.")
     except Exception as exc:
+        fallback = generate_fallback_dj_signal(text, output_path)
         return {
-            "path": None,
-            "sample_rate": None,
-            "status": f"Text-only DJ intro fallback. Kokoro unavailable or unsupported here: {exc}",
+            "path": fallback["path"],
+            "sample_rate": fallback["sample_rate"],
+            "status": f"Fallback DJ radio-signal intro audio generated. Kokoro spoken TTS unavailable or unsupported here: {exc}",
             "tts_succeeded": False,
+            "fallback_audio": True,
             "model_attempted": True,
             "model_id": "hexgrad/Kokoro-82M",
         }

tests/test_app_logic.py

@@ -76,6 +76,12 @@ class TurntableTimeMachineLogicTests(unittest.TestCase):
         self.assertIn(result[11], app.DURATIONS)
         self.assertIn("era-card", result[14])
 
+    def test_prompt_mode_labels_are_plain_language(self):
+        self.assertEqual(
+            app.PROMPT_MODES,
+            ["Best stability (English)", "Broadcast language", "English + broadcast language"],
+        )
+
     def test_music_wrapper_attempts_model_by_default_then_falls_back(self):
         result = generate_music(
             "Create an original music clip. No vocals. No lyrics.",
@@ -91,6 +97,25 @@ class TurntableTimeMachineLogicTests(unittest.TestCase):
         self.assertEqual(sr, 44100)
         self.assertGreater(audio.shape[0], 0)
 
+    def test_fallback_music_varies_by_prompt_route(self):
+        first = generate_music(
+            "Create an original music clip. Start from 1960s Motown-inspired soul. Transform it into 2000s filtered disco house.",
+            duration=1,
+            bpm=118,
+            seed=123,
+            output_path="outputs/test_route_one.wav",
+        )
+        second = generate_music(
+            "Create an original music clip. Start from 2020s lo-fi chill. Transform it into 1970s funk.",
+            duration=1,
+            bpm=118,
+            seed=123,
+            output_path="outputs/test_route_two.wav",
+        )
+        audio_one, _ = sf.read(first["path"])
+        audio_two, _ = sf.read(second["path"])
+        self.assertGreater(float(abs(audio_one - audio_two).mean()), 0.001)
+
     def test_audio_model_calls_can_be_exercised_with_test_switch(self):
         os.environ["TTM_TEST_MODEL_CALLS"] = "1"
         music = generate_music(
@@ -137,7 +162,7 @@ class TurntableTimeMachineLogicTests(unittest.TestCase):
                     "Clean digital master",
                     "nostalgic and warm",
                     "English",
-                    "English prompt for best stability",
+                    "Best stability (English)",
                     vocal_mode,
                     "Night drive",
                     1,
@@ -147,8 +172,9 @@ class TurntableTimeMachineLogicTests(unittest.TestCase):
                 final_path, music_path, intro_path, _intro_text, lyrics_text, prompt, _card, status = result[:8]
                 self.assertTrue(Path(final_path).exists())
                 self.assertTrue(Path(music_path).exists())
-                self.assertIsNone(intro_path)
+                self.assertTrue(Path(intro_path).exists())
                 self.assertIn("ACE-Step", status)
+                self.assertIn("Fallback DJ radio-signal intro audio generated", status)
                 audio, sr = sf.read(final_path)
                 self.assertEqual(sr, 44100)
                 self.assertGreater(audio.shape[0], 0)
@@ -171,7 +197,7 @@ class TurntableTimeMachineLogicTests(unittest.TestCase):
             "Clean digital master",
             "nostalgic and warm",
             "English",
-            "English prompt for best stability",
+            "Best stability (English)",
             "Original micro-lyrics",
             "Night drive",
             1,