first pass - analysis + UI scaffold

.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.pyc
+*.pyo
+*.wav
+*.mp3
+*.flac
+*.ogg
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+*.egg
+.eggs/
+_stems/
+flagged/
+*.pt
+*.bin
+*.safetensors
+.DS_Store
+Thumbs.db

README.md

@@ -1,15 +1,25 @@
 ---
-title: Coda
-emoji: 👀
-colorFrom: blue
-colorTo: gray
+title: CODA
+emoji: 🎵
+colorFrom: yellow
+colorTo: orange
 sdk: gradio
 sdk_version: 6.16.0
 python_version: '3.12'
 app_file: app.py
 pinned: false
 license: mit
-short_description: Finish what you started. A local AI that continues the songs
+short_description: Finish what you started. A local AI that continues your songs.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CODA
+
+You have an unfinished song. Maybe you ran out of ideas at the bridge, maybe the groove just stops at 0:47. Upload it. CODA listens, figures out what key you're in and where the beat lands, then continues the music from where you stopped. Vocals, instruments, lyrics -- it picks up all of it.
+
+Everything runs locally. No audio leaves your machine, no cloud APIs, no subscriptions. The whole stack fits under 13B parameters: MusicGen Large handles the music continuation, Whisper + Demucs pull and transcribe vocals, Qwen3 writes new lyrics that match your style, and librosa does the key/tempo detection without any ML at all.
+
+Upload a WAV, MP3, or FLAC (under 60 seconds). You'll see the detected key, tempo, and duration right away. Hit continue and CODA generates what comes next.
+
+---
+
+Built by Tony Winslow for the Build Small Hackathon 2025. MIT license.

analyze.py

@@ -0,0 +1,99 @@
+import librosa
+import numpy as np
+
+
+# krumhansl-schmuckler key profiles
+# major and minor correlation vectors for pitch class distribution
+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])
+
+PITCH_CLASSES = ['C', 'C#', 'D', 'D#', 'E', 'F',
+                 'F#', 'G', 'G#', 'A', 'A#', 'B']
+
+
+def find_key(path):
+    """chroma-based key detection using krumhansl-schmuckler profiles"""
+    track, sr = librosa.load(path, sr=None)
+
+    # pull chroma energy, average across time
+    chroma = librosa.feature.chroma_cqt(y=track, sr=sr)
+    pitch_dist = np.mean(chroma, axis=1)
+
+    # normalize
+    pitch_dist = (pitch_dist - pitch_dist.mean()) / (pitch_dist.std() + 1e-8)
+
+    best_corr = -2
+    best_key = 'C major'
+
+    for shift in range(12):
+        rolled = np.roll(pitch_dist, -shift)
+
+        # check major
+        major_norm = (MAJOR_PROFILE - MAJOR_PROFILE.mean()) / MAJOR_PROFILE.std()
+        corr_major = np.corrcoef(rolled, major_norm)[0, 1]
+        if corr_major > best_corr:
+            best_corr = corr_major
+            best_key = f'{PITCH_CLASSES[shift]} major'
+
+        # check minor
+        minor_norm = (MINOR_PROFILE - MINOR_PROFILE.mean()) / MINOR_PROFILE.std()
+        corr_minor = np.corrcoef(rolled, minor_norm)[0, 1]
+        if corr_minor > best_corr:
+            best_corr = corr_minor
+            best_key = f'{PITCH_CLASSES[shift]} minor'
+
+    return best_key
+
+
+def get_tempo(path):
+    track, sr = librosa.load(path, sr=None)
+    tempo, _ = librosa.beat.beat_track(y=track, sr=sr)
+    # librosa sometimes returns an array
+    if hasattr(tempo, '__len__'):
+        return float(tempo[0])
+    return float(tempo)
+
+
+def get_duration(path):
+    return librosa.get_duration(path=path)
+
+
+def fingerprint(path):
+    track, sr = librosa.load(path, sr=None, mono=False)
+
+    channels = 1 if track.ndim == 1 else track.shape[0]
+
+    # reload mono for analysis
+    if channels > 1:
+        mono = librosa.to_mono(track)
+    else:
+        mono = track
+
+    key_sig = find_key(path)
+    bpm = get_tempo(path)
+    length = librosa.get_duration(y=mono, sr=sr)
+
+    return {
+        'key': key_sig,
+        'bpm': round(bpm, 1),
+        'duration': round(length, 2),
+        'sample_rate': sr,
+        'channels': channels
+    }
+
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) < 2:
+        print('usage: python analyze.py <audio_file>')
+        sys.exit(1)
+
+    info = fingerprint(sys.argv[1])
+    print(f"key: {info['key']}")
+    print(f"bpm: {info['bpm']}")
+    print(f"duration: {info['duration']}s")
+    print(f"sample rate: {info['sample_rate']}Hz")
+    print(f"channels: {info['channels']}")

