midigen-lib 0.1.0__py3-none-any.whl

midigen/__init__.py

@@ -0,0 +1,9 @@
+from .midigen import MidiGen
+from .track import Track
+from .note import Note
+from .chord import Chord, ChordProgression, Arpeggio
+from .key import Key, KEY_MAP
+from .drums import DrumKit
+from .song import Song
+from .section import Section
+from .instruments import INSTRUMENT_MAP

midigen/chord.py

@@ -0,0 +1,209 @@
+from typing import List
+from midigen.note import Note
+from midigen.key import KEY_MAP, Key
+from enum import Enum
+import music21
+
+
+class Chord:
+    def __init__(self, notes: List[Note]):
+        self.notes = notes
+        self.root = self.get_root()
+        self._calculate_start_time()
+        self._calculate_duration()
+
+    def __str__(self) -> str:
+        return f"[{', '.join(str(note) for note in self.notes)}]"
+
+    def _calculate_start_time(self) -> int:
+        """
+        Calculate the start time of the chord.
+
+        Returns:
+            The start time of the chord.
+        """
+        self.time = min(note.time for note in self.notes) if self.notes else 0
+        return self.time
+
+    def _calculate_duration(self) -> int:
+        """
+        Calculate the duration of the chord.
+
+        Returns:
+            The duration of the longest note in the chord.
+        """
+        if not self.notes:
+            return 0
+
+        # Find the earliest start time of any note in the chord
+        earliest_start_time = min(note.time for note in self.notes)
+        # Find the latest ending time, calculated as start time plus duration for each note
+        latest_end_time = max(note.time + note.duration for note in self.notes)
+
+        # The duration of the chord is the difference between the earliest start and the latest end
+        self.duration = latest_end_time - earliest_start_time
+        return self.duration
+
+    def add_note(self, note: Note) -> None:
+        self.notes.append(note)
+        self._calculate_duration()
+        self._calculate_start_time()
+
+    def get_chord(self) -> List[Note]:
+        return self.notes
+
+    def get_root(self) -> Note:
+        if self.notes:
+            self.root = self.notes[0]
+            return self.root
+        return None
+
+    def major_triad(self) -> List[Note]:
+        return [self.root, self.root + 4, self.root + 7]
+
+    def minor_triad(self) -> List[Note]:
+        return [self.root, self.root + 3, self.root + 7]
+
+    def dominant_seventh(self) -> List[Note]:
+        return self.major_triad() + [self.root + 10]
+
+    def major_seventh(self) -> List[Note]:
+        return self.major_triad() + [self.root + 11]
+
+    def minor_seventh(self) -> List[Note]:
+        return self.minor_triad() + [self.root + 10]
+
+    def half_diminished_seventh(self) -> List[Note]:
+        return [self.root, self.root + 3, self.root + 6, self.root + 10]
+
+    def diminished_seventh(self) -> List[Note]:
+        return [self.root, self.root + 3, self.root + 6, self.root + 9]
+
+    def minor_ninth(self) -> List[Note]:
+        return self.minor_seventh() + [self.root + 14]
+
+    def major_ninth(self) -> List[Note]:
+        return self.major_seventh() + [self.root + 14]
+
+    def dominant_ninth(self) -> List[Note]:
+        return self.dominant_seventh() + [self.root + 14]
+
+
+class ChordProgression:
+    def __init__(self, chords: List[Chord]):
+        self.chords = chords
+        self._calculate_start_time()
+        self._calculate_duration()
+
+    def __str__(self) -> str:
+        return f"[{', '.join(str(chord) for chord in self.chords)}]"
+
+    def get_progression(self) -> List[Chord]:
+        return self.chords
+
+    def _calculate_duration(self) -> int:
+        self.duration = sum(chord._calculate_duration() for chord in self.chords)
+        return self.duration
+
+    def _calculate_start_time(self) -> int:
+        self.time = min(chord._calculate_start_time() for chord in self.chords) if self.chords else 0
+        return self.time
+
+    def __eq__(self, other) -> bool:
+        return self.chords == other.chords
+
+    def add_chord(self, chord: Chord) -> None:
+        """
+        Add a chord (simultaneous notes) to the track.
+
+        :param chord: A Chord object.
+        """
+        self.chords.append(chord)
+        self._calculate_duration()
+        self._calculate_start_time()
+
+    @classmethod
+    def from_roman_numerals(
+        cls,
+        key: Key,
+        progression_string: str,
+        octave: int = 4,
+        duration: int = 480,
+        time_per_chord: int = 0
+    ):
+        m21_key = music21.key.Key(key.name, key.mode)
+        roman_numerals = progression_string.split('-')
+        chords = []
+        current_time = 0
+        for rn_str in roman_numerals:
+            rn = music21.roman.RomanNumeral(rn_str, m21_key)
+            pitches = rn.pitches
+            notes = []
+            for i, pitch in enumerate(pitches):
+                note_name = f"{pitch.nameWithOctave}"
+                # A simple way to handle octave, might need refinement
+                note_name_without_octave = ''.join(filter(str.isalpha, pitch.name))
+                full_note_name = f"{note_name_without_octave}{octave}"
+                midi_pitch = KEY_MAP.get(full_note_name)
+
+                # If the note is not in the current octave, try the next one
+                if midi_pitch is None:
+                    full_note_name = f"{note_name_without_octave}{octave + 1}"
+                    midi_pitch = KEY_MAP.get(full_note_name)
+
+                if midi_pitch:
+                    # The first note of the chord starts at `current_time`, subsequent notes start at the same time.
+                    note_time = current_time if i == 0 else 0
+                    notes.append(Note(pitch=midi_pitch, velocity=64, duration=duration, time=note_time))
+
+            if notes:
+                chords.append(Chord(notes))
+            current_time += time_per_chord
+
+        return cls(chords)
+
+
+class ArpeggioPattern(Enum):
+    ASCENDING = "ascending"
+    DESCENDING = "descending"
+    ALTERNATING = "alternating"
+
+
+class Arpeggio(Chord):
+    def __init__(self, notes: List[Note], delay: int = 0, pattern: ArpeggioPattern = ArpeggioPattern.ASCENDING, loops: int = 1):
+        """
+        :param root_note: The root note of the arpeggio.
+        :param delay: The delay between each note in the arpeggio.
+        """
+        super().__init__(notes)
+        self.delay = delay
+        self.pattern = pattern
+        self.loops = loops
+
+    def get_notes(self) -> List[Note]:
+        return self.notes
+
+    def get_sequential_notes(self) -> List[Note]:
+        """
+        Get the sequential notes of the arpeggio based on the pattern, delay, and looping.
+
+        Returns:
+            A list of notes representing the arpeggio.
+        """
+        sequential_notes = []
+        for loop in range(self.loops):
+            if self.pattern == ArpeggioPattern.ASCENDING:
+                notes = self.notes
+            elif self.pattern == ArpeggioPattern.DESCENDING:
+                notes = list(reversed(self.notes))
+            elif self.pattern == ArpeggioPattern.ALTERNATING:
+                notes = self.notes if loop % 2 == 0 else list(reversed(self.notes))
+
+            for i, note in enumerate(notes):
+                # Add an offset to the time for the second and subsequent loops
+                time_offset = loop * len(notes) * self.delay
+                time = note.time + time_offset if i == 0 else self.delay * i + time_offset
+                new_note = Note(note.pitch, note.velocity, note.duration, time)
+                sequential_notes.append(new_note)
+
+        return sequential_notes

