Update app.py

app.py

@@ -1,252 +1,318 @@
 import os
-import io
 import math
 import tempfile
 import warnings
-from typing import List, Tuple, Dict
+from typing import Dict, List, Tuple
 
 import gradio as gr
 import numpy as np
 import pandas as pd
 import librosa
-import soundfile as sf
 
 warnings.filterwarnings("ignore", category=UserWarning)
 warnings.filterwarnings("ignore", category=FutureWarning)
 
-# ------------------------------
-# Key detection (Krumhansl-Schmuckler)
-# ------------------------------
+# =========================================================
+# Key detection profiles (two well-known sets) for voting
+# =========================================================
 
-MAJOR_PROFILE = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88])
-MINOR_PROFILE = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17])
+# Krumhansl-Schmuckler (Harte)
+KS_MAJOR = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88], dtype=float)
+KS_MINOR = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17], dtype=float)
+
+# Temperley / Kostka–Payne (scaled roughly to similar ranges)
+TP_MAJOR = np.array([0.748, 0.060, 0.488, 0.082, 0.670, 0.460, 0.096, 0.715, 0.104, 0.366, 0.057, 0.400], dtype=float) * 10
+TP_MINOR = np.array([0.712, 0.084, 0.474, 0.618, 0.049, 0.460, 0.105, 0.670, 0.461, 0.044, 0.373, 0.330], dtype=float) * 10
 
-# Pitch-class order used across the app
 PITCHES_FLAT = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']
 
-# Prefer flat spellings to align with common Camelot mappings
-MAJOR_NAMES = [f"{p} major" for p in PITCHES_FLAT]
-MINOR_NAMES = [f"{p} minor" for p in PITCHES_FLAT]
+CAMELOT_MAJOR = {'B':'1B','F#':'2B','Gb':'2B','Db':'3B','C#':'3B','Ab':'4B','Eb':'5B','Bb':'6B','F':'7B','C':'8B','G':'9B','D':'10B','A':'11B','E':'12B'}
+CAMELOT_MINOR = {'Ab':'1A','G#':'1A','Eb':'2A','D#':'2A','Bb':'3A','A#':'3A','F':'4A','C':'5A','G':'6A','D':'7A','A':'8A','E':'9A','B':'10A','F#':'11A','Gb':'11A','Db':'12A','C#':'12A'}
 
-# Camelot mapping (tonic -> code)
-CAMELOT_MAJOR = {
-    'B': '1B', 'F#': '2B', 'Gb': '2B', 'Db': '3B', 'C#': '3B', 'Ab': '4B', 'Eb': '5B',
-    'Bb': '6B', 'F': '7B', 'C': '8B', 'G': '9B', 'D': '10B', 'A': '11B', 'E': '12B'
-}
-CAMELOT_MINOR = {
-    'Ab': '1A', 'G#': '1A', 'Eb': '2A', 'D#': '2A', 'Bb': '3A', 'A#': '3A', 'F': '4A',
-    'C': '5A', 'G': '6A', 'D': '7A', 'A': '8A', 'E': '9A', 'B': '10A', 'F#': '11A',
-    'Gb': '11A', 'Db': '12A', 'C#': '12A'
-}
+# =========================================================
+# Utility helpers
+# =========================================================
 
+def roll(arr: np.ndarray, steps: int) -> np.ndarray:
+    return np.roll(arr, steps)
 
-def rotate_profile(profile: np.ndarray, steps: int) -> np.ndarray:
-    return np.roll(profile, steps)
+def tonic_from_index(idx: int) -> str:
+    return PITCHES_FLAT[int(idx) % 12]
 
+def camelot(tonic: str, mode: str) -> str:
+    return (CAMELOT_MAJOR if mode == "major" else CAMELOT_MINOR).get(tonic, "")
 
-def _tonic_name_from_index(idx: int) -> str:
-    # idx 0..11 in the PITCHES_FLAT order
-    return PITCHES_FLAT[idx % 12]
+def normalize(v: np.ndarray) -> np.ndarray:
+    n = np.linalg.norm(v) + 1e-12
+    return v / n
 
+# =========================================================
+# Improved BPM estimation (multi-method consensus)
+# =========================================================
 
