Update app.py

app.py

@@ -6,14 +6,11 @@ import librosa
 import numpy as np
 import soundfile as sf
 from pydub import AudioSegment
-from pydub.silence import split_on_silence
 from moviepy.editor import AudioFileClip, ImageClip, CompositeVideoClip, ColorClip
 import subprocess
 from pathlib import Path
 import sys
 import yt_dlp
-import json
-from datetime import datetime
 import pyloudnorm as pyln
 
 # --- OPTIONAL: MIDI IMPORT ---
@@ -29,14 +26,17 @@ import PIL.Image
 if not hasattr(PIL.Image, 'ANTIALIAS'):
     PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
 
-# --- CONFIG ---
+# --- CONFIGURATION ---
 OUTPUT_DIR = Path("nightpulse_output")
 TEMP_DIR = Path("temp_processing")
 
-# -----------------------------
-# Startup Checks
-# -----------------------------
+
+# ==========================================
+# 1. SYSTEM UTILITIES
+# ==========================================
+
 def check_ffmpeg():
+    """Checks if FFmpeg is installed and accessible."""
     if shutil.which("ffmpeg") is None:
         print("CRITICAL WARNING: FFmpeg not found in system PATH.")
         return False
@@ -44,24 +44,86 @@ def check_ffmpeg():
 
 check_ffmpeg()
 
-# -----------------------------
-# Key Detection
-# -----------------------------
+
+# ==========================================
+# 2. HELPER FUNCTIONS
+# ==========================================
+
+def download_from_url(url):
+    """Downloads audio from YouTube/SoundCloud using yt-dlp."""
+    if not url:
+        return None
+        
+    if TEMP_DIR.exists():
+        shutil.rmtree(TEMP_DIR, ignore_errors=True)
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
+    ydl_opts = {
+        "format": "bestaudio/best",
+        "outtmpl": str(TEMP_DIR / "%(title)s.%(ext)s"),
+        "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": "192"}],
+        "quiet": True,
+        "no_warnings": True,
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        filename = ydl.prepare_filename(info)
+        final_path = Path(filename).with_suffix(".wav")
+        return str(final_path)
+
+
+def safe_copy_to_temp(audio_file: str) -> str:
+    """Copies uploaded file to temp with a safe filename."""
+    src = Path(audio_file)
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    safe_stem = "".join(c if c.isalnum() or c in "._-" else "_" for c in src.stem)
+    dst = TEMP_DIR / f"{safe_stem}{src.suffix.lower()}"
+    try:
+        shutil.copy(src, dst)
+    except Exception:
+        return str(src)
+    return str(dst)
+
+
+def ensure_wav(input_path: str) -> str:
+    """Converts MP3/M4A to WAV for Demucs compatibility."""
+    p = Path(input_path)
+    if p.suffix.lower() == ".wav":
+        return str(p)
+
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    out = TEMP_DIR / f"{p.stem}.wav"
+    
+    audio = AudioSegment.from_file(str(p))
+    audio.export(str(out), format="wav")
+    return str(out)
+
+
+# ==========================================
+# 3. AI ENGINES (Demucs, MIDI, Key)
+# ==========================================
+
 def detect_key(audio_path):
+    """Estimates musical key using Librosa Chroma."""
     try:
         y, sr = librosa.load(str(audio_path), sr=None, duration=60)
         chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
         chroma_vals = np.sum(chroma, axis=1)
+        
         maj_profile = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88]
         min_profile = [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]
         pitches = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+        
         best_score = -1
         best_key = "Unknown"
+        
         for i in range(12):
             p_maj = np.roll(maj_profile, i)
             p_min = np.roll(min_profile, i)
             score_maj = np.corrcoef(chroma_vals, p_maj)[0, 1]
             score_min = np.corrcoef(chroma_vals, p_min)[0, 1]
+            
             if score_maj > best_score:
                 best_score = score_maj
                 best_key = f"{pitches[i]}maj"
@@ -72,107 +134,124 @@ def detect_key(audio_path):
     except Exception:
         return "Unknown"
 