app.py

@@ -0,0 +1,235 @@
+import gradio as gr
+import os
+import tempfile
+from analyze import fingerprint, find_key, get_tempo, get_duration
+
+try:
+    import spaces
+except ImportError:
+    class _FakeSpaces:
+        def GPU(self, fn=None, **kw):
+            if fn: return fn
+            return lambda f: f
+    spaces = _FakeSpaces()
+
+
+CUSTOM_CSS = """
+/* ---- base ---- */
+.gradio-container {
+    background: #1a1714 !important;
+    font-family: 'Georgia', 'Times New Roman', serif !important;
+    max-width: 760px !important;
+    margin: 0 auto !important;
+}
+.app-header {
+    text-align: center;
+    padding: 40px 20px 10px 20px;
+}
+.app-header h1 {
+    color: #f0ece4 !important;
+    font-size: 3.2em !important;
+    font-weight: 400 !important;
+    letter-spacing: 0.15em !important;
+    margin-bottom: 4px !important;
+    font-family: 'Georgia', serif !important;
+}
+.app-header p {
+    color: #8a7e6e !important;
+    font-size: 1em !important;
+    font-style: italic !important;
+    margin-top: 0 !important;
+}
+.upload-panel, .results-panel, .continue-panel {
+    background: #211e19 !important;
+    border: 1px solid #3a332a !important;
+    border-radius: 12px !important;
+    padding: 24px !important;
+    margin-bottom: 16px !important;
+}
+.gradio-container label, .gradio-container .label-wrap span {
+    color: #c8956c !important;
+    font-family: 'Georgia', serif !important;
+    font-size: 0.95em !important;
+}
+.gradio-container .prose, .gradio-container p, .gradio-container span {
+    color: #f0ece4 !important;
+}
+.gradio-container .upload-button {
+    background: #2a2520 !important;
+    border: 2px dashed #4a4035 !important;
+    color: #c8956c !important;
+    border-radius: 8px !important;
+}
+.gradio-container .upload-button:hover {
+    border-color: #c8956c !important;
+    background: #302a22 !important;
+}
+.stat-card {
+    background: #2a2520 !important;
+    border: 1px solid #3a332a !important;
+    border-radius: 10px !important;
+    padding: 20px !important;
+    text-align: center !important;
+}
+.stat-label {
+    color: #8a7e6e !important;
+    font-size: 0.8em !important;
+    text-transform: uppercase !important;
+    letter-spacing: 0.12em !important;
+    margin-bottom: 6px !important;
+}
+.stat-value {
+    color: #c8956c !important;
+    font-size: 1.8em !important;
+    font-weight: 400 !important;
+    font-family: 'Georgia', serif !important;
+}
+.gradio-container button.primary {
+    background: #c8956c !important;
+    color: #1a1714 !important;
+    border: none !important;
+    border-radius: 8px !important;
+    font-family: 'Georgia', serif !important;
+    font-size: 1em !important;
+    padding: 12px 32px !important;
+    letter-spacing: 0.06em !important;
+    transition: all 0.2s ease !important;
+}
+.gradio-container button.primary:hover {
+    background: #d4a57c !important;
+}
+.gradio-container button.secondary {
+    background: transparent !important;
+    color: #c8956c !important;
+    border: 1px solid #4a4035 !important;
+    border-radius: 8px !important;
+    font-family: 'Georgia', serif !important;
+}
+.gradio-container button.secondary:hover {
+    border-color: #c8956c !important;
+}
+footer { display: none !important; }
+.gradio-container .tab-nav button {
+    color: #8a7e6e !important;
+    border: none !important;
+    background: transparent !important;
+    font-family: 'Georgia', serif !important;
+}
+.gradio-container .tab-nav button.selected {
+    color: #c8956c !important;
+    border-bottom: 2px solid #c8956c !important;
+}
+.gradio-container input, .gradio-container textarea {
+    background: #2a2520 !important;
+    color: #f0ece4 !important;
+    border-color: #3a332a !important;
+}
+.gradio-container .audio-player {
+    background: #2a2520 !important;
+    border-radius: 8px !important;
+}
+.gradio-container .progress-bar {
+    background: #c8956c !important;
+}
+.tape-deco {
+    text-align: center;
+    padding: 8px 0;
+    color: #3a332a;
+    font-size: 0.85em;
+    letter-spacing: 0.3em;
+}
+"""
+
+
+def make_stat_html(label, value):
+    return (
+        '<div class="stat-card">'
+        '<div class="stat-label">' + label + '</div>'
+        '<div class="stat-value">' + str(value) + '</div>'
+        '</div>'
+    )
+
+
+def analyze_track(audio):
+    if audio is None:
+        return (
+            make_stat_html("key", "---"),
+            make_stat_html("tempo", "---"),
+            make_stat_html("duration", "---"),
+            gr.update(visible=False),
+            None
+        )
+
+    try:
+        info = fingerprint(audio)
+        key_html = make_stat_html("key", info["key"])
+        bpm_html = make_stat_html("tempo", str(info["bpm"]) + " bpm")
+        dur_html = make_stat_html("duration", str(info["duration"]) + "s")
+        return (key_html, bpm_html, dur_html, gr.update(visible=True), audio)
+    except Exception as e:
+        err = make_stat_html("error", str(e)[:50])
+        return (err, make_stat_html("tempo", "---"), make_stat_html("duration", "---"), gr.update(visible=False), None)
+
+
+def placeholder_continue(audio_path):
+    return "continuation coming soon. MusicGen pipeline lands on Day 2."
+
+
+HEADER_HTML = (
+    '<div class="app-header">'
+    '<h1>CODA</h1>'
+    '<p>upload an unfinished song. it picks up where you left off.</p>'
+    '</div>'
+    '<div class="tape-deco">- - - - - - - - - - - -</div>'
+)
+
+FOOTER_HTML = (
+    '<div class="tape-deco" style="margin-top: 20px;">- - - - - - - - - - - -</div>'
+    '<div style="text-align:center; padding:16px 0; color:#4a4035; font-size:0.8em; font-family:Georgia,serif;">'
+    'CODA // 100% local // no cloud APIs // built for Build Small 2025'
+    '</div>'
+)
+
+
+with gr.Blocks(title="CODA") as app:
+
+    current_track = gr.State(None)
+
+    gr.HTML(HEADER_HTML)
+
+    with gr.Group(elem_classes="upload-panel"):
+        audio_input = gr.Audio(
+            label="drop a track",
+            type="filepath",
+            sources=["upload", "microphone"],
+        )
+
+    with gr.Group(elem_classes="results-panel"):
+        gr.HTML('<div class="tape-deco" style="margin-bottom:12px;">analysis</div>')
+        with gr.Row():
+            key_display = gr.HTML(make_stat_html("key", "---"))
+            bpm_display = gr.HTML(make_stat_html("tempo", "---"))
+            dur_display = gr.HTML(make_stat_html("duration", "---"))
+
+    with gr.Group(elem_classes="continue-panel", visible=False) as continue_section:
+        gr.HTML('<div class="tape-deco" style="margin-bottom:12px;">continue</div>')
+        continue_btn = gr.Button("continue this track", variant="primary")
+        continue_output = gr.Textbox(label="status", interactive=False, lines=2)
+
+    audio_input.change(
+        fn=analyze_track,
+        inputs=[audio_input],
+        outputs=[key_display, bpm_display, dur_display, continue_section, current_track]
+    )
+
+    continue_btn.click(
+        fn=placeholder_continue,
+        inputs=[current_track],
+        outputs=[continue_output]
+    )
+
+    gr.HTML(FOOTER_HTML)
+
+
+if __name__ == "__main__":
+    app.launch(css=CUSTOM_CSS, theme=gr.themes.Base())