-def estimate_key(y: np.ndarray, sr: int) -> Tuple[str, str, int]:
+def pick_best_bpm(y: np.ndarray, sr: int, hop: int = 512) -> Tuple[float, float]:
     """
-    Returns (key_name, mode, tonic_index)
-    mode in {"major","minor"}
-    tonic_index: 0..11 where 0=C, 1=Db, ..., 11=B in PITCHES_FLAT
+    Returns (bpm, confidence[0..1]).
+    Strategy:
+      1) Onset envelope -> autocorrelation peak
+      2) Tempogram peak
+      3) librosa beat tracker tempo
+    Then consensus + half/double correction scored against onset envelope.
     """
-    # Use harmonic component for stability
+    onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop, aggregate=np.median)
+
+    # 1) Autocorr peak
+    ac = librosa.autocorrelate(onset_env, max_size=onset_env.size // 2)
+    # Convert lags to BPM (exclude lag 0)
+    lags = np.arange(1, len(ac))
+    bpms_ac = 60.0 * sr / (lags * hop)
+    # Keep BPM range plausible
+    mask = (bpms_ac >= 60) & (bpms_ac <= 200)
+    bpms_ac = bpms_ac[mask]
+    ac_vals = ac[1:][mask]
+    bpm_ac = float(bpms_ac[np.argmax(ac_vals)]) if len(bpms_ac) else 0.0
+    conf_ac = float(np.max(ac_vals) / (np.sum(ac_vals) + 1e-12)) if len(ac_vals) else 0.0
+
+    # 2) Tempogram peak
+    tg = librosa.feature.tempogram(onset_envelope=onset_env, sr=sr, hop_length=hop)
+    tempi = librosa.beat.tempo(onset_envelope=onset_env, sr=sr, hop_length=hop, aggregate=None)
+    # robust choice: most frequent tempo
+    if tempi is not None and len(tempi):
+        # histogram in 60..200
+        t = tempi[(tempi >= 60) & (tempi <= 200)]
+        if len(t):
+            hist, edges = np.histogram(t, bins=np.arange(60, 202, 1))
+            bpm_tg = float(60 + np.argmax(hist))
+            conf_tg = float(np.max(hist) / (np.sum(hist) + 1e-12))
+        else:
+            bpm_tg, conf_tg = 0.0, 0.0
+    else:
+        bpm_tg, conf_tg = 0.0, 0.0
+
+    # 3) Beat tracker tempo
+    tempo_bt, beats = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr, hop_length=hop)
+    bpm_bt = float(tempo_bt)
+    conf_bt = 0.5 if beats is not None and len(beats) > 8 else 0.1
+
+    candidates = [bpm for bpm in [bpm_ac, bpm_tg, bpm_bt] if 30 < bpm < 240]
+    if not candidates:
+        return max(bpm_bt, 0.0), 0.0
+
+    # Generate half/double variants and score them by alignment with onsets
+    expanded = []
+    for bpm in candidates:
+        expanded += [bpm/2, bpm, bpm*2]
+    expanded = [b for b in expanded if 60 <= b <= 200]
+
+    def alignment_score(bpm_val: float) -> float:
+        # Predict beat locations and sum onset strengths near beats
+        period = (60.0 / bpm_val) * sr / hop  # beats in frames
+        # Start at the strongest onset frame
+        start = int(np.argmax(onset_env))
+        beat_frames = np.arange(start, len(onset_env), period)
+        beat_frames = np.round(beat_frames).astype(int)
+        beat_frames = beat_frames[beat_frames < len(onset_env)]
+        # window around each beat
+        s = 0.0
+        for f in beat_frames:
+            lo = max(0, f-2)
+            hi = min(len(onset_env), f+3)
+            s += float(np.max(onset_env[lo:hi]))
+        return s / (len(beat_frames) + 1e-12)
+
+    scored = [(b, alignment_score(b)) for b in expanded]
+    best_bpm, best_score = max(scored, key=lambda x: x[1])
+
+    # Confidence combines alignment and agreement among methods
+    agree = np.mean([min(best_bpm, c)/max(best_bpm, c) for c in candidates])  # 1 if identical
+    confidence = float(0.7 * (best_score / (np.max(onset_env) + 1e-12)) + 0.3 * agree)
+    confidence = float(np.clip(confidence, 0.0, 1.0))
+
+    return best_bpm, confidence
+
+# =========================================================
+# Improved Key estimation
+# =========================================================
+
+def beat_sync_chroma(y: np.ndarray, sr: int, hop: int = 512) -> np.ndarray:
+    # Harmonic component only to suppress drums
     y_harm, _ = librosa.effects.hpss(y)
