chordsym 0.0.2__py3-none-any.whl

chordsym/__init__.py

@@ -0,0 +1,28 @@
+"""chordsym: chord symbols without dependencies — parse, pitch classes, keys, transposition.
+
+>>> from chordsym import parse_chord, transpose_chord, estimate_key
+>>> parse_chord("Am7"), transpose_chord("Am7", 2), estimate_key(["Am", "Dm", "E7"])
+((9, 'minor'), 'Bm7', Key(tonic=9, minor=True))
+"""
+
+from chordsym.keys import Key, chord_function, estimate_key
+from chordsym.parse import chord_tones, is_chord_token, parse_chord
+from chordsym.transpose import (
+    key_name,
+    transpose_chord,
+    transposition_table,
+    uses_flats,
+)
+
+__all__ = [
+    "Key",
+    "chord_function",
+    "chord_tones",
+    "estimate_key",
+    "is_chord_token",
+    "key_name",
+    "parse_chord",
+    "transpose_chord",
+    "transposition_table",
+    "uses_flats",
+]

chordsym/_grammar.py

@@ -0,0 +1,104 @@
+"""The chord-symbol grammar and tables, shared by the Python package and its TypeScript twin.
+
+This module is the single source of truth for every regular expression and lookup table
+chordsym uses. ``chordsym._codegen`` writes it to ``ts/src/grammar.generated.ts``, so the
+TypeScript package reads the same patterns and tables; a test fails when the committed
+TypeScript file is stale.
+
+Every pattern here must mean the same thing in Python's ``re`` and in a JavaScript
+``RegExp`` with the ``u`` flag. Hence:
+
+- no ``\\d``, ``\\w``, ``\\s``, ``\\b`` (or their negations): Python's are Unicode-aware,
+  JavaScript's are not (``\\d``) or differ at the edges (``\\s``); use ``[0-9]`` and
+  :data:`WS` instead;
+- ``.`` only with the DOTALL flag (``s`` in JavaScript), listed in :data:`PATTERNS`;
+- whole-string matches are written by the caller (``fullmatch`` / ``^(?:...)$``), never
+  with ``$`` inside a pattern.
+
+``tests/test_grammar.py`` enforces the first rule; ``fixtures/cases.json`` checks the rest
+by running the same cases on both sides.
+
+>>> sorted(PATTERNS)[:3]
+['chord', 'diminished', 'major_seventh']
+"""
+
+#: Whitespace, as a character-class body: exactly the characters Python's ``str.isspace``
+#: accepts (what ``str.strip()`` removes), written out so a JavaScript ``RegExp`` (whose
+#: ``\s`` lacks ``\x1c``-``\x1f`` and ``\x85`` and adds ``\ufeff``) matches the same set.
+WS = (
+    "\\t\\n\\x0b\\x0c\\r\\x1c\\x1d\\x1e\\x1f \\x85\\xa0\\u1680"
+    "\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000"
+)
+
+#: name -> (pattern source, flags). Flags: ``"s"`` means DOTALL.
+PATTERNS: dict[str, tuple[str, str]] = {
+    # Is this token a chord symbol? (used with a whole-string match)
+    "chord": (
+        r"[*.]{0,3}\(?"  # leading marks: *D, ...Dm6
+        r"[A-G][#b]?"  # root
+        r"(?:maj|min|dim|aug|sus|add|m|M|\+|°|º|ø)?"  # quality
+        r"[0-9]{0,2}[M+\-]?"  # extension: 7, 9, 13; Brazilian 7M, 7+, 5-
+        r"(?:sus[0-9]{0,2}|(?:maj|add|dim|aug|no|m|b|#|\+|-)[0-9]{1,2}[+\-]?)*"  # b5, add9
+        r"(?:/(?:[#b]?[0-9]{1,2}[+\-#b]?|sus[0-9]{0,2}))*"  # stacked: 7/9, 5-/7, 7/sus4
+        r"(?:\([^()" + WS + r"]{1,10}\))*"  # parenthesised alterations: (#9), 7(4)(9)
+        r"(?:/[A-G][#b]?)?"  # bass
+        r"\)?\*?",
+        "",
+    ),
+    # Lead marks, root letter, accidental, the rest (used with a whole-string match).
+    "root": (r"[*.(" + WS + r"]*([A-G])([#b]?)(.*)", "s"),
+    # A diminished quality, at the start of what follows the root.
+    "diminished": (r"(?:dim|°|º|ø|m(?:in)?7?\(?b5)", ""),
+    # A power chord's 5 (not 5 of 13 or 55), at the start of what follows the root.
+    "power": (r"5(?![0-9])", ""),
+    # A note name: letter and optional accidental, at the start of a string.
+    "note": (r"([A-G])([#b]?)", ""),
+    # Seventh and extension markers, searched anywhere in what follows the root.
+    "major_seventh": (r"(maj|M|Δ)(7|9|11|13)", ""),
+    "seventh": (r"(?<!add)(7|9|11|13)", ""),
+    "sixth": (r"(?<![0-9])6", ""),
+    "ninth": (r"9|add2", ""),
+    # Root, suffix, and a final /bass with what trails it (used with a whole-string match).
+    # The bass is only a final ``/note`` (``D/F#``); a slash inside the extension
+    # (``C6/9``, ``Bm5-/7``) belongs to the chord's suffix.
+    "transposable": (
+        r"([*.(" + WS + r"]*)([A-G][#b]?)(.*?)(?:/([A-G][#b]?)([^/A-Za-z0-9#]*))?",
+        "s",
+    ),
+}
+
+#: Natural-note pitch classes and accidental offsets.
+PITCH_CLASSES = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+ACCIDENTALS = {"#": 1, "b": -1, "": 0}
+
+#: Note names by pitch class, spelled with sharps or with flats.
+SHARP_NAMES = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
+FLAT_NAMES = ("C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B")
+
+#: Keys whose signatures use flats, as tonic pitch classes: F Bb Eb Ab Db Gb; d g c f bb eb.
+FLAT_MAJOR_TONICS = (5, 10, 3, 8, 1, 6)
+FLAT_MINOR_TONICS = (2, 7, 0, 5, 10, 3)
+
+#: Qualities each scale degree (semitones above the tonic) takes in a key.
+MAJOR_KEY = {
+    0: ("major",),
+    2: ("minor",),
+    4: ("minor",),
+    5: ("major",),
+    7: ("major",),
+    9: ("minor",),
+    11: ("diminished", "minor"),
+}
+MINOR_KEY = {
+    0: ("minor",),
+    2: ("diminished", "minor"),
+    3: ("major",),
+    5: ("minor",),
+    7: ("minor", "major"),  # the harmonic-minor V is at home in a minor key
+    8: ("major",),
+    10: ("major",),
+}
+
+#: Key estimation: score of a chord that is the key's tonic, a diatonic chord, and the
+#: bonus for a song starting or ending on the tonic chord.
+KEY_WEIGHTS = {"tonic": 2.0, "diatonic": 1.0, "outside": 0.0, "ends": 2.0}

