Spaces:
Sleeping
Sleeping
File size: 4,650 Bytes
98d85a9 51deb9e 2259626 98d85a9 2259626 3975220 98d85a9 3975220 98d85a9 51deb9e 98d85a9 51deb9e 98d85a9 51deb9e 3975220 51deb9e 98d85a9 51deb9e 3975220 51deb9e 98d85a9 51deb9e 98d85a9 3975220 98d85a9 51deb9e 3975220 98d85a9 0d9d4b5 98d85a9 51deb9e 98d85a9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | """Gradio Server and synchronous ZeroGPU generation contracts."""
from __future__ import annotations
import io
import os
import tempfile
import unittest
import wave
from pathlib import Path
from types import SimpleNamespace
# Importing app builds the module-level hosted app, whose storage empties its
# OUTPUT_DIR on start. Never let a test run wipe the developer's ./outputs.
os.environ["OUTPUT_DIR"] = tempfile.mkdtemp(prefix="rickroll-test-outputs-")
try:
from app import create_zero_gpu_app
except ModuleNotFoundError as exc: # optional hosted dependencies are absent locally
raise unittest.SkipTest(f"Hosted Gradio dependencies unavailable: {exc}") from exc
from fastapi.testclient import TestClient
from backend.storage import StorageError
class _AudioRuntime:
def __init__(self) -> None:
self.last_request: dict | None = None
def initialize(self) -> None:
return None
def info(self) -> dict:
return {
"ready": True,
"model": {"loaded": True},
"vae": {"loaded": True},
"adapter": {"loaded": True},
}
def generate(
self,
lyrics: str,
style: str,
stage: Path,
progress,
*,
duration_seconds: int = 60,
input_audio_path: Path | None = None,
) -> dict:
self.last_request = {
"style": style,
"duration_seconds": duration_seconds,
"input_audio": input_audio_path.read_bytes() if input_audio_path else None,
}
progress({"stage": "synthesizing", "percent": 50})
output = Path(stage) / "audio.wav"
with wave.open(str(output), "wb") as audio:
audio.setnchannels(2)
audio.setsampwidth(2)
audio.setframerate(48_000)
audio.writeframes(bytes(48_000 * 2 * 2 // 10))
return {
"audio_path": str(output),
"metadata": {
"requested_duration": duration_seconds,
"generation_mode": "text",
},
}
class ZeroGpuAppTest(unittest.TestCase):
def test_gradio_transport_runs_and_publishes_for_the_cookie_session(self) -> None:
with tempfile.TemporaryDirectory() as directory:
runtime = _AudioRuntime()
app = create_zero_gpu_app(runtime=runtime, output_dir=directory)
with TestClient(app, base_url="https://testserver") as client:
session_response = client.get("/api/v1/tracks")
health = client.get("/api/v1/health").json()
request = SimpleNamespace(
headers={"host": "testserver", "origin": "https://testserver"},
cookies={"yue_session": client.cookies.get("yue_session")},
)
job = app.state.zero_gpu_generate("Neon signal", "Cyber synth", 90, request)
track = client.get(f"/api/v1/tracks/{job['track_id']}")
self.assertEqual(session_response.status_code, 200)
self.assertEqual(health["generation_transport"], "gradio")
self.assertTrue(health["ready"])
self.assertEqual(job["status"], "completed")
self.assertEqual(track.status_code, 200)
self.assertEqual(track.json()["lyrics"], "Neon signal")
self.assertEqual(track.json()["metadata"]["requested_duration"], 90)
self.assertEqual(runtime.last_request["duration_seconds"], 90)
self.assertEqual(runtime.last_request["style"], "Cyber synth")
def test_worker_artifact_is_published_only_by_parent_state(self) -> None:
with tempfile.TemporaryDirectory() as directory:
app = create_zero_gpu_app(runtime=_AudioRuntime(), output_dir=directory)
with TestClient(app, base_url="https://testserver"):
session, _ = app.state.session_manager.get_or_create(None)
job = app.state.jobs.submit(session_id=session.id, lyrics="Parent index", style="Cyber synth")
job, stage = app.state.jobs.begin(job.id, session.id)
result = app.state.jobs.generate_artifact(stage, job.lyrics, job.style)
self.assertEqual(app.state.storage.list(session.id), [])
completed = app.state.jobs.complete(job.id, session.id, stage, result)
stored = app.state.storage.get(completed.track_id, session.id)
self.assertEqual(completed.status, "completed")
self.assertEqual(stored.payload["lyrics"], "Parent index")
if __name__ == "__main__":
unittest.main()
|