563 lines
19 KiB
Python
563 lines
19 KiB
Python
from typing import List, Dict, Any, Tuple
|
|
|
|
# ============================================================
|
|
# CONFIG / CONSTANTS (keep most variables here)
|
|
# ============================================================
|
|
|
|
GLOBAL_KEY = "G" # global major key center
|
|
DEBUG = 0 # 0..5 (0 = no debug, 5 = max)
|
|
|
|
NOTE_TO_PC = {
|
|
"C": 0, "B#": 0,
|
|
"C#": 1, "Db": 1,
|
|
"D": 2,
|
|
"D#": 3, "Eb": 3,
|
|
"E": 4, "Fb": 4,
|
|
"F": 5, "E#": 5,
|
|
"F#": 6, "Gb": 6,
|
|
"G": 7,
|
|
"G#": 8, "Ab": 8,
|
|
"A": 9,
|
|
"A#": 10, "Bb": 10,
|
|
"B": 11, "Cb": 11,
|
|
}
|
|
|
|
MAJOR_INTERVALS = [0, 2, 4, 5, 7, 9, 11] # 7-note set
|
|
|
|
DEGREE_LABELS = {
|
|
0: "1",
|
|
1: "b2",
|
|
2: "2",
|
|
3: "b3",
|
|
4: "3",
|
|
5: "4",
|
|
6: "b5",
|
|
7: "5",
|
|
8: "#5",
|
|
9: "6",
|
|
10: "b7",
|
|
11: "7",
|
|
}
|
|
|
|
ROMANS = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "VII"}
|
|
|
|
# 21-mode catalog: each is a 7-note set described by intervals from its root.
|
|
# Ordering matters for tie-break: Major-family first, then Melodic-minor, then Harmonic-minor.
|
|
|
|
MODE_CATALOG: List[Dict[str, Any]] = []
|
|
|
|
def _build_catalog():
|
|
# Major family (7)
|
|
major_modes = [
|
|
("Ionian (major)", [0, 2, 4, 5, 7, 9, 11]),
|
|
("Dorian", [0, 2, 3, 5, 7, 9, 10]),
|
|
("Phrygian", [0, 1, 3, 5, 7, 8, 10]),
|
|
("Lydian", [0, 2, 4, 6, 7, 9, 11]),
|
|
("Mixolydian", [0, 2, 4, 5, 7, 9, 10]),
|
|
("Aeolian (natural minor)", [0, 2, 3, 5, 7, 8, 10]),
|
|
("Locrian", [0, 1, 3, 5, 6, 8, 10]),
|
|
]
|
|
|
|
# Melodic minor family (7) (ascending melodic minor)
|
|
melodic_minor_modes = [
|
|
("Melodic minor", [0, 2, 3, 5, 7, 9, 11]),
|
|
("Dorian b2", [0, 1, 3, 5, 7, 9, 10]),
|
|
("Lydian augmented", [0, 2, 4, 6, 8, 9, 11]),
|
|
("Lydian dominant", [0, 2, 4, 6, 7, 9, 10]),
|
|
("Mixolydian b6", [0, 2, 4, 5, 7, 8, 10]),
|
|
("Locrian #2", [0, 2, 3, 5, 6, 8, 10]),
|
|
("Altered (super locrian)", [0, 1, 3, 4, 6, 8, 10]),
|
|
]
|
|
|
|
# Harmonic minor family (7)
|
|
harmonic_minor_modes = [
|
|
("Harmonic minor", [0, 2, 3, 5, 7, 8, 11]),
|
|
("Locrian #6", [0, 1, 3, 5, 6, 9, 10]),
|
|
("Ionian #5", [0, 2, 4, 5, 8, 9, 11]),
|
|
("Dorian #4", [0, 2, 3, 6, 7, 9, 10]),
|
|
("Phrygian dominant", [0, 1, 4, 5, 7, 8, 10]),
|
|
("Lydian #2", [0, 3, 4, 6, 7, 9, 11]),
|
|
("Altered diminished", [0, 1, 3, 4, 6, 7, 9]), # sometimes called "Ultralocrian"
|
|
]
|
|
|
|
# store
|
|
for fam_i, (family, modes) in enumerate([
|
|
("major", major_modes),
|
|
("melodic_minor", melodic_minor_modes),
|
|
("harmonic_minor", harmonic_minor_modes),
|
|
]):
|
|
for mode_i, (name, intervals) in enumerate(modes):
|
|
MODE_CATALOG.append({
|
|
"family": family,
|
|
"family_rank": fam_i, # tie-break: smaller is preferred
|
|
"mode_rank": mode_i, # within family
|
|
"name": name,
|
|
"intervals": intervals
|
|
})
|
|
|
|
_build_catalog()
|
|
|
|
# ============================================================
|
|
# BASIC HELPERS
|
|
# ============================================================
|
|
|
|
def dprint(level: int, msg: str) -> None:
|
|
if DEBUG >= level:
|
|
print(msg)
|
|
|
|
def normalize_note(name: str) -> str:
|
|
s = name.strip().replace("♭", "b").replace("♯", "#")
|
|
if not s:
|
|
return s
|
|
return s[0].upper() + s[1:]
|
|
|
|
def note_to_pc(name: str) -> int:
|
|
name = normalize_note(name)
|
|
if name not in NOTE_TO_PC:
|
|
raise ValueError(f"Unknown note name: {name}")
|
|
return NOTE_TO_PC[name]
|
|
|
|
def build_scale_from_intervals(root_pc: int, intervals: List[int]) -> List[int]:
|
|
return [(root_pc + i) % 12 for i in intervals]
|
|
|
|
def build_major_scale_pcs(tonic: str) -> List[int]:
|
|
t_pc = note_to_pc(tonic)
|
|
return [(t_pc + i) % 12 for i in MAJOR_INTERVALS]
|
|
|
|
def pitch_to_degree_label(note_pc: int, root_pc: int) -> str:
|
|
return DEGREE_LABELS[(note_pc - root_pc) % 12]
|
|
|
|
# ============================================================
|
|
# CHORD PARSING + REQUIRED TONES
|
|
# ============================================================
|
|
|
|
def parse_chord_symbol(symbol: str) -> Dict[str, Any]:
|
|
"""
|
|
Parses roots like D, Db, F#
|
|
Parses qualities: maj7 / M7, m / m7, dominant by presence of 7/9/13 without maj/min marker.
|
|
Parses alterations: b9, #9, b13, #11, b5, #5
|
|
Also recognizes plain extensions: 9, 11, 13 (as unaltered).
|
|
"""
|
|
s = symbol.strip().replace("♭", "b").replace("♯", "#")
|
|
if not s:
|
|
raise ValueError("Empty chord symbol.")
|
|
|
|
# root letter + optional accidental
|
|
if len(s) >= 2 and s[1] in ("b", "#"):
|
|
root, rest = s[:2], s[2:]
|
|
else:
|
|
root, rest = s[0], s[1:]
|
|
|
|
root = normalize_note(root)
|
|
r = rest.lower()
|
|
|
|
# Quality
|
|
quality = "maj"
|
|
if "maj" in r or "ma7" in r or "maj7" in r or "∆" in r:
|
|
quality = "maj"
|
|
elif r.startswith("m") or "min" in r:
|
|
quality = "min"
|
|
|
|
# Dominant (7/9/13) when not maj/min explicitly
|
|
dominant = False
|
|
if any(x in r for x in ["7", "9", "11", "13"]) and ("maj" not in r and not (r.startswith("m") or "min" in r)):
|
|
quality = "dom"
|
|
dominant = True
|
|
|
|
# Extract alterations and extensions
|
|
# We treat "b9" etc as explicit, and "9"/"11"/"13" as plain extensions if present.
|
|
alts = []
|
|
for a in ["b9", "#9", "b13", "#11", "b5", "#5"]:
|
|
if a in r:
|
|
alts.append(a)
|
|
|
|
exts = []
|
|
for e in ["13", "11", "9", "7"]: # check longer first
|
|
if e in r:
|
|
exts.append(e)
|
|
|
|
return {
|
|
"symbol": symbol,
|
|
"root": root,
|
|
"quality": quality, # 'maj', 'min', 'dom'
|
|
"dominant": dominant,
|
|
"alts": alts,
|
|
"exts": exts,
|
|
}
|
|
|
|
def chord_required_semitones(ch: Dict[str, Any]) -> Tuple[List[int], List[int]]:
|
|
"""
|
|
Returns (core_tones, extra_tones) as semitone offsets from chord root.
|
|
core_tones: identity tones (triad + 7 if present/assumed by quality)
|
|
extra_tones: extensions/alterations (9/11/13, b9, #9, #11, b13, etc)
|
|
"""
|
|
q = ch["quality"]
|
|
exts = ch["exts"]
|
|
alts = set(ch["alts"])
|
|
|
|
# core: 1 + 3/b3 + 5 + 7/b7 depending on chord quality
|
|
if q == "maj":
|
|
core = [0, 4, 7] + ([11] if ("7" in exts or "maj7" in ch["symbol"].lower() or "ma7" in ch["symbol"].lower()) else [])
|
|
elif q == "min":
|
|
core = [0, 3, 7] + ([10] if ("7" in exts or "m7" in ch["symbol"].lower()) else [])
|
|
else: # dom
|
|
core = [0, 4, 7, 10] # dominant implies b7
|
|
|
|
extra: List[int] = []
|
|
|
|
# plain extensions (if written)
|
|
if "9" in exts:
|
|
extra.append(2)
|
|
if "11" in exts:
|
|
extra.append(5)
|
|
if "13" in exts:
|
|
extra.append(9)
|
|
|
|
# alterations override / add
|
|
if "b9" in alts:
|
|
extra.append(1)
|
|
if "#9" in alts:
|
|
extra.append(3)
|
|
if "#11" in alts:
|
|
extra.append(6)
|
|
if "b13" in alts:
|
|
extra.append(8)
|
|
if "b5" in alts:
|
|
extra.append(6)
|
|
if "#5" in alts:
|
|
extra.append(8)
|
|
|
|
# remove duplicates while preserving order
|
|
def uniq(xs: List[int]) -> List[int]:
|
|
out = []
|
|
seen = set()
|
|
for x in xs:
|
|
if x not in seen:
|
|
out.append(x)
|
|
seen.add(x)
|
|
return out
|
|
|
|
return uniq(core), uniq(extra)
|
|
|
|
# ============================================================
|
|
# ROMAN NUMERAL IN GLOBAL MAJOR KEY
|
|
# ============================================================
|
|
|
|
def degree_in_global_major(chord_root: str, global_key: str) -> int:
|
|
scale = build_major_scale_pcs(global_key)
|
|
r_pc = note_to_pc(chord_root)
|
|
return scale.index(r_pc) + 1 if r_pc in scale else 0
|
|
|
|
def roman_for_degree(deg: int, quality: str) -> str:
|
|
if deg == 0:
|
|
return "N/A"
|
|
base = ROMANS[deg]
|
|
return base.lower() if quality == "min" else base
|
|
|
|
# ============================================================
|
|
# 21-MODE MATCHING ENGINE
|
|
# ============================================================
|
|
|
|
def mode_match_rank(
|
|
root_pc: int,
|
|
core: List[int],
|
|
extra: List[int],
|
|
melody_pcs: List[int],
|
|
mode: Dict[str, Any],
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Scoring idea:
|
|
- core tones should strongly be present in mode (big penalty if missing)
|
|
- extra (extensions/alterations) should be present if possible (smaller penalty)
|
|
- melody notes in mode add points, weighted by order (earlier notes count slightly more)
|
|
"""
|
|
mode_pcs = set(build_scale_from_intervals(root_pc, mode["intervals"]))
|
|
|
|
core_pcs = {(root_pc + s) % 12 for s in core}
|
|
extra_pcs = {(root_pc + s) % 12 for s in extra}
|
|
|
|
missing_core = [pc for pc in core_pcs if pc not in mode_pcs]
|
|
missing_extra = [pc for pc in extra_pcs if pc not in mode_pcs]
|
|
|
|
# melody match with order weighting
|
|
n = max(len(melody_pcs), 1)
|
|
weights = [(n - i) / n for i in range(n)] # first notes slightly heavier
|
|
melody_hits = []
|
|
melody_score = 0.0
|
|
for i, pc in enumerate(melody_pcs):
|
|
hit = (pc in mode_pcs)
|
|
melody_hits.append(hit)
|
|
if hit:
|
|
melody_score += 1.0 * weights[i]
|
|
|
|
# penalties / bonuses
|
|
score = 0.0
|
|
score += 4.0 * (len(core_pcs) - len(missing_core))
|
|
score -= 10.0 * len(missing_core)
|
|
score += 1.5 * (len(extra_pcs) - len(missing_extra))
|
|
score -= 2.5 * len(missing_extra)
|
|
score += melody_score
|
|
|
|
return {
|
|
"mode": mode,
|
|
"score": score,
|
|
"missing_core": missing_core,
|
|
"missing_extra": missing_extra,
|
|
"melody_score": melody_score,
|
|
"melody_hits": melody_hits,
|
|
}
|
|
|
|
def choose_modes_21(
|
|
chord_info: Dict[str, Any],
|
|
melody_pcs: List[int],
|
|
) -> Dict[str, Any]:
|
|
root_pc = note_to_pc(chord_info["root"])
|
|
core, extra = chord_required_semitones(chord_info)
|
|
|
|
dprint(4, f"[debug] chord root pc={root_pc}, core semitones={core}, extra semitones={extra}")
|
|
|
|
ranked = []
|
|
for mode in MODE_CATALOG:
|
|
r = mode_match_rank(root_pc, core, extra, melody_pcs, mode)
|
|
ranked.append(r)
|
|
|
|
# Sort:
|
|
# 1) higher score
|
|
# 2) prefer major-family first (family_rank)
|
|
# 3) prefer earlier mode_rank
|
|
ranked.sort(key=lambda x: (-x["score"], x["mode"]["family_rank"], x["mode"]["mode_rank"]))
|
|
|
|
if DEBUG >= 5:
|
|
for k in range(min(10, len(ranked))):
|
|
m = ranked[k]
|
|
dprint(5, f"[debug] rank {k+1}: {m['mode']['family']}::{m['mode']['name']} score={m['score']:.3f} "
|
|
f"missing_core={len(m['missing_core'])} missing_extra={len(m['missing_extra'])} "
|
|
f"melody_score={m['melody_score']:.3f}")
|
|
|
|
best = ranked[0]
|
|
# include some alternatives that are close
|
|
alternatives = ranked[1:6]
|
|
|
|
return {
|
|
"best": best,
|
|
"alternatives": alternatives,
|
|
}
|
|
|
|
# ============================================================
|
|
# SIMPLE MELODY FUNCTION TAGS (per chord)
|
|
# ============================================================
|
|
|
|
def analyze_melody_functions(melody_pcs: List[int], root_pc: int, quality: str) -> Dict[int, List[str]]:
|
|
"""
|
|
Heuristics, minimal and local:
|
|
- chord_tone: chord triad + 7 (based on quality)
|
|
- guide_tone: the 3rd and 7th relative to root (major 3rd + maj7 assumed for maj7-ish,
|
|
minor 3rd + b7 for minor7-ish, major3 + b7 for dominant)
|
|
- scale_line: 3 stepwise notes
|
|
- neighbor: a == c and b step away
|
|
- passing / chromatic passing: between two chord tones
|
|
"""
|
|
n = len(melody_pcs)
|
|
labels: Dict[int, List[str]] = {i: [] for i in range(n)}
|
|
|
|
if quality == "maj":
|
|
chord_tones = {(root_pc + s) % 12 for s in [0, 4, 7, 11]}
|
|
guide_tones = {(root_pc + 4) % 12, (root_pc + 11) % 12}
|
|
elif quality == "min":
|
|
chord_tones = {(root_pc + s) % 12 for s in [0, 3, 7, 10]}
|
|
guide_tones = {(root_pc + 3) % 12, (root_pc + 10) % 12}
|
|
else:
|
|
chord_tones = {(root_pc + s) % 12 for s in [0, 4, 7, 10]}
|
|
guide_tones = {(root_pc + 4) % 12, (root_pc + 10) % 12}
|
|
|
|
for i, pc in enumerate(melody_pcs):
|
|
if pc in guide_tones:
|
|
labels[i].append("guide_tone")
|
|
if pc in chord_tones:
|
|
labels[i].append("chord_tone")
|
|
|
|
# scale line
|
|
for i in range(1, n - 1):
|
|
a, b, c = melody_pcs[i - 1], melody_pcs[i], melody_pcs[i + 1]
|
|
d1 = (b - a) % 12
|
|
d2 = (c - b) % 12
|
|
if d1 in (1, 2, 10, 11) and d2 == d1:
|
|
labels[i - 1].append("scale_line")
|
|
labels[i].append("scale_line")
|
|
labels[i + 1].append("scale_line")
|
|
|
|
# neighbors
|
|
for i in range(1, n - 1):
|
|
a, b, c = melody_pcs[i - 1], melody_pcs[i], melody_pcs[i + 1]
|
|
if a == c and a in chord_tones:
|
|
step = (b - a) % 12
|
|
if step in (1, 2):
|
|
labels[i].append("upper_neighbor")
|
|
elif step in (10, 11):
|
|
labels[i].append("lower_neighbor")
|
|
|
|
# passing / chromatic passing (no scale context; purely chord-tone bridge)
|
|
for i in range(1, n - 1):
|
|
a, b, c = melody_pcs[i - 1], melody_pcs[i], melody_pcs[i + 1]
|
|
if a in chord_tones and c in chord_tones and b not in chord_tones:
|
|
up = (b - a) % 12
|
|
down = (c - b) % 12
|
|
if up in (1, 2, 10, 11) and down in (1, 2, 10, 11):
|
|
# if b is diatonic to either end? we don't know scale here, so treat semitone as chromatic
|
|
if up == 1 or down == 1 or up == 11 or down == 11:
|
|
labels[i].append("chromatic_passing_tone")
|
|
else:
|
|
labels[i].append("passing_tone")
|
|
|
|
return labels
|
|
|
|
# ============================================================
|
|
# MAIN ANALYSIS
|
|
# ============================================================
|
|
|
|
def analyze_chord_and_melody(chord_symbol: str, melody_notes: List[str], global_key: str) -> Dict[str, Any]:
|
|
chord = parse_chord_symbol(chord_symbol)
|
|
melody_pcs = [note_to_pc(n) for n in melody_notes]
|
|
|
|
deg = degree_in_global_major(chord["root"], global_key)
|
|
roman = roman_for_degree(deg, chord["quality"])
|
|
|
|
dprint(3, f"[debug] parsed chord={chord} deg={deg} roman={roman}")
|
|
|
|
mode_choice = choose_modes_21(chord, melody_pcs)
|
|
best = mode_choice["best"]
|
|
best_mode = best["mode"]
|
|
|
|
root_pc = note_to_pc(chord["root"])
|
|
melody_degrees = [pitch_to_degree_label(pc, root_pc) for pc in melody_pcs]
|
|
|
|
functions = analyze_melody_functions(melody_pcs, root_pc, chord["quality"])
|
|
|
|
return {
|
|
"global_key": global_key,
|
|
"chord": chord,
|
|
"degree_in_key": deg,
|
|
"roman": roman,
|
|
"best_mode": {
|
|
"family": best_mode["family"],
|
|
"name": best_mode["name"],
|
|
"score": best["score"],
|
|
"melody_score": best["melody_score"],
|
|
"missing_core": best["missing_core"],
|
|
"missing_extra": best["missing_extra"],
|
|
},
|
|
"alternatives": [
|
|
{
|
|
"family": a["mode"]["family"],
|
|
"name": a["mode"]["name"],
|
|
"score": a["score"],
|
|
"melody_score": a["melody_score"],
|
|
"missing_core": a["missing_core"],
|
|
"missing_extra": a["missing_extra"],
|
|
}
|
|
for a in mode_choice["alternatives"]
|
|
],
|
|
"melody_notes": [normalize_note(n) for n in melody_notes],
|
|
"melody_degrees": melody_degrees,
|
|
"functions": functions,
|
|
}
|
|
|
|
# ============================================================
|
|
# CLI
|
|
# ============================================================
|
|
|
|
def parse_cli_line(line: str) -> Tuple[str, List[str]]:
|
|
"""
|
|
Expects: [chord]: note1, note2, ...
|
|
Allows commas or whitespace between notes.
|
|
"""
|
|
if ":" not in line:
|
|
raise ValueError("Input must contain ':' like D7b9b13: F#, A, C, Eb, Bb")
|
|
|
|
chord_part, melody_part = line.split(":", 1)
|
|
chord = chord_part.strip()
|
|
if not chord:
|
|
raise ValueError("Missing chord before ':'.")
|
|
|
|
melody_raw = melody_part.strip()
|
|
if not melody_raw:
|
|
raise ValueError("Missing melody notes after ':'.")
|
|
|
|
if "," in melody_raw:
|
|
tokens = [t.strip() for t in melody_raw.split(",")]
|
|
else:
|
|
tokens = [t.strip() for t in melody_raw.split()]
|
|
|
|
notes = [t for t in tokens if t]
|
|
if not notes:
|
|
raise ValueError("No valid note names parsed.")
|
|
|
|
return chord, notes
|
|
|
|
def main():
|
|
global DEBUG
|
|
|
|
print("Interactive chord/melody analyzer (21-mode matching)")
|
|
print(f"Global key: {GLOBAL_KEY} major")
|
|
print(f"Debug level: {DEBUG} (0..5)")
|
|
print("Input format: [chord]: note1, note2, note3 ...")
|
|
print('Commands: "quit", or "debug=N" to set debug level.\n')
|
|
|
|
while True:
|
|
s = input("Enter > ").strip()
|
|
if not s:
|
|
continue
|
|
if s.lower() == "quit":
|
|
print("Goodbye.")
|
|
break
|
|
if s.lower().startswith("debug="):
|
|
try:
|
|
DEBUG = int(s.split("=", 1)[1].strip())
|
|
if DEBUG < 0 or DEBUG > 5:
|
|
raise ValueError
|
|
print(f"Debug set to {DEBUG}.")
|
|
except ValueError:
|
|
print("Error: debug must be an integer 0..5.")
|
|
continue
|
|
|
|
try:
|
|
chord, notes = parse_cli_line(s)
|
|
result = analyze_chord_and_melody(chord, notes, GLOBAL_KEY)
|
|
except ValueError as e:
|
|
print(f"Error: {e}")
|
|
print("Please type again.")
|
|
continue
|
|
|
|
print("\n====================================")
|
|
print(f"Chord: {result['chord']['symbol']} (root {result['chord']['root']}, quality {result['chord']['quality']})")
|
|
print(f"Global key: {result['global_key']} major")
|
|
print(f"Roman numeral (by root in global key): {result['roman']} (degree {result['degree_in_key']})")
|
|
|
|
bm = result["best_mode"]
|
|
print("\nBest mode match (rooted on chord root):")
|
|
print(f" {bm['family']} :: {bm['name']}")
|
|
print(f" score={bm['score']:.3f} (melody_score={bm['melody_score']:.3f})")
|
|
if bm["missing_core"]:
|
|
print(f" WARNING missing core chord tones (pcs): {bm['missing_core']}")
|
|
if bm["missing_extra"]:
|
|
print(f" missing extension/alteration tones (pcs): {bm['missing_extra']}")
|
|
|
|
print("\nAlternatives:")
|
|
for a in result["alternatives"]:
|
|
print(f" - {a['family']} :: {a['name']} score={a['score']:.3f} melody_score={a['melody_score']:.3f}"
|
|
f" missing_core={len(a['missing_core'])} missing_extra={len(a['missing_extra'])}")
|
|
|
|
print("\nMelody numeral labels (relative to chord root):")
|
|
for i, (n, deg) in enumerate(zip(result["melody_notes"], result["melody_degrees"])):
|
|
print(f" [{i}] {n:3} -> {deg}")
|
|
|
|
print("\nPer-note function tags:")
|
|
for i, labs in result["functions"].items():
|
|
if labs:
|
|
print(f" index {i}, note {result['melody_notes'][i]}: {', '.join(sorted(set(labs)))}")
|
|
|
|
print("====================================\n")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|