pychord 1.2.3__py3-none-any.whl

examples/pychord-midi.py

@@ -0,0 +1,32 @@
+# An example to create MIDI file with PyChord and pretty_midi
+# Prerequisite: pip install pretty_midi
+# pretty_midi: https://github.com/craffel/pretty-midi
+
+
+import pretty_midi
+
+from pychord import Chord
+
+
+def create_midi(chords):
+    midi_data = pretty_midi.PrettyMIDI()
+    piano_program = pretty_midi.instrument_name_to_program('Acoustic Grand Piano')
+    piano = pretty_midi.Instrument(program=piano_program)
+    length = 1
+    for n, chord in enumerate(chords):
+        for note_name in chord.components_with_pitch(root_pitch=4):
+            note_number = pretty_midi.note_name_to_number(note_name)
+            note = pretty_midi.Note(velocity=100, pitch=note_number, start=n * length, end=(n + 1) * length)
+            piano.notes.append(note)
+    midi_data.instruments.append(piano)
+    midi_data.write('chord.mid')
+
+
+def main():
+    chords_str = ["C", "Dm7", "G", "C"]
+    chords = [Chord(c) for c in chords_str]
+    create_midi(chords)
+
+
+if __name__ == '__main__':
+    main()

pychord/__init__.py

@@ -0,0 +1,5 @@
+# flake8: noqa
+from .analyzer import find_chords_from_notes
+from .chord import Chord
+from .progression import ChordProgression
+from .quality import Quality, QualityManager

