From: Scott Gasch <scott@gasch.org>
Date: Fri, 22 Apr 2022 03:05:21 +0000 (-0700)
Subject: Chord name parsing.
X-Git-Url: https://wannabe.guru.org/gitweb/?a=commitdiff_plain;h=068d71327bf6ec8618cd70a6d3fce5d075503cae;p=python_utils.git

Chord name parsing.
---

diff --git a/music/chords.g4 b/music/chords.g4
new file mode 100644
index 0000000..bd180a9
--- /dev/null
+++ b/music/chords.g4
@@ -0,0 +1,127 @@
+// © Copyright 2022, Scott Gasch
+//
+// antlr4 -Dlanguage=Python3 ./chords.g4
+//
+// Hi, self.  In ANTLR grammars, there are two separate types of symbols: those
+// for the lexer and those for the parser.  The former begin with a CAPITAL
+// whereas the latter begin with lowercase.  The order of the lexer symbols
+// is the order that the lexer will recognize them in.  There's a good tutorial
+// on this shit at:
+//
+//    https://tomassetti.me/antlr-mega-tutorial/
+//
+// There are also a zillion premade grammars at:
+//
+//    https://github.com/antlr/grammars-v4
+
+grammar chords;
+
+parse
+    : rootNote majMinSusPowerExpr* addNotesExpr* extensionExpr* overBassNoteExpr*
+    ;
+
+rootNote
+    : NOTE
+    ;
+
+overBassNoteExpr
+    : SLASH NOTE
+    ;
+
+majMinSusPowerExpr
+    : majExpr
+    | minExpr
+    | susExpr
+    | diminishedExpr
+    | augmentedExpr
+    | powerChordExpr
+    ;
+
+majExpr: MAJOR;
+
+minExpr: MINOR;
+
+susExpr: SUS ('2'|'4');
+
+diminishedExpr: DIMINISHED;
+
+augmentedExpr: AUGMENTED;
+
+powerChordExpr: '5';
+
+addNotesExpr
+    : SIX
+    | SEVEN
+    | MAJ_SEVEN
+    | ADD_NINE
+    ;
+
+extensionExpr
+    : INTERVAL
+    ;
+
+SPACE: [ \t\r\n] -> skip;
+
+NOTE: (AS|BS|CS|DS|ES|FS|GS) ;
+
+AS
+    : ('A'|'a')
+    | ('Ab'|'ab')
+    | ('A#'|'a#')
+    ;
+
+BS
+    : ('B'|'b')
+    | ('Bb'|'bb')
+    ;
+
+CS
+    : ('C'|'c')
+    | ('C#'|'c#')
+    ;
+
+DS
+    : ('D'|'d')
+    | ('Db'|'db')
+    | ('D#'|'d#')
+    ;
+
+ES
+    : ('E'|'e')
+    | ('Eb'|'eb')
+    ;
+
+FS
+    : ('F'|'f')
+    | ('F#'|'f#')
+    ;
+
+GS
+    : ('G'|'g')
+    | ('Gb'|'gb')
+    | ('G#'|'g#')
+    ;
+
+MAJOR: ('M'|'Maj'|'maj'|'Major'|'major');
+
+MINOR: ('m'|'min'|'minor');
+
+SUS: ('sus'|'suspended');
+
+DIMINISHED: ('dim'|'diminished');
+
+AUGMENTED: ('aug'|'augmented');
+
+SLASH: ('/'|'\\');
+
+SIX: '6';
+
+SEVEN: '7';
+
+MAJ_SEVEN: MAJOR '7';
+
+ADD_NINE: ('add'|'Add')* '9';
+
+INTERVAL: (MAJOR|MINOR)* ('b'|'#')* DIGITS ;
+
+DIGITS: [1-9]+ ;
diff --git a/music/chords.py b/music/chords.py
new file mode 100755
index 0000000..fc2bd5f
--- /dev/null
+++ b/music/chords.py
@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+# type: ignore
+# pylint: disable=W0201
+# pylint: disable=R0904
+
+# © Copyright 2021-2022, Scott Gasch
+
+"""Parse music chords; work in progress..."""
+
+import functools
+import itertools
+import logging
+import re
+import sys
+from typing import Any, Callable, Dict, Iterator, List, Optional
+
+import antlr4  # type: ignore
+
+import acl
+import bootstrap
+import decorator_utils
+from music.chordsLexer import chordsLexer  # type: ignore
+from music.chordsListener import chordsListener  # type: ignore
+from music.chordsParser import chordsParser  # type: ignore
+
+logger = logging.getLogger(__name__)
+notes = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']
+
+
+def generate_scale(starting_note: str) -> Iterator[str]:
+    starting_note = starting_note.upper()
+    start = 0
+    while notes[start] != starting_note:
+        start += 1
+    while True:
+        if start >= len(notes):
+            start = 0
+        yield notes[start]
+        start += 1
+
+
+def degree_of_note(root_note: str, target_note: str) -> Optional[int]:
+    root_note = root_note.upper()
+    target_note = target_note.upper()
+    for degree, note in enumerate(itertools.islice(generate_scale(root_note), 24)):
+        print(f'"{target_note}", "{note}", {degree}')
+        if note == target_note:
+            return degree - 1
+    return None
+
+
+def debug_parse(enter_or_exit_f: Callable[[Any, Any], None]):
+    @functools.wraps(enter_or_exit_f)
+    def debug_parse_wrapper(*args, **kwargs):
+        # slf = args[0]
+        ctx = args[1]
+        depth = ctx.depth()
+        logger.debug(
+            '  ' * (depth - 1)
+            + f'Entering {enter_or_exit_f.__name__} ({ctx.invokingState} / {ctx.exception})'
+        )
+        for c in ctx.getChildren():
+            logger.debug('  ' * (depth - 1) + f'{c} {type(c)}')
+        retval = enter_or_exit_f(*args, **kwargs)
+        return retval
+
+    return debug_parse_wrapper
+
+
+class ParseException(Exception):
+    """An exception thrown during parsing because of unrecognized input."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__()
+        self.message = message
+
+
+class RaisingErrorListener(antlr4.DiagnosticErrorListener):
+    """An error listener that raises ParseExceptions."""
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        raise ParseException(msg)
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        pass
+
+    def reportAttemptingFullContext(
+        self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs
+    ):
+        pass
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        pass
+
+
+class Chord:
+    def __init__(self, root_note: str, other_notes: Dict[str, int]):
+        self.root_note = root_note.upper()
+        self.other_notes = other_notes
+
+
+@decorator_utils.decorate_matching_methods_with(
+    debug_parse,
+    acl=acl.StringWildcardBasedACL(
+        allowed_patterns=[
+            'enter*',
+            'exit*',
+        ],
+        denied_patterns=['enterEveryRule', 'exitEveryRule'],
+        order_to_check_allow_deny=acl.Order.DENY_ALLOW,
+        default_answer=False,
+    ),
+)
+class ChordParser(chordsListener):
+    """A class to parse dates expressed in human language."""
+
+    MINOR = 0
+    MAJOR = 1
+    SUSPENDED = 2
+    DIMINISHED = 3
+    AUGMENTED = 4
+    POWER = 5
+
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def interval_name_to_semitone_count(
+        interval_name: str, root: Optional[str]
+    ) -> Optional[List[int]]:
+        interval_name = interval_name.lower()
+        interval_name = re.sub(r'\s+', '', interval_name)
+        interval_name = re.sub(r'th', '', interval_name)
+        interval_name = re.sub(r'add', '', interval_name)
+        interval_name = re.sub(r'perfect', '', interval_name)
+        logger.debug('Canonicalized interval name: %s', interval_name)
+
+        number = None
+        g = re.search(r'[1-9]+', interval_name)
+        if g:
+            number = int(g.group(0))
+        else:
+            return None
+        logger.debug('Number: %d', number)
+
+        minor = 'min' in interval_name or 'b' in interval_name
+        diminished = 'dim' in interval_name
+        augmented = 'aug' in interval_name or '#' in interval_name
+        base_intervals = {
+            2: 2,
+            3: 4,
+            4: 5,
+            5: 7,
+            6: 9,
+            7: 11,
+            9: 14,
+            10: 16,
+            11: 17,
+            13: 19,
+        }
+
+        base_interval = base_intervals.get(number, None)
+        if base_interval is None:
+            return None
+        logger.debug('Starting base_interval is %d', base_interval)
+
+        if diminished:
+            logger.debug('Diminished...')
+            base_interval -= 2
+        elif minor:
+            logger.debug('Minor...')
+            base_interval -= 1
+        elif augmented:
+            logger.debug('Augmented...')
+            base_interval += 1
+        logger.debug('Returning %d semitones.', base_interval)
+        return base_interval
+
+    def parse(self, chord_string: str) -> Optional[Chord]:
+        chord_string = chord_string.strip()
+        chord_string = re.sub(r'\s+', ' ', chord_string)
+        self._reset()
+        listener = RaisingErrorListener()
+        input_stream = antlr4.InputStream(chord_string)
+        lexer = chordsLexer(input_stream)
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(listener)
+        stream = antlr4.CommonTokenStream(lexer)
+        parser = chordsParser(stream)
+        parser.removeErrorListeners()
+        parser.addErrorListener(listener)
+        tree = parser.parse()
+        walker = antlr4.ParseTreeWalker()
+        walker.walk(self, tree)
+        return self.chord
+
+    def _reset(self) -> None:
+        self.chord = None
+        self.rootNote = None
+        self.susNote = None
+        self.bassNote = None
+        self.chordType = ChordParser.MAJOR
+        self.addedNotes = []
+
+    # -- overridden methods invoked by parse walk.  Note: not part of the class'
+    # public API(!!) --
+
+    def visitErrorNode(self, node: antlr4.ErrorNode) -> None:
+        pass
+
+    def visitTerminal(self, node: antlr4.TerminalNode) -> None:
+        pass
+
+    def exitParse(self, ctx: chordsParser.ParseContext) -> None:
+        """Populate self.chord"""
+        print(f'Root note is a {self.rootNote}')
+        scale = list(itertools.islice(generate_scale(self.rootNote), 24))
+
+        chord_types_with_perfect_5th = set(
+            [
+                ChordParser.MAJOR,
+                ChordParser.MINOR,
+                ChordParser.SUSPENDED,
+                ChordParser.POWER,
+            ]
+        )
+        if self.chordType in chord_types_with_perfect_5th:
+            if self.chordType == ChordParser.MAJOR:
+                logger.debug('Major chord.')
+                self.addedNotes.append('maj3')
+            elif self.chordType == ChordParser.MINOR:
+                logger.debug('Minor chord.')
+                self.addedNotes.append('min3')
+            elif self.chordType == ChordParser.SUSPENDED:
+                if self.susNote == 2:
+                    logger.debug('sus2 chord.')
+                    self.addedNotes.append('maj2')
+                elif self.susNote == 4:
+                    logger.debug('sus4 chord.')
+                    self.addedNotes.append('perfect4')
+            elif self.chordType == ChordParser.POWER:
+                logger.debug('Power chord.')
+            self.addedNotes.append('perfect5th')
+        elif self.chordType == ChordParser.DIMINISHED:
+            logger.debug('Diminished chord.')
+            self.addedNotes.append('min3')
+            self.addedNotes.append('dim5')
+        elif self.chordType == ChordParser.AUGMENTED:
+            logger.debug('Augmented chord.')
+            self.addedNotes.append('maj3')
+            self.addedNotes.append('aug5')
+
+        other_notes: Dict[str, int] = {}
+        for expression in self.addedNotes:
+            semitone_count = ChordParser.interval_name_to_semitone_count(expression, self.rootNote)
+            if semitone_count in (14, 17, 19):
+                other_notes['min7'] = 10
+            other_notes[expression] = semitone_count
+
+        for expression, semitone_count in other_notes.items():
+            note_name = scale[semitone_count]
+            print(f'Contains: {expression} ({semitone_count} semitones) => {note_name}')
+        if self.bassNote:
+            degree = degree_of_note(self.rootNote, self.bassNote)
+            print(f'Add a {self.bassNote} ({degree}) in the bass')
+            other_notes[self.bassNote] = degree
+        self.chord = Chord(self.rootNote, other_notes)
+
+    def exitRootNote(self, ctx: chordsParser.RootNoteContext):
+        self.rootNote = ctx.NOTE().__str__().upper()
+        logger.debug('Root note is "%s"', self.rootNote)
+
+    def exitOverBassNoteExpr(self, ctx: chordsParser.OverBassNoteExprContext):
+        self.bassNote = ctx.NOTE().__str__().upper()
+        logger.debug('Bass note is "%s"', self.bassNote)
+
+    def exitPowerChordExpr(self, ctx: chordsParser.PowerChordExprContext):
+        self.chordType = ChordParser.POWER
+        logger.debug('Power chord')
+
+    def exitMajExpr(self, ctx: chordsParser.MajExprContext):
+        self.chordType = ChordParser.MAJOR
+        logger.debug('Major')
+
+    def exitMinExpr(self, ctx: chordsParser.MinExprContext):
+        self.chordType = ChordParser.MINOR
+        logger.debug('Minor')
+
+    def exitSusExpr(self, ctx: chordsParser.SusExprContext):
+        self.chordType = ChordParser.SUSPENDED
+        logger.debug('Suspended')
+        if '2' in ctx.getText():
+            self.susNote = 2
+        elif '4' in ctx.getText():
+            self.susNote = 4
+
+    def exitDiminishedExpr(self, ctx: chordsParser.DiminishedExprContext):
+        self.chordType = ChordParser.DIMINISHED
+        logger.debug('Diminished')
+
+    def exitAugmentedExpr(self, ctx: chordsParser.AugmentedExprContext):
+        self.chordType = ChordParser.AUGMENTED
+        logger.debug('Augmented')
+
+    def exitAddNotesExpr(self, ctx: chordsParser.AddNotesExprContext):
+        if ctx.SIX():
+            self.addedNotes.append('maj6')
+        if ctx.SEVEN():
+            self.addedNotes.append('min7')
+        if ctx.MAJ_SEVEN():
+            self.addedNotes.append('maj7')
+        if ctx.ADD_NINE():
+            self.addedNotes.append('maj9')
+
+    def exitExtensionExpr(self, ctx: chordsParser.ExtensionExprContext):
+        self.addedNotes.append(ctx.getText())
+
+
+@bootstrap.initialize
+def main() -> None:
+    parser = ChordParser()
+    for line in sys.stdin:
+        line = line.strip()
+        line = re.sub(r"#.*$", "", line)
+        if re.match(r"^ *$", line) is not None:
+            continue
+        try:
+            chord = parser.parse(line)
+            print(chord)
+        except Exception as e:
+            logger.exception(e)
+            print("Unrecognized.")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()