Cubase-MCP-GAJ3T.MusicGen.R.../tests/integration/test_text_to_midi.py

262 lines
9.7 KiB
Python

"""Real standard-profile text -> intent -> score -> compiled SMF -> disk read-back."""
import shutil
import uuid
from collections.abc import Iterator
from fractions import Fraction
from pathlib import Path
import mido # type: ignore[import-untyped]
import pytest
from riff_groove_builder.articulations import compile_score
from riff_groove_builder.compose import compose_score
from riff_groove_builder.description import resolve_description
from riff_groove_builder.errors import UnsupportedArticulationError, UnsupportedDescriptionError
from riff_groove_builder.midi import validate_midi_file, write_midi
from riff_groove_builder.profiles import load_profile_registry
from riff_groove_builder.schemas import GenerateMusicRequest, Part, ProfileSelection, Score
ROOT = Path(__file__).resolve().parents[2]
pytestmark = pytest.mark.integration
Event = tuple[int, str, int, int, int]
@pytest.fixture
def workspace() -> Iterator[Path]:
path = ROOT / ".test-artifacts" / f"text-midi-{uuid.uuid4().hex}"
path.mkdir(parents=True)
try:
yield path
finally:
shutil.rmtree(path)
def generate(text: str, path: Path, seed: int = 0) -> Score:
request = GenerateMusicRequest(description=text, basename=path.stem, seed=seed)
resolved = resolve_description(request)
selected = load_profile_registry().select(
resolved.intent.parts,
ProfileSelection(
**{
part: "standard.gm-drums.v1" if part == "drums" else f"standard.{part}.v1"
for part in resolved.intent.parts
}
),
)
assert all(profile.provenance.status == "standard_midi" for profile in selected.values())
assert all(profile.summary.mapping_kind == "standard_midi" for profile in selected.values())
assert {part: profile.id for part, profile in selected.items()} == {
part: {
"lead": "standard.lead.v1",
"bass": "standard.bass.v1",
"drums": "standard.gm-drums.v1",
}[part]
for part in resolved.intent.parts
}
score = compose_score(resolved.intent, selected)
plan = compile_score(score, selected)
assert write_midi(path, plan) == path
validate_midi_file(path, plan)
return score
def events(path: Path) -> list[list[Event]]:
result: list[list[Event]] = []
for track in mido.MidiFile(path).tracks[1:]:
tick = 0
part: list[Event] = []
for message in track:
tick += message.time
if not message.is_meta:
assert message.type in ("note_on", "note_off")
part.append((tick, message.type, message.channel, message.note, message.velocity))
result.append(part)
return result
@pytest.mark.parametrize(
("text", "parts", "tempo", "bars", "meter", "root", "minor"),
[
("lead only 90 BPM 2 bars 3/4 D major quarter", ["lead"], 90, 2, (3, 4), 2, False),
("bass only 72.5 BPM 3 bars 6/8 Bb minor eighth", ["bass"], 72.5, 3, (6, 8), 10, True),
("drums only 155 BPM 2 bars 7/8 sixteenth", ["drums"], 155, 2, (7, 8), 4, True),
(
"lead bass drums 137.5 BPM 4 bars 4/4 F# minor eighth",
["lead", "bass", "drums"],
137.5,
4,
(4, 4),
6,
True,
),
(
"no drums 111 BPM 1 bar 7/8 Eb major quarter rests",
["lead", "bass"],
111,
1,
(7, 8),
3,
False,
),
],
)
def test_real_disk_tempo_meter_parts_pitch_timing_and_pairing(
workspace: Path,
text: str,
parts: list[Part],
tempo: float,
bars: int,
meter: tuple[int, int],
root: int,
minor: bool,
) -> None:
path = workspace / "description.mid"
score = generate(text, path)
assert score.intent.parts == parts
midi = mido.MidiFile(path)
assert midi.type == 1
assert midi.ticks_per_beat == 960
assert len(midi.tracks) == len(parts) + 1
expected_end = Fraction(bars * meter[0] * 4 * 960, meter[1])
assert expected_end.denominator == 1
conductor = midi.tracks[0]
assert [(msg.tempo, msg.time) for msg in conductor if msg.type == "set_tempo"] == [
(round(60_000_000 / tempo), 0)
]
assert [
(msg.numerator, msg.denominator, msg.time)
for msg in conductor
if msg.type == "time_signature"
] == [(*meter, 0)]
assert abs(midi.length - float(expected_end / 960) * round(60_000_000 / tempo) / 1e6) < 1e-9
for track in midi.tracks:
assert sum(msg.time for msg in track) == expected_end
assert track[-1].type == "end_of_track"
scale = {0, 2, 3, 5, 7, 8, 10} if minor else {0, 2, 4, 5, 7, 9, 11}
for part, track, actual in zip(parts, midi.tracks[1:], events(path), strict=True):
assert track[0].name == part.capitalize()
channel = {"lead": 0, "bass": 1, "drums": 9}[part]
active: dict[int, int] = {}
onsets = 0
for tick, kind, ch, pitch, velocity in actual:
assert ch == channel
assert 0 <= tick <= expected_end
if kind == "note_on":
assert pitch not in active
assert tick < expected_end and 1 <= velocity <= 127
active[pitch] = tick
onsets += 1
if part == "drums":
assert pitch in {36, 38, 42} # Independently known GM kick/snare/hat.
else:
assert 0 <= pitch <= 127
assert (pitch - root) % 12 in (scale if part == "lead" else {0, 7})
assert (58 <= pitch <= 80) if part == "lead" else (34 <= pitch <= 53)
else:
assert pitch in active and active.pop(pitch) < tick
assert not active
assert onsets > 0
def test_precise_independent_bass_events(workspace: Path) -> None:
path = workspace / "bass.mid"
generate("bass only 1 bar C major quarter", path)
assert events(path) == [
[
(0, "note_on", 1, 36, 64),
(960, "note_off", 1, 36, 0),
(960, "note_on", 1, 43, 96),
(1920, "note_off", 1, 43, 0),
(1920, "note_on", 1, 36, 64),
(2880, "note_off", 1, 36, 0),
(2880, "note_on", 1, 43, 80),
(3840, "note_off", 1, 43, 0),
]
]
def test_precise_independent_drum_events(workspace: Path) -> None:
path = workspace / "drums.mid"
generate("drums only 1 bar quarter", path)
assert events(path) == [
[
(0, "note_on", 9, 36, 64),
(0, "note_on", 9, 42, 64),
(240, "note_off", 9, 36, 0),
(240, "note_off", 9, 42, 0),
(960, "note_on", 9, 38, 64),
(960, "note_on", 9, 42, 64),
(1200, "note_off", 9, 38, 0),
(1200, "note_off", 9, 42, 0),
(1920, "note_on", 9, 36, 64),
(1920, "note_on", 9, 42, 64),
(2160, "note_off", 9, 36, 0),
(2160, "note_off", 9, 42, 0),
(2880, "note_on", 9, 38, 80),
(2880, "note_on", 9, 42, 80),
(3120, "note_off", 9, 38, 0),
(3120, "note_off", 9, 42, 0),
]
]
def test_seeded_byte_determinism_and_changed_seed_content(workspace: Path) -> None:
paths = [workspace / f"seed-{index}.mid" for index in range(3)]
for path, seed in zip(paths, (123, 123, 124), strict=True):
generate("lead bass drums 2 bars 7/8 metal sixteenth", path, seed)
assert paths[0].read_bytes() == paths[1].read_bytes()
assert events(paths[0]) == events(paths[1])
assert events(paths[0]) != events(paths[2])
def test_text_changes_measurable_rhythm_and_duration(workspace: Path) -> None:
descriptions = ("quarter", "eighth", "sixteenth", "eighth rests", "eighth metal")
counts: list[list[int]] = []
onsets: list[list[list[int]]] = []
for index, text in enumerate(descriptions):
path = workspace / f"rhythm-{index}.mid"
generate(f"bass drums 1 bar {text}", path)
actual = events(path)
starts = [[tick for tick, kind, _, _, _ in track if kind == "note_on"] for track in actual]
onsets.append(starts)
counts.append([len(track) for track in starts])
assert all(sum(msg.time for msg in track) == 3840 for track in mido.MidiFile(path).tracks)
assert counts == [[4, 8], [8, 12], [16, 20], [7, 11], [8, 16]]
assert onsets[0][0] == [0, 960, 1920, 2880]
assert onsets[1][0] == list(range(0, 3840, 480))
assert onsets[2][0] == list(range(0, 3840, 240))
assert onsets[3][0] == list(range(0, 3360, 480))
def test_scalar_text_changes_survive_disk_readback(workspace: Path) -> None:
variants = (
"bass 1 bar C major quarter",
"bass 1 bar D minor quarter",
"bass 1 bar C major quarter 90 bpm",
"bass 2 bars C major quarter",
"bass 1 bar C major quarter 3/4",
)
paths = [workspace / f"scalar-{index}.mid" for index in range(len(variants))]
for text, path in zip(variants, paths, strict=True):
generate(text, path)
assert events(paths[0]) != events(paths[1]) # Key changes actual pitches.
assert events(paths[0]) == events(paths[2]) # Tempo changes metadata, not tick positions.
assert paths[0].read_bytes() != paths[2].read_bytes()
assert [sum(msg.time for msg in mido.MidiFile(path).tracks[0]) for path in paths] == [
3840,
3840,
3840,
7680,
2880,
]
@pytest.mark.parametrize(
"text", ["lead palm mute", "bass palm mute", "drums palm mute", "lead slide", "guitar audio"]
)
def test_unsupported_material_fails_before_any_artifact(workspace: Path, text: str) -> None:
with pytest.raises((UnsupportedArticulationError, UnsupportedDescriptionError)):
generate(text, workspace / "must-not-exist.mid")
assert list(workspace.iterdir()) == []