Create app.py

app.py

@@ -0,0 +1,239 @@
+import re
+import numpy as np
+import gradio as gr
+import pretty_midi
+import subprocess
+import random
+from datasets import load_dataset
+
+# ==========================================
+# 1. DATA PREPARATION (MULTI-GENRE)
+# ==========================================
+print("Downloading and sorting dataset by genre... (This will take a minute on boot)")
+dataset = load_dataset("ailsntua/Chordonomicon", split="train", streaming=True)
+
+target_genres = ["pop", "rock", "jazz", "metal", "country", "blues", "r&b", "folk"]
+corpus_by_genre = {genre: set() for genre in target_genres}
+pattern = re.compile(r'<([^>]+)>\s*([^<]+)')
+
+for row in dataset:
+    if all(len(progressions) >= 100 for progressions in corpus_by_genre.values()):
+        break
+
+    main_genre = str(row.get('main_genre', '')).lower()
+    genres_str = str(row.get('genres', '')).lower()
+    combined_genres = main_genre + " " + genres_str
+
+    matched_genre = None
+    for g in target_genres:
+        if g in combined_genres and len(corpus_by_genre[g]) < 100:
+            matched_genre = g
+            break
+
+    if not matched_genre: continue 
+
+    chord_string = row.get('chords', '')
+    if not chord_string: continue
+
+    matches = pattern.findall(chord_string)
+    for tag, chords in matches:
+        tag = tag.lower().strip()
+        chords = " ".join(chords.split())
+        
+        if chords and ('verse' in tag or 'chorus' in tag):
+            corpus_by_genre[matched_genre].add(chords)
+            if len(corpus_by_genre[matched_genre]) >= 100:
+                break 
+
+corpus_by_genre = {g: list(chords) for g, chords in corpus_by_genre.items()}
+
+# ==========================================
+# 2. MARKOV CHAIN LOGIC
+# ==========================================
+def train_markov_model(corpus, order=1):
+    markov_model = {}
+    art_start = "*S*"
+    art_end = "*E*"
+
+    for progression in corpus:
+        chords = progression.split()
+        if not chords: continue
+        current_state = tuple([art_start] * order)
+
+        for chord in chords:
+            if current_state not in markov_model: markov_model[current_state] = {}
+            if chord not in markov_model[current_state]: markov_model[current_state][chord] = 0
+            markov_model[current_state][chord] += 1
+            current_state = tuple(list(current_state)[1:] + [chord])
+
+        if current_state not in markov_model: markov_model[current_state] = {}
+        if art_end not in markov_model[current_state]: markov_model[current_state][art_end] = 0
+        markov_model[current_state][art_end] += 1
+
+    return markov_model
+
+def get_next_chord(current_state, markov_model):
+    if current_state not in markov_model: return "*E*"
+    transitions = markov_model[current_state]
+    next_chords = list(transitions.keys())
+    counts = list(transitions.values())
+    total = sum(counts)
+    probs = [c / total for c in counts]
+    return np.random.choice(next_chords, p=probs)
+
+def generate_progression(markov_model, target_length, order=1):
+    art_start = "*S*"
+    art_end = "*E*"
+    current_state = tuple([art_start] * order)
+    progression = []
+    
+    max_attempts = target_length * 5 
+    attempts = 0
+
+    while len(progression) < target_length and attempts < max_attempts:
+        attempts += 1
+        next_chord = get_next_chord(current_state, markov_model)
+
+        if next_chord == art_end:
+            current_state = tuple([art_start] * order)
+            continue 
+
+        progression.append(next_chord)
+        current_state = tuple(list(current_state)[1:] + [next_chord])
+
+    return " ".join(progression)
+
+# ==========================================
+# 3. AUDIO SYNTHESIS & VOICING LOGIC
+# ==========================================
+NOTE_TO_MIDI = {'C': 60, 'Cs': 61, 'Db': 61, 'D': 62, 'Ds': 63, 'Eb': 63, 'E': 64, 'F': 65, 'Fs': 66, 'Gb': 66, 'G': 67, 'Gs': 68, 'Ab': 68, 'A': 69, 'As': 70, 'Bb': 70, 'B': 71}
+MIDI_TO_NOTE = {60: 'C', 61: 'Db', 62: 'D', 63: 'Eb', 64: 'E', 65: 'F', 66: 'Gb', 67: 'G', 68: 'Ab', 69: 'A', 70: 'Bb', 71: 'B'}
+CHORD_INTERVALS = {'maj': [0, 4, 7], 'min': [0, 3, 7], '7': [0, 4, 7, 10], 'maj7': [0, 4, 7, 11], 'min7': [0, 3, 7, 10], 'sus4': [0, 5, 7], 'sus2': [0, 2, 7], 'dim': [0, 3, 6], 'no3d': [0, 7], '5': [0, 7]}
+
+def parse_chord_to_midi(chord_string):
+    if not chord_string or chord_string == 'N': return [], ""
+    chord_string = chord_string.split('/')[0]
+    root_note = chord_string[0]
+    remainder = chord_string[1:]
+    if remainder and remainder[0] in ['s', 'b']:
+        root_note += remainder[0]
+        remainder = remainder[1:]
+
+    root_midi = NOTE_TO_MIDI.get(root_note, 60)
+    quality = 'maj'
+    intervals = CHORD_INTERVALS['maj']
+    for q, ints in CHORD_INTERVALS.items():
+        if remainder.startswith(q):
+            intervals = ints; quality = q; break
+    return [root_midi + i for i in intervals], quality
+
+def apply_voicing(pitches, voicing_type):
+    if not pitches: return pitches
+    pitches = sorted(pitches)
+    if voicing_type == "First Inversion" and len(pitches) > 1: pitches[0] += 12
+    elif voicing_type == "Second Inversion" and len(pitches) > 2: pitches[0] += 12; pitches[1] += 12
+    elif voicing_type == "Random Voice Leading":
+        choice = random.choice([0, 1, 2])
+        if choice == 1 and len(pitches) > 1: pitches[0] += 12
+        if choice == 2 and len(pitches) > 2: pitches[0] += 12; pitches[1] += 12
+    elif voicing_type == "Open / Spread" and len(pitches) >= 3: pitches[0] -= 12; pitches[1] += 12
+    return sorted(pitches) if voicing_type != "Open / Spread" else pitches
+
+def generate_audio_file(progression_string, instrument, transpose_semitones, voicing_type):
+    if not progression_string.strip(): return None, None, ""
+
+    is_metal = (instrument == "Metal Guitar")
+    prog_num = 30 if is_metal else 0
+    velocity = 110 if is_metal else 85
+
+    midi = pretty_midi.PrettyMIDI(initial_tempo=120)
+    inst = pretty_midi.Instrument(program=prog_num)
+    current_time = 0.0
+    transposed_chord_names = []
+
+    for chord in progression_string.split():
+        pitches, quality = parse_chord_to_midi(chord)
+        if not pitches: continue
+
+        # Transpose
+        pitches = [p + transpose_semitones for p in pitches]
+        normalized_root = ((pitches[0] - 60) % 12) + 60
+        transposed_chord_names.append(MIDI_TO_NOTE.get(normalized_root, "C") + quality)
+
+        if is_metal: pitches = [p - 12 for p in pitches]
+        pitches = apply_voicing(pitches, voicing_type)
+
+        for pitch in pitches:
+            note = pretty_midi.Note(velocity=velocity, pitch=pitch, start=current_time, end=current_time + 0.5)
+            inst.notes.append(note)
+        current_time += 0.5
+
+    midi.instruments.append(inst)
+    midi_path = 'generated_progression.mid'
+    wav_path = 'generated_progression.wav'
+    
+    midi.write(midi_path)
+    subprocess.run(['fluidsynth', '-ni', '/usr/share/sounds/sf2/FluidR3_GM.sf2', midi_path, '-F', wav_path, '-r', '44100'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    
+    return wav_path, midi_path, " ".join(transposed_chord_names)
+
+# ==========================================
+# 4. GRADIO INTERFACE
+# ==========================================
+def app_logic(genre, order, length, instrument, transpose, voicing):
+    corpus = corpus_by_genre.get(genre, [])
+
+    if not corpus:
+        return f"Error: No chords found for {genre}.", "", None, None
+
+    model = train_markov_model(corpus, order=int(order))
+    raw_chords = generate_progression(model, target_length=int(length), order=int(order))
+
+    if not raw_chords.strip():
+        return "(Generation stopped. The Markov chain hit an early dead end. Try again or lower the Order.)", "", None, None
+
+    audio_path, midi_path, final_transposed_chords = generate_audio_file(raw_chords, instrument, int(transpose), voicing)
+
+    return raw_chords, final_transposed_chords, audio_path, midi_path
+
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# 🎸 Markhords: AI Chord Progression Generator")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Training Data")
+            genre_dropdown = gr.Dropdown(
+                choices=[g.capitalize() for g in target_genres], 
+                value="Pop", 
+                label="Dataset Genre (100 Progressions Each)"
+            )
+            
+            gr.Markdown("### 2. Generation Settings")
+            order_slider = gr.Slider(minimum=1, maximum=3, step=1, value=1, label="Markov Chain Order")
+            length_slider = gr.Slider(minimum=2, maximum=16, step=1, value=8, label="Target Length (Chords)")
+
+            gr.Markdown("### 3. Post-Processing")
+            transpose_slider = gr.Slider(minimum=-12, maximum=12, step=1, value=0, label="Transpose (Semitones)")
+            voicing_dropdown = gr.Dropdown(
+                choices=["Root Position", "First Inversion", "Second Inversion", "Open / Spread", "Random Voice Leading"],
+                value="Root Position",
+                label="Chord Voicings"
+            )
+            instrument_dropdown = gr.Dropdown(choices=["Piano", "Metal Guitar"], value="Piano", label="Instrument")
+
+            generate_btn = gr.Button("Generate Chords", variant="primary")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### Output")
+            output_raw_text = gr.Textbox(label="Original Generated Progression", lines=2, interactive=False)
+            output_final_text = gr.Textbox(label="Final Progression (After Transposition)", lines=2, interactive=False)
+            output_audio = gr.Audio(label="Playback", type="filepath", autoplay=True)
+            output_midi = gr.File(label="Download MIDI", interactive=False)
+
+    generate_btn.click(
+        fn=lambda g, o, l, i, t, v: app_logic(g.lower(), o, l, i, t, v),
+        inputs=[genre_dropdown, order_slider, length_slider, instrument_dropdown, transpose_slider, voicing_dropdown],
+        outputs=[output_raw_text, output_final_text, output_audio, output_midi]
+    )
+
+demo.launch()