-# -----------------------------
-# Helpers
-# -----------------------------
-def download_from_url(url):
-    if not url: return None
-    if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR, ignore_errors=True)
-    TEMP_DIR.mkdir(parents=True, exist_ok=True)
-    ydl_opts = {
-        "format": "bestaudio/best",
-        "outtmpl": str(TEMP_DIR / "%(title)s.%(ext)s"),
-        "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": "192"}],
-        "quiet": True, "no_warnings": True,
-    }
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(url, download=True)
-        filename = ydl.prepare_filename(info)
-        return str(Path(filename).with_suffix(".wav"))
-
-def safe_copy_to_temp(audio_file: str) -> str:
-    src = Path(audio_file)
-    TEMP_DIR.mkdir(parents=True, exist_ok=True)
-    safe_stem = "".join(c if c.isalnum() or c in "._-" else "_" for c in src.stem)
-    dst = TEMP_DIR / f"{safe_stem}{src.suffix.lower()}"
-    try: shutil.copy(src, dst)
-    except Exception: return str(src)
-    return str(dst)
-
-def ensure_wav(input_path: str) -> str:
-    p = Path(input_path)
-    if p.suffix.lower() == ".wav": return str(p)
-    TEMP_DIR.mkdir(parents=True, exist_ok=True)
-    out = TEMP_DIR / f"{p.stem}.wav"
-    AudioSegment.from_file(str(p)).export(str(out), format="wav")
-    return str(out)
 
-# -----------------------------
-# Demucs + MIDI
-# -----------------------------
 def run_demucs(cmd):
+    """Runs the Demucs separation command."""
     p = subprocess.run(cmd, capture_output=True, text=True)
-    if p.returncode != 0: raise gr.Error(f"Demucs Error:\n{p.stderr[-2000:]}")
+    if p.returncode != 0:
+        raise gr.Error(f"Demucs Error:\n{p.stderr[-2000:]}")
     return p.stdout
 
+
 def extract_midi(audio_path, out_path):
-    if not MIDI_AVAILABLE: return
+    """Converts audio to MIDI using Spotify Basic Pitch (Fixed Logic)."""
+    if not MIDI_AVAILABLE:
+        return
     out_dir = out_path.parent
-    name = out_path.stem
-    predict_and_save([str(audio_path)], str(out_dir), True, False, False, sonify_midi=False, save_midi_path=str(out_path))
-    expected = out_dir / f"{name}_basic_pitch.mid"
-    if expected.exists(): shutil.move(expected, out_path)
-
-# -----------------------------
-# Audio Processing
-# -----------------------------
+    
+    # 1. Run prediction (Standard arguments only)
+    predict_and_save(
+        audio_path_list=[str(audio_path)],
+        output_directory=str(out_dir),
+        save_midi=True,
+        save_model_outputs=False,
+        save_notes=False,
+        sonify_midi=False
+    )
+    
+    # 2. Find and Rename
+    # Basic Pitch creates: <original_name>_basic_pitch.mid
+    src_name = audio_path.stem
+    generated_file = out_dir / f"{src_name}_basic_pitch.mid"
+    
+    if generated_file.exists():
+        if out_path.exists():
+            try:
+                os.remove(out_path)
+            except OSError:
+                pass # Continue if we can't delete
+        shutil.move(str(generated_file), str(out_path))
+
+
+# ==========================================
+# 4. AUDIO PROCESSING
+# ==========================================
+
 def apply_loudness(seg: AudioSegment, mode: str, target: float = -14.0) -> AudioSegment:
     mode = (mode or "none").lower().strip()
+    
     if mode == "none": return seg
     if mode == "peak": return seg.normalize()
     if mode == "rms":
         change = target - seg.dBFS
         return seg.apply_gain(change)
+        
     if mode == "lufs":
-        samples = np.array(seg.get_array_of_samples())
-        if seg.channels == 2: samples = samples.reshape((-1, 2))
-        samples_float = samples.astype(np.float64) / 32768.0
-        meter = pyln.Meter(seg.frame_rate) 
-        loudness = meter.integrated_loudness(samples_float)
-        if loudness == -float('inf'): return seg
-        gain_db = max(min(target - loudness, 20.0), -20.0)
-        return seg.apply_gain(gain_db)
+        try:
+            samples = np.array(seg.get_array_of_samples())
+            if seg.channels == 2:
+                samples = samples.reshape((-1, 2))
+            samples_float = samples.astype(np.float64) / 32768.0
+            
+            meter = pyln.Meter(seg.frame_rate) 
+            loudness = meter.integrated_loudness(samples_float)
+            
+            if loudness == -float('inf'): return seg
+            
+            gain_db = target - loudness
+            gain_db = max(min(gain_db, 20.0), -20.0)
+            return seg.apply_gain(gain_db)
+        except Exception:
+            return seg
     return seg
 
