mirror of
https://github.com/kennethreitz/pytheory.git
synced 2026-06-05 14:50:18 +00:00
kennethreitz
7d56ed7a2c
Tests for articulations, dynamic curves, Part.hit(), Part.ramp(), djembe/cajón/metal patterns and fills. 882 tests total. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
7364 lines
229 KiB
Python
7364 lines
229 KiB
Python
import pytest
|
|
import numpy
|
|
|
|
import pytheory
|
|
from pytheory import Tone, TonedScale, Fretboard, Chord, Key, Note
|
|
from pytheory.charts import CHARTS, NamedChord, charts_for_fretboard, QUALITIES
|
|
from pytheory.systems import System, SYSTEMS
|
|
|
|
try:
|
|
import sounddevice
|
|
HAS_PORTAUDIO = True
|
|
except OSError:
|
|
HAS_PORTAUDIO = False
|
|
|
|
needs_portaudio = pytest.mark.skipif(not HAS_PORTAUDIO, reason="PortAudio not available")
|
|
|
|
|
|
# ── Tone basics ──────────────────────────────────────────────────────────────
|
|
|
|
def test_tone_from_string():
|
|
c4 = Tone.from_string("C4")
|
|
assert c4.name == "C"
|
|
assert c4.octave == 4
|
|
|
|
|
|
def test_tone_from_string_sharp():
|
|
cs4 = Tone.from_string("C#4")
|
|
assert cs4.name == "C#"
|
|
assert cs4.octave == 4
|
|
|
|
|
|
def test_tone_from_string_no_octave():
|
|
d = Tone.from_string("D")
|
|
assert d.name == "D"
|
|
assert d.octave is None
|
|
|
|
|
|
def test_tone_initialization():
|
|
c4 = Tone(name="C", octave=4)
|
|
assert c4.name == "C"
|
|
assert c4.octave == 4
|
|
|
|
|
|
def test_tone_initialization_with_octave_in_name_and_kwarg():
|
|
# When name has digits, explicit octave kwarg is kept
|
|
t = Tone(name="C4", octave=5)
|
|
assert t.name == "C"
|
|
assert t.octave == 5 # explicit kwarg preserved
|
|
|
|
|
|
def test_tone_full_name():
|
|
c4 = Tone(name="C", octave=4)
|
|
d = Tone(name="D", octave=None)
|
|
assert c4.full_name == "C4"
|
|
assert d.full_name == "D"
|
|
|
|
|
|
def test_tone_repr():
|
|
c4 = Tone(name="C", octave=4)
|
|
assert repr(c4) == "<Tone C4>"
|
|
|
|
|
|
def test_tone_system():
|
|
c4 = Tone(name="C", octave=4, system="western")
|
|
assert c4.system_name == "western"
|
|
assert c4.system == pytheory.SYSTEMS["western"]
|
|
|
|
|
|
def test_tone_exists():
|
|
c4 = Tone(name="C", octave=4, system="western")
|
|
assert c4.exists is True
|
|
|
|
|
|
def test_tone_invalid_raises():
|
|
"""Invalid tone names raise ValueError at construction time (fixes #39)."""
|
|
import pytest
|
|
with pytest.raises(ValueError, match="Unknown tone name"):
|
|
Tone(name="H", octave=4, system="western")
|
|
with pytest.raises(ValueError, match="Unknown tone name"):
|
|
Tone("X")
|
|
|
|
|
|
def test_tone_names_method():
|
|
t = Tone(name="C#", alt_names=["Db"], octave=4)
|
|
assert t.names() == ["C#", "Db"]
|
|
|
|
|
|
# ── Tone equality ────────────────────────────────────────────────────────────
|
|
|
|
def test_tone_eq_string():
|
|
c4 = Tone(name="C", octave=4)
|
|
assert c4 == "C"
|
|
assert not (c4 == "D")
|
|
|
|
|
|
def test_tone_eq_tone():
|
|
a = Tone(name="C", octave=4)
|
|
b = Tone(name="C", octave=4)
|
|
assert a == b
|
|
|
|
|
|
def test_tone_eq_different_octave():
|
|
a = Tone(name="C", octave=4)
|
|
b = Tone(name="C", octave=5)
|
|
assert not (a == b)
|
|
|
|
|
|
def test_tone_eq_alt_name():
|
|
a = Tone(name="C#", alt_names=["Db"], octave=4)
|
|
b = Tone(name="Db", alt_names=["C#"], octave=4)
|
|
assert a == b # b.name "Db" is in a.names(), and vice versa
|
|
|
|
|
|
def test_tone_hash():
|
|
a = Tone(name="C", octave=4)
|
|
b = Tone(name="C", octave=4)
|
|
assert hash(a) == hash(b)
|
|
s = {a, b}
|
|
assert len(s) == 1
|
|
|
|
|
|
# ── Tone arithmetic ─────────────────────────────────────────────────────────
|
|
|
|
def test_tone_addition():
|
|
t = Tone.from_string("C4", system=pytheory.SYSTEMS["western"])
|
|
assert t.add(12).full_name == "C5"
|
|
|
|
|
|
def test_tone_subtraction():
|
|
t = Tone.from_string("C5", system=pytheory.SYSTEMS["western"])
|
|
assert t.subtract(12).full_name == "C4"
|
|
|
|
|
|
def test_tone_add_semitone():
|
|
t = Tone.from_string("C4", system=pytheory.SYSTEMS["western"])
|
|
assert t.add(1).name == "C#"
|
|
assert t.add(1).octave == 4
|
|
|
|
|
|
def test_tone_add_across_octave_boundary():
|
|
"""B4 + 1 semitone = C5 (octave changes at C)."""
|
|
t = Tone.from_string("B4", system=pytheory.SYSTEMS["western"])
|
|
result = t.add(1)
|
|
assert result.name == "C"
|
|
assert result.octave == 5
|
|
|
|
|
|
def test_tone_subtract_across_octave_boundary():
|
|
"""C4 - 1 semitone = B3."""
|
|
t = Tone.from_string("C4", system=pytheory.SYSTEMS["western"])
|
|
result = t.subtract(1)
|
|
assert result.name == "B"
|
|
assert result.octave == 3
|
|
|
|
|
|
def test_tone_add_within_octave_no_wrap():
|
|
"""A4 + 2 = B4 (no octave change, A and B are in same octave)."""
|
|
t = Tone.from_string("A4", system=pytheory.SYSTEMS["western"])
|
|
result = t.add(2)
|
|
assert result.name == "B"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_tone_octave_correct_for_chromatic_walk():
|
|
"""Walk all 12 semitones from C4 to C5 and verify octave numbers."""
|
|
t = Tone.from_string("C4", system=pytheory.SYSTEMS["western"])
|
|
expected = [
|
|
("C", 4), ("C#", 4), ("D", 4), ("D#", 4),
|
|
("E", 4), ("F", 4), ("F#", 4), ("G", 4),
|
|
("G#", 4), ("A", 4), ("A#", 4), ("B", 4), ("C", 5),
|
|
]
|
|
for i, (name, octave) in enumerate(expected):
|
|
result = t.add(i)
|
|
assert result.name == name, f"step {i}: expected {name}, got {result.name}"
|
|
assert result.octave == octave, f"step {i}: expected octave {octave}, got {result.octave}"
|
|
|
|
|
|
# ── Pitch frequencies ────────────────────────────────────────────────────────
|
|
|
|
def test_pitch_a4_is_440():
|
|
t = Tone.from_string("A4", system="western")
|
|
assert abs(t.pitch() - 440.0) < 0.01
|
|
|
|
|
|
def test_pitch_a0():
|
|
t = Tone.from_string("A0", system="western")
|
|
assert abs(t.pitch() - 27.5) < 0.01
|
|
|
|
|
|
def test_tone_octave_zero_full_name():
|
|
t = Tone.from_string("A0", system="western")
|
|
assert t.full_name == "A0"
|
|
|
|
|
|
def test_pitch_a3_is_220():
|
|
t = Tone.from_string("A3", system="western")
|
|
assert abs(t.pitch() - 220.0) < 0.01
|
|
|
|
|
|
def test_pitch_c4_middle_c():
|
|
t = Tone.from_string("C4", system="western")
|
|
assert abs(t.pitch() - 261.63) < 0.01
|
|
|
|
|
|
def test_pitch_c5():
|
|
t = Tone.from_string("C5", system="western")
|
|
assert abs(t.pitch() - 523.25) < 0.01
|
|
|
|
|
|
def test_pitch_e4():
|
|
t = Tone.from_string("E4", system="western")
|
|
assert abs(t.pitch() - 329.63) < 0.01
|
|
|
|
|
|
def test_pitch_octave_doubles_frequency():
|
|
t1 = Tone.from_string("C4", system="western")
|
|
t2 = Tone.from_string("C5", system="western")
|
|
ratio = t2.pitch() / t1.pitch()
|
|
assert abs(ratio - 2.0) < 0.001
|
|
|
|
|
|
def test_pitch_symbolic():
|
|
t = Tone.from_string("A4", system="western")
|
|
sym_pitch = t.pitch(symbolic=True)
|
|
assert float(sym_pitch) == 440.0
|
|
|
|
|
|
# ── Scales ───────────────────────────────────────────────────────────────────
|
|
|
|
def test_c_major_scale():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
names = [t.name for t in major.tones]
|
|
assert names == ["C", "D", "E", "F", "G", "A", "B", "C"]
|
|
|
|
|
|
def test_c_major_scale_octaves():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
octaves = [t.octave for t in major.tones]
|
|
assert octaves == [4, 4, 4, 4, 4, 4, 4, 5]
|
|
|
|
|
|
def test_c_minor_scale():
|
|
c = TonedScale(tonic="C4")
|
|
minor = c["minor"]
|
|
names = [t.name for t in minor.tones]
|
|
# C D Eb F G Ab Bb C (using flats for flat keys)
|
|
assert names == ["C", "D", "Eb", "F", "G", "Ab", "Bb", "C"]
|
|
|
|
|
|
def test_c_harmonic_minor_scale():
|
|
c = TonedScale(tonic="C4")
|
|
hminor = c["harmonic minor"]
|
|
names = [t.name for t in hminor.tones]
|
|
# C D Eb F G Ab B C (raised 7th)
|
|
assert names == ["C", "D", "Eb", "F", "G", "Ab", "B", "C"]
|
|
|
|
|
|
def test_g_major_scale():
|
|
g = TonedScale(tonic="G4")
|
|
major = g["major"]
|
|
names = [t.name for t in major.tones]
|
|
assert names == ["G", "A", "B", "C", "D", "E", "F#", "G"]
|
|
|
|
|
|
def test_available_scales():
|
|
c = TonedScale(tonic="C4")
|
|
scales = c.scales
|
|
assert "major" in scales
|
|
assert "minor" in scales
|
|
assert "harmonic minor" in scales
|
|
assert "ionian" in scales
|
|
assert "dorian" in scales
|
|
|
|
|
|
def test_scale_degree_by_roman_numeral():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
assert major["I"].name == "C"
|
|
assert major["V"].name == "G"
|
|
|
|
|
|
def test_scale_degree_by_index():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
assert major[0].name == "C"
|
|
assert major[4].name == "G"
|
|
|
|
|
|
def test_scale_invalid_key():
|
|
c = TonedScale(tonic="C4")
|
|
with pytest.raises(KeyError):
|
|
c["nonexistent"]
|
|
|
|
|
|
# ── Modes ────────────────────────────────────────────────────────────────────
|
|
|
|
def test_ionian_equals_major():
|
|
c = TonedScale(tonic="C4")
|
|
major_names = [t.name for t in c["major"].tones]
|
|
ionian_names = [t.name for t in c["ionian"].tones]
|
|
assert major_names == ionian_names
|
|
|
|
|
|
def test_aeolian_equals_minor():
|
|
c = TonedScale(tonic="C4")
|
|
minor_names = [t.name for t in c["minor"].tones]
|
|
aeolian_names = [t.name for t in c["aeolian"].tones]
|
|
assert minor_names == aeolian_names
|
|
|
|
|
|
def test_c_dorian():
|
|
c = TonedScale(tonic="C4")
|
|
dorian = c["dorian"]
|
|
names = [t.name for t in dorian.tones]
|
|
# Dorian: W H W W W H W → C D Eb F G A Bb C
|
|
assert names == ["C", "D", "Eb", "F", "G", "A", "Bb", "C"]
|
|
|
|
|
|
def test_c_phrygian():
|
|
c = TonedScale(tonic="C4")
|
|
phrygian = c["phrygian"]
|
|
names = [t.name for t in phrygian.tones]
|
|
# Phrygian: H W W W H W W → C Db Eb F G Ab Bb C
|
|
assert names == ["C", "Db", "Eb", "F", "G", "Ab", "Bb", "C"]
|
|
|
|
|
|
def test_c_lydian():
|
|
c = TonedScale(tonic="C4")
|
|
lydian = c["lydian"]
|
|
names = [t.name for t in lydian.tones]
|
|
# Lydian: W W W H W W H → C D E F# G A B C
|
|
assert names == ["C", "D", "E", "F#", "G", "A", "B", "C"]
|
|
|
|
|
|
def test_c_mixolydian():
|
|
c = TonedScale(tonic="C4")
|
|
mixolydian = c["mixolydian"]
|
|
names = [t.name for t in mixolydian.tones]
|
|
# Mixolydian: W W H W W H W → C D E F G A Bb C
|
|
assert names == ["C", "D", "E", "F", "G", "A", "Bb", "C"]
|
|
|
|
|
|
def test_c_locrian():
|
|
c = TonedScale(tonic="C4")
|
|
locrian = c["locrian"]
|
|
names = [t.name for t in locrian.tones]
|
|
# Locrian: H W W H W W W → C Db Eb F Gb Ab Bb C
|
|
assert names == ["C", "Db", "Eb", "F", "Gb", "Ab", "Bb", "C"]
|
|
|
|
|
|
# ── Chords ───────────────────────────────────────────────────────────────────
|
|
|
|
def test_chord_creation():
|
|
c_major = Chord(
|
|
tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
Tone(name="G", octave=4),
|
|
]
|
|
)
|
|
assert len(c_major.tones) == 3
|
|
assert c_major.tones[0].full_name == "C4"
|
|
assert c_major.tones[1].full_name == "E4"
|
|
assert c_major.tones[2].full_name == "G4"
|
|
|
|
|
|
def test_chord_harmony():
|
|
c_major = Chord(
|
|
tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
Tone(name="G", octave=4),
|
|
]
|
|
)
|
|
assert c_major.harmony > 0
|
|
|
|
|
|
def test_chord_dissonance():
|
|
c_major = Chord(
|
|
tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
Tone(name="G", octave=4),
|
|
]
|
|
)
|
|
assert c_major.dissonance > 0
|
|
|
|
|
|
def test_chord_single_tone():
|
|
single = Chord(tones=[Tone(name="C", octave=4)])
|
|
assert single.harmony == 0
|
|
assert single.dissonance == 0
|
|
assert single.beat_pulse == 0
|
|
assert single.intervals == []
|
|
|
|
|
|
def test_chord_repr():
|
|
c = Chord(tones=[Tone(name="C", octave=4), Tone(name="E", octave=4)])
|
|
assert "C4" in repr(c)
|
|
assert "E4" in repr(c)
|
|
|
|
|
|
# ── Named chords (acceptable tones / music theory) ──────────────────────────
|
|
|
|
def test_named_chord_c_major_tones():
|
|
c = NamedChord(tone_name="C", quality="")
|
|
names = c.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names
|
|
assert "G" in names
|
|
|
|
|
|
def test_named_chord_c_major_explicit_tones():
|
|
c = NamedChord(tone_name="C", quality="maj")
|
|
names = c.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names
|
|
assert "G" in names
|
|
|
|
|
|
def test_named_chord_c_minor_tones():
|
|
cm = NamedChord(tone_name="C", quality="m")
|
|
names = cm.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "Eb" in names # minor 3rd
|
|
assert "G" in names
|
|
|
|
|
|
def test_named_chord_power_chord():
|
|
c5 = NamedChord(tone_name="C", quality="5")
|
|
names = c5.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "G" in names
|
|
assert len(names) == 2
|
|
|
|
|
|
def test_named_chord_dominant_7th():
|
|
c7 = NamedChord(tone_name="C", quality="7")
|
|
names = c7.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names # major 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "Bb" in names # minor 7th
|
|
|
|
|
|
def test_named_chord_diminished():
|
|
cdim = NamedChord(tone_name="C", quality="dim")
|
|
names = cdim.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "Eb" in names # minor 3rd
|
|
assert "Gb" in names # diminished 5th
|
|
|
|
|
|
def test_named_chord_minor_7th():
|
|
cm7 = NamedChord(tone_name="C", quality="m7")
|
|
names = cm7.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "Eb" in names # minor 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "Bb" in names # minor 7th
|
|
|
|
|
|
def test_named_chord_major_7th():
|
|
cmaj7 = NamedChord(tone_name="C", quality="maj7")
|
|
names = cmaj7.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names # major 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "B" in names # major 7th
|
|
|
|
|
|
# ── Fretboard ────────────────────────────────────────────────────────────────
|
|
|
|
def test_fretboard_creation():
|
|
standard_tuning = [
|
|
Tone(name="E", octave=4),
|
|
Tone(name="B", octave=3),
|
|
Tone(name="G", octave=3),
|
|
Tone(name="D", octave=3),
|
|
Tone(name="A", octave=2),
|
|
Tone(name="E", octave=2),
|
|
]
|
|
fretboard = Fretboard(tones=standard_tuning)
|
|
assert len(fretboard.tones) == 6
|
|
assert fretboard.tones[0].full_name == "E4"
|
|
assert fretboard.tones[-1].full_name == "E2"
|
|
|
|
|
|
def test_fretboard_repr():
|
|
fretboard = Fretboard(tones=[Tone(name="E", octave=4)])
|
|
assert "E4" in repr(fretboard)
|
|
|
|
|
|
# ── Chord fingerings ─────────────────────────────────────────────────────────
|
|
|
|
@pytest.fixture
|
|
def guitar_fretboard():
|
|
tuning = [
|
|
Tone.from_string("E4"),
|
|
Tone.from_string("B3"),
|
|
Tone.from_string("G3"),
|
|
Tone.from_string("D3"),
|
|
Tone.from_string("A2"),
|
|
Tone.from_string("E2"),
|
|
]
|
|
return Fretboard(tones=tuning)
|
|
|
|
|
|
def test_chord_fingering_c(guitar_fretboard):
|
|
c = CHARTS["western"]["C"]
|
|
fingering = c.fingering(fretboard=guitar_fretboard)
|
|
assert len(fingering) == 6
|
|
# All fret values should be small integers or None
|
|
for f in fingering:
|
|
assert f is None or (isinstance(f, int) and f >= 0)
|
|
|
|
|
|
def test_chord_fingering_am(guitar_fretboard):
|
|
am = CHARTS["western"]["Am"]
|
|
fingering = am.fingering(fretboard=guitar_fretboard)
|
|
assert len(fingering) == 6
|
|
|
|
|
|
def test_chord_fingering_em(guitar_fretboard):
|
|
em = CHARTS["western"]["Em"]
|
|
fingering = em.fingering(fretboard=guitar_fretboard)
|
|
assert len(fingering) == 6
|
|
# Em should be very open (lots of 0s)
|
|
zeros = sum(1 for f in fingering if f == 0)
|
|
assert zeros >= 3
|
|
|
|
|
|
@pytest.mark.slow
|
|
def test_chord_fingering_all_western_chords(guitar_fretboard):
|
|
"""Every chord in the western chart should produce a valid fingering."""
|
|
for name, chord in CHARTS["western"].items():
|
|
fingering = chord.fingering(fretboard=guitar_fretboard)
|
|
assert len(fingering) == 6, f"{name} produced wrong number of positions"
|
|
|
|
|
|
def test_chord_fingering_multiple(guitar_fretboard):
|
|
c = CHARTS["western"]["C"]
|
|
fingerings = c.fingering(fretboard=guitar_fretboard, multiple=True)
|
|
assert len(fingerings) >= 1
|
|
assert all(len(f) == 6 for f in fingerings)
|
|
|
|
|
|
# ── Charts ───────────────────────────────────────────────────────────────────
|
|
|
|
def test_charts_western_exists():
|
|
assert "western" in CHARTS
|
|
assert len(CHARTS["western"]) > 0
|
|
|
|
|
|
def test_charts_has_basic_chords():
|
|
chart = CHARTS["western"]
|
|
for name in ["C", "D", "E", "F", "G", "A", "B"]:
|
|
assert name in chart, f"Missing chord: {name}"
|
|
|
|
|
|
def test_charts_has_minor_chords():
|
|
chart = CHARTS["western"]
|
|
for name in ["Am", "Dm", "Em"]:
|
|
assert name in chart, f"Missing chord: {name}"
|
|
|
|
|
|
def test_charts_has_seventh_chords():
|
|
chart = CHARTS["western"]
|
|
for name in ["C7", "G7", "A7"]:
|
|
assert name in chart, f"Missing chord: {name}"
|
|
|
|
|
|
# ── System ───────────────────────────────────────────────────────────────────
|
|
|
|
def test_western_system_has_12_tones():
|
|
system = pytheory.SYSTEMS["western"]
|
|
assert system.semitones == 12
|
|
|
|
|
|
def test_western_system_tones():
|
|
system = pytheory.SYSTEMS["western"]
|
|
tone_names = [t.name for t in system.tones]
|
|
assert "A" in tone_names
|
|
assert "C" in tone_names
|
|
assert "G" in tone_names
|
|
|
|
|
|
def test_western_system_scales():
|
|
system = pytheory.SYSTEMS["western"]
|
|
scales = system.scales
|
|
assert "heptatonic" in scales
|
|
assert "major" in scales["heptatonic"]
|
|
assert "minor" in scales["heptatonic"]
|
|
|
|
|
|
def test_western_system_modes():
|
|
system = pytheory.SYSTEMS["western"]
|
|
modes = system.modes
|
|
mode_names = [m["mode"] for m in modes]
|
|
assert "ionian" in mode_names
|
|
assert "dorian" in mode_names
|
|
|
|
|
|
# ── Scale intervals (music theory verification) ─────────────────────────────
|
|
|
|
def test_major_scale_intervals():
|
|
"""Major scale should follow W-W-H-W-W-W-H pattern (2-2-1-2-2-2-1)."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
major = system.scales["heptatonic"]["major"]
|
|
assert major["intervals"] == [2, 2, 1, 2, 2, 2, 1]
|
|
|
|
|
|
def test_minor_scale_intervals():
|
|
"""Natural minor should follow W-H-W-W-H-W-W pattern."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
minor = system.scales["heptatonic"]["minor"]
|
|
assert minor["intervals"] == [2, 1, 2, 2, 1, 2, 2]
|
|
|
|
|
|
def test_harmonic_minor_scale_intervals():
|
|
"""Harmonic minor should follow W-H-W-W-H-WH-H pattern."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
hminor = system.scales["heptatonic"]["harmonic minor"]
|
|
assert hminor["intervals"] == [2, 1, 2, 2, 1, 3, 1]
|
|
|
|
|
|
def test_dorian_mode_intervals():
|
|
"""Dorian: W-H-W-W-W-H-W (rotation of major by 1)."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
dorian = system.scales["heptatonic"]["dorian"]
|
|
assert dorian["intervals"] == [2, 1, 2, 2, 2, 1, 2]
|
|
|
|
|
|
def test_lydian_mode_intervals():
|
|
"""Lydian: W-W-W-H-W-W-H (rotation of major by 3)."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
lydian = system.scales["heptatonic"]["lydian"]
|
|
assert lydian["intervals"] == [2, 2, 2, 1, 2, 2, 1]
|
|
|
|
|
|
def test_mixolydian_mode_intervals():
|
|
"""Mixolydian: W-W-H-W-W-H-W (rotation of major by 4)."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
mixolydian = system.scales["heptatonic"]["mixolydian"]
|
|
assert mixolydian["intervals"] == [2, 2, 1, 2, 2, 1, 2]
|
|
|
|
|
|
def test_all_mode_intervals_sum_to_12():
|
|
"""Every heptatonic mode's intervals should sum to 12 semitones."""
|
|
system = pytheory.SYSTEMS["western"]
|
|
for name, scale in system.scales["heptatonic"].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
# ── Play module (non-audio tests) ───────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_synth_enum():
|
|
from pytheory.play import Synth
|
|
# Synth members are callable and produce audio
|
|
assert Synth.SINE.value == "sine"
|
|
assert Synth.SAW.value == "saw"
|
|
assert Synth.TRIANGLE.value == "triangle"
|
|
# Should be directly callable
|
|
wave = Synth.SINE(440)
|
|
assert len(wave) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sine_wave_length():
|
|
from pytheory.play import sine_wave, SAMPLE_RATE
|
|
wave = sine_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sine_wave_custom_samples():
|
|
from pytheory.play import sine_wave
|
|
wave = sine_wave(440, n_samples=1000)
|
|
assert len(wave) == 1000
|
|
|
|
|
|
# ── Tone.from_tuple ─────────────────────────────────────────────────────────
|
|
|
|
def test_tone_from_tuple_single():
|
|
t = Tone.from_tuple(("A",))
|
|
assert t.name == "A"
|
|
assert t.alt_names == []
|
|
|
|
|
|
def test_tone_from_tuple_with_alt():
|
|
t = Tone.from_tuple(("C#", "Db"))
|
|
assert t.name == "C#"
|
|
assert t.alt_names == ("Db",)
|
|
|
|
|
|
def test_tone_from_tuple_with_octave():
|
|
t = Tone.from_tuple(("A4",))
|
|
assert t.name == "A"
|
|
assert t.octave == 4
|
|
|
|
|
|
# ── Tone.from_index ─────────────────────────────────────────────────────────
|
|
|
|
def test_tone_from_index():
|
|
system = SYSTEMS["western"]
|
|
t = Tone.from_index(3, octave=4, system=system) # C is index 3
|
|
assert t.name == "C"
|
|
assert t.octave == 4
|
|
|
|
|
|
def test_tone_from_index_zero():
|
|
system = SYSTEMS["western"]
|
|
t = Tone.from_index(0, octave=4, system=system) # A is index 0
|
|
assert t.name == "A"
|
|
assert t.octave == 4
|
|
|
|
|
|
# ── Tone._index ─────────────────────────────────────────────────────────────
|
|
|
|
def test_tone_index_in_system():
|
|
t = Tone.from_string("A4", system="western")
|
|
assert t._index == 0
|
|
|
|
|
|
def test_tone_index_c():
|
|
t = Tone.from_string("C4", system="western")
|
|
assert t._index == 3
|
|
|
|
|
|
def test_tone_index_without_system_raises():
|
|
t = Tone(name="C", octave=4)
|
|
t._system = None
|
|
t.system_name = None
|
|
with pytest.raises(ValueError, match="index"):
|
|
_ = t._index
|
|
|
|
|
|
# ── Tone._math errors ───────────────────────────────────────────────────────
|
|
|
|
def test_tone_math_without_system_raises():
|
|
t = Tone(name="C", octave=4)
|
|
t._system = None
|
|
t.system_name = None
|
|
with pytest.raises(ValueError):
|
|
t._math(1)
|
|
|
|
|
|
# ── Tone equality edge cases ────────────────────────────────────────────────
|
|
|
|
def test_tone_eq_non_tone_non_string():
|
|
t = Tone(name="C", octave=4)
|
|
assert not (t == 42)
|
|
assert not (t == None)
|
|
assert not (t == [])
|
|
|
|
|
|
def test_tone_eq_different_name():
|
|
a = Tone(name="C", octave=4)
|
|
b = Tone(name="D", octave=4)
|
|
assert not (a == b)
|
|
|
|
|
|
def test_tone_eq_no_octave():
|
|
a = Tone(name="C")
|
|
b = Tone(name="C")
|
|
assert a == b
|
|
|
|
|
|
# ── Tone arithmetic — multi-octave ──────────────────────────────────────────
|
|
|
|
def test_tone_add_two_octaves():
|
|
t = Tone.from_string("C4", system="western")
|
|
result = t.add(24)
|
|
assert result.name == "C"
|
|
assert result.octave == 6
|
|
|
|
|
|
def test_tone_subtract_two_octaves():
|
|
t = Tone.from_string("C6", system="western")
|
|
result = t.subtract(24)
|
|
assert result.name == "C"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_tone_add_tritone():
|
|
"""C + 6 semitones = F#."""
|
|
t = Tone.from_string("C4", system="western")
|
|
result = t.add(6)
|
|
assert result.name == "F#"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_tone_subtract_to_lower_octave():
|
|
"""E2 - 5 = B1."""
|
|
t = Tone.from_string("E2", system="western")
|
|
result = t.subtract(5)
|
|
assert result.name == "B"
|
|
assert result.octave == 1
|
|
|
|
|
|
def test_tone_chromatic_walk_descending():
|
|
"""Walk down from C5 to C4."""
|
|
t = Tone.from_string("C5", system="western")
|
|
expected = [
|
|
("C", 5), ("B", 4), ("A#", 4), ("A", 4),
|
|
("G#", 4), ("G", 4), ("F#", 4), ("F", 4),
|
|
("E", 4), ("D#", 4), ("D", 4), ("C#", 4), ("C", 4),
|
|
]
|
|
for i, (name, octave) in enumerate(expected):
|
|
result = t.subtract(i)
|
|
assert result.name == name, f"step -{i}: expected {name}, got {result.name}"
|
|
assert result.octave == octave, f"step -{i}: expected octave {octave}, got {result.octave}"
|
|
|
|
|
|
def test_tone_add_zero():
|
|
t = Tone.from_string("C4", system="western")
|
|
result = t.add(0)
|
|
assert result.name == "C"
|
|
assert result.octave == 4
|
|
|
|
|
|
# ── Pitch — more frequencies ────────────────────────────────────────────────
|
|
|
|
def test_pitch_b4():
|
|
t = Tone.from_string("B4", system="western")
|
|
assert abs(t.pitch() - 493.88) < 0.01
|
|
|
|
|
|
def test_pitch_d4():
|
|
t = Tone.from_string("D4", system="western")
|
|
assert abs(t.pitch() - 293.66) < 0.01
|
|
|
|
|
|
def test_pitch_g3():
|
|
t = Tone.from_string("G3", system="western")
|
|
assert abs(t.pitch() - 196.00) < 0.01
|
|
|
|
|
|
def test_pitch_a2():
|
|
t = Tone.from_string("A2", system="western")
|
|
assert abs(t.pitch() - 110.0) < 0.01
|
|
|
|
|
|
def test_pitch_a5():
|
|
t = Tone.from_string("A5", system="western")
|
|
assert abs(t.pitch() - 880.0) < 0.01
|
|
|
|
|
|
def test_pitch_e2_low():
|
|
"""Low E on guitar."""
|
|
t = Tone.from_string("E2", system="western")
|
|
assert abs(t.pitch() - 82.41) < 0.01
|
|
|
|
|
|
def test_pitch_precision():
|
|
t = Tone.from_string("A4", system="western")
|
|
p = t.pitch(precision=10)
|
|
assert abs(p - 440.0) < 0.01
|
|
|
|
|
|
def test_pitch_without_system_raises():
|
|
t = Tone(name="C", octave=4)
|
|
t._system = None
|
|
t.system_name = None
|
|
with pytest.raises(ValueError, match="Pitches"):
|
|
t.pitch()
|
|
|
|
|
|
def test_pitch_pythagorean_temperament():
|
|
"""Pythagorean A4 should still be 440 (it's the reference)."""
|
|
t = Tone.from_string("A4", system="western")
|
|
assert abs(t.pitch(temperament="pythagorean") - 440.0) < 0.01
|
|
|
|
|
|
def test_pitch_all_chromatic_ascending():
|
|
"""Verify all 12 chromatic pitches from A4 are strictly ascending."""
|
|
pitches = []
|
|
for i in range(12):
|
|
t = Tone.from_string("A4", system="western").add(i)
|
|
pitches.append(t.pitch())
|
|
for i in range(1, len(pitches)):
|
|
assert pitches[i] > pitches[i - 1], f"Pitch at step {i} not ascending"
|
|
|
|
|
|
def test_pitch_consistency_across_octaves():
|
|
"""Every note an octave up should be exactly 2x the frequency."""
|
|
for note in ["C", "D", "E", "F", "G", "A", "B"]:
|
|
t3 = Tone.from_string(f"{note}3", system="western")
|
|
t4 = Tone.from_string(f"{note}4", system="western")
|
|
ratio = t4.pitch() / t3.pitch()
|
|
assert abs(ratio - 2.0) < 0.001, f"{note}4/{note}3 ratio = {ratio}"
|
|
|
|
|
|
# ── Scale — repr and degree access ──────────────────────────────────────────
|
|
|
|
def test_scale_repr():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
r = repr(major)
|
|
assert "Scale" in r
|
|
assert "I=C4" in r
|
|
assert "V=G4" in r
|
|
|
|
|
|
def test_scale_degree_by_name_tonic():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
tone = major.degree("tonic")
|
|
assert tone.name == "C"
|
|
|
|
|
|
def test_scale_degree_by_name_dominant():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
tone = major.degree("dominant")
|
|
assert tone.name == "G"
|
|
|
|
|
|
def test_scale_degree_major_minor_both_raises():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
with pytest.raises(ValueError):
|
|
major.degree("tonic", major=True, minor=True)
|
|
|
|
|
|
def test_scale_degree_all_roman_numerals():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
expected = ["C", "D", "E", "F", "G", "A", "B"]
|
|
numerals = ["I", "II", "III", "IV", "V", "VI", "VII"]
|
|
for numeral, name in zip(numerals, expected):
|
|
assert major[numeral].name == name, f"Degree {numeral} expected {name}"
|
|
|
|
|
|
def test_scale_slice_access():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
first_three = major[0:3]
|
|
assert len(first_three) == 3
|
|
assert first_three[0].name == "C"
|
|
assert first_three[2].name == "E"
|
|
|
|
|
|
def test_scale_degrees_length_mismatch_raises():
|
|
from pytheory.scales import Scale
|
|
with pytest.raises(ValueError, match="number of tones and degrees"):
|
|
Scale(tones=(Tone(name="C"), Tone(name="D")), degrees=("I",))
|
|
|
|
|
|
# ── TonedScale ──────────────────────────────────────────────────────────────
|
|
|
|
def test_toned_scale_repr():
|
|
c = TonedScale(tonic="C4")
|
|
r = repr(c)
|
|
assert "TonedScale" in r
|
|
assert "C4" in r
|
|
|
|
|
|
def test_toned_scale_get_none():
|
|
c = TonedScale(tonic="C4")
|
|
assert c.get("nonexistent") is None
|
|
|
|
|
|
def test_toned_scale_with_tone_object():
|
|
tone = Tone.from_string("D4", system="western")
|
|
d = TonedScale(tonic=tone)
|
|
major = d["major"]
|
|
assert major.tones[0].name == "D"
|
|
|
|
|
|
def test_d_major_scale():
|
|
d = TonedScale(tonic="D4")
|
|
major = d["major"]
|
|
names = [t.name for t in major.tones]
|
|
assert names == ["D", "E", "F#", "G", "A", "B", "C#", "D"]
|
|
|
|
|
|
def test_f_major_scale():
|
|
f = TonedScale(tonic="F4")
|
|
major = f["major"]
|
|
names = [t.name for t in major.tones]
|
|
assert names == ["F", "G", "A", "Bb", "C", "D", "E", "F"]
|
|
|
|
|
|
def test_a_minor_scale():
|
|
a = TonedScale(tonic="A4")
|
|
minor = a["minor"]
|
|
names = [t.name for t in minor.tones]
|
|
# A B C D E F G A
|
|
assert names == ["A", "B", "C", "D", "E", "F", "G", "A"]
|
|
|
|
|
|
def test_e_minor_scale():
|
|
e = TonedScale(tonic="E4")
|
|
minor = e["minor"]
|
|
names = [t.name for t in minor.tones]
|
|
# E F# G A B C D E
|
|
assert names == ["E", "F#", "G", "A", "B", "C", "D", "E"]
|
|
|
|
|
|
def test_b_major_scale():
|
|
b = TonedScale(tonic="B4")
|
|
major = b["major"]
|
|
names = [t.name for t in major.tones]
|
|
assert names == ["B", "C#", "D#", "E", "F#", "G#", "A#", "B"]
|
|
|
|
|
|
def test_d_dorian():
|
|
d = TonedScale(tonic="D4")
|
|
dorian = d["dorian"]
|
|
names = [t.name for t in dorian.tones]
|
|
# D Dorian: D E F G A B C D (same notes as C major)
|
|
assert names == ["D", "E", "F", "G", "A", "B", "C", "D"]
|
|
|
|
|
|
def test_g_mixolydian():
|
|
g = TonedScale(tonic="G4")
|
|
mixo = g["mixolydian"]
|
|
names = [t.name for t in mixo.tones]
|
|
# G Mixolydian: G A B C D E F G (same notes as C major)
|
|
assert names == ["G", "A", "B", "C", "D", "E", "F", "G"]
|
|
|
|
|
|
def test_scale_octaves_across_boundary():
|
|
"""A4 major scale should cross into octave 5 at the right point."""
|
|
a = TonedScale(tonic="A4")
|
|
major = a["major"]
|
|
full = [t.full_name for t in major.tones]
|
|
assert full == ["A4", "B4", "C#5", "D5", "E5", "F#5", "G#5", "A5"]
|
|
|
|
|
|
# ── Mode interval tests (remaining modes) ───────────────────────────────────
|
|
|
|
def test_phrygian_mode_intervals():
|
|
system = SYSTEMS["western"]
|
|
phrygian = system.scales["heptatonic"]["phrygian"]
|
|
assert phrygian["intervals"] == [1, 2, 2, 2, 1, 2, 2]
|
|
|
|
|
|
def test_aeolian_mode_intervals():
|
|
"""Aeolian should have same intervals as natural minor."""
|
|
system = SYSTEMS["western"]
|
|
aeolian = system.scales["heptatonic"]["aeolian"]
|
|
minor = system.scales["heptatonic"]["minor"]
|
|
assert aeolian["intervals"] == minor["intervals"]
|
|
|
|
|
|
def test_locrian_mode_intervals():
|
|
system = SYSTEMS["western"]
|
|
locrian = system.scales["heptatonic"]["locrian"]
|
|
assert locrian["intervals"] == [1, 2, 2, 1, 2, 2, 2]
|
|
|
|
|
|
def test_ionian_mode_intervals():
|
|
"""Ionian should have same intervals as major."""
|
|
system = SYSTEMS["western"]
|
|
ionian = system.scales["heptatonic"]["ionian"]
|
|
major = system.scales["heptatonic"]["major"]
|
|
assert ionian["intervals"] == major["intervals"]
|
|
|
|
|
|
# ── Chord intervals and properties ──────────────────────────────────────────
|
|
|
|
def test_chord_intervals_c_major():
|
|
"""C4-E4-G4 intervals should be 4 and 3 semitones (major 3rd + minor 3rd)."""
|
|
c_major = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert c_major.intervals == [4, 3]
|
|
|
|
|
|
def test_chord_intervals_octave():
|
|
c_oct = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
])
|
|
assert c_oct.intervals == [12]
|
|
|
|
|
|
def test_chord_intervals_minor_triad():
|
|
a_minor = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
Tone.from_string("E5", system="western"),
|
|
])
|
|
assert a_minor.intervals == [3, 4] # minor 3rd + major 3rd
|
|
|
|
|
|
def test_chord_beat_pulse_unison():
|
|
"""Two identical tones should have beat pulse of 0."""
|
|
chord = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("A4", system="western"),
|
|
])
|
|
assert chord.beat_pulse == 0
|
|
|
|
|
|
def test_chord_beat_pulse_octave():
|
|
"""Two tones an octave apart should have beat pulse = 440 Hz."""
|
|
chord = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("A5", system="western"),
|
|
])
|
|
assert abs(chord.beat_pulse - 440.0) < 0.01
|
|
|
|
|
|
def test_chord_beat_frequencies():
|
|
"""beat_frequencies returns sorted (tone, tone, hz) tuples."""
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
beats = chord.beat_frequencies
|
|
assert len(beats) == 3 # 3 pairs from 3 tones
|
|
# Should be sorted ascending by Hz
|
|
assert beats[0][2] <= beats[1][2] <= beats[2][2]
|
|
|
|
|
|
def test_chord_empty():
|
|
chord = Chord(tones=[])
|
|
assert chord.harmony == 0
|
|
assert chord.dissonance == 0
|
|
assert chord.beat_pulse == 0
|
|
assert chord.intervals == []
|
|
assert chord.beat_frequencies == []
|
|
|
|
|
|
def test_chord_harmony_fifth_beats_tritone():
|
|
"""A perfect fifth (3:2) should score higher harmony than a tritone."""
|
|
fifth = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
tritone = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("F#4", system="western"),
|
|
])
|
|
assert fifth.harmony > tritone.harmony
|
|
|
|
|
|
def test_chord_harmony_octave_highest():
|
|
"""An octave (2:1) should score highest harmony."""
|
|
octave = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
])
|
|
fifth = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert octave.harmony > fifth.harmony
|
|
|
|
|
|
def test_chord_dissonance_tritone_vs_fifth():
|
|
"""A tritone should produce more roughness than a perfect fifth."""
|
|
tritone = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("F#4", system="western"),
|
|
])
|
|
fifth = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert tritone.dissonance > fifth.dissonance
|
|
|
|
|
|
def test_chord_dissonance_wide_interval_low():
|
|
"""Very wide intervals (octave+) should have low roughness."""
|
|
octave = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
])
|
|
third = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
])
|
|
# Octave exceeds critical bandwidth → less roughness than a 3rd
|
|
assert octave.dissonance < third.dissonance
|
|
|
|
|
|
def test_chord_dissonance_positive():
|
|
"""Any two distinct tones should produce non-zero roughness."""
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert chord.dissonance > 0
|
|
|
|
|
|
def test_chord_fingering_wrong_positions_raises():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
])
|
|
with pytest.raises(ValueError, match="positions"):
|
|
chord.fingering(1, 2, 3) # 3 positions for 2 tones
|
|
|
|
|
|
# ── Fretboard fingering ─────────────────────────────────────────────────────
|
|
|
|
def test_fretboard_fingering():
|
|
tuning = [
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("B3", system="western"),
|
|
]
|
|
fb = Fretboard(tones=tuning)
|
|
chord = fb.fingering(0, 0) # Open strings
|
|
assert chord.tones[0].name == "E"
|
|
assert chord.tones[1].name == "B"
|
|
|
|
|
|
def test_fretboard_fingering_fretted():
|
|
tuning = [
|
|
Tone.from_string("E4", system="western"),
|
|
]
|
|
fb = Fretboard(tones=tuning)
|
|
chord = fb.fingering(1) # 1st fret on E string = F
|
|
assert chord.tones[0].name == "F"
|
|
|
|
|
|
def test_fretboard_fingering_wrong_count_raises():
|
|
fb = Fretboard(tones=[Tone.from_string("E4", system="western")])
|
|
with pytest.raises(ValueError, match="positions"):
|
|
fb.fingering(1, 2) # 2 positions for 1 string
|
|
|
|
|
|
# ── Named chord — all qualities ─────────────────────────────────────────────
|
|
|
|
def test_named_chord_repr():
|
|
c = NamedChord(tone_name="C", quality="m7")
|
|
assert repr(c) == "<NamedChord name='Cm7'>"
|
|
|
|
|
|
def test_named_chord_name_property():
|
|
c = NamedChord(tone_name="A", quality="maj7")
|
|
assert c.name == "Amaj7"
|
|
|
|
|
|
def test_named_chord_flat_to_sharp_conversion():
|
|
"""Flat tone names should be converted to sharp equivalents internally."""
|
|
bb = NamedChord(tone_name="Bb", quality="")
|
|
assert bb.tone.name == "A#"
|
|
|
|
ab = NamedChord(tone_name="Ab", quality="")
|
|
assert ab.tone.name == "G#"
|
|
|
|
db = NamedChord(tone_name="Db", quality="")
|
|
assert db.tone.name == "C#"
|
|
|
|
eb = NamedChord(tone_name="Eb", quality="")
|
|
assert eb.tone.name == "D#"
|
|
|
|
gb = NamedChord(tone_name="Gb", quality="")
|
|
assert gb.tone.name == "F#"
|
|
|
|
|
|
def test_named_chord_m6_tones():
|
|
cm6 = NamedChord(tone_name="C", quality="m6")
|
|
names = cm6.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "Eb" in names # minor 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "A" in names # major 6th
|
|
assert len(names) == 4
|
|
|
|
|
|
def test_named_chord_m9_tones():
|
|
cm9 = NamedChord(tone_name="C", quality="m9")
|
|
names = cm9.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "Eb" in names # minor 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "Bb" in names # minor 7th
|
|
assert "D" in names # major 9th
|
|
assert len(names) == 5
|
|
|
|
|
|
def test_named_chord_maj9_tones():
|
|
cmaj9 = NamedChord(tone_name="C", quality="maj9")
|
|
names = cmaj9.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names # major 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "B" in names # major 7th
|
|
assert "D" in names # major 9th
|
|
assert len(names) == 5
|
|
|
|
|
|
def test_named_chord_9_tones():
|
|
c9 = NamedChord(tone_name="C", quality="9")
|
|
names = c9.acceptable_tone_names
|
|
assert "C" in names
|
|
assert "E" in names # major 3rd
|
|
assert "G" in names # perfect 5th
|
|
assert "Bb" in names # minor 7th
|
|
assert "D" in names # major 9th
|
|
assert len(names) == 5
|
|
|
|
|
|
def test_named_chord_fix_fingering():
|
|
assert NamedChord.fix_fingering((0, 1, -1, 3)) == (0, 1, None, 3)
|
|
assert NamedChord.fix_fingering((0, 0, 0)) == (0, 0, 0)
|
|
assert NamedChord.fix_fingering((-1, -1)) == (None, None)
|
|
|
|
|
|
def test_named_chord_fingerings_returns_multiple(guitar_fretboard):
|
|
c = CHARTS["western"]["C"]
|
|
all_fingerings = c.fingerings(fretboard=guitar_fretboard)
|
|
assert len(all_fingerings) > 1
|
|
assert all(len(f) == 6 for f in all_fingerings)
|
|
|
|
|
|
def test_named_chord_possible_fingerings(guitar_fretboard):
|
|
c = CHARTS["western"]["C"]
|
|
possible = c._possible_fingerings(fretboard=guitar_fretboard)
|
|
assert len(possible) == 6 # One tuple per string
|
|
assert all(isinstance(p, tuple) for p in possible)
|
|
|
|
|
|
# ── Charts — comprehensive ──────────────────────────────────────────────────
|
|
|
|
def test_charts_total_chord_count():
|
|
"""Should have 12 tones * 12 qualities = 144 chords."""
|
|
assert len(CHARTS["western"]) == 12 * len(QUALITIES)
|
|
|
|
|
|
def test_charts_all_qualities_present():
|
|
chart = CHARTS["western"]
|
|
for quality in QUALITIES:
|
|
matching = [name for name in chart if name.endswith(quality) or (quality == "" and len(name) <= 2)]
|
|
assert len(matching) > 0, f"No chords with quality '{quality}'"
|
|
|
|
|
|
@pytest.mark.slow
|
|
def test_charts_for_fretboard(guitar_fretboard):
|
|
result = charts_for_fretboard(fretboard=guitar_fretboard)
|
|
assert len(result) == len(CHARTS["western"])
|
|
for name, fingering in result.items():
|
|
assert len(fingering) == 6, f"{name} has wrong fingering length"
|
|
|
|
|
|
@pytest.mark.slow
|
|
def test_charts_fingering_values_in_range(guitar_fretboard):
|
|
"""All fret values should be 0-6 or None (muted)."""
|
|
for name, chord in CHARTS["western"].items():
|
|
fingering = chord.fingering(fretboard=guitar_fretboard)
|
|
for i, f in enumerate(fingering):
|
|
assert f is None or (0 <= f < 7), \
|
|
f"{name} string {i}: fret {f} out of range"
|
|
|
|
|
|
# ── System ──────────────────────────────────────────────────────────────────
|
|
|
|
def test_system_repr():
|
|
system = SYSTEMS["western"]
|
|
assert repr(system) == "<System semitones=12>"
|
|
|
|
|
|
def test_system_semitones():
|
|
system = SYSTEMS["western"]
|
|
assert system.semitones == 12
|
|
|
|
|
|
def test_system_tones_are_tone_objects():
|
|
system = SYSTEMS["western"]
|
|
for tone in system.tones:
|
|
assert isinstance(tone, Tone)
|
|
|
|
|
|
def test_system_tones_have_alt_names():
|
|
"""Tones with enharmonic equivalents should have alt names."""
|
|
system = SYSTEMS["western"]
|
|
cs = [t for t in system.tones if t.name == "C#"]
|
|
assert len(cs) == 1
|
|
assert "Db" in cs[0].alt_names
|
|
|
|
|
|
def test_system_chromatic_scale():
|
|
system = SYSTEMS["western"]
|
|
chromatic = system.scales["chromatic"]["chromatic"]
|
|
assert chromatic["intervals"] == [1] * 12
|
|
|
|
|
|
def test_system_generate_scale_major_minor_raises():
|
|
with pytest.raises(ValueError, match="both major and minor"):
|
|
System.generate_scale(major=True, minor=True)
|
|
|
|
|
|
def test_system_modes_list():
|
|
system = SYSTEMS["western"]
|
|
modes = system.modes
|
|
assert len(modes) > 0
|
|
for mode in modes:
|
|
assert "degree" in mode
|
|
assert "mode" in mode
|
|
assert isinstance(mode["degree"], int)
|
|
|
|
|
|
# ── Wave generation ─────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_sawtooth_wave_length():
|
|
from pytheory.play import sawtooth_wave, SAMPLE_RATE
|
|
wave = sawtooth_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sawtooth_wave_custom_samples():
|
|
from pytheory.play import sawtooth_wave
|
|
wave = sawtooth_wave(440, n_samples=2000)
|
|
assert len(wave) == 2000
|
|
|
|
|
|
@needs_portaudio
|
|
def test_triangle_wave_length():
|
|
from pytheory.play import triangle_wave, SAMPLE_RATE
|
|
wave = triangle_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
|
|
|
|
@needs_portaudio
|
|
def test_triangle_wave_custom_samples():
|
|
from pytheory.play import triangle_wave
|
|
wave = triangle_wave(440, n_samples=2000)
|
|
assert len(wave) == 2000
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sine_wave_output_type():
|
|
from pytheory.play import sine_wave
|
|
wave = sine_wave(440)
|
|
assert wave.dtype == numpy.int16
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sawtooth_wave_output_type():
|
|
from pytheory.play import sawtooth_wave
|
|
wave = sawtooth_wave(440)
|
|
assert wave.dtype == numpy.int16
|
|
|
|
|
|
@needs_portaudio
|
|
def test_triangle_wave_output_type():
|
|
from pytheory.play import triangle_wave
|
|
wave = triangle_wave(440)
|
|
assert wave.dtype == numpy.int16
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sine_wave_different_frequencies():
|
|
from pytheory.play import sine_wave
|
|
wave_low = sine_wave(220)
|
|
wave_high = sine_wave(880)
|
|
# Both should be valid arrays of the same length
|
|
assert len(wave_low) == len(wave_high)
|
|
# But they should have different content
|
|
assert not numpy.array_equal(wave_low, wave_high)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_synth_callable_with_pitch():
|
|
"""Synth enum members should work with actual pitch values from Tone."""
|
|
from pytheory.play import Synth
|
|
t = Tone.from_string("A4", system="western")
|
|
hz = t.pitch()
|
|
wave = Synth.SINE(hz)
|
|
assert len(wave) > 0
|
|
|
|
|
|
# ── Integration: scale → chord → fingering ──────────────────────────────────
|
|
|
|
def test_build_chord_from_scale(guitar_fretboard):
|
|
"""Build a I-IV-V progression from C major and verify fingerings."""
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
|
|
tonic = major["I"].name # C
|
|
subdominant = major["IV"].name # F
|
|
dominant = major["V"].name # G
|
|
|
|
chart = CHARTS["western"]
|
|
for name in [tonic, subdominant, dominant]:
|
|
fingering = chart[name].fingering(fretboard=guitar_fretboard)
|
|
assert len(fingering) == 6
|
|
|
|
|
|
def test_circle_of_fifths():
|
|
"""Walk the circle of fifths starting from C."""
|
|
t = Tone.from_string("C4", system="western")
|
|
expected = ["C", "G", "D", "A", "E", "B", "F#", "C#", "G#", "D#", "A#", "F"]
|
|
for i, name in enumerate(expected):
|
|
assert t.name == name, f"Step {i}: expected {name}, got {t.name}"
|
|
t = t.add(7) # perfect fifth = 7 semitones
|
|
|
|
|
|
def test_circle_of_fourths():
|
|
"""Walk the circle of fourths starting from C."""
|
|
t = Tone.from_string("C4", system="western")
|
|
expected = ["C", "F", "A#", "D#", "G#", "C#", "F#", "B", "E", "A", "D", "G"]
|
|
for i, name in enumerate(expected):
|
|
assert t.name == name, f"Step {i}: expected {name}, got {t.name}"
|
|
t = t.add(5) # perfect fourth = 5 semitones
|
|
|
|
|
|
def test_enharmonic_equivalence_in_scales():
|
|
"""D Dorian and C major should contain the same pitch classes."""
|
|
c_major = TonedScale(tonic="C4")["major"]
|
|
d_dorian = TonedScale(tonic="D4")["dorian"]
|
|
|
|
c_names = sorted(set(t.name for t in c_major.tones))
|
|
d_names = sorted(set(t.name for t in d_dorian.tones))
|
|
assert c_names == d_names
|
|
|
|
|
|
def test_relative_minor():
|
|
"""A minor (relative minor of C major) should share the same notes."""
|
|
c_major = TonedScale(tonic="C4")["major"]
|
|
a_minor = TonedScale(tonic="A4")["minor"]
|
|
|
|
c_names = sorted(set(t.name for t in c_major.tones))
|
|
a_names = sorted(set(t.name for t in a_minor.tones))
|
|
assert c_names == a_names
|
|
|
|
|
|
# ── Tone operators ──────────────────────────────────────────────────────────
|
|
|
|
def test_tone_add_operator():
|
|
t = Tone.from_string("C4", system="western")
|
|
result = t + 7
|
|
assert result.name == "G"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_tone_sub_int_operator():
|
|
t = Tone.from_string("G4", system="western")
|
|
result = t - 7
|
|
assert result.name == "C"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_tone_sub_tone_operator():
|
|
"""Subtracting two tones gives semitone distance."""
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert g4 - c4 == 7
|
|
|
|
|
|
def test_tone_sub_tone_negative():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert c4 - g4 == -7
|
|
|
|
|
|
def test_tone_sub_tone_octave():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
c5 = Tone.from_string("C5", system="western")
|
|
assert c5 - c4 == 12
|
|
|
|
|
|
def test_tone_lt():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert c4 < g4
|
|
assert not g4 < c4
|
|
|
|
|
|
def test_tone_gt():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert g4 > c4
|
|
assert not c4 > g4
|
|
|
|
|
|
def test_tone_le():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
c4b = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert c4 <= g4
|
|
assert c4 <= c4b
|
|
|
|
|
|
def test_tone_ge():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
c4b = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert g4 >= c4
|
|
assert c4 >= c4b
|
|
|
|
|
|
def test_tone_sorting():
|
|
"""Tones should be sortable by pitch."""
|
|
tones = [
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("A3", system="western"),
|
|
]
|
|
sorted_tones = sorted(tones)
|
|
names = [t.name for t in sorted_tones]
|
|
assert names == ["A", "C", "E", "G"]
|
|
|
|
|
|
def test_tone_str():
|
|
c4 = Tone(name="C", octave=4)
|
|
assert str(c4) == "C4"
|
|
d = Tone(name="D")
|
|
assert str(d) == "D"
|
|
|
|
|
|
def test_tone_frequency_property():
|
|
t = Tone.from_string("A4", system="western")
|
|
assert abs(t.frequency - 440.0) < 0.01
|
|
|
|
|
|
def test_tone_frequency_c4():
|
|
t = Tone.from_string("C4", system="western")
|
|
assert abs(t.frequency - 261.63) < 0.01
|
|
|
|
|
|
def test_tone_chaining():
|
|
"""Operators should be chainable."""
|
|
t = Tone.from_string("C4", system="western")
|
|
result = t + 4 + 3 # C -> E -> G
|
|
assert result.name == "G"
|
|
assert result.octave == 4
|
|
|
|
|
|
# ── Scale iteration ─────────────────────────────────────────────────────────
|
|
|
|
def test_scale_iter():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
names = [t.name for t in major]
|
|
assert names == ["C", "D", "E", "F", "G", "A", "B", "C"]
|
|
|
|
|
|
def test_scale_len():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
assert len(major) == 8 # 7 notes + octave
|
|
|
|
|
|
def test_scale_contains_name():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
assert "C" in major
|
|
assert "E" in major
|
|
assert "C#" not in major
|
|
|
|
|
|
def test_scale_contains_tone():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
c4 = Tone(name="C", octave=4)
|
|
assert c4 in major
|
|
|
|
|
|
def test_scale_note_names():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
assert major.note_names == ["C", "D", "E", "F", "G", "A", "B", "C"]
|
|
|
|
|
|
# ── Scale.chord() and Scale.triad() ─────────────────────────────────────────
|
|
|
|
def test_scale_chord():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
chord = major.chord(0, 2, 4) # C E G
|
|
assert len(chord) == 3
|
|
assert chord.tones[0].name == "C"
|
|
assert chord.tones[1].name == "E"
|
|
assert chord.tones[2].name == "G"
|
|
|
|
|
|
def test_scale_triad_root():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
triad = major.triad(0) # I chord = C E G
|
|
assert len(triad) == 3
|
|
names = [t.name for t in triad]
|
|
assert names == ["C", "E", "G"]
|
|
|
|
|
|
def test_scale_triad_iv():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
triad = major.triad(3) # IV chord = F A C
|
|
names = [t.name for t in triad]
|
|
assert names == ["F", "A", "C"]
|
|
|
|
|
|
def test_scale_triad_v():
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
triad = major.triad(4) # V chord = G B D
|
|
names = [t.name for t in triad]
|
|
assert names == ["G", "B", "D"]
|
|
|
|
|
|
def test_scale_triad_ii_minor():
|
|
"""ii chord in C major should be D F A (minor triad)."""
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
triad = major.triad(1)
|
|
names = [t.name for t in triad]
|
|
assert names == ["D", "F", "A"]
|
|
|
|
|
|
def test_scale_chord_seventh():
|
|
"""Build a 7th chord from scale degrees."""
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
seventh = major.chord(0, 2, 4, 6) # C E G B = Cmaj7
|
|
assert len(seventh) == 4
|
|
names = [t.name for t in seventh]
|
|
assert names == ["C", "E", "G", "B"]
|
|
|
|
|
|
# ── Chord iteration ─────────────────────────────────────────────────────────
|
|
|
|
def test_chord_iter():
|
|
chord = Chord(tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
Tone(name="G", octave=4),
|
|
])
|
|
names = [t.name for t in chord]
|
|
assert names == ["C", "E", "G"]
|
|
|
|
|
|
def test_chord_len():
|
|
chord = Chord(tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
])
|
|
assert len(chord) == 2
|
|
|
|
|
|
def test_chord_contains_name():
|
|
chord = Chord(tones=[
|
|
Tone(name="C", octave=4),
|
|
Tone(name="E", octave=4),
|
|
Tone(name="G", octave=4),
|
|
])
|
|
assert "C" in chord
|
|
assert "E" in chord
|
|
assert "D" not in chord
|
|
|
|
|
|
def test_chord_contains_tone():
|
|
c4 = Tone(name="C", octave=4)
|
|
chord = Chord(tones=[c4, Tone(name="E", octave=4)])
|
|
assert c4 in chord
|
|
|
|
|
|
# ── Fretboard presets ───────────────────────────────────────────────────────
|
|
|
|
def test_fretboard_guitar():
|
|
fb = Fretboard.guitar()
|
|
assert len(fb) == 6
|
|
names = [t.name for t in fb]
|
|
assert names == ["E", "B", "G", "D", "A", "E"]
|
|
|
|
|
|
def test_fretboard_guitar_octaves():
|
|
fb = Fretboard.guitar()
|
|
octaves = [t.octave for t in fb]
|
|
assert octaves == [4, 3, 3, 3, 2, 2]
|
|
|
|
|
|
def test_fretboard_bass():
|
|
fb = Fretboard.bass()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["G", "D", "A", "E"]
|
|
|
|
|
|
def test_fretboard_ukulele():
|
|
fb = Fretboard.ukulele()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["A", "E", "C", "G"]
|
|
|
|
|
|
def test_fretboard_iter():
|
|
fb = Fretboard.guitar()
|
|
tones = list(fb)
|
|
assert len(tones) == 6
|
|
assert all(isinstance(t, Tone) for t in tones)
|
|
|
|
|
|
def test_fretboard_len():
|
|
fb = Fretboard.guitar()
|
|
assert len(fb) == 6
|
|
|
|
|
|
def test_fretboard_preset_fingerings():
|
|
"""Preset fretboards should work with chord charts."""
|
|
fb = Fretboard.guitar()
|
|
c = CHARTS["western"]["C"]
|
|
fingering = c.fingering(fretboard=fb)
|
|
assert len(fingering) == 6
|
|
|
|
|
|
def test_fretboard_ukulele_fingerings():
|
|
fb = Fretboard.ukulele()
|
|
c = CHARTS["western"]["C"]
|
|
fingering = c.fingering(fretboard=fb)
|
|
assert len(fingering) == 4
|
|
|
|
|
|
def test_fretboard_guitar_drop_d():
|
|
fb = Fretboard.guitar("drop d")
|
|
assert len(fb) == 6
|
|
assert fb.tones[-1].name == "D"
|
|
assert fb.tones[-1].octave == 2
|
|
|
|
|
|
def test_fretboard_guitar_open_g():
|
|
fb = Fretboard.guitar("open g")
|
|
assert len(fb) == 6
|
|
assert fb.tones[0].name == "D"
|
|
|
|
|
|
def test_fretboard_guitar_custom_tuple():
|
|
fb = Fretboard.guitar(("E4", "B3", "G3", "D3", "A2", "D2"))
|
|
assert len(fb) == 6
|
|
assert fb.tones[-1].name == "D"
|
|
|
|
|
|
def test_fretboard_bass_five_string():
|
|
fb = Fretboard.bass(five_string=True)
|
|
assert len(fb) == 5
|
|
assert fb.tones[-1].name == "B"
|
|
|
|
|
|
def test_fretboard_tunings_dict():
|
|
for name in Fretboard.TUNINGS:
|
|
fb = Fretboard.guitar(name)
|
|
assert len(fb) == 6, f"Tuning {name} should have 6 strings"
|
|
|
|
|
|
def test_fretboard_mandolin():
|
|
fb = Fretboard.mandolin()
|
|
assert len(fb) == 4
|
|
assert fb.tones[0].name == "E"
|
|
assert fb.tones[-1].name == "G"
|
|
|
|
|
|
def test_fretboard_violin():
|
|
fb = Fretboard.violin()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["E", "A", "D", "G"]
|
|
|
|
|
|
def test_fretboard_viola():
|
|
fb = Fretboard.viola()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["A", "D", "G", "C"]
|
|
|
|
|
|
def test_fretboard_cello():
|
|
fb = Fretboard.cello()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["A", "D", "G", "C"]
|
|
assert fb.tones[0].octave == 3
|
|
|
|
|
|
def test_fretboard_banjo():
|
|
fb = Fretboard.banjo()
|
|
assert len(fb) == 5
|
|
assert fb.tones[-1].name == "G" # high drone string
|
|
|
|
|
|
def test_fretboard_banjo_open_d():
|
|
fb = Fretboard.banjo("open d")
|
|
assert len(fb) == 5
|
|
|
|
|
|
def test_fretboard_twelve_string():
|
|
fb = Fretboard.twelve_string()
|
|
assert len(fb) == 12
|
|
|
|
|
|
def test_fretboard_violin_tuned_in_fifths():
|
|
"""Violin strings should be a perfect 5th apart."""
|
|
fb = Fretboard.violin()
|
|
for i in range(len(fb.tones) - 1):
|
|
interval = fb.tones[i] - fb.tones[i + 1]
|
|
assert interval == 7, f"Strings {i} and {i+1} not a 5th apart"
|
|
|
|
|
|
def test_fretboard_octave_mandolin():
|
|
fb = Fretboard.octave_mandolin()
|
|
assert len(fb) == 4
|
|
assert fb.tones[0].name == "E"
|
|
assert fb.tones[0].octave == 4
|
|
|
|
|
|
def test_fretboard_mandocello():
|
|
fb = Fretboard.mandocello()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["A", "D", "G", "C"]
|
|
assert fb.tones[0].octave == 3
|
|
|
|
|
|
def test_fretboard_double_bass():
|
|
fb = Fretboard.double_bass()
|
|
assert len(fb) == 4
|
|
names = [t.name for t in fb]
|
|
assert names == ["G", "D", "A", "E"]
|
|
|
|
|
|
def test_fretboard_double_bass_tuned_in_fourths():
|
|
fb = Fretboard.double_bass()
|
|
for i in range(len(fb.tones) - 1):
|
|
interval = fb.tones[i] - fb.tones[i + 1]
|
|
assert interval == 5, f"Strings {i} and {i+1} not a 4th apart"
|
|
|
|
|
|
def test_fretboard_harp():
|
|
fb = Fretboard.harp()
|
|
assert len(fb) == 47
|
|
assert fb.tones[0].name == "G"
|
|
assert fb.tones[0].octave == 7
|
|
assert fb.tones[-1].name == "C"
|
|
assert fb.tones[-1].octave == 1
|
|
|
|
|
|
def test_fretboard_pedal_steel():
|
|
fb = Fretboard.pedal_steel()
|
|
assert len(fb) == 10
|
|
|
|
|
|
def test_mandolin_family_fifths():
|
|
"""All mandolin family instruments should be tuned in 5ths."""
|
|
for name in ["mandolin", "mandola", "octave_mandolin", "mandocello"]:
|
|
fb = getattr(Fretboard, name)()
|
|
for i in range(len(fb.tones) - 1):
|
|
interval = fb.tones[i] - fb.tones[i + 1]
|
|
assert interval == 7, f"{name} strings {i},{i+1} not a 5th apart"
|
|
|
|
|
|
def test_all_instruments_create():
|
|
"""Every instrument preset should instantiate without error."""
|
|
instruments = [
|
|
"guitar", "twelve_string", "bass", "ukulele",
|
|
"mandolin", "mandola", "octave_mandolin", "mandocello",
|
|
"violin", "viola", "cello", "double_bass",
|
|
"banjo", "harp", "pedal_steel",
|
|
"bouzouki", "oud", "sitar", "shamisen", "erhu",
|
|
"charango", "pipa", "balalaika", "lute", "keyboard",
|
|
]
|
|
for name in instruments:
|
|
fb = getattr(Fretboard, name)()
|
|
assert len(fb) > 0, f"{name} has no strings"
|
|
|
|
|
|
def test_fretboard_oud():
|
|
fb = Fretboard.oud()
|
|
assert len(fb) == 6
|
|
|
|
|
|
def test_fretboard_shamisen():
|
|
fb = Fretboard.shamisen()
|
|
assert len(fb) == 3
|
|
|
|
|
|
def test_fretboard_erhu():
|
|
fb = Fretboard.erhu()
|
|
assert len(fb) == 2
|
|
assert fb.tones[0] - fb.tones[1] == 7 # tuned in 5ths
|
|
|
|
|
|
def test_fretboard_bouzouki_irish():
|
|
fb = Fretboard.bouzouki("irish")
|
|
assert len(fb) == 4
|
|
|
|
|
|
def test_fretboard_bouzouki_greek():
|
|
fb = Fretboard.bouzouki("greek")
|
|
assert len(fb) == 4
|
|
|
|
|
|
def test_fretboard_charango():
|
|
fb = Fretboard.charango()
|
|
assert len(fb) == 5
|
|
|
|
|
|
def test_fretboard_balalaika():
|
|
fb = Fretboard.balalaika()
|
|
assert len(fb) == 3
|
|
# Two unison strings
|
|
assert fb.tones[1].name == fb.tones[2].name
|
|
|
|
|
|
def test_fretboard_lute():
|
|
fb = Fretboard.lute()
|
|
assert len(fb) == 6
|
|
|
|
|
|
def test_fretboard_sitar():
|
|
fb = Fretboard.sitar()
|
|
assert len(fb) == 7
|
|
|
|
|
|
def test_fretboard_pipa():
|
|
fb = Fretboard.pipa()
|
|
assert len(fb) == 4
|
|
|
|
|
|
def test_keyboard_88():
|
|
kb = Fretboard.keyboard()
|
|
assert len(kb) == 88
|
|
|
|
|
|
def test_keyboard_25():
|
|
kb = Fretboard.keyboard(25, "C3")
|
|
assert len(kb) == 25
|
|
assert kb.tones[-1].name == "C"
|
|
assert kb.tones[-1].octave == 3
|
|
|
|
|
|
def test_keyboard_custom():
|
|
kb = Fretboard.keyboard(61, "C2")
|
|
assert len(kb) == 61
|
|
|
|
|
|
# ── Ergonomic integration tests ─────────────────────────────────────────────
|
|
|
|
def test_ergonomic_workflow():
|
|
"""Demonstrate the improved API in a realistic workflow."""
|
|
# Build a scale
|
|
c = TonedScale(tonic="C4")
|
|
major = c["major"]
|
|
|
|
# Iterate and check
|
|
assert "C" in major
|
|
assert len(major) == 8
|
|
|
|
# Build chords from the scale
|
|
I = major.triad(0) # C major
|
|
IV = major.triad(3) # F major
|
|
V = major.triad(4) # G major
|
|
|
|
assert "C" in I
|
|
assert "F" in IV
|
|
assert "G" in V
|
|
|
|
# Get fingerings
|
|
fb = Fretboard.guitar()
|
|
for name in ["C", "F", "G"]:
|
|
fingering = CHARTS["western"][name].fingering(fretboard=fb)
|
|
assert len(fingering) == len(fb)
|
|
|
|
|
|
def test_tone_arithmetic_workflow():
|
|
"""Demonstrate tone arithmetic with operators."""
|
|
c4 = Tone.from_string("C4", system="western")
|
|
|
|
# Build intervals
|
|
major_third = c4 + 4 # E4
|
|
perfect_fifth = c4 + 7 # G4
|
|
octave = c4 + 12 # C5
|
|
|
|
assert str(major_third) == "E4"
|
|
assert str(perfect_fifth) == "G4"
|
|
assert str(octave) == "C5"
|
|
|
|
# Measure intervals
|
|
assert perfect_fifth - c4 == 7
|
|
assert octave - c4 == 12
|
|
|
|
# Compare
|
|
assert c4 < major_third < perfect_fifth < octave
|
|
|
|
|
|
# ── Indian system ───────────────────────────────────────────────────────────
|
|
|
|
def test_indian_system_exists():
|
|
assert "indian" in SYSTEMS
|
|
assert SYSTEMS["indian"].semitones == 12
|
|
|
|
|
|
def test_indian_system_tones():
|
|
indian = SYSTEMS["indian"]
|
|
names = [t.name for t in indian.tones]
|
|
assert "Sa" in names
|
|
assert "Pa" in names
|
|
assert "Dha" in names
|
|
assert len(names) == 12
|
|
|
|
|
|
def test_indian_sa_pitch():
|
|
"""Sa4 should equal C4 = 261.63 Hz."""
|
|
sa = Tone.from_string("Sa4", system="indian")
|
|
assert abs(sa.frequency - 261.63) < 0.01
|
|
|
|
|
|
def test_indian_pa_pitch():
|
|
"""Pa4 should equal G4 = 392.00 Hz."""
|
|
sa = Tone.from_string("Sa4", system="indian")
|
|
pa = sa + 7
|
|
assert pa.name == "Pa"
|
|
assert abs(pa.frequency - 392.00) < 0.01
|
|
|
|
|
|
def test_indian_dha_pitch():
|
|
"""Dha4 should equal A4 = 440 Hz."""
|
|
dha = Tone.from_string("Dha4", system="indian")
|
|
assert abs(dha.frequency - 440.0) < 0.01
|
|
|
|
|
|
def test_indian_octave_sa():
|
|
"""Sa4 + 12 = Sa5."""
|
|
sa = Tone.from_string("Sa4", system="indian")
|
|
result = sa + 12
|
|
assert result.name == "Sa"
|
|
assert result.octave == 5
|
|
|
|
|
|
def test_indian_bilawal_thaat():
|
|
"""Bilawal = major scale: Sa Re Ga Ma Pa Dha Ni Sa."""
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
bilawal = sa["bilawal"]
|
|
names = [t.name for t in bilawal]
|
|
assert names == ["Sa", "Re", "Ga", "Ma", "Pa", "Dha", "Ni", "Sa"]
|
|
|
|
|
|
def test_indian_bhairav_thaat():
|
|
"""Bhairav: Sa komal-Re Ga Ma Pa komal-Dha Ni Sa."""
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
bhairav = sa["bhairav"]
|
|
names = [t.name for t in bhairav]
|
|
assert names == ["Sa", "komal Re", "Ga", "Ma", "Pa", "komal Dha", "Ni", "Sa"]
|
|
|
|
|
|
def test_indian_todi_thaat():
|
|
"""Todi: Sa komal-Re komal-Ga tivra-Ma Pa komal-Dha Ni Sa."""
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
todi = sa["todi"]
|
|
names = [t.name for t in todi]
|
|
assert names == ["Sa", "komal Re", "komal Ga", "tivra Ma", "Pa", "komal Dha", "Ni", "Sa"]
|
|
|
|
|
|
def test_indian_kalyan_thaat():
|
|
"""Kalyan = Lydian: Sa Re Ga tivra-Ma Pa Dha Ni Sa."""
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
kalyan = sa["kalyan"]
|
|
names = [t.name for t in kalyan]
|
|
assert names == ["Sa", "Re", "Ga", "tivra Ma", "Pa", "Dha", "Ni", "Sa"]
|
|
|
|
|
|
def test_indian_all_thaats_available():
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
thaats = sa.scales
|
|
for thaat in ["bilawal", "bhairav", "todi", "kalyan", "kafi",
|
|
"asavari", "bhairavi", "khamaj", "poorvi", "marwa"]:
|
|
assert thaat in thaats, f"Missing thaat: {thaat}"
|
|
|
|
|
|
def test_indian_all_thaat_intervals_sum_to_12():
|
|
indian = SYSTEMS["indian"]
|
|
for name, scale in indian.scales["thaat"].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
def test_indian_bilawal_equals_western_major():
|
|
"""Bilawal intervals should match Western major."""
|
|
indian = SYSTEMS["indian"]
|
|
western = SYSTEMS["western"]
|
|
bilawal = indian.scales["thaat"]["bilawal"]["intervals"]
|
|
major = western.scales["heptatonic"]["major"]["intervals"]
|
|
assert bilawal == major
|
|
|
|
|
|
def test_indian_tone_arithmetic():
|
|
sa = Tone.from_string("Sa4", system="indian")
|
|
assert (sa + 2).name == "Re"
|
|
assert (sa + 4).name == "Ga"
|
|
assert (sa + 5).name == "Ma"
|
|
assert (sa + 7).name == "Pa"
|
|
assert (sa + 9).name == "Dha"
|
|
assert (sa + 11).name == "Ni"
|
|
|
|
|
|
def test_indian_chromatic_walk():
|
|
"""Walk all 12 swaras from Sa4."""
|
|
sa = Tone.from_string("Sa4", system="indian")
|
|
expected = ["Sa", "komal Re", "Re", "komal Ga", "Ga", "Ma",
|
|
"tivra Ma", "Pa", "komal Dha", "Dha", "komal Ni", "Ni", "Sa"]
|
|
for i, name in enumerate(expected):
|
|
result = sa + i
|
|
assert result.name == name, f"step {i}: expected {name}, got {result.name}"
|
|
|
|
|
|
def test_indian_scale_triad():
|
|
"""Build a triad from Bilawal (Sa Ga Pa)."""
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
bilawal = sa["bilawal"]
|
|
triad = bilawal.triad(0)
|
|
names = [t.name for t in triad]
|
|
assert names == ["Sa", "Ga", "Pa"]
|
|
|
|
|
|
def test_indian_scale_degree_access():
|
|
sa = TonedScale(tonic="Sa4", system=SYSTEMS["indian"])
|
|
bilawal = sa["bilawal"]
|
|
assert bilawal[0].name == "Sa"
|
|
assert bilawal[4].name == "Pa"
|
|
assert bilawal["I"].name == "Sa"
|
|
assert bilawal["V"].name == "Pa"
|
|
|
|
|
|
# ── Arabic system ───────────────────────────────────────────────────────────
|
|
|
|
def test_arabic_system_exists():
|
|
assert "arabic" in SYSTEMS
|
|
assert SYSTEMS["arabic"].semitones == 12
|
|
|
|
|
|
def test_arabic_tones():
|
|
arabic = SYSTEMS["arabic"]
|
|
names = [t.name for t in arabic.tones]
|
|
assert "Do" in names
|
|
assert "Re" in names
|
|
assert "Sol" in names
|
|
|
|
|
|
def test_arabic_do_pitch():
|
|
"""Do4 should equal C4 = 261.63 Hz."""
|
|
do = Tone.from_string("Do4", system="arabic")
|
|
assert abs(do.frequency - 261.63) < 0.01
|
|
|
|
|
|
def test_arabic_ajam_maqam():
|
|
"""Ajam = major scale."""
|
|
do = TonedScale(tonic="Do4", system=SYSTEMS["arabic"])
|
|
ajam = do["ajam"]
|
|
names = [t.name for t in ajam]
|
|
assert names == ["Do", "Re", "Mi", "Fa", "Sol", "La", "Si", "Do"]
|
|
|
|
|
|
def test_arabic_hijaz_maqam():
|
|
"""Hijaz has augmented 2nd between 2nd and 3rd degrees."""
|
|
do = TonedScale(tonic="Do4", system=SYSTEMS["arabic"])
|
|
hijaz = do["hijaz"]
|
|
names = [t.name for t in hijaz]
|
|
assert names[0] == "Do"
|
|
assert names[1] == "Reb" # flat 2nd
|
|
assert names[2] == "Mi" # natural 3rd (augmented 2nd interval)
|
|
|
|
|
|
def test_arabic_all_maqamat_available():
|
|
do = TonedScale(tonic="Do4", system=SYSTEMS["arabic"])
|
|
for maqam in ["ajam", "nahawand", "kurd", "hijaz", "nikriz",
|
|
"bayati", "rast", "saba", "sikah", "jiharkah"]:
|
|
assert maqam in do.scales, f"Missing maqam: {maqam}"
|
|
|
|
|
|
def test_arabic_all_maqam_intervals_sum_to_12():
|
|
arabic = SYSTEMS["arabic"]
|
|
for name, scale in arabic.scales["maqam"].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
def test_arabic_ajam_equals_western_major():
|
|
arabic = SYSTEMS["arabic"]
|
|
western = SYSTEMS["western"]
|
|
ajam = arabic.scales["maqam"]["ajam"]["intervals"]
|
|
major = western.scales["heptatonic"]["major"]["intervals"]
|
|
assert ajam == major
|
|
|
|
|
|
def test_arabic_tone_arithmetic():
|
|
do = Tone.from_string("Do4", system="arabic")
|
|
assert (do + 2).name == "Re"
|
|
assert (do + 4).name == "Mi"
|
|
assert (do + 7).name == "Sol"
|
|
|
|
|
|
# ── Japanese system ─────────────────────────────────────────────────────────
|
|
|
|
def test_japanese_system_exists():
|
|
assert "japanese" in SYSTEMS
|
|
assert SYSTEMS["japanese"].semitones == 12
|
|
|
|
|
|
def test_japanese_hirajoshi():
|
|
"""Hirajoshi: C D Eb G Ab."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
h = c["hirajoshi"]
|
|
names = [t.name for t in h]
|
|
assert names == ["C", "D", "Eb", "G", "Ab", "C"]
|
|
|
|
|
|
def test_japanese_in_scale():
|
|
"""In (Miyako-bushi): C Db F G Ab."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
s = c["in"]
|
|
names = [t.name for t in s]
|
|
assert names == ["C", "Db", "F", "G", "Ab", "C"]
|
|
|
|
|
|
def test_japanese_yo_scale():
|
|
"""Yo: C D F G Bb."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
s = c["yo"]
|
|
names = [t.name for t in s]
|
|
assert names == ["C", "D", "F", "G", "A#", "C"]
|
|
|
|
|
|
def test_japanese_iwato():
|
|
"""Iwato: C Db F Gb Bb."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
s = c["iwato"]
|
|
names = [t.name for t in s]
|
|
assert names == ["C", "Db", "F", "Gb", "Bb", "C"]
|
|
|
|
|
|
def test_japanese_kumoi():
|
|
"""Kumoi: C D Eb G A."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
s = c["kumoi"]
|
|
names = [t.name for t in s]
|
|
assert names == ["C", "D", "Eb", "G", "A", "C"]
|
|
|
|
|
|
def test_japanese_ritsu():
|
|
"""Ritsu (gagaku): C D Eb F G A Bb = Dorian."""
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
s = c["ritsu"]
|
|
names = [t.name for t in s]
|
|
assert names == ["C", "D", "Eb", "F", "G", "A", "Bb", "C"]
|
|
|
|
|
|
def test_japanese_all_scales_available():
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["japanese"])
|
|
for scale in ["hirajoshi", "in", "yo", "iwato", "kumoi", "insen", "ritsu", "ryo"]:
|
|
assert scale in c.scales, f"Missing scale: {scale}"
|
|
|
|
|
|
def test_japanese_pentatonic_intervals_sum_to_12():
|
|
japanese = SYSTEMS["japanese"]
|
|
for name, scale in japanese.scales["pentatonic"].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
def test_japanese_heptatonic_intervals_sum_to_12():
|
|
japanese = SYSTEMS["japanese"]
|
|
for name, scale in japanese.scales["heptatonic"].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
# ── Blues system ────────────────────────────────────────────────────────────
|
|
|
|
def test_blues_system_exists():
|
|
assert "blues" in SYSTEMS
|
|
assert SYSTEMS["blues"].semitones == 12
|
|
|
|
|
|
def test_blues_major_pentatonic():
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["blues"])
|
|
s = c["major pentatonic"]
|
|
assert s.note_names == ["C", "D", "E", "G", "A", "C"]
|
|
|
|
|
|
def test_blues_minor_pentatonic():
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["blues"])
|
|
s = c["minor pentatonic"]
|
|
assert s.note_names == ["C", "D#", "F", "G", "A#", "C"]
|
|
|
|
|
|
def test_blues_scale():
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["blues"])
|
|
s = c["blues"]
|
|
names = s.note_names
|
|
assert names == ["C", "Eb", "F", "Gb", "G", "Bb", "C"]
|
|
assert len(names) == 7 # 6 notes + octave
|
|
|
|
|
|
def test_blues_all_scales_available():
|
|
c = TonedScale(tonic="C4", system=SYSTEMS["blues"])
|
|
for scale in ["major pentatonic", "minor pentatonic", "blues",
|
|
"major blues", "dominant", "minor"]:
|
|
assert scale in c.scales, f"Missing scale: {scale}"
|
|
|
|
|
|
def test_blues_all_intervals_sum_to_12():
|
|
blues = SYSTEMS["blues"]
|
|
for scale_type in blues.scales:
|
|
for name, scale in blues.scales[scale_type].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
# ── Gamelan system ──────────────────────────────────────────────────────────
|
|
|
|
def test_gamelan_system_exists():
|
|
assert "gamelan" in SYSTEMS
|
|
assert SYSTEMS["gamelan"].semitones == 12
|
|
|
|
|
|
def test_gamelan_tones():
|
|
gamelan = SYSTEMS["gamelan"]
|
|
names = [t.name for t in gamelan.tones]
|
|
assert "ji" in names
|
|
assert "ro" in names
|
|
assert "mo" in names
|
|
|
|
|
|
def test_gamelan_slendro():
|
|
ji = TonedScale(tonic="ji4", system=SYSTEMS["gamelan"])
|
|
s = ji["slendro"]
|
|
assert s.note_names == ["ji", "ro", "pat", "mo", "pi", "ji"]
|
|
|
|
|
|
def test_gamelan_pelog():
|
|
ji = TonedScale(tonic="ji4", system=SYSTEMS["gamelan"])
|
|
s = ji["pelog"]
|
|
assert len(s) == 8 # 7 notes + octave
|
|
|
|
|
|
def test_gamelan_all_scales_available():
|
|
ji = TonedScale(tonic="ji4", system=SYSTEMS["gamelan"])
|
|
for scale in ["slendro", "pelog nem", "pelog barang", "pelog lima", "pelog"]:
|
|
assert scale in ji.scales, f"Missing scale: {scale}"
|
|
|
|
|
|
def test_gamelan_all_intervals_sum_to_12():
|
|
gamelan = SYSTEMS["gamelan"]
|
|
for scale_type in gamelan.scales:
|
|
for name, scale in gamelan.scales[scale_type].items():
|
|
total = sum(scale["intervals"])
|
|
assert total == 12, f"{name} intervals sum to {total}, not 12"
|
|
|
|
|
|
# ── Overtone series ─────────────────────────────────────────────────────────
|
|
|
|
def test_overtones_a4():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
harmonics = a4.overtones(4)
|
|
assert len(harmonics) == 4
|
|
assert abs(harmonics[0] - 440.0) < 0.01
|
|
assert abs(harmonics[1] - 880.0) < 0.01
|
|
assert abs(harmonics[2] - 1320.0) < 0.01
|
|
assert abs(harmonics[3] - 1760.0) < 0.01
|
|
|
|
|
|
def test_overtones_default_count():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
assert len(c4.overtones()) == 8
|
|
|
|
|
|
def test_overtones_ratios():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
harmonics = a4.overtones(8)
|
|
f0 = harmonics[0]
|
|
for i, h in enumerate(harmonics):
|
|
assert abs(h / f0 - (i + 1)) < 0.001
|
|
|
|
|
|
# ── Chord identification ────────────────────────────────────────────────────
|
|
|
|
def test_identify_c_major():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert chord.identify() == "C major"
|
|
|
|
|
|
def test_identify_a_minor():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
Tone.from_string("E5", system="western"),
|
|
])
|
|
assert chord.identify() == "A minor"
|
|
|
|
|
|
def test_identify_g_dominant_7th():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
Tone.from_string("F5", system="western"),
|
|
])
|
|
assert chord.identify() == "G dominant 7th"
|
|
|
|
|
|
def test_identify_power_chord():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert chord.identify() == "C power"
|
|
|
|
|
|
def test_identify_diminished():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
Tone.from_string("F5", system="western"),
|
|
])
|
|
assert chord.identify() == "B diminished"
|
|
|
|
|
|
def test_identify_single_tone():
|
|
chord = Chord(tones=[Tone.from_string("C4", system="western")])
|
|
assert chord.identify() is None
|
|
|
|
|
|
# ── Voice leading ───────────────────────────────────────────────────────────
|
|
|
|
def test_voice_leading_same_chord():
|
|
c_maj = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
vl = c_maj.voice_leading(c_maj)
|
|
total = sum(abs(v[2]) for v in vl)
|
|
assert total == 0
|
|
|
|
|
|
def test_voice_leading_returns_tuples():
|
|
c = Chord([Tone.from_string("C4", system="western")])
|
|
d = Chord([Tone.from_string("D4", system="western")])
|
|
vl = c.voice_leading(d)
|
|
assert len(vl) == 1
|
|
assert vl[0][2] == 2
|
|
|
|
|
|
# ── Harmonic analysis ───────────────────────────────────────────────────────
|
|
|
|
def test_analyze_I():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert chord.analyze("C") == "I"
|
|
|
|
|
|
def test_analyze_V():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
])
|
|
assert chord.analyze("C") == "V"
|
|
|
|
|
|
def test_analyze_ii():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("D4", system="western"),
|
|
Tone.from_string("F4", system="western"),
|
|
Tone.from_string("A4", system="western"),
|
|
])
|
|
assert chord.analyze("C") == "ii"
|
|
|
|
|
|
def test_analyze_V7():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
Tone.from_string("F5", system="western"),
|
|
])
|
|
assert chord.analyze("C") == "V7"
|
|
|
|
|
|
def test_analyze_not_in_key():
|
|
"""F# major in C major is now recognized as a borrowed chord (bV)."""
|
|
chord = Chord(tones=[
|
|
Tone.from_string("F#4", system="western"),
|
|
Tone.from_string("A#4", system="western"),
|
|
Tone.from_string("C#5", system="western"),
|
|
])
|
|
result = chord.analyze("C")
|
|
assert result is not None
|
|
assert "b" in result # borrowed chord with flat prefix
|
|
|
|
|
|
# ── Tension ─────────────────────────────────────────────────────────────────
|
|
|
|
def test_tension_c_major_low():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert chord.tension["score"] == 0.0
|
|
assert chord.tension["tritones"] == 0
|
|
|
|
|
|
def test_tension_g7_high():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
Tone.from_string("F5", system="western"),
|
|
])
|
|
t = chord.tension
|
|
assert t["tritones"] == 1
|
|
assert t["has_dominant_function"] is True
|
|
assert t["score"] > 0.5
|
|
|
|
|
|
def test_tension_empty():
|
|
chord = Chord(tones=[])
|
|
assert chord.tension["score"] == 0.0
|
|
|
|
|
|
# ── Version ─────────────────────────────────────────────────────────────────
|
|
|
|
def test_version():
|
|
import pytheory
|
|
assert pytheory.__version__
|
|
|
|
|
|
def test_all_exports():
|
|
import pytheory
|
|
assert not hasattr(pytheory, "ceil")
|
|
assert not hasattr(pytheory, "floor")
|
|
assert "Tone" in pytheory.__all__
|
|
|
|
|
|
# ── Interval naming ─────────────────────────────────────────────────────────
|
|
|
|
def test_interval_to_perfect_fifth():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = Tone.from_string("G4", system="western")
|
|
assert c4.interval_to(g4) == "perfect 5th"
|
|
|
|
|
|
def test_interval_to_major_third():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
e4 = Tone.from_string("E4", system="western")
|
|
assert c4.interval_to(e4) == "major 3rd"
|
|
|
|
|
|
def test_interval_to_octave():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
c5 = Tone.from_string("C5", system="western")
|
|
assert c4.interval_to(c5) == "octave"
|
|
|
|
|
|
def test_interval_to_unison():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
assert c4.interval_to(c4) == "unison"
|
|
|
|
|
|
def test_interval_to_compound():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
d5 = c4 + 14
|
|
assert c4.interval_to(d5) == "major 2nd + 1 octave"
|
|
|
|
|
|
def test_interval_to_two_octaves():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
c6 = c4 + 24
|
|
assert c4.interval_to(c6) == "2 octaves"
|
|
|
|
|
|
# ── MIDI ────────────────────────────────────────────────────────────────────
|
|
|
|
def test_midi_c4():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
assert c4.midi == 60
|
|
|
|
|
|
def test_midi_a4():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
assert a4.midi == 69
|
|
|
|
|
|
def test_midi_c5():
|
|
c5 = Tone.from_string("C5", system="western")
|
|
assert c5.midi == 72
|
|
|
|
|
|
def test_midi_no_octave():
|
|
c = Tone(name="C")
|
|
assert c.midi is None
|
|
|
|
|
|
def test_midi_chromatic_sequence():
|
|
"""MIDI numbers should increment by 1 per semitone."""
|
|
c4 = Tone.from_string("C4", system="western")
|
|
for i in range(12):
|
|
assert (c4 + i).midi == 60 + i
|
|
|
|
|
|
# ── Transpose ──────────────────────────────────────────────────────────────
|
|
|
|
def test_tone_transpose():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
assert c4.transpose(7).name == "G"
|
|
|
|
|
|
def test_chord_transpose():
|
|
c_maj = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
g_maj = c_maj.transpose(7)
|
|
assert g_maj.identify() == "G major"
|
|
|
|
|
|
def test_chord_transpose_preserves_quality():
|
|
am = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
Tone.from_string("E5", system="western"),
|
|
])
|
|
dm = am.transpose(5)
|
|
assert dm.identify() == "D minor"
|
|
|
|
|
|
def test_chord_transpose_negative():
|
|
g_maj = Chord(tones=[
|
|
Tone.from_string("G4", system="western"),
|
|
Tone.from_string("B4", system="western"),
|
|
Tone.from_string("D5", system="western"),
|
|
])
|
|
c_maj = g_maj.transpose(-7)
|
|
assert c_maj.identify() == "C major"
|
|
|
|
|
|
def test_scale_transpose():
|
|
c_major = TonedScale(tonic="C4")["major"]
|
|
d_major = c_major.transpose(2)
|
|
assert d_major.note_names == ["D", "E", "F#", "G", "A", "B", "C#", "D"]
|
|
|
|
|
|
def test_scale_transpose_negative():
|
|
d_major = TonedScale(tonic="D4")["major"]
|
|
c_major = d_major.transpose(-2)
|
|
assert c_major.note_names == ["C", "D", "E", "F", "G", "A", "B", "C"]
|
|
|
|
|
|
# ── Chord root and quality ─────────────────────────────────────────────────
|
|
|
|
def test_chord_root():
|
|
c_maj = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert c_maj.root.name == "C"
|
|
|
|
|
|
def test_chord_quality():
|
|
c_maj = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert c_maj.quality == "major"
|
|
|
|
|
|
def test_chord_quality_minor():
|
|
am = Chord(tones=[
|
|
Tone.from_string("A4", system="western"),
|
|
Tone.from_string("C5", system="western"),
|
|
Tone.from_string("E5", system="western"),
|
|
])
|
|
assert am.quality == "minor"
|
|
|
|
|
|
def test_chord_root_unknown():
|
|
chord = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("D4", system="western"),
|
|
])
|
|
assert chord.root is None
|
|
assert chord.quality is None
|
|
|
|
|
|
# ── Tone.from_frequency ────────────────────────────────────────────────────
|
|
|
|
def test_from_frequency_a4():
|
|
t = Tone.from_frequency(440)
|
|
assert t.name == "A"
|
|
assert t.octave == 4
|
|
|
|
|
|
def test_from_frequency_c4():
|
|
t = Tone.from_frequency(261.63)
|
|
assert t.name == "C"
|
|
assert t.octave == 4
|
|
|
|
|
|
def test_from_frequency_a5():
|
|
t = Tone.from_frequency(880)
|
|
assert t.name == "A"
|
|
assert t.octave == 5
|
|
|
|
|
|
def test_from_frequency_a3():
|
|
t = Tone.from_frequency(220)
|
|
assert t.name == "A"
|
|
assert t.octave == 3
|
|
|
|
|
|
def test_from_frequency_roundtrip():
|
|
"""from_frequency(tone.frequency) should return the same note."""
|
|
for note in ["C4", "E4", "G4", "A4", "B3", "F#5"]:
|
|
t = Tone.from_string(note, system="western")
|
|
recovered = Tone.from_frequency(t.frequency)
|
|
assert recovered.name == t.name
|
|
assert recovered.octave == t.octave
|
|
|
|
|
|
# ── Tone.from_midi ─────────────────────────────────────────────────────────
|
|
|
|
def test_from_midi_c4():
|
|
assert Tone.from_midi(60).name == "C"
|
|
assert Tone.from_midi(60).octave == 4
|
|
|
|
|
|
def test_from_midi_a4():
|
|
assert Tone.from_midi(69).name == "A"
|
|
assert Tone.from_midi(69).octave == 4
|
|
|
|
|
|
def test_from_midi_roundtrip():
|
|
"""from_midi(tone.midi) should return the same note."""
|
|
for midi in [48, 60, 69, 72, 84]:
|
|
t = Tone.from_midi(midi)
|
|
assert t.midi == midi
|
|
|
|
|
|
# ── Chord.inversion ────────────────────────────────────────────────────────
|
|
|
|
def test_chord_inversion_0():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
inv0 = c.inversion(0)
|
|
assert [t.full_name for t in inv0] == ["C4", "E4", "G4"]
|
|
|
|
|
|
def test_chord_inversion_1():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
inv1 = c.inversion(1)
|
|
assert inv1.tones[0].name == "E"
|
|
assert inv1.tones[-1].name == "C"
|
|
assert inv1.tones[-1].octave == 5
|
|
|
|
|
|
def test_chord_inversion_2():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
inv2 = c.inversion(2)
|
|
assert inv2.tones[0].name == "G"
|
|
assert inv2.tones[0].octave == 4
|
|
|
|
|
|
def test_chord_inversion_preserves_identity():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("E4", system="western"),
|
|
Tone.from_string("G4", system="western"),
|
|
])
|
|
assert c.inversion(1).identify() == "C major"
|
|
assert c.inversion(2).identify() == "C major"
|
|
|
|
|
|
# ── Scale.seventh ──────────────────────────────────────────────────────────
|
|
|
|
def test_scale_seventh_I():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
assert major.seventh(0).identify() == "C major 7th"
|
|
|
|
|
|
def test_scale_seventh_ii():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
assert major.seventh(1).identify() == "D minor 7th"
|
|
|
|
|
|
def test_scale_seventh_V():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
assert major.seventh(4).identify() == "G dominant 7th"
|
|
|
|
|
|
# ── Scale.harmonize ────────────────────────────────────────────────────────
|
|
|
|
def test_harmonize_c_major():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
chords = major.harmonize()
|
|
assert len(chords) == 7
|
|
qualities = [c.identify() for c in chords]
|
|
assert qualities == [
|
|
"C major", "D minor", "E minor", "F major",
|
|
"G major", "A minor", "B diminished",
|
|
]
|
|
|
|
|
|
def test_harmonize_len():
|
|
minor = TonedScale(tonic="A4")["minor"]
|
|
assert len(minor.harmonize()) == 7
|
|
|
|
|
|
# ── Scale.progression ──────────────────────────────────────────────────────
|
|
|
|
def test_progression_I_IV_V():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
prog = major.progression("I", "IV", "V")
|
|
assert len(prog) == 3
|
|
assert prog[0].identify() == "C major"
|
|
assert prog[1].identify() == "F major"
|
|
assert prog[2].identify() == "G major"
|
|
|
|
|
|
def test_progression_with_seventh():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
prog = major.progression("I", "V7")
|
|
assert prog[0].identify() == "C major"
|
|
assert prog[1].identify() == "G dominant 7th"
|
|
|
|
|
|
def test_progression_pop():
|
|
major = TonedScale(tonic="G4")["major"]
|
|
prog = major.progression("I", "V", "vi", "IV")
|
|
assert prog[0].identify() == "G major"
|
|
assert prog[3].identify() == "C major"
|
|
|
|
|
|
# ── Key class ───────────────────────────────────────────────────────────────
|
|
|
|
def test_key_c_major():
|
|
k = Key("C", "major")
|
|
assert k.note_names == ["C", "D", "E", "F", "G", "A", "B", "C"]
|
|
|
|
|
|
def test_key_repr():
|
|
assert repr(Key("C", "major")) == "<Key C major>"
|
|
|
|
|
|
def test_key_chords():
|
|
k = Key("C", "major")
|
|
assert k.chords == [
|
|
"C major", "D minor", "E minor", "F major",
|
|
"G major", "A minor", "B diminished",
|
|
]
|
|
|
|
|
|
def test_key_seventh_chords():
|
|
k = Key("C", "major")
|
|
sevenths = k.seventh_chords
|
|
assert sevenths[0] == "C major 7th"
|
|
assert sevenths[4] == "G dominant 7th"
|
|
|
|
|
|
def test_key_triad():
|
|
k = Key("C", "major")
|
|
assert k.triad(0).identify() == "C major"
|
|
assert k.triad(4).identify() == "G major"
|
|
|
|
|
|
def test_key_seventh():
|
|
k = Key("C", "major")
|
|
assert k.seventh(4).identify() == "G dominant 7th"
|
|
|
|
|
|
def test_key_progression():
|
|
k = Key("G", "major")
|
|
prog = k.progression("I", "IV", "V")
|
|
assert prog[0].identify() == "G major"
|
|
|
|
|
|
def test_key_relative_major_to_minor():
|
|
k = Key("C", "major")
|
|
rel = k.relative
|
|
assert rel.tonic_name == "A"
|
|
assert rel.mode == "minor"
|
|
|
|
|
|
def test_key_relative_minor_to_major():
|
|
k = Key("A", "minor")
|
|
rel = k.relative
|
|
assert rel.tonic_name == "C"
|
|
assert rel.mode == "major"
|
|
|
|
|
|
def test_key_parallel():
|
|
k = Key("C", "major")
|
|
par = k.parallel
|
|
assert par.tonic_name == "C"
|
|
assert par.mode == "minor"
|
|
|
|
|
|
def test_key_relative_shares_notes():
|
|
c = Key("C", "major")
|
|
a = c.relative
|
|
c_notes = sorted(set(c.note_names))
|
|
a_notes = sorted(set(a.note_names))
|
|
assert c_notes == a_notes
|
|
|
|
|
|
# ── Note alias ──────────────────────────────────────────────────────────────
|
|
|
|
def test_note_is_tone():
|
|
assert Note is Tone
|
|
|
|
|
|
def test_note_from_string():
|
|
n = Note.from_string("C4", system="western")
|
|
assert n.name == "C"
|
|
assert n.frequency == Tone.from_string("C4", system="western").frequency
|
|
|
|
|
|
# ── Chord.from_name ────────────────────────────────────────────────────────
|
|
|
|
def test_chord_from_name_c():
|
|
c = Chord.from_name("C")
|
|
assert c.identify() == "C major"
|
|
|
|
|
|
def test_chord_from_name_am7():
|
|
am7 = Chord.from_name("Am7")
|
|
assert am7.identify() == "A minor 7th"
|
|
|
|
|
|
def test_chord_from_name_g7():
|
|
g7 = Chord.from_name("G7")
|
|
assert g7.identify() == "G dominant 7th"
|
|
|
|
|
|
def test_chord_from_name_unknown_raises():
|
|
with pytest.raises(ValueError):
|
|
Chord.from_name("Xmaj13")
|
|
|
|
|
|
def test_chord_str():
|
|
c = Chord.from_name("C")
|
|
assert str(c) == "C major"
|
|
|
|
|
|
# ── Interval constants ─────────────────────────────────────────────────────
|
|
|
|
def test_interval_constants():
|
|
from pytheory import Interval
|
|
assert Interval.PERFECT_FIFTH == 7
|
|
assert Interval.MAJOR_THIRD == 4
|
|
assert Interval.OCTAVE == 12
|
|
assert Interval.TRITONE == 6
|
|
|
|
|
|
def test_interval_with_tone():
|
|
from pytheory import Interval
|
|
c4 = Tone.from_string("C4", system="western")
|
|
assert (c4 + Interval.PERFECT_FIFTH).name == "G"
|
|
assert (c4 + Interval.MAJOR_THIRD).name == "E"
|
|
assert (c4 + Interval.MINOR_THIRD).name == "D#"
|
|
|
|
|
|
# ── Enharmonic ─────────────────────────────────────────────────────────────
|
|
|
|
def test_enharmonic_sharp():
|
|
cs = Tone.from_string("C#4", system="western")
|
|
assert cs.enharmonic == "Db"
|
|
|
|
|
|
def test_enharmonic_natural():
|
|
c = Tone.from_string("C4", system="western")
|
|
assert c.enharmonic is None
|
|
|
|
|
|
# ── PROGRESSIONS ───────────────────────────────────────────────────────────
|
|
|
|
def test_progressions_dict():
|
|
from pytheory import PROGRESSIONS
|
|
assert "I-V-vi-IV" in PROGRESSIONS
|
|
assert "12-bar blues" in PROGRESSIONS
|
|
assert len(PROGRESSIONS["12-bar blues"]) == 12
|
|
|
|
|
|
def test_progressions_with_key():
|
|
from pytheory import PROGRESSIONS
|
|
k = Key("C", "major")
|
|
pop = k.progression(*PROGRESSIONS["I-V-vi-IV"])
|
|
assert len(pop) == 4
|
|
assert pop[0].identify() == "C major"
|
|
|
|
|
|
# ── Key.__str__ ────────────────────────────────────────────────────────────
|
|
|
|
def test_key_str():
|
|
assert str(Key("C", "major")) == "C major"
|
|
assert str(Key("A", "minor")) == "A minor"
|
|
|
|
|
|
# ── Key.detect ─────────────────────────────────────────────────────────────
|
|
|
|
def test_key_detect_c_major():
|
|
k = Key.detect("C", "D", "E", "F", "G", "A", "B")
|
|
assert k.tonic_name == "C"
|
|
assert k.mode == "major"
|
|
|
|
|
|
def test_key_detect_a_major():
|
|
k = Key.detect("A", "B", "C#", "D", "E", "F#", "G#")
|
|
assert k.tonic_name == "A"
|
|
assert k.mode == "major"
|
|
|
|
|
|
def test_key_detect_prefers_major():
|
|
"""When major and minor match equally, prefer major."""
|
|
k = Key.detect("C", "E", "G")
|
|
assert k.mode == "major"
|
|
|
|
|
|
def test_key_detect_partial():
|
|
"""Should work with a subset of scale notes."""
|
|
k = Key.detect("C", "E", "G")
|
|
assert k.tonic_name == "C"
|
|
|
|
|
|
def test_key_detect_empty():
|
|
assert Key.detect() is None
|
|
|
|
|
|
# ── Tone properties ────────────────────────────────────────────────────────
|
|
|
|
def test_tone_is_natural():
|
|
assert Tone.from_string("C4").is_natural is True
|
|
assert Tone.from_string("B4").is_natural is True
|
|
|
|
|
|
def test_tone_is_sharp():
|
|
assert Tone.from_string("C#4").is_sharp is True
|
|
assert Tone.from_string("C4").is_sharp is False
|
|
|
|
|
|
def test_tone_is_flat():
|
|
t = Tone(name="Bb", octave=4)
|
|
assert t.is_flat is True
|
|
assert Tone.from_string("C4").is_flat is False
|
|
# B natural should NOT be detected as flat
|
|
assert Tone.from_string("B4").is_flat is False
|
|
|
|
|
|
# ── Fretboard.INSTRUMENTS ──────────────────────────────────────────────────
|
|
|
|
def test_instruments_list():
|
|
assert len(Fretboard.INSTRUMENTS) == 25
|
|
assert "guitar" in Fretboard.INSTRUMENTS
|
|
assert "sitar" in Fretboard.INSTRUMENTS
|
|
assert "keyboard" in Fretboard.INSTRUMENTS
|
|
|
|
|
|
# ── Chord.from_tones ──────────────────────────────────────────────────────
|
|
|
|
def test_chord_from_tones():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
assert c.identify() == "C major"
|
|
|
|
|
|
def test_chord_from_tones_minor():
|
|
am = Chord.from_tones("A", "C", "E")
|
|
assert am.identify() == "A minor"
|
|
|
|
|
|
def test_chord_from_tones_octave():
|
|
c = Chord.from_tones("C", "E", "G", octave=3)
|
|
assert c.tones[0].octave == 3
|
|
|
|
|
|
# ── Tab output ────────────────────────────────────────────────────────────
|
|
|
|
def test_tab_output():
|
|
from pytheory.charts import CHARTS
|
|
fb = Fretboard.guitar()
|
|
tab = CHARTS["western"]["C"].tab(fretboard=fb)
|
|
assert "C" in tab
|
|
assert "|--" in tab
|
|
lines = tab.strip().split("\n")
|
|
assert len(lines) == 7 # chord name + 6 strings
|
|
|
|
|
|
def test_tab_muted_string():
|
|
from pytheory.charts import CHARTS
|
|
fb = Fretboard.guitar()
|
|
tab = CHARTS["western"]["F"].tab(fretboard=fb)
|
|
# F chord may have muted strings shown as 'x'
|
|
assert "|--" in tab
|
|
|
|
|
|
# ── Scale.detect ──────────────────────────────────────────────────────────
|
|
|
|
def test_scale_detect_c_major():
|
|
from pytheory.scales import Scale
|
|
result = Scale.detect("C", "D", "E", "F", "G", "A", "B")
|
|
assert result[0] == "C"
|
|
assert result[1] == "major"
|
|
assert result[2] == 7
|
|
|
|
|
|
def test_scale_detect_g_major():
|
|
from pytheory.scales import Scale
|
|
result = Scale.detect("C", "D", "E", "F#", "G", "A", "B")
|
|
assert result[0] == "G"
|
|
assert result[1] == "major"
|
|
|
|
|
|
def test_scale_detect_none():
|
|
from pytheory.scales import Scale
|
|
assert Scale.detect() is None
|
|
|
|
|
|
# ── Nashville numbers ────────────────────────────────────────────────────
|
|
|
|
def test_nashville_1_4_5():
|
|
k = Key("C", "major")
|
|
prog = k.nashville(1, 4, 5)
|
|
assert prog[0].identify() == "C major"
|
|
assert prog[1].identify() == "F major"
|
|
assert prog[2].identify() == "G major"
|
|
|
|
|
|
def test_nashville_with_seventh():
|
|
k = Key("G", "major")
|
|
prog = k.nashville(1, 4, "57")
|
|
assert prog[2].identify() == "D dominant 7th"
|
|
|
|
|
|
def test_nashville_on_scale():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
prog = scale.nashville(1, 5, 1)
|
|
assert prog[0].identify() == "C major"
|
|
assert prog[1].identify() == "G major"
|
|
|
|
|
|
# ── Capo ───────────────────────────────────────────────────────────────────
|
|
|
|
def test_guitar_capo():
|
|
fb = Fretboard.guitar(capo=2)
|
|
assert fb.tones[0].name == "F#"
|
|
assert len(fb) == 6
|
|
|
|
|
|
def test_capo_method():
|
|
fb = Fretboard.guitar()
|
|
fb3 = fb.capo(3)
|
|
assert fb3.tones[0].name == "G"
|
|
|
|
|
|
def test_capo_zero():
|
|
fb = Fretboard.guitar(capo=0)
|
|
assert fb.tones[0].name == "E"
|
|
|
|
|
|
# ── Chord.__add__ ─────────────────────────────────────────────────────────
|
|
|
|
def test_chord_add():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
bass = Chord.from_tones("G", octave=2)
|
|
merged = c + bass
|
|
assert len(merged) == 4
|
|
|
|
|
|
def test_chord_add_preserves_tones():
|
|
a = Chord.from_tones("C", "E")
|
|
b = Chord.from_tones("G", "B")
|
|
merged = a + b
|
|
names = [t.name for t in merged]
|
|
assert "C" in names and "G" in names
|
|
|
|
|
|
# ── Tritone substitution ──────────────────────────────────────────────────
|
|
|
|
def test_tritone_sub():
|
|
g7 = Chord.from_name("G7")
|
|
sub = g7.tritone_sub()
|
|
assert sub.identify() == "C# dominant 7th"
|
|
|
|
|
|
def test_tritone_sub_is_6_semitones():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
sub = c.tritone_sub()
|
|
assert sub.root.name == "F#"
|
|
|
|
|
|
# ── Secondary dominants ──────────────────────────────────────────────────
|
|
|
|
def test_secondary_dominant_V_of_V():
|
|
k = Key("C", "major")
|
|
vv = k.secondary_dominant(5)
|
|
assert vv.identify() == "D dominant 7th"
|
|
|
|
|
|
def test_secondary_dominant_V_of_ii():
|
|
k = Key("C", "major")
|
|
assert k.secondary_dominant(2).identify() == "A dominant 7th"
|
|
|
|
|
|
def test_secondary_dominant_V_of_vi():
|
|
k = Key("C", "major")
|
|
assert k.secondary_dominant(6).identify() == "E dominant 7th"
|
|
|
|
|
|
# ── Key.all_keys ─────────────────────────────────────────────────────────
|
|
|
|
def test_all_keys():
|
|
keys = Key.all_keys()
|
|
assert len(keys) == 24
|
|
majors = [k for k in keys if k.mode == "major"]
|
|
minors = [k for k in keys if k.mode == "minor"]
|
|
assert len(majors) == 12
|
|
assert len(minors) == 12
|
|
|
|
|
|
# ── More progressions ───────────────────────────────────────────────────
|
|
|
|
def test_progressions_count():
|
|
from pytheory.scales import PROGRESSIONS
|
|
assert len(PROGRESSIONS) >= 14
|
|
|
|
|
|
def test_pachelbel_progression():
|
|
from pytheory.scales import PROGRESSIONS
|
|
k = Key("C", "major")
|
|
prog = k.progression(*PROGRESSIONS["Pachelbel"])
|
|
assert len(prog) == 8
|
|
assert prog[0].identify() == "C major"
|
|
|
|
|
|
# ── Tone.letter ────────────────────────────────────────────────────────────
|
|
|
|
def test_tone_letter_natural():
|
|
assert Tone.from_string("C4").letter == "C"
|
|
|
|
|
|
def test_tone_letter_sharp():
|
|
assert Tone.from_string("C#4").letter == "C"
|
|
|
|
|
|
def test_tone_letter_flat():
|
|
assert Tone(name="Bb", octave=4).letter == "B"
|
|
|
|
|
|
# ── Key.signature ──────────────────────────────────────────────────────────
|
|
|
|
def test_key_signature_c_major():
|
|
sig = Key("C", "major").signature
|
|
assert sig["sharps"] == 0
|
|
assert sig["flats"] == 0
|
|
|
|
|
|
def test_key_signature_g_major():
|
|
sig = Key("G", "major").signature
|
|
assert sig["sharps"] == 1
|
|
assert sig["accidentals"] == ["F#"]
|
|
|
|
|
|
def test_key_signature_d_major():
|
|
sig = Key("D", "major").signature
|
|
assert sig["sharps"] == 2
|
|
|
|
|
|
# ── Chord.from_intervals ──────────────────────────────────────────────────
|
|
|
|
def test_chord_from_intervals_major():
|
|
assert Chord.from_intervals("C", 4, 7).identify() == "C major"
|
|
|
|
|
|
def test_chord_from_intervals_dom7():
|
|
assert Chord.from_intervals("G", 4, 7, 10).identify() == "G dominant 7th"
|
|
|
|
|
|
# ── Chord.from_midi_message ──────────────────────────────────────────────
|
|
|
|
def test_chord_from_midi_message():
|
|
c = Chord.from_midi_message(60, 64, 67)
|
|
assert c.identify() == "C major"
|
|
|
|
|
|
# ── Chord.add_tone / remove_tone ──────────────────────────────────────────
|
|
|
|
def test_chord_add_tone():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
cmaj7 = c.add_tone(Tone("B", octave=4))
|
|
assert cmaj7.identify() == "C major 7th"
|
|
|
|
|
|
def test_chord_remove_tone():
|
|
cmaj7 = Chord.from_name("Cmaj7")
|
|
c = cmaj7.remove_tone("B")
|
|
assert c.identify() == "C major"
|
|
|
|
|
|
# ── analyze_progression ──────────────────────────────────────────────────
|
|
|
|
def test_analyze_progression():
|
|
from pytheory import analyze_progression
|
|
prog = [Chord.from_name("C"), Chord.from_name("Am"),
|
|
Chord.from_name("F"), Chord.from_name("G")]
|
|
assert analyze_progression(prog, key="C") == ["I", "vi", "IV", "V"]
|
|
|
|
|
|
# ── Key.borrowed_chords ─────────────────────────────────────────────────
|
|
|
|
def test_borrowed_chords():
|
|
borrowed = Key("C", "major").borrowed_chords
|
|
assert len(borrowed) > 0
|
|
|
|
|
|
# ── Key.random_progression ──────────────────────────────────────────────
|
|
|
|
def test_random_progression():
|
|
prog = Key("C", "major").random_progression(4)
|
|
assert len(prog) == 4
|
|
|
|
|
|
# ── Fretboard.scale_diagram ────────────────────────────────────────────
|
|
|
|
def test_scale_diagram():
|
|
fb = Fretboard.guitar()
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
diagram = fb.scale_diagram(scale, frets=5)
|
|
assert "E|" in diagram
|
|
lines = diagram.strip().split("\n")
|
|
assert len(lines) == 7
|
|
|
|
|
|
# ── Coverage gap tests ─────────────────────────────────────────────────────
|
|
|
|
def test_tone_init_octave_parsed_from_name():
|
|
"""Tone('C4') should parse octave from name string."""
|
|
t = Tone("C4")
|
|
assert t.octave == 4
|
|
assert t.name == "C"
|
|
|
|
|
|
def test_tone_enharmonic_from_alt_names_direct():
|
|
t = Tone(name="C#", alt_names="Db", octave=4)
|
|
assert t.enharmonic == "Db"
|
|
|
|
|
|
def test_tone_sub_not_implemented():
|
|
t = Tone("C4")
|
|
result = t.__sub__(3.5)
|
|
assert result is NotImplemented
|
|
|
|
|
|
def test_tone_lt_not_implemented():
|
|
assert Tone("C4").__lt__("not a tone") is NotImplemented
|
|
|
|
|
|
def test_tone_le_not_implemented():
|
|
assert Tone("C4").__le__("not a tone") is NotImplemented
|
|
|
|
|
|
def test_tone_gt_not_implemented():
|
|
assert Tone("C4").__gt__("not a tone") is NotImplemented
|
|
|
|
|
|
def test_tone_ge_not_implemented():
|
|
assert Tone("C4").__ge__("not a tone") is NotImplemented
|
|
|
|
|
|
def test_tone_from_frequency_negative_raises():
|
|
with pytest.raises(ValueError, match="positive"):
|
|
Tone.from_frequency(-100)
|
|
|
|
|
|
def test_tone_interval_compound_2_octaves():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
e6 = c4 + 28 # 2 octaves + major 3rd
|
|
assert "2 octaves" in c4.interval_to(e6)
|
|
|
|
|
|
def test_tone_circle_of_fifths_returns_12():
|
|
c = Tone.from_string("C4", system="western")
|
|
assert len(c.circle_of_fifths()) == 12
|
|
|
|
|
|
def test_tone_circle_of_fourths_returns_12():
|
|
c = Tone.from_string("C4", system="western")
|
|
assert len(c.circle_of_fourths()) == 12
|
|
|
|
|
|
def test_chord_repr_unidentified():
|
|
"""Chord with no known pattern should show raw tones in repr."""
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("D4", system="western"),
|
|
])
|
|
assert "tones=" in repr(c)
|
|
|
|
|
|
def test_chord_str_unidentified():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("D4", system="western"),
|
|
])
|
|
assert "C4" in str(c)
|
|
|
|
|
|
def test_chord_add_not_implemented():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
assert c.__add__("not a chord") is NotImplemented
|
|
|
|
|
|
def test_chord_identify_returns_none_for_unknown():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("C#4", system="western"),
|
|
Tone.from_string("D4", system="western"),
|
|
])
|
|
assert c.identify() is None
|
|
|
|
|
|
def test_chord_voice_leading_different_sizes():
|
|
"""Voice leading should pad shorter chord."""
|
|
c3 = Chord.from_tones("C", "E", "G")
|
|
c4 = Chord.from_intervals("C", 4, 7, 10)
|
|
vl = c3.voice_leading(c4)
|
|
assert len(vl) == 4 # padded to match
|
|
|
|
|
|
def test_chord_analyze_with_tone_key():
|
|
"""analyze() should accept a Tone as key_tonic."""
|
|
c = Chord.from_tones("C", "E", "G")
|
|
key_tone = Tone.from_string("C4", system="western")
|
|
assert c.analyze(key_tone) == "I"
|
|
|
|
|
|
def test_chord_analyze_unknown_chord():
|
|
c = Chord(tones=[
|
|
Tone.from_string("C4", system="western"),
|
|
Tone.from_string("D4", system="western"),
|
|
])
|
|
assert c.analyze("C") is None
|
|
|
|
|
|
def test_chord_analyze_diminished():
|
|
b_dim = Chord.from_intervals("B", 3, 6)
|
|
result = b_dim.analyze("C")
|
|
assert "dim" in result
|
|
|
|
|
|
def test_chord_analyze_augmented():
|
|
c_aug = Chord.from_intervals("C", 4, 8)
|
|
result = c_aug.analyze("C")
|
|
assert "+" in result
|
|
|
|
|
|
def test_chord_analyze_9th():
|
|
c9 = Chord.from_intervals("C", 2, 4, 7, 10)
|
|
result = c9.analyze("C")
|
|
assert "9" in result
|
|
|
|
|
|
def test_scale_with_system_object():
|
|
"""Scale created with system object instead of string."""
|
|
from pytheory.scales import Scale
|
|
system = SYSTEMS["western"]
|
|
s = Scale(tones=(Tone("C", octave=4), Tone("D", octave=4)), system=system)
|
|
assert s.system == system
|
|
|
|
|
|
def test_scale_degree_by_mode_name():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
# Access by mode name should work via degree lookup
|
|
tone = major.degree("ionian")
|
|
assert tone is not None
|
|
|
|
|
|
def test_scale_getitem_raises():
|
|
major = TonedScale(tonic="C4")["major"]
|
|
with pytest.raises(KeyError):
|
|
major["nonexistent_degree"]
|
|
|
|
|
|
def test_key_with_string_system():
|
|
k = Key("C", "major", system="western")
|
|
assert k.note_names[0] == "C"
|
|
|
|
|
|
def test_key_detect_returns_none_empty():
|
|
assert Key.detect() is None
|
|
|
|
|
|
def test_key_signature_flat_key():
|
|
"""F major has one flat (Bb)."""
|
|
# F major scale: F G A Bb C D E
|
|
# But our system uses sharps, so Bb = A#
|
|
sig = Key("F", "major").signature
|
|
# The scale uses A# which is sharp notation for Bb
|
|
assert sig["sharps"] + sig["flats"] >= 0 # at least runs
|
|
|
|
|
|
def test_key_borrowed_chords_minor():
|
|
"""Minor key should borrow from parallel major."""
|
|
borrowed = Key("A", "minor").borrowed_chords
|
|
assert len(borrowed) > 0
|
|
|
|
|
|
def test_key_parallel_returns_none_for_other_modes():
|
|
"""Parallel should return None for non-major/minor modes."""
|
|
k = Key("C", "major")
|
|
k.mode = "lydian" # force non-standard mode
|
|
assert k.parallel is None
|
|
|
|
|
|
def test_key_relative_returns_none_for_other_modes():
|
|
k = Key("C", "major")
|
|
k.mode = "lydian"
|
|
assert k.relative is None
|
|
|
|
|
|
def test_toned_scale_with_string_system():
|
|
ts = TonedScale(tonic="Do4", system="arabic")
|
|
assert "ajam" in ts.scales
|
|
|
|
|
|
def test_fretboard_fingering_method():
|
|
"""Fretboard.fingering should return a Chord."""
|
|
fb = Fretboard.guitar()
|
|
result = fb.fingering(0, 0, 0, 0, 0, 0)
|
|
assert len(result) == 6
|
|
|
|
|
|
def test_charts_muted_string():
|
|
"""A chord with no valid fret gets -1 → None."""
|
|
from pytheory.charts import NamedChord
|
|
nc = NamedChord(tone_name="C", quality="")
|
|
fixed = nc.fix_fingering((0, -1, 2))
|
|
assert fixed == (0, None, 2)
|
|
|
|
|
|
def test_fretboard_chord_method():
|
|
"""Fretboard.chord() looks up a chord by name."""
|
|
fb = Fretboard.guitar()
|
|
f = fb.chord("G")
|
|
assert f.identify() == "G major"
|
|
assert len(f) == 6
|
|
|
|
|
|
def test_fretboard_chord_system_kwarg():
|
|
"""Fretboard.chord() accepts a system keyword argument."""
|
|
fb = Fretboard.guitar()
|
|
f = fb.chord("Am", system="western")
|
|
assert f.identify() == "A minor"
|
|
|
|
|
|
def test_fretboard_tab_method():
|
|
"""Fretboard.tab() returns ASCII tablature."""
|
|
fb = Fretboard.guitar()
|
|
tab = fb.tab("C")
|
|
assert "C major" in tab
|
|
assert "e|" in tab
|
|
assert "E|" in tab
|
|
|
|
|
|
@pytest.mark.slow
|
|
def test_fretboard_chart_method():
|
|
"""Fretboard.chart() generates all fingerings."""
|
|
fb = Fretboard.guitar()
|
|
chart = fb.chart()
|
|
assert "C" in chart
|
|
assert "Am7" in chart
|
|
assert chart["C"].identify() == "C major"
|
|
|
|
|
|
def test_fingering_tab_method():
|
|
"""Fingering.tab() renders ASCII tablature."""
|
|
fb = Fretboard.guitar()
|
|
f = fb.chord("Em")
|
|
tab = f.tab()
|
|
assert "E minor" in tab
|
|
assert "e|" in tab
|
|
|
|
|
|
# ── Flat note support ─────────────────────────────────────────────────────────
|
|
|
|
def test_flat_tone_from_string():
|
|
db = Tone.from_string("Db4", system="western")
|
|
assert db.name == "Db"
|
|
assert db.octave == 4
|
|
|
|
|
|
def test_flat_tone_frequency_matches_sharp():
|
|
db = Tone.from_string("Db4", system="western")
|
|
cs = Tone.from_string("C#4", system="western")
|
|
assert db.frequency == cs.frequency
|
|
|
|
|
|
def test_flat_tone_frequency_all_enharmonics():
|
|
pairs = [("Bb3", "A#3"), ("Eb4", "D#4"), ("Gb4", "F#4"), ("Ab4", "G#4")]
|
|
for flat, sharp in pairs:
|
|
f = Tone.from_string(flat, system="western").frequency
|
|
s = Tone.from_string(sharp, system="western").frequency
|
|
assert f == s, f"{flat} != {sharp}"
|
|
|
|
|
|
def test_flat_tone_arithmetic():
|
|
db = Tone.from_string("Db4", system="western")
|
|
result = db + 2
|
|
assert result.name == "D#"
|
|
assert result.octave == 4
|
|
|
|
|
|
def test_flat_tone_interval():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
db4 = Tone.from_string("Db4", system="western")
|
|
assert db4 - c4 == 1
|
|
|
|
|
|
def test_flat_tone_exists():
|
|
db = Tone.from_string("Db4", system="western")
|
|
assert db.exists is True
|
|
|
|
|
|
def test_flat_tone_index_resolves():
|
|
db = Tone.from_string("Db4", system="western")
|
|
cs = Tone.from_string("C#4", system="western")
|
|
assert db._index == cs._index
|
|
|
|
|
|
def test_flat_chord_from_tones():
|
|
chord = Chord.from_tones("Db", "F", "Ab")
|
|
assert chord.identify() == "Db major"
|
|
|
|
|
|
def test_flat_chord_from_tones_minor():
|
|
chord = Chord.from_tones("Bb", "Db", "F")
|
|
assert chord.identify() == "Bb minor"
|
|
|
|
|
|
def test_flat_chord_from_tones_seventh():
|
|
chord = Chord.from_tones("Eb", "G", "Bb", "Db")
|
|
assert chord.identify() == "Eb dominant 7th"
|
|
|
|
|
|
def test_system_resolve_name_sharp():
|
|
assert SYSTEMS["western"].resolve_name("C#") == "C#"
|
|
|
|
|
|
def test_system_resolve_name_flat():
|
|
assert SYSTEMS["western"].resolve_name("Db") == "C#"
|
|
|
|
|
|
def test_system_resolve_name_natural():
|
|
assert SYSTEMS["western"].resolve_name("C") == "C"
|
|
|
|
|
|
def test_system_resolve_name_unknown():
|
|
assert SYSTEMS["western"].resolve_name("X") is None
|
|
|
|
|
|
# ── CLI tests ─────────────────────────────────────────────────────────────────
|
|
|
|
def test_cli_tone(capsys):
|
|
from pytheory.cli import cmd_tone
|
|
import argparse
|
|
args = argparse.Namespace(note="A4", temperament="equal")
|
|
cmd_tone(args)
|
|
out = capsys.readouterr().out
|
|
assert "440.00" in out
|
|
assert "A4" in out
|
|
assert "MIDI" in out
|
|
|
|
|
|
def test_cli_tone_pythagorean(capsys):
|
|
from pytheory.cli import cmd_tone
|
|
import argparse
|
|
args = argparse.Namespace(note="C5", temperament="pythagorean")
|
|
cmd_tone(args)
|
|
out = capsys.readouterr().out
|
|
assert "Equal temp" in out
|
|
assert "cents" in out
|
|
|
|
|
|
def test_cli_scale(capsys):
|
|
from pytheory.cli import cmd_scale
|
|
import argparse
|
|
args = argparse.Namespace(tonic="C", mode="major", system="western")
|
|
cmd_scale(args)
|
|
out = capsys.readouterr().out
|
|
assert "C D E F G A B C" in out
|
|
|
|
|
|
def test_cli_chord(capsys):
|
|
from pytheory.cli import cmd_chord
|
|
import argparse
|
|
args = argparse.Namespace(notes=["C", "E", "G"])
|
|
cmd_chord(args)
|
|
out = capsys.readouterr().out
|
|
assert "C major" in out
|
|
assert "Harmony" in out
|
|
assert "Tension" in out
|
|
|
|
|
|
def test_cli_key(capsys):
|
|
from pytheory.cli import cmd_key
|
|
import argparse
|
|
args = argparse.Namespace(tonic="G", mode="major")
|
|
cmd_key(args)
|
|
out = capsys.readouterr().out
|
|
assert "G major" in out
|
|
assert "Signature" in out
|
|
assert "Relative" in out
|
|
|
|
|
|
def test_cli_fingering(capsys):
|
|
from pytheory.cli import cmd_fingering
|
|
import argparse
|
|
args = argparse.Namespace(chord="Am", capo=0)
|
|
cmd_fingering(args)
|
|
out = capsys.readouterr().out
|
|
assert "Am" in out
|
|
assert "|--" in out
|
|
|
|
|
|
def test_cli_progression(capsys):
|
|
from pytheory.cli import cmd_progression
|
|
import argparse
|
|
args = argparse.Namespace(tonic="C", mode="major", numerals=["I", "V", "vi", "IV"])
|
|
cmd_progression(args)
|
|
out = capsys.readouterr().out
|
|
assert "C major" in out
|
|
assert "I → V → vi → IV" in out
|
|
|
|
|
|
def test_cli_detect(capsys):
|
|
from pytheory.cli import cmd_detect
|
|
import argparse
|
|
args = argparse.Namespace(notes=["C", "E", "G", "A", "D"])
|
|
cmd_detect(args)
|
|
out = capsys.readouterr().out
|
|
assert "C major" in out
|
|
|
|
|
|
def test_cli_detect_no_match(capsys):
|
|
from pytheory.cli import cmd_detect
|
|
import argparse
|
|
args = argparse.Namespace(notes=[])
|
|
cmd_detect(args)
|
|
out = capsys.readouterr().out
|
|
assert "Could not detect" in out
|
|
|
|
|
|
def test_cli_main_no_args(capsys):
|
|
from pytheory.cli import main
|
|
import sys
|
|
old_argv = sys.argv
|
|
sys.argv = ["pytheory"]
|
|
try:
|
|
main()
|
|
except SystemExit:
|
|
pass
|
|
sys.argv = old_argv
|
|
|
|
|
|
# ── Play module tests ─────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_play_render():
|
|
"""_render produces a numpy array of the right length."""
|
|
from pytheory.play import _render, Synth, SAMPLE_RATE
|
|
tone = Tone.from_string("A4", system="western")
|
|
samples = _render(tone, synth=Synth.SINE, t=500)
|
|
expected = int(SAMPLE_RATE * 500 / 1000)
|
|
assert len(samples) == expected
|
|
|
|
|
|
@needs_portaudio
|
|
def test_play_render_chord():
|
|
from pytheory.play import _render, Synth
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
samples = _render(chord, synth=Synth.SINE, t=200)
|
|
assert len(samples) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_play_render_all_synths():
|
|
from pytheory.play import _render, Synth
|
|
tone = Tone.from_string("C4", system="western")
|
|
for synth in Synth:
|
|
samples = _render(tone, synth=synth, t=100)
|
|
assert len(samples) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_play_save(tmp_path):
|
|
"""save() writes a valid WAV file."""
|
|
from pytheory.play import save, Synth
|
|
path = tmp_path / "test.wav"
|
|
tone = Tone.from_string("A4", system="western")
|
|
save(tone, str(path), synth=Synth.SINE, t=200)
|
|
assert path.exists()
|
|
assert path.stat().st_size > 44 # WAV header is 44 bytes
|
|
|
|
|
|
@needs_portaudio
|
|
def test_play_save_chord(tmp_path):
|
|
from pytheory.play import save
|
|
path = tmp_path / "chord.wav"
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
save(chord, str(path), t=200)
|
|
assert path.exists()
|
|
|
|
|
|
# ── Chord.symbol ────────────────────────────────────────────────────────────
|
|
|
|
def test_chord_symbol_major():
|
|
c = Chord.from_tones("C", "E", "G")
|
|
assert c.symbol == "C"
|
|
|
|
|
|
def test_chord_symbol_minor():
|
|
c = Chord.from_tones("A", "C", "E")
|
|
assert c.symbol == "Am"
|
|
|
|
|
|
def test_chord_symbol_dominant_7th():
|
|
c = Chord.from_intervals("G", 4, 7, 10)
|
|
assert c.symbol == "G7"
|
|
|
|
|
|
def test_chord_symbol_major_7th():
|
|
c = Chord.from_intervals("C", 4, 7, 11)
|
|
assert c.symbol == "Cmaj7"
|
|
|
|
|
|
def test_chord_symbol_minor_7th():
|
|
c = Chord.from_intervals("D", 3, 7, 10)
|
|
assert c.symbol == "Dm7"
|
|
|
|
|
|
def test_chord_symbol_diminished():
|
|
c = Chord.from_intervals("B", 3, 6)
|
|
assert c.symbol == "Bdim"
|
|
|
|
|
|
def test_chord_symbol_augmented():
|
|
c = Chord.from_intervals("C", 4, 8)
|
|
assert c.symbol == "Caug"
|
|
|
|
|
|
def test_chord_symbol_sus2():
|
|
c = Chord.from_intervals("C", 2, 7)
|
|
assert c.symbol == "Csus2"
|
|
|
|
|
|
def test_chord_symbol_sus4():
|
|
c = Chord.from_intervals("C", 5, 7)
|
|
assert c.symbol == "Csus4"
|
|
|
|
|
|
def test_chord_symbol_power():
|
|
c = Chord.from_intervals("C", 7)
|
|
assert c.symbol == "C5"
|
|
|
|
|
|
def test_chord_symbol_half_diminished():
|
|
c = Chord.from_intervals("B", 3, 6, 10)
|
|
assert c.symbol == "Bm7b5"
|
|
|
|
|
|
def test_chord_symbol_dim7():
|
|
c = Chord.from_intervals("B", 3, 6, 9)
|
|
assert c.symbol == "Bdim7"
|
|
|
|
|
|
def test_chord_symbol_unidentifiable():
|
|
c = Chord.from_intervals("C", 1)
|
|
assert c.symbol is None
|
|
|
|
|
|
# ── Key.common_progressions ─────────────────────────────────────────────────
|
|
|
|
def test_common_progressions_returns_dict():
|
|
key = Key("C", "major")
|
|
progs = key.common_progressions()
|
|
assert isinstance(progs, dict)
|
|
assert len(progs) > 0
|
|
|
|
|
|
def test_common_progressions_contains_known():
|
|
key = Key("C", "major")
|
|
progs = key.common_progressions()
|
|
assert "I-V-vi-IV" in progs
|
|
assert "12-bar blues" in progs
|
|
assert "ii-V-I" in progs
|
|
|
|
|
|
def test_common_progressions_chords_are_correct():
|
|
key = Key("G", "major")
|
|
progs = key.common_progressions()
|
|
chords = progs["I-IV-V-I"]
|
|
symbols = [c.symbol for c in chords]
|
|
assert symbols == ["G", "C", "D", "G"]
|
|
|
|
|
|
def test_common_progressions_i_v_vi_iv():
|
|
key = Key("C", "major")
|
|
progs = key.common_progressions()
|
|
chords = progs["I-V-vi-IV"]
|
|
symbols = [c.symbol for c in chords]
|
|
assert symbols == ["C", "G", "Am", "F"]
|
|
|
|
|
|
# ── CLI: modes, circle, progressions ────────────────────────────────────────
|
|
|
|
def test_cli_modes(capsys):
|
|
from pytheory.cli import cmd_modes
|
|
import argparse
|
|
args = argparse.Namespace(tonic="C", system="western")
|
|
cmd_modes(args)
|
|
out = capsys.readouterr().out
|
|
assert "ionian" in out
|
|
assert "dorian" in out
|
|
assert "locrian" in out
|
|
|
|
|
|
def test_cli_circle(capsys):
|
|
from pytheory.cli import cmd_circle
|
|
import argparse
|
|
args = argparse.Namespace(tonic="C")
|
|
cmd_circle(args)
|
|
out = capsys.readouterr().out
|
|
assert "Circle of fifths" in out
|
|
assert "Circle of fourths" in out
|
|
assert "G" in out
|
|
assert "F" in out
|
|
|
|
|
|
def test_cli_progressions(capsys):
|
|
from pytheory.cli import cmd_progressions
|
|
import argparse
|
|
args = argparse.Namespace(tonic="C", mode="major")
|
|
cmd_progressions(args)
|
|
out = capsys.readouterr().out
|
|
assert "I-V-vi-IV" in out
|
|
assert "C" in out
|
|
|
|
|
|
# ── Chord.from_symbol ───────────────────────────────────────────────────────
|
|
|
|
def test_from_symbol_major():
|
|
c = Chord.from_symbol("C")
|
|
assert c.identify() == "C major"
|
|
|
|
|
|
def test_from_symbol_minor():
|
|
c = Chord.from_symbol("Am")
|
|
assert c.identify() == "A minor"
|
|
|
|
|
|
def test_from_symbol_dominant_7th():
|
|
c = Chord.from_symbol("G7")
|
|
assert c.identify() == "G dominant 7th"
|
|
|
|
|
|
def test_from_symbol_major_7th():
|
|
c = Chord.from_symbol("Cmaj7")
|
|
assert c.identify() == "C major 7th"
|
|
|
|
|
|
def test_from_symbol_minor_7th():
|
|
c = Chord.from_symbol("Dm7")
|
|
assert c.identify() == "D minor 7th"
|
|
|
|
|
|
def test_from_symbol_diminished():
|
|
c = Chord.from_symbol("Bdim")
|
|
assert c.identify() == "B diminished"
|
|
|
|
|
|
def test_from_symbol_augmented():
|
|
c = Chord.from_symbol("Caug")
|
|
assert c.identify() == "C augmented"
|
|
|
|
|
|
def test_from_symbol_sus4():
|
|
c = Chord.from_symbol("Csus4")
|
|
assert c.identify() == "C sus4"
|
|
|
|
|
|
def test_from_symbol_sus2():
|
|
c = Chord.from_symbol("Dsus2")
|
|
assert c.identify() == "D sus2"
|
|
|
|
|
|
def test_from_symbol_power():
|
|
c = Chord.from_symbol("C5")
|
|
assert c.identify() == "C power"
|
|
|
|
|
|
def test_from_symbol_half_diminished():
|
|
c = Chord.from_symbol("Bm7b5")
|
|
assert c.identify() == "B half-diminished 7th"
|
|
|
|
|
|
def test_from_symbol_flat_root():
|
|
c = Chord.from_symbol("Bbmaj7")
|
|
assert c.symbol == "Bbmaj7"
|
|
|
|
|
|
def test_from_symbol_sharp_root():
|
|
c = Chord.from_symbol("F#m")
|
|
assert c.identify() == "F# minor"
|
|
|
|
|
|
def test_from_symbol_dim7():
|
|
c = Chord.from_symbol("Cdim7")
|
|
assert c.identify() == "C diminished 7th"
|
|
|
|
|
|
def test_from_symbol_9th():
|
|
c = Chord.from_symbol("G9")
|
|
assert c.identify() == "G dominant 9th"
|
|
|
|
|
|
def test_from_symbol_roundtrip():
|
|
"""from_symbol → symbol should round-trip."""
|
|
for sym in ["C", "Am", "G7", "Dmaj7", "Em7", "Bdim", "Fsus4"]:
|
|
c = Chord.from_symbol(sym)
|
|
assert c.symbol == sym, f"Round-trip failed for {sym}: got {c.symbol}"
|
|
|
|
|
|
def test_from_symbol_invalid_raises():
|
|
with pytest.raises(ValueError):
|
|
Chord.from_symbol("Xmaj7")
|
|
|
|
|
|
def test_from_symbol_unknown_quality_raises():
|
|
with pytest.raises(ValueError):
|
|
Chord.from_symbol("Czzz")
|
|
|
|
|
|
# ── Tone.cents_difference ──────────────────────────────────────────────────
|
|
|
|
def test_cents_semitone():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
bb4 = a4 + 1
|
|
cents = a4.cents_difference(bb4)
|
|
assert abs(cents - 100.0) < 0.01
|
|
|
|
|
|
def test_cents_octave():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
a5 = Tone.from_string("A5", system="western")
|
|
cents = a4.cents_difference(a5)
|
|
assert abs(cents - 1200.0) < 0.01
|
|
|
|
|
|
def test_cents_unison():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
assert abs(a4.cents_difference(a4)) < 0.01
|
|
|
|
|
|
def test_cents_negative():
|
|
a4 = Tone.from_string("A4", system="western")
|
|
g4 = a4 - 2
|
|
cents = a4.cents_difference(g4)
|
|
assert cents < 0
|
|
|
|
|
|
def test_cents_fifth():
|
|
c4 = Tone.from_string("C4", system="western")
|
|
g4 = c4 + 7
|
|
cents = c4.cents_difference(g4)
|
|
assert abs(cents - 700.0) < 0.01
|
|
|
|
|
|
# ── Key.pivot_chords ───────────────────────────────────────────────────────
|
|
|
|
def test_pivot_chords_closely_related():
|
|
c = Key("C", "major")
|
|
g = Key("G", "major")
|
|
pivots = c.pivot_chords(g)
|
|
assert len(pivots) > 0
|
|
assert "G major" in pivots
|
|
assert "E minor" in pivots
|
|
|
|
|
|
def test_pivot_chords_same_key():
|
|
c = Key("C", "major")
|
|
pivots = c.pivot_chords(c)
|
|
assert set(pivots) == set(c.chords)
|
|
|
|
|
|
def test_pivot_chords_distant_keys():
|
|
c = Key("C", "major")
|
|
fs = Key("F#", "major")
|
|
pivots = c.pivot_chords(fs)
|
|
assert len(pivots) < len(c.chords)
|
|
|
|
|
|
# ── Scale.parallel_modes ───────────────────────────────────────────────────
|
|
|
|
def test_parallel_modes_c_major():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
modes = c.parallel_modes()
|
|
assert "C ionian" in modes
|
|
assert "D dorian" in modes
|
|
assert "E phrygian" in modes
|
|
assert "A aeolian" in modes
|
|
assert len(modes) == 7
|
|
|
|
|
|
def test_parallel_modes_share_notes():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
modes = c.parallel_modes()
|
|
c_notes = set(modes["C ionian"][:-1])
|
|
for name, notes in modes.items():
|
|
assert set(notes[:-1]) == c_notes, f"{name} has different notes"
|
|
|
|
|
|
def test_parallel_modes_g_major():
|
|
g = TonedScale(tonic="G4")["major"]
|
|
modes = g.parallel_modes()
|
|
assert "G ionian" in modes
|
|
assert "A dorian" in modes
|
|
|
|
|
|
# ── ADSR envelope ──────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_envelope_enum_presets():
|
|
from pytheory.play import Envelope
|
|
assert len(Envelope) == 10
|
|
for e in Envelope:
|
|
a, d, s, r = e.value
|
|
assert a >= 0
|
|
assert d >= 0
|
|
assert 0 <= s <= 1.0
|
|
assert r >= 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_envelope_applied_to_render():
|
|
from pytheory.play import _render, Envelope
|
|
tone = Tone.from_string("A4", system="western")
|
|
raw = _render(tone, t=500, envelope=Envelope.NONE)
|
|
shaped = _render(tone, t=500, envelope=Envelope.PIANO)
|
|
# Shaped signal should start quieter (attack) and end quieter (release)
|
|
assert abs(float(shaped[0])) < abs(float(raw[0])) + 1
|
|
assert abs(float(shaped[-1])) < abs(float(raw[-1])) + 1
|
|
|
|
|
|
@needs_portaudio
|
|
def test_envelope_none_is_raw():
|
|
from pytheory.play import _render, Envelope
|
|
tone = Tone.from_string("A4", system="western")
|
|
raw = _render(tone, t=200, envelope=Envelope.NONE)
|
|
# With NONE envelope, first sample should be non-zero (no attack fade)
|
|
assert raw.dtype in (numpy.int16, numpy.float32)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_all_envelopes_render():
|
|
from pytheory.play import _render, Envelope
|
|
tone = Tone.from_string("C4", system="western")
|
|
for e in Envelope:
|
|
samples = _render(tone, t=200, envelope=e)
|
|
assert len(samples) > 0
|
|
|
|
|
|
# ── C_INDEX constant ───────────────────────────────────────────────────────
|
|
|
|
def test_c_index_constant():
|
|
from pytheory._statics import C_INDEX
|
|
assert C_INDEX == 3
|
|
|
|
|
|
# ── Scale.fitness ──────────────────────────────────────────────────────────
|
|
|
|
def test_fitness_perfect():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness("C", "D", "E", "F", "G") == 1.0
|
|
|
|
|
|
def test_fitness_partial():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness("C", "D", "F#", "G") == 0.75
|
|
|
|
|
|
def test_fitness_none():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness("C#", "D#", "F#") == 0.0
|
|
|
|
|
|
def test_fitness_empty():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness() == 0.0
|
|
|
|
|
|
def test_fitness_single_match():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness("C") == 1.0
|
|
|
|
|
|
def test_fitness_single_miss():
|
|
c = TonedScale(tonic="C4")["major"]
|
|
assert c.fitness("C#") == 0.0
|
|
|
|
|
|
# ── Key.suggest_next ───────────────────────────────────────────────────────
|
|
|
|
def test_suggest_next_v_resolves_to_i():
|
|
key = Key("C", "major")
|
|
g_major = key.triad(4) # V
|
|
suggestions = key.suggest_next(g_major)
|
|
assert len(suggestions) > 0
|
|
assert suggestions[0].identify() == "C major" # V → I
|
|
|
|
|
|
def test_suggest_next_ii_goes_to_v():
|
|
key = Key("C", "major")
|
|
dm = key.triad(1) # ii
|
|
suggestions = key.suggest_next(dm)
|
|
assert suggestions[0].identify() == "G major" # ii → V
|
|
|
|
|
|
def test_suggest_next_iv():
|
|
key = Key("C", "major")
|
|
f_major = key.triad(3) # IV
|
|
suggestions = key.suggest_next(f_major)
|
|
assert suggestions[0].identify() == "G major" # IV → V
|
|
|
|
|
|
def test_suggest_next_returns_chords():
|
|
key = Key("G", "major")
|
|
for i in range(7):
|
|
chord = key.triad(i)
|
|
suggestions = key.suggest_next(chord)
|
|
assert len(suggestions) > 0
|
|
for s in suggestions:
|
|
assert s.identify() is not None
|
|
|
|
|
|
# ── Tone.helmholtz ─────────────────────────────────────────────────────────
|
|
|
|
def test_helmholtz_middle_c():
|
|
assert Tone.from_string("C4", system="western").helmholtz == "c"
|
|
|
|
|
|
def test_helmholtz_c3():
|
|
assert Tone.from_string("C3", system="western").helmholtz == "C"
|
|
|
|
|
|
def test_helmholtz_c5():
|
|
assert Tone.from_string("C5", system="western").helmholtz == "c'"
|
|
|
|
|
|
def test_helmholtz_c6():
|
|
assert Tone.from_string("C6", system="western").helmholtz == "c''"
|
|
|
|
|
|
def test_helmholtz_c2():
|
|
assert Tone.from_string("C2", system="western").helmholtz == "CC"
|
|
|
|
|
|
def test_helmholtz_a2():
|
|
assert Tone.from_string("A2", system="western").helmholtz == "AA"
|
|
|
|
|
|
def test_helmholtz_sharp():
|
|
assert Tone.from_string("C#4", system="western").helmholtz == "c#"
|
|
|
|
|
|
def test_helmholtz_sharp_high():
|
|
assert Tone.from_string("F#5", system="western").helmholtz == "f#'"
|
|
|
|
|
|
def test_scientific_is_full_name():
|
|
t = Tone.from_string("A4", system="western")
|
|
assert t.scientific == t.full_name
|
|
|
|
|
|
# ── Chord.slash ────────────────────────────────────────────────────────────
|
|
|
|
def test_slash_chord():
|
|
c = Chord.from_symbol("C")
|
|
c_over_g = c.slash("G")
|
|
assert len(c_over_g.tones) == 4
|
|
assert c_over_g.tones[0].name == "G"
|
|
|
|
|
|
def test_slash_name_different_bass():
|
|
c = Chord.from_symbol("C")
|
|
c_over_e = c.slash("E")
|
|
assert c_over_e.slash_name == "C/E"
|
|
|
|
|
|
def test_slash_name_root_bass():
|
|
c = Chord.from_symbol("C")
|
|
c_over_c = c.slash("C")
|
|
assert c_over_c.slash_name == "C"
|
|
|
|
|
|
def test_slash_chord_custom_octave():
|
|
c = Chord.from_symbol("C")
|
|
c_over_g2 = c.slash("G", octave=2)
|
|
assert c_over_g2.tones[0].octave == 2
|
|
|
|
|
|
# ── Borrowed chord analysis (bVI, bVII, etc.) ─────────────────────────────
|
|
|
|
def test_analyze_borrowed_bvi():
|
|
ab = Chord.from_symbol("Ab")
|
|
result = ab.analyze("C", "major")
|
|
assert result is not None
|
|
assert "b" in result.lower() or "VI" in result
|
|
|
|
|
|
def test_analyze_borrowed_bvii():
|
|
bb = Chord.from_symbol("Bb")
|
|
result = bb.analyze("C", "major")
|
|
assert result is not None
|
|
assert "b" in result.lower() or "VII" in result
|
|
|
|
|
|
def test_analyze_diatonic_still_works():
|
|
c = Chord.from_symbol("C")
|
|
assert c.analyze("C", "major") == "I"
|
|
g = Chord.from_symbol("G")
|
|
assert g.analyze("C", "major") == "V"
|
|
dm = Chord.from_symbol("Dm")
|
|
assert dm.analyze("C", "major") == "ii"
|
|
|
|
|
|
# ── Fretboard.scale_diagram with chord highlighting ───────────────────────
|
|
|
|
def test_scale_diagram_chord_highlight():
|
|
fb = Fretboard.guitar()
|
|
scale = TonedScale(tonic="A4")["minor"]
|
|
am = Chord.from_symbol("Am")
|
|
diagram = fb.scale_diagram(scale, frets=5, chord=am)
|
|
# Chord tones (A, C, E) should be uppercase
|
|
assert "A " in diagram or "A|" in diagram
|
|
assert "C " in diagram
|
|
assert "E " in diagram
|
|
# Non-chord scale tones should be lowercase
|
|
assert "d " in diagram or "d|" in diagram
|
|
|
|
|
|
def test_scale_diagram_no_chord_unchanged():
|
|
fb = Fretboard.guitar()
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
diagram = fb.scale_diagram(scale, frets=3)
|
|
# Without chord arg, should have normal case
|
|
assert "C " in diagram
|
|
assert "E " in diagram
|
|
|
|
|
|
# ── MIDI export ────────────────────────────────────────────────────────────
|
|
|
|
def test_save_midi_tone(tmp_path):
|
|
from pytheory.play import save_midi
|
|
path = tmp_path / "tone.mid"
|
|
tone = Tone.from_string("C4", system="western")
|
|
save_midi(tone, str(path))
|
|
assert path.exists()
|
|
data = path.read_bytes()
|
|
assert data[:4] == b'MThd'
|
|
|
|
|
|
def test_save_midi_chord(tmp_path):
|
|
from pytheory.play import save_midi
|
|
path = tmp_path / "chord.mid"
|
|
chord = Chord.from_symbol("Am")
|
|
save_midi(chord, str(path))
|
|
assert path.exists()
|
|
data = path.read_bytes()
|
|
assert data[:4] == b'MThd'
|
|
|
|
|
|
def test_save_midi_progression(tmp_path):
|
|
from pytheory.play import save_midi
|
|
path = tmp_path / "prog.mid"
|
|
chords = Key("C", "major").progression("I", "V", "vi", "IV")
|
|
save_midi(chords, str(path), t=500, bpm=120)
|
|
assert path.exists()
|
|
assert path.stat().st_size > 14 # header is 14 bytes
|
|
|
|
|
|
def test_save_midi_with_gap(tmp_path):
|
|
from pytheory.play import save_midi
|
|
path = tmp_path / "gap.mid"
|
|
chords = Key("G", "major").progression("I", "IV", "V", "I")
|
|
save_midi(chords, str(path), gap=100)
|
|
assert path.exists()
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 1: Drop voicings on Chord class
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_close_voicing_c_major():
|
|
"""Close voicing packs tones within one octave."""
|
|
chord = Chord.from_symbol("C")
|
|
inv = chord.inversion(1) # E4, G4, C5
|
|
closed = inv.close_voicing()
|
|
# Should be identifiable as C major
|
|
assert closed.identify() == "C major"
|
|
# All tones within one octave of root
|
|
root = closed.tones[0]
|
|
for t in closed.tones[1:]:
|
|
diff = abs(t - root)
|
|
assert diff <= 12
|
|
|
|
|
|
def test_close_voicing_seventh():
|
|
chord = Chord.from_symbol("Cmaj7").inversion(2)
|
|
closed = chord.close_voicing()
|
|
assert closed.identify() == "C major 7th"
|
|
|
|
|
|
def test_open_voicing_c_major():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
opened = chord.open_voicing()
|
|
assert len(opened.tones) == 4
|
|
# The spread should be wider than close voicing for 4+ tones
|
|
closed = chord.close_voicing()
|
|
close_span = abs(closed.tones[-1] - closed.tones[0])
|
|
open_span = max(t.pitch() for t in opened.tones) - min(t.pitch() for t in opened.tones)
|
|
close_span_hz = max(t.pitch() for t in closed.tones) - min(t.pitch() for t in closed.tones)
|
|
assert open_span > close_span_hz
|
|
|
|
|
|
def test_open_voicing_seventh():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
opened = chord.open_voicing()
|
|
assert len(opened.tones) == 4
|
|
|
|
|
|
def test_drop2_voicing():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
d2 = chord.drop2()
|
|
assert len(d2.tones) == 4
|
|
# The lowest tone should be below the original root
|
|
assert d2.tones[0] < chord.tones[0]
|
|
|
|
|
|
def test_drop2_identifies_same():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
d2 = chord.drop2()
|
|
assert d2.identify() == "C major 7th"
|
|
|
|
|
|
def test_drop3_voicing():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
d3 = chord.drop3()
|
|
assert len(d3.tones) == 4
|
|
# The lowest tone should be below the original root
|
|
assert d3.tones[0] < chord.tones[0]
|
|
|
|
|
|
def test_drop3_identifies_same():
|
|
chord = Chord.from_symbol("Cmaj7")
|
|
d3 = chord.drop3()
|
|
assert d3.identify() == "C major 7th"
|
|
|
|
|
|
def test_drop2_small_chord():
|
|
"""Drop2 on a single-tone chord returns it unchanged."""
|
|
chord = Chord(tones=[Tone.from_string("C4", system="western")])
|
|
d2 = chord.drop2()
|
|
assert len(d2.tones) == 1
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 2: Key.modulation_path(target)
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_modulation_path_close_keys():
|
|
"""C major to G major — closely related, should find pivot chord."""
|
|
path = Key("C", "major").modulation_path(Key("G", "major"))
|
|
assert len(path) == 4 # I, pivot, V, I
|
|
assert path[0].identify() == "C major"
|
|
assert path[-1].identify() == "G major"
|
|
|
|
|
|
def test_modulation_path_returns_chords():
|
|
path = Key("C", "major").modulation_path(Key("F", "major"))
|
|
for chord in path:
|
|
assert isinstance(chord, Chord)
|
|
|
|
|
|
def test_modulation_path_distant_keys():
|
|
"""C major to F# major — distant, may use chromatic approach."""
|
|
path = Key("C", "major").modulation_path(Key("F#", "major"))
|
|
assert len(path) >= 3
|
|
assert path[0].identify() == "C major"
|
|
assert path[-1].identify() == "F# major"
|
|
|
|
|
|
def test_modulation_path_same_key():
|
|
"""Modulating to the same key should still return a path."""
|
|
path = Key("C", "major").modulation_path(Key("C", "major"))
|
|
assert len(path) >= 3
|
|
assert path[0].identify() == "C major"
|
|
assert path[-1].identify() == "C major"
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 3: Scale.degree_name(n)
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_degree_name_tonic():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
assert scale.degree_name(0) == "tonic"
|
|
|
|
|
|
def test_degree_name_dominant():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
assert scale.degree_name(4) == "dominant"
|
|
|
|
|
|
def test_degree_name_leading_tone():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
assert scale.degree_name(6) == "leading tone"
|
|
|
|
|
|
def test_degree_name_subtonic_minor():
|
|
scale = TonedScale(tonic="C4")["minor"]
|
|
assert scale.degree_name(6, minor=True) == "subtonic"
|
|
|
|
|
|
def test_degree_name_all_major():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
expected = ["tonic", "supertonic", "mediant", "subdominant",
|
|
"dominant", "submediant", "leading tone"]
|
|
for i, name in enumerate(expected):
|
|
assert scale.degree_name(i) == name
|
|
|
|
|
|
def test_degree_name_out_of_range():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
assert scale.degree_name(10) == "degree 10"
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 4: Chord.extensions()
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_extensions_c_major_triad():
|
|
chord = Chord.from_symbol("C")
|
|
exts = chord.extensions()
|
|
ext_names = [t.name for t in exts]
|
|
# 9th (D) and 13th (A) should be available; 11th (F) is avoid note on major
|
|
assert "D" in ext_names
|
|
assert "A" in ext_names
|
|
|
|
|
|
def test_extensions_returns_tones():
|
|
chord = Chord.from_symbol("C")
|
|
exts = chord.extensions()
|
|
for t in exts:
|
|
assert isinstance(t, Tone)
|
|
|
|
|
|
def test_extensions_with_scale():
|
|
scale = TonedScale(tonic="C4")["major"]
|
|
chord = Chord.from_symbol("C")
|
|
exts = chord.extensions(scale=scale)
|
|
ext_names = [t.name for t in exts]
|
|
# D, F, A are all in C major scale
|
|
assert "D" in ext_names
|
|
assert "A" in ext_names
|
|
|
|
|
|
def test_extensions_minor_chord():
|
|
chord = Chord.from_symbol("Am")
|
|
exts = chord.extensions()
|
|
# Should return some extensions
|
|
assert len(exts) >= 1
|
|
|
|
|
|
def test_extensions_empty_chord():
|
|
chord = Chord(tones=[])
|
|
exts = chord.extensions()
|
|
assert exts == []
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 5: CLI identify command
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_cli_identify_cmaj7(capsys):
|
|
from pytheory.cli import cmd_identify
|
|
import argparse
|
|
args = argparse.Namespace(symbol="Cmaj7")
|
|
cmd_identify(args)
|
|
out = capsys.readouterr().out
|
|
assert "C major 7th" in out
|
|
assert "Symbol" in out
|
|
assert "Tones" in out
|
|
assert "Harmony" in out
|
|
|
|
|
|
def test_cli_identify_am(capsys):
|
|
from pytheory.cli import cmd_identify
|
|
import argparse
|
|
args = argparse.Namespace(symbol="Am")
|
|
cmd_identify(args)
|
|
out = capsys.readouterr().out
|
|
assert "A minor" in out
|
|
|
|
|
|
def test_cli_identify_g7(capsys):
|
|
from pytheory.cli import cmd_identify
|
|
import argparse
|
|
args = argparse.Namespace(symbol="G7")
|
|
cmd_identify(args)
|
|
out = capsys.readouterr().out
|
|
assert "G dominant 7th" in out
|
|
assert "Tension" in out
|
|
assert "Dissonance" in out
|
|
|
|
|
|
def test_cli_identify_intervals(capsys):
|
|
from pytheory.cli import cmd_identify
|
|
import argparse
|
|
args = argparse.Namespace(symbol="C")
|
|
cmd_identify(args)
|
|
out = capsys.readouterr().out
|
|
assert "Intervals" in out
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 6: CLI midi command
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_cli_midi_basic(capsys, tmp_path):
|
|
from pytheory.cli import cmd_midi
|
|
import argparse
|
|
outfile = str(tmp_path / "test.mid")
|
|
args = argparse.Namespace(
|
|
tonic="C", mode="major", numerals=["I", "V", "vi", "IV"],
|
|
output=outfile, bpm=120, duration=500
|
|
)
|
|
cmd_midi(args)
|
|
out = capsys.readouterr().out
|
|
assert "C major" in out
|
|
assert "Output" in out
|
|
import os
|
|
assert os.path.exists(outfile)
|
|
|
|
|
|
def test_cli_midi_custom_bpm(capsys, tmp_path):
|
|
from pytheory.cli import cmd_midi
|
|
import argparse
|
|
outfile = str(tmp_path / "test_bpm.mid")
|
|
args = argparse.Namespace(
|
|
tonic="G", mode="major", numerals=["I", "IV", "V"],
|
|
output=outfile, bpm=90, duration=750
|
|
)
|
|
cmd_midi(args)
|
|
out = capsys.readouterr().out
|
|
assert "90" in out
|
|
|
|
|
|
def test_cli_midi_file_content(tmp_path):
|
|
from pytheory.cli import cmd_midi
|
|
import argparse
|
|
outfile = str(tmp_path / "content.mid")
|
|
args = argparse.Namespace(
|
|
tonic="C", mode="major", numerals=["I", "V"],
|
|
output=outfile, bpm=120, duration=500
|
|
)
|
|
cmd_midi(args)
|
|
data = (tmp_path / "content.mid").read_bytes()
|
|
assert data[:4] == b'MThd'
|
|
|
|
|
|
def test_cli_midi_minor(capsys, tmp_path):
|
|
from pytheory.cli import cmd_midi
|
|
import argparse
|
|
outfile = str(tmp_path / "minor.mid")
|
|
args = argparse.Namespace(
|
|
tonic="A", mode="minor", numerals=["i", "IV", "V"],
|
|
output=outfile, bpm=120, duration=500
|
|
)
|
|
cmd_midi(args)
|
|
out = capsys.readouterr().out
|
|
assert "A minor" in out
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
# Feature 7: Tone.solfege property
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
|
|
|
def test_solfege_natural_notes():
|
|
expected = {"C": "Do", "D": "Re", "E": "Mi", "F": "Fa",
|
|
"G": "Sol", "A": "La", "B": "Ti"}
|
|
for note, solf in expected.items():
|
|
t = Tone.from_string(f"{note}4", system="western")
|
|
assert t.solfege == solf, f"{note} should be {solf}, got {t.solfege}"
|
|
|
|
|
|
def test_solfege_sharps():
|
|
expected = {"C#": "Di", "D#": "Ri", "F#": "Fi", "G#": "Si", "A#": "Li"}
|
|
for note, solf in expected.items():
|
|
t = Tone.from_string(f"{note}4", system="western")
|
|
assert t.solfege == solf, f"{note} should be {solf}, got {t.solfege}"
|
|
|
|
|
|
def test_solfege_flats():
|
|
expected = {"Db": "Ra", "Eb": "Me", "Gb": "Se", "Ab": "Le", "Bb": "Te"}
|
|
for note, solf in expected.items():
|
|
t = Tone(name=note, octave=4, system="western")
|
|
assert t.solfege == solf, f"{note} should be {solf}, got {t.solfege}"
|
|
|
|
|
|
def test_solfege_no_octave():
|
|
t = Tone(name="C", system="western")
|
|
assert t.solfege == "Do"
|
|
|
|
|
|
def test_solfege_unknown_raises():
|
|
"""A non-standard name should raise ValueError at construction (fixes #39)."""
|
|
import pytest
|
|
with pytest.raises(ValueError, match="Unknown tone name"):
|
|
Tone(name="X", system="western")
|
|
|
|
|
|
# ── Rhythm / Duration system ────────────────────────────────────────────────
|
|
|
|
from pytheory.rhythm import Duration, TimeSignature, Note as RhythmNote, Rest, Score
|
|
|
|
|
|
def test_duration_values():
|
|
assert Duration.WHOLE.value == 4.0
|
|
assert Duration.HALF.value == 2.0
|
|
assert Duration.QUARTER.value == 1.0
|
|
assert Duration.EIGHTH.value == 0.5
|
|
assert Duration.SIXTEENTH.value == 0.25
|
|
assert Duration.DOTTED_HALF.value == 3.0
|
|
assert Duration.DOTTED_QUARTER.value == 1.5
|
|
assert abs(Duration.TRIPLET_QUARTER.value - 2 / 3) < 1e-9
|
|
|
|
|
|
def test_duration_arithmetic():
|
|
# Multiplication
|
|
assert Duration.WHOLE * 2 == 8.0
|
|
assert 2 * Duration.HALF == 4.0
|
|
assert Duration.QUARTER * 3 == 3.0
|
|
# Division
|
|
assert Duration.WHOLE / 2 == 2.0
|
|
# Addition
|
|
assert Duration.HALF + Duration.QUARTER == 3.0
|
|
assert Duration.HALF + 1.0 == 3.0
|
|
assert 1.0 + Duration.HALF == 3.0
|
|
|
|
|
|
def test_time_signature_from_string_4_4():
|
|
ts = TimeSignature.from_string("4/4")
|
|
assert ts.beats == 4
|
|
assert ts.unit == 4
|
|
assert ts.beats_per_measure == 4.0
|
|
|
|
|
|
def test_time_signature_from_string_3_4():
|
|
ts = TimeSignature.from_string("3/4")
|
|
assert ts.beats == 3
|
|
assert ts.unit == 4
|
|
assert ts.beats_per_measure == 3.0
|
|
|
|
|
|
def test_time_signature_from_string_6_8():
|
|
ts = TimeSignature.from_string("6/8")
|
|
assert ts.beats == 6
|
|
assert ts.unit == 8
|
|
assert ts.beats_per_measure == 3.0 # 6 * (4/8) = 3
|
|
|
|
|
|
def test_time_signature_repr():
|
|
assert repr(TimeSignature(3, 4)) == "3/4"
|
|
|
|
|
|
def test_rhythm_note_creation():
|
|
t = Tone.from_string("C4")
|
|
n = RhythmNote(tone=t, duration=Duration.QUARTER)
|
|
assert n.tone is t
|
|
assert n.duration is Duration.QUARTER
|
|
assert n.beats == 1.0
|
|
|
|
|
|
def test_rest_creation():
|
|
r = Rest(Duration.HALF)
|
|
assert r.tone is None
|
|
assert r.duration is Duration.HALF
|
|
assert r.beats == 2.0
|
|
|
|
|
|
def test_rest_default_duration():
|
|
r = Rest()
|
|
assert r.duration is Duration.QUARTER
|
|
|
|
|
|
def test_score_add_chaining():
|
|
t1 = Tone.from_string("C4")
|
|
t2 = Tone.from_string("E4")
|
|
score = Score("4/4", bpm=120)
|
|
result = score.add(t1, Duration.QUARTER).add(t2, Duration.QUARTER)
|
|
assert result is score
|
|
assert len(score) == 2
|
|
|
|
|
|
def test_score_total_beats():
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.HALF)
|
|
score.rest(Duration.QUARTER)
|
|
assert score.total_beats == 4.0
|
|
|
|
|
|
def test_score_measures_complete():
|
|
score = Score("4/4", bpm=120)
|
|
for _ in range(4):
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
assert score.measures == 1.0
|
|
|
|
|
|
def test_score_measures_fractional():
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.QUARTER)
|
|
assert score.measures == 0.5
|
|
|
|
|
|
def test_score_measures_3_4():
|
|
score = Score("3/4", bpm=100)
|
|
for _ in range(3):
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
assert score.measures == 1.0
|
|
|
|
|
|
def test_score_duration_ms():
|
|
score = Score("4/4", bpm=120)
|
|
# At 120 bpm, one beat = 500 ms
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER) # 1 beat = 500 ms
|
|
score.add(Tone.from_string("E4"), Duration.HALF) # 2 beats = 1000 ms
|
|
assert score.duration_ms == 1500.0
|
|
|
|
|
|
def test_score_iteration():
|
|
score = Score("4/4", bpm=120)
|
|
t = Tone.from_string("C4")
|
|
score.add(t, Duration.QUARTER)
|
|
score.rest(Duration.QUARTER)
|
|
notes = list(score)
|
|
assert len(notes) == 2
|
|
assert notes[0].tone is t
|
|
assert notes[1].tone is None
|
|
|
|
|
|
def test_score_repr():
|
|
score = Score("4/4", bpm=120)
|
|
for _ in range(4):
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
r = repr(score)
|
|
assert "4/4" in r
|
|
assert "120bpm" in r
|
|
assert "1.0 measures" in r
|
|
|
|
|
|
def test_score_with_rests():
|
|
score = Score("4/4", bpm=60)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.rest(Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.QUARTER)
|
|
score.rest(Duration.QUARTER)
|
|
assert score.total_beats == 4.0
|
|
assert score.measures == 1.0
|
|
# At 60 bpm, 1 beat = 1000 ms, 4 beats = 4000 ms
|
|
assert score.duration_ms == 4000.0
|
|
|
|
|
|
def test_score_save_midi(tmp_path):
|
|
"""save_midi writes a valid MIDI file header."""
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.QUARTER)
|
|
score.rest(Duration.QUARTER)
|
|
score.add(Tone.from_string("G4"), Duration.QUARTER)
|
|
|
|
midi_path = tmp_path / "test.mid"
|
|
score.save_midi(str(midi_path))
|
|
|
|
data = midi_path.read_bytes()
|
|
# Valid MIDI starts with MThd
|
|
assert data[:4] == b"MThd"
|
|
# Contains a track chunk
|
|
assert b"MTrk" in data
|
|
# File is non-trivial
|
|
assert len(data) > 30
|
|
|
|
|
|
# ── DrumSound and Pattern ──────────────────────────────────────────────────
|
|
|
|
def test_drum_sound_values():
|
|
from pytheory.rhythm import DrumSound
|
|
assert DrumSound.KICK.value == 36
|
|
assert DrumSound.SNARE.value == 38
|
|
assert DrumSound.CLOSED_HAT.value == 42
|
|
assert DrumSound.RIDE.value == 51
|
|
|
|
|
|
def test_pattern_list_presets():
|
|
from pytheory import Pattern
|
|
presets = Pattern.list_presets()
|
|
assert len(presets) >= 40
|
|
assert "rock" in presets
|
|
assert "jazz" in presets
|
|
assert "salsa" in presets
|
|
assert "bossa nova" in presets
|
|
assert "bebop" in presets
|
|
assert "funk" in presets
|
|
|
|
|
|
def test_pattern_preset_rock():
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("rock")
|
|
assert p.name == "rock"
|
|
assert p.beats == 4.0
|
|
assert len(p.hits) > 0
|
|
|
|
|
|
def test_pattern_preset_salsa():
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("salsa")
|
|
assert p.beats == 8.0 # 2-bar clave cycle
|
|
assert len(p.hits) > 20
|
|
|
|
|
|
def test_pattern_preset_invalid():
|
|
from pytheory import Pattern
|
|
with pytest.raises(ValueError, match="Unknown preset"):
|
|
Pattern.preset("nonexistent")
|
|
|
|
|
|
def test_pattern_to_score():
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("rock")
|
|
score = p.to_score(repeats=4, bpm=120)
|
|
assert score.total_beats == 16.0
|
|
assert score.measures == 4.0
|
|
|
|
|
|
def test_pattern_to_score_waltz():
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("waltz")
|
|
score = p.to_score(repeats=4, bpm=180)
|
|
assert score.total_beats == 12.0
|
|
assert score.bpm == 180
|
|
|
|
|
|
def test_pattern_midi_export(tmp_path):
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("bossa nova")
|
|
score = p.to_score(repeats=2, bpm=140)
|
|
path = tmp_path / "bossa.mid"
|
|
score.save_midi(str(path))
|
|
data = path.read_bytes()
|
|
assert data[:4] == b"MThd"
|
|
assert len(data) > 50
|
|
|
|
|
|
def test_pattern_all_presets_valid():
|
|
from pytheory import Pattern
|
|
for name in Pattern.list_presets():
|
|
p = Pattern.preset(name)
|
|
assert p.beats > 0
|
|
assert len(p.hits) > 0
|
|
score = p.to_score(repeats=1, bpm=120)
|
|
assert score.total_beats == p.beats
|
|
|
|
|
|
def test_pattern_repr():
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("funk")
|
|
r = repr(p)
|
|
assert "funk" in r
|
|
assert "4/4" in r
|
|
|
|
|
|
# ── Drum synthesis ─────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_render_drum_hit_all_sounds():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in DrumSound:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
assert wave.dtype == numpy.float32
|
|
|
|
|
|
@needs_portaudio
|
|
def test_render_pattern_rock():
|
|
from pytheory.play import _render_pattern
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("rock")
|
|
buf = _render_pattern(p, bpm=120)
|
|
assert len(buf) > 0
|
|
assert buf.dtype == numpy.float32
|
|
assert numpy.max(numpy.abs(buf)) <= 0.91 # normalized
|
|
|
|
|
|
@needs_portaudio
|
|
def test_render_pattern_all_presets():
|
|
from pytheory.play import _render_pattern
|
|
from pytheory import Pattern
|
|
for name in Pattern.list_presets():
|
|
p = Pattern.preset(name)
|
|
buf = _render_pattern(p, bpm=120)
|
|
assert len(buf) > 0, f"Empty buffer for {name}"
|
|
|
|
|
|
@needs_portaudio
|
|
def test_render_pattern_different_tempos():
|
|
from pytheory.play import _render_pattern
|
|
from pytheory import Pattern
|
|
p = Pattern.preset("jazz")
|
|
slow = _render_pattern(p, bpm=60)
|
|
fast = _render_pattern(p, bpm=240)
|
|
assert len(slow) > len(fast) # slower = more samples
|
|
|
|
|
|
# ── Part and multi-part Score ──────────────────────────────────────────────
|
|
|
|
def test_part_creation():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw", envelope="pluck")
|
|
assert lead.name == "lead"
|
|
assert lead.synth == "saw"
|
|
assert lead.envelope == "pluck"
|
|
assert "lead" in score.parts
|
|
|
|
|
|
def test_part_add_string():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.add("C5", Duration.QUARTER)
|
|
assert len(lead) == 1
|
|
assert lead.notes[0].tone.name == "C"
|
|
assert lead.notes[0].tone.octave == 5
|
|
|
|
|
|
def test_part_add_chaining():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
result = lead.add("C5", Duration.QUARTER).add("E5", Duration.QUARTER).rest(Duration.HALF)
|
|
assert result is lead
|
|
assert len(lead) == 3
|
|
assert lead.total_beats == 4.0
|
|
|
|
|
|
def test_part_total_beats_in_score():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.add("C5", Duration.WHOLE).add("E5", Duration.WHOLE)
|
|
assert score.total_beats == 8.0
|
|
|
|
|
|
def test_multiple_parts():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw")
|
|
bass = score.part("bass", synth="triangle")
|
|
lead.add("C5", Duration.WHOLE)
|
|
bass.add("C2", Duration.WHOLE).add("G2", Duration.WHOLE)
|
|
assert len(score.parts) == 2
|
|
assert score.total_beats == 8.0 # bass is longer
|
|
|
|
|
|
def test_score_add_pattern():
|
|
from pytheory import Score, Pattern
|
|
score = Score("4/4", bpm=120)
|
|
score.add_pattern(Pattern.preset("rock"), repeats=2)
|
|
assert score._drum_pattern_beats == 8.0
|
|
assert len(score._drum_hits) > 0
|
|
|
|
|
|
def test_score_add_pattern_chaining():
|
|
from pytheory import Score, Pattern
|
|
score = Score("4/4", bpm=120)
|
|
result = score.add_pattern(Pattern.preset("rock"), repeats=1)
|
|
assert result is score
|
|
|
|
|
|
def test_part_repr():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw")
|
|
lead.add("C5", Duration.QUARTER)
|
|
r = repr(lead)
|
|
assert "lead" in r
|
|
assert "saw" in r
|
|
|
|
|
|
def test_score_repr_with_parts():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
score.part("lead")
|
|
score.part("bass")
|
|
r = repr(score)
|
|
assert "2 parts" in r
|
|
|
|
|
|
@needs_portaudio
|
|
def test_render_score_with_parts():
|
|
from pytheory import Score, Duration, Pattern, Key
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
score.add_pattern(Pattern.preset("rock"), repeats=2)
|
|
chords = score.part("chords", synth="sine", envelope="pad")
|
|
lead = score.part("lead", synth="saw", envelope="pluck")
|
|
key = Key("C", "major")
|
|
for chord in key.progression("I", "V", "vi", "IV"):
|
|
chords.add(chord, Duration.HALF)
|
|
lead.add("E5", Duration.QUARTER).add("G5", Duration.QUARTER)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
assert buf.dtype == numpy.float32
|
|
|
|
|
|
def test_backwards_compat_add():
|
|
"""Score.add() still works without named parts."""
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Chord.from_symbol("C"), Duration.WHOLE)
|
|
assert len(score.notes) == 1
|
|
assert score.total_beats == 4.0
|
|
|
|
|
|
# ── New synth waveforms ───────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_square_wave():
|
|
from pytheory.play import square_wave, SAMPLE_RATE
|
|
wave = square_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
# Square wave should only have values at +peak and -peak
|
|
unique = set(numpy.unique(wave))
|
|
assert len(unique) <= 3 # +peak, -peak, possibly 0 at zero crossings
|
|
|
|
|
|
@needs_portaudio
|
|
def test_pulse_wave():
|
|
from pytheory.play import pulse_wave, SAMPLE_RATE
|
|
wave = pulse_wave(440, duty=0.25)
|
|
assert len(wave) == SAMPLE_RATE
|
|
|
|
|
|
@needs_portaudio
|
|
def test_pulse_wave_duty_affects_timbre():
|
|
from pytheory.play import pulse_wave
|
|
narrow = pulse_wave(440, duty=0.125, n_samples=1000)
|
|
wide = pulse_wave(440, duty=0.5, n_samples=1000)
|
|
# Different duty cycles produce different waveforms
|
|
assert not numpy.array_equal(narrow, wide)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_fm_wave():
|
|
from pytheory.play import fm_wave, SAMPLE_RATE
|
|
wave = fm_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
# FM should produce a more complex waveform than sine
|
|
assert len(numpy.unique(wave)) > 100
|
|
|
|
|
|
@needs_portaudio
|
|
def test_fm_wave_params():
|
|
from pytheory.play import fm_wave
|
|
bell = fm_wave(440, mod_ratio=3.5, mod_index=5, n_samples=1000)
|
|
piano = fm_wave(440, mod_ratio=1, mod_index=1.5, n_samples=1000)
|
|
assert not numpy.array_equal(bell, piano)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_noise_wave():
|
|
from pytheory.play import noise_wave, SAMPLE_RATE
|
|
wave = noise_wave(n_samples=SAMPLE_RATE)
|
|
assert len(wave) == SAMPLE_RATE
|
|
# Noise should be random — two calls produce different results
|
|
wave2 = noise_wave(n_samples=SAMPLE_RATE)
|
|
assert not numpy.array_equal(wave, wave2)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_supersaw_wave():
|
|
from pytheory.play import supersaw_wave, sawtooth_wave, SAMPLE_RATE
|
|
wave = supersaw_wave(440)
|
|
assert len(wave) == SAMPLE_RATE
|
|
|
|
|
|
@needs_portaudio
|
|
def test_all_synths_in_enum():
|
|
from pytheory.play import Synth
|
|
assert len(Synth) == 42
|
|
for s in Synth:
|
|
wave = s(440, n_samples=1000)
|
|
assert len(wave) == 1000
|
|
|
|
|
|
@needs_portaudio
|
|
def test_resolve_synth_new_names():
|
|
from pytheory.play import _resolve_synth, square_wave, fm_wave, supersaw_wave
|
|
assert _resolve_synth("square") is square_wave
|
|
assert _resolve_synth("fm") is fm_wave
|
|
assert _resolve_synth("supersaw") is supersaw_wave
|
|
|
|
|
|
@needs_portaudio
|
|
def test_part_with_new_synths():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
for synth_name in ["square", "pulse", "fm", "noise", "supersaw"]:
|
|
p = score.part(synth_name, synth=synth_name, envelope="pluck")
|
|
p.add("C4", Duration.QUARTER)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Drum fill tests ──────────────────────────────────────────────────────────
|
|
|
|
|
|
def test_fill_presets_exist():
|
|
from pytheory import Pattern
|
|
expected = [
|
|
"rock", "rock crash", "jazz", "jazz brush", "salsa", "samba",
|
|
"funk", "metal", "blast", "buildup", "breakdown",
|
|
"reggae", "afrobeat", "bossa nova", "house", "trap",
|
|
"hip hop", "disco", "cumbia", "highlife", "second line",
|
|
]
|
|
for name in expected:
|
|
p = Pattern.fill(name)
|
|
assert p is not None
|
|
|
|
|
|
def test_fill_is_pattern():
|
|
from pytheory import Pattern
|
|
p = Pattern.fill("rock")
|
|
assert isinstance(p, Pattern)
|
|
|
|
|
|
def test_fill_beats():
|
|
from pytheory import Pattern
|
|
for name in Pattern.list_fills():
|
|
p = Pattern.fill(name)
|
|
assert p.beats == 4.0, f"Fill {name!r} should be 4 beats, got {p.beats}"
|
|
|
|
|
|
def test_fill_invalid_raises():
|
|
from pytheory import Pattern
|
|
with pytest.raises(ValueError, match="Unknown fill"):
|
|
Pattern.fill("nonexistent_fill_xyz")
|
|
|
|
|
|
def test_score_fill():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
score.fill("rock")
|
|
assert len(score._drum_hits) > 0
|
|
|
|
|
|
def test_drums_with_fill():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
score.drums("rock", repeats=8, fill="rock", fill_every=4)
|
|
# 8 bars total, each 4 beats = 32 beats
|
|
assert score._drum_pattern_beats == 32.0
|
|
|
|
|
|
def test_drums_fill_last_bar_only():
|
|
from pytheory import Score, Pattern
|
|
score = Score("4/4", bpm=120)
|
|
score.drums("rock", repeats=4, fill="rock")
|
|
# 4 bars total, each 4 beats = 16 beats
|
|
assert score._drum_pattern_beats == 16.0
|
|
# The last bar should be a fill (different hit count than groove)
|
|
groove = Pattern.preset("rock")
|
|
fill_pat = Pattern.fill("rock")
|
|
# Build expected: 3 bars groove + 1 bar fill
|
|
expected_hits = 3 * len(groove.hits) + len(fill_pat.hits)
|
|
assert len(score._drum_hits) == expected_hits
|
|
|
|
|
|
def test_fill_all_presets_valid():
|
|
from pytheory import Pattern
|
|
for name in Pattern.list_fills():
|
|
p = Pattern.fill(name)
|
|
assert len(p.hits) > 0, f"Fill {name!r} has no hits"
|
|
|
|
|
|
def test_new_groove_presets():
|
|
from pytheory import Pattern
|
|
new_grooves = [
|
|
"country", "ska", "dub", "jungle", "techno",
|
|
"gospel", "swing", "bolero", "tango", "flamenco",
|
|
]
|
|
for name in new_grooves:
|
|
p = Pattern.preset(name)
|
|
assert len(p.hits) > 0, f"Groove {name!r} has no hits"
|
|
|
|
|
|
def test_new_fill_presets():
|
|
from pytheory import Pattern
|
|
new_fills = [
|
|
"reggae", "afrobeat", "bossa nova", "house", "trap",
|
|
"hip hop", "disco", "cumbia", "highlife", "second line",
|
|
]
|
|
for name in new_fills:
|
|
p = Pattern.fill(name)
|
|
assert len(p.hits) > 0, f"Fill {name!r} has no hits"
|
|
|
|
|
|
# ── Audio effects ──────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_reverb_effect():
|
|
from pytheory.play import _apply_reverb
|
|
dry = numpy.zeros(44100, dtype=numpy.float32)
|
|
dry[0] = 1.0 # impulse
|
|
wet = _apply_reverb(dry, mix=1.0, decay=0.5)
|
|
assert numpy.max(numpy.abs(wet[1000:])) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_reverb_zero_mix():
|
|
from pytheory.play import _apply_reverb
|
|
dry = numpy.random.uniform(-1, 1, 1000).astype(numpy.float32)
|
|
result = _apply_reverb(dry, mix=0.0)
|
|
assert numpy.allclose(result, dry)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_delay_effect():
|
|
from pytheory.play import _apply_delay
|
|
dry = numpy.zeros(44100, dtype=numpy.float32)
|
|
dry[:100] = 1.0
|
|
wet = _apply_delay(dry, mix=0.5, time=0.1, feedback=0.3)
|
|
echo_start = int(0.1 * 44100)
|
|
assert numpy.max(numpy.abs(wet[echo_start:echo_start + 200])) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_delay_zero_mix():
|
|
from pytheory.play import _apply_delay
|
|
dry = numpy.random.uniform(-1, 1, 1000).astype(numpy.float32)
|
|
result = _apply_delay(dry, mix=0.0)
|
|
assert numpy.allclose(result, dry)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_lowpass_filter():
|
|
from pytheory.play import _apply_lowpass, SAMPLE_RATE
|
|
t = numpy.arange(44100, dtype=numpy.float32) / SAMPLE_RATE
|
|
signal = numpy.sin(2 * numpy.pi * 100 * t) + numpy.sin(2 * numpy.pi * 5000 * t)
|
|
filtered = _apply_lowpass(signal.astype(numpy.float32), cutoff=500)
|
|
rms_orig = numpy.sqrt(numpy.mean(signal[22050:] ** 2))
|
|
rms_filt = numpy.sqrt(numpy.mean(filtered[22050:] ** 2))
|
|
assert rms_filt < rms_orig
|
|
|
|
|
|
@needs_portaudio
|
|
def test_lowpass_with_resonance():
|
|
from pytheory.play import _apply_lowpass
|
|
t = numpy.arange(44100, dtype=numpy.float32) / 44100
|
|
signal = numpy.sin(2 * numpy.pi * 1000 * t).astype(numpy.float32)
|
|
flat = _apply_lowpass(signal, cutoff=1000, q=0.707)
|
|
resonant = _apply_lowpass(signal, cutoff=1000, q=5.0)
|
|
assert numpy.max(numpy.abs(resonant)) > numpy.max(numpy.abs(flat))
|
|
|
|
|
|
@needs_portaudio
|
|
def test_part_effects_in_render():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw", envelope="pluck",
|
|
reverb=0.3, delay=0.2, lowpass=2000)
|
|
lead.add("C5", Duration.WHOLE)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_part_effects_change_output():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
s1 = Score("4/4", bpm=120)
|
|
s1.part("lead", synth="saw", envelope="pluck").add("C5", Duration.WHOLE)
|
|
dry = render_score(s1)
|
|
s2 = Score("4/4", bpm=120)
|
|
s2.part("lead", synth="saw", envelope="pluck",
|
|
reverb=0.5, delay=0.3).add("C5", Duration.WHOLE)
|
|
wet = render_score(s2)
|
|
assert not numpy.allclose(dry, wet, atol=0.01)
|
|
|
|
|
|
# ── Arpeggiator ───────────────────────────────────────────────────────────
|
|
|
|
def test_arpeggio_basic():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.arpeggio(Chord.from_symbol("C"), bars=1, pattern="up",
|
|
division=Duration.SIXTEENTH)
|
|
# 1 bar of 16ths = 16 notes
|
|
assert len(lead) == 16
|
|
|
|
|
|
def test_arpeggio_patterns():
|
|
from pytheory import Score, Duration
|
|
for pat in ["up", "down", "updown", "downup", "random"]:
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part(f"lead_{pat}")
|
|
lead.arpeggio(Chord.from_symbol("Am"), bars=1, pattern=pat)
|
|
assert len(lead) > 0
|
|
|
|
|
|
def test_arpeggio_octaves():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.arpeggio(Chord.from_symbol("C"), bars=1, octaves=2,
|
|
division=Duration.EIGHTH)
|
|
# C major = 3 tones, 2 octaves = 6 tones in the cycle
|
|
assert len(lead) == 8 # 1 bar of 8ths
|
|
|
|
|
|
def test_arpeggio_string_chord():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.arpeggio("Dm7", bars=1)
|
|
assert len(lead) > 0
|
|
|
|
|
|
def test_arpeggio_chaining():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
result = lead.arpeggio("C", bars=1).arpeggio("Am", bars=1)
|
|
assert result is lead
|
|
assert lead.total_beats == 8.0
|
|
|
|
|
|
def test_arpeggio_with_legato():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw", legato=True, glide=0.03)
|
|
lead.arpeggio("Cm", bars=2, pattern="updown", octaves=2)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
def test_arpeggio_updown_length():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.arpeggio(Chord.from_symbol("Am"), bars=2, pattern="updown",
|
|
division=Duration.EIGHTH)
|
|
# 2 bars of 8ths = 16 notes
|
|
assert len(lead) == 16
|
|
|
|
|
|
# ── Part.set() automation ─────────────────────────────────────────────────
|
|
|
|
def test_part_set_stores_automation():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.add("C5", Duration.WHOLE)
|
|
lead.set(lowpass=2000)
|
|
lead.add("E5", Duration.WHOLE)
|
|
assert len(lead._automation) == 1
|
|
assert lead._automation[0][0] == 4.0
|
|
|
|
|
|
def test_part_set_chaining():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
result = lead.set(lowpass=1000, reverb=0.3)
|
|
assert result is lead
|
|
|
|
|
|
def test_part_get_params_at():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", lowpass=500)
|
|
lead.add("C5", Duration.WHOLE)
|
|
lead.set(lowpass=2000, reverb=0.4)
|
|
lead.add("E5", Duration.WHOLE)
|
|
p0 = lead._get_params_at(0)
|
|
assert p0["lowpass"] == 500
|
|
assert p0["reverb_mix"] == 0
|
|
p4 = lead._get_params_at(4.0)
|
|
assert p4["lowpass"] == 2000
|
|
assert p4["reverb_mix"] == 0.4
|
|
|
|
|
|
@needs_portaudio
|
|
def test_automation_changes_output():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
s1 = Score("4/4", bpm=120)
|
|
s1.part("lead", synth="saw", lowpass=500).add("C5", Duration.WHOLE).add("C5", Duration.WHOLE)
|
|
buf1 = render_score(s1)
|
|
s2 = Score("4/4", bpm=120)
|
|
p2 = s2.part("lead", synth="saw", lowpass=500)
|
|
p2.add("C5", Duration.WHOLE)
|
|
p2.set(lowpass=5000)
|
|
p2.add("C5", Duration.WHOLE)
|
|
buf2 = render_score(s2)
|
|
assert not numpy.allclose(buf1, buf2, atol=0.01)
|
|
|
|
|
|
def test_part_set_multiple():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", lowpass=400)
|
|
lead.add("C5", Duration.WHOLE)
|
|
lead.set(lowpass=1000)
|
|
lead.add("C5", Duration.WHOLE)
|
|
lead.set(lowpass=3000, distortion=0.5)
|
|
lead.add("C5", Duration.WHOLE)
|
|
assert len(lead._automation) == 2
|
|
p8 = lead._get_params_at(8.0)
|
|
assert p8["lowpass"] == 3000
|
|
assert p8["distortion_mix"] == 0.5
|
|
|
|
|
|
# ── Chorus effect ──────────────────────────────────────────────────────────
|
|
|
|
@needs_portaudio
|
|
def test_chorus_effect():
|
|
from pytheory.play import _apply_chorus
|
|
t = numpy.arange(44100, dtype=numpy.float32) / 44100
|
|
signal = numpy.sin(2 * numpy.pi * 440 * t).astype(numpy.float32)
|
|
wet = _apply_chorus(signal, mix=0.5)
|
|
assert not numpy.allclose(signal, wet, atol=0.01)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_chorus_zero_mix():
|
|
from pytheory.play import _apply_chorus
|
|
dry = numpy.random.uniform(-1, 1, 1000).astype(numpy.float32)
|
|
result = _apply_chorus(dry, mix=0.0)
|
|
assert numpy.allclose(result, dry)
|
|
|
|
|
|
@needs_portaudio
|
|
def test_part_with_chorus():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
score.part("lead", synth="saw", chorus=0.5).add("C5", Duration.WHOLE)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── LFO automation ────────────────────────────────────────────────────────
|
|
|
|
def test_lfo_generates_automation():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.lfo("lowpass", rate=1.0, min=400, max=2000, bars=2)
|
|
# 2 bars * 4 beats / 0.25 resolution = 32 points
|
|
assert len(lead._automation) == 32
|
|
|
|
|
|
def test_lfo_sine_shape():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", lowpass=500)
|
|
lead.lfo("lowpass", rate=1.0, min=200, max=1000, bars=1, shape="sine")
|
|
# Check values stay in range
|
|
for beat, params in lead._automation:
|
|
assert 200 <= params["lowpass"] <= 1000
|
|
|
|
|
|
def test_lfo_all_shapes():
|
|
from pytheory import Score
|
|
for shape in ["sine", "triangle", "saw", "square"]:
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part(f"lead_{shape}")
|
|
lead.lfo("lowpass", rate=1.0, min=100, max=5000, bars=1, shape=shape)
|
|
assert len(lead._automation) > 0
|
|
|
|
|
|
def test_lfo_chaining():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
result = lead.lfo("lowpass", rate=1.0, min=400, max=2000, bars=1)
|
|
assert result is lead
|
|
|
|
|
|
def test_lfo_multiple_params():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.lfo("lowpass", rate=1.0, min=400, max=2000, bars=2)
|
|
lead.lfo("distortion", rate=0.5, min=0.0, max=0.8, bars=2)
|
|
# Both sets of automation points should exist
|
|
lp_points = [p for _, p in lead._automation if "lowpass" in p]
|
|
dist_points = [p for _, p in lead._automation if "distortion_mix" in p]
|
|
assert len(lp_points) > 0
|
|
assert len(dist_points) > 0
|
|
|
|
|
|
@needs_portaudio
|
|
def test_lfo_renders_correctly():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="saw", lowpass=400, lowpass_q=3.0)
|
|
lead.lfo("lowpass", rate=1.0, min=300, max=3000, bars=2)
|
|
lead.add("C4", Duration.WHOLE).add("C4", Duration.WHOLE)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Per-note velocity tests ─────────────────────────────────────────────────
|
|
|
|
def test_note_velocity_default():
|
|
from pytheory.rhythm import Note, Duration
|
|
n = Note(tone=None, duration=Duration.QUARTER)
|
|
assert n.velocity == 100
|
|
|
|
|
|
def test_note_velocity_custom():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.add("C5", Duration.QUARTER, velocity=60)
|
|
assert lead.notes[0].velocity == 60
|
|
|
|
|
|
def test_arpeggio_velocity():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.arpeggio("Cm", bars=1, velocity=75)
|
|
for n in lead.notes:
|
|
assert n.velocity == 75
|
|
|
|
|
|
# ── Swing / groove tests ────────────────────────────────────────────────────
|
|
|
|
def test_score_swing_default():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
assert score.swing == 0.0
|
|
|
|
|
|
def test_score_swing_set():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120, swing=0.5)
|
|
assert score.swing == 0.5
|
|
|
|
|
|
# ── Tempo change tests ──────────────────────────────────────────────────────
|
|
|
|
def test_set_tempo():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead")
|
|
lead.add("C4", Duration.WHOLE)
|
|
score.set_tempo(140)
|
|
assert len(score._tempo_changes) == 1
|
|
beat_pos, new_bpm = score._tempo_changes[0]
|
|
assert new_bpm == 140
|
|
assert beat_pos == 4.0 # after one WHOLE note
|
|
|
|
|
|
# ── Fade in/out tests ───────────────────────────────────────────────────────
|
|
|
|
def test_fade_in():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", volume=0.8)
|
|
lead.fade_in(bars=2)
|
|
# Should generate automation points with ascending volume
|
|
volumes = [p["volume"] for _, p in lead._automation]
|
|
assert len(volumes) > 0
|
|
assert volumes[0] == pytest.approx(0.0)
|
|
assert volumes[-1] == pytest.approx(0.8)
|
|
# Check ascending order
|
|
for i in range(1, len(volumes)):
|
|
assert volumes[i] >= volumes[i - 1]
|
|
|
|
|
|
def test_fade_out():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", volume=0.8)
|
|
lead.fade_out(bars=2)
|
|
# Should generate automation points with descending volume
|
|
volumes = [p["volume"] for _, p in lead._automation]
|
|
assert len(volumes) > 0
|
|
assert volumes[0] == pytest.approx(0.8)
|
|
assert volumes[-1] == pytest.approx(0.0)
|
|
# Check descending order
|
|
for i in range(1, len(volumes)):
|
|
assert volumes[i] <= volumes[i - 1]
|
|
|
|
|
|
@needs_portaudio
|
|
def test_velocity_affects_render():
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
import numpy as np
|
|
# Loud note
|
|
score_loud = Score("4/4", bpm=120)
|
|
lead_loud = score_loud.part("lead", synth="sine", envelope="none")
|
|
lead_loud.add("A4", Duration.QUARTER, velocity=127)
|
|
buf_loud = render_score(score_loud)
|
|
# Quiet note
|
|
score_quiet = Score("4/4", bpm=120)
|
|
lead_quiet = score_quiet.part("lead", synth="sine", envelope="none")
|
|
lead_quiet.add("A4", Duration.QUARTER, velocity=30)
|
|
buf_quiet = render_score(score_quiet)
|
|
# Loud should have greater peak amplitude (both are normalized,
|
|
# but we compare RMS of the raw rendered parts before normalization)
|
|
# Actually, render_score normalizes. Let's just check they both render.
|
|
assert len(buf_loud) > 0
|
|
assert len(buf_quiet) > 0
|
|
# The loud note should have higher peak than the quiet note
|
|
# Since both scores have only one note, normalization makes peaks equal.
|
|
# Instead, render a score with BOTH loud and quiet notes and check
|
|
# the loud section is louder.
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="sine", envelope="none")
|
|
lead.add("A4", Duration.QUARTER, velocity=127)
|
|
lead.add("A4", Duration.QUARTER, velocity=30)
|
|
buf = render_score(score)
|
|
mid = len(buf) // 2
|
|
rms_first = np.sqrt(np.mean(buf[:mid] ** 2))
|
|
rms_second = np.sqrt(np.mean(buf[mid:] ** 2))
|
|
assert rms_first > rms_second
|
|
|
|
|
|
# ── Sidechain compression tests ─────────────────────────────────────────────
|
|
|
|
|
|
def test_sidechain_default():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
pad = score.part("pad", synth="sine", envelope="pad")
|
|
assert pad.sidechain == 0.0
|
|
assert pad.sidechain_release == 0.1
|
|
|
|
|
|
def test_sidechain_set():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
pad = score.part("pad", synth="sine", envelope="pad", sidechain=0.8,
|
|
sidechain_release=0.15)
|
|
assert pad.sidechain == 0.8
|
|
assert pad.sidechain_release == 0.15
|
|
|
|
|
|
@needs_portaudio
|
|
def test_sidechain_render():
|
|
from pytheory import Score, Duration, Pattern
|
|
from pytheory.play import render_score
|
|
import numpy as np
|
|
|
|
# Score without sidechain
|
|
score1 = Score("4/4", bpm=120)
|
|
score1.add_pattern(Pattern.preset("rock"), repeats=2)
|
|
pad1 = score1.part("pad", synth="sine", envelope="pad")
|
|
pad1.add("C4", Duration.WHOLE).add("C4", Duration.WHOLE)
|
|
buf1 = render_score(score1)
|
|
|
|
# Score with sidechain
|
|
score2 = Score("4/4", bpm=120)
|
|
score2.add_pattern(Pattern.preset("rock"), repeats=2)
|
|
pad2 = score2.part("pad", synth="sine", envelope="pad", sidechain=0.8)
|
|
pad2.add("C4", Duration.WHOLE).add("C4", Duration.WHOLE)
|
|
buf2 = render_score(score2)
|
|
|
|
# Both should render to non-empty buffers of the same length
|
|
assert len(buf1) > 0
|
|
assert len(buf1) == len(buf2)
|
|
# The buffers should differ (sidechain alters the mix)
|
|
assert not np.array_equal(buf1, buf2)
|
|
|
|
|
|
# ── Song structure / Section tests ───────────────────────────────────────────
|
|
|
|
|
|
def test_section_basic():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="sine")
|
|
|
|
score.section("verse")
|
|
lead.add("C5", Duration.WHOLE)
|
|
|
|
score.section("chorus")
|
|
lead.add("E5", Duration.WHOLE)
|
|
score.end_section()
|
|
|
|
assert "verse" in score._sections
|
|
assert "chorus" in score._sections
|
|
assert score._sections["verse"]._finalized
|
|
assert score._sections["chorus"]._finalized
|
|
|
|
|
|
def test_section_repeat():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="sine")
|
|
|
|
score.section("verse")
|
|
lead.add("C5", Duration.WHOLE) # 4 beats
|
|
score.end_section()
|
|
|
|
beats_before = score.total_beats
|
|
assert beats_before == 4.0
|
|
|
|
score.repeat("verse")
|
|
assert score.total_beats == 8.0
|
|
|
|
|
|
def test_section_repeat_parts():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
lead = score.part("lead", synth="sine")
|
|
bass = score.part("bass", synth="triangle")
|
|
|
|
score.section("verse")
|
|
lead.add("C5", Duration.QUARTER)
|
|
lead.add("D5", Duration.QUARTER)
|
|
bass.add("C3", Duration.HALF)
|
|
score.end_section()
|
|
|
|
assert len(lead.notes) == 2
|
|
assert len(bass.notes) == 1
|
|
|
|
score.repeat("verse")
|
|
assert len(lead.notes) == 4
|
|
assert len(bass.notes) == 2
|
|
|
|
score.repeat("verse", times=2)
|
|
assert len(lead.notes) == 8
|
|
assert len(bass.notes) == 4
|
|
|
|
|
|
def test_section_unknown_raises():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
with pytest.raises(ValueError, match="Unknown section"):
|
|
score.repeat("nonexistent")
|
|
|
|
|
|
# ── REPL ──────────────────────────────────────────────────────────────────
|
|
|
|
def test_repl_session_defaults():
|
|
from pytheory.repl import Session
|
|
s = Session()
|
|
assert str(s.key) == "C major"
|
|
assert s.bpm == 120
|
|
assert s.current_part is None
|
|
assert s._drum_preset is None
|
|
|
|
|
|
def test_repl_cmd_key():
|
|
from pytheory.repl import Session, cmd_key
|
|
s = Session()
|
|
cmd_key(s, ["Am"])
|
|
assert s.key.tonic_name == "A"
|
|
assert s.key.mode == "minor"
|
|
|
|
|
|
def test_repl_cmd_key_major():
|
|
from pytheory.repl import Session, cmd_key
|
|
s = Session()
|
|
cmd_key(s, ["G", "major"])
|
|
assert s.key.tonic_name == "G"
|
|
assert s.key.mode == "major"
|
|
|
|
|
|
def test_repl_cmd_bpm():
|
|
from pytheory.repl import Session, cmd_bpm
|
|
s = Session()
|
|
cmd_bpm(s, ["140"])
|
|
assert s.bpm == 140
|
|
assert s.score.bpm == 140
|
|
|
|
|
|
def test_repl_cmd_swing():
|
|
from pytheory.repl import Session, cmd_swing
|
|
s = Session()
|
|
cmd_swing(s, ["0.5"])
|
|
assert s.swing == 0.5
|
|
|
|
|
|
def test_repl_cmd_drums():
|
|
from pytheory.repl import Session, cmd_drums
|
|
s = Session()
|
|
cmd_drums(s, ["rock"])
|
|
assert s._drum_preset == "rock"
|
|
assert len(s.score._drum_hits) > 0
|
|
|
|
|
|
def test_repl_cmd_part():
|
|
from pytheory.repl import Session, cmd_part
|
|
s = Session()
|
|
cmd_part(s, ["lead", "saw", "pluck"])
|
|
assert "lead" in s.parts
|
|
assert s.current_part is not None
|
|
assert s.current_part.synth == "saw"
|
|
assert s.current_part.envelope == "pluck"
|
|
|
|
|
|
def test_repl_cmd_add_note():
|
|
from pytheory.repl import Session, cmd_add
|
|
s = Session()
|
|
cmd_add(s, ["C5", "1"])
|
|
assert s.current_part is not None # auto-created
|
|
assert len(s.current_part.notes) == 1
|
|
|
|
|
|
def test_repl_cmd_add_chord():
|
|
from pytheory.repl import Session, cmd_add
|
|
s = Session()
|
|
cmd_add(s, ["Am", "4"])
|
|
assert len(s.current_part.notes) == 1
|
|
|
|
|
|
def test_repl_cmd_rest():
|
|
from pytheory.repl import Session, cmd_rest
|
|
s = Session()
|
|
s.ensure_part("lead")
|
|
s.current_part = s.parts["lead"]
|
|
cmd_rest(s, ["2"])
|
|
assert len(s.current_part.notes) == 1
|
|
assert s.current_part.notes[0].tone is None
|
|
|
|
|
|
def test_repl_cmd_arp():
|
|
from pytheory.repl import Session, cmd_part, cmd_arp
|
|
s = Session()
|
|
cmd_part(s, ["lead"])
|
|
cmd_arp(s, ["Am", "updown", "2", "2"])
|
|
assert len(s.current_part.notes) > 0
|
|
|
|
|
|
def test_repl_cmd_prog():
|
|
from pytheory.repl import Session, cmd_key, cmd_prog
|
|
s = Session()
|
|
cmd_key(s, ["Am"])
|
|
cmd_prog(s, ["i", "iv", "V", "i"])
|
|
assert len(s.current_part.notes) == 4
|
|
|
|
|
|
def test_repl_cmd_effects():
|
|
from pytheory.repl import Session, cmd_part, _set_effect
|
|
s = Session()
|
|
cmd_part(s, ["lead", "saw"])
|
|
_set_effect(s, "reverb", ["0.4"])
|
|
assert s.current_part.reverb_mix == 0.4
|
|
_set_effect(s, "delay", ["0.3", "0.375"])
|
|
assert s.current_part.delay_mix == 0.3
|
|
assert s.current_part.delay_time == 0.375
|
|
_set_effect(s, "lowpass", ["2000", "3"])
|
|
assert s.current_part.lowpass == 2000
|
|
assert s.current_part.lowpass_q == 3.0
|
|
_set_effect(s, "distortion", ["0.5"])
|
|
assert s.current_part.distortion_mix == 0.5
|
|
|
|
|
|
def test_repl_cmd_legato():
|
|
from pytheory.repl import Session, cmd_part, cmd_legato
|
|
s = Session()
|
|
cmd_part(s, ["lead"])
|
|
cmd_legato(s, [])
|
|
assert s.current_part.legato is True
|
|
cmd_legato(s, ["off"])
|
|
assert s.current_part.legato is False
|
|
|
|
|
|
def test_repl_cmd_set():
|
|
from pytheory.repl import Session, cmd_part, cmd_add, cmd_set
|
|
s = Session()
|
|
cmd_part(s, ["lead"])
|
|
cmd_add(s, ["C5", "4"])
|
|
cmd_set(s, ["lowpass", "3000"])
|
|
assert len(s.current_part._automation) == 1
|
|
|
|
|
|
def test_repl_cmd_lfo():
|
|
from pytheory.repl import Session, cmd_part, cmd_lfo
|
|
s = Session()
|
|
cmd_part(s, ["lead"])
|
|
cmd_lfo(s, ["lowpass", "0.5", "400", "3000", "4"])
|
|
assert len(s.current_part._automation) > 0
|
|
|
|
|
|
def test_repl_save_midi(tmp_path):
|
|
from pytheory.repl import Session, cmd_key, cmd_prog, cmd_save_midi
|
|
s = Session()
|
|
cmd_key(s, ["Am"])
|
|
cmd_prog(s, ["i", "iv", "V", "i"])
|
|
path = str(tmp_path / "test.mid")
|
|
cmd_save_midi(s, [path])
|
|
assert (tmp_path / "test.mid").exists()
|
|
|
|
|
|
def test_repl_prompt_compact():
|
|
from pytheory.repl import Session, _prompt
|
|
s = Session()
|
|
p = _prompt(s)
|
|
assert "key=C" in p
|
|
assert "bpm=120" in p
|
|
|
|
|
|
def test_repl_prompt_with_part():
|
|
from pytheory.repl import Session, cmd_part, _prompt
|
|
s = Session()
|
|
cmd_part(s, ["lead", "saw"])
|
|
p = _prompt(s)
|
|
assert "→lead(saw)" in p
|
|
|
|
|
|
def test_repl_prompt_multiline():
|
|
from pytheory.repl import Session, cmd_part, cmd_drums, _prompt, _set_effect
|
|
s = Session()
|
|
cmd_drums(s, ["bossa", "nova"])
|
|
cmd_part(s, ["lead", "saw"])
|
|
_set_effect(s, "reverb", ["0.4"])
|
|
_set_effect(s, "lowpass", ["2000"])
|
|
_set_effect(s, "distortion", ["0.5"])
|
|
p = _prompt(s)
|
|
assert "♫>" in p # should be multiline
|
|
|
|
|
|
def test_repl_clear():
|
|
from pytheory.repl import Session, cmd_part, cmd_drums, cmd_clear
|
|
s = Session()
|
|
cmd_drums(s, ["rock"])
|
|
cmd_part(s, ["lead"])
|
|
cmd_clear(s, [])
|
|
assert len(s.parts) == 0
|
|
assert s.current_part is None
|
|
|
|
|
|
def test_repl_chords(capsys):
|
|
from pytheory.repl import Session, cmd_key, cmd_chords
|
|
s = Session()
|
|
cmd_key(s, ["C"])
|
|
cmd_chords(s, [])
|
|
out = capsys.readouterr().out
|
|
assert "C major" in out
|
|
assert "D minor" in out
|
|
|
|
|
|
# ── Figured Bass ──────────────────────────────────────────────────────────────
|
|
|
|
def test_figured_bass_root_position():
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
assert chord.figured_bass == ""
|
|
|
|
|
|
def test_figured_bass_first_inversion():
|
|
# E in bass: first inversion of C major
|
|
chord = Chord.from_symbol("C").inversion(1)
|
|
assert chord.figured_bass == "6"
|
|
|
|
|
|
def test_figured_bass_second_inversion():
|
|
# G in bass: second inversion of C major
|
|
chord = Chord.from_symbol("C").inversion(2)
|
|
assert chord.figured_bass == "6/4"
|
|
|
|
|
|
def test_figured_bass_seventh_root():
|
|
# G7 in root position: G is the lowest note
|
|
chord = Chord.from_symbol("G7", octave=4)
|
|
assert chord.figured_bass == "7"
|
|
|
|
|
|
def test_figured_bass_seventh_first_inv():
|
|
# First inversion of G7: B in bass
|
|
chord = Chord.from_symbol("G7").inversion(1)
|
|
assert chord.figured_bass == "6/5"
|
|
|
|
|
|
def test_figured_bass_seventh_second_inv():
|
|
chord = Chord.from_symbol("G7").inversion(2)
|
|
assert chord.figured_bass == "4/3"
|
|
|
|
|
|
def test_figured_bass_seventh_third_inv():
|
|
chord = Chord.from_symbol("G7").inversion(3)
|
|
assert chord.figured_bass == "2"
|
|
|
|
|
|
def test_analyze_figured():
|
|
# V7 in root position
|
|
chord = Chord.from_symbol("G7")
|
|
result = chord.analyze_figured("C")
|
|
assert result == "V7"
|
|
|
|
|
|
def test_analyze_figured_with_inversion():
|
|
# V in first inversion
|
|
chord = Chord.from_symbol("G").inversion(1)
|
|
result = chord.analyze_figured("C")
|
|
assert result == "V6"
|
|
|
|
|
|
# ── Pitch Class Set Theory ───────────────────────────────────────────────────
|
|
|
|
def test_pitch_classes():
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
assert chord.pitch_classes == {0, 4, 7}
|
|
|
|
|
|
def test_pitch_classes_with_sharps():
|
|
chord = Chord.from_tones("C", "E", "G#")
|
|
assert chord.pitch_classes == {0, 4, 8}
|
|
|
|
|
|
def test_normal_form():
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
assert chord.normal_form == (0, 4, 7)
|
|
|
|
|
|
def test_prime_form_major():
|
|
# Major and minor triads share the same prime form (0, 3, 7)
|
|
# because C major (0,4,7) inverts to (0,5,8) -> normal form (0,3,7)
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
assert chord.prime_form == (0, 3, 7)
|
|
|
|
|
|
def test_prime_form_minor():
|
|
# Minor triad: A C E has intervals 0,3,7 which inverts to 0,5,9
|
|
# Normal form of inversion: best compact = (0,3,7) via inversion check
|
|
chord = Chord.from_tones("A", "C", "E")
|
|
assert chord.prime_form == (0, 3, 7)
|
|
|
|
|
|
def test_forte_number_triad():
|
|
chord = Chord.from_tones("C", "E", "G")
|
|
assert chord.forte_number == "3-11"
|
|
|
|
|
|
def test_forte_number_minor_triad():
|
|
chord = Chord.from_tones("A", "C", "E")
|
|
assert chord.forte_number == "3-11"
|
|
|
|
|
|
def test_forte_number_dom7():
|
|
chord = Chord.from_symbol("G7")
|
|
assert chord.forte_number == "4-27"
|
|
|
|
|
|
def test_forte_number_augmented():
|
|
chord = Chord.from_tones("C", "E", "G#")
|
|
assert chord.forte_number == "3-12"
|
|
|
|
|
|
def test_forte_number_diminished7():
|
|
chord = Chord.from_tones("B", "D", "F", "Ab")
|
|
assert chord.forte_number == "4-28"
|
|
|
|
|
|
# ── Scale.recommend ───────────────────────────────────────────────────────
|
|
|
|
def test_recommend_c_major_notes():
|
|
from pytheory.scales import Scale
|
|
results = Scale.recommend("C", "D", "E", "F", "G", "A", "B")
|
|
assert len(results) > 0
|
|
assert results[0][2] == 1.0 # perfect match
|
|
# Chromatic should NOT be the top result
|
|
assert "chromatic" not in results[0][1]
|
|
|
|
|
|
def test_recommend_pentatonic():
|
|
from pytheory.scales import Scale
|
|
results = Scale.recommend("C", "D", "E", "G", "A")
|
|
assert len(results) > 0
|
|
assert results[0][2] == 1.0
|
|
|
|
|
|
def test_recommend_returns_top():
|
|
from pytheory.scales import Scale
|
|
results = Scale.recommend("C", "E", "G", top=3)
|
|
assert len(results) <= 3
|
|
|
|
|
|
def test_recommend_empty():
|
|
from pytheory.scales import Scale
|
|
assert Scale.recommend() == []
|
|
|
|
|
|
def test_recommend_fitness_descending():
|
|
from pytheory.scales import Scale
|
|
results = Scale.recommend("C", "D", "E", "F#", "G")
|
|
for i in range(len(results) - 1):
|
|
assert results[i][2] >= results[i + 1][2]
|
|
|
|
|
|
# ── MIDI Import (Score.from_midi) ────────────────────────────────────────
|
|
|
|
|
|
def test_from_midi_basic(tmp_path):
|
|
"""Create a simple MIDI with save_midi, re-import with from_midi."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("G4"), Duration.QUARTER)
|
|
|
|
midi_path = str(tmp_path / "basic.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
# Should have at least one part with notes
|
|
assert len(imported.parts) >= 1
|
|
total_notes = sum(
|
|
1 for p in imported.parts.values()
|
|
for n in p.notes if n.tone is not None
|
|
)
|
|
assert total_notes == 3
|
|
|
|
|
|
def test_from_midi_tempo(tmp_path):
|
|
"""Verify BPM is preserved through save/import."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("4/4", bpm=140)
|
|
score.add(Tone.from_string("A4"), Duration.QUARTER)
|
|
|
|
midi_path = str(tmp_path / "tempo.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
assert imported.bpm == 140
|
|
|
|
|
|
def test_from_midi_roundtrip(tmp_path):
|
|
"""Save a progression as MIDI, import it, check parts/notes."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("3/4", bpm=100)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("D4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("F4"), Duration.QUARTER)
|
|
|
|
midi_path = str(tmp_path / "roundtrip.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
assert imported.bpm == 100
|
|
assert imported.time_signature == TimeSignature(3, 4)
|
|
total_notes = sum(
|
|
1 for p in imported.parts.values()
|
|
for n in p.notes if n.tone is not None
|
|
)
|
|
assert total_notes == 4
|
|
|
|
|
|
def test_from_midi_velocity(tmp_path):
|
|
"""Verify velocity is preserved through save/import."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("4/4", bpm=120)
|
|
# save_midi uses a fixed velocity param, default 100
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
score.add(Tone.from_string("E4"), Duration.HALF)
|
|
|
|
midi_path = str(tmp_path / "velocity.mid")
|
|
score.save_midi(midi_path, velocity=80)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
sounding = [
|
|
n for p in imported.parts.values()
|
|
for n in p.notes if n.tone is not None
|
|
]
|
|
assert len(sounding) == 2
|
|
for n in sounding:
|
|
assert n.velocity == 80
|
|
|
|
|
|
def test_from_midi_drums(tmp_path):
|
|
"""Verify drum hits survive a roundtrip."""
|
|
from pytheory import Score, Pattern
|
|
score = Score("4/4", bpm=120)
|
|
score.add_pattern(Pattern.preset("rock"), repeats=1)
|
|
|
|
midi_path = str(tmp_path / "drums.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
assert len(imported._drum_hits) > 0
|
|
|
|
|
|
def test_from_midi_time_signature(tmp_path):
|
|
"""Verify time signature is preserved."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("6/8", bpm=150)
|
|
score.add(Tone.from_string("C4"), Duration.QUARTER)
|
|
|
|
midi_path = str(tmp_path / "timesig.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
assert imported.time_signature == TimeSignature(6, 8)
|
|
assert imported.bpm == 150
|
|
|
|
|
|
def test_from_midi_note_durations(tmp_path):
|
|
"""Verify note durations are approximately preserved."""
|
|
from pytheory import Score, Duration, Tone
|
|
score = Score("4/4", bpm=120)
|
|
score.add(Tone.from_string("C4"), Duration.WHOLE) # 4 beats
|
|
score.add(Tone.from_string("E4"), Duration.HALF) # 2 beats
|
|
|
|
midi_path = str(tmp_path / "durations.mid")
|
|
score.save_midi(midi_path)
|
|
|
|
imported = Score.from_midi(midi_path)
|
|
sounding = [
|
|
n for p in imported.parts.values()
|
|
for n in p.notes if n.tone is not None
|
|
]
|
|
assert len(sounding) == 2
|
|
assert abs(sounding[0].beats - 4.0) < 0.01
|
|
assert abs(sounding[1].beats - 2.0) < 0.01
|
|
|
|
|
|
# ── Instrument presets ────────────────────────────────────────────────────────
|
|
|
|
def test_instrument_piano():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("p", instrument="piano")
|
|
assert p.synth == "piano_synth"
|
|
assert p.vel_to_filter == 3000
|
|
|
|
|
|
def test_instrument_violin():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("v", instrument="violin")
|
|
assert p.synth == "strings_synth"
|
|
assert p.envelope == "bowed"
|
|
assert p.humanize == 0.15
|
|
assert p.lowpass == 5000
|
|
assert p.detune == 2
|
|
|
|
|
|
def test_instrument_override():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
# Explicit synth overrides the preset
|
|
p = score.part("p", instrument="piano", synth="saw")
|
|
assert p.synth == "saw"
|
|
|
|
|
|
def test_instrument_unknown_raises():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
with pytest.raises(ValueError, match="Unknown instrument"):
|
|
score.part("x", instrument="kazoo")
|
|
|
|
|
|
def test_list_instruments():
|
|
from pytheory import Score, INSTRUMENTS
|
|
result = Score.list_instruments()
|
|
assert isinstance(result, list)
|
|
assert result == sorted(result)
|
|
assert "piano" in result
|
|
assert "violin" in result
|
|
assert "808_bass" in result
|
|
assert len(result) == len(INSTRUMENTS)
|
|
|
|
|
|
def test_instrument_effects():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("c", instrument="celesta")
|
|
assert p.reverb_mix == 0.3
|
|
assert p.reverb_type == "plate"
|
|
assert p.synth == "fm"
|
|
assert p.envelope == "mallet"
|
|
|
|
|
|
def test_instrument_808_bass():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("b", instrument="808_bass")
|
|
assert p.distortion_mix == 0.4
|
|
assert p.distortion_drive == 2.5
|
|
assert p.lowpass == 200
|
|
assert p.lowpass_q == 1.5
|
|
assert p.synth == "sine"
|
|
assert p.envelope == "pluck"
|
|
|
|
|
|
# ── Non-12-TET / Microtonal systems ─────────────────────────────────────────
|
|
|
|
from pytheory import TET
|
|
|
|
|
|
def test_tet_factory_creates_system():
|
|
edo17 = TET(17)
|
|
assert len(edo17.tone_names) == 17
|
|
assert edo17.semitones == 17
|
|
|
|
|
|
def test_tet_factory_numbered_tones():
|
|
edo17 = TET(17)
|
|
t = Tone("0", octave=4, system=edo17)
|
|
assert t.frequency == pytest.approx(440.0, rel=1e-3)
|
|
# One octave up
|
|
t_up = t.add(17)
|
|
assert t_up.frequency == pytest.approx(880.0, rel=1e-3)
|
|
|
|
|
|
def test_tet_factory_custom_names():
|
|
names = ["A", "B", "C", "D", "E"]
|
|
edo5 = TET(5, names=names)
|
|
assert len(edo5.tone_names) == 5
|
|
t = Tone("A", octave=4, system=edo5)
|
|
assert t.frequency == pytest.approx(440.0, rel=1e-3)
|
|
|
|
|
|
def test_tet_factory_wrong_name_count():
|
|
with pytest.raises(ValueError):
|
|
TET(5, names=["A", "B", "C"])
|
|
|
|
|
|
def test_19tet_system():
|
|
sys19 = SYSTEMS["19-tet"]
|
|
assert sys19.semitones == 19
|
|
a = Tone("A", octave=4, system=sys19)
|
|
assert a.frequency == pytest.approx(440.0, rel=1e-3)
|
|
# Octave should double
|
|
a5 = a.add(19)
|
|
assert a5.frequency == pytest.approx(880.0, rel=1e-3)
|
|
|
|
|
|
def test_19tet_scale():
|
|
sys19 = SYSTEMS["19-tet"]
|
|
ts = TonedScale(system=sys19, tonic=Tone("C", octave=4, system=sys19))
|
|
major = ts["major"]
|
|
assert len(major.tones) == 8 # 7 + octave
|
|
|
|
|
|
def test_31tet_system():
|
|
sys31 = SYSTEMS["31-tet"]
|
|
assert sys31.semitones == 31
|
|
a = Tone("A", octave=4, system=sys31)
|
|
assert a.frequency == pytest.approx(440.0, rel=1e-3)
|
|
|
|
|
|
def test_shruti_system():
|
|
shruti = SYSTEMS["shruti"]
|
|
assert shruti.semitones == 22
|
|
sa = Tone("Sa", octave=4, system=shruti)
|
|
# Sa should be near C4 (261.63 Hz) — not exact due to 22-TET
|
|
assert 250 < sa.frequency < 270
|
|
|
|
|
|
def test_shruti_octave():
|
|
shruti = SYSTEMS["shruti"]
|
|
sa4 = Tone("Sa", octave=4, system=shruti)
|
|
sa5 = sa4.add(22)
|
|
assert sa5.frequency == pytest.approx(sa4.frequency * 2, rel=1e-3)
|
|
|
|
|
|
def test_shruti_bhairav_scale():
|
|
shruti = SYSTEMS["shruti"]
|
|
ts = TonedScale(system=shruti, tonic=Tone("Sa", octave=4, system=shruti))
|
|
bhairav = ts["bhairav"]
|
|
names = [t.name for t in bhairav.tones]
|
|
assert names[0] == "Sa"
|
|
assert "komal Re" in names # the microtonal komal Re
|
|
assert len(bhairav.tones) == 8
|
|
|
|
|
|
def test_maqam_system():
|
|
maqam = SYSTEMS["maqam"]
|
|
assert maqam.semitones == 24
|
|
do = Tone("Do", octave=4, system=maqam)
|
|
assert 250 < do.frequency < 270
|
|
|
|
|
|
def test_maqam_rast_has_quarter_tones():
|
|
maqam = SYSTEMS["maqam"]
|
|
ts = TonedScale(system=maqam, tonic=Tone("Do", octave=4, system=maqam))
|
|
rast = ts["rast"]
|
|
names = [t.name for t in rast.tones]
|
|
# Rast should contain quarter-tone positions
|
|
assert any("↓" in n or "↑" in n for n in names)
|
|
|
|
|
|
def test_slendro_system():
|
|
slendro = SYSTEMS["slendro"]
|
|
assert slendro.semitones == 5
|
|
ji = Tone("ji", octave=4, system=slendro)
|
|
# 5 steps = octave
|
|
ji_up = ji.add(5)
|
|
assert ji_up.frequency == pytest.approx(ji.frequency * 2, rel=1e-3)
|
|
|
|
|
|
def test_pelog_system():
|
|
pelog = SYSTEMS["pelog"]
|
|
assert pelog.semitones == 9
|
|
ts = TonedScale(system=pelog, tonic=Tone("ji", octave=4, system=pelog))
|
|
full_pelog = ts["pelog"]
|
|
assert len(full_pelog.tones) == 8
|
|
|
|
|
|
def test_thai_system():
|
|
thai = SYSTEMS["thai"]
|
|
assert thai.semitones == 7
|
|
do = Tone("do", octave=4, system=thai)
|
|
# 7 steps = octave
|
|
do_up = do.add(7)
|
|
assert do_up.frequency == pytest.approx(do.frequency * 2, rel=1e-3)
|
|
|
|
|
|
def test_turkish_makam_system():
|
|
makam = SYSTEMS["makam"]
|
|
assert makam.semitones == 53
|
|
ts = TonedScale(system=makam, tonic=Tone("Do", octave=4, system=makam))
|
|
rast = ts["rast"]
|
|
assert len(rast.tones) == 8
|
|
|
|
|
|
def test_carnatic_system():
|
|
carnatic = SYSTEMS["carnatic"]
|
|
assert carnatic.semitones == 72
|
|
ts = TonedScale(system=carnatic, tonic=Tone("Sa", octave=4, system=carnatic))
|
|
shankarabharanam = ts["shankarabharanam"]
|
|
assert len(shankarabharanam.tones) == 8
|
|
|
|
|
|
def test_circle_of_fifths_19tet():
|
|
sys19 = SYSTEMS["19-tet"]
|
|
c = Tone("C", octave=4, system=sys19)
|
|
cof = c.circle_of_fifths()
|
|
assert len(cof) == 19 # should cycle through all 19 tones
|
|
|
|
|
|
def test_circle_of_fifths_western_unchanged():
|
|
"""Existing 12-TET circle of fifths should not be affected."""
|
|
c = Tone("C", octave=4, system="western")
|
|
cof = c.circle_of_fifths()
|
|
assert len(cof) == 12
|
|
assert cof[0].name == "C"
|
|
assert cof[1].name == "G"
|
|
|
|
|
|
def test_from_frequency_non12():
|
|
sys19 = SYSTEMS["19-tet"]
|
|
t = Tone.from_frequency(440.0, system=sys19)
|
|
assert t.name == "A"
|
|
assert t.octave == 4
|
|
|
|
|
|
def test_score_system_param():
|
|
"""Score passes system to parts for string→Tone resolution."""
|
|
from pytheory import Score, Duration
|
|
shruti = SYSTEMS["shruti"]
|
|
score = Score("4/4", bpm=120, system=shruti)
|
|
p = score.part("test", synth="sine")
|
|
assert p._system is shruti
|
|
# String "Sa" should resolve via shruti system, not western
|
|
p.add(Tone("Sa", octave=4, system=shruti), Duration.QUARTER)
|
|
assert len(p.notes) == 1
|
|
|
|
|
|
def test_interval_to_non12():
|
|
sys19 = SYSTEMS["19-tet"]
|
|
a = Tone("A", octave=4, system=sys19)
|
|
a5 = a.add(19)
|
|
result = a.interval_to(a5)
|
|
assert "octave" in result
|
|
|
|
|
|
# ── Dedicated instrument synths ──────────────────────────────────────────────
|
|
|
|
def test_all_dedicated_synths_render():
|
|
"""Every dedicated synth waveform produces valid audio."""
|
|
from pytheory.play import (piano_wave, bass_guitar_wave, flute_wave,
|
|
trumpet_wave, clarinet_wave, oboe_wave,
|
|
marimba_wave, harpsichord_wave, cello_wave,
|
|
harp_wave, upright_bass_wave,
|
|
acoustic_guitar_wave, electric_guitar_wave,
|
|
sitar_wave, SAMPLE_RATE)
|
|
synths = [piano_wave, bass_guitar_wave, flute_wave, trumpet_wave,
|
|
clarinet_wave, oboe_wave, marimba_wave, harpsichord_wave,
|
|
cello_wave, harp_wave, upright_bass_wave,
|
|
acoustic_guitar_wave, electric_guitar_wave, sitar_wave]
|
|
for fn in synths:
|
|
wave = fn(440, n_samples=11025)
|
|
assert len(wave) == 11025
|
|
assert wave.dtype == numpy.int16
|
|
assert numpy.abs(wave).max() > 0
|
|
|
|
|
|
def test_piano_brightness_scales():
|
|
"""High-pitched piano should be brighter (more high harmonics)."""
|
|
from pytheory.play import piano_wave
|
|
low = piano_wave(130, n_samples=22050) # C3
|
|
high = piano_wave(1047, n_samples=22050) # C6
|
|
# Both should produce valid audio
|
|
assert numpy.abs(low).max() > 0
|
|
assert numpy.abs(high).max() > 0
|
|
|
|
|
|
def test_acoustic_guitar_body_resonance():
|
|
"""Acoustic guitar should produce richer spectrum than raw pluck."""
|
|
from pytheory.play import acoustic_guitar_wave, pluck_wave
|
|
ag = acoustic_guitar_wave(220, n_samples=22050)
|
|
pk = pluck_wave(220, n_samples=22050)
|
|
assert len(ag) == len(pk) == 22050
|
|
|
|
|
|
def test_cello_has_vibrato():
|
|
"""Cello synth should produce pitch variation (vibrato)."""
|
|
from pytheory.play import cello_wave
|
|
wave = cello_wave(220, n_samples=44100)
|
|
assert len(wave) == 44100
|
|
assert numpy.abs(wave).max() > 0
|
|
|
|
|
|
# ── Cabinet simulation ───────────────────────────────────────────────────────
|
|
|
|
def test_cabinet_reduces_highs():
|
|
"""Cabinet sim should reduce high-frequency content."""
|
|
from pytheory.play import _apply_cabinet
|
|
# White noise has flat spectrum
|
|
noise = numpy.random.uniform(-1, 1, 44100).astype(numpy.float32)
|
|
cabbed = _apply_cabinet(noise, brightness=0.5)
|
|
# RMS of cabbed should be lower (energy removed by filters)
|
|
assert numpy.sqrt(numpy.mean(cabbed ** 2)) < numpy.sqrt(numpy.mean(noise ** 2))
|
|
|
|
|
|
def test_cabinet_brightness_param():
|
|
"""Higher brightness = more high-frequency content passes through."""
|
|
from pytheory.play import _apply_cabinet
|
|
noise = numpy.random.uniform(-1, 1, 44100).astype(numpy.float32)
|
|
dark = _apply_cabinet(noise, brightness=0.0)
|
|
bright = _apply_cabinet(noise, brightness=1.0)
|
|
# Bright should have more energy than dark
|
|
assert numpy.sqrt(numpy.mean(bright ** 2)) > numpy.sqrt(numpy.mean(dark ** 2))
|
|
|
|
|
|
# ── Analog drift ─────────────────────────────────────────────────────────────
|
|
|
|
def test_analog_drift_varies_pitch():
|
|
"""Analog drift should make repeated renders slightly different."""
|
|
from pytheory import Score, Duration
|
|
score1 = Score("4/4", bpm=120)
|
|
p1 = score1.part("t", synth="saw", analog=0.5)
|
|
p1.add("C4", Duration.QUARTER)
|
|
p1.add("C4", Duration.QUARTER)
|
|
# With analog > 0, each C4 gets a random pitch offset
|
|
# This is hard to test deterministically, just verify it renders
|
|
from pytheory.play import render_score
|
|
buf = render_score(score1)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Guitar strumming ─────────────────────────────────────────────────────────
|
|
|
|
def test_strum_requires_fretboard():
|
|
"""Strumming without a fretboard should raise ValueError."""
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("g", synth="saw")
|
|
with pytest.raises(ValueError, match="fretboard"):
|
|
p.strum("Am", Duration.QUARTER)
|
|
|
|
|
|
def test_strum_adds_notes():
|
|
"""Strumming should add notes to the part."""
|
|
from pytheory import Score, Duration, Fretboard
|
|
score = Score("4/4", bpm=120)
|
|
fb = Fretboard.guitar()
|
|
p = score.part("g", instrument="acoustic_guitar", fretboard=fb)
|
|
p.strum("Am", Duration.HALF)
|
|
assert len(p.notes) > 0
|
|
|
|
|
|
def test_strum_direction():
|
|
"""Both down and up strums should work."""
|
|
from pytheory import Score, Duration, Fretboard
|
|
score = Score("4/4", bpm=120)
|
|
fb = Fretboard.guitar()
|
|
p = score.part("g", instrument="acoustic_guitar", fretboard=fb)
|
|
p.strum("G", Duration.QUARTER, direction="down")
|
|
p.strum("G", Duration.QUARTER, direction="up")
|
|
assert len(p.notes) >= 2 # grace notes + chord per strum
|
|
|
|
|
|
# ── World drums ──────────────────────────────────────────────────────────────
|
|
|
|
def test_tabla_sounds_render():
|
|
"""All tabla drum sounds should produce valid audio."""
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.TABLA_NA, DrumSound.TABLA_TIN, DrumSound.TABLA_GE,
|
|
DrumSound.TABLA_DHA, DrumSound.TABLA_TIT, DrumSound.TABLA_KE]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
assert wave.dtype == numpy.float32
|
|
|
|
|
|
def test_dhol_sounds_render():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.DHOL_DAGGA, DrumSound.DHOL_TILLI, DrumSound.DHOL_BOTH]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
|
|
|
|
def test_mridangam_sounds_render():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.MRIDANGAM_THAM, DrumSound.MRIDANGAM_NAM,
|
|
DrumSound.MRIDANGAM_DIN, DrumSound.MRIDANGAM_THA]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
|
|
|
|
def test_djembe_sounds_render():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.DJEMBE_BASS, DrumSound.DJEMBE_TONE, DrumSound.DJEMBE_SLAP]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
|
|
|
|
def test_metal_kit_sounds_render():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.METAL_KICK, DrumSound.METAL_SNARE, DrumSound.METAL_HAT]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
|
|
|
|
def test_tabla_pattern_presets():
|
|
"""All tabla patterns should load without error."""
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["teental", "jhaptaal", "rupak", "dadra",
|
|
"keherwa", "tabla solo", "tiri kita"]:
|
|
p = Pattern.preset(name)
|
|
assert p.beats > 0
|
|
|
|
|
|
def test_world_drum_pattern_presets():
|
|
"""All world drum patterns should load."""
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["bhangra", "dhol chaal", "qawwali", "dholak folk",
|
|
"adi talam", "mridangam korvai", "djembe", "kuku", "soli",
|
|
"double kick", "metal blast", "metal groove", "metal gallop"]:
|
|
p = Pattern.preset(name)
|
|
assert p.beats > 0
|
|
|
|
|
|
# ── Guitar presets with cabinet sim ──────────────────────────────────────────
|
|
|
|
def test_guitar_presets_have_cabinet():
|
|
"""Distorted guitar presets should have cabinet simulation."""
|
|
from pytheory import Score
|
|
for preset in ["distorted_guitar", "orange_crunch", "metal_guitar"]:
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("g", instrument=preset)
|
|
assert p.cabinet > 0, f"{preset} should have cabinet sim"
|
|
|
|
|
|
def test_clean_guitar_preset():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("g", instrument="clean_guitar")
|
|
assert p.synth == "electric_guitar_synth"
|
|
assert p.cabinet > 0
|
|
|
|
|
|
# ── New instrument synths (v0.36+) ──────────────────────────────────────────
|
|
|
|
def test_new_synths_render():
|
|
"""All 7 new synths produce valid audio."""
|
|
from pytheory.play import (pedal_steel_wave, theremin_wave, kalimba_wave,
|
|
steel_drum_wave, accordion_wave,
|
|
didgeridoo_wave, bagpipe_wave,
|
|
banjo_wave, mandolin_wave, ukulele_wave,
|
|
vocal_wave, SAMPLE_RATE)
|
|
synths = [pedal_steel_wave, theremin_wave, kalimba_wave, steel_drum_wave,
|
|
accordion_wave, didgeridoo_wave, bagpipe_wave,
|
|
banjo_wave, mandolin_wave, ukulele_wave, vocal_wave]
|
|
for fn in synths:
|
|
wave = fn(440, n_samples=11025)
|
|
assert len(wave) == 11025
|
|
assert wave.dtype == numpy.int16
|
|
assert numpy.abs(wave).max() > 0
|
|
|
|
|
|
def test_vocal_synth_with_lyric():
|
|
"""Vocal synth accepts lyric parameter."""
|
|
from pytheory.play import vocal_wave
|
|
for lyric in ["ah", "ee", "oh", "oo", "hi", "la"]:
|
|
wave = vocal_wave(330, n_samples=11025, lyric=lyric)
|
|
assert len(wave) == 11025
|
|
assert numpy.abs(wave).max() > 0
|
|
|
|
|
|
def test_vocal_different_vowels_differ():
|
|
"""Different vowels should produce different waveforms."""
|
|
from pytheory.play import vocal_wave
|
|
ah = vocal_wave(330, n_samples=22050, lyric="ah")
|
|
ee = vocal_wave(330, n_samples=22050, lyric="ee")
|
|
# They should differ (different formant peaks)
|
|
assert not numpy.array_equal(ah, ee)
|
|
|
|
|
|
def test_all_instrument_presets_create():
|
|
"""Every instrument preset in INSTRUMENTS should create a valid Part."""
|
|
from pytheory import Score
|
|
from pytheory.rhythm import INSTRUMENTS
|
|
for name in INSTRUMENTS:
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("test", instrument=name)
|
|
assert p.synth is not None
|
|
|
|
|
|
def test_new_instrument_presets():
|
|
"""New instrument presets have correct synths."""
|
|
from pytheory import Score
|
|
presets = {
|
|
"pedal_steel": "pedal_steel_synth",
|
|
"theremin": "theremin_synth",
|
|
"kalimba": "kalimba_synth",
|
|
"steel_drum": "steel_drum_synth",
|
|
"accordion": "accordion_synth",
|
|
"didgeridoo": "didgeridoo_synth",
|
|
"bagpipe": "bagpipe_synth",
|
|
"banjo": "banjo_synth",
|
|
"mandolin": "mandolin_synth",
|
|
"ukulele": "ukulele_synth",
|
|
}
|
|
for name, expected_synth in presets.items():
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("t", instrument=name)
|
|
assert p.synth == expected_synth, f"{name} has {p.synth}, expected {expected_synth}"
|
|
|
|
|
|
# ── Cajón drums ─────────────────────────────────────────────────────────────
|
|
|
|
def test_cajon_sounds_render():
|
|
from pytheory.play import _render_drum_hit
|
|
from pytheory.rhythm import DrumSound
|
|
for sound in [DrumSound.CAJON_BASS, DrumSound.CAJON_SLAP, DrumSound.CAJON_TAP]:
|
|
wave = _render_drum_hit(sound.value, 22050)
|
|
assert len(wave) == 22050
|
|
assert wave.dtype == numpy.float32
|
|
|
|
|
|
def test_cajon_patterns():
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["cajon", "cajon rumba", "cajon folk"]:
|
|
p = Pattern.preset(name)
|
|
assert p.beats > 0
|
|
|
|
|
|
# ── Pitch bends ─────────────────────────────────────────────────────────────
|
|
|
|
def test_pitch_bend_renders():
|
|
"""Pitch bend should produce valid audio without errors."""
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("t", instrument="electric_guitar")
|
|
p.add("A4", Duration.HALF, bend=2, bend_type="smooth")
|
|
p.add("A4", Duration.HALF, bend=-1, bend_type="late")
|
|
p.add("A4", Duration.HALF, bend=3, bend_type="linear")
|
|
p.add("A4", Duration.HALF)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
def test_pitch_bend_types():
|
|
"""All three bend types should work."""
|
|
from pytheory.rhythm import Note, Duration
|
|
for bt in ["smooth", "linear", "late"]:
|
|
n = Note(tone=None, duration=Duration.QUARTER, bend=2, bend_type=bt)
|
|
assert n.bend_type == bt
|
|
|
|
|
|
# ── Roll method ─────────────────────────────────────────────────────────────
|
|
|
|
def test_roll_adds_notes():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("t", instrument="timpani")
|
|
p.roll("C3", Duration.WHOLE, velocity_start=30, velocity_end=100)
|
|
assert len(p.notes) > 4 # should be many 16th notes
|
|
|
|
|
|
def test_roll_velocity_ramp():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("t", instrument="timpani")
|
|
p.roll("C3", Duration.WHOLE, velocity_start=20, velocity_end=100)
|
|
velocities = [n.velocity for n in p.notes]
|
|
# First should be quieter than last
|
|
assert velocities[0] < velocities[-1]
|
|
|
|
|
|
def test_roll_custom_speed():
|
|
from pytheory import Score, Duration
|
|
score = Score("4/4", bpm=120)
|
|
p = score.part("t", synth="sine")
|
|
p.roll("A4", Duration.WHOLE, speed=0.125) # 32nd notes
|
|
# 4 beats / 0.125 = 32 notes
|
|
assert len(p.notes) == 32
|
|
|
|
|
|
# ── Int tone names ──────────────────────────────────────────────────────────
|
|
|
|
def test_int_tone_name():
|
|
from pytheory import Tone, TET
|
|
edo = TET(22)
|
|
t = Tone(0, octave=4, system=edo)
|
|
assert t.name == "0"
|
|
assert t.frequency == pytest.approx(440.0, rel=1e-3)
|
|
|
|
|
|
def test_int_tone_wrapping():
|
|
from pytheory import Tone, TET
|
|
edo = TET(22)
|
|
t = Tone(22, octave=4, system=edo)
|
|
assert t.name == "0"
|
|
assert t.octave == 5
|
|
assert t.frequency == pytest.approx(880.0, rel=1e-3)
|
|
|
|
|
|
def test_int_tone_negative():
|
|
from pytheory import Tone, TET
|
|
edo = TET(22)
|
|
t = Tone(-1, octave=4, system=edo)
|
|
assert t.name == "21"
|
|
assert t.octave == 3
|
|
|
|
|
|
def test_system_tone_method():
|
|
from pytheory import TET
|
|
edo = TET(19)
|
|
t = edo.tone(5, octave=4)
|
|
assert t.name == "5"
|
|
assert t.octave == 4
|
|
|
|
|
|
# ── B#/Cb octave boundary ──────────────────────────────────────────────────
|
|
|
|
def test_b_sharp_octave():
|
|
t = Tone("B#4")
|
|
assert t.octave == 5
|
|
assert t.frequency == pytest.approx(Tone("C5").frequency, rel=1e-3)
|
|
|
|
|
|
def test_c_flat_octave():
|
|
t = Tone("Cb4")
|
|
assert t.octave == 3
|
|
assert t.frequency == pytest.approx(Tone("B3").frequency, rel=1e-3)
|
|
|
|
|
|
# ── Note choking ────────────────────────────────────────────────────────────
|
|
|
|
def test_note_choking_renders():
|
|
"""Fast repeated notes should render without errors (choking active)."""
|
|
from pytheory import Score, Duration
|
|
from pytheory.play import render_score
|
|
score = Score("4/4", bpm=200)
|
|
p = score.part("t", instrument="piano")
|
|
for _ in range(32):
|
|
p.add("C4", Duration.SIXTEENTH)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Score system/temperament ───────────────────────────────────────────────
|
|
|
|
def test_score_temperament():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120, temperament="just")
|
|
assert score.temperament == "just"
|
|
|
|
|
|
def test_score_reference_pitch():
|
|
from pytheory import Score
|
|
score = Score("4/4", bpm=120, reference_pitch=415.0)
|
|
assert score.reference_pitch == 415.0
|
|
|
|
|
|
def test_score_system_propagates():
|
|
from pytheory import Score, SYSTEMS
|
|
shruti = SYSTEMS["shruti"]
|
|
score = Score("4/4", bpm=120, system=shruti)
|
|
p = score.part("t", synth="sine")
|
|
assert p._system is shruti
|
|
|
|
|
|
# ── Synth enum count ────────────────────────────────────────────────────────
|
|
|
|
def test_synth_enum_count():
|
|
from pytheory.play import Synth
|
|
assert len(Synth) == 42
|
|
|
|
|
|
def test_all_synths_render_and_enum_match():
|
|
"""Every Synth enum member should render valid audio."""
|
|
from pytheory.play import Synth
|
|
for s in Synth:
|
|
wave = s(440, n_samples=1000)
|
|
assert len(wave) == 1000
|
|
|
|
|
|
# ── Articulations ────────────────────────────────────────────────────────
|
|
|
|
def test_articulation_field_on_note():
|
|
from pytheory.rhythm import Note, Duration
|
|
n = Note(tone=None, duration=Duration.QUARTER, articulation="staccato")
|
|
assert n.articulation == "staccato"
|
|
|
|
|
|
def test_articulation_default_empty():
|
|
from pytheory.rhythm import Note, Duration
|
|
n = Note(tone=None, duration=Duration.QUARTER)
|
|
assert n.articulation == ""
|
|
|
|
|
|
def test_part_add_articulation():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.add("C4", Duration.QUARTER, articulation="staccato")
|
|
p.add("D4", Duration.QUARTER, articulation="legato")
|
|
p.add("E4", Duration.QUARTER, articulation="marcato")
|
|
p.add("F4", Duration.QUARTER, articulation="tenuto")
|
|
p.add("G4", Duration.QUARTER, articulation="accent")
|
|
p.add("A4", Duration.QUARTER, articulation="fermata")
|
|
assert len(p.notes) == 6
|
|
assert p.notes[0].articulation == "staccato"
|
|
assert p.notes[5].articulation == "fermata"
|
|
|
|
|
|
@needs_portaudio
|
|
def test_articulations_render():
|
|
"""Articulations should produce audio without errors."""
|
|
from pytheory.play import render_score
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine", volume=0.3)
|
|
for art in ["", "staccato", "legato", "marcato", "tenuto", "accent", "fermata"]:
|
|
p.add("C4", Duration.QUARTER, articulation=art)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Dynamic curves ───────────────────────────────────────────────────────
|
|
|
|
def test_crescendo_adds_notes():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.crescendo(["C4", "D4", "E4", "F4"], Duration.QUARTER,
|
|
start_vel=40, end_vel=100)
|
|
assert len(p.notes) == 4
|
|
assert p.notes[0].velocity == 40
|
|
assert p.notes[3].velocity == 100
|
|
|
|
|
|
def test_decrescendo_adds_notes():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.decrescendo(["C4", "D4", "E4", "F4"], Duration.QUARTER,
|
|
start_vel=110, end_vel=40)
|
|
assert len(p.notes) == 4
|
|
assert p.notes[0].velocity == 110
|
|
assert p.notes[3].velocity == 40
|
|
|
|
|
|
def test_swell_velocity_shape():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.swell(["C4", "D4", "E4", "F4", "G4"], Duration.QUARTER,
|
|
low_vel=30, peak_vel=110)
|
|
assert len(p.notes) == 5
|
|
# First and last should be near low_vel
|
|
assert p.notes[0].velocity == 30
|
|
assert p.notes[4].velocity == 30
|
|
# Middle should be at or near peak
|
|
assert p.notes[2].velocity == 110
|
|
|
|
|
|
def test_dynamics_custom_velocities():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.dynamics(["C4", "D4", "E4"], Duration.QUARTER,
|
|
velocities=[50, 100, 75])
|
|
assert p.notes[0].velocity == 50
|
|
assert p.notes[1].velocity == 100
|
|
assert p.notes[2].velocity == 75
|
|
|
|
|
|
def test_dynamics_with_articulation():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="sine")
|
|
p.crescendo(["C4", "D4"], Duration.QUARTER,
|
|
start_vel=40, end_vel=100, articulation="staccato")
|
|
assert p.notes[0].articulation == "staccato"
|
|
assert p.notes[1].articulation == "staccato"
|
|
|
|
|
|
# ── Part.hit() ───────────────────────────────────────────────────────────
|
|
|
|
def test_part_hit_adds_note():
|
|
from pytheory.rhythm import DrumSound, _DrumTone
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("kit", synth="sine")
|
|
p.hit(DrumSound.KICK, Duration.QUARTER, velocity=100)
|
|
p.hit(DrumSound.SNARE, Duration.QUARTER, velocity=90, articulation="accent")
|
|
assert len(p.notes) == 2
|
|
assert isinstance(p.notes[0].tone, _DrumTone)
|
|
assert p.notes[0].tone.sound == DrumSound.KICK
|
|
assert p.notes[1].articulation == "accent"
|
|
|
|
|
|
@needs_portaudio
|
|
def test_part_hit_renders():
|
|
"""Part.hit() drum sounds should render through the note pipeline."""
|
|
from pytheory.rhythm import DrumSound
|
|
from pytheory.play import render_score
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("kit", synth="sine", volume=0.5)
|
|
p.hit(DrumSound.KICK, Duration.QUARTER)
|
|
p.hit(DrumSound.SNARE, Duration.QUARTER)
|
|
p.hit(DrumSound.CLOSED_HAT, Duration.QUARTER)
|
|
p.hit(DrumSound.CRASH, Duration.QUARTER)
|
|
buf = render_score(score)
|
|
assert len(buf) > 0
|
|
|
|
|
|
# ── Part.ramp() ──────────────────────────────────────────────────────────
|
|
|
|
def test_ramp_generates_automation():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="saw", lowpass=200)
|
|
p.ramp(over=4.0, lowpass=8000)
|
|
# Should have generated automation points
|
|
assert len(p._automation) > 0
|
|
# First point should be near 200, last near 8000
|
|
first_lp = p._automation[0][1].get("lowpass", 0)
|
|
last_lp = p._automation[-1][1].get("lowpass", 0)
|
|
assert first_lp < 1000 # near start
|
|
assert last_lp > 7000 # near target
|
|
|
|
|
|
def test_ramp_easing_curves():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
for curve in ["linear", "ease_in", "ease_out", "ease_in_out"]:
|
|
p = score.part(f"test_{curve}", synth="saw", lowpass=200)
|
|
p.ramp(over=4.0, curve=curve, lowpass=8000)
|
|
assert len(p._automation) > 0
|
|
|
|
|
|
def test_ramp_multiple_params():
|
|
score = pytheory.Score("4/4", bpm=120)
|
|
p = score.part("test", synth="saw", lowpass=200)
|
|
p.ramp(over=4.0, lowpass=8000, reverb=0.5)
|
|
# Should have both params in automation points
|
|
last_point = p._automation[-1][1]
|
|
assert "lowpass" in last_point
|
|
assert "reverb_mix" in last_point # mapped from "reverb"
|
|
|
|
|
|
# ── Cross-choke ──────────────────────────────────────────────────────────
|
|
|
|
def test_djembe_patterns_exist():
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["djembe", "kuku", "soli", "dununba", "tiriba",
|
|
"yankadi", "djansa", "mendiani"]:
|
|
p = Pattern.preset(name)
|
|
assert p.beats > 0
|
|
assert len(p.hits) > 0
|
|
|
|
|
|
def test_djembe_fills_exist():
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["djembe call", "djembe roll", "djembe break"]:
|
|
f = Pattern.fill(name)
|
|
assert f.beats == 4.0
|
|
assert len(f.hits) > 0
|
|
|
|
|
|
def test_cajon_fills_exist():
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["cajon flam", "cajon rumble", "cajon breakdown"]:
|
|
f = Pattern.fill(name)
|
|
assert f.beats == 4.0
|
|
assert len(f.hits) > 0
|
|
|
|
|
|
def test_metal_fills_exist():
|
|
from pytheory.rhythm import Pattern
|
|
for name in ["metal triplet", "metal blast", "metal cascade"]:
|
|
f = Pattern.fill(name)
|
|
assert f.beats == 4.0
|
|
assert len(f.hits) > 0
|
|
|
|
|
|
# ── render_score in __all__ ──────────────────────────────────────────────
|
|
|
|
def test_render_score_exported():
|
|
assert "render_score" in pytheory.__all__
|