midigen/drums.py

@@ -0,0 +1,104 @@
+from midigen.note import Note
+from typing import List
+
+GM1_DRUM_MAP = {
+    "Acoustic Bass Drum": 35,
+    "Bass Drum 1": 36,
+    "Side Stick": 37,
+    "Acoustic Snare": 38,
+    "Hand Clap": 39,
+    "Electric Snare": 40,
+    "Low Floor Tom": 41,
+    "Closed Hi Hat": 42,
+    "High Floor Tom": 43,
+    "Pedal Hi-Hat": 44,
+    "Low Tom": 45,
+    "Open Hi-Hat": 46,
+    "Low-Mid Tom": 47,
+    "Hi-Mid Tom": 48,
+    "Crash Cymbal 1": 49,
+    "High Tom": 50,
+    "Ride Cymbal 1": 51,
+    "Chinese Cymbal": 52,
+    "Ride Bell": 53,
+    "Tambourine": 54,
+    "Splash Cymbal": 55,
+    "Cowbell": 56,
+    "Crash Cymbal 2": 57,
+    "Vibraslap": 58,
+    "Ride Cymbal 2": 59,
+    "Hi Bongo": 60,
+    "Low Bongo": 61,
+    "Mute Hi Conga": 62,
+    "Open Hi Conga": 63,
+    "Low Conga": 64,
+    "High Timbale": 65,
+    "Low Timbale": 66,
+    "High Agogo": 67,
+    "Low Agogo": 68,
+    "Cabasa": 69,
+    "Maracas": 70,
+    "Short Whistle": 71,
+    "Long Whistle": 72,
+    "Short Guiro": 73,
+    "Long Guiro": 74,
+    "Claves": 75,
+    "Hi Wood Block": 76,
+    "Low Wood Block": 77,
+    "Mute Cuica": 78,
+    "Open Cuica": 79,
+    "Mute Triangle": 80,
+    "Open Triangle": 81,
+}
+
+
+class Drum:
+    """
+    A drum sound in a drum kit, represented as a MIDI note.
+    """
+
+    def __init__(self, pitch: int, velocity: int, duration: int, time: int):
+        if duration < 0:
+            raise ValueError("Duration must be non-negative")
+        if velocity < 0:
+            raise ValueError("Velocity must be non-negative")
+        if not 0 <= pitch <= 127:
+            raise ValueError("Pitch must be within the MIDI standard range of 0 to 127")
+
+        self.note = Note(pitch, velocity, duration, time)
+
+
+class DrumKit:
+    """
+    A collection of drum sounds, each represented as a MIDI note.
+    """
+
+    def __init__(self):
+        self.drums = []
+
+    def add_drum(
+        self, drum_name: str, velocity: int = 64, duration: int = 1, time: int = 0
+    ) -> None:
+        """
+        Add a drum to the drum kit.
+
+        :param drum_name: The name of the drum, as defined in the GM1_DRUM_MAP.
+        :param velocity: The velocity of the drum sound.
+        :param duration: The duration of the drum sound.
+        :param time: The time at which the drum sound should start.
+        """
+        if drum_name not in GM1_DRUM_MAP:
+            raise ValueError(
+                f"Invalid drum name: {drum_name}. Please use a valid drum name from the GM1_DRUM_MAP."
+            )
+
+        drum = Drum(GM1_DRUM_MAP[drum_name], velocity, duration, time)
+        self.drums.append(drum)
+
+    def get_drums(self) -> List[Note]:
+        """
+        Get the list of drums in the drum kit.
+
+        :return: A list of Drum objects.
+        """
+        return [drum.note for drum in self.drums]

