566 lines
20 KiB
Python
566 lines
20 KiB
Python
"""Real MIDI and wheel checks of synthetic mechanics and standard fallback, not vendors."""
|
|
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
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 ArticulationCompileError, compile_score
|
|
from riff_groove_builder.errors import UnsupportedArticulationError
|
|
from riff_groove_builder.midi import validate_midi_file, write_midi
|
|
from riff_groove_builder.profiles import load_profile_registry, parse_profile
|
|
from riff_groove_builder.schemas import (
|
|
ControlChangeEvent,
|
|
DrumNote,
|
|
EventPlan,
|
|
MusicalIntent,
|
|
Part,
|
|
PitchedNote,
|
|
PositiveBeat,
|
|
ProfileSelection,
|
|
RationalBeat,
|
|
Score,
|
|
ScoreTrack,
|
|
TimeSignature,
|
|
)
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
FIXTURES = ROOT / "tests" / "fixtures" / "profiles"
|
|
pytestmark = pytest.mark.integration
|
|
Event = tuple[int, str, int, int]
|
|
|
|
|
|
@pytest.fixture
|
|
def workspace() -> Iterator[Path]:
|
|
path = ROOT / ".test-artifacts" / f"articulation-{uuid.uuid4().hex}"
|
|
path.mkdir(parents=True)
|
|
try:
|
|
yield path
|
|
finally:
|
|
shutil.rmtree(path)
|
|
|
|
|
|
def ratio(value: Fraction | int) -> RationalBeat:
|
|
value = Fraction(value)
|
|
return RationalBeat(numerator=value.numerator, denominator=value.denominator)
|
|
|
|
|
|
def synthetic_score() -> Score:
|
|
# Explicit independent score, common logical origin 2; no compiler helpers.
|
|
def pitched(
|
|
part: Part,
|
|
start: Fraction | int,
|
|
length: Fraction | int,
|
|
pitch: int,
|
|
articulation: str,
|
|
intensity: float = 0.5,
|
|
) -> PitchedNote:
|
|
assert part in ("lead", "bass")
|
|
return PitchedNote(
|
|
part=part,
|
|
start=ratio(start),
|
|
duration=PositiveBeat.model_validate(ratio(length).model_dump()),
|
|
pitch=pitch,
|
|
articulation=articulation,
|
|
intensity=intensity,
|
|
)
|
|
|
|
def drum(
|
|
start: Fraction | int,
|
|
length: Fraction | int,
|
|
voice: str,
|
|
art: str,
|
|
intensity: float,
|
|
) -> DrumNote:
|
|
return DrumNote(
|
|
part="drums",
|
|
start=ratio(start),
|
|
duration=PositiveBeat.model_validate(ratio(length).model_dump()),
|
|
voice=voice,
|
|
articulation=art,
|
|
intensity=intensity,
|
|
)
|
|
|
|
return Score(
|
|
intent=MusicalIntent(
|
|
description="SYNTHETIC three-part articulated test",
|
|
parts=["lead", "bass", "drums"],
|
|
tempo_bpm=120,
|
|
bars=1,
|
|
time_signature=TimeSignature(numerator=4, denominator=4),
|
|
key="C major",
|
|
seed=0,
|
|
),
|
|
start=ratio(2),
|
|
end=ratio(6),
|
|
tracks=[
|
|
ScoreTrack(
|
|
part="lead",
|
|
notes=[
|
|
pitched("lead", 2, 1, 60, "Palm Mute"),
|
|
pitched("lead", Fraction(5, 2), 1, 64, "pm", 1),
|
|
pitched("lead", 4, 1, 60, "normal"),
|
|
pitched("lead", 5, 1, 60, "sustain"),
|
|
],
|
|
),
|
|
ScoreTrack(
|
|
part="bass",
|
|
notes=[
|
|
pitched("bass", 2, Fraction(1, 2), 40, "normal"),
|
|
pitched("bass", 3, Fraction(1, 2), 43, "slide"),
|
|
pitched("bass", Fraction(13, 4), Fraction(3, 4), 45, "slide"),
|
|
pitched("bass", Fraction(17, 4), Fraction(7, 4), 40, "normal"),
|
|
],
|
|
),
|
|
ScoreTrack(
|
|
part="drums",
|
|
notes=[
|
|
drum(2, Fraction(1, 2), "low", "accent", 0.5),
|
|
drum(Fraction(9, 4), Fraction(1, 2), "high_hit", "hard hit", 1),
|
|
drum(3, 1, "low_hit", "normal", 0),
|
|
drum(Fraction(11, 2), Fraction(1, 2), "high", "accent", 0),
|
|
],
|
|
),
|
|
],
|
|
)
|
|
|
|
|
|
def expected() -> list[list[Event]]:
|
|
# Hand-derived absolute ticks/payloads; never iterate production events to build expectations.
|
|
return [
|
|
[
|
|
(0, "note_on", 2, 64),
|
|
(0, "control_change", 20, 64),
|
|
(60, "note_off", 2, 0),
|
|
(120, "note_on", 60, 80),
|
|
(600, "note_on", 64, 100),
|
|
(1080, "note_off", 60, 0),
|
|
(1560, "note_off", 64, 0),
|
|
(1920, "note_on", 1, 64),
|
|
(1920, "control_change", 20, 0),
|
|
(1980, "note_off", 1, 0),
|
|
(2040, "note_on", 60, 64),
|
|
(3000, "note_off", 60, 0),
|
|
(3000, "note_on", 60, 64),
|
|
(3960, "note_off", 60, 0),
|
|
],
|
|
[
|
|
(120, "note_on", 3, 60),
|
|
(120, "control_change", 21, 0),
|
|
(120, "note_on", 40, 60),
|
|
(180, "note_off", 3, 0),
|
|
(600, "note_off", 40, 0),
|
|
(960, "note_on", 4, 60),
|
|
(960, "control_change", 21, 90),
|
|
(1080, "note_on", 43, 60),
|
|
(1200, "control_change", 21, 90),
|
|
(1320, "note_on", 45, 60),
|
|
(1560, "note_off", 43, 0),
|
|
(2040, "note_off", 45, 0),
|
|
(2100, "note_off", 4, 0),
|
|
(2100, "control_change", 21, 0),
|
|
(2100, "note_on", 3, 60),
|
|
(2100, "control_change", 21, 0),
|
|
(2160, "note_off", 3, 0),
|
|
(2280, "note_on", 40, 60),
|
|
(3960, "note_off", 40, 0),
|
|
],
|
|
[
|
|
(120, "control_change", 22, 0),
|
|
(120, "control_change", 22, 100),
|
|
(120, "note_on", 36, 100),
|
|
(360, "control_change", 22, 100),
|
|
(360, "note_on", 40, 120),
|
|
(600, "note_off", 36, 0),
|
|
(840, "note_off", 40, 0),
|
|
(900, "control_change", 22, 0),
|
|
(900, "control_change", 22, 0),
|
|
(1080, "note_on", 36, 1),
|
|
(2040, "note_off", 36, 0),
|
|
(3480, "control_change", 22, 100),
|
|
(3480, "note_on", 40, 80),
|
|
(3960, "note_off", 40, 0),
|
|
(4020, "control_change", 22, 0),
|
|
(4020, "control_change", 22, 0),
|
|
],
|
|
]
|
|
|
|
|
|
def compiled() -> EventPlan:
|
|
return compile_score(
|
|
synthetic_score(),
|
|
{
|
|
part: parse_profile((FIXTURES / f"synthetic-{part}.json").read_bytes())
|
|
for part in synthetic_score().intent.parts
|
|
},
|
|
)
|
|
|
|
|
|
def test_three_part_exact_events_saved_readback_and_shared_tail(workspace: Path) -> None:
|
|
plan = compiled()
|
|
assert (plan.musical_start_tick, plan.musical_end_tick, plan.end_tick) == (120, 3960, 4020)
|
|
for track, independent in zip(plan.tracks, expected(), strict=True):
|
|
observed = [
|
|
(
|
|
e.tick,
|
|
e.kind,
|
|
e.controller if isinstance(e, ControlChangeEvent) else e.note,
|
|
e.value if isinstance(e, ControlChangeEvent) else e.velocity,
|
|
)
|
|
for e in track.events
|
|
]
|
|
assert observed == independent
|
|
path = write_midi(workspace / "synthetic.mid", plan)
|
|
validate_midi_file(path, plan)
|
|
midi = mido.MidiFile(path)
|
|
assert midi.type == 1 and midi.ticks_per_beat == 960 and len(midi.tracks) == 4
|
|
for track, independent, channel in zip(midi.tracks[1:], expected(), [2, 5, 12], strict=True):
|
|
tick = 0
|
|
events: list[Event] = []
|
|
active: dict[int, int] = {}
|
|
for message in track:
|
|
tick += message.time
|
|
if message.is_meta:
|
|
continue
|
|
assert message.channel == channel
|
|
if message.type == "control_change":
|
|
events.append((tick, message.type, message.control, message.value))
|
|
else:
|
|
events.append((tick, message.type, message.note, message.velocity))
|
|
if message.type == "note_on":
|
|
assert message.note not in active
|
|
active[message.note] = tick
|
|
else:
|
|
assert tick > active.pop(message.note)
|
|
assert events == independent
|
|
assert active == {} and tick == 4020
|
|
assert track[-1].type == "end_of_track"
|
|
assert sum(m.time for m in midi.tracks[0]) == 4020
|
|
assert midi.tracks[0][1].tempo == 500000
|
|
other = write_midi(workspace / "repeat.mid", compiled())
|
|
assert other.read_bytes() == path.read_bytes()
|
|
|
|
|
|
def test_shared_channels_rejected_including_empty_selected_parts() -> None:
|
|
source = synthetic_score()
|
|
selected = {
|
|
part: parse_profile((FIXTURES / f"synthetic-{part}.json").read_bytes())
|
|
for part in source.intent.parts
|
|
}
|
|
source.tracks[1].notes = []
|
|
selected["bass"].channel = selected["lead"].channel
|
|
with pytest.raises(ArticulationCompileError) as error:
|
|
compile_score(source, selected)
|
|
assert error.value.details["reason"] == "shared_channel"
|
|
|
|
|
|
def test_unsupported_voice_never_guesses_gm_map() -> None:
|
|
source = synthetic_score()
|
|
drum = source.tracks[2].notes[0]
|
|
assert isinstance(drum, DrumNote)
|
|
drum.voice = "acoustic_bass_drum"
|
|
with pytest.raises(ArticulationCompileError) as error:
|
|
compile_score(
|
|
source,
|
|
{
|
|
part: parse_profile((FIXTURES / f"synthetic-{part}.json").read_bytes())
|
|
for part in source.intent.parts
|
|
},
|
|
)
|
|
assert error.value.details["reason"] == "unsupported_drum_voice"
|
|
|
|
|
|
def standard_score() -> Score:
|
|
return Score(
|
|
intent=MusicalIntent(
|
|
description="Standard MIDI fallback, no verified vendor mapping",
|
|
parts=["lead", "bass", "drums"],
|
|
tempo_bpm=120,
|
|
bars=1,
|
|
time_signature=TimeSignature(numerator=4, denominator=4),
|
|
key="C major",
|
|
seed=0,
|
|
),
|
|
start=ratio(0),
|
|
end=ratio(4),
|
|
tracks=[
|
|
ScoreTrack(
|
|
part="lead",
|
|
notes=[
|
|
PitchedNote(
|
|
part="lead",
|
|
start=ratio(0),
|
|
duration=PositiveBeat(numerator=1),
|
|
pitch=0,
|
|
articulation="normal",
|
|
intensity=0,
|
|
),
|
|
PitchedNote(
|
|
part="lead",
|
|
start=ratio(1),
|
|
duration=PositiveBeat(numerator=1),
|
|
pitch=127,
|
|
articulation="sustain",
|
|
intensity=1,
|
|
),
|
|
],
|
|
),
|
|
ScoreTrack(
|
|
part="bass",
|
|
notes=[
|
|
PitchedNote(
|
|
part="bass",
|
|
start=ratio(0),
|
|
duration=PositiveBeat(numerator=2),
|
|
pitch=40,
|
|
articulation="sustain",
|
|
intensity=0.5,
|
|
),
|
|
],
|
|
),
|
|
ScoreTrack(
|
|
part="drums",
|
|
notes=[
|
|
DrumNote(
|
|
part="drums",
|
|
start=ratio(0),
|
|
duration=PositiveBeat(numerator=1),
|
|
voice="kick",
|
|
articulation="normal",
|
|
intensity=0.25,
|
|
),
|
|
DrumNote(
|
|
part="drums",
|
|
start=ratio(1),
|
|
duration=PositiveBeat(numerator=1),
|
|
voice="snare",
|
|
articulation="sustain",
|
|
intensity=0.75,
|
|
),
|
|
DrumNote(
|
|
part="drums",
|
|
start=ratio(2),
|
|
duration=PositiveBeat(numerator=1),
|
|
voice="closed_hat",
|
|
articulation="normal",
|
|
intensity=0.5,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
)
|
|
|
|
|
|
def test_standard_fallback_compiles_and_roundtrips_real_midi(workspace: Path) -> None:
|
|
score = standard_score()
|
|
profiles = load_profile_registry().select(
|
|
score.intent.parts,
|
|
ProfileSelection(
|
|
lead="standard.lead.v1", bass="standard.bass.v1", drums="standard.gm-drums.v1"
|
|
),
|
|
)
|
|
plan = compile_score(score, profiles)
|
|
assert plan == compile_score(score, profiles)
|
|
assert (plan.musical_start_tick, plan.musical_end_tick, plan.end_tick) == (0, 3840, 3840)
|
|
independent: list[list[Event]] = [
|
|
[
|
|
(0, "note_on", 0, 1),
|
|
(960, "note_off", 0, 0),
|
|
(960, "note_on", 127, 127),
|
|
(1920, "note_off", 127, 0),
|
|
],
|
|
[(0, "note_on", 40, 64), (1920, "note_off", 40, 0)],
|
|
[
|
|
(0, "note_on", 36, 32),
|
|
(960, "note_off", 36, 0),
|
|
(960, "note_on", 38, 96),
|
|
(1920, "note_off", 38, 0),
|
|
(1920, "note_on", 42, 64),
|
|
(2880, "note_off", 42, 0),
|
|
],
|
|
]
|
|
assert [{event.channel for event in track.events} for track in plan.tracks] == [{0}, {1}, {9}]
|
|
for track, expected_events in zip(plan.tracks, independent, strict=True):
|
|
assert all(e.role == "musical_note" for e in track.events)
|
|
assert [
|
|
(e.tick, e.kind, e.note, e.velocity)
|
|
for e in track.events
|
|
if not isinstance(e, ControlChangeEvent)
|
|
] == expected_events
|
|
path = write_midi(workspace / "standard-fallback.mid", plan)
|
|
validate_midi_file(path, plan)
|
|
midi = mido.MidiFile(path)
|
|
assert midi.type == 1 and midi.ticks_per_beat == 960 and len(midi.tracks) == 4
|
|
assert [m.tempo for m in midi.tracks[0] if m.type == "set_tempo"] == [500000]
|
|
assert [(m.numerator, m.denominator) for m in midi.tracks[0] if m.type == "time_signature"] == [
|
|
(4, 4)
|
|
]
|
|
for track, channel, expected_events in zip(
|
|
midi.tracks[1:], [0, 1, 9], independent, strict=True
|
|
):
|
|
tick = 0
|
|
events: list[Event] = []
|
|
for message in track:
|
|
tick += message.time
|
|
if not message.is_meta:
|
|
assert message.type in ("note_on", "note_off")
|
|
assert message.channel == channel
|
|
events.append((tick, message.type, message.note, message.velocity))
|
|
assert events == expected_events
|
|
assert tick == 3840 and track[-1].type == "end_of_track"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("part", "technique"), [("lead", "palm_mute"), ("bass", "slide"), ("drums", "accent")]
|
|
)
|
|
def test_standard_fallback_rejects_unsupported_techniques(part: Part, technique: str) -> None:
|
|
score = standard_score()
|
|
track = next(track for track in score.tracks if track.part == part)
|
|
track.notes[0].articulation = technique
|
|
profiles = load_profile_registry().select(
|
|
score.intent.parts,
|
|
ProfileSelection(
|
|
lead="standard.lead.v1", bass="standard.bass.v1", drums="standard.gm-drums.v1"
|
|
),
|
|
)
|
|
with pytest.raises(UnsupportedArticulationError) as error:
|
|
compile_score(score, profiles)
|
|
assert error.value.code == "UNSUPPORTED_ARTICULATION"
|
|
assert "verified profile" not in error.value.public_message
|
|
|
|
|
|
def test_standard_fallback_rejects_unknown_voice() -> None:
|
|
score = standard_score()
|
|
note = score.tracks[2].notes[0]
|
|
assert isinstance(note, DrumNote)
|
|
note.voice = "sd3_custom_voice"
|
|
profiles = load_profile_registry().select(
|
|
score.intent.parts,
|
|
ProfileSelection(
|
|
lead="standard.lead.v1", bass="standard.bass.v1", drums="standard.gm-drums.v1"
|
|
),
|
|
)
|
|
with pytest.raises(ArticulationCompileError) as error:
|
|
compile_score(score, profiles)
|
|
assert error.value.details["reason"] == "unsupported_drum_voice"
|
|
|
|
|
|
def test_built_wheel_standard_registry_installed_and_zip_resources_outside_repo(
|
|
workspace: Path,
|
|
) -> None:
|
|
scratch = workspace / "scratch"
|
|
scratch.mkdir()
|
|
env = os.environ.copy()
|
|
for name in ("PYTHONPATH", "PYTHONHOME"):
|
|
env.pop(name, None)
|
|
env.update(
|
|
{
|
|
"TEMP": str(scratch),
|
|
"TMP": str(scratch),
|
|
"TMPDIR": str(scratch),
|
|
"PIP_NO_INDEX": "1",
|
|
"PIP_NO_CACHE_DIR": "1",
|
|
"PYTHONDONTWRITEBYTECODE": "1",
|
|
"PIP_DISABLE_PIP_VERSION_CHECK": "1",
|
|
}
|
|
)
|
|
|
|
def run(args: list[str], *, outside: bool = False) -> str:
|
|
result = subprocess.run(
|
|
[sys.executable, "-I", "-B", *args],
|
|
cwd=ROOT.parent if outside else ROOT,
|
|
env=env,
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=180,
|
|
check=False,
|
|
)
|
|
assert result.returncode == 0, result.stdout + result.stderr
|
|
return result.stdout
|
|
|
|
# Build the wheel from the sdist so build intermediates stay in this workspace.
|
|
run(["-m", "build", "--no-isolation", "--outdir", str(workspace / "dist")])
|
|
wheel = next((workspace / "dist").glob("*.whl"))
|
|
installed = workspace / "installed"
|
|
run(
|
|
[
|
|
"-m",
|
|
"pip",
|
|
"install",
|
|
"--no-deps",
|
|
"--no-index",
|
|
"--no-cache-dir",
|
|
"--target",
|
|
str(installed),
|
|
str(wheel),
|
|
]
|
|
)
|
|
probe = """
|
|
import json
|
|
import pathlib
|
|
import sys
|
|
sys.path.insert(0, sys.argv[1])
|
|
import riff_groove_builder.profiles as profiles
|
|
from importlib.resources import files
|
|
from riff_groove_builder.data.profiles import PROFILE_RESOURCES
|
|
from riff_groove_builder.schemas import ProfileListResult, ProfileSelection
|
|
assert str(profiles.__file__).startswith(sys.argv[1])
|
|
assert set(PROFILE_RESOURCES) == {
|
|
"standard-midi-lead-v1.json", "standard-midi-bass-v1.json",
|
|
"general-midi-percussion-v1.json",
|
|
"ample-metal-eclipse-4.0.1-riffer-v1.json",
|
|
"ample-metal-ray5-4.1.0-riffer-v1.json",
|
|
"toontrack-sd3-3.4.4-core-v1.json",
|
|
}
|
|
root = files("riff_groove_builder.data.profiles")
|
|
assert root.joinpath("__init__.py").is_file()
|
|
assert {p.name for p in root.iterdir() if p.name.endswith(".json")} == set(PROFILE_RESOURCES)
|
|
registry = profiles.load_profile_registry()
|
|
summaries = registry.summaries()
|
|
assert [p.id for p in summaries] == [
|
|
"ample.ame.4.0.1.riffer.v1", "ample.amr.4.1.0.riffer.v1",
|
|
"standard.bass.v1", "standard.gm-drums.v1", "standard.lead.v1",
|
|
"toontrack.sd3.3.4.4.core.v1"
|
|
]
|
|
assert ProfileListResult(profiles=summaries).profiles == summaries
|
|
defaults = registry.select(["lead", "bass", "drums"], ProfileSelection())
|
|
assert all(p.default and p.provenance.status == "verified_subset" for p in defaults.values())
|
|
selected = registry.select(["lead", "bass", "drums"], ProfileSelection(
|
|
lead="standard.lead.v1", bass="standard.bass.v1", drums="standard.gm-drums.v1"
|
|
))
|
|
assert {part: p.channel for part, p in selected.items()} == {"lead": 0, "bass": 1, "drums": 9}
|
|
for p in selected.values():
|
|
assert p.summary.mapping_kind == p.provenance.status == "standard_midi"
|
|
assert not p.default and not p.summary.native_available
|
|
assert "NOT a verified" in p.summary.product_name
|
|
assert not p.id.startswith("test.") and not p.summary.product_name.startswith("SYNTHETIC")
|
|
assert p.summary.supported_articulations == ["normal"]
|
|
assert p.resolve_articulation("sustain").actions == []
|
|
assert selected["drums"].resolve_voice("kick") == 36
|
|
assert selected["drums"].resolve_voice("snare") == 38
|
|
assert selected["drums"].resolve_voice("closed_hat") == 42
|
|
print(json.dumps({"module": str(profiles.__file__), "cwd": str(pathlib.Path.cwd()),
|
|
"profiles": [p.id for p in summaries], "isolated": sys.flags.isolated}))
|
|
"""
|
|
for location in [installed, wheel]:
|
|
evidence = json.loads(run(["-c", probe, str(location)], outside=True))
|
|
assert evidence["profiles"] == [
|
|
"ample.ame.4.0.1.riffer.v1",
|
|
"ample.amr.4.1.0.riffer.v1",
|
|
"standard.bass.v1",
|
|
"standard.gm-drums.v1",
|
|
"standard.lead.v1",
|
|
"toontrack.sd3.3.4.4.core.v1",
|
|
]
|
|
assert evidence["isolated"] == 1
|
|
assert Path(evidence["cwd"]) == ROOT.parent
|
|
print(f"Wheel profile-resource evidence: {evidence}")
|