pychord/analyzer.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from .chord import Chord
+from .quality import QualityManager
+from .utils import note_to_val
+
+
+def find_chords_from_notes(notes: List[str]) -> List[Chord]:
+    """ Find possible chords consisted from notes
+
+    :param notes: List of note arranged from lower note. ex) ["C", "Eb", "G"]
+    :return: List of chord
+    """
+    if not notes:
+        raise ValueError("Please specify notes which consist a chord.")
+    root = notes[0]
+    root_and_positions = []
+    for rotated_notes in get_all_rotated_notes(notes):
+        rotated_root = rotated_notes[0]
+        root_and_positions.append((rotated_root, notes_to_positions(rotated_notes, rotated_notes[0])))
+    chords = []
+    for temp_root, positions in root_and_positions:
+        quality = QualityManager().find_quality_from_components(positions)
+        if quality is None:
+            continue
+        if temp_root == root:
+            chord = "{}{}".format(root, quality)
+        else:
+            chord = "{}{}/{}".format(temp_root, quality, root)
+        chords.append(Chord(chord))
+    return chords
+
+
+def notes_to_positions(notes: List[str], root: str) -> List[int]:
+    """ Get notes positions from the root note
+
+    >>> notes_to_positions(["C", "E", "G"], "C")
+    [0, 4, 7]
+
+    :param notes: List of notes
+    :param root: Root note
+    :return: List of note positions
+    """
+    root_pos = note_to_val(root)
+    current_pos = root_pos
+    positions = []
+    for note in notes:
+        note_pos = note_to_val(note)
+        if note_pos < current_pos:
+            note_pos += 12 * ((current_pos - note_pos) // 12 + 1)
+        positions.append(note_pos - root_pos)
+        current_pos = note_pos
+    return positions
+
+
+def get_all_rotated_notes(notes: List[str]) -> List[List[str]]:
+    """ Get all rotated notes
+
+    get_all_rotated_notes([A,C,E]) -> [[A,C,E],[C,E,A],[E,A,C]]
+    """
+    notes_list = []
+    for x in range(len(notes)):
+        notes_list.append(notes[x:] + notes[:x])
+    return notes_list

pychord/chord.py

@@ -0,0 +1,206 @@
+from typing import List, Union
+
+from .constants import NOTE_VAL_DICT, VAL_NOTE_DICT
+from .constants.scales import RELATIVE_KEY_DICT
+from .parser import parse
+from .quality import QualityManager, Quality
+from .utils import transpose_note, display_appended, display_on, note_to_val, val_to_note
+
+
+class Chord:
+    """ Class to handle a chord.
+
+    Attributes:
+        _chord: Name of the chord. (e.g. C, Am7, F#m7-5/A)
+        _root: The root note of chord. (e.g. C, A, F#)
+        _quality: The quality of chord. (e.g. maj, m7, m7-5)
+        _appended: The appended notes on chord.
+        _on: The base note of slash chord.
+    """
+
+    def __init__(self, chord: str):
+        """ Constructor of Chord instance
+
+        :param chord: Name of chord (e.g. C, Am7, F#m7-5/A).
+        """
+        root, quality, appended, on = parse(chord)
+        self._chord: str = chord
+        self._root: str = root
+        self._quality: Quality = quality
+        self._appended: List[str] = appended
+        self._on: str = on
+
+        self._append_on_chord()
+
+    def __unicode__(self):
+        return self._chord
+
+    def __str__(self):
+        return self._chord
+
+    def __repr__(self):
+        return f"<Chord: {self._chord}>"
+
+    def __eq__(self, other):
+        if not isinstance(other, Chord):
+            raise TypeError(f"Cannot compare Chord object with {type(other)} object")
+        if note_to_val(self._root) != note_to_val(other.root):
+            return False
+        if self._quality != other.quality:
+            return False
+        if self._appended != other.appended:
+            return False
+        if self._on and other.on:
+            if note_to_val(self._on) != note_to_val(other.on):
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @classmethod
+    def from_note_index(
+        cls,
+        note: int,
+        quality: str,
+        scale: str,
+        diatonic: bool = False,
+        chromatic: int = 0,
+    ) -> "Chord":
+        """Create a Chord from note index in a scale
+
+        Chord.from_note_index(1, "", "Cmaj") returns I of C major => Chord("C")
+        Chord.from_note_index(3, "m7", "Fmaj") returns IIImin of F major => Chord("Am7")
+        Chord.from_note_index(5, "7", "Amin") returns Vmin of A minor => Chord("E7")
+        Chord.from_note_index(2, "", "Cmaj") returns II of C major => Chord("D")
+        Chord.from_note_index(2, "m", "Cmaj") returns IImin of C major => Chord("Dm")
+        Chord.from_note_index(2, "", "Cmaj", diatonic=True) returns IImin of C major => Chord("Dm")
+        Chord.from_note_index(2, "", "Cmin", chromatic=-1) returns bII of C minor => Chord("Db")
+
+        :param note: Scale degree of the chord's root (1-7)
+        :param quality: Quality of the chord (e.g. m7, sus4)
+        :param scale: Base scale (e.g. Cmaj, Amin, F#maj, Ebmin)
+        :param diatonic: If True, chord quality is determined using the base scale (overrides :param quality)
+        :param chromatic: Lower or raise the scale degree (and all notes of the chord) by semitone(s)
+        """
+        if not 1 <= note <= 8:
+            raise ValueError(f"Invalid note {note}")
+        relative_key = RELATIVE_KEY_DICT[scale[-3:]][note - 1]
+        root_num = NOTE_VAL_DICT[scale[:-3]] + chromatic
+        root = VAL_NOTE_DICT[(root_num + relative_key) % 12][0]
+
+        scale_degrees = RELATIVE_KEY_DICT[scale[-3:]]
+
+        if diatonic:
+            # construct the chord based on scale degrees, within 1 octave
+            third = scale_degrees[(note + 1) % 7]
+            fifth = scale_degrees[(note + 3) % 7]
+            seventh = scale_degrees[(note + 5) % 7]
+
+            # adjust the chord to its root position (as a stack of thirds),
+            # then set the root to 0
+            # e.g. (9, 0, 4) -> [0, 3, 7]
+            def get_diatonic_chord(chord):
+                uninverted = []
+                for note in chord:
+                    if not uninverted:
+                        uninverted.append(note)
+                    elif note > uninverted[-1]:
+                        uninverted.append(note)
+                    else:
+                        uninverted.append(note + 12)
+                uninverted = [x - uninverted[0] for x in uninverted]
+                return uninverted
+
+            if quality in ["", "-", "maj", "m", "min"]:
+                triad = (relative_key, third, fifth)
+                q = get_diatonic_chord(triad)
+            elif quality in ["7", "M7", "maj7", "m7"]:
+                seventh_chord = (relative_key, third, fifth, seventh)
+                q = get_diatonic_chord(seventh_chord)
+            else:
+                raise NotImplementedError("Only generic chords (triads, sevenths) are supported")
+
+            # look up QualityManager to determine chord quality
+            quality_manager = QualityManager()
+            quality = quality_manager.find_quality_from_components(q)
+            if not quality:
+                raise RuntimeError(f"Quality with components {q} not found")
+
+        return cls(f"{root}{quality}")
+
+    @property
+    def chord(self):
+        """ The name of chord """
+        return self._chord
+
+    @property
+    def root(self):
+        """ The root note of chord """
+        return self._root
+
+    @property
+    def quality(self):
+        """ The quality of chord """
+        return self._quality
+
+    @property
+    def appended(self):
+        """ The appended notes on chord """
+        return self._appended
+
+    @property
+    def on(self):
+        """ The base note of slash chord """
+        return self._on
+
+    def info(self):
+        """ Return information of chord to display """
+        return f"""{self._chord}
+root={self._root}
+quality={self._quality}
+appended={self._appended}
+on={self._on}"""
+
+    def transpose(self, trans: int, scale: str = "C") -> None:
+        """ Transpose the chord
+
+        :param trans: Transpose key
+        :param scale: key scale
+        """
+        if not isinstance(trans, int):
+            raise TypeError(f"Expected integers, not {type(trans)}")
+        self._root = transpose_note(self._root, trans, scale)
+        if self._on:
+            self._on = transpose_note(self._on, trans, scale)
+        self._reconfigure_chord()
+
+    def components(self, visible: bool = True) -> Union[List[str], List[int]]:
+        """ Return the component notes of chord
+
+        :param visible: returns the name of notes if True else list of int
+        :return: component notes of chord
+        """
+        return self._quality.get_components(root=self._root, visible=visible)
+
+    def components_with_pitch(self, root_pitch: int) -> List[str]:
+        """ Return the component notes of chord formatted like ["C4", "E4", "G4"]
+
+        :param root_pitch: the pitch of the root note
+        :return: component notes of chord
+        """
+        components = self._quality.get_components(root=self._root)
+        if components[0] < 0:
+            components = [c + 12 for c in components]
+        return [f"{val_to_note(c, scale=self._root)}{root_pitch + c // 12}" for c in components]
+
+    def _append_on_chord(self):
+        if self._on:
+            self._quality.append_on_chord(self.on, self.root)
+
+    def _reconfigure_chord(self):
+        # TODO: Use appended
+        self._chord = "{}{}{}{}".format(self._root,
+                                        self._quality.quality,
+                                        display_appended(self._appended),
+                                        display_on(self._on))

pychord/constants/__init__.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+from .scales import NOTE_VAL_DICT, VAL_NOTE_DICT, SCALE_VAL_DICT

pychord/constants/qualities.py

@@ -0,0 +1,115 @@
+# Do not import DEFAULT_QUALITIES directly
+# Use QualityManager instead
+DEFAULT_QUALITIES = [
+    # chords consist of 2 notes
+    ('5', (0, 7)),
+    ('no5', (0, 4)),
+    ('omit5', (0, 4)),
+    ('m(no5)', (0, 3)),
+    ('m(omit5)', (0, 3)),
+    # 3 notes
+    ('', (0, 4, 7)),
+    ('maj', (0, 4, 7)),
+    ('m', (0, 3, 7)),
+    ('min', (0, 3, 7)),
+    ('-', (0, 3, 7)),
+    ('dim', (0, 3, 6)),
+    # Not to confuse Ab5 with A(b5)
+    ('(b5)', (0, 4, 6)),
+    ('aug', (0, 4, 8)),
+    ('sus2', (0, 2, 7)),
+    ('sus4', (0, 5, 7)),
+    ('sus', (0, 5, 7)),
+    # 4 notes
+    ('6', (0, 4, 7, 9)),
+    ('6b5', (0, 4, 6, 9)),  # https://www.scales-chords.com/chord/piano/C%236b5
+    ('6-5', (0, 4, 6, 9)),  # https://www.scales-chords.com/chord/piano/C%236b5
+    ('7', (0, 4, 7, 10)),
+    ('7-5', (0, 4, 6, 10)),
+    ('7b5', (0, 4, 6, 10)),
+    ('7+5', (0, 4, 8, 10)),
+    ('7#5', (0, 4, 8, 10)),
+    ('7sus4', (0, 5, 7, 10)),
+    ('m6', (0, 3, 7, 9)),
+    ('m7', (0, 3, 7, 10)),
+    ('m7-5', (0, 3, 6, 10)),
+    ('m7b5', (0, 3, 6, 10)),
+    ('m7+5', (0, 3, 8, 10)),
+    ('m7#5', (0, 3, 8, 10)),
+    ('dim6', (0, 3, 6, 8)),
+    ('dim7', (0, 3, 6, 9)),
+    ('M7', (0, 4, 7, 11)),
+    ('maj7', (0, 4, 7, 11)),
+    ('maj7+5', (0, 4, 8, 11)),
+    ('M7+5', (0, 4, 8, 11)),
+    ('mmaj7', (0, 3, 7, 11)),
+    ('mM7', (0, 3, 7, 11)),
+    ('add4', (0, 4, 5, 7)),
+    ('majadd4', (0, 4, 5, 7)),
+    ('Madd4', (0, 4, 5, 7)),
+    ('madd4', (0, 3, 5, 7)),
+    ('add9', (0, 4, 7, 14)),
+    ('majadd9', (0, 4, 7, 14)),
+    ('Madd9', (0, 4, 7, 14)),
+    ('madd9', (0, 3, 7, 14)),
+    ('sus4add9', (0, 5, 7, 14)),
+    ('sus4add2', (0, 2, 5, 7)),
+    ('2', (0, 4, 7, 14)),
+    ('add11', (0, 4, 7, 17)),
+    ('4', (0, 4, 7, 17)),
+    # 5 notes
+    ('m69', (0, 3, 7, 9, 14)),
+    ('69', (0, 4, 7, 9, 14)),
+    ('9', (0, 4, 7, 10, 14)),
+    ('m9', (0, 3, 7, 10, 14)),
+    ('M9', (0, 4, 7, 11, 14)),
+    ('maj9', (0, 4, 7, 11, 14)),
+    ('9sus4', (0, 5, 7, 10, 14)),
+    ('7-9', (0, 4, 7, 10, 13)),
+    ('7b9', (0, 4, 7, 10, 13)),
+    ('7(b9)', (0, 4, 7, 10, 13)),   # https://www.oolimo.com/guitarchords/Fsharp7(b9)
+    ('7+9', (0, 4, 7, 10, 15)),
+    ('7#9', (0, 4, 7, 10, 15)),
+    ('9-5', (0, 4, 6, 10, 14)),
+    ('9b5', (0, 4, 6, 10, 14)),
+    ('9+5', (0, 4, 8, 10, 14)),
+    ('9#5', (0, 4, 8, 10, 14)),
+    ('7#9b5', (0, 4, 6, 10, 15)),
+    ('7#9#5', (0, 4, 8, 10, 15)),
+    ('m7b9b5', (0, 3, 6, 10, 13)),
+    ('7b9b5', (0, 4, 6, 10, 13)),
+    ('7b9#5', (0, 4, 8, 10, 13)),
+    ('11', (0, 7, 10, 14, 17)),
+    ('7+11', (0, 4, 7, 10, 18)),
+    ('7#11', (0, 4, 7, 10, 18)),
+    ('maj7+11', (0, 4, 7, 11, 18)),
+    ('M7+11', (0, 4, 7, 11, 18)),
+    ('maj7#11', (0, 4, 7, 11, 18)),
+    ('M7#11', (0, 4, 7, 11, 18)),
+    ('7b9#9', (0, 4, 7, 10, 13, 15)),
+    ('7b9#11', (0, 4, 7, 10, 13, 18)),
+    ('7#9#11', (0, 4, 7, 10, 15, 18)),
+    ('7-13', (0, 4, 7, 10, 20)),
+    ('7b13', (0, 4, 7, 10, 20)),
+    ('m7add11', (0, 3, 7, 10, 17)),
+    ('maj7add11', (0, 4, 7, 11, 17)),
+    ('M7add11', (0, 4, 7, 11, 17)),
+    ('mmaj7add11', (0, 3, 7, 11, 17)),
+    ('mM7add11', (0, 3, 7, 11, 17)),
+    # 6 notes
+    ('7b9b13', (0, 4, 7, 10, 13, 17, 20)),
+    ('9+11', (0, 4, 7, 10, 14, 18)),
+    ('9#11', (0, 4, 7, 10, 14, 18)),
+    ('m11', (0, 3, 7, 10, 14, 17)),    # https://chord-c.com/guitar-chord/B/minor-eleventh/
+    ('13', (0, 4, 7, 10, 14, 21)),
+    ('13-9', (0, 4, 7, 10, 13, 21)),
+    ('13b9', (0, 4, 7, 10, 13, 21)),
+    ('13+9', (0, 4, 7, 10, 15, 21)),
+    ('13#9', (0, 4, 7, 10, 15, 21)),
+    ('13+11', (0, 4, 7, 10, 18, 21)),
+    ('13#11', (0, 4, 7, 10, 18, 21)),
+    ('maj13', (0, 4, 7, 11, 14, 21)),   # https://chord-c.com/guitar-chord/C/major-thirteenth/
+    ('M13', (0, 4, 7, 11, 14, 21)),
+    ('maj7add13', (0, 4, 7, 9, 11, 14)),
+    ('M7add13', (0, 4, 7, 9, 11, 14)),
+]

pychord/constants/scales.py

@@ -0,0 +1,80 @@
+NOTE_VAL_DICT = {
+    'Ab': 8,
+    'A': 9,
+    'A#': 10,
+    'Bb': 10,
+    'B': 11,
+    'Cb': 11,
+    'C': 0,
+    'C#': 1,
+    'Db': 1,
+    'D': 2,
+    'D#': 3,
+    'Eb': 3,
+    'E': 4,
+    'F': 5,
+    'F#': 6,
+    'Gb': 6,
+    'G': 7,
+    'G#': 8,
+}
+
+VAL_NOTE_DICT = {
+    0: ['C'],
+    1: ['Db', 'C#'],
+    2: ['D'],
+    3: ['Eb', 'D#'],
+    4: ['E'],
+    5: ['F'],
+    6: ['F#', 'Gb'],
+    7: ['G'],
+    8: ['Ab', 'G#'],
+    9: ['A'],
+    10: ['Bb', 'A#'],
+    11: ['B', 'Cb']
+}
+
+SHARPED_SCALE = {
+    0: 'C', 1: 'C#', 2: 'D', 3: 'D#',
+    4: 'E', 5: 'F', 6: 'F#', 7: 'G',
+    8: 'G#', 9: 'A', 10: 'A#', 11: 'B'
+}
+
+FLATTED_SCALE = {
+    0: 'C', 1: 'Db', 2: 'D', 3: 'Eb',
+    4: 'E', 5: 'F', 6: 'Gb', 7: 'G',
+    8: 'Ab', 9: 'A', 10: 'Bb', 11: 'B'
+}
+
+SCALE_VAL_DICT = {
+    'Ab': FLATTED_SCALE,
+    'A': SHARPED_SCALE,
+    'A#': SHARPED_SCALE,
+    'Bb': FLATTED_SCALE,
+    'B': SHARPED_SCALE,
+    'Cb': FLATTED_SCALE,
+    'C': FLATTED_SCALE,
+    'C#': SHARPED_SCALE,
+    'Db': FLATTED_SCALE,
+    'D': SHARPED_SCALE,
+    'D#': SHARPED_SCALE,
+    'Eb': FLATTED_SCALE,
+    'E': SHARPED_SCALE,
+    'F': FLATTED_SCALE,
+    'F#': SHARPED_SCALE,
+    'Gb': FLATTED_SCALE,
+    'G': SHARPED_SCALE,
+    'G#': SHARPED_SCALE,
+}
+
+# https://en.wikipedia.org/wiki/Mode_(music)#Modern_modes
+# Ionian -> maj, Aeolian -> min
+RELATIVE_KEY_DICT = {
+    'maj': [0, 2, 4, 5, 7, 9, 11, 12],
+    'Dor': [0, 2, 3, 5, 7, 9, 10, 12],
+    'Phr': [0, 1, 3, 5, 7, 8, 10, 12],
+    'Lyd': [0, 2, 4, 6, 7, 9, 11, 12],
+    'Mix': [0, 2, 4, 5, 7, 9, 10, 12],
+    'min': [0, 2, 3, 5, 7, 8, 10, 12],
+    'Loc': [0, 1, 3, 5, 6, 8, 10, 12],
+}

pychord/parser.py

@@ -0,0 +1,47 @@
+from typing import Tuple, List
+import re
+
+from .quality import QualityManager, Quality
+from .utils import NOTE_VAL_DICT
+
+inversion_re = re.compile("/([0-9]+)")
+
+
+def parse(chord: str) -> Tuple[str, Quality, List[str], str]:
+    """Parse a string to get chord component
+
+    :param chord: str expression of a chord
+    :return: (root, quality, appended, on)
+    """
+
+    if len(chord) > 1 and chord[1] in ("b", "#"):
+        root = chord[:2]
+        rest = chord[2:]
+    else:
+        root = chord[:1]
+        rest = chord[1:]
+
+    def check_note(note: str):
+        """ Raise ValueError if note is invalid """
+        if note not in NOTE_VAL_DICT:
+            raise ValueError(f"Invalid note {note}")
+
+    check_note(root)
+
+    inversion = 0
+    inversion_m = inversion_re.search(rest)
+    if inversion_m:
+        inversion = int(inversion_m.group(1))
+        rest = inversion_re.sub("", rest)
+
+    on_chord_idx = rest.find("/")
+    if on_chord_idx >= 0:
+        on = rest[on_chord_idx + 1:]
+        rest = rest[:on_chord_idx]
+        check_note(on)
+    else:
+        on = ""
+    quality = QualityManager().get_quality(rest, inversion)
+    # TODO: Implement parser for appended notes
+    appended: List[str] = []
+    return root, quality, appended, on

pychord/progression.py

@@ -0,0 +1,112 @@
+from typing import Union, List
+
+from .chord import Chord
+
+
+class ChordProgression:
+    """ Class to handle chord progressions.
+
+    Attributes:
+        _chords: component chords of chord progression.
+    """
+
+    def __init__(self, initial_chords: Union[str, Chord, List[Union[str, Chord]]] = []):
+        """ Constructor of ChordProgression instance.
+
+        :param initial_chords: Initial chord or chords of the chord progressions
+        """
+        if isinstance(initial_chords, Chord):
+            chords = [initial_chords]
+        elif isinstance(initial_chords, str):
+            chords = [self._as_chord(initial_chords)]
+        elif isinstance(initial_chords, list):
+            chords = [self._as_chord(chord) for chord in initial_chords]
+        else:
+            raise TypeError(
+                f"Cannot initialize ChordProgression with argument of {type(initial_chords)} type")
+        self._chords: List[Chord] = chords
+
+    def __unicode__(self):
+        return " | ".join([chord.chord for chord in self._chords])
+
+    def __str__(self):
+        return " | ".join([chord.chord for chord in self._chords])
+
+    def __repr__(self):
+        return f"<ChordProgression: {' | '.join([chord.chord for chord in self._chords])}>"
+
+    def __add__(self, other):
+        self._chords += other.chords
+        return self
+
+    def __len__(self):
+        return len(self._chords)
+
+    def __getitem__(self, item):
+        return self._chords[item]
+
+    def __setitem__(self, key, value):
+        self._chords[key] = value
+
+    def __eq__(self, other):
+        if not isinstance(other, ChordProgression):
+            raise TypeError(
+                f"Cannot compare ChordProgression object with {type(other)} object")
+        if len(self) != len(other):
+            return False
+        for c, o in zip(self, other):
+            if c != o:
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def chords(self) -> List[Chord]:
+        """ Get component chords of chord progression """
+        return self._chords
+
+    def append(self, chord: Union[str, Chord]) -> None:
+        """ Append a chord to chord progressions
+
+        :param chord: A chord to append
+        """
+        self._chords.append(self._as_chord(chord))
+
+    def insert(self, index: int, chord: Union[str, Chord]) -> None:
+        """ Insert a chord to chord progressions
+
+        :param index: Index to insert a chord
+        :param chord: A chord to insert
+        """
+        self._chords.insert(index, self._as_chord(chord))
+
+    def pop(self, index: int = -1) -> Chord:
+        """ Pop a chord from chord progressions
+
+        :param index: Index of the chord to pop (default: -1)
+        """
+        return self._chords.pop(index)
+
+    def transpose(self, trans: int) -> None:
+        """ Transpose whole chord progressions
+
+        :param trans: Transpose key
+        """
+        for chord in self._chords:
+            chord.transpose(trans)
+
+    @staticmethod
+    def _as_chord(chord: Union[str, Chord]) -> Chord:
+        """ Convert from str to Chord instance if input is str
+
+        :param chord: Chord name or Chord instance
+        :return: Chord instance
+        """
+        if isinstance(chord, Chord):
+            return chord
+        elif isinstance(chord, str):
+            return Chord(chord)
+        else:
+            raise TypeError("input type should be str or Chord instance.")

pychord/quality.py

@@ -0,0 +1,133 @@
+import copy
+from collections import OrderedDict
+from typing import Tuple, List
+
+from .constants.qualities import DEFAULT_QUALITIES
+from .utils import note_to_val, val_to_note
+
+
+class Quality:
+    """ Chord quality """
+
+    def __init__(self, name: str, components: Tuple[int, ...]):
+        """ Constructor of chord quality
+
+        :param name: name of quality
+        :param components: components of quality
+        """
+        self._quality: str = name
+        self.components: Tuple[int, ...] = components
+
+    def __unicode__(self):
+        return self._quality
+
+    def __str__(self):
+        return self._quality
+
+    def __eq__(self, other):
+        if not isinstance(other, Quality):
+            raise TypeError(f"Cannot compare Quality object with {type(other)} object")
+        return self.components == other.components
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @property
+    def quality(self):
+        """ Get name of quality """
+        return self._quality
+
+    def get_components(self, root='C', visible=False):
+        """ Get components of chord quality
+
+        :param str root: the root note of the chord
+        :param bool visible: returns the name of notes if True
+        :rtype: list[str|int]
+        :return: components of chord quality
+        """
+        root_val = note_to_val(root)
+        components = [v + root_val for v in self.components]
+
+        if visible:
+            components = [val_to_note(c, scale=root) for c in components]
+
+        return components
+
+    def append_on_chord(self, on_chord, root):
+        """ Append on chord
+
+        To create Am7/G
+        q = Quality('m7')
+        q.append_on_chord('G', root='A')
+
+        :param str on_chord: bass note of the chord
+        :param str root: root note of the chord
+        """
+        root_val = note_to_val(root)
+        on_chord_val = note_to_val(on_chord) - root_val
+
+        components = list(self.components)
+        for idx, val in enumerate(self.components):
+            if val % 12 == on_chord_val:
+                components.remove(val)
+                break
+
+        if on_chord_val > root_val:
+            on_chord_val -= 12
+
+        if on_chord_val not in components:
+            components = [on_chord_val] + [
+                v for v in components if v % 12 != on_chord_val % 12
+            ]
+
+        self.components = tuple(components)
+
+
+class QualityManager:
+    """ Singleton class to manage the qualities """
+
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, "_instance"):
+            cls._instance = super(QualityManager, cls).__new__(cls)
+            cls._instance.load_default_qualities()
+        return cls._instance
+
+    def load_default_qualities(self):
+        self._qualities = OrderedDict([
+            (q, Quality(q, c)) for q, c in DEFAULT_QUALITIES
+        ])
+
+    def get_quality(self, name: str, inversion: int = 0) -> Quality:
+        if name not in self._qualities:
+            raise ValueError(f"Unknown quality: {name}")
+        # Create a new instance not to affect any existing instances
+        q = copy.deepcopy(self._qualities[name])
+        # apply requested inversion :
+        for i in range(inversion):
+            n = q.components[0]
+            while n < q.components[-1]:
+                n += 12
+            q.components = q.components[1:] + (n,)
+        return q
+
+    def get_qualities(self):
+        return dict(self._qualities)
+
+    def set_quality(self, name: str, components: Tuple[int, ...]):
+        """ Set a Quality
+
+        This method will not affect any existing Chord instances.
+        :param name: name of quality
+        :param components: components of quality
+        """
+        self._qualities[name] = Quality(name, components)
+
+    def find_quality_from_components(self, components: List[int]):
+        """ Find a quality from components
+
+        :param components: components of quality
+        """
+        for q in self._qualities.values():
+            if list(q.components) == components:
+                return copy.deepcopy(q)
+        return None