+
 def extract_one_shots(drum_stem_path, bpm, out_dir, loudness_mode, target_dbfs):
     y, sr = librosa.load(str(drum_stem_path), sr=None)
     onset_frames = librosa.onset.onset_detect(y=y, sr=sr, backtrack=True)
     onset_times = librosa.frames_to_time(onset_frames, sr=sr)
+    
     audio = AudioSegment.from_wav(str(drum_stem_path))
     hits = []
+    
     for i in range(len(onset_times)):
         start_ms = int(onset_times[i] * 1000)
-        dur = min(int(onset_times[i+1] * 1000) - start_ms, 450) if i < len(onset_times) - 1 else 450
+        if i < len(onset_times) - 1:
+            next_ms = int(onset_times[i+1] * 1000)
+            dur = min(next_ms - start_ms, 450)
+        else:
+            dur = 450
+            
         hit = audio[start_ms : start_ms + dur]
         if hit.rms > 100 and len(hit) > 30:
             hits.append(hit.fade_out(10))
+            
     hits.sort(key=lambda x: x.rms, reverse=True)
     hits = hits[:32]
+    
+    out_dir.mkdir(parents=True, exist_ok=True)
     for i, hit in enumerate(hits):
         hit = apply_loudness(hit, mode=loudness_mode, target=target_dbfs)
         hit.export(out_dir / f"DrumShot_{i+1:02d}.wav", format="wav")
 
-# -----------------------------
-# Loop Engine
-# -----------------------------
-def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_lengths, 
-                         hop_bars, loops_per, top_k, fade_ms, loop_seam, seam_ms, 
-                         min_bar_gap, loudness_mode, target_dbfs, out_dir):
-    if not stem_path.exists(): return []
+
+# ==========================================
+# 5. LOOP ENGINE
+# ==========================================
+
+def make_quantized_loops(
+    stem_path, stem_name, bpm, key, bar_starts_ms, bar_lengths, 
+    hop_bars, loops_per, top_k, fade_ms, loop_seam, seam_ms, 
+    min_bar_gap, loudness_mode, target_dbfs, out_dir
+):
+    if not stem_path.exists():
+        return []
+        
     audio = AudioSegment.from_wav(str(stem_path))
     ms_per_bar = (240000.0 / bpm) 
-    trim_win = 8
+    trim_win = 8 
     extra_ms = (seam_ms if loop_seam else 0) + (trim_win * 2)
+    
     grid = bar_starts_ms[::max(1, int(hop_bars))] if bar_starts_ms else []
     candidates = []
 
@@ -187,8 +266,10 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
 
     candidates.sort(key=lambda x: x[0], reverse=True)
     if top_k > 0: candidates = candidates[:int(top_k)]
+    
     selected = []
     used_bars = []
+    
     for score, start, blen in candidates:
         b_idx = int(np.argmin([abs(start - b) for b in bar_starts_ms]))
         if any(abs(b_idx - u) < min_bar_gap for u in used_bars): continue
@@ -197,12 +278,16 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
         if len(selected) >= loops_per: break
 
     exported = []
+    out_dir.mkdir(parents=True, exist_ok=True)
+    
     for i, (_, start, blen) in enumerate(selected, 1):
         t_dur = int(ms_per_bar * blen)
         x_dur = t_dur + extra_ms
         loop = audio[start : start + x_dur]
-        loop = loop[trim_win : -trim_win] if len(loop) > trim_win*2 else loop
-        if loop_seam and len(loop) > seam_ms*2:
+        
+        if len(loop) > trim_win * 2: loop = loop[trim_win : -trim_win]
+        
+        if loop_seam and len(loop) > seam_ms * 2:
             head = loop[:seam_ms]
             tail = loop[-seam_ms:]
             body = loop[seam_ms:-seam_ms]
@@ -210,30 +295,43 @@ def make_quantized_loops(stem_path, stem_name, bpm, key, bar_starts_ms, bar_leng
         else:
             loop = loop[:t_dur]
             if fade_ms > 0: loop = loop.fade_in(fade_ms).fade_out(fade_ms)
+            
         loop = loop[:t_dur] 
         loop = apply_loudness(loop, mode=loudness_mode, target=target_dbfs)
+        
         fname = f"{bpm}BPM_{key}_{stem_name}_L{blen}bars_{i:02d}.wav"
         out_path = out_dir / fname
         loop.export(out_path, format="wav")
         exported.append(out_path)
+        
     return exported
 
-# -----------------------------
-# Phase 1: Analyze
-# -----------------------------
+
+# ==========================================
+# 6. MAIN LOGIC
+# ==========================================
+
 def analyze_and_separate(file_in, url_in, mode, manual_bpm):
     if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR, ignore_errors=True)
     TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    
     fpath = download_from_url(url_in) if url_in else file_in