+    # Tuned, high-resolution CQT chroma
+    chroma_cqt = librosa.feature.chroma_cqt(
+        y=y_harm, sr=sr, hop_length=hop, bins_per_octave=36, window='hann', cqt_mode='full'
+    )
+    # Timbre-robust CENS chroma
+    chroma_cens = librosa.feature.chroma_cens(y=y_harm, sr=sr, hop_length=hop)
+    # Weighted sum (CQT carries pitch detail, CENS stabilizes)
+    chroma = normalize(0.65 * chroma_cqt + 0.35 * chroma_cens)
+
+    # Beat-synchronize to reduce local key shifts/percussive bias
+    tempo, beats = librosa.beat.beat_track(y=y_harm, sr=sr, hop_length=hop)
+    if beats is not None and len(beats) > 2:
+        chroma_sync = librosa.util.sync(chroma, beats, aggregate=np.mean)
+    else:
+        chroma_sync = chroma
 
-    # Chroma
-    chroma = librosa.feature.chroma_cqt(y=y_harm, sr=sr, n_chroma=12)
-    chroma_mean = chroma.mean(axis=1)
-    if np.allclose(chroma_mean.sum(), 0):
-        # Fallback to avoid divide-by-zero if silence
-        chroma_mean = np.ones(12)
+    # Normalize columns and average to pitch-class profile
+    chroma_sync = chroma_sync / (np.linalg.norm(chroma_sync, axis=0, keepdims=True) + 1e-12)
+    return np.mean(chroma_sync, axis=1)
 
-    # Normalize
-    chroma_mean = chroma_mean / (np.linalg.norm(chroma_mean) + 1e-9)
+def score_key(pcp: np.ndarray, profiles: Tuple[np.ndarray, np.ndarray]) -> Tuple[str, str, float]:
+    maj_prof, min_prof = profiles
+    pcp = normalize(pcp)
 
-    # Try all 12 rotations for major & minor
-    best_score = -1
+    best_score = -1.0
     best_mode = "major"
     best_tonic = 0
 
     for i in range(12):
-        major_score = np.dot(chroma_mean, rotate_profile(MAJOR_PROFILE, -i))
-        minor_score = np.dot(chroma_mean, rotate_profile(MINOR_PROFILE, -i))
-
-        if major_score > best_score:
-            best_score = major_score
-            best_mode = "major"
-            best_tonic = i
-
-        if minor_score > best_score:
-            best_score = minor_score
-            best_mode = "minor"
-            best_tonic = i
-
-    # Build name
-    tonic_name = _tonic_name_from_index(best_tonic)
-    if best_mode == "major":
-        key_name = f"{tonic_name} major"
-    else:
-        key_name = f"{tonic_name} minor"
-
-    return key_name, best_mode, best_tonic
+        s_maj = float(np.dot(pcp, normalize(roll(maj_prof, -i))))
+        s_min = float(np.dot(pcp, normalize(roll(min_prof, -i))))
+        if s_maj > best_score:
+            best_score, best_mode, best_tonic = s_maj, "major", i
+        if s_min > best_score:
+            best_score, best_mode, best_tonic = s_min, "minor", i
+
+    # confidence = margin between best and runner-up
+    all_scores = []
+    for i in range(12):
+        all_scores.append(float(np.dot(pcp, normalize(roll(maj_prof, -i)))))
+        all_scores.append(float(np.dot(pcp, normalize(roll(min_prof, -i)))))
+    all_scores = np.array(all_scores, dtype=float)
+    margin = (np.sort(all_scores)[-1] - np.sort(all_scores)[-2]) / (np.max(all_scores) + 1e-12)
+    confidence = float(np.clip(margin, 0.0, 1.0))
 
+    tonic = tonic_from_index(best_tonic)
+    key_name = f"{tonic} {best_mode}"
+    return key_name, best_mode, confidence, best_tonic
 