pychord/utils.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from .constants import NOTE_VAL_DICT, SCALE_VAL_DICT
+
+
+def note_to_val(note: str) -> int:
+    """ Get index value of a note
+
+    >>> note_to_val("C")
+    0
+    >>> note_to_val("B")
+    11
+    """
+    if note not in NOTE_VAL_DICT:
+        raise ValueError(f"Unknown note {note}")
+    return NOTE_VAL_DICT[note]
+
+
+def val_to_note(val: int, scale: str = "C") -> str:
+    """ Return note by index in a scale
+
+    >>> val_to_note(0)
+    "C"
+    >>> val_to_note(11, "D")
+    "D#"
+    """
+    val %= 12
+    return SCALE_VAL_DICT[scale][val]
+
+
+def transpose_note(note: str, transpose: int, scale: str = "C") -> str:
+    """ Transpose a note
+
+    >>> transpose_note("C", 1)
+    "Db"
+    >>> transpose_note("D", 4, "A")
+    "F#"
+    """
+    val = note_to_val(note)
+    val += transpose
+    return val_to_note(val, scale)
+
+
+def display_appended(appended: List[str]) -> str:
+    # TODO: Implement this
+    return ""
+
+
+def display_on(on_note: str) -> str:
+    if on_note:
+        return f"/{on_note}"
+    return ""

