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

924 lines
38 KiB
Python

"""Offline built-wheel import and real stdio acceptance, not plugin certification."""
import asyncio
import hashlib
import json
import os
import shutil
import subprocess
import sys
import tarfile
import uuid
import zipfile
from collections.abc import Iterator
from email.parser import Parser
from pathlib import Path
import anyio
import mido # type: ignore[import-untyped]
import pytest
from jsonschema import Draft202012Validator
from mcp.shared.version import SUPPORTED_PROTOCOL_VERSIONS
from test_cc_stdio import exercise_control_stdio
from test_hybrid_stdio import exercise_hybrid_stdio
from test_native_service import TEMPLATE, job, validate_saved
from test_phrase_stdio import exercise_phrase_stdio
from test_stdio import TIMEOUT, RawStdio
from test_text_feedback import exercise_text_feedback
from riff_groove_builder.schemas import (
GenerationError,
GenerationResult,
ProfileListResult,
ToolName,
tool_input_schema,
tool_output_schema,
)
ROOT = Path(__file__).resolve().parents[2]
EVIDENCE = ROOT / ".test-artifacts" / "step16" / "installed-wheel"
pytestmark = pytest.mark.integration
def _distribution_directory(workspace: Path) -> Path:
configured = os.environ.get("RIFF_RELEASE_DIST")
if configured is None:
return workspace / "dist"
directory = Path(configured).resolve(strict=True)
assert directory.is_dir() and directory.is_relative_to(ROOT / "dist")
assert len(list(directory.glob("*.whl"))) == len(list(directory.glob("*.tar.gz"))) == 1
return directory
def _run(command: list[str], *, cwd: Path, env: dict[str, str]) -> str:
result = subprocess.run(
command,
cwd=cwd,
env=env,
capture_output=True,
text=True,
timeout=180,
check=False,
)
assert result.returncode == 0, (
f"Command failed: {command!r}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
)
return result.stdout
@pytest.fixture(scope="module")
def distribution_workspace() -> Iterator[tuple[Path, dict[str, str]]]:
workspace = ROOT / ".test-artifacts" / f"distribution-{uuid.uuid4().hex}"
workspace.mkdir(parents=True)
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",
"PIP_DISABLE_PIP_VERSION_CHECK": "1",
"PYTHONDONTWRITEBYTECODE": "1",
}
)
try:
if os.environ.get("RIFF_RELEASE_DIST") is None:
# Default build makes the wheel from the sdist, exercising both layouts.
_run(
[
sys.executable,
"-I",
"-B",
"-m",
"build",
"--no-isolation",
"--outdir",
str(workspace / "dist"),
str(ROOT),
],
cwd=ROOT,
env=env,
)
_distribution_directory(workspace)
yield workspace, env
finally:
shutil.rmtree(workspace)
def test_build_distributions(
distribution_workspace: tuple[Path, dict[str, str]],
) -> None:
workspace, _ = distribution_workspace
directory = _distribution_directory(workspace)
wheels = list(directory.glob("*.whl"))
sdists = list(directory.glob("*.tar.gz"))
assert len(wheels) == len(sdists) == 1
with zipfile.ZipFile(wheels[0]) as wheel:
assert "riff_groove_builder/__init__.py" in wheel.namelist()
package_files = {
path.relative_to(ROOT / "src").as_posix(): path
for path in (ROOT / "src" / "riff_groove_builder").rglob("*")
if path.is_file() and path.suffix in (".py", ".json")
}
assert {
name for name in wheel.namelist() if name.startswith("riff_groove_builder/")
} == set(package_files)
for name, path in package_files.items():
assert wheel.read(name) == path.read_bytes()
metadata_names = [name for name in wheel.namelist() if ".dist-info/" in name]
assert sorted(name.rsplit("/", 1)[1] for name in metadata_names) == [
"METADATA",
"RECORD",
"WHEEL",
"top_level.txt",
]
assert len(wheel.namelist()) == len(package_files) + len(metadata_names)
metadata = Parser().parsestr(
wheel.read(next(name for name in metadata_names if name.endswith("/METADATA"))).decode(
"utf-8"
)
)
assert metadata["Version"] == "0.2.0"
assert str(metadata.get_payload()).replace("\r\n", "\n") == (ROOT / "README.md").read_text(
"utf-8"
)
with tarfile.open(sdists[0]) as sdist:
names = sdist.getnames()
assert any(name.endswith("/src/riff_groove_builder/__init__.py") for name in names)
assert any(name.endswith("/pyproject.toml") for name in names)
assert not any("/.venv/" in name or "/.test-artifacts/" in name for name in names)
files = {
"/".join(member.name.split("/")[1:]): member
for member in sdist.getmembers()
if member.isfile()
}
for name, path in package_files.items():
saved = sdist.extractfile(files["src/" + name])
assert saved is not None and saved.read() == path.read_bytes()
for name in ("README.md", "pyproject.toml"):
saved = sdist.extractfile(files[name])
assert saved is not None and saved.read() == (ROOT / name).read_bytes()
assert all(
name in ("README.md", "pyproject.toml", "setup.cfg", "PKG-INFO")
or name.removeprefix("src/") in package_files
or name.startswith("src/gaj3t_musicgen_riff_groove_builder.egg-info/")
for name in files
)
def test_wheel_import_outside_checkout(
distribution_workspace: tuple[Path, dict[str, str]],
) -> None:
workspace, env = distribution_workspace
wheel = next(_distribution_directory(workspace).glob("*.whl"))
environment = workspace / "wheel-venv"
outside_checkout = ROOT.parent
assert not outside_checkout.is_relative_to(ROOT)
_run(
[sys.executable, "-I", "-B", "-m", "venv", str(environment)],
cwd=outside_checkout,
env=env,
)
python = environment / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
_run(
[
str(python),
"-I",
"-B",
"-m",
"pip",
"install",
"--no-index",
"--no-deps",
"--no-cache-dir",
str(wheel),
],
cwd=outside_checkout,
env=env,
)
probe = """
import contextlib
import importlib.metadata
import io
import json
import pathlib
import sys
stdout, stderr = io.StringIO(), io.StringIO()
with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
import riff_groove_builder as package
assert stdout.getvalue() == stderr.getvalue() == ""
assert "mcp" not in sys.modules
assert "riff_groove_builder.server" not in sys.modules
distribution = importlib.metadata.distribution("gaj3t-musicgen-riff-groove-builder")
module_path = pathlib.Path(package.__file__).resolve()
installed_file = pathlib.Path(distribution.locate_file("riff_groove_builder/__init__.py")).resolve()
assert package.__version__ == distribution.version == "0.2.0"
assert module_path == installed_file
assert module_path.is_relative_to(pathlib.Path(sys.prefix).resolve())
print(json.dumps({
"version": package.__version__,
"metadata_version": distribution.version,
"module_path": str(module_path),
"prefix": sys.prefix,
"cwd": str(pathlib.Path.cwd()),
"isolated": sys.flags.isolated,
}))
"""
output = _run(
[str(python), "-I", "-B", "-c", probe],
cwd=outside_checkout,
env=env,
)
evidence = json.loads(output)
assert evidence["isolated"] == 1
assert Path(evidence["cwd"]).resolve() == outside_checkout
assert Path(evidence["module_path"]).is_relative_to(environment)
assert not Path(evidence["module_path"]).is_relative_to(ROOT / "src")
print(f"Installed-wheel evidence: {output.strip()}")
_WHEEL_BOOTSTRAP = """
import hashlib
import importlib
import importlib.metadata
import importlib.resources
import json
from pathlib import Path
import runpy
import sys
target = Path(sys.argv[1]).resolve()
sys.path.insert(0, str(target))
names = (
"riff_groove_builder", "riff_groove_builder.server",
"riff_groove_builder.service", "riff_groove_builder.schemas",
"riff_groove_builder.errors", "riff_groove_builder.description",
"riff_groove_builder.hybrid", "riff_groove_builder.pitch",
"riff_groove_builder.compose", "riff_groove_builder.profiles",
"riff_groove_builder.articulations", "riff_groove_builder.midi",
"riff_groove_builder.formats", "riff_groove_builder.formats.agp",
"riff_groove_builder.formats.sdp", "riff_groove_builder.data",
"riff_groove_builder.data.profiles",
)
locations = {}
for name in names:
module = importlib.import_module(name)
path = Path(module.__file__).resolve()
assert path.is_relative_to(target), (name, path)
locations[name] = str(path)
main_path = Path(importlib.util.find_spec("riff_groove_builder.__main__").origin).resolve()
assert main_path.is_relative_to(target)
locations["riff_groove_builder.__main__"] = str(main_path)
distribution = importlib.metadata.distribution("gaj3t-musicgen-riff-groove-builder")
assert Path(distribution.locate_file("")).resolve() == target
assert distribution.version == "0.2.0"
assert not json.loads(distribution.read_text("direct_url.json")).get("dir_info", {}).get("editable")
profiles = importlib.import_module("riff_groove_builder.data.profiles")
resources = importlib.resources.files(profiles)
resource_names = sorted(path.name for path in resources.iterdir() if path.name.endswith(".json"))
assert resource_names == sorted(profiles.PROFILE_RESOURCES)
resource_evidence = {}
for name in resource_names:
resource = resources.joinpath(name)
assert Path(str(resource)).resolve().is_relative_to(target)
assert json.loads(resource.read_text(encoding="utf-8"))["schema_version"] == "1"
resource_evidence[name] = {
"path": str(resource), "sha256": hashlib.sha256(resource.read_bytes()).hexdigest()
}
assert sys.flags.isolated == 1
if sys.argv[2] == "probe":
from riff_groove_builder.articulations import compile_score
from riff_groove_builder.formats.agp import write_riffer, validate_riffer_file
from riff_groove_builder.profiles import load_profile_registry
from riff_groove_builder.schemas import Score, ProfileSelection, ControlChangeEvent
native_evidence = []
output = target.parent / "installed-native-readback"
output.mkdir()
for part, identifier, pitch, extension in (
("lead", "ample.ame.4.0.1.riffer.v1", 36, "griff"),
("bass", "ample.amr.4.1.0.riffer.v1", 35, "briff"),
):
profile = load_profile_registry().select(
[part], ProfileSelection(**{part: identifier})
)[part]
score = Score.model_validate({
"intent": {
"description": "Original installed-wheel native verification",
"parts": [part], "tempo_bpm": 120, "bars": 1,
"time_signature": {"numerator": 4, "denominator": 4},
"key": "C minor", "seed": 0,
},
"start": {"numerator": 0}, "end": {"numerator": 4},
"tracks": [{"part": part, "notes": [{
"kind": "pitched", "part": part, "pitch": pitch,
"start": {"numerator": 0}, "duration": {"numerator": 1},
"intensity": 0.5, "articulation": "palm_mute",
}]}],
})
plan = compile_score(score, {part: profile})
plan.tracks[0].events.append(ControlChangeEvent(
part=part, channel=profile.channel, tick=480, priority=10,
sequence=100, controller=1, value=120,
))
path = output / ("original." + extension)
write_riffer(path, plan, part, profile)
saved = validate_riffer_file(path, plan, part, profile)
assert len(saved.notes) == 1 and saved.notes[0].pitch == pitch
assert saved.notes[0].articulation == ("PM" if part == "lead" else "PMP")
assert saved.cc1 == ((240, 120),)
native_evidence.append({
"extension": extension, "notes": len(saved.notes), "cc1": saved.cc1,
"size_bytes": path.stat().st_size, "path": str(path),
})
from riff_groove_builder.formats.sdp import write_sdp, validate_sdp_file
template = output / "original-template.sd3p"
lines = [
"PlugVersion 3.4.4", "SAMPLER {", "HQ {", 'soundlib "SL-DFH"', "}",
]
for index, (pad, pitch) in enumerate((("kickR", 36), ("snareR", 38), ("hatsTP", 42))):
lines.extend([
f"instbox {index} {{", "xpad 0 SL-DFH {", "pads {", f"pad {pad} {{",
"}", f"alias {pad} {pitch}", "}", "}", "}",
])
lines.extend([
"}", "ClearTracksFirst", "SongTrack 0 {", "ClearTrackFirst", "ClearSongParts",
"TrackLength 4", "Tempo 120 0 0", "TimeSig 4 4 0", "}",
"SetCurrentSongTrack 0", "MidiInChannel -1",
])
template.write_bytes(("\\n".join(lines) + "\\n").encode())
profile = load_profile_registry().select(
["drums"], ProfileSelection(drums="toontrack.sd3.3.4.4.core.v1")
)["drums"]
score = Score.model_validate({
"intent": {
"description": "Original installed-wheel SD3 verification",
"parts": ["drums"], "tempo_bpm": 137.5, "bars": 1,
"time_signature": {"numerator": 4, "denominator": 4},
"key": "E minor", "seed": 19,
},
"start": {"numerator": 0}, "end": {"numerator": 4},
"tracks": [{"part": "drums", "notes": [{
"kind": "drum", "part": "drums", "voice": "snare",
"start": {"numerator": 0}, "duration": {"numerator": 1, "denominator": 8},
"intensity": 1.0, "articulation": "normal",
}]}],
})
plan = compile_score(score, {"drums": profile})
path = output / "original.sd3p"
write_sdp(path, plan, "drums", profile, template=template)
saved = validate_sdp_file(path, plan, "drums", profile, template=template)
assert len(saved.notes) == 1
assert (saved.notes[0].channel, saved.notes[0].pitch, saved.notes[0].velocity) == (9, 38, 127)
native_evidence.append({
"extension": "sd3p", "notes": 1,
"size_bytes": path.stat().st_size, "path": str(path),
})
print(json.dumps({
"locations": locations, "resources": resource_names, "target": str(target),
"resource_evidence": resource_evidence,
"module_sha256": {
name: hashlib.sha256(Path(path).read_bytes()).hexdigest()
for name, path in locations.items()
},
"cwd": str(Path.cwd()), "isolated": sys.flags.isolated,
"dependency_mcp": importlib.import_module("mcp").__file__,
"version": distribution.version,
"native_readback": native_evidence,
}))
else:
sys.argv = ["riff_groove_builder", "--output-dir", sys.argv[2], *sys.argv[3:]]
runpy.run_module("riff_groove_builder", run_name="__main__")
"""
@pytest.fixture
def anyio_backend() -> str:
return "asyncio"
async def _call(
client: RawStdio, name: ToolName, arguments: dict[str, object]
) -> dict[str, object]:
Draft202012Validator(tool_input_schema(name)).validate(arguments)
response = await client.request(name, "tools/call", {"name": name, "arguments": arguments})
result = response["result"]
Draft202012Validator(tool_output_schema(name)).validate(result["structuredContent"])
assert len(result["content"]) == 1
assert result["content"][0]["type"] == "text"
assert json.loads(result["content"][0]["text"]) == result["structuredContent"]
assert isinstance(result, dict)
return result
def _read_published_midi(
result: GenerationResult, outputs: Path, basename: str
) -> dict[str, object]:
assert result.resolved.parts == ["lead", "bass", "drums"]
assert result.resolved.tempo_bpm == 137.5 and result.resolved.bars == 2
assert result.resolved.time_signature.model_dump() == {"numerator": 7, "denominator": 8}
assert result.resolved.key == "A# minor" and result.resolved.seed == 42
assert result.resolved.profile_ids.selected() == {
"lead": "standard.lead.v1",
"bass": "standard.bass.v1",
"drums": "standard.gm-drums.v1",
}
assert result.resolved.musical_start_tick == 0
assert result.resolved.musical_end_tick == 6720 and result.resolved.ticks_per_quarter == 960
assert result.resolved.assumptions == [
"template: omitted; using rock.",
"technique: omitted; using normal.",
]
assert result.resolved.overrides == []
assert len(result.artifacts) == 1
artifact = result.artifacts[0]
path = Path(artifact.path)
assert artifact.format == "mid" and artifact.parts == result.resolved.parts
assert artifact.profile_ids == ["standard.lead.v1", "standard.bass.v1", "standard.gm-drums.v1"]
assert path.is_absolute() and path == outputs / basename / f"{basename}.mid"
assert list(path.parent.iterdir()) == [path]
data = path.read_bytes()
assert data.startswith(b"MThd") and len(data) == artifact.size_bytes == path.stat().st_size
midi = mido.MidiFile(path)
assert midi.type == 1 and midi.ticks_per_beat == 960
assert [track.name for track in midi.tracks] == ["Conductor", "Lead", "Bass", "Drums"]
conductor = midi.tracks[0]
assert [message.type for message in conductor] == [
"track_name",
"set_tempo",
"time_signature",
"end_of_track",
]
assert conductor[1].tempo == 436364 and conductor[1].time == 0
assert (conductor[2].numerator, conductor[2].denominator, conductor[2].time) == (7, 8, 0)
counts = []
for index, track in enumerate(midi.tracks):
tick = 0
active: dict[tuple[int, int], int] = {}
onsets = []
for message in track:
assert isinstance(message.time, int) and message.time >= 0
tick += message.time
if message.is_meta:
assert message.type in (
("track_name", "set_tempo", "time_signature", "end_of_track")
if index == 0
else ("track_name", "end_of_track")
)
continue
assert index > 0 and message.type in ("note_on", "note_off")
assert message.channel == (0, 1, 9)[index - 1]
assert 0 <= message.note <= 127 and 0 <= message.velocity <= 127
key = message.channel, message.note
if message.type == "note_on":
assert message.velocity > 0 and key not in active and tick < 6720
active[key] = tick
onsets.append(tick)
if index == 3:
assert message.note in (36, 38, 42)
else:
assert key in active and tick - active.pop(key) == (240 if index == 3 else 960)
assert not active and tick == 6720
assert track[-1].type == "end_of_track"
assert sum(message.type == "end_of_track" for message in track) == 1
assert onsets == (
[]
if index == 0
else [
tick
for tick in (0, 960, 1920, 3360, 4320, 5280)
for _ in range(2 if index == 3 else 1)
]
)
counts.append(len(onsets))
return {
"path": str(path),
"size": len(data),
"sha256": hashlib.sha256(data).hexdigest(),
"note_counts": counts,
}
@pytest.mark.anyio
async def test_built_wheel_real_stdio_generation_outside_checkout(
distribution_workspace: tuple[Path, dict[str, str]],
) -> None:
workspace, env = distribution_workspace
wheel = next(_distribution_directory(workspace).glob("*.whl"))
wheel_sha256 = hashlib.sha256(wheel.read_bytes()).hexdigest()
target = workspace / "installed-server"
outputs = workspace / "server-outputs"
outputs.mkdir()
outside = ROOT.parent
assert not outside.is_relative_to(ROOT)
_run(
[
sys.executable,
"-I",
"-B",
"-m",
"pip",
"install",
"--no-index",
"--no-deps",
"--no-cache-dir",
"--target",
str(target),
str(wheel),
],
cwd=outside,
env=env,
)
with zipfile.ZipFile(wheel) as archive:
resources = [name for name in archive.namelist() if name.endswith(".json")]
assert len(resources) == 6
assert all(name.startswith("riff_groove_builder/data/profiles/") for name in resources)
for name in resources:
assert target.joinpath(*name.split("/")).read_bytes() == archive.read(name)
command = [sys.executable, "-I", "-B", "-c", _WHEEL_BOOTSTRAP, str(target)]
evidence = json.loads(_run([*command, "probe"], cwd=outside, env=env))
assert Path(evidence["cwd"]) == outside and evidence["isolated"] == 1
assert Path(evidence["dependency_mcp"]).is_relative_to(Path(sys.prefix))
assert len(evidence["locations"]) == 18
assert [item["extension"] for item in evidence["native_readback"]] == ["griff", "briff", "sd3p"]
assert all(
item["notes"] == 1
and item["size_bytes"] > 0
and Path(item["path"]).is_relative_to(workspace)
for item in evidence["native_readback"]
)
assert all(Path(path).is_relative_to(target) for path in evidence["locations"].values())
assert all(
not Path(path).is_relative_to(ROOT / "src") for path in evidence["locations"].values()
)
for name, path in evidence["locations"].items():
source = ROOT / "src" / Path(path).relative_to(target)
assert hashlib.sha256(source.read_bytes()).hexdigest() == evidence["module_sha256"][name]
for name, resource in evidence["resource_evidence"].items():
source = ROOT / "src" / "riff_groove_builder" / "data" / "profiles" / name
assert hashlib.sha256(source.read_bytes()).hexdigest() == resource["sha256"]
disk_evidence = []
for initialized in (True, False):
process = await asyncio.wait_for(
asyncio.create_subprocess_exec(
*command,
str(outputs),
cwd=outside,
env=env,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
),
TIMEOUT,
)
client = RawStdio(process)
try:
if not initialized:
await client.close()
assert process.returncode == 0
assert client.lines == [] and client.diagnostics == b""
evidence["uninitialized_eof_exit_code"] = process.returncode
continue
with anyio.fail_after(60):
handshake = await client.initialize()
assert handshake["result"]["protocolVersion"] in SUPPORTED_PROTOCOL_VERSIONS
assert handshake["result"]["serverInfo"]["name"] == "riff-groove-builder"
tools = (await client.request(1, "tools/list"))["result"]["tools"]
names: tuple[ToolName, ...] = ("list_instrument_profiles", "generate_music")
assert [tool["name"] for tool in tools] == list(names)
for name, tool in zip(names, tools, strict=True):
assert tool["inputSchema"] == tool_input_schema(name)
assert tool["outputSchema"] == tool_output_schema(name)
listed = await _call(client, "list_instrument_profiles", {})
assert listed["isError"] is False
profiles = ProfileListResult.model_validate(listed["structuredContent"]).profiles
assert [profile.id for profile in 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 all(
profile.mapping_kind == "standard_midi"
and profile.midi_available
and not profile.native_available
and profile.supported_articulations == ["normal"]
and profile.limitations
for profile in profiles
if profile.id.startswith("standard.")
)
assert [p.native_available for p in profiles] == [
True,
True,
False,
False,
False,
False,
]
evidence["text_only_recovery"] = await exercise_text_feedback(
client, outputs, label="installed-wheel"
)
evidence["handshake"] = handshake["result"]
evidence["tool_names"] = [tool["name"] for tool in tools]
arguments: dict[str, object] = {
"description": "lead bass drums 137.5 BPM 2 bars 7/8 Bb minor quarter rests",
"seed": 42,
"profiles": {
"lead": "standard.lead.v1",
"bass": "standard.bass.v1",
"drums": "standard.gm-drums.v1",
},
}
for basename, formats in (
("explicit", ["mid"]),
("default", None),
("native", ["agp", "sdp"]),
):
extra = {} if formats is None else {"formats": formats}
response = await _call(
client, "generate_music", {**arguments, "basename": basename, **extra}
)
assert response["isError"] is False
result = GenerationResult.model_validate(response["structuredContent"])
fallback = [] if basename == "explicit" else ["lead", "bass", "drums"]
assert result.status == ("midi_fallback" if fallback else "complete")
assert result.artifacts[0].fallback_for == fallback
assert [(warning.code, warning.part) for warning in result.warnings] == [
("STANDARD_MIDI_MAPPING", "lead"),
("STANDARD_MIDI_MAPPING", "bass"),
("STANDARD_MIDI_MAPPING", "drums"),
*(("NATIVE_FORMAT_UNAVAILABLE", part) for part in fallback),
]
for warning in result.warnings[3:]:
assert (
"sdp_profile_not_supported"
if warning.part == "drums"
else "riffer_profile_not_supported"
) in warning.message
disk_evidence.append(_read_published_midi(result, outputs, basename))
assert len({item["sha256"] for item in disk_evidence}) == 1
target_request = job(basename="target-no-template")
response = await _call(
client,
"generate_music",
target_request.model_dump(mode="json", exclude_none=True),
)
target_result = GenerationResult.model_validate(response["structuredContent"])
assert response["isError"] is False and target_result.status == "midi_fallback"
assert [a.format for a in target_result.artifacts] == ["mid", "griff", "briff"]
assert target_result.artifacts[0].fallback_for == ["drums"]
assert [
(w.part, w.message)
for w in target_result.warnings
if w.code == "NATIVE_FORMAT_UNAVAILABLE"
] == [
(
"drums",
"sd3p: sdp_template_required; "
"the combined Standard MIDI substitutes for this native target.",
)
]
validate_saved(target_result, target_request, None)
before = sorted(outputs.iterdir())
response = await _call(
client,
"generate_music",
job(basename="target-disabled", allow_midi_fallback=False).model_dump(
mode="json", exclude_none=True
),
)
assert response["isError"] is True
error = GenerationError.model_validate(response["structuredContent"])
assert error.code == "NATIVE_FORMAT_UNAVAILABLE"
assert error.details == {
"format": "sd3p",
"part": "drums",
"reason": "sdp_template_required",
}
assert sorted(outputs.iterdir()) == before
failures: list[tuple[str, str, dict[str, object], str]] = [
(
"disabled",
"drums only",
{"allow_midi_fallback": False},
"NATIVE_FORMAT_UNAVAILABLE",
),
(
"unsupported",
"lead only palm mute",
{"formats": ["mid"]},
"UNSUPPORTED_ARTICULATION",
),
(
"disabled_lead",
"lead only",
{"allow_midi_fallback": False},
"NATIVE_FORMAT_UNAVAILABLE",
),
("unicode", "drums only café", {"formats": ["mid"]}, "UNSUPPORTED_DESCRIPTION"),
("explicit", "drums only", {"formats": ["mid"]}, "OUTPUT_EXISTS"),
]
for basename, description, error_options, code in failures:
before = sorted(outputs.iterdir())
response = await _call(
client,
"generate_music",
{
"description": description,
"basename": basename,
"profiles": (
{"drums": "standard.gm-drums.v1"}
if description.startswith("drums")
else {"lead": "standard.lead.v1"}
),
**error_options,
},
)
assert response["isError"] is True
error = GenerationError.model_validate(response["structuredContent"])
assert error.code == code
assert sorted(outputs.iterdir()) == before
if basename == "disabled":
assert error.details == {
"format": "sd3p",
"part": "drums",
"reason": "sdp_profile_not_supported",
}
if basename == "disabled_lead":
assert error.details == {
"format": "griff",
"part": "lead",
"reason": "riffer_profile_not_supported",
}
assert "café" not in json.dumps(response, ensure_ascii=False)
assert not list(outputs.glob(".riff-stage-*"))
await client.send('{"private-description": "秘密 café", invalid JSON')
notification = await client.receive()
assert notification["method"] == "notifications/message"
assert notification["params"]["data"] == "Internal Server Error"
assert (await client.request("after-malformed", "ping"))["result"] == {}
await client.assert_quiet()
finally:
with anyio.CancelScope(shield=True):
await client.close()
assert process.returncode == 0
if initialized:
assert len(client.lines) == 20
assert b"SDK rejected malformed protocol input" in client.diagnostics
assert "秘密" not in client.diagnostics.decode("utf-8")
assert b"private-description" not in client.diagnostics
evidence["server_pid"] = process.pid
evidence["stdout_lines"] = len(client.lines)
evidence["exit_code"] = process.returncode
else:
assert client.lines == [] and client.diagnostics == b""
original_template = target.parent / "controls-original-template.sd3p"
shutil.copyfile(TEMPLATE, original_template)
original_bytes = original_template.read_bytes()
original_info = original_template.stat()
process = await asyncio.wait_for(
asyncio.create_subprocess_exec(
*command,
str(outputs),
"--sd3-template",
str(original_template),
cwd=outside,
env=env,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
),
TIMEOUT,
)
native_client = RawStdio(process)
native_evidence = []
try:
await native_client.initialize()
listed = await _call(native_client, "list_instrument_profiles", {})
summaries = ProfileListResult.model_validate(listed["structuredContent"]).profiles
assert all(p.native_available for p in summaries if p.mapping_kind == "instrument")
for basename, formats in (
("native-default", None),
("native-alias", ["agp", "sdp"]),
("native-actual", ["griff", "briff", "sd3p"]),
("native-midi", ["mid"]),
):
request = job(basename=basename, formats=formats, allow_midi_fallback=False)
response = await _call(
native_client, "generate_music", request.model_dump(mode="json", exclude_none=True)
)
assert response["isError"] is False
result = GenerationResult.model_validate(response["structuredContent"])
assert result.status == "complete"
assert [a.format for a in result.artifacts] == (
["mid", "griff", "briff", "sd3p"]
if formats is None
else ["mid"]
if formats == ["mid"]
else ["griff", "briff", "sd3p"]
)
native_evidence.append(validate_saved(result, request, original_template))
before_collision = {
str(path): path.read_bytes() for path in outputs.rglob("*") if path.is_file()
}
response = await _call(
native_client,
"generate_music",
job(basename="native-default").model_dump(mode="json", exclude_none=True),
)
assert response["isError"] is True
assert GenerationError.model_validate(response["structuredContent"]).code == "OUTPUT_EXISTS"
assert {
str(path): path.read_bytes() for path in outputs.rglob("*") if path.is_file()
} == before_collision
assert not list(outputs.glob(".riff-stage-*"))
control_outputs = await exercise_control_stdio(
native_client, outputs, original_template, prefix="wheel-cc"
)
await exercise_phrase_stdio(native_client, outputs, label="installed-wheel")
legacy_lines = len(native_client.lines)
finally:
with anyio.CancelScope(shield=True):
await native_client.close()
assert native_client.diagnostics == b"" and process.returncode == 0
assert legacy_lines == len(native_client.lines) == 23
process = await asyncio.wait_for(
asyncio.create_subprocess_exec(
*command,
str(outputs),
cwd=outside,
env=env,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
),
TIMEOUT,
)
hybrid_client = RawStdio(process)
try:
handshake = await hybrid_client.initialize()
assert handshake["result"]["serverInfo"]["version"] == "0.2.0"
hybrid_outputs = await exercise_hybrid_stdio(
hybrid_client, outputs, label="installed-wheel"
)
finally:
await hybrid_client.close()
assert process.returncode == 0 and hybrid_client.diagnostics == b""
evidence["hybrid_transport"] = {
"handshake": handshake["result"],
"stdout_lines": len(hybrid_client.lines),
"exit_code": process.returncode,
"stderr": hybrid_client.diagnostics.decode("utf-8"),
"sd3_template": None,
}
assert original_template.read_bytes() == original_bytes
assert (original_template.stat().st_ino, original_template.stat().st_mtime_ns) == (
original_info.st_ino,
original_info.st_mtime_ns,
)
assert sorted(path.name for path in outputs.iterdir()) == sorted(
[
"default",
"explicit",
"native",
"native-alias",
"native-actual",
"native-default",
"native-midi",
"target-no-template",
"text-recovered",
"phrase-original",
"phrase-nearby",
*control_outputs,
*hybrid_outputs,
]
)
assert not list(outputs.rglob("*.agp")) and not list(outputs.rglob("*.sdp"))
print(f"Installed-wheel server evidence: {json.dumps(evidence, sort_keys=True)}")
print(f"Installed-wheel disk evidence: {json.dumps(disk_evidence, sort_keys=True)}")
print(f"Installed-wheel native service evidence: {json.dumps(native_evidence, sort_keys=True)}")
assert hashlib.sha256(wheel.read_bytes()).hexdigest() == wheel_sha256
evidence.update(
{
"wheel_path": str(wheel),
"wheel_sha256": wheel_sha256,
"native_stdout_lines": len(native_client.lines),
"native_exit_code": process.returncode,
"native_stderr": native_client.diagnostics.decode("utf-8"),
"disk": disk_evidence,
"native": native_evidence,
}
)
EVIDENCE.mkdir(parents=True, exist_ok=True)
(EVIDENCE / "distribution-acceptance.json").write_text(
json.dumps(evidence, indent=2), encoding="utf-8"
)