Simple Python code to create MIDI files from melodic patterns formatted as arrays of intervals in semitones (from #DigThatLick). Created with the kind help of ChatGPT 4 (because I’m a noncoder and it was a valuable learning exercise).

JazzPatt.tsv

JazzPatt2MIDI

import mido
from mido import MidiFile, MidiTrack, Message
import csv
import ast

def intervals_to_midi_pattern(intervals, start_note=60):
    """
    Converts a list of intervals into a MIDI pattern (sequence of notes).

    :param intervals: A list of intervals (difference in pitch between notes).
    :param start_note: The MIDI note number to start the pattern from.
    :return: A list of MIDI note numbers forming the pattern.
    """
    pattern = [start_note]
    for interval in intervals:
        pattern.append(pattern[-1] + interval)
    return pattern

def append_pattern_to_track(track, pattern, bar_duration=1920):
    """
    Appends a MIDI pattern to a track, followed by silence to align the next pattern to a new bar.

    :param track: The MIDI track to append the pattern to.
    :param pattern: The MIDI pattern to append.
    :param bar_duration: The duration of a bar in MIDI ticks (default is 1920 for a 4/4 bar).
    """
    is_first_note = True
    pattern_duration = 0
    previous_note = None  # Initialize previous note
    
    for note in pattern:
        # Duration of a note alternates for a swing rhythm
        note_duration = 320 if is_first_note else 160
        # Accentuate notes on the downbeat that are higher than the previous note
        if is_first_note and (previous_note is None or note > previous_note):
            velocity = 120  # Higher velocity for accented note
        else:
            velocity = 30  # Regular velocity

        note_on = Message('note_on', note=note, velocity=velocity, time=0)
        note_off = Message('note_off', note=note, velocity=velocity, time=note_duration)
        track.append(note_on)
        track.append(note_off)

        previous_note = note  # Update the previous note
        pattern_duration += note_duration
        is_first_note = not is_first_note

    # Add silence to align the start of the next pattern with a new bar
    remaining_duration = bar_duration - (pattern_duration % bar_duration)
    if remaining_duration < bar_duration:
        track.append(Message('note_off', note=0, velocity=0, time=remaining_duration))
	# Add an extra bar of silence
    track.append(Message('note_off', note=0, velocity=0, time=bar_duration))

def create_combined_midi(patterns, output_file):
    """
    Creates a single MIDI file from a list of MIDI patterns, each starting at a new bar.

    :param patterns: A list of MIDI patterns.
    :param output_file: The filename for the output MIDI file.
    """
    mid = MidiFile()
    track = MidiTrack()
    mid.tracks.append(track)
    
    for pattern in patterns:
        append_pattern_to_track(track, pattern)

    mid.save(output_file)

def create_midi_for_single_pattern(pattern, pattern_id, index, num_instances, bar_duration=1920):
    """
    Creates an individual MIDI file for a given pattern.

    :param pattern: The MIDI pattern.
    :param pattern_id: The ID of the pattern.
    :param index: The index number of the pattern.
    :param num_instances: The number of instances of the pattern.
    :param bar_duration: The duration of a bar in MIDI ticks.
    """
    filename = f"pattern_{index}_{num_instances}_{pattern_id}.mid"
    mid = MidiFile()
    track = MidiTrack()
    mid.tracks.append(track)

    append_pattern_to_track(track, pattern, bar_duration)
    mid.save(filename)

# Read melodic patterns from CSV file and create individual MIDI files
with open('JazzPatt.csv', newline='') as csvfile:
    reader = csv.reader(csvfile, delimiter=';')
    next(reader)  # Skip the header row
    for index, row in enumerate(reader, start=1):
        pattern = ast.literal_eval(row[0])
        pattern_id = row[1]
        num_instances = row[2]
        midi_pattern = intervals_to_midi_pattern(pattern)
        create_midi_for_single_pattern(midi_pattern, pattern_id, index, num_instances)