Inflect-v3 / test_studio.py
owensong's picture
Default to native 24 kHz and add eight voice-matched Mini event tags for all six voices
4f78128 verified
Raw History Blame Contribute Delete
9.66 kB
import json
from pathlib import Path
import unittest
from unittest.mock import patch
from catalog import MAX_CHARACTERS, MODELS, TAGS, VOICES, validate
class StudioContract(unittest.TestCase):
def request(self, text="A little voice test.", **updates):
args = dict(text=text, model="mini", voice="cassidy", enhanced=False, events=False, seed=42)
args.update(updates)
return validate(**args)
def test_all_published_models_and_voices(self):
for key in MODELS:
for voice in VOICES:
self.assertEqual(self.request(model=key, voice=voice)["voice"], voice)
def test_no_enhancer_silently_added_to_small_models(self):
for key in ("micro", "atom"):
self.assertFalse(self.request(model=key)["enhanced"])
def test_compare_keeps_native_rate(self):
self.assertFalse(self.request(compare=True)["enhanced"])
def test_bounded_and_speakable_text(self):
for text in ("", " ", "x"*(MAX_CHARACTERS+1)):
with self.assertRaises(ValueError):self.request(text)
def test_event_contract(self):
self.assertEqual(len(TAGS), 8)
for voice in VOICES:
for tag in TAGS:
self.assertTrue(self.request("Okay. "+tag+" Let's go.", voice=voice, events=True)["events"])
for changes in (dict(model="micro"), dict(model="atom"), dict(compare=True), dict(events=False)):
args = dict(events=True);args.update(changes)
with self.assertRaises(ValueError):self.request("Okay. [sigh] Let's go.", **args)
def test_unknown_tags_refused(self):
for text in ("[angry] Hello.", "Hello <whisper>there</whisper>", "Hello [oops", "Hello [sigh] [oops", "word[inhale]"):
with self.assertRaises(ValueError):self.request(text, events=True)
def test_seed_bounds(self):
for seed in (-1, 2**32, 2.5, True, float('nan'), float('inf')):
with self.assertRaises(ValueError):self.request(seed=seed)
def test_public_revisions_are_pinned(self):
for spec in MODELS.values():
self.assertEqual(len(spec.revision), 40)
int(spec.revision,16)
class BridgeContract(unittest.TestCase):
@classmethod
def setUpClass(cls):
import os
with patch.dict(os.environ, {"INFLECT_UI_PREVIEW": "1"}):
import app
cls.app = app
def payload(self):
return json.dumps(dict(id="test-id", request=dict(text="Hello.",model="mini",voice="cassidy",
enhanced=True,events=False,seed=42,mode="Create")))
def test_bridge_accepts_complete_settings(self):
identifier, request = self.app.decode_request(self.payload())
self.assertEqual(identifier, "test-id")
self.assertEqual(request["model"], "mini")
def test_bridge_rejects_incomplete_or_invalid_settings(self):
for value in ('{}', '[]', '{"id":"bad<id>","request":{}}'):
with self.assertRaises(ValueError): self.app.decode_request(value)
def test_response_marker_escapes_html(self):
value = dict(id="test-id",message='<script>"&</script>')
rendered = self.app.marker(value)
self.assertNotIn("<script>", rendered)
self.assertEqual(self.app.marker_value(rendered), value)
def test_allocation_failure_returns_current_request_error(self):
value = self.app.marker_value(self.app.ui_finalize(self.payload(), ""))
self.assertEqual(value["id"], "test-id")
self.assertEqual(value["status"], "error")
def test_finalize_preserves_success(self):
rendered = self.app.marker(dict(id="test-id",status="complete",takes=[]))
self.assertEqual(self.app.ui_finalize(self.payload(), rendered), rendered)
class QualityComparison(unittest.TestCase):
def test_same_performance_is_rendered_once_with_preserved_pauses(self):
import contextlib
import io
import tempfile
from types import SimpleNamespace
import numpy as np
import soundfile as sf
from engine import Studio
class Wave:
def __init__(self, data): self.data = data
def detach(self): return self
def cpu(self): return self
def numpy(self): return self.data
class Enhancer:
calls = 0
def enhance(self, wave, rate):
self.calls += 1
self.assert_rate = rate
return Wave(np.repeat(wave.numpy(), 2)), {}
chunks = [np.linspace(-.25, .25, 100, dtype=np.float32), np.full(120, .1, dtype=np.float32)]
renders = []
def render(prepared, voice, runtime, enhancer, seed, subtype):
renders.append((voice, seed, subtype))
parts = []
for chunk in chunks:
if parts: parts.append(np.zeros(5760, dtype=np.float32))
wave, _ = enhancer.enhance(Wave(chunk), 24000)
parts.append(wave.numpy())
stream = io.BytesIO()
sf.write(stream, np.concatenate(parts), 48000, format="WAV", subtype="FLOAT")
return stream.getvalue(), {}
studio = Studio.__new__(Studio)
studio.torch = SimpleNamespace(inference_mode=contextlib.nullcontext)
studio.enhancer = Enhancer()
studio.mini_cli = SimpleNamespace(render=render)
studio.mini_runtime = object()
request = dict(model="mini", voice="cassidy", text="Test.", seed=42, events=False, prepared={})
with tempfile.TemporaryDirectory(prefix="inflect-ui-quality-") as directory:
studio.output = Path(directory)
results = studio.generate_quality_pair(request)
self.assertEqual(len(renders), 1)
self.assertEqual(studio.enhancer.calls, 2)
a, rate_a = sf.read(results[0]["path"], dtype="float32")
b, rate_b = sf.read(results[1]["path"], dtype="float32")
self.assertEqual((rate_a, rate_b), (24000, 48000))
self.assertEqual(len(b), 2 * len(a))
expected = np.concatenate([chunks[0], np.zeros(2880, dtype=np.float32), chunks[1]])
np.testing.assert_allclose(a, expected, atol=1/32768)
self.assertTrue(np.all(a[100:2980] == 0))
self.assertTrue(np.all(b[200:5960] == 0))
self.assertEqual([r["variant"] for r in results], ["native", "enhanced"])
self.assertTrue(all(r["shared_performance"] for r in results))
def test_capture_is_a_copy_not_a_mutable_reference(self):
from engine import NativeCapture
from unittest.mock import Mock
import numpy as np
source = np.array([.1, .2], dtype=np.float32)
wave = Mock()
wave.detach.return_value.cpu.return_value.numpy.return_value = source
capture = NativeCapture(Mock())
capture.enhance(wave, 24000)
source[:] = 0
self.assertGreater(float(capture.chunks[0].sum()), .29)
def test_restrictions_apply_before_runtime(self):
from engine import Studio
studio = Studio.__new__(Studio)
for request in (dict(model="micro", events=False), dict(model="mini", events=True)):
with self.assertRaises(ValueError): studio.generate_quality_pair(request)
def test_api_routes_quality_without_changing_existing_comparison(self):
import app
from unittest.mock import Mock
fake = Mock()
fake.prepare.side_effect = lambda request: request
fake.generate_quality_pair.return_value = [dict(path="a.wav", rate=24000), dict(path="b.wav", rate=48000)]
fake.generate.return_value = dict(path="c.wav", rate=24000)
with patch.object(app, "STUDIO", fake):
files, metadata = app.run_synthesis("Hello.", "mini", "cassidy", True, False, 42, "Quality")
self.assertEqual(files, ["a.wav", "b.wav"])
self.assertEqual([m["rate"] for m in metadata], [24000, 48000])
fake.generate.assert_not_called()
app.run_synthesis("Hello.", "mini", "cassidy", True, False, 42, "Compare")
self.assertEqual(fake.generate.call_count, 3)
with self.assertRaises(ValueError): app.run_synthesis("Hello.", "micro", "cassidy", False, False, 42, "Quality")
with self.assertRaises(ValueError): app.run_synthesis("Hello. [sigh]", "mini", "cassidy", True, True, 42, "Quality")
class StaticPreviews(unittest.TestCase):
def test_every_model_and_voice_has_a_verified_native_sample(self):
import hashlib
import numpy as np
import soundfile as sf
root = Path(__file__).parent / "assets/previews"
manifest = json.loads((root / "manifest.json").read_text())
self.assertEqual(len(manifest["samples"]), 18)
for model in MODELS:
for voice in VOICES:
filename = f"{model}-{voice}.wav"
sample = next(s for s in manifest["samples"] if s["file"] == filename)
self.assertEqual(hashlib.sha256((root / filename).read_bytes()).hexdigest(), sample["sha256"])
audio, rate = sf.read(root / filename, dtype="float32")
self.assertEqual(rate, 24000)
self.assertEqual(audio.ndim, 1)
self.assertTrue(np.isfinite(audio).all())
self.assertGreater(audio.size, 24000)
self.assertLess(float(np.abs(audio).max()), 1)
if __name__ == "__main__":unittest.main()