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

429 lines
16 KiB
Python

"""Real disk and independent MIDIUtil evidence with exclusively synthetic maps."""
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 midiutil import MIDIFile # type: ignore[import-untyped]
from riff_groove_builder.errors import SerializationError
from riff_groove_builder.midi import validate_midi_file, write_midi
from riff_groove_builder.schemas import (
ControlChangeEvent,
DrumNote,
EventPlan,
EventTrack,
MusicalIntent,
NoteOffEvent,
NoteOnEvent,
Part,
PitchedNote,
PositiveBeat,
RationalBeat,
ScheduledEvent,
Score,
ScoreTrack,
TimeSignature,
)
pytestmark = pytest.mark.integration
Event = tuple[int, str, int, int, int]
PARTS: list[Part] = ["bass", "drums", "lead"]
@pytest.fixture
def workspace() -> Iterator[Path]:
root = (
Path(__file__).resolve().parents[2] / ".test-artifacts" / f"midi-files-{uuid.uuid4().hex}"
)
root.mkdir(parents=True)
try:
yield root
finally:
shutil.rmtree(root)
def synthetic_plan(numerator: int = 4, denominator: int = 4, bpm: float = 137.5) -> EventPlan:
"""All pitches/controllers/channels below are arbitrary test-local numbers."""
signature = TimeSignature.model_validate({"numerator": numerator, "denominator": denominator})
duration = Fraction(numerator * 4, denominator)
musical_end = 240 + int(duration * 960)
score_end = Fraction(2) + duration
score = Score(
intent=MusicalIntent(
description="Synthetic three-part MIDI interoperability fixture",
parts=PARTS.copy(),
tempo_bpm=bpm,
bars=1,
time_signature=signature,
key="A minor",
seed=0,
),
start=RationalBeat(numerator=2),
end=RationalBeat(numerator=score_end.numerator, denominator=score_end.denominator),
tracks=[
ScoreTrack(
part="bass",
notes=[
PitchedNote(
part="bass",
pitch=45,
start=RationalBeat(numerator=2),
duration=PositiveBeat(
numerator=duration.numerator, denominator=duration.denominator
),
intensity=0.5,
articulation="synthetic_bass",
)
],
),
ScoreTrack(
part="drums",
notes=[
DrumNote(
voice="synthetic_hit",
start=RationalBeat(numerator=start, denominator=denom),
duration=PositiveBeat(numerator=1, denominator=8),
intensity=0.5,
articulation="synthetic_drum",
)
for start, denom in ((2, 1), (5, 2))
],
),
ScoreTrack(
part="lead",
notes=[
PitchedNote(
part="lead",
pitch=69,
start=RationalBeat(numerator=start, denominator=3),
duration=PositiveBeat(numerator=length, denominator=3),
intensity=0.5,
articulation="synthetic_lead",
)
for start, length in ((6, 1), (7, 2))
],
),
],
)
# tick, kind, channel, data1, data2, role. Kept deliberately out of tick order.
raw: dict[Part, list[tuple[int, str, int, int, int, str]]] = {
"lead": [
(musical_end + 60, "control_change", 2, 21, 0, "articulation_control"),
(240, "note_on", 2, 69, 97, "musical_note"),
(0, "note_on", 2, 5, 33, "keyswitch"),
(560, "note_on", 2, 69, 88, "musical_note"),
(80, "control_change", 2, 21, 100, "articulation_control"),
(280, "note_off", 2, 5, 33, "keyswitch"),
(1200, "note_off", 2, 69, 88, "musical_note"),
(560, "note_off", 2, 69, 97, "musical_note"),
],
"bass": [
(musical_end, "note_off", 5, 45, 83, "musical_note"),
(0, "note_on", 5, 6, 34, "keyswitch"),
(120, "control_change", 5, 22, 88, "articulation_control"),
(240, "note_on", 5, 45, 83, "musical_note"),
(100, "note_off", 5, 6, 34, "keyswitch"),
(musical_end + 80, "control_change", 5, 22, 0, "articulation_control"),
],
"drums": [
(musical_end + 120, "control_change", 12, 23, 0, "articulation_control"),
(240, "note_on", 12, 73, 110, "musical_note"),
(20, "note_on", 12, 7, 35, "keyswitch"),
(360, "note_off", 12, 73, 110, "musical_note"),
(120, "control_change", 12, 23, 66, "articulation_control"),
(720, "note_on", 12, 73, 104, "musical_note"),
(100, "note_off", 12, 7, 35, "keyswitch"),
(840, "note_off", 12, 73, 104, "musical_note"),
],
}
tracks = []
for part in PARTS:
events: list[ScheduledEvent] = []
for sequence, (tick, kind, channel, data1, data2, role) in enumerate(raw[part]):
common = {
"tick": tick,
"part": part,
"channel": channel,
"sequence": sequence,
"role": role,
}
if kind == "control_change":
events.append(
ControlChangeEvent.model_validate(
{**common, "priority": 10, "controller": data1, "value": data2}
)
)
else:
cls = NoteOnEvent if kind == "note_on" else NoteOffEvent
events.append(
cls.model_validate(
{
**common,
"priority": 20 if kind == "note_on" else 0,
"note": data1,
"velocity": data2,
}
)
)
tracks.append(EventTrack(part=part, events=events))
return EventPlan(
score=score,
musical_start_tick=240,
musical_end_tick=musical_end,
end_tick=musical_end + 120,
tracks=tracks,
)
def normalized(path: Path) -> list[list[Event]]:
result = []
for track in mido.MidiFile(path).tracks:
events: list[Event] = []
tick = 0
for message in track:
assert type(message.time) is int and message.time >= 0
tick += message.time
if message.is_meta:
continue
assert message.type in ("note_on", "note_off", "control_change")
data1 = message.control if message.type == "control_change" else message.note
data2 = message.value if message.type == "control_change" else message.velocity
events.append((tick, message.type, message.channel, data1, data2))
result.append(events)
return result
def reference(path: Path, numerator: int, denominator: int, bpm: float) -> None:
"""Construct independently with MIDIUtil's note/duration and CC APIs."""
end = 240 + numerator * 4 * 960 // denominator
midi = MIDIFile(
3,
file_format=1,
ticks_per_quarternote=960,
eventtime_is_ticks=True,
adjust_origin=False,
removeDuplicates=False,
deinterleave=False,
)
midi.addTempo(0, 0, bpm)
midi.addTimeSignature(0, 0, numerator, {4: 2, 8: 3}[denominator], 24)
for index, name in enumerate(("Bass", "Drums", "Lead")):
midi.addTrackName(index, 0, name)
midi.addNote(0, 5, 6, 0, 100, 34)
midi.addNote(0, 5, 45, 240, end - 240, 83)
midi.addControllerEvent(0, 5, 120, 22, 88)
midi.addControllerEvent(0, 5, end + 80, 22, 0)
midi.addNote(1, 12, 7, 20, 80, 35)
midi.addNote(1, 12, 73, 240, 120, 110)
midi.addNote(1, 12, 73, 720, 120, 104)
midi.addControllerEvent(1, 12, 120, 23, 66)
midi.addControllerEvent(1, 12, end + 120, 23, 0)
midi.addNote(2, 2, 5, 0, 280, 33)
midi.addNote(2, 2, 69, 240, 320, 97)
midi.addNote(2, 2, 69, 560, 640, 88)
midi.addControllerEvent(2, 2, 80, 21, 100)
midi.addControllerEvent(2, 2, end + 60, 21, 0)
with path.open("xb") as stream:
midi.writeFile(stream)
@pytest.mark.parametrize(
("numerator", "denominator", "bpm", "tempo"),
[(4, 4, 120.0, 500000), (3, 4, 137.5, 436364), (6, 8, 120.125, 499480), (7, 8, 137.5, 436364)],
)
def test_real_disk_and_independent_reference(
workspace: Path, numerator: int, denominator: int, bpm: float, tempo: int
) -> None:
plan = synthetic_plan(numerator, denominator, bpm)
production = write_midi(workspace / "production.mid", plan)
comparison = workspace / "midiutil.mid"
reference(comparison, numerator, denominator, bpm)
validate_midi_file(production, plan)
observed = normalized(production)
assert observed == normalized(comparison)
end = 240 + numerator * 4 * 960 // denominator
assert observed == [
[],
[
(0, "note_on", 5, 6, 34),
(100, "note_off", 5, 6, 34),
(120, "control_change", 5, 22, 88),
(240, "note_on", 5, 45, 83),
(end, "note_off", 5, 45, 83),
(end + 80, "control_change", 5, 22, 0),
],
[
(20, "note_on", 12, 7, 35),
(100, "note_off", 12, 7, 35),
(120, "control_change", 12, 23, 66),
(240, "note_on", 12, 73, 110),
(360, "note_off", 12, 73, 110),
(720, "note_on", 12, 73, 104),
(840, "note_off", 12, 73, 104),
(end + 120, "control_change", 12, 23, 0),
],
[
(0, "note_on", 2, 5, 33),
(80, "control_change", 2, 21, 100),
(240, "note_on", 2, 69, 97),
(280, "note_off", 2, 5, 33),
(560, "note_off", 2, 69, 97),
(560, "note_on", 2, 69, 88),
(1200, "note_off", 2, 69, 88),
(end + 60, "control_change", 2, 21, 0),
],
]
loaded = mido.MidiFile(production)
ref = mido.MidiFile(comparison)
assert production.read_bytes()[:14] == (b"MThd\x00\x00\x00\x06\x00\x01\x00\x04\x03\xc0")
assert loaded.type == ref.type == 1 and loaded.ticks_per_beat == ref.ticks_per_beat == 960
assert [track.name for track in loaded.tracks] == ["Conductor", "Bass", "Drums", "Lead"]
assert len(ref.tracks) == 4 # MIDIUtil inserts its own conductor ahead of three user tracks.
assert [track.name for track in ref.tracks[1:]] == ["Bass", "Drums", "Lead"]
assert [(message.type, message.time) for message in loaded.tracks[0]] == [
("track_name", 0),
("set_tempo", 0),
("time_signature", 0),
("end_of_track", end + 120),
]
assert loaded.tracks[0][1].tempo == tempo
assert tempo == round(Fraction(60_000_000) / Fraction(str(bpm)))
# MIDIUtil 1.2.1 truncates, unlike the production nearest-integer policy.
assert [message.tempo for message in ref.tracks[0] if message.type == "set_tempo"] == [
int(60_000_000 / bpm)
]
for file in (loaded, ref):
signatures = [message for message in file.tracks[0] if message.type == "time_signature"]
assert len(signatures) == 1
assert (signatures[0].numerator, signatures[0].denominator) == (numerator, denominator)
for track in loaded.tracks:
assert sum(message.time for message in track) == end + 120
assert sum(message.type == "end_of_track" for message in track) == 1
assert track[-1].type == "end_of_track"
# Reference EOTs are local last-event positions, not the production shared tail.
assert [sum(message.time for message in track) for track in ref.tracks] == [
0,
end + 80,
end + 120,
end + 60,
]
def test_repeated_input_is_byte_deterministic(workspace: Path) -> None:
plan = synthetic_plan()
first = write_midi(workspace / "first.mid", plan)
second = write_midi(workspace / "second.mid", plan)
for track in plan.tracks:
track.events.reverse()
third = write_midi(workspace / "reordered-input.mid", plan)
assert first.read_bytes() == second.read_bytes() == third.read_bytes()
validate_midi_file(third, plan)
@pytest.mark.parametrize("damage", ["empty", "header", "truncated", "trailing", "track_size"])
def test_corrupt_files_fail_without_deletion(workspace: Path, damage: str) -> None:
plan = synthetic_plan()
path = write_midi(workspace / "damaged.mid", plan)
data = path.read_bytes()
if damage == "empty":
broken = b""
elif damage == "header":
broken = b"XXXX" + data[4:]
elif damage == "truncated":
broken = data[:-3]
elif damage == "trailing":
broken = data + b"unexplained trailing data"
else:
broken = data[:18] + b"\x00\x00\x00\x01" + data[22:]
path.write_bytes(broken)
with pytest.raises(SerializationError):
validate_midi_file(path, plan)
assert path.read_bytes() == broken
@pytest.mark.parametrize(
"change",
[
"type",
"ppq",
"order",
"name",
"pitch",
"velocity",
"channel",
"cc",
"tempo",
"meter",
"timing",
"end",
"missing_release",
"extra_program",
],
)
def test_readable_but_wrong_content_is_not_success(workspace: Path, change: str) -> None:
plan = synthetic_plan()
path = write_midi(workspace / "wrong.mid", plan)
loaded = mido.MidiFile(path)
if change == "type":
loaded.type = 2
elif change == "ppq":
loaded.ticks_per_beat = 480
elif change == "order":
loaded.tracks[1], loaded.tracks[2] = loaded.tracks[2], loaded.tracks[1]
elif change == "name":
loaded.tracks[1][0].name = "Wrong"
elif change in ("pitch", "velocity", "channel"):
attribute = "note" if change == "pitch" else change
setattr(loaded.tracks[1][1], attribute, 11)
elif change == "cc":
next(message for message in loaded.tracks[1] if message.type == "control_change").value = 1
elif change == "tempo":
loaded.tracks[0][1].tempo = 500000
elif change == "meter":
loaded.tracks[0][2].numerator = 3
elif change == "timing":
loaded.tracks[1][1].time += 1
elif change == "end":
loaded.tracks[1][-1].time += 1
elif change == "missing_release":
del loaded.tracks[1][2]
else:
loaded.tracks[1].insert(1, mido.Message("program_change", channel=5, program=1))
loaded.save(path)
assert len(mido.MidiFile(path).tracks) == 4
with pytest.raises(SerializationError) as failure:
validate_midi_file(path, plan)
assert failure.value.details["reason"] in ("smf_header_mismatch", "smf_content_mismatch")
assert path.exists()
def test_writer_checks_actual_saved_content_and_cleans_mismatch(
workspace: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
path = workspace / "changed-on-disk.mid"
sentinel = workspace / "keep"
sentinel.write_bytes(b"unrelated")
read_bytes = Path.read_bytes
observed_disk_read = []
def tamper_then_read(self: Path) -> bytes:
assert self == path and path.exists()
loaded = mido.MidiFile(path)
loaded.tracks[1][1].note = 11
loaded.save(path)
observed_disk_read.append(True)
return read_bytes(path)
monkeypatch.setattr(Path, "read_bytes", tamper_then_read)
with pytest.raises(SerializationError) as failure:
write_midi(path, synthetic_plan())
assert failure.value.details == {"reason": "smf_content_mismatch", "track": 1}
assert observed_disk_read == [True]
assert not path.exists()
assert read_bytes(sentinel) == b"unrelated"