midigen/instruments.py

@@ -0,0 +1,146 @@
+INSTRUMENT_MAP = {
+    # Piano
+    "Acoustic Grand Piano": 0,
+    "Bright Acoustic Piano": 1,
+    "Electric Grand Piano": 2,
+    "Honky-tonk Piano": 3,
+    "Electric Piano 1": 4,
+    "Electric Piano 2": 5,
+    "Harpsichord": 6,
+    "Clavinet": 7,
+    # Chromatic Percussion
+    "Celesta": 8,
+    "Glockenspiel": 9,
+    "Music Box": 10,
+    "Vibraphone": 11,
+    "Marimba": 12,
+    "Xylophone": 13,
+    "Tubular Bells": 14,
+    "Dulcimer": 15,
+    # Organ
+    "Drawbar Organ": 16,
+    "Percussive Organ": 17,
+    "Rock Organ": 18,
+    "Church Organ": 19,
+    "Reed Organ": 20,
+    "Accordion": 21,
+    "Harmonica": 22,
+    "Tango Accordion": 23,
+    # Guitar
+    "Acoustic Guitar (nylon)": 24,
+    "Acoustic Guitar (steel)": 25,
+    "Electric Guitar (jazz)": 26,
+    "Electric Guitar (clean)": 27,
+    "Electric Guitar (muted)": 28,
+    "Overdriven Guitar": 29,
+    "Distortion Guitar": 30,
+    "Guitar Harmonics": 31,
+    # Bass
+    "Acoustic Bass": 32,
+    "Electric Bass (finger)": 33,
+    "Electric Bass (pick)": 34,
+    "Fretless Bass": 35,
+    "Slap Bass 1": 36,
+    "Slap Bass 2": 37,
+    "Synth Bass 1": 38,
+    "Synth Bass 2": 39,
+    # Strings
+    "Violin": 40,
+    "Viola": 41,
+    "Cello": 42,
+    "Contrabass": 43,
+    "Tremolo Strings": 44,
+    "Pizzicato Strings": 45,
+    "Orchestral Harp": 46,
+    "Timpani": 47,
+    # Ensemble
+    "String Ensemble 1": 48,
+    "String Ensemble 2": 49,
+    "Synth Strings 1": 50,
+    "Synth Strings 2": 51,
+    "Choir Aahs": 52,
+    "Voice Oohs": 53,
+    "Synth Voice": 54,
+    "Orchestra Hit": 55,
+    # Brass
+    "Trumpet": 56,
+    "Trombone": 57,
+    "Tuba": 58,
+    "Muted Trumpet": 59,
+    "French Horn": 60,
+    "Brass Section": 61,
+    "Synth Brass 1": 62,
+    "Synth Brass 2": 63,
+    # Reed
+    "Soprano Sax": 64,
+    "Alto Sax": 65,
+    "Tenor Sax": 66,
+    "Baritone Sax": 67,
+    "Oboe": 68,
+    "English Horn": 69,
+    "Bassoon": 70,
+    "Clarinet": 71,
+    # Pipe
+    "Piccolo": 72,
+    "Flute": 73,
+    "Recorder": 74,
+    "Pan Flute": 75,
+    "Blown Bottle": 76,
+    "Shakuhachi": 77,
+    "Whistle": 78,
+    "Ocarina": 79,
+    # Synth Lead
+    "Lead 1 (square)": 80,
+    "Lead 2 (sawtooth)": 81,
+    "Lead 3 (calliope)": 82,
+    "Lead 4 (chiff)": 83,
+    "Lead 5 (charang)": 84,
+    "Lead 6 (voice)": 85,
+    "Lead 7 (fifths)": 86,
+    "Lead 8 (bass + lead)": 87,
+    # Synth Pad
+    "Pad 1 (new age)": 88,
+    "Pad 2 (warm)": 89,
+    "Pad 3 (polysynth)": 90,
+    "Pad 4 (choir)": 91,
+    "Pad 5 (bowed)": 92,
+    "Pad 6 (metallic)": 93,
+    "Pad 7 (halo)": 94,
+    "Pad 8 (sweep)": 95,
+    # Synth Effects
+    "FX 1 (rain)": 96,
+    "FX 2 (soundtrack)": 97,
+    "FX 3 (crystal)": 98,
+    "FX 4 (atmosphere)": 99,
+    "FX 5 (brightness)": 100,
+    "FX 6 (goblins)": 101,
+    "FX 7 (echoes)": 102,
+    "FX 8 (sci-fi)": 103,
+    # Ethnic
+    "Sitar": 104,
+    "Banjo": 105,
+    "Shamisen": 106,
+    "Koto": 107,
+    "Kalimba": 108,
+    "Bagpipe": 109,
+    "Fiddle": 110,
+    "Shanai": 111,
+    # Percussive
+    "Tinkle Bell": 112,
+    "Agogo": 113,
+    "Steel Drums": 114,
+    "Woodblock": 115,
+    "Taiko Drum": 116,
+    "Melodic Tom": 117,
+    "Synth Drum": 118,
+    "Reverse Cymbal": 119,
+    # Sound Effects
+    "Guitar Fret Noise": 120,
+    "Breath Noise": 121,
+    "Seashore": 122,
+    "Bird Tweet": 123,
+    "Telephone Ring": 124,
+    "Helicopter": 125,
+    "Applause": 126,
+    "Gunshot": 127,
+}