-    if not fpath: raise gr.Error("No Audio Source")
+    if not fpath: raise gr.Error("No Audio Source Provided.")
     fpath = safe_copy_to_temp(fpath)
     fpath = ensure_wav(fpath)
     
-    bpm = manual_bpm if manual_bpm else int(librosa.beat.beat_track(y=librosa.load(fpath, duration=60)[0])[0])
+    if manual_bpm:
+        bpm = int(manual_bpm)
+    else:
+        y, sr = librosa.load(fpath, duration=60)
+        tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
+        bpm = int(tempo[0] if np.ndim(tempo) > 0 else tempo)
+        
     key = detect_key(fpath)
     
     cmd = [sys.executable, "-m", "demucs", "-n", "htdemucs_6s" if mode=="6stem" else "htdemucs", "--out", str(TEMP_DIR), fpath]
     if mode == "2stem": cmd += ["--two-stems", "vocals"]
+    
     run_demucs(cmd)
     
     track_dir = next((TEMP_DIR / ("htdemucs_6s" if mode=="6stem" else "htdemucs")).iterdir())
@@ -243,28 +341,27 @@ def analyze_and_separate(file_in, url_in, mode, manual_bpm):
         "Piano": track_dir/"piano.wav", "Guitar": track_dir/"guitar.wav",
         "Instrumental": track_dir/"no_vocals.wav"
     }
-    valid = [k for k,v in stem_map.items() if v.exists()]
-    loops_def = [s for s in valid if s != "Vocals"]
     
-    # UI Updates for Checkboxes
-    cb_export = gr.CheckboxGroup(choices=valid, value=valid)
-    cb_loops = gr.CheckboxGroup(choices=valid, value=loops_def)
+    valid_stems = [k for k,v in stem_map.items() if v.exists()]
+    loops_defaults = [s for s in valid_stems if s != "Vocals"]
     
-    # Previews
-    p_d = str(stem_map["Drums"]) if "Drums" in valid else None
-    p_b = str(stem_map["Bass"]) if "Bass" in valid else None
-    p_v = str(stem_map["Vocals"]) if "Vocals" in valid else None
+    cb_export = gr.CheckboxGroup(choices=valid_stems, value=valid_stems)
+    cb_loops = gr.CheckboxGroup(choices=valid_stems, value=loops_defaults)
     
-    return (p_d, p_b, p_v, f"**Detected:** {bpm} BPM | **Key:** {key}", bpm, key, str(track_dir), mode, cb_export, cb_loops)
-
-# -----------------------------
-# Phase 2: Package (With Smart Video Resize)
-# -----------------------------
-def package_and_export(track_folder, bpm, key, stem_mode, art, 
-                       ex_stems, loop_stems, do_midi, do_oneshots, do_vocal_chops,
-                       loops_per, bars, hop, topk, fadems, loopseam, seamms, mingap,
-                       loud_mode, loud_target, vid_fmt):
+    p_d = str(stem_map["Drums"]) if "Drums" in valid_stems else None
+    p_b = str(stem_map["Bass"]) if "Bass" in valid_stems else None
+    p_v = str(stem_map["Vocals"]) if "Vocals" in valid_stems else None
     
+    info_text = f"### 🎵 Detected: {bpm} BPM | Key: {key}"
+    return (p_d, p_b, p_v, info_text, bpm, key, str(track_dir), mode, cb_export, cb_loops)
+
+
+def package_and_export(
+    track_folder, bpm, key, stem_mode, art, 
+    ex_stems, loop_stems, do_midi, do_oneshots, do_vocal_chops,
+    loops_per, bars, hop, topk, fadems, loopseam, seamms, mingap,
+    loud_mode, loud_target, vid_fmt
+):
     if not track_folder: raise gr.Error("Run Phase 1 First.")
     
     if OUTPUT_DIR.exists(): shutil.rmtree(OUTPUT_DIR, ignore_errors=True)
