Upload publicapi.py

public/publicapi.py

@@ -2,7 +2,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# GhostAI Music Generator — Release v1.3.1
+# GhostAI Music Generator — Release v1.3.2
 # Gradio UI + FastAPI server, externalized styles (CSS), prompts (INI), and examples (MD).
 # Saves MP3s to ./mp3, single rotating log (max 5MB) in ./logs, colorized console.
 
@@ -40,7 +40,7 @@ import uvicorn
 
 from colorama import init as colorama_init, Fore, Style
 
-RELEASE = "v1.3.1"
+RELEASE = "v1.3.2"
 
 # ======================================================================================
 # PATCHES & RUNTIME
@@ -263,7 +263,7 @@ def balance_stereo(seg: AudioSegment, noise_threshold=-40, sample_rate=48000) ->
         stereo = stereo * mask
         left, right = stereo[:, 0], stereo[:, 1]
         l_rms = np.sqrt(np.mean(left[left != 0] ** 2)) if np.any(left != 0) else 0
-        r_rms = np.sqrt(np.mean(np.mean(right[right != 0] ** 2))) if np.any(right != 0) else 0
+        r_rms = np.sqrt(np.mean(right[right != 0] ** 2)) if np.any(right != 0) else 0
         if l_rms > 0 and r_rms > 0:
             avg = (l_rms + r_rms) / 2
             stereo[:, 0] *= (avg / l_rms)
@@ -316,12 +316,11 @@ def apply_fade(seg: AudioSegment, fade_in=500, fade_out=800) -> AudioSegment:
         return seg
 
 # ======================================================================================
-# PROMPTS (FROM INI) — SAFE FORMAT TO AVOID KeyError('mood') AND OTHER PLACEHOLDERS
+# PROMPTS (FROM INI) — SAFE FORMAT + STYLE-DRIVEN UI CHANGES
 # ======================================================================================
 
 class SafeFormatDict(dict):
     def __missing__(self, key):
-        # Gracefully handle missing placeholders in templates (e.g., {mood}, {genre})
         return ""
 
 class StylesConfig:
@@ -343,11 +342,12 @@ class StylesConfig:
         self.styles = {}
         for sec in self.cfg.sections():
             d: Dict[str, Any] = {k: v for k, v in self.cfg.items(sec)}
-            # Split known list-like fields
+            # Normalize list-like fields
             listish = {
                 "drum_beat", "synthesizer", "rhythmic_steps", "bass_style", "guitar_style",
                 "variations", "mood", "genre", "key", "scale", "feel", "instrument",
-                "lead", "pad", "arp", "drums", "bass", "guitar", "strings", "brass", "woodwinds"
+                "lead", "pad", "arp", "drums", "bass", "guitar", "strings", "brass", "woodwinds",
+                "structure"
             }
             for key in listish:
                 if key in d and isinstance(d[key], str):
@@ -366,13 +366,10 @@ class StylesConfig:
         self.maybe_reload()
         return list(self.styles.keys())
 