-def camelot_from_key(tonic: str, mode: str) -> str:
-    if mode == "major":
-        return CAMELOT_MAJOR.get(tonic, "")
+def estimate_key(y: np.ndarray, sr: int) -> Tuple[str, str, float, int]:
+    """
+    Dual-profile voting: Krumhansl + Temperley.
+    We average their confidences and pick the agreement (or strongest if tie).
+    """
+    pcp = beat_sync_chroma(y, sr)
+    k_key, k_mode, k_conf, k_tonic = score_key(pcp, (KS_MAJOR, KS_MINOR))
+    t_key, t_mode, t_conf, t_tonic = score_key(pcp, (TP_MAJOR, TP_MINOR))
+
+    # If both agree on tonic & mode, boost confidence
+    if (k_mode == t_mode) and (k_tonic == t_tonic):
+        mode = k_mode
+        tonic_idx = k_tonic
+        name = k_key  # same as t_key
+        conf = float(np.clip(0.5 * (k_conf + t_conf) + 0.3, 0.0, 1.0))
     else:
-        return CAMELOT_MINOR.get(tonic, "")
-
-
-# ------------------------------
-# Feature engineering (Energy, Danceability, Happiness)
-# ------------------------------
+        # Choose the one with higher confidence, but allow close-call fallback
+        if (k_conf >= t_conf + 0.05):
+            name, mode, tonic_idx, conf = k_key, k_mode, k_tonic, k_conf * 0.9
+        elif (t_conf >= k_conf + 0.05):
+            name, mode, tonic_idx, conf = t_key, t_mode, t_tonic, t_conf * 0.9
+        else:
+            # disagree slightly: pick by proximity to major/minor brightness
+            brightness = float(np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))) / (sr/2.0 + 1e-12)
+            pick_t = (k_tonic, t_tonic)[int(brightness > 0.5)]
+            pick_m = ("minor", "major")[int(brightness > 0.5)]
+            if pick_m == k_mode and pick_t == k_tonic:
+                name, mode, tonic_idx, conf = k_key, k_mode, k_tonic, (k_conf+t_conf)/2
+            else:
+                name, mode, tonic_idx, conf = t_key, t_mode, t_tonic, (k_conf+t_conf)/2
+
+    return name, mode, float(np.clip(conf, 0.0, 1.0)), int(tonic_idx)
+
+# =========================================================
+# Extra features
+# =========================================================
 
 def robust_scale(x: float, lo: float, hi: float) -> float:
-    """Clamp and scale x∈[lo,hi] to [0,1]."""
-    return float(np.clip((x - lo) / (hi - lo + 1e-9), 0.0, 1.0))
-
+    return float(np.clip((x - lo) / (hi - lo + 1e-12), 0.0, 1.0))
 
-def estimate_features(y: np.ndarray, sr: int, tempo_bpm: float, mode: str) -> Dict[str, float]:
-    """
-    Lightweight proxies inspired by common MIR features.
-    Returns values in [0, 100].
-    """
-    # Energy: mean RMS, robust-scaled
+def estimate_extras(y: np.ndarray, sr: int, bpm: float, mode: str) -> Dict[str, float]:
     rms = librosa.feature.rms(y=y, frame_length=2048, hop_length=512).squeeze()
-    energy_raw = float(np.mean(rms))
-    energy_score = robust_scale(energy_raw, lo=0.01, hi=0.2)
+    energy = robust_scale(float(np.mean(rms)), lo=0.01, hi=0.2)
 
-    # Rhythm pulse (0..1): average PLP magnitude
     try:
         plp = librosa.beat.plp(y=y, sr=sr)
         pulse = float(np.mean(plp))
     except Exception:
         pulse = 0.5
 
-    # Tempo preference for dancing: bell centered ~118 BPM
-    tempo_pref = math.exp(-((tempo_bpm - 118.0) / 50.0) ** 2)  # 1 at ~118, smooth drop-off
-
-    # Danceability combines pulse & tempo preference
+    tempo_pref = math.exp(-((bpm - 118.0) / 50.0) ** 2)
     danceability = 0.6 * tempo_pref + 0.4 * pulse
 
-    # Brightness proxy: spectral centroid / (sr/2)
     centroid = librosa.feature.spectral_centroid(y=y, sr=sr).squeeze()
