Spaces:
Running on Zero
Running on Zero
Download test_studio.py from owensong/Inflect-v3: direct link, hf CLI and curl.
- Browser
- Download file 9.66 kB
-
https://huggingface.co/spaces/owensong/Inflect-v3/resolve/main/test_studio.py
- Command line
-
hf download hf://spaces/owensong/Inflect-v3/test_studio.py
-
curl -L -o test_studio.py https://huggingface.co/spaces/owensong/Inflect-v3/resolve/main/test_studio.py
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): | |
| 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() | |