continue_music.py

@@ -0,0 +1,56 @@
+import torch
+import torchaudio
+from audiocraft.models import MusicGen
+
+
+_model = None
+
+
+def _load_model():
+    global _model
+    if _model is None:
+        _model = MusicGen.get_pretrained('facebook/musicgen-large')
+    return _model
+
+
+def continue_track(path, prompt_duration=10, gen_duration=15, key=None, bpm=None):
+    """
+    takes the last `prompt_duration` seconds of the input track
+    and generates `gen_duration` seconds of continuation.
+    key and bpm are hints for the text prompt.
+    """
+    model = _load_model()
+    model.set_generation_params(duration=gen_duration)
+
+    track, sr = torchaudio.load(path)
+
+    # grab the tail end as context
+    tail_samples = int(prompt_duration * sr)
+    if track.shape[1] > tail_samples:
+        tail = track[:, -tail_samples:]
+    else:
+        tail = track
+
+    # resample to 32kHz if needed (musicgen expects this)
+    if sr != 32000:
+        resampler = torchaudio.transforms.Resample(sr, 32000)
+        tail = resampler(tail)
+
+    # mono
+    if tail.shape[0] > 1:
+        tail = tail.mean(dim=0, keepdim=True)
+
+    tail = tail.unsqueeze(0)  # batch dim
+
+    # build a natural description
+    desc = "continue this song"
+    if key and bpm:
+        desc = f"continue this song in {key} at {bpm} bpm"
+    elif key:
+        desc = f"continue this song in {key}"
+
+    with torch.no_grad():
+        output = model.generate_continuation(tail, 32000, [desc])
+
+    result = output[0].cpu()
+    return result, 32000