-    brightness = float(np.mean(centroid)) / (sr / 2.0 + 1e-9)
+    brightness = float(np.mean(centroid)) / (sr/2.0 + 1e-12)
     brightness = np.clip(brightness, 0.0, 1.0)
-
-    # Mode bonus (major tends to "happier" valence)
-    mode_bonus = 0.15 if mode == "major" else 0.0
-
-    # Tempo influence on "happiness" (moderate-faster feels brighter)
-    tempo_valence = math.exp(-((tempo_bpm - 120.0) / 60.0) ** 2)
-
-    happiness = 0.5 * brightness + 0.3 * tempo_valence + 0.2 * mode_bonus
+    happiness = 0.5 * brightness + 0.3 * math.exp(-((bpm - 120.0) / 60.0) ** 2) + (0.2 if mode == "major" else 0.0)
 
     return {
-        "Energy": round(energy_score * 100, 1),
-        "Danceability": round(danceability * 100, 1),
+        "Energy": round(energy * 100, 1),
+        "Danceability": round(np.clip(danceability, 0.0, 1.0) * 100, 1),
         "Happiness": round(np.clip(happiness, 0.0, 1.0) * 100, 1),
     }
 
+# =========================================================
+# Core analyzer
+# =========================================================
 
-# ------------------------------
-# Core analysis
-# ------------------------------
-
-def analyze_single(path: str, max_duration_s: float = 240.0) -> Dict[str, str]:
-    """
-    Analyze a single audio file and return a row dict.
-    To keep Spaces snappy, we optionally cap analysis to the first N seconds.
-    """
-    filename = os.path.basename(path)
-
-    # Load mono at 22.05k for speed; trim leading/trailing silence
+def analyze_one(path: str, max_duration_s: float = 300.0) -> Dict[str, str]:
+    fn = os.path.basename(path)
+    # Mono 22.05k for speed; trim silence
     y, sr = librosa.load(path, sr=22050, mono=True, duration=max_duration_s)
     y, _ = librosa.effects.trim(y, top_db=40)
 
-    if len(y) == 0:
-        return {
-            "File Name": filename,
-            "Key": "N/A",
-            "Alt Key": "",
-            "BPM": "N/A",
-            "Energy": "N/A",
-            "Danceability": "N/A",
-            "Happiness": "N/A",
-        }
-
-    # Tempo / BPM
-    try:
-        tempo, beats = librosa.beat.beat_track(y=y, sr=sr)
-        bpm = float(tempo)
-    except Exception:
-        bpm = float(librosa.beat.tempo(y=y, sr=sr))
-    bpm_display = int(round(bpm))
+    if y.size == 0:
+        return {"File Name": fn, "Key": "N/A", "Alt Key": "", "BPM": "N/A",
+                "Energy": "N/A", "Danceability": "N/A", "Happiness": "N/A"}
+
+    # BPM (with confidence)
+    bpm_val, bpm_conf = pick_best_bpm(y, sr, hop=512)
+    bpm_disp = int(round(bpm_val)) if bpm_val > 0 else "N/A"
 
-    # Key
-    key_name, mode, tonic_idx = estimate_key(y, sr)
-    tonic_name = _tonic_name_from_index(tonic_idx)
-    camelot = camelot_from_key(tonic_name, mode)
+    # Key (with confidence)
+    key_name, mode, key_conf, tonic_idx = estimate_key(y, sr)
+    camelot_code = camelot(PITCHES_FLAT[tonic_idx], mode)
 
-    # Extra features
-    feats = estimate_features(y, sr, bpm, mode)
+    extras = estimate_extras(y, sr, bpm_val if bpm_val > 0 else 120.0, mode)
 
     return {
-        "File Name": filename,
-        "Key": key_name,
-        "Alt Key": camelot,
-        "BPM": bpm_display,
-        "Energy": feats["Energy"],
-        "Danceability": feats["Danceability"],
-        "Happiness": feats["Happiness"],
+        "File Name": fn,
+        "Key": f"{key_name}",           # e.g., "Bb minor"
+        "Alt Key": camelot_code,        # e.g., "3A"
+        "BPM": bpm_disp,
+        "Energy": extras["Energy"],
+        "Danceability": extras["Danceability"],
+        "Happiness": extras["Happiness"],
     }
 