@@ -279,13 +376,15 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
         "Instrumental": t_dir/"no_vocals.wav"
     }
     
-    # Exports (Stems, MIDI, Shots, Loops)
     for s in ex_stems:
         if stems.get(s, Path("x")).exists():
             shutil.copy(stems[s], OUTPUT_DIR/"Stems"/f"{bpm}BPM_{key}_{s}.wav")
+
     if do_midi and MIDI_AVAILABLE:
         for s in ["Bass", "Piano", "Guitar", "Other"]:
-            if stems.get(s, Path("x")).exists(): extract_midi(stems[s], OUTPUT_DIR/"MIDI"/f"{bpm}BPM_{key}_{s}.mid")
+            if stems.get(s, Path("x")).exists():
+                extract_midi(stems[s], OUTPUT_DIR/"MIDI"/f"{bpm}BPM_{key}_{s}.mid")
+
     if do_oneshots and stems.get("Drums", Path("x")).exists():
         extract_one_shots(stems["Drums"], bpm, OUTPUT_DIR/"OneShots", loud_mode, loud_target)
     
@@ -296,23 +395,33 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
     y, sr = librosa.load(str(grid_src), sr=22050, duration=240)
     _, beats = librosa.beat.beat_track(y=y, sr=sr)
     beat_times = librosa.frames_to_time(beats, sr=sr)