chordsym/keys.py

@@ -0,0 +1,78 @@
+"""What a chord does in a key: estimate a song's key from its chords, label chords by function.
+
+>>> key = estimate_key(["G", "D", "Em", "C", "G", "D", "G"])
+>>> key
+Key(tonic=7, minor=False)
+>>> [chord_function(symbol, key) for symbol in ["G", "Em", "C", "Bb", "N.C."]]
+['tonic', 'diatonic', 'diatonic', 'outside', None]
+>>> estimate_key(["Am", "Dm", "E7", "Am"])
+Key(tonic=9, minor=True)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from chordsym import _grammar
+from chordsym.parse import parse_chord
+
+_MAJOR_KEY = {degree: set(qs) for degree, qs in _grammar.MAJOR_KEY.items()}
+_MINOR_KEY = {degree: set(qs) for degree, qs in _grammar.MINOR_KEY.items()}
+_WEIGHTS = _grammar.KEY_WEIGHTS
+
+
+@dataclass(frozen=True)
+class Key:
+    """A key: its tonic as a pitch class (C = 0, C# = 1, ... B = 11), major or minor."""
+
+    tonic: int
+    minor: bool = False
+
+    def __post_init__(self):
+        if isinstance(self.tonic, bool) or not isinstance(self.tonic, int):
+            raise TypeError(f"Key tonic must be an int pitch class, not {self.tonic!r}")
+        if not 0 <= self.tonic < 12:
+            raise ValueError(f"Key tonic must be 0-11 (C = 0), not {self.tonic}")
+
+
+def _function(parsed: tuple[int, str], key: Key) -> str:
+    root, quality = parsed
+    degree = (root - key.tonic) % 12
+    qualities = (_MINOR_KEY if key.minor else _MAJOR_KEY).get(degree)
+    if qualities is None or (quality != "open" and quality not in qualities):
+        return "outside"
+    return "tonic" if degree == 0 else "diatonic"
+
+
+def chord_function(symbol: str, key: Key) -> str | None:
+    """``"tonic"``, ``"diatonic"`` or ``"outside"`` in ``key``; None if ``symbol`` is not a chord."""
+    parsed = parse_chord(symbol)
+    return None if parsed is None else _function(parsed, key)
+
+
+def estimate_key(symbols: Iterable[str]) -> Key | None:
+    """The key that best explains a song's chords, in order; None if there are no chords.
+
+    Each chord scores for a key when it belongs to it, and more when it is its
+    tonic; a song that starts or ends on a key's tonic chord scores extra for
+    that key. Ties go to the major key, and to the lower tonic.
+    """
+    chords = [parsed for parsed in map(parse_chord, symbols) if parsed]
+    if not chords:
+        return None
+    best, best_score = None, float("-inf")
+    for tonic in range(12):
+        for minor in (False, True):
+            key = Key(tonic, minor)
+            # A plain left-to-right sum, as the TypeScript twin does: the builtin sum()
+            # compensates float rounding (Python 3.12+), which would break ties differently.
+            score = 0.0
+            for parsed in chords:
+                score += _WEIGHTS[_function(parsed, key)]
+            for parsed in (chords[0], chords[-1]):
+                if _function(parsed, key) == "tonic":
+                    score += _WEIGHTS["ends"]
+            if score > best_score:
+                best, best_score = key, score
+    return best

chordsym/parse.py

@@ -0,0 +1,121 @@
+"""Read a chord symbol: is it one, what is its root and quality, which pitch classes it sounds.
+
+Pure standard library. A pitch class is an int 0-11 (C = 0, C# = 1, ... B = 11).
+
+>>> is_chord_token("F#m7b5"), is_chord_token("Bridge")
+(True, False)
+>>> parse_chord("Bbmaj7/D")
+(10, 'major')
+>>> chord_tones("Cmaj7"), chord_tones("Am/G"), chord_tones("F#m7b5")
+((0, 4, 7, 11), (7, 9, 0, 4), (6, 9, 0, 4))
+"""
+
+from __future__ import annotations
+
+import re
+
+from chordsym import _grammar
+
+
+def _compile(name: str) -> re.Pattern:
+    source, flags = _grammar.PATTERNS[name]
+    return re.compile(source, re.DOTALL if "s" in flags else 0)
+
+
+_CHORD_RE = _compile("chord")
+_ROOT_RE = _compile("root")
+_DIMINISHED_RE = _compile("diminished")
+_POWER_RE = _compile("power")
+_NOTE_RE = _compile("note")
+_MAJOR_SEVENTH_RE = _compile("major_seventh")
+_SEVENTH_RE = _compile("seventh")
+_SIXTH_RE = _compile("sixth")
+_NINTH_RE = _compile("ninth")
+_PITCH_CLASSES = _grammar.PITCH_CLASSES
+_ACCIDENTALS = _grammar.ACCIDENTALS
+
+
+def is_chord_token(token: str) -> bool:
+    """True if ``token`` reads as a chord symbol (``G``, ``F#m7b5``, ``E7(#9)``, ``C/G``).
+
+    >>> is_chord_token("Bb7(4)(9)"), is_chord_token("A7/sus4"), is_chord_token("Bridge")
+    (True, True, False)
+    """
+    return bool(_CHORD_RE.fullmatch(token))
+
+
+def parse_chord(symbol: str) -> tuple[int, str] | None:
+    """``(root pitch class, quality)``, or None for what is not a chord.
+
+    The quality is ``"major"``, ``"minor"``, ``"diminished"``, or ``"open"`` (a
+    suspended or power chord, which has no third). A bass note is ignored. What
+    the chart parser would not read as a chord (:func:`is_chord_token`) is not one.
+
+    >>> parse_chord("F#m7"), parse_chord("Bbmaj7/D"), parse_chord("A7sus4"), parse_chord("Bm7b5")
+    ((6, 'minor'), (10, 'major'), (9, 'open'), (11, 'diminished'))
+    >>> parse_chord("C-7"), parse_chord("Bridge")
+    ((0, 'minor'), None)
+    """
+    symbol = symbol.strip()
+    match = _ROOT_RE.fullmatch(symbol)
+    if not (match and is_chord_token(symbol)):
+        return None
+    letter, accidental, rest = match.groups()
+    root = (_PITCH_CLASSES[letter] + _ACCIDENTALS[accidental]) % 12
+    if rest.startswith(("maj", "M")):
+        quality = "major"
+    elif _DIMINISHED_RE.match(rest):
+        quality = "diminished"
+    elif rest.startswith(("min", "m", "-")):  # "C-7" is jazz for Cm7
+        quality = "minor"
+    elif "sus" in rest or _POWER_RE.match(rest):
+        quality = "open"
+    else:
+        quality = "major"
+    return root, quality
+
+
+def _note(text: str) -> int | None:
+    m = _NOTE_RE.match(text.strip())
+    if not m:
+        return None
+    return (_PITCH_CLASSES[m.group(1)] + _ACCIDENTALS[m.group(2)]) % 12
+
+
+def chord_tones(symbol: str) -> tuple[int, ...] | None:
+    """The chord's pitch classes, bass first (the root, or the bass of a slash chord).
+
+    Triads by quality (``m``, ``dim``, ``aug``/``+``, ``sus2``, ``sus4``, ``5``), then
+    sevenths (``7``, ``maj7``, ``dim7``, ``m7b5``), sixths and added ninths. ``None``
+    for what :func:`chordsym.parse_chord` does not read as a chord.
+    """
+    parsed = parse_chord(symbol)
+    if parsed is None:
+        return None
+    root, quality = parsed
+    head, _, bass_text = symbol.strip().partition("/")
+    rest = _NOTE_RE.sub("", head, count=1)
+    third = {"minor": 3, "diminished": 3}.get(quality, 4)
+    fifth = 6 if quality == "diminished" else 7
+    if "aug" in rest or rest.startswith("+"):
+        fifth = 8
+    intervals = [0, third, fifth]
+    if quality == "open":  # suspended or power: no third
+        intervals = (
+            [0, 7] if _POWER_RE.match(rest) else [0, 2 if "sus2" in rest else 5, 7]
+        )
+    if "dim7" in rest or rest in ("°7", "o7"):
+        intervals.append(9)
+    elif _MAJOR_SEVENTH_RE.search(rest):
+        intervals.append(11)
+    elif _SEVENTH_RE.search(rest):
+        intervals.append(10)
+    if _SIXTH_RE.search(rest):
+        intervals.append(9)
+    if _NINTH_RE.search(rest) and 2 not in intervals:
+        intervals.append(2)
+    tones = list(dict.fromkeys((root + i) % 12 for i in intervals))
+    bass = _note(bass_text) if bass_text else None
+    if bass is not None:
+        tones = [bass] + [t for t in tones if t != bass]
+    return tuple(tones)

chordsym/transpose.py

@@ -0,0 +1,114 @@
+"""Move chord symbols by semitones, spelled for the target key.
+
+>>> transpose_chord("F#m7", 1), transpose_chord("C/E", 3, flats=True)
+('Gm7', 'Eb/G')
+>>> transposition_table(["G", "D", "Em", "C", "G"], 3)
+{'semitones': 3, 'key': 'Bb', 'chords': {'G': 'Bb', 'D': 'F', 'Em': 'Gm', 'C': 'Eb'}}
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from chordsym import _grammar
+from chordsym.keys import Key, estimate_key
+from chordsym.parse import _ACCIDENTALS, _PITCH_CLASSES, _compile, parse_chord
+
+_SHARP_NAMES = _grammar.SHARP_NAMES
+_FLAT_NAMES = _grammar.FLAT_NAMES
+_FLAT_MAJOR_TONICS = frozenset(_grammar.FLAT_MAJOR_TONICS)
+_FLAT_MINOR_TONICS = frozenset(_grammar.FLAT_MINOR_TONICS)
+#: Groups: lead, root, rest, bass, tail.
+_TRANSPOSABLE_RE = _compile("transposable")
+
+
+def _check_semitones(semitones) -> None:
+    if isinstance(semitones, bool) or not isinstance(semitones, int):
+        raise TypeError(f"semitones must be an int, not {semitones!r}")
+
+
+def _pitch_class(name: str) -> int:
+    return (_PITCH_CLASSES[name[0]] + _ACCIDENTALS[name[1:]]) % 12
+
+
+def uses_flats(key: Key | None) -> bool:
+    """Whether chords in ``key`` are spelled with flats (Bb, Eb) rather than sharps.
+
+    >>> uses_flats(Key(5)), uses_flats(Key(7)), uses_flats(Key(2, minor=True)), uses_flats(None)
+    (True, False, True, False)
+    """
+    if key is None:
+        return False
+    return key.tonic in (_FLAT_MINOR_TONICS if key.minor else _FLAT_MAJOR_TONICS)
+
+
+def key_name(key: Key, *, flats: bool | None = None) -> str:
+    """``"G"``, ``"Bb"``, ``"F#m"``: the key spelled as its tonic chord.
+
+    >>> key_name(Key(10)), key_name(Key(6, minor=True)), key_name(Key(6, minor=True), flats=True)
+    ('Bb', 'F#m', 'Gbm')
+    """
+    flats = uses_flats(key) if flats is None else flats
+    return (_FLAT_NAMES if flats else _SHARP_NAMES)[key.tonic] + (
+        "m" if key.minor else ""
+    )
+
+
+def transpose_chord(symbol: str, semitones: int, *, flats: bool = False) -> str:
+    """``symbol`` moved by ``semitones``: root and bass move, the rest is kept as written.
+
+    ``flats`` spells moved notes with flats (choose it from the target key with
+    :func:`uses_flats`). What is not a chord comes back unchanged.
+
+    >>> transpose_chord("G", 2), transpose_chord("F#m7", 1), transpose_chord("C/E", 3, flats=True)
+    ('A', 'Gm7', 'Eb/G')
+    >>> transpose_chord("Bbmaj7", -1, flats=True), transpose_chord("N.C.", 4), transpose_chord("Am", 0)
+    ('Amaj7', 'N.C.', 'Am')
+    >>> [transpose_chord(c, 2) for c in ("D7/9", "Bm5-/7", "C6/9", "C(4/9)", "(Em7)", "Am7/G)")]
+    ['E7/9', 'C#m5-/7', 'D6/9', 'D(4/9)', '(F#m7)', 'Bm7/A)']
+    """
+    _check_semitones(semitones)
+    if semitones % 12 == 0 or parse_chord(symbol) is None:
+        return symbol
+    match = _TRANSPOSABLE_RE.fullmatch(symbol)
+    if match is None:
+        return symbol
+    names = _FLAT_NAMES if flats else _SHARP_NAMES
+
+    def moved(name: str) -> str:
+        return names[(_pitch_class(name) + semitones) % 12]
+
+    lead, root, rest, bass, tail = match.groups()
+    out = lead + moved(root) + rest
+    if bass:
+        out += "/" + moved(bass) + (tail or "")
+    return out
+
+
+def transposition_table(
+    symbols: Iterable[str], semitones: int, *, key: Key | None = None
+) -> dict:
+    """The chords of a song moved by ``semitones``, spelled for the new key.
+
+    ``symbols`` are the song's chords in order (they give the key when ``key`` is
+    not given). Returns ``{"semitones", "key", "chords"}``: the new key's name
+    (``""`` when there are no chords) and ``{original: transposed}`` over the
+    distinct chords, in order of first appearance.
+
+    >>> transposition_table(["G", "D", "Em", "C", "G"], 3)
+    {'semitones': 3, 'key': 'Bb', 'chords': {'G': 'Bb', 'D': 'F', 'Em': 'Gm', 'C': 'Eb'}}
+    """
+    _check_semitones(semitones)
+    symbols = list(symbols)
+    key = key or estimate_key(symbols)
+    target = Key((key.tonic + semitones) % 12, key.minor) if key else None
+    flats = uses_flats(target)
+    chords = {
+        symbol: transpose_chord(symbol, semitones, flats=flats)
+        for symbol in dict.fromkeys(symbols)
+    }
+    return {
+        "semitones": semitones,
+        "key": key_name(target) if target else "",
+        "chords": chords,
+    }

chordsym-0.0.2.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.5
+Name: chordsym
+Version: 0.0.2
+Summary: Chord symbols without dependencies: parse, pitch classes, key estimation, transposition
+Project-URL: Homepage, https://github.com/thorwhalen/chordsym
+Project-URL: Repository, https://github.com/thorwhalen/chordsym
+Project-URL: Documentation, https://thorwhalen.github.io/chordsym
+Author: Thor Whalen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chords,harmony,music,transposition
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# chordsym
+
+Chord symbols without dependencies (standard library only): is this token a chord, which root and quality, which pitch classes, which key does a song's chord list suggest, and how do the chords read moved by N semitones.
+
+```python
+>>> from chordsym import parse_chord, chord_tones, transpose_chord, transposition_table, estimate_key
+>>> parse_chord("F#m7"), chord_tones("Cmaj7")
+((6, 'minor'), (0, 4, 7, 11))
+>>> transpose_chord("C/E", 3, flats=True)
+'Eb/G'
+>>> transposition_table(["G", "D", "Em", "C"], 3)["chords"]
+{'G': 'Bb', 'D': 'F', 'Em': 'Gm', 'C': 'Eb'}
+```
+
+It reads the spellings found in scraped chord charts (`C6/9`, `Bm5-/7`, Brazilian `7M`, `E7(#9)`, `D/F#`), not only textbook ones. Pitch classes are ints 0-11 (C = 0).
+
+## In the browser: the TypeScript twin
+
+The same functions ship to npm as `chordsym` (in `ts/`), with camelCase names and keyword arguments as an options object:
+
+```ts
+import { parseChord, transposeChord, estimateKey } from "chordsym";
+
+parseChord("Am7");                         // [9, "minor"]
+transposeChord("C/E", 3, { flats: true }); // "Eb/G"
+estimateKey(["Am", "Dm", "E7"]);           // { tonic: 9, minor: true }
+```
+
+The two are kept identical by construction, not by care:
+
+- **One grammar.** Every regular expression and table lives in `chordsym/_grammar.py`, written in the subset of regex syntax that means the same in Python and JavaScript (no `\d`, `\s`, `\w`, `\b`). `python -m chordsym._codegen` writes it to `ts/src/grammar.generated.ts`, and a test fails if that file is stale.
+- **One set of golden cases.** `fixtures/cases.json` holds about 1,500 calls with their expected results, errors included (`ValueError` in Python is `RangeError` in TypeScript). pytest and vitest both run every one and compare them as JSON text, so order matters. To add a case, append it and run `python -m chordsym._fixtures`, which records the Python results; review the diff, since a changed expectation is a behaviour change on both sides.
+- **A wide net before releases.** `python scripts/twin_differential.py` (after `cd ts && npm run build`) runs about 75,000 generated chord spellings and 3,000 songs through both and reports any difference.
+
+Where the languages differ, the TypeScript side says so in its types: `transpositionTable(...).chords` is a `Map` (a plain object would reorder integer-like keys), and a `Key` is a plain `{ tonic, minor }` object checked by every function that takes one (`keyEquals` compares two).
+
+Versions: an npm release carries the version of the Python release it was cut from (lockstep at release points, so `chordsym@X.Y.Z` on npm and PyPI are the same behaviour).
+
+Seeded from songleaf (thorwhalen/songleaf#31). Planned: dialects (Harte, Chordonomicon, Nashville/Roman) as strategies; pychord and music21 as test oracles only.

chordsym-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+chordsym/__init__.py,sha256=TGiEWWrKbYgGJdknM1HOJJV3MTfkP2cekJ69kLR3sAo,752
+chordsym/_grammar.py,sha256=IcIZo_7hrUaYEKj46TNC_7UZvRDLZbfEJkgbvXm2T9U,4632
+chordsym/keys.py,sha256=YVKR1cIWS_ziMggubL-A6xkO9gc4X7Tsi2uW-zILWe4,3016
+chordsym/parse.py,sha256=L8Fcn4Vqb02mgbpI2Ncg3iLU9wdsTQcda00EMceOx2E,4274
+chordsym/transpose.py,sha256=y_8JayLP_rKm62FOVHKqDgngMHjozyeLrQvurrlSPKU,4261
+chordsym-0.0.2.dist-info/METADATA,sha256=6dQy78xWcYIzNf_3X_qpksRiOoPzXSKC8Yxr2nUJ_WE,3628
+chordsym-0.0.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+chordsym-0.0.2.dist-info/licenses/LICENSE,sha256=ekE13yCE9fWWEJfP1NPnUJabZ_Wwrc6coKJV2ZZx27w,1068
+chordsym-0.0.2.dist-info/RECORD,,

chordsym-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

chordsym-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thor Whalen
+
+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.