-
 def analyze_batch(files: List[str], save_results: bool, search: str):
-    if not files or len(files) == 0:
-        return pd.DataFrame(columns=["File Name", "Key", "Alt Key", "BPM", "Energy", "Danceability", "Happiness"]), None
+    if not files:
+        return pd.DataFrame(columns=["File Name","Key","Alt Key","BPM","Energy","Danceability","Happiness"]), None
 
     rows = []
     for f in files:
         try:
-            rows.append(analyze_single(f))
+            rows.append(analyze_one(f))
         except Exception as e:
-            rows.append({
-                "File Name": os.path.basename(f),
-                "Key": f"Error: {e}",
-                "Alt Key": "",
-                "BPM": "",
-                "Energy": "",
-                "Danceability": "",
-                "Happiness": "",
-            })
-
-    df = pd.DataFrame(rows, columns=["File Name", "Key", "Alt Key", "BPM", "Energy", "Danceability", "Happiness"])
-
-    # Optional search filter (case-insensitive)
-    if search and isinstance(search, str) and search.strip():
+            rows.append({"File Name": os.path.basename(f), "Key": f"Error: {e}", "Alt Key": "", "BPM": "",
+                         "Energy": "", "Danceability": "", "Happiness": ""})
+
+    df = pd.DataFrame(rows, columns=["File Name","Key","Alt Key","BPM","Energy","Danceability","Happiness"])
+
+    if search and search.strip():
         mask = df.apply(lambda col: col.astype(str).str.contains(search.strip(), case=False, na=False))
         df = df[mask.any(axis=1)]
 
     csv_file = None
-    if save_results and len(df) > 0:
+    if save_results and len(df):
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
         df.to_csv(tmp.name, index=False, encoding="utf-8")
         csv_file = tmp.name
 
     return df, csv_file
 
-
-# ------------------------------
+# =========================================================
 # UI
-# ------------------------------
+# =========================================================
 
 CSS = """
 #app-title { font-weight: 700; font-size: 28px; }
@@ -255,26 +321,22 @@ th, td { text-align: left !important; }
 """
 
 with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
-    gr.Markdown("<div id='app-title'>Audio Key & BPM Finder — with Energy, Danceability, Happiness</div>")
+    gr.Markdown("<div id='app-title'>Audio Key & BPM Finder — Accurate Mode</div>")
     gr.Markdown(
-        "Upload one or more audio files (mp3/wav/m4a/etc.). "
-        "The tool estimates musical **Key**, **Camelot (Alt Key)**, **BPM**, and proxy scores for **Energy**, **Danceability**, and **Happiness**."
-        "<br><span class='small-note'>Note: Energy/Danceability/Happiness are heuristic estimates for quick analysis.</span>"
+        "Upload audio (mp3/wav/m4a…). The app estimates **Key**, **Camelot (Alt Key)**, and **BPM** using consensus methods, "
+        "plus heuristic **Energy**, **Danceability**, **Happiness**."
+        "<br><span class='small-note'>Tip: Longer clips (30–120s) improve accuracy. Results are global track estimates.</span>"
     )
 
     with gr.Row():
         files = gr.File(label="Audio Files", file_count="multiple", type="filepath")
     with gr.Row():
-        search = gr.Textbox(label="Search (filter by file name or any column)", placeholder="Type to filter…", scale=3)
+        search = gr.Textbox(label="Search (filter any column)", placeholder="Type to filter…", scale=3)
         save = gr.Checkbox(label="Save results as CSV", value=False, scale=1)
         run = gr.Button("Analyze", variant="primary", scale=1)
 
-    out_df = gr.Dataframe(
-        headers=["File Name", "Key", "Alt Key", "BPM", "Energy", "Danceability", "Happiness"],
-        interactive=False,
-        wrap=True,
-        label="Results"
-    )
+    out_df = gr.Dataframe(headers=["File Name","Key","Alt Key","BPM","Energy","Danceability","Happiness"],
+                          interactive=False, wrap=True, label="Results")
     out_csv = gr.File(label="Download CSV", visible=True)
 
     run.click(fn=analyze_batch, inputs=[files, save, search], outputs=[out_df, out_csv])