pychord-1.2.3.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: pychord
+Version: 1.2.3
+Summary: A library to handle musical chords in python.
+Author-email: Yuma Mihira <info@yuma.cloud>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yuma-m/pychord
+Keywords: music,chord
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+![PyChord](./pychord.png)
+
+# PyChord ![Build Status](https://github.com/yuma-m/pychord/actions/workflows/build.yml/badge.svg) [![Documentation Status](https://readthedocs.org/projects/pychord/badge/?version=latest)](http://pychord.readthedocs.io/en/latest/?badge=latest)
+
+## Overview
+
+PyChord is a python library to handle musical chords.
+
+## Installation
+
+```sh
+$ pip install pychord
+```
+
+## Basic Usage
+
+### Create a Chord
+
+```python
+>>> from pychord import Chord
+>>> c = Chord("Am7")
+>>> c
+<Chord: Am7>
+>>> c.info()
+"""
+Am7
+root=A
+quality=m7
+appended=[]
+on=None
+"""
+```
+
+### Transpose a Chord
+
+```python
+>>> c = Chord("Am7/G")
+>>> c.transpose(3)
+>>> c
+<Chord: Cm7/Bb>
+```
+
+### Get component notes
+
+```python
+>>> c = Chord("Am7")
+>>> c.components()
+['A', 'C', 'E', 'G']
+>>> c.components_with_pitch(root_pitch=3)
+['A3', 'C4', 'E4', 'G4']
+```
+
+### Compare Chords
+
+```python
+>>> Chord("C") == Chord("D")
+False
+>>> Chord("C#") == Chord("Db")
+True
+>>> c = Chord("C")
+>>> c.transpose(2)
+>>> c == Chord("D")
+True
+```
+
+### Find Chords from notes
+
+```python
+>>> from pychord import find_chords_from_notes
+>>> find_chords_from_notes(["C", "E", "G"])
+[ <Chord: C>]
+>>> find_chords_from_notes(["F#", "A", "C", "D"])
+[ <Chord: D7/F#>]
+>>> find_chords_from_notes(["F", "G", "C"])
+[ <Chord: Fsus2>, <Chord: Csus4/F>]
+```
+
+### Create and handle chord progressions
+
+```python
+>>> from pychord import ChordProgression
+>>> cp = ChordProgression(["C", "G/B", "Am"])
+>>> cp
+<ChordProgression: C | G/B | Am>
+
+>>> cp.append("Em/G")
+>>> cp
+<ChordProgression: C | G/B | Am | Em/G>
+
+>>> cp.transpose(+3)
+>>> cp
+<ChordProgression: Eb | Bb/D | Cm | Gm/Bb>
+
+>>> cp[1]
+<Chord: Bb/D>
+```
+
+## Advanced Usage
+
+### Create a Chord from note index in a scale
+
+```python
+>>> Chord.from_note_index(note=1, quality="", scale="Cmaj")
+<Chord: C>  # I of C major
+>>> Chord.from_note_index(note=3, quality="m7", scale="Fmaj")
+<Chord: Am7>  # IIIm7 of F major
+>>> Chord.from_note_index(note=5, quality="7", scale="Amin")
+<Chord: E7>  # V7 of A minor
+```
+
+### Overwrite the default Quality components with yours
+
+```python
+>>> from pychord import Chord, QualityManager
+>>> Chord("C11").components()
+['C', 'G', 'Bb', 'D', 'F']
+
+>>> quality_manager = QualityManager()
+>>> quality_manager.set_quality("11", (0, 4, 7, 10, 14, 17))
+>>> Chord("C11").components()
+['C', 'E', 'G', 'Bb', 'D', 'F']
+```
+
+### Inversions
+
+Chord inversions are created with a forward slash and a number
+indicating the order. This can optionally be combined with an
+additional forward slash to change the bass note:
+
+```python
+>>> Chord("C/1").components() # First inversion of C
+['E', 'G', 'C']
+>>> Chord("C/2").components() # Second inversion of C
+['G', 'C', 'E']
+
+>>> Chord("Cm7/3/F").components() # Third inversion of Cm7 with an added F bass
+['F', 'Bb', 'C', 'Eb', 'G']
+```
+
+## Examples
+
+- [pychord-midi.py](./examples/pychord-midi.py) - Create a MIDI file using PyChord and pretty_midi.
+
+## Supported Python Versions
+
+- 3.8 and above
+
+## Links
+
+- PyPI: https://pypi.python.org/pypi/pychord
+- GitHub: https://github.com/yuma-m/pychord
+- Documentation: http://pychord.readthedocs.io/en/latest/
+
+## Author
+
+- [Yuma Mihira](https://yuma.cloud/)
+
+## License
+
+- MIT License
+
+Icon is made by [Freepik](https://www.flaticon.com/authors/freepik).

pychord-1.2.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+examples/pychord-midi.py,sha256=nSPFfhJnwYHysADorEXaIIsgTUOm58EzXckpSWReM2E,985
+pychord/__init__.py,sha256=b7x9naaKu7Z2UgG-YXE372xPssAIn2gsMtKa78Tor_k,172
+pychord/analyzer.py,sha256=xt9xoOORLHkMRjD56lFj2w3RVI5Ms9XlgvdnQqTP5lM,1995
+pychord/chord.py,sha256=0hnan-GZVz3-BAKVaSEN3vmnRdBzqPUGLKmw5CQJDX8,7521
+pychord/parser.py,sha256=X_e-pDIZhTp2_8VT39pUN84XsWpk6UUeeVEDrSWojhY,1252
+pychord/progression.py,sha256=fb6w4dMBOHivVj7tIuvYglUHcffgdBnETqC5drFg_Ww,3456
+pychord/quality.py,sha256=2IqBxUX2uoa-rCvDNo11daKevAsvo2U74xoPU0n0lao,4071
+pychord/utils.py,sha256=_d7HK57di37mPe4DnjqGuIjP_b2fZEq3Pq4qCJj3uMk,1027
+pychord/constants/__init__.py,sha256=8eR7MemP8wC9OaxpcwhvyxsrkHJEe2pgjlkJ5mJGusw,80
+pychord/constants/qualities.py,sha256=ui--gDT0iicf_DOfFiWIcRwhudv9Lh1_cxvG5Mf0vEs,3748
+pychord/constants/scales.py,sha256=BQhhGzAhx7xtliBRUdW65W3pDce6GgwTG8zFN3ZZgdo,1605
+pychord-1.2.3.dist-info/licenses/LICENSE,sha256=T84Eir2LETaTDcgSBnUHcsJCuLXxvZSaYFZSL1sCjN0,1066
+pychord-1.2.3.dist-info/METADATA,sha256=EFrX0MG3mMbG0gqLa9gbjW1YMW4xBUDAGgv1lyHyK9M,4060
+pychord-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pychord-1.2.3.dist-info/top_level.txt,sha256=NOgJx-31h3rXznW6f9whk22j9POizbvhpQ5w2Q-zToM,17
+pychord-1.2.3.dist-info/RECORD,,

pychord-1.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pychord-1.2.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pychord-1.2.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+examples
+pychord