poster.py

@@ -0,0 +1,79 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+
+# warm palette matching the app
+BG_COLOR = (26, 23, 20)
+AMBER = (200, 149, 108)
+CREAM = (240, 236, 228)
+DARK_ACCENT = (60, 50, 40)
+
+
+def make_poster(title, key_sig, bpm, duration, out_path='poster.png'):
+    """
+    generates a simple album-art-style card for the analyzed track.
+    no ML here, just pillow.
+    """
+    w, h = 800, 800
+    img = Image.new('RGB', (w, h), BG_COLOR)
+    draw = ImageDraw.Draw(img)
+
+    # big warm circle as a vinyl record silhouette
+    cx, cy = w // 2, h // 2 - 40
+    radius = 240
+    draw.ellipse(
+        [cx - radius, cy - radius, cx + radius, cy + radius],
+        fill=DARK_ACCENT,
+        outline=AMBER,
+        width=3
+    )
+
+    # inner circle (label area)
+    inner_r = 80
+    draw.ellipse(
+        [cx - inner_r, cy - inner_r, cx + inner_r, cy + inner_r],
+        fill=BG_COLOR,
+        outline=AMBER,
+        width=2
+    )
+
+    # spindle dot
+    draw.ellipse([cx - 6, cy - 6, cx + 6, cy + 6], fill=AMBER)
+
+    # grooves (concentric rings)
+    for r in range(inner_r + 20, radius, 16):
+        draw.ellipse(
+            [cx - r, cy - r, cx + r, cy + r],
+            outline=(50, 42, 34),
+            width=1
+        )
+
+    # text below the record
+    try:
+        title_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 32)
+        detail_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 22)
+        small_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 16)
+    except OSError:
+        title_font = ImageFont.load_default()
+        detail_font = title_font
+        small_font = title_font
+
+    # track title
+    title_text = title if len(title) < 40 else title[:37] + '...'
+    bbox = draw.textbbox((0, 0), title_text, font=title_font)
+    tw = bbox[2] - bbox[0]
+    draw.text(((w - tw) // 2, h - 200), title_text, fill=CREAM, font=title_font)
+
+    # key + bpm line
+    info_text = f"{key_sig}  ·  {bpm} BPM  ·  {duration:.1f}s"
+    bbox = draw.textbbox((0, 0), info_text, font=detail_font)
+    tw = bbox[2] - bbox[0]
+    draw.text(((w - tw) // 2, h - 150), info_text, fill=AMBER, font=detail_font)
+
+    # coda branding
+    brand = "CODA"
+    bbox = draw.textbbox((0, 0), brand, font=small_font)
+    tw = bbox[2] - bbox[0]
+    draw.text(((w - tw) // 2, h - 60), brand, fill=(100, 85, 70), font=small_font)
+
+    img.save(out_path)
+    return out_path

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=5.0.0
+torch>=2.1.0
+torchaudio>=2.1.0
+librosa>=0.10.2
+numpy>=1.24.0
+soundfile>=0.12.1
+Pillow>=10.0.0
+transformers>=4.51.0
+accelerate>=0.26.0
+audiocraft
+demucs
+spaces

transcribe.py

@@ -0,0 +1,73 @@
+import torch
+import torchaudio
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
+
+
+_processor = None
+_model = None
+
+
+def _load_whisper():
+    global _processor, _model
+    if _model is None:
+        _processor = WhisperProcessor.from_pretrained("openai/whisper-large-v3")
+        _model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v3")
+    return _processor, _model
+
+
+def isolate_vocals(path):
+    """
+    run demucs to split stems, return path to vocals.
+    expects demucs CLI installed via pip.
+    """
+    import subprocess
+    import os
+
+    out_dir = os.path.join(os.path.dirname(path), '_stems')
+    cmd = ['python', '-m', 'demucs', '--two-stems', 'vocals',
+           '-o', out_dir, path]
+    subprocess.run(cmd, check=True, capture_output=True)
+
+    # demucs outputs to out_dir/htdemucs/<trackname>/vocals.wav
+    track_name = os.path.splitext(os.path.basename(path))[0]
+    vocals_path = os.path.join(out_dir, 'htdemucs', track_name, 'vocals.wav')
+
+    if not os.path.exists(vocals_path):
+        raise FileNotFoundError(f"demucs didn't produce vocals at {vocals_path}")
+
+    return vocals_path
+
+
+def transcribe(path, isolate=True):
+    """
+    extract lyrics from audio.
+    if isolate=True, runs demucs first to pull vocals.
+    """
+    if isolate:
+        try:
+            vocal_path = isolate_vocals(path)
+        except Exception:
+            # fall back to raw audio if stem separation fails
+            vocal_path = path
+    else:
+        vocal_path = path
+
+    processor, model = _load_whisper()
+
+    track, sr = torchaudio.load(vocal_path)
+
+    # whisper wants 16kHz mono
+    if sr != 16000:
+        track = torchaudio.transforms.Resample(sr, 16000)(track)
+    if track.shape[0] > 1:
+        track = track.mean(dim=0, keepdim=True)
+
+    track = track.squeeze()
+
+    inputs = processor(track.numpy(), sampling_rate=16000, return_tensors="pt")
+
+    with torch.no_grad():
+        predicted_ids = model.generate(inputs.input_features)
+
+    lyrics = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+    return lyrics.strip()

write_lyrics.py

@@ -0,0 +1,66 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+_model = None
+_tokenizer = None
+
+
+def _load_qwen():
+    global _model, _tokenizer
+    if _model is None:
+        model_id = "Qwen/Qwen3-8B"
+        _tokenizer = AutoTokenizer.from_pretrained(model_id)
+        _model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            torch_dtype="auto",
+            device_map="auto"
+        )
+    return _model, _tokenizer
+
+
+def continue_lyrics(existing_lyrics, key=None, bpm=None, style_hint=None, num_lines=8):
+    """
+    takes existing lyrics and writes more in the same style.
+    key/bpm/style_hint give the model musical context.
+    """
+    model, tokenizer = _load_qwen()
+
+    context_parts = []
+    if key:
+        context_parts.append(f"The song is in {key}")
+    if bpm:
+        context_parts.append(f"at {bpm} BPM")
+    if style_hint:
+        context_parts.append(f"with a {style_hint} feel")
+
+    context = ", ".join(context_parts) + "." if context_parts else ""
+
+    prompt = f"""You are a songwriter. Continue the following lyrics naturally,
+matching the tone, rhythm, and imagery. Write exactly {num_lines} new lines.
+Do not repeat existing lines. Do not add commentary or explanations.
+{context}
+
+Existing lyrics:
+{existing_lyrics}
+
+Continuation:"""
+
+    messages = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+
+    inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+    output = model.generate(
+        **inputs,
+        max_new_tokens=256,
+        temperature=0.8,
+        top_p=0.9,
+        do_sample=True
+    )
+
+    generated = output[0][inputs.input_ids.shape[1]:]
+    result = tokenizer.decode(generated, skip_special_tokens=True)
+
+    # trim to requested line count
+    lines = [l for l in result.strip().split('\n') if l.strip()]
+    return '\n'.join(lines[:num_lines])