-    bar_starts = [int(t*1000) for t in beat_times[::4]] if len(beat_times) >= 8 else [int(i * (240000/bpm)) for i in range(int((len(y)/sr)/(240/bpm)))]
+    
+    if len(beat_times) < 8:
+        ms_per_beat = 60000.0 / bpm
+        total_len_ms = (len(y) / sr) * 1000
+        bar_starts = [int(i * (ms_per_beat * 4)) for i in range(int(total_len_ms // (ms_per_beat * 4)))]
+    else:
+        bar_starts = [int(t*1000) for t in beat_times[::4]]
+        
     bar_ints = sorted([int(b) for b in bars])
     
     all_loops = {}
     for s in loop_stems:
         if s == "Vocals" and do_vocal_chops: continue
         if stems.get(s, Path("x")).exists():
-            exported = make_quantized_loops(stems[s], s, bpm, key, bar_starts, bar_ints, hop, loops_per, topk, 
-                                            fadems, loopseam, seamms, mingap, loud_mode, loud_target, OUTPUT_DIR/"Loops")
+            exported = make_quantized_loops(
+                stems[s], s, bpm, key, bar_starts, bar_ints, hop, loops_per, topk, 
+                fadems, loopseam, seamms, mingap, loud_mode, loud_target, OUTPUT_DIR/"Loops"
+            )
             all_loops[s] = exported
 
     if do_vocal_chops and stems.get("Vocals", Path("x")).exists():
-        exported = make_quantized_loops(stems["Vocals"], "Vocals_Chop", bpm, key, bar_starts, [1, 2], 1, 30, 0, 
-                                        fadems, False, 0, 0, loud_mode, loud_target, OUTPUT_DIR/"Vocal_Chops")
+        exported = make_quantized_loops(
+            stems["Vocals"], "Vocals_Chop", bpm, key, bar_starts, [1, 2], 1, 30, 0, 
+            fadems, False, 0, 0, loud_mode, loud_target, OUTPUT_DIR/"Vocal_Chops"
+        )
         all_loops["Vocals"] = exported
 
-    # --- SMART VIDEO ENGINE ---
     vid_path = None
     if art and any(all_loops.values()):
         for k in ["Other", "Synths", "Piano", "Guitar", "Instrumental", "Bass", "Drums"]:
@@ -321,15 +430,10 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
                 break
         
         print(f"Rendering Video ({vid_fmt})...")
-        res_map = {
-            "9:16 (TikTok/Reels)": (1080, 1920),
-            "16:9 (YouTube)": (1920, 1080),
-            "1:1 (Square)": (1080, 1080)
-        }
+        res_map = {"9:16 (TikTok/Reels)": (1080, 1920), "16:9 (YouTube)": (1920, 1080), "1:1 (Square)": (1080, 1080)}
         w, h = res_map.get(vid_fmt, (1080, 1920))
         
         clip = AudioFileClip(str(a_path))
-        
         bg_clip = ImageClip(art)
         img_w, img_h = bg_clip.size
         
@@ -338,123 +442,113 @@ def package_and_export(track_folder, bpm, key, stem_mode, art,
         
         if img_aspect > target_aspect:
             bg_clip = bg_clip.resize(height=h)
-            new_w = bg_clip.w
-            crop_x = (new_w - w) // 2
+            crop_x = (bg_clip.w - w) // 2
             bg_clip = bg_clip.crop(x1=crop_x, width=w)
         else:
             bg_clip = bg_clip.resize(width=w)
-            new_h = bg_clip.h
-            crop_y = (new_h - h) // 2
+            crop_y = (bg_clip.h - h) // 2
             bg_clip = bg_clip.crop(y1=crop_y, height=h)
 
         bg_clip = bg_clip.resize(lambda t: 1 + 0.02*t).set_position("center").set_duration(clip.duration)
-        
-        bar_h = 20
-        bar = ColorClip(size=(w, bar_h), color=(255,255,255)).set_opacity(0.8)
+        bar = ColorClip(size=(w, 20), color=(255,255,255)).set_opacity(0.8)
         bar = bar.set_position(lambda t: (int(-w + w*(t/clip.duration)), h - 50))
         bar = bar.set_duration(clip.duration)
         
         final = CompositeVideoClip([bg_clip, bar], size=(w,h))
         final.audio = clip
-        vid_path = str(OUTPUT_DIR/"Promo.mp4")
+        vid_path = str(OUTPUT_DIR / "Promo.mp4")
         final.write_videofile(vid_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
 
     z_path = "NightPulse_Ultimate.zip"
     with zipfile.ZipFile(z_path, "w") as zf:
         for r, _, fs in os.walk(OUTPUT_DIR):
-            for f in fs: zf.write(Path(r)/f, Path(r).relative_to(OUTPUT_DIR)/f)
+            for f in fs:
+                zf.write(Path(r)/f, Path(r).relative_to(OUTPUT_DIR)/f)
             
     return z_path, vid_path
 
-# -----------------------------
-# UI Layout
-# -----------------------------
+
+# ==========================================
+# 7. UI WIRING
+# ==========================================
+
 with gr.Blocks(title="Night Pulse | Ultimate") as app:
     gr.Markdown("# 🎹 Night Pulse | Studio Ultimate")
     
-    # Hidden State
     folder = gr.State()
     bpm_st = gr.State()
     key_st = gr.State()
     mode_st = gr.State()
 
     with gr.Row():
-        # --- COL 1: CONFIGURATION ---
         with gr.Column(scale=1):
-            gr.Markdown("### 1. Setup & Source")
+            gr.Markdown("### 1. Source Material")
             with gr.Tabs():
-                with gr.Tab("Link"): url = gr.Textbox(label="YouTube/SC URL")
-                with gr.Tab("File"): file = gr.Audio(type="filepath", label="Upload File")
+                with gr.Tab("Link"):
+                    url = gr.Textbox(label="YouTube/SoundCloud URL")
+                with gr.Tab("File"):
+                    file = gr.Audio(type="filepath", label="Upload File")
             
-            mode = gr.Dropdown([("2 Stems (Vox+Inst)", "2stem"), ("4 Stems (Basic)", "4stem"), ("6 Stems (Full)", "6stem")], value="6stem", label="Separation Model")
+            mode = gr.Dropdown([("2 Stems (Vox+Inst)", "2stem"), ("4 Stems (Basic)", "4stem"), ("6 Stems (Full)", "6stem")], value="6stem", label="Separation Quality")
             mbpm = gr.Number(label="Manual BPM (Optional)")
             
-            gr.Markdown("#### Extraction Targets")
             with gr.Row():
                 do_midi = gr.Checkbox(label="MIDI", value=True)
                 do_oneshots = gr.Checkbox(label="Drum Shots", value=True)
                 do_vox = gr.Checkbox(label="Vocal Chops", value=True)
 
-            btn1 = gr.Button("🚀 Phase 1: Analyze & Separate", variant="primary", scale=2)
+            btn1 = gr.Button("🚀 Phase 1: Analyze & Separate", variant="primary")
 
-        # --- COL 2: REFINEMENT (Dynamic) ---
         with gr.Column(scale=1):
-            gr.Markdown("### 2. Select & Refine")
-            info = gr.Markdown("Waiting for analysis...")
-            
-            # Dynamic checkboxes
-            ex_stems = gr.CheckboxGroup(label="Export Full Stems")
-            lp_stems = gr.CheckboxGroup(label="Generate Loops For")
+            gr.Markdown("### 2. Refine")
+            info = gr.Markdown("Waiting...")
+            ex_stems = gr.CheckboxGroup(label="Export Stems")
+            lp_stems = gr.CheckboxGroup(label="Loop Targets")
             
-            gr.Markdown("#### Preview")
             with gr.Row():
-                p1 = gr.Audio(label="Drums", show_label=True)
-                p2 = gr.Audio(label="Bass", show_label=True)
-                p3 = gr.Audio(label="Vocals", show_label=True)
+                p1 = gr.Audio(label="Drums")
+                p2 = gr.Audio(label="Bass")
+                p3 = gr.Audio(label="Vocals")
 
     gr.Markdown("---")
     
     with gr.Row():
-        # --- COL 3: EXPORT SETTINGS ---
         with gr.Column(scale=1):
-            gr.Markdown("### 3. Loop Engine & Video")
+            gr.Markdown("### 3. Engine")
             with gr.Row():
                 loops_per = gr.Slider(1, 40, 12, 1, label="Loops Count")
                 hop = gr.Slider(1, 8, 1, 1, label="Hop (Bars)")
-            bars = gr.CheckboxGroup(["1","2","4","8"], ["4","8"], label="Loop Lengths")
+            bars = gr.CheckboxGroup(["1","2","4","8"], ["4","8"], label="Lengths")
             
-            art = gr.Image(type="filepath", label="Cover Art (Auto-Resize)")
+            art = gr.Image(type="filepath", label="Cover Art")
             vid_fmt = gr.Dropdown(["9:16 (TikTok/Reels)", "16:9 (YouTube)", "1:1 (Square)"], value="9:16 (TikTok/Reels)", label="Video Format")
 
-            with gr.Accordion("Advanced Audio", open=False):
+            with gr.Accordion("Advanced", open=False):
                 l_mode = gr.Dropdown(["none", "peak", "rms", "lufs"], "lufs", label="Norm Mode")
-                l_target = gr.Slider(-24, -5, -14, 1, label="Target Level")
+                l_target = gr.Slider(-24, -5, -14, 1, label="Target")
                 fadems = gr.Slider(0, 50, 10, label="Fade ms")
-                seam = gr.Checkbox(True, label="Loop Seam")
+                seam = gr.Checkbox(True, label="Seamless")
                 seamms = gr.Slider(0, 100, 20, label="Seam ms")
                 mingap = gr.Slider(0,16,4, label="De-Dup Gap")
                 topk = gr.Slider(0, 100, 30, 1, label="Top K")
 
-            btn2 = gr.Button("📦 Phase 2: Package Ultimate Pack", variant="primary")
+            btn2 = gr.Button("📦 Phase 2: Package", variant="primary")
 
-        # --- COL 4: OUTPUT ---
         with gr.Column(scale=1):
-            gr.Markdown("### 4. Final Downloads")
-            z_out = gr.File(label="Complete Pack (Zip)")
-            v_out = gr.Video(label="Social Media Promo")
+            gr.Markdown("### 4. Download")
+            z_out = gr.File(label="Zip Pack")
+            v_out = gr.Video(label="Promo Video")
 
-    # Wire up
     def p1_wrap(f, u, m, b):
-        d, ba, v, bpm, key, pth, md, c1, c2 = analyze_and_separate(f, u, m, b)
-        return d, ba, v, f"### 🎵 Detected: {bpm} BPM | Key: {key}", bpm, key, pth, md, c1, c2
+        d, ba, v, info_txt, bpm, key, pth, md, c1, c2 = analyze_and_separate(f, u, m, b)
+        return d, ba, v, info_txt, bpm, key, pth, md, c1, c2
         
     btn1.click(p1_wrap, [file, url, mode, mbpm], [p1, p2, p3, info, bpm_st, key_st, folder, mode_st, ex_stems, lp_stems])
     
-    # Corrected variable name: 'seam' instead of 'loopseam'
     btn2.click(package_and_export, 
                [folder, bpm_st, key_st, mode_st, art, ex_stems, lp_stems, do_midi, do_oneshots, do_vox,
                 loops_per, bars, hop, topk, fadems, seam, seamms, mingap, l_mode, l_target, vid_fmt], 
                [z_out, v_out])
 
 if __name__ == "__main__":
-    app.launch(ssr_mode=False)
+    app.launch()