midigen/key.py

@@ -0,0 +1,203 @@
+VALID_KEYS = [
+    (note, mode)
+    for note in [
+        "A",
+        "A#",
+        "Ab",
+        "B",
+        "Bb",
+        "C",
+        "C#",
+        "Cb",
+        "D",
+        "D#",
+        "Db",
+        "E",
+        "Eb",
+        "F",
+        "F#",
+        "Fb",
+        "G",
+        "G#",
+        "Gb",
+    ]
+    for mode in ["major", "minor"]
+]
+
+KEY_MAP = {
+    "C0": 12,
+    "C#0": 13,
+    "Db0": 13,
+    "D0": 14,
+    "D#0": 15,
+    "Eb0": 15,
+    "E0": 16,
+    "F0": 17,
+    "F#0": 18,
+    "Gb0": 18,
+    "G0": 19,
+    "G#0": 20,
+    "Ab0": 20,
+    "A0": 21,
+    "A#0": 22,
+    "Bb0": 22,
+    "B0": 23,
+    "C1": 24,
+    "C#1": 25,
+    "Db1": 25,
+    "D1": 26,
+    "D#1": 27,
+    "Eb1": 27,
+    "E1": 28,
+    "F1": 29,
+    "F#1": 30,
+    "Gb1": 30,
+    "G1": 31,
+    "G#1": 32,
+    "Ab1": 32,
+    "A1": 33,
+    "A#1": 34,
+    "Bb1": 34,
+    "B1": 35,
+    "C2": 36,
+    "C#2": 37,
+    "Db2": 37,
+    "D2": 38,
+    "D#2": 39,
+    "Eb2": 39,
+    "E2": 40,
+    "F2": 41,
+    "F#2": 42,
+    "Gb2": 42,
+    "G2": 43,
+    "G#2": 44,
+    "Ab2": 44,
+    "A2": 45,
+    "A#2": 46,
+    "Bb2": 46,
+    "B2": 47,
+    "C3": 48,
+    "C#3": 49,
+    "Db3": 49,
+    "D3": 50,
+    "D#3": 51,
+    "Eb3": 51,
+    "E3": 52,
+    "F3": 53,
+    "F#3": 54,
+    "Gb3": 54,
+    "G3": 55,
+    "G#3": 56,
+    "Ab3": 56,
+    "A3": 57,
+    "A#3": 58,
+    "Bb3": 58,
+    "B3": 59,
+    "C4": 60,
+    "C#4": 61,
+    "Db4": 61,
+    "D4": 62,
+    "D#4": 63,
+    "Eb4": 63,
+    "E4": 64,
+    "F4": 65,
+    "F#4": 66,
+    "Gb4": 66,
+    "G4": 67,
+    "G#4": 68,
+    "Ab4": 68,
+    "A4": 69,
+    "A#4": 70,
+    "Bb4": 70,
+    "B4": 71,
+    "C5": 72,
+    "C#5": 73,
+    "Db5": 73,
+    "D5": 74,
+    "D#5": 75,
+    "Eb5": 75,
+    "E5": 76,
+    "F5": 77,
+    "F#5": 78,
+    "Gb5": 78,
+    "G5": 79,
+    "G#5": 80,
+    "Ab5": 80,
+    "A5": 81,
+    "A#5": 82,
+    "Bb5": 82,
+    "B5": 83,
+    "C6": 84,
+    "C#6": 85,
+    "Db6": 85,
+    "D6": 86,
+    "D#6": 87,
+    "Eb6": 87,
+    "E6": 88,
+    "F6": 89,
+    "F#6": 90,
+    "Gb6": 90,
+    "G6": 91,
+    "G#6": 92,
+    "Ab6": 92,
+    "A6": 93,
+    "A#6": 94,
+    "Bb6": 94,
+    "B6": 95,
+    "C7": 96,
+    "C#7": 97,
+    "Db7": 97,
+    "D7": 98,
+    "D#7": 99,
+    "Eb7": 99,
+    "E7": 100,
+    "F7": 101,
+    "F#7": 102,
+    "Gb7": 102,
+    "G7": 103,
+    "G#7": 104,
+    "Ab7": 104,
+    "A7": 105,
+    "A#7": 106,
+    "Bb7": 106,
+    "B7": 107,
+    "C8": 108,
+    "C#8": 109,
+    "Db8": 109,
+    "D8": 110,
+    "D#8": 111,
+    "Eb8": 111,
+    "E8": 112,
+    "F8": 113,
+    "F#8": 114,
+    "Gb8": 114,
+    "G8": 115,
+    "G#8": 116,
+    "Ab8": 116,
+    "A8": 117,
+    "A#8": 118,
+    "Bb8": 118,
+    "B8": 119,
+}
+
+
+class Key:
+    def __init__(self, name: str, mode: str = "major"):
+        if (name, mode) not in VALID_KEYS:
+            raise ValueError(
+                f"Invalid key. Please use a valid key from the list: {format(VALID_KEYS)}"
+            )
+
+        self.name = name
+        self.mode = mode
+
+    def __str__(self) -> str:
+        return f"{self.name}{'' if self.mode == 'major' else 'm'}"
+
+    def __repr__(self) -> str:
+        return f"Key(name='{self.name}', mode='{self.mode}')"
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Key):
+            return self.name == other.name and self.mode == other.mode
+        return False