Update app.py

app.py

@@ -1,452 +1,314 @@
-import os
-import sys
-import gc
-import time
-import random
-import warnings
-import tempfile
-import psutil
-import numpy as np
-import torch
-import torchaudio
-import gradio as gr
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GhostAI Music Generator — Zero-GPU Friendly
+Full Gradio application with conflict-free dependencies.
+
+Python  : 3.10
+Torch   : 2.1 CPU wheels
+Updated : 2025-05-29
+"""
+
+import os, sys, gc, time, random, warnings, tempfile, psutil, numpy as np
+import torch, torchaudio, gradio as gr
 from pydub import AudioSegment
 from torch.cuda.amp import autocast
 from audiocraft.models import MusicGen
 from huggingface_hub import login
 
-# ----------------------------------------------------------------------
-# PYTORCH COMPATIBILITY SHIM (for versions < 2.3)
-# ----------------------------------------------------------------------
+# ------------------------------------------------------------------ #
+#  Compatibility shim (torch < 2.3)                                   #
+# ------------------------------------------------------------------ #
 if not hasattr(torch, "get_default_device"):
-    def _get_default_device():
-        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    torch.get_default_device = _get_default_device
+    torch.get_default_device = lambda: torch.device(
+        "cuda" if torch.cuda.is_available() else "cpu"
+    )
 
-# ----------------------------------------------------------------------
-# WARNING SUPPRESSION & ENV TUNING
-# ----------------------------------------------------------------------
 warnings.filterwarnings("ignore")
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
 
-# ----------------------------------------------------------------------
-# HUGGING FACE AUTH
-# ----------------------------------------------------------------------
-hf_token = os.getenv("HF_TOKEN")
-if not hf_token:
-    print("ERROR: HF_TOKEN environment variable not set. Please set it.")
-    sys.exit(1)
-
-try:
-    login(hf_token)
-except Exception as e:
-    print(f"ERROR: Failed to authenticate with Hugging Face: {e}")
+# ------------------------------------------------------------------ #
+#  Hugging Face authentication                                        #
+# ------------------------------------------------------------------ #
+HF_TOKEN = os.getenv("HF_TOKEN")
+if not HF_TOKEN:
+    print("ERROR: set HF_TOKEN in the Space secrets.")
     sys.exit(1)
+login(HF_TOKEN)
 
-# ----------------------------------------------------------------------
-# VERSION CHECKS
-# ----------------------------------------------------------------------
-if np.__version__ != "1.23.5":
-    print(f"WARNING: NumPy version {np.__version__} detected (expected 1.23.5).")
-if not torch.__version__.startswith("2.3.1"):
-    print(f"WARNING: PyTorch version {torch.__version__} detected (expected 2.3.1).")
-
-# ----------------------------------------------------------------------
-# DEVICE SETUP
-# ----------------------------------------------------------------------
-print("Debugging GPU and CUDA setup…")
-print(f"PyTorch CUDA available: {torch.cuda.is_available()}")
-if torch.cuda.is_available():
-    print(f"CUDA device count : {torch.cuda.device_count()}")
-    print(f"CUDA device name  : {torch.cuda.get_device_name(0)}")
-    print(f"CUDA version      : {torch.version.cuda}")
-else:
-    print("CUDA unavailable; falling back to CPU (performance will suffer).")
-
+# ------------------------------------------------------------------ #
+#  Device setup                                                       #
+# ------------------------------------------------------------------ #
 device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Pre-run memory cleanup (GPU)
+print(f"Running on {device.upper()}")
 if device == "cuda":
-    torch.cuda.empty_cache()
-    gc.collect()
-    torch.cuda.ipc_collect()
-    torch.cuda.synchronize()
-
-# ----------------------------------------------------------------------
-# LOAD MUSICGEN
-# ----------------------------------------------------------------------
-try:
-    print("Loading MusicGen medium model…")
-    musicgen_model = MusicGen.get_pretrained("facebook/musicgen-medium", device=device)
-    musicgen_model.set_generation_params(duration=10, two_step_cfg=False)
-except Exception as e:
-    print(f"ERROR: Failed to load MusicGen model: {e}")
-    print("Check HF access and PyTorch version compatibility.")
-    sys.exit(1)
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
 
-# ----------------------------------------------------------------------
-# HELPER: RESOURCE MONITOR
-# ----------------------------------------------------------------------
-def print_resource_usage(stage: str):
-    print(f"--- {stage} ---")
+def gpu_clean():
     if device == "cuda":
-        print(f"GPU Memory Allocated: {torch.cuda.memory_allocated() / (1024**3):.2f} GB")
-        print(f"GPU Memory Reserved : {torch.cuda.memory_reserved()  / (1024**3):.2f} GB")
-    print(f"CPU Memory Used     : {psutil.virtual_memory().percent}%")
-    print("--------------------")
+        torch.cuda.empty_cache()
+        gc.collect()
+        torch.cuda.ipc_collect()
+        torch.cuda.synchronize()
+
+gpu_clean()
+
+# ------------------------------------------------------------------ #
+#  Load MusicGen                                                      #
+# ------------------------------------------------------------------ #
+print("Loading facebook/musicgen-medium …")
+musicgen = MusicGen.get_pretrained("facebook/musicgen-medium", device=device)
+musicgen.set_generation_params(duration=10, two_step_cfg=False)
+
+# ------------------------------------------------------------------ #
+#  Resource monitor                                                   #
+# ------------------------------------------------------------------ #
+def log_resources(tag=""):
+    if tag:
+        print(f"-- {tag} --")
+    if device == "cuda":
+        alloc = torch.cuda.memory_allocated() / 1024 ** 3
+        res   = torch.cuda.memory_reserved()  / 1024 ** 3
+        print(f"GPU mem | alloc {alloc:.2f} GB  reserved {res:.2f} GB")
+    print(f"CPU mem | {psutil.virtual_memory().percent}% used")
 
-def check_vram(required_gb=3.5):
+def vram_ok(th=3.5):
     if device != "cuda":
         return True
-    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-    used  = torch.cuda.memory_allocated() / (1024**3)
-    avail = total - used
-    if avail < required_gb:
-        print(f"WARNING: Only {avail:.2f} GB VRAM free (need ≥ {required_gb} GB).")
-    return avail >= required_gb
-
-# ----------------------------------------------------------------------
-# PROMPT BUILDERS  (UNCHANGED)
-# ----------------------------------------------------------------------
-def _prompt(base, bpm, drum, synth, steps, bass, guitar, default_bass, default_gtr, vibe):
-    rhythm = f" with {steps}" if steps != "none" else vibe.format(bpm=bpm)
-    drum   = f", {drum} drums"          if drum   != "none" else ""
-    synth  = f", {synth} accents"       if synth  != "none" else ""
-    bass   = f", {bass}"                if bass   != "none" else default_bass
-    guitar = f", {guitar} guitar riffs" if guitar != "none" else default_gtr
-    return f"{base}{bass}{guitar}{drum}{synth}{rhythm} at {bpm} BPM."
-
-def set_red_hot_chili_peppers_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental funk rock",
-        bpm, drum, synth, steps, bass, guitar,
-        ", groovy basslines", ", syncopated guitar riffs",
-        "{bpm} BPM funky flow" if bpm > 120 else "groovy rhythmic flow"
-    )
-
-def set_nirvana_grunge_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental grunge",
-        bpm, drum, synth, steps, bass, guitar,
-        ", melodic basslines", ", raw distorted guitar riffs",
-        "{bpm} BPM grungy pulse" if bpm > 120 else "grungy rhythmic pulse"
-    )
-
-def set_pearl_jam_grunge_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental grunge",
-        bpm, drum, synth, steps, bass, guitar,
-        ", deep bass", ", soulful guitar leads",
-        "{bpm} BPM driving flow" if bpm > 120 else "driving rhythmic flow"
-    )
-
-def set_soundgarden_grunge_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental grunge",
-        bpm, drum, synth, steps, bass, guitar,
-        "", ", heavy sludgy guitar riffs",
-        "{bpm} BPM heavy groove" if bpm > 120 else "sludgy rhythmic groove"
-    )
-
-def set_foo_fighters_prompt(bpm, drum, synth, steps, bass, guitar):
-    styles = ["anthemic", "gritty", "melodic", "fast-paced", "driving"]
-    moods  = ["energetic", "introspective", "rebellious", "uplifting"]
-    style  = random.choice(styles)
-    mood   = random.choice(moods)
-    return _prompt(
-        "Instrumental alternative rock",
-        bpm, drum, synth, steps, bass, guitar,
-        "", f", {style} guitar riffs",
-        "{bpm} BPM powerful groove" if bpm > 120 else "catchy rhythmic groove"
-    ) + f", Foo Fighters-inspired {mood} vibe"
-
-def set_smashing_pumpkins_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental alternative rock",
-        bpm, drum, synth, steps, bass, guitar,
-        "", ", dreamy guitar textures",
-        "{bpm} BPM dynamic flow" if bpm > 120 else "dreamy rhythmic flow"
-    )
-
-def set_radiohead_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental experimental rock",
-        bpm, drum, synth, steps, bass, guitar,
-        "", ", intricate guitar layers",
-        "{bpm} BPM intricate pulse" if bpm > 120 else "intricate rhythmic pulse"
-    )
-
-def set_classic_rock_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental classic rock",
-        bpm, drum, synth, steps, bass, guitar,
-        ", groovy bass", ", bluesy electric guitars",
-        "{bpm} BPM bluesy steps" if bpm > 120 else "steady rhythmic groove"
-    )
-
-def set_alternative_rock_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental alternative rock",
-        bpm, drum, synth, steps, bass, guitar,
-        ", melodic basslines", ", distorted guitar riffs",
-        "{bpm} BPM quirky steps" if bpm > 120 else "energetic rhythmic flow"
-    )
-
-def set_post_punk_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental post-punk",
-        bpm, drum, synth, steps, bass, guitar,
-        ", driving basslines", ", jangly guitars",
-        "{bpm} BPM sharp steps" if bpm > 120 else "moody rhythmic pulse"
-    )
-
-def set_indie_rock_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental indie rock",
-        bpm, drum, synth, steps, bass, guitar,
-        "", ", jangly guitars",
-        "{bpm} BPM catchy steps" if bpm > 120 else "jangly rhythmic flow"
-    )
-
-def set_funk_rock_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental funk rock",
-        bpm, drum, synth, steps, bass, guitar,
-        ", slap bass", ", funky guitar chords",
-        "{bpm} BPM aggressive steps" if bpm > 120 else "funky rhythmic groove"
-    )
-
-def set_detroit_techno_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental Detroit techno",
-        bpm, drum, synth, steps, bass, guitar,
-        ", driving basslines", "",
-        "{bpm} BPM pulsing steps" if bpm > 120 else "deep rhythmic groove"
-    )
-
-def set_deep_house_prompt(bpm, drum, synth, steps, bass, guitar):
-    return _prompt(
-        "Instrumental deep house",
-        bpm, drum, synth, steps, bass, guitar,
-        ", deep basslines", "",
-        "{bpm} BPM soulful steps" if bpm > 120 else "laid-back rhythmic flow"
-    )
-
-# ----------------------------------------------------------------------
-# AUDIO POST-PROCESSING
-# ----------------------------------------------------------------------
+    total = torch.cuda.get_device_properties(0).total_memory / 1024 ** 3
+    free  = total - torch.cuda.memory_allocated() / 1024 ** 3
+    if free < th:
+        print(f"Only {free:.2f} GB VRAM free (<{th} GB)")
+    return free >= th
+
+# ------------------------------------------------------------------ #
+#  Prompt builders                                                    #
+# ------------------------------------------------------------------ #
+def _p(base,bpm,drum,synth,step,bass,gtr,def_bass,def_gtr,flow):
+    step_txt = f" with {step}" if step!="none" else flow.format(bpm=bpm)
+    drum_txt = f", {drum} drums"        if drum  != "none" else ""
+    syn_txt  = f", {synth} accents"     if synth != "none" else ""
+    bass_txt = f", {bass}"              if bass  != "none" else def_bass
+    gtr_txt  = f", {gtr} guitar riffs"  if gtr   != "none" else def_gtr
+    return f"{base}{bass_txt}{gtr_txt}{drum_txt}{syn_txt}{step_txt} at {bpm} BPM."
+
+def set_red_hot_chili_peppers_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental funk rock",bpm,dr,syn,st,bass,gtr,
+              ", groovy basslines",", syncopated guitar riffs",
+              "{bpm} BPM funky flow" if bpm>120 else "groovy rhythmic flow")
+
+def set_nirvana_grunge_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental grunge",bpm,dr,syn,st,bass,gtr,
+              ", melodic basslines",", raw distorted guitar riffs",
+              "{bpm} BPM grungy pulse" if bpm>120 else "grungy rhythmic pulse")
+
+def set_pearl_jam_grunge_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental grunge",bpm,dr,syn,st,bass,gtr,
+              ", deep bass",", soulful guitar leads",
+              "{bpm} BPM driving flow" if bpm>120 else "driving rhythmic flow")
+
+def set_soundgarden_grunge_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental grunge",bpm,dr,syn,st,bass,gtr,
+              "",", heavy sludgy guitar riffs",
+              "{bpm} BPM heavy groove" if bpm>120 else "sludgy rhythmic groove")
+
+def set_foo_fighters_prompt(bpm,dr,syn,st,bass,gtr):
+    styles=["anthemic","gritty","melodic","fast-paced","driving"]
+    moods=["energetic","introspective","rebellious","uplifting"]
+    return (_p("Instrumental alternative rock",bpm,dr,syn,st,bass,gtr,
+               "",f", {random.choice(styles)} guitar riffs",
+               "{bpm} BPM powerful groove" if bpm>120 else "catchy rhythmic groove")
+            +f", Foo Fighters-inspired {random.choice(moods)} vibe")
+
+def set_smashing_pumpkins_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental alternative rock",bpm,dr,syn,st,bass,gtr,
+              "",", dreamy guitar textures",
+              "{bpm} BPM dynamic flow" if bpm>120 else "dreamy rhythmic flow")
+
+def set_radiohead_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental experimental rock",bpm,dr,syn,st,bass,gtr,
+              "",", intricate guitar layers",
+              "{bpm} BPM intricate pulse" if bpm>120 else "intricate rhythmic pulse")
+
+def set_classic_rock_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental classic rock",bpm,dr,syn,st,bass,gtr,
+              ", groovy bass",", bluesy electric guitars",
+              "{bpm} BPM bluesy steps" if bpm>120 else "steady rhythmic groove")
+
+def set_alternative_rock_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental alternative rock",bpm,dr,syn,st,bass,gtr,
+              ", melodic basslines",", distorted guitar riffs",
+              "{bpm} BPM quirky steps" if bpm>120 else "energetic rhythmic flow")
+
+def set_post_punk_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental post-punk",bpm,dr,syn,st,bass,gtr,
+              ", driving basslines",", jangly guitars",
+              "{bpm} BPM sharp steps" if bpm>120 else "moody rhythmic pulse")
+
+def set_indie_rock_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental indie rock",bpm,dr,syn,st,bass,gtr,
+              "",", jangly guitars",
+              "{bpm} BPM catchy steps" if bpm>120 else "jangly rhythmic flow")
+
+def set_funk_rock_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental funk rock",bpm,dr,syn,st,bass,gtr,
+              ", slap bass",", funky guitar chords",
+              "{bpm} BPM aggressive steps" if bpm>120 else "funky rhythmic groove")
+
+def set_detroit_techno_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental Detroit techno",bpm,dr,syn,st,bass,gtr,
+              ", driving basslines","",
+              "{bpm} BPM pulsing steps" if bpm>120 else "deep rhythmic groove")
+
+def set_deep_house_prompt(bpm,dr,syn,st,bass,gtr):
+    return _p("Instrumental deep house",bpm,dr,syn,st,bass,gtr,
+              ", deep basslines","",
+              "{bpm} BPM soulful steps" if bpm>120 else "laid-back rhythmic flow")
+
+# ------------------------------------------------------------------ #
+#  Audio post-processing                                              #
+# ------------------------------------------------------------------ #
 def apply_eq(seg: AudioSegment):
     return seg.low_pass_filter(8000).high_pass_filter(80)
 
 def apply_fade(seg: AudioSegment, fin=1000, fout=1000):
     return seg.fade_in(fin).fade_out(fout)
 
-# ----------------------------------------------------------------------
-# CORE GENERATION
-# ----------------------------------------------------------------------
-def generate_music(prompt, cfg, k, p, temp,
-                   total_dur, chunk_dur, crossfade,
-                   bpm, drum, synth, steps, bass, guitar):
+# ------------------------------------------------------------------ #
+#  Core generation                                                    #
+# ------------------------------------------------------------------ #
+def generate_music(prompt,cfg,k,p,temp,
+                   total_dur,chunk_dur,xfade,
+                   bpm,drum,synth,step,bass,gtr):
 
     if not prompt.strip():
-        return None, "⚠️ Please enter a prompt."
-
-    if not check_vram(3.5):
-        return None, "⚠️ Insufficient VRAM. Lower duration."
-
-    total_dur = int(total_dur)
-    chunk_dur = int(max(5, min(chunk_dur, 15)))
-    num_chunks = max(1, total_dur // chunk_dur)
-    chunk_dur  = total_dur / num_chunks
-    overlap    = min(1.0, crossfade / 1000.0)
-    render_len = chunk_dur + overlap
-    sr         = musicgen_model.sample_rate
-    segments   = []
+        return None,"⚠️ Prompt cannot be empty."
+    if not vram_ok():
+        return None,"⚠️ Not enough VRAM."
+
+    total_dur  = int(total_dur)
+    chunk_dur  = int(max(5,min(chunk_dur,15)))
+    chunks     = max(1,total_dur//chunk_dur)
+    chunk_dur  = total_dur/chunks
+    overlap    = min(1.0,xfade/1000.0)
+    render_len = chunk_dur+overlap
+    sr         = musicgen.sample_rate
+    parts      = []
 
     torch.manual_seed(42)
     np.random.seed(42)
 
-    start = time.time()
-    for i in range(num_chunks):
-        print_resource_usage(f"Before chunk {i+1}")
-        musicgen_model.set_generation_params(
-            duration=render_len,
-            use_sampling=True,
-            top_k=k, top_p=p,
-            temperature=temp,
-            cfg_coef=cfg
-        )
-        with torch.no_grad(), autocast():
-            chunk = musicgen_model.generate([prompt], progress=False)[0]
-
-        chunk = chunk.cpu().float()
-        if chunk.dim() == 1:
-            chunk = torch.stack([chunk, chunk])
-        elif chunk.shape[0] == 1:
-            chunk = torch.cat([chunk, chunk], dim=0)
-        elif chunk.shape[0] != 2:
-            chunk = chunk[:1]
-            chunk = torch.cat([chunk, chunk], dim=0)
-
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
-            torchaudio.save(tmp.name, chunk, sr, bits_per_sample=24)
-            seg = AudioSegment.from_wav(tmp.name)
+    t0=time.time()
+    for i in range(chunks):
+        log_resources(f"before chunk {i+1}")
+        musicgen.set_generation_params(
+            duration=render_len,use_sampling=True,
+            top_k=k,top_p=p,temperature=temp,cfg_coef=cfg)
+        with torch.no_grad(),autocast():
+            audio=musicgen.generate([prompt],progress=False)[0]
+
+        audio=audio.cpu().float()
+        if audio.dim()==1:
+            audio=torch.stack([audio,audio])
+        elif audio.shape[0]==1:
+            audio=torch.cat([audio,audio])
+        elif audio.shape[0]!=2:
+            audio=torch.cat([audio[:1],audio[:1]])
+
+        with tempfile.NamedTemporaryFile(suffix=".wav",delete=False) as tmp:
+            torchaudio.save(tmp.name,audio,sr,bits_per_sample=24)
+            seg=AudioSegment.from_wav(tmp.name)
         os.unlink(tmp.name)
-        segments.append(seg)
-
-        if device == "cuda":
-            torch.cuda.empty_cache()
-            gc.collect()
-            torch.cuda.ipc_collect()
-            torch.cuda.synchronize()
-
-        print_resource_usage(f"After chunk {i+1}")
-
-    final = segments[0]
-    for seg in segments[1:]:
-        final = final.append(seg + 1, crossfade=crossfade)
-    final = final[:total_dur * 1000]
-    final = apply_fade(apply_eq(final).normalize(headroom=-9.0))
-
-    out_path = "output_cleaned.mp3"
-    final.export(out_path, format="mp3", bitrate="128k",
-                 tags={"title": "GhostAI Instrumental", "artist": "GhostAI"})
-    print_resource_usage("After final")
-    print(f"Total time: {time.time() - start:.2f}s")
-    return out_path, "✅ Done!"
-
-# ----------------------------------------------------------------------
-# CLEAR INPUTS
-# ----------------------------------------------------------------------
+        parts.append(seg)
+        gpu_clean()
+        log_resources(f"after chunk {i+1}")
+
+    track=parts[0]
+    for seg in parts[1:]:
+        track=track.append(seg+1,crossfade=xfade)
+    track=track[:total_dur*1000]
+    track=apply_fade(apply_eq(track).normalize(headroom=-9.0))
+
+    out_path="output_cleaned.mp3"
+    track.export(out_path,format="mp3",bitrate="128k",
+                 tags={"title":"GhostAI Instrumental","artist":"GhostAI"})
+    log_resources("final")
+    print(f"Time: {time.time()-t0:.1f}s")
+    return out_path,"✅ Done!"
+
 def clear_inputs():
-    return ("", 3.0, 250, 0.9, 1.0, 30, 10, 1000,
-            120, "none", "none", "none", "none", "none")
-
-# ----------------------------------------------------------------------
-# CSS
-# ----------------------------------------------------------------------
-css = """
-body{background:linear-gradient(135deg,#0A0A0A 0%,#1C2526 100%);color:#E0E0E0;font-family:'Orbitron',sans-serif}
-.header-container{text-align:center;padding:10px 20px;background:rgba(0,0,0,.9);border-bottom:1px solid #00FF9F}
-#ghost-logo{font-size:40px;animation:glitch-ghost 1.5s infinite}
-h1{color:#A100FF;font-size:24px;animation:glitch-text 2s infinite}
-p{color:#E0E0E0;font-size:12px}
-.input-container,.settings-container,.output-container{max-width:1200px;margin:20px auto;padding:20px;background:rgba(28,37,38,.8);border-radius:10px}
-.textbox{background:#1A1A1A;border:1px solid #A100FF;color:#E0E0E0}
-.genre-buttons{display:flex;justify-content:center;flex-wrap:wrap;gap:15px}
-.genre-btn,button{background:linear-gradient(45deg,#A100FF,#00FF9F);border:none;color:#0A0A0A;padding:10px 20px;border-radius:5px}
-.gradio-container{padding:20px}
-.group-container{margin-bottom:20px;padding:15px;border:1px solid #00FF9F;border-radius:8px}
-@keyframes glitch-ghost{0%{transform:translate(0,0);opacity:1}20%{transform:translate(-5px,2px);opacity:.8}100%{transform:translate(0,0);opacity:1}}
-@keyframes glitch-text{0%{transform:translate(0,0)}20%{transform:translate(-2px,1px)}100%{transform:translate(0,0)}}
-@font-face{font-family:'Orbitron';src:url('https://fonts.gstatic.com/s/orbitron/v29/yMJRMIlzdpvBhQQL_Qq7dy0.woff2') format('woff2')}
+    return ("",3.0,250,0.9,1.0,30,10,1000,
+            120,"none","none","none","none","none")
+
+# ------------------------------------------------------------------ #
+#  UI                                                                 #
+# ------------------------------------------------------------------ #
+css="""body{background:linear-gradient(135deg,#0A0A0A 0%,#1C2526 100%);color:#E0E0E0;font-family:'Arial',sans-serif}
+.header{text-align:center;padding:10px 20px;background:rgba(0,0,0,.9);border-bottom:1px solid #00FF9F}
 """
 
-# ----------------------------------------------------------------------
-# GRADIO UI
-# ----------------------------------------------------------------------
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("""
-    <div class="header-container">
-        <div id="ghost-logo">👻</div>
-        <h1>GhostAI Music Generator 🎹</h1>
-        <p>Summon the Sound of the Unknown</p>
-    </div>
-    """)
-
-    # INPUT
-    with gr.Column(elem_classes="input-container"):
-        gr.Markdown("### 🎸 Prompt Settings")
-        prompt_box = gr.Textbox(label="Instrumental Prompt ✍️",
-                                placeholder="Click a genre button or type your own prompt",
-                                lines=4, elem_classes="textbox")
-        with gr.Row(elem_classes="genre-buttons"):
-            buttons = {
-                "Red Hot Chili Peppers 🌶️"  : set_red_hot_chili_peppers_prompt,
-                "Nirvana Grunge 🎸"          : set_nirvana_grunge_prompt,
-                "Pearl Jam Grunge 🦪"        : set_pearl_jam_grunge_prompt,
-                "Soundgarden Grunge 🌑"      : set_soundgarden_grunge_prompt,
-                "Foo Fighters 🤘"            : set_foo_fighters_prompt,
-                "Smashing Pumpkins 🎃"       : set_smashing_pumpkins_prompt,
-                "Radiohead 🧠"               : set_radiohead_prompt,
-                "Classic Rock 🎸"            : set_classic_rock_prompt,
-                "Alternative Rock 🎵"        : set_alternative_rock_prompt,
-                "Post-Punk 🖤"               : set_post_punk_prompt,
-                "Indie Rock 🎤"              : set_indie_rock_prompt,
-                "Funk Rock 🕺"               : set_funk_rock_prompt,
-                "Detroit Techno 🎛️"         : set_detroit_techno_prompt,
-                "Deep House 🏠"              : set_deep_house_prompt
-            }
-            for label, fn in buttons.items():
-                gr.Button(label, elem_classes="genre-btn").click(
-                    fn,
-                    inputs=[gr.State("bpm"), gr.State("drum"), gr.State("synth"),
-                            gr.State("steps"), gr.State("bass"), gr.State("guitar")],
-                    outputs=prompt_box
-                )
-
-    # SETTINGS
-    with gr.Column(elem_classes="settings-container"):
-        gr.Markdown("### ⚙️ API Settings")
-        with gr.Group(elem_classes="group-container"):
-            cfg_scale         = gr.Slider(label="CFG Scale 🎯",  minimum=1,  maximum=10, value=3,   step=0.1)
-            top_k             = gr.Slider(label="Top-K 🔢",      minimum=10, maximum=500,value=250, step=10)
-            top_p             = gr.Slider(label="Top-P 🎰",      minimum=0,  maximum=1,  value=0.9, step=0.05)
-            temperature       = gr.Slider(label="Temperature 🔥",minimum=0.1,maximum=2,  value=1,   step=0.1)
-            total_duration    = gr.Radio (label="Length ⏳ (s)",  choices=[30,60,90,120], value=30)
-            chunk_duration    = gr.Slider(label="Chunk ⏱️ (s)",  minimum=5,  maximum=15, value=10,  step=1)
-            crossfade_duration= gr.Slider(label="Crossfade 🎶 (ms)",minimum=100,maximum=2000,value=1000,step=100)
-
-        gr.Markdown("### 🎵 Musical Controls")
-        with gr.Group(elem_classes="group-container"):
-            bpm        = gr.Slider(label="Tempo 🎵 (BPM)", minimum=60, maximum=180, value=120, step=1)
-            drum_beat  = gr.Dropdown(label="Drum Beat 🥁",
-                                     choices=["none","standard rock","funk groove","techno kick","jazz swing"], value="none")
-            synthesizer= gr.Dropdown(label="Synthesizer 🎹",
-                                     choices=["none","analog synth","digital pad","arpeggiated synth"],        value="none")
-            rhythmic_steps=gr.Dropdown(label="Rhythmic Steps 👣",
-                                       choices=["none","syncopated steps","steady steps","complex steps"],      value="none")
-            bass_style = gr.Dropdown(label="Bass Style 🎸",
-                                     choices=["none","slap bass","deep bass","melodic bass"],                   value="none")
-            guitar_style=gr.Dropdown(label="Guitar Style 🎸",
-                                     choices=["none","distorted","clean","jangle"],                              value="none")
-
-        with gr.Row(elem_classes="action-buttons"):
-            gen_btn = gr.Button("Generate Music 🚀")
-            clr_btn = gr.Button("Clear Inputs 🧹")
-
-    # OUTPUT
-    with gr.Column(elem_classes="output-container"):
-        gr.Markdown("### 🎧 Output")
-        out_audio = gr.Audio(label="Generated Track 🎵", type="filepath")
-        status    = gr.Textbox(label="Status 📢", interactive=False)
-
-    # ACTIONS
-    gen_btn.click(
-        generate_music,
-        inputs=[prompt_box, cfg_scale, top_k, top_p, temperature,
-                total_duration, chunk_duration, crossfade_duration,
-                bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style],
-        outputs=[out_audio, status]
-    )
-    clr_btn.click(
-        clear_inputs,
-        inputs=None,
-        outputs=[prompt_box, cfg_scale, top_k, top_p, temperature,
-                 total_duration, chunk_duration, crossfade_duration,
-                 bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style]
-    )
-
-# ----------------------------------------------------------------------
-# LAUNCH
-# ----------------------------------------------------------------------
-app = demo.launch(share=False, inbrowser=False, show_error=True)
-
-# Disable OpenAPI docs (HF Spaces hardening)
+    gr.HTML('<div class="header"><span style="font-size:32px">👻</span> <b>GhostAI Music Generator</b></div>')
+
+    prompt_box=gr.Textbox(label="Prompt",lines=4)
+    cfg_scale =gr.Slider(1,10,3,label="CFG")
+    top_k     =gr.Slider(10,500,250,step=10,label="Top-K")
+    top_p     =gr.Slider(0,1,0.9,step=0.05,label="Top-P")
+    temp      =gr.Slider(0.1,2,1,step=0.1,label="Temperature")
+    total_dur =gr.Radio([30,60,90,120],value=30,label="Length (s)")
+    chunk_dur =gr.Slider(5,15,10,step=1,label="Chunk Length (s)")
+    xfade     =gr.Slider(100,2000,1000,step=100,label="Cross-fade (ms)")
+
+    bpm   =gr.Slider(60,180,120,label="BPM")
+    drum  =gr.Dropdown(["none","standard rock","funk groove","techno kick","jazz swing"],value="none",label="Drum")
+    synth =gr.Dropdown(["none","analog synth","digital pad","arpeggiated synth"],value="none",label="Synth")
+    step  =gr.Dropdown(["none","syncopated steps","steady steps","complex steps"],value="none",label="Steps")
+    bass  =gr.Dropdown(["none","slap bass","deep bass","melodic bass"],value="none",label="Bass")
+    gtr   =gr.Dropdown(["none","distorted","clean","jangle"],value="none",label="Guitar")
+
+    # Genre buttons
+    btns={
+        "RHCP 🌶️":set_red_hot_chili_peppers_prompt,
+        "Nirvana 🎸":set_nirvana_grunge_prompt,
+        "Pearl Jam 🦪":set_pearl_jam_grunge_prompt,
+        "Soundgarden 🌑":set_soundgarden_grunge_prompt,
+        "Foo Fighters 🤘":set_foo_fighters_prompt,
+        "Smashing Pumpkins 🎃":set_smashing_pumpkins_prompt,
+        "Radiohead 🧠":set_radiohead_prompt,
+        "Classic Rock 🎸":set_classic_rock_prompt,
+        "Alt Rock 🎵":set_alternative_rock_prompt,
+        "Post-Punk 🖤":set_post_punk_prompt,
+        "Indie Rock 🎤":set_indie_rock_prompt,
+        "Funk Rock 🕺":set_funk_rock_prompt,
+        "Detroit Techno 🎛️":set_detroit_techno_prompt,
+        "Deep House 🏠":set_deep_house_prompt
+    }
+    with gr.Row():
+        for label,fn in btns.items():
+            gr.Button(label).click(
+                fn,
+                inputs=[bpm,drum,synth,step,bass,gtr],
+                outputs=prompt_box
+            )
+
+    gen=gr.Button("Generate 🎼")
+    clr=gr.Button("Clear")
+
+    audio_out=gr.Audio(type="filepath")
+    status   =gr.Textbox(interactive=False,label="Status")
+
+    gen.click(generate_music,
+              inputs=[prompt_box,cfg_scale,top_k,top_p,temp,
+                      total_dur,chunk_dur,xfade,
+                      bpm,drum,synth,step,bass,gtr],
+              outputs=[audio_out,status])
+    clr.click(clear_inputs,None,
+              [prompt_box,cfg_scale,top_k,top_p,temp,
+               total_dur,chunk_dur,xfade,
+               bpm,drum,synth,step,bass,gtr])
+
+app=demo.launch(share=False,show_error=True)
 try:
-    fastapi_app = demo._server.app
-    fastapi_app.docs_url    = None
-    fastapi_app.redoc_url   = None
-    fastapi_app.openapi_url = None
+    demo._server.app.docs_url=demo._server.app.redoc_url=demo._server.app.openapi_url=None
 except Exception:
     pass