-    def _pick(self, s: Dict[str, Any], field: str, incoming: Optional[str]) -> str:
-        if incoming and incoming != "none":
-            return str(incoming)
-        val = s.get(field, [])
-        if isinstance(val, list):
-            return random.choice(val) if val else "none"
-        return str(val) if val else "none"
+    def _pick_from_list(self, vals: Any) -> str:
+        if isinstance(vals, list):
+            return random.choice(vals) if vals else ""
+        return str(vals or "")
 
     def build_prompt(
         self,
@@ -390,19 +387,21 @@ class StylesConfig:
             return ""
         s = self.styles[style]
 
-        # BPM handling
         bpm_min = int(s.get("bpm_min", "100"))
         bpm_max = int(s.get("bpm_max", "140"))
         final_bpm = bpm if bpm != 120 else random.randint(bpm_min, bpm_max)
 
-        # Picks for band controls
-        d = self._pick(s, "drum_beat", drum_beat)
-        syn = self._pick(s, "synthesizer", synthesizer)
-        r = self._pick(s, "rhythmic_steps", rhythmic_steps)
-        b = self._pick(s, "bass_style", bass_style)
-        g = self._pick(s, "guitar_style", guitar_style)
+        def choose(field_name: str, incoming: str) -> str:
+            if incoming and incoming != "none":
+                return incoming
+            return self._pick_from_list(s.get(field_name, [])) or ""
+
+        d = choose("drum_beat", drum_beat)
+        syn = choose("synthesizer", synthesizer)
+        r = choose("rhythmic_steps", rhythmic_steps)
+        b = choose("bass_style", bass_style)
+        g = choose("guitar_style", guitar_style)
 
-        # Variation logic per chunk
         var_list = s.get("variations", [])
         variation = ""
         if isinstance(var_list, list) and var_list:
@@ -411,37 +410,54 @@ class StylesConfig:
             else:
                 variation = random.choice(var_list)
 
-        # Start with all keys from the style; choose a random item for list-type values
+        # Start from style fields (pick one value from lists)
         fields: Dict[str, Any] = {}
         for k, v in s.items():
-            if isinstance(v, list):
-                fields[k] = random.choice(v) if v else ""
-            else:
-                fields[k] = v
+            fields[k] = self._pick_from_list(v) if isinstance(v, list) else v
+
+        # Map structure -> section for templates that use {section}
+        if "structure" in s:
+            fields["section"] = self._pick_from_list(s["structure"])
 
-        # Overlay computed/required fields
         fields.update({
             "bpm": final_bpm,
             "chunk": chunk_num,
-            "drum": d if d != "none" else "",
-            "synth": syn if syn != "none" else "",
-            "rhythm": r if r != "none" else "",
-            "bass": b if b != "none" else "",
-            "guitar": g if g != "none" else "",
+            "drum": f" {d}" if d else "",
+            "synth": f" {syn}" if syn else "",
+            "rhythm": f" {r}" if r else "",
+            "bass": f" {b}" if b else "",
+            "guitar": f" {g}" if g else "",
             "variation": variation
         })
 
-        # Default template if none in INI
         tpl = s.get(
             "prompt_template",
-            "Instrumental track at {bpm} BPM {variation}. {mood} {genre} {drum} {bass} {guitar} {synth} {rhythm}"
+            "Instrumental track at {bpm} BPM {variation}. {mood} {section} {drum}{bass}{guitar}{synth}{rhythm}"
         )
 
-        # Safe formatting (prevents KeyError for undefined placeholders like {mood})
         prompt = tpl.format_map(SafeFormatDict(fields))
         prompt = re.sub(r"\s{2,}", " ", prompt).strip()
         return prompt
 
+    def style_defaults_for_ui(self, style: str) -> Dict[str, Any]:
+        self.maybe_reload()
+        s = self.styles.get(style, {})
+        bpm_min = int(s.get("bpm_min", "100"))
+        bpm_max = int(s.get("bpm_max", "140"))
+        chosen = {
+            "bpm": random.randint(bpm_min, bpm_max),
+            "drum_beat": self._pick_from_list(s.get("drum_beat", [])) or "none",
+            "synthesizer": self._pick_from_list(s.get("synthesizer", [])) or "none",
+            "rhythmic_steps": self._pick_from_list(s.get("rhythmic_steps", [])) or "none",
+            "bass_style": self._pick_from_list(s.get("bass_style", [])) or "none",
+            "guitar_style": self._pick_from_list(s.get("guitar_style", [])) or "none",
+        }
+        # Normalize any "none" literal that might sneak in as empty
+        for k, v in chosen.items():
+            if v == "":
+                chosen[k] = "none"
+        return chosen
+
 STYLES = StylesConfig(PROMPTS_INI)
 
 # ======================================================================================
@@ -572,7 +588,6 @@ def generate_music(
     if not instrumental_prompt.strip():
         return None, "⚠️ Enter a prompt.", vram_status_text
 
-    # Validate I/O
     try:
         out_sr = int(output_sample_rate)
     except:
@@ -818,7 +833,6 @@ def prompt(style: str, bpm: int = 120, chunk: int = 1,
     return {"style": style, "prompt": txt}
 
 # Back-compat endpoints declared in prompts.ini (e.g., /set_classical_star_wars_prompt)
-# Fix closure capture by binding route path explicitly.
 for sec, cfg in list(STYLES.styles.items()):
     api_name = cfg.get("api_name")
     if api_name:
@@ -903,19 +917,13 @@ def read_css() -> str:
     try:
         if CSS_FILE.exists():
             return CSS_FILE.read_text(encoding="utf-8")
-        # High-contrast ADA-compliant fallback (white text, dark bg)
         return """
 :root { color-scheme: dark; }
-body, .gradio-container {
-  background: #0E1014 !important;
-  color: #FFFFFF !important;
-}
+body, .gradio-container { background: #0E1014 !important; color: #FFFFFF !important; }
 * { color: #FFFFFF !important; }
 input, textarea, select {
-  background: #151922 !important;
-  color: #FFFFFF !important;
-  border: 1px solid #2A3142 !important;
-  border-radius: 10px !important;
+  background: #151922 !important; color: #FFFFFF !important;
+  border: 1px solid #2A3142 !important; border-radius: 10px !important;
 }
 .ga-header { display:flex; gap:12px; align-items:center; }
 .ga-header .logo { font-size: 28px; }
@@ -956,7 +964,6 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
             # BAND GRID (fixed rows of 4 per row)
             with gr.Group(elem_classes="ga-section"):
                 gr.Markdown("### Band / Style (grid 4 per row)")
-                # helper to create a row of 4 buttons
                 def row_of_buttons(entries):
                     with gr.Row(equal_height=True):
                         buttons = []
@@ -965,7 +972,6 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
                             buttons.append((key, btn))
                         return buttons
 
-                # rows
                 row1 = row_of_buttons([
                     ("metallica", "Metallica (Thrash) 🎸"),
                     ("nirvana", "Nirvana (Grunge) 🎤"),
@@ -974,7 +980,7 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
                 ])
                 row2 = row_of_buttons([
                     ("foo_fighters", "Foo Fighters (Alt Rock) 🤘"),
-                    ("rhcp", "Red Hot Chili Peppers (Funk Rock) 🌶️"),
+                    ("red_hot_chili_peppers", "Red Hot Chili Peppers (Funk Rock) 🌶️"),
                     ("smashing_pumpkins", "Smashing Pumpkins (Alt) 🎃"),
                     ("radiohead", "Radiohead (Experimental) 🧠"),
                 ])
@@ -1006,12 +1012,12 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
                         target_volume = gr.Slider(-30.0, -20.0, step=0.5, value=float(loaded.get("target_volume", -23.0)), label="Target Loudness (dBFS RMS)")
                         preset = gr.Dropdown(choices=["default", "rock", "techno", "grunge", "indie", "funk_rock"], value=str(loaded.get("preset", "default")), label="Preset")
                     with gr.Row():
-                        drum_beat = gr.Dropdown(choices=["none", "standard rock", "funk groove", "techno kick", "jazz swing"], value=str(loaded.get("drum_beat", "none")), label="Drum Beat")
-                        synthesizer = gr.Dropdown(choices=["none", "analog synth", "digital pad", "arpeggiated synth"], value=str(loaded.get("synthesizer", "none")), label="Synthesizer")
-                        rhythmic_steps = gr.Dropdown(choices=["none", "syncopated steps", "steady steps", "complex steps"], value=str(loaded.get("rhythmic_steps", "none")), label="Rhythmic Steps")
+                        drum_beat = gr.Dropdown(choices=["none", "standard rock", "funk groove", "techno kick", "jazz swing", "four-on-the-floor", "steady kick", "orchestral percussion", "precise drums", "heavy drums"], value=str(loaded.get("drum_beat", "none")), label="Drum Beat")
+                        synthesizer = gr.Dropdown(choices=["none", "analog synth", "digital pad", "arpeggiated synth", "lush synths", "atmospheric synths", "pulsing synths", "analog pad", "warm synths"], value=str(loaded.get("synthesizer", "none")), label="Synthesizer")
+                        rhythmic_steps = gr.Dropdown(choices=["none", "syncopated steps", "steady steps", "complex steps", "martial march", "staccato ostinato", "triplet swells"], value=str(loaded.get("rhythmic_steps", "none")), label="Rhythmic Steps")
                     with gr.Row():
-                        bass_style = gr.Dropdown(choices=["none", "slap bass", "deep bass", "melodic bass"], value=str(loaded.get("bass_style", "none")), label="Bass Style")
-                        guitar_style = gr.Dropdown(choices=["none", "distorted", "clean", "jangle"], value=str(loaded.get("guitar_style", "none")), label="Guitar Style")
+                        bass_style = gr.Dropdown(choices=["none", "slap bass", "deep bass", "melodic bass", "groovy bass", "hypnotic bass", "driving bass", "low brass", "cellos", "double basses", "subby bass"], value=str(loaded.get("bass_style", "none")), label="Bass Style")
+                        guitar_style = gr.Dropdown(choices=["none", "distorted", "clean", "jangle", "downpicked", "thrash riffing", "dreamy", "experimental", "funky"], value=str(loaded.get("guitar_style", "none")), label="Guitar Style")
                         max_steps = gr.Dropdown(choices=[1000, 1200, 1300, 1500], value=int(loaded.get("max_steps", 1500)), label="Max Steps (hint)")
 
                     bitrate_state = gr.State(value=str(loaded.get("bitrate", "192k")))
@@ -1053,18 +1059,52 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
             refresh_md = gr.Button("Refresh Examples.md", variant="secondary")
             refresh_md.click(lambda: read_examples(), outputs=md_box)
 
-    # Band button wiring (from prompts.ini)
-    def set_prompt_from_style(style_key, bpm_v, drum_v, synth_v, steps_v, bass_v, guitar_v):
-        txt = STYLES.build_prompt(style_key, int(bpm_v), 1, str(drum_v), str(synth_v), str(steps_v), str(bass_v), str(guitar_v))
-        return txt or f"{style_key}: update prompts.ini"
+    # =========================
+    # STYLE -> UI SYNC HANDLER
+    # =========================
+    def set_prompt_and_settings_from_style(style_key, current_bpm, current_drum, current_synth, current_steps, current_bass, current_guitar):
+        # Always derive fresh settings based on the selected style
+        defaults = STYLES.style_defaults_for_ui(style_key)
+        # Ensure fields exist even if style key missing
+        new_bpm = int(defaults.get("bpm", current_bpm or 120))
+        new_drum = str(defaults.get("drum_beat", "none"))
+        new_synth = str(defaults.get("synthesizer", "none"))
+        new_steps = str(defaults.get("rhythmic_steps", "none"))
+        new_bass = str(defaults.get("bass_style", "none"))
+        new_guitar = str(defaults.get("guitar_style", "none"))
+
+        # Build a prompt using these chosen defaults so text matches controls
+        prompt_txt = STYLES.build_prompt(
+            style_key,
+            new_bpm,
+            1,
+            new_drum,
+            new_synth,
+            new_steps,
+            new_bass,
+            new_guitar
+        )
+        if not prompt_txt:
+            prompt_txt = f"{style_key}: update prompts.ini"
 
+        return (
+            prompt_txt,           # Instrumental Prompt
+            new_bpm,              # BPM slider
+            new_drum,             # Drum Beat dropdown
+            new_synth,            # Synth dropdown
+            new_steps,            # Rhythmic Steps dropdown
+            new_bass,             # Bass Style dropdown
+            new_guitar            # Guitar Style dropdown
+        )
+
+    # Wire all style buttons to update BOTH the prompt and the key UI settings
     for key, btn in row1 + row2 + row3 + row4:
         if key == "foo_pad":
             continue
         btn.click(
-            set_prompt_from_style,
+            set_prompt_and_settings_from_style,
             inputs=[gr.State(key), bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style],
-            outputs=instrumental_prompt
+            outputs=[instrumental_prompt, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style]
         )
 
     # Quick-sets
@@ -1165,6 +1205,10 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
     load_btn.click(
         _load_action,
         outputs=[
+            instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+            drum_eat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+            preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box
+        ] if False else [
             instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
             drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
             preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box
@@ -1180,7 +1224,6 @@ with gr.Blocks(css=read_css(), analytics_enabled=False, title=f"GhostAI Music Ge
         ]
     )
 
-    # Logs
     def _get_log():
         try:
             return LOG_FILE.read_text(encoding="utf-8")[-40000:]