Cubase-MCP-GAJ3T.MusicGen.R.../tests/unit/test_riffer.py

513 lines
18 KiB
Python

"""Original content only: independent native read-back, never factory sequence fixtures."""
import shutil
import uuid
import xml.etree.ElementTree as ET
from collections.abc import Iterator
from pathlib import Path
from unittest.mock import Mock
import pytest
from pydantic import ValidationError
from riff_groove_builder.articulations import compile_score
from riff_groove_builder.errors import (
NativeFormatUnavailableError,
OutputExistsError,
OutputIOError,
SerializationError,
)
from riff_groove_builder.formats.agp import (
check_riffer_capability,
validate_riffer_file,
write_riffer,
)
from riff_groove_builder.profiles import InstrumentProfile, load_profile_registry, parse_profile
from riff_groove_builder.schemas import (
ControlChangeEvent,
EventPlan,
MusicalIntent,
NoteOffEvent,
Part,
PitchedNote,
PositiveBeat,
ProfileSelection,
RationalBeat,
Score,
ScoreTrack,
TimeSignature,
)
ROOT = Path(__file__).resolve().parents[2]
def target(part: Part) -> InstrumentProfile:
identifier = "ample.ame.4.0.1.riffer.v1" if part == "lead" else "ample.amr.4.1.0.riffer.v1"
return load_profile_registry().select([part], ProfileSelection(**{part: identifier}))[part]
def original_plan(part: Part, *, ppq: int = 960) -> tuple[EventPlan, InstrumentProfile]:
assert part in ("lead", "bass")
profile = target(part)
assert profile.playable_range is not None
low = profile.playable_range.low
high = profile.playable_range.high
score = Score(
intent=MusicalIntent(
description="Original codec verification chord and palm mute, not a factory sequence.",
parts=[part],
tempo_bpm=123.5,
bars=1,
time_signature=TimeSignature(numerator=4, denominator=4),
key="C minor",
seed=17,
),
start=RationalBeat(numerator=0),
end=RationalBeat(numerator=4),
tracks=[
ScoreTrack(
part=part,
notes=[
PitchedNote(
part=part,
pitch=pitch,
start=RationalBeat(numerator=start),
duration=PositiveBeat(numerator=1),
intensity=intensity,
articulation=articulation,
)
for pitch, start, intensity, articulation in (
(low, 0, 0.0, "normal"),
(high, 0, 1.0, "normal"),
(low + 2, 2, 0.5, "palm_mute"),
)
],
)
],
)
plan = compile_score(score, {part: profile}, ppq=ppq)
for tick, value in ((0, 0), (ppq, 120), (ppq * 3, 0)):
plan.tracks[0].events.append(
ControlChangeEvent(
tick=tick,
part=part,
channel=profile.channel,
priority=10,
sequence=100 + tick,
controller=1,
value=value,
)
)
plan.tracks[0].events.sort(key=lambda e: e.ordering_key)
for event in plan.tracks[0].events:
if isinstance(event, NoteOffEvent) and event.role == "musical_note":
event.velocity = 45
return plan, profile
@pytest.fixture
def workspace() -> Iterator[Path]:
path = ROOT / ".test-artifacts" / f"riffer-{uuid.uuid4().hex}"
path.mkdir(parents=True)
try:
yield path
finally:
shutil.rmtree(path)
@pytest.mark.parametrize("part", ["lead", "bass"])
def test_target_profiles_are_real_default_subsets(part: Part) -> None:
profile = target(part)
assert profile.default
assert profile.provenance.status == "verified_subset"
assert profile.summary.native_available and profile.summary.midi_available
assert check_riffer_capability(part, profile).available
assert profile.riffer is not None
assert profile.riffer.layout_version == "2.1"
assert profile.summary.native_format == profile.riffer.extension
assert parse_profile(profile.model_dump_json()) == profile
assert load_profile_registry().select([part], ProfileSelection())[part].summary.native_available
assert all(
"\\" not in source.reference and not source.reference.startswith(("C:", "D:"))
for source in profile.provenance.sources
)
@pytest.mark.parametrize("part", ["lead", "bass"])
@pytest.mark.parametrize("intensity", [0.0, 0.25, 0.5, 0.75, 1.0])
def test_evidenced_keyswitches_and_velocity_bands(part: Part, intensity: float) -> None:
profile = target(part)
for name, switch in (("normal", 24), ("palm_mute", 26 if part == "lead" else 24)):
art = profile.resolve_articulation(name)
assert art.actions[0].kind == "keyswitch" and art.actions[0].note == switch
bounds = (64, 126) if name == "normal" else ((1, 127) if part == "lead" else (32, 63))
assert art.velocity(intensity) == round(bounds[0] + (bounds[1] - bounds[0]) * intensity)
@pytest.mark.parametrize(
"mutation",
[
"version",
"layout",
"ppq",
"ppq_bool",
"extension",
"instrument",
"order",
"tuning",
"frets",
"controller",
"controller_bool",
"articulation",
"default_type",
"range",
"provenance",
"policy",
"velocity",
"switch",
"lead",
"gate",
"normal",
],
)
def test_native_subset_settings_are_strict(mutation: str) -> None:
data = target("lead").model_dump()
native = data["riffer"]
if mutation == "version":
data["summary"]["product_version"] = data["provenance"]["product_version"] = "4.0.2"
elif mutation == "layout":
native["layout_version"] = "2.2"
elif mutation == "ppq":
native["ppq"] = 960
elif mutation == "ppq_bool":
native["ppq"] = True
elif mutation == "extension":
native["extension"] = "briff"
elif mutation == "instrument":
native["instrument"] = "AMR"
elif mutation == "order":
native["strings"].reverse()
elif mutation == "tuning":
native["strings"][0]["open_note"] = 37
elif mutation == "frets":
native["strings"][0]["max_fret"] = 23
elif mutation == "controller":
native["controllers"] = [2]
elif mutation == "controller_bool":
native["controllers"] = [True]
elif mutation == "articulation":
native["articulations"]["normal"] = "PM"
elif mutation == "default_type":
data["default"] = "yes"
elif mutation == "range":
data["playable_range"]["high"] = 100
elif mutation == "provenance":
data["provenance"]["status"] = "standard_midi"
elif mutation == "policy":
data["provenance"]["sources"].pop()
elif mutation == "velocity":
data["articulations"][0]["layers"][0]["velocity_low"] = 2
elif mutation == "switch":
data["articulations"][0]["actions"][0]["note"] = 25
elif mutation == "lead":
data["articulations"][0]["actions"][0]["lead"]["numerator"] = 1
elif mutation == "gate":
data["articulations"][0]["actions"][0]["gate"]["denominator"] = 64
else:
data["normal_articulation"] = "palm_mute"
with pytest.raises(ValidationError):
InstrumentProfile.model_validate(data)
@pytest.mark.parametrize("part", ["lead", "bass"])
@pytest.mark.parametrize("ppq", [480, 960, 1920])
def test_real_xml_writer_and_independent_readback(workspace: Path, part: Part, ppq: int) -> None:
plan, profile = original_plan(part, ppq=ppq)
path = workspace / f"original.{profile.summary.native_format}"
before = plan.model_dump()
assert write_riffer(path, plan, part, profile) == path
result = validate_riffer_file(path, plan, part, profile)
assert len(result.notes) == 3 and result.end_tick == 1920
assert result.cc1 == ((0, 0), (480, 120), (1440, 0))
assert {n.articulation for n in result.notes} == {"Sus", "PM" if part == "lead" else "PMP"}
assert {n.off_velocity for n in result.notes} == {45}
assert all(n.begin in (0, 960) and n.end in (480, 1440) for n in result.notes)
root = ET.parse(path).getroot()
assert root.tag == "Riff" and root.get("Inst") == ("AME" if part == "lead" else "AMR")
assert root.get("Ver") == "2.1" and root.get("PPQBase") == "480"
assert plan.model_dump() == before
assert list(workspace.iterdir()) == [path]
@pytest.mark.parametrize(
"mutation",
[
"version",
"ppq",
"target",
"tempo",
"meter",
"key",
"bars",
"loop",
"pitch",
"fret",
"begin",
"end",
"velocity",
"off_velocity",
"articulation",
"legato",
"muted",
"string",
"delete_note",
"extra_note",
"extra_child",
"cc_value",
"cc_tick",
"cc_curve",
"cc_delete",
"cc_duplicate",
"root_text",
"note_text",
"doctype",
],
)
def test_saved_file_validator_detects_corruption_independently(
workspace: Path, mutation: str
) -> None:
plan, profile = original_plan("lead")
path = workspace / "original.griff"
write_riffer(path, plan, "lead", profile)
tree = ET.parse(path)
root = tree.getroot()
string = root.find("String")
note = root.find("String/Note")
point = root.find("cc-1.Mod/p")
assert string is not None and note is not None and point is not None
header_changes = {
"version": ("Ver", "2.2"),
"ppq": ("PPQBase", "960"),
"target": ("Inst", "AMR"),
"tempo": ("Tempo", "121"),
"meter": ("Time-Signature", "3/4"),
"key": ("Key", "Am"),
"bars": ("Measures", "2"),
"loop": ("loopEnd", "100"),
}
note_changes = {
"pitch": ("NoteID", "37"),
"fret": ("Fret", "1"),
"begin": ("Begin", "1"),
"end": ("End", "479"),
"velocity": ("Velocity", "2"),
"off_velocity": ("Off-Velocity", "44"),
"articulation": ("Articulation", "PM"),
"legato": ("Legato", "Legato Slide"),
"muted": ("Muted", "True"),
}
if mutation in header_changes:
root.set(*header_changes[mutation])
elif mutation in note_changes:
note.set(*note_changes[mutation])
elif mutation == "string":
string.set("ID", "1")
elif mutation == "delete_note":
string.remove(note)
elif mutation == "extra_note":
ET.SubElement(string, "Note", note.attrib)
elif mutation == "extra_child":
ET.SubElement(root, "Chord")
elif mutation == "cc_value":
point.set("value", "1")
elif mutation == "cc_tick":
point.set("tick", "2")
elif mutation == "cc_curve":
point.set("curveType", "curve")
elif mutation == "cc_delete":
root.remove(root[-1])
elif mutation == "cc_duplicate":
ET.SubElement(root[-1], "p", point.attrib)
elif mutation == "root_text":
root.text = "unexpected content"
elif mutation == "note_text":
note.text = "unexpected content"
tree.write(path, encoding="utf-8", xml_declaration=True)
if mutation == "doctype":
path.write_bytes(b'<!DOCTYPE Riff [<!ENTITY e "ignored">]>' + path.read_bytes())
with pytest.raises(SerializationError) as error:
validate_riffer_file(path, plan, "lead", profile)
assert error.value.details["reason"] == "invalid_saved_riffer"
@pytest.mark.parametrize(
"mutation",
["preroll", "tail", "note_missing", "switch_missing", "wrong_channel", "cc2", "cc_same_tick"],
)
def test_unsupported_or_mismatched_plan_is_not_silently_dropped(
workspace: Path, mutation: str
) -> None:
plan, profile = original_plan("lead")
if mutation == "preroll":
plan.musical_start_tick += 2
plan.musical_end_tick += 2
plan.end_tick += 2
for event in plan.tracks[0].events:
event.tick += 2
elif mutation == "tail":
plan.end_tick += 2
elif mutation in ("note_missing", "switch_missing"):
role = "musical_note" if mutation == "note_missing" else "keyswitch"
pitch = 36 if mutation == "note_missing" else 24
plan.tracks[0].events = [
e
for e in plan.tracks[0].events
if not (e.kind != "control_change" and e.role == role and e.note == pitch)
]
elif mutation == "wrong_channel":
for event in plan.tracks[0].events:
event.channel = 3
else:
point = next(e for e in plan.tracks[0].events if isinstance(e, ControlChangeEvent))
if mutation == "cc2":
point.controller = 2
else:
duplicate = point.model_copy(update={"sequence": 999})
plan.tracks[0].events.append(duplicate)
path = workspace / "must-not-exist.griff"
with pytest.raises(SerializationError):
write_riffer(path, plan, "lead", profile)
assert not path.exists()
@pytest.mark.parametrize("suffix", [".agp", ".mid", ".briff", ".GRIFF", ""])
def test_wrong_suffix_fails_before_io(workspace: Path, suffix: str) -> None:
plan, profile = original_plan("lead")
path = workspace / "never-created" / ("wrong" + suffix)
with pytest.raises(SerializationError) as error:
write_riffer(path, plan, "lead", profile)
assert error.value.details["reason"] == "wrong_native_suffix"
assert not path.parent.exists()
def test_writer_exclusive_creation_and_no_parent_creation(workspace: Path) -> None:
plan, profile = original_plan("lead")
path = workspace / "existing.griff"
path.write_bytes(b"operator-owned")
with pytest.raises(OutputExistsError):
write_riffer(path, plan, "lead", profile)
assert path.read_bytes() == b"operator-owned"
with pytest.raises(OutputIOError):
write_riffer(workspace / "absent" / "original.griff", plan, "lead", profile)
assert list(workspace.iterdir()) == [path]
def test_no_codec_from_standard_profile_and_no_io(workspace: Path) -> None:
plan, _ = original_plan("lead")
profile = load_profile_registry().select(["lead"], ProfileSelection(lead="standard.lead.v1"))[
"lead"
]
with pytest.raises(NativeFormatUnavailableError):
write_riffer(workspace / "original.griff", plan, "lead", profile)
assert not list(workspace.iterdir())
def test_no_fake_success_if_serializer_loses_notes(
workspace: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
plan, profile = original_plan("lead")
monkeypatch.setattr("riff_groove_builder.formats.agp._serialize", Mock(return_value=b"<Riff/>"))
with pytest.raises(SerializationError):
write_riffer(workspace / "broken.griff", plan, "lead", profile)
def test_rational_grid_rejected_instead_of_rounded(workspace: Path) -> None:
plan, profile = original_plan("lead", ppq=6720)
plan.score.tracks[0].notes[2].start = RationalBeat(numerator=13, denominator=7)
# The logical score compiles exactly at 6720 PPQ, but not at native PPQ 480.
plan = compile_score(plan.score, {"lead": profile}, ppq=6720)
with pytest.raises(SerializationError) as error:
write_riffer(workspace / "off-grid.griff", plan, "lead", profile)
assert error.value.details["reason"] == "off_grid_beats"
@pytest.mark.parametrize("impossible", [False, True])
def test_physical_assignment_backtracks_or_rejects_without_dropping(
workspace: Path, impossible: bool
) -> None:
plan, profile = original_plan("lead")
notes = plan.score.tracks[0].notes
assert isinstance(notes[0], PitchedNote) and isinstance(notes[1], PitchedNote)
notes[0].pitch = 36 if impossible else 62
notes[0].duration = PositiveBeat(numerator=2)
notes[1].pitch = 37 if impossible else 84
notes[1].start = RationalBeat(numerator=1)
notes.pop()
plan = compile_score(plan.score, {"lead": profile})
path = workspace / "assignment.griff"
if impossible:
with pytest.raises(SerializationError) as error:
write_riffer(path, plan, "lead", profile)
assert error.value.details["reason"] == "no_physical_string_assignment"
assert not path.exists()
else:
write_riffer(path, plan, "lead", profile)
readback = validate_riffer_file(path, plan, "lead", profile)
assert len(readback.notes) == 2
assert next(n for n in readback.notes if n.pitch == 62).string != 1
assert next(n for n in readback.notes if n.pitch == 84).string == 1
assert readback.cc1 == ()
@pytest.mark.parametrize("empty", [False, True])
def test_exact_triplets_score_origin_and_empty_score(workspace: Path, empty: bool) -> None:
plan, profile = original_plan("bass")
plan.score.start = RationalBeat(numerator=8)
plan.score.end = RationalBeat(numerator=12)
for note in plan.score.tracks[0].notes:
note.start.numerator += 8
if empty:
plan.score.tracks[0].notes.clear()
else:
plan.score.tracks[0].notes.pop()
for note in plan.score.tracks[0].notes:
note.start = RationalBeat(numerator=25, denominator=3)
note.duration = PositiveBeat(numerator=1, denominator=3)
plan = compile_score(plan.score, {"bass": profile})
path = workspace / "triplets.briff"
write_riffer(path, plan, "bass", profile)
readback = validate_riffer_file(path, plan, "bass", profile)
assert len(readback.notes) == (0 if empty else 2)
assert all((n.begin, n.end) == (160, 320) for n in readback.notes)
assert readback.end_tick == 1920
def test_saved_reader_rejects_physical_overlap_even_with_all_musical_notes(
workspace: Path,
) -> None:
plan, profile = original_plan("lead")
notes = plan.score.tracks[0].notes
assert isinstance(notes[0], PitchedNote)
notes[0].pitch = 62
notes[0].duration = PositiveBeat(numerator=2)
notes[1].start = RationalBeat(numerator=1)
notes.pop()
plan = compile_score(plan.score, {"lead": profile})
path = workspace / "overlap.griff"
write_riffer(path, plan, "lead", profile)
tree = ET.parse(path)
strings = tree.getroot().findall("String")
moved: ET.Element | None = None
for string in strings[:-1]:
for note in list(string):
if note.get("NoteID") == "62":
string.remove(note)
note.set("Fret", "0")
moved = note
assert moved is not None
strings[-1].insert(0, moved)
tree.write(path, encoding="utf-8", xml_declaration=True)
with pytest.raises(SerializationError) as error:
validate_riffer_file(path, plan, "lead", profile)
assert error.value.details["reason"] == "invalid_saved_riffer"