Open-source speech recognition toolkit for training, inference, streaming ASR, VAD, punctuation, speaker diarization pipelines, and OpenAI-compatible/MCP serving.
Python asraudiochineseemotion-recognitionfunasrmcp-servermultilingual-asropenai-compatible-apiparaformerpunctuationpytorchreal-time-asrspeaker-diarizationspeech-recognitionspeech-to-textstreaming-asrtranscriptionvllmvoice-activity-detectionwhisper-alternative
feat: add explicit MOSS serving profiles to Gradio client
zhifu gaod91d961e37a0
diff --git a/.github/workflows/test-gradio-client.yml b/.github/workflows/test-gradio-client.ymlnew file mode 100644index 000000000..66e0aa4f2--- /dev/null+++ b/.github/workflows/test-gradio-client.yml@@ -0,0 +1,37 @@+name: Validate Gradio client++on:+ pull_request:+ paths:+ - "examples/openai_api/gradio_app.py"+ - "examples/openai_api/GRADIO*.md"+ - "tests/test_gradio_app.py"+ - ".github/workflows/test-gradio-client.yml"+ push:+ branches: [main]+ paths:+ - "examples/openai_api/gradio_app.py"+ - "examples/openai_api/GRADIO*.md"+ - "tests/test_gradio_app.py"+ - ".github/workflows/test-gradio-client.yml"++permissions:+ contents: read++jobs:+ gradio-contract:+ runs-on: ubuntu-latest+ timeout-minutes: 10+ env:+ GRADIO_ANALYTICS_ENABLED: "False"+ steps:+ - uses: actions/checkout@v4+ - uses: actions/setup-python@v5+ with:+ python-version: "3.12"+ - name: Install the isolated client test environment+ run: python -m pip install gradio==6.26.0 pytest+ - name: Check client dependencies+ run: python -m pip check+ - name: Test real UI components and local HTTP transport without model downloads+ run: python -m pytest -q tests/test_gradio_app.pydiff --git a/examples/openai_api/gradio_app.py b/examples/openai_api/gradio_app.pyindex a1978861b..2404f3b01 100644--- a/examples/openai_api/gradio_app.py+++ b/examples/openai_api/gradio_app.py@@ -14,6 +14,23 @@ import uuidDEFAULT_BASE_URL = "http://localhost:8000"DEFAULT_MODEL = "sensevoice"+BACKEND_PROFILES = {+ "funasr": {+ "models": (DEFAULT_MODEL, "paraformer", "paraformer-en", "fun-asr-nano", "moss-transcribe-diarize"),+ "formats": ("json", "verbose_json"),+ "default_format": "verbose_json",+ },+ "vllm": {+ "models": ("moss-transcribe-diarize",),+ "formats": ("json", "diarized_json"),+ "default_format": "diarized_json",+ },+ "sglang-omni": {+ "models": ("OpenMOSS-Team/MOSS-Transcribe-Diarize",),+ "formats": ("verbose_json",),+ "default_format": "verbose_json",+ },+}def request_json(url: str, timeout: float) -> dict:@@ -102,25 +119,35 @@ def safe_check(base_url: str, timeout: float) -> str:return f"Service check failed: {error}"-def build_app(default_base_url: str, default_timeout: float):+def build_app(default_base_url: str, default_timeout: float, *, backend: str = "funasr", default_model: str | None = None):+ profile = BACKEND_PROFILES[backend]+ models = list(profile["models"])+ selected_model = default_model if default_model is not None else models[0]+ if selected_model not in models:+ models.append(selected_model)+ model_choices = [+ ("MOSS-Transcribe-Diarize" if value == "OpenMOSS-Team/MOSS-Transcribe-Diarize" else value, value)+ for value in models+ ]+try:import gradio as grexcept ImportError as error:- raise SystemExit("Install Gradio first: pip install gradio") from error+ raise SystemExit("Install Gradio in the client environment: python -m pip install gradio==6.26.0") from errorwith gr.Blocks(title="FunASR OpenAI API Demo") as demo:gr.Markdown("# FunASR OpenAI-Compatible API Demo")- gr.Markdown("Start `python server.py --model sensevoice --device cuda --port 8000`, then upload or record audio here.")with gr.Row():- base_url = gr.Textbox(label="API base URL", value=default_base_url)+ base_url = gr.Textbox(label="API base URL", value=default_base_url, min_width=240)model = gr.Dropdown(label="Model alias",- choices=["sensevoice", "paraformer", "paraformer-en", "fun-asr-nano"],- value=DEFAULT_MODEL,+ choices=model_choices,+ value=selected_model,+ min_width=240,)- response_format = gr.Radio(label="Response format", choices=["json", "verbose_json"], value="verbose_json")- timeout = gr.Number(label="Timeout seconds", value=default_timeout, precision=0)+ response_format = gr.Radio(label="Response format", choices=profile["formats"], value=profile["default_format"], min_width=240)+ timeout = gr.Number(label="Timeout seconds", value=default_timeout, precision=0, min_width=240)audio = gr.Audio(label="Audio", sources=["upload", "microphone"], type="filepath")with gr.Row():@@ -140,16 +167,21 @@ def build_app(default_base_url: str, default_timeout: float):return demo-def main() -> None:+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:parser = argparse.ArgumentParser(description="Run a Gradio demo for the FunASR OpenAI-compatible API")- parser.add_argument("--base-url", default=os.getenv("BASE_URL", DEFAULT_BASE_URL), help="FunASR API base URL")+ parser.add_argument("--base-url", default=os.getenv("BASE_URL", DEFAULT_BASE_URL), help="Backend origin without /v1; reached from the Gradio process")+ parser.add_argument("--backend", choices=tuple(BACKEND_PROFILES), default="funasr", help="Transcription protocol profile (native profiles default to MOSS)")+ parser.add_argument("--model", help="Exact served-model ID; overrides the profile's default model")parser.add_argument("--host", default=os.getenv("GRADIO_HOST", "127.0.0.1"), help="Gradio bind host")parser.add_argument("--port", type=int, default=int(os.getenv("GRADIO_PORT", "7860")), help="Gradio bind port")parser.add_argument("--timeout", type=float, default=float(os.getenv("TIMEOUT", "300")), help="HTTP timeout in seconds")parser.add_argument("--share", action="store_true", help="Create a temporary Gradio share link")- args = parser.parse_args()+ return parser.parse_args(argv)- app = build_app(args.base_url, args.timeout)++def main() -> None:+ args = parse_args()+ app = build_app(args.base_url, args.timeout, backend=args.backend, default_model=args.model)app.launch(server_name=args.host, server_port=args.port, share=args.share)diff --git a/tests/test_gradio_app.py b/tests/test_gradio_app.pynew file mode 100644index 000000000..36f0ccb22--- /dev/null+++ b/tests/test_gradio_app.py@@ -0,0 +1,231 @@+"""Model-free tests for the real Gradio UI and multipart HTTP client."""++import importlib.util+import json+from email import policy+from email.parser import BytesParser+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from pathlib import Path+import threading+import wave++import pytest+++ROOT = Path(__file__).resolve().parents[1]+SPEC = importlib.util.spec_from_file_location(+ "gradio_app", ROOT / "examples/openai_api/gradio_app.py"+)+app = importlib.util.module_from_spec(SPEC)+SPEC.loader.exec_module(app)+++def audio(tmp_path):+ path = tmp_path / "sample.wav"+ with wave.open(str(path), "wb") as stream:+ stream.setnchannels(1)+ stream.setsampwidth(2)+ stream.setframerate(16000)+ stream.writeframes(b"\x00\x00" * 1600)+ return path+++def endpoint():+ state = {+ "requests": [],+ "status": 200,+ "metadata": True,+ "payload": {+ "text": "\u4f60\u597d",+ "segments": [+ {"start": 0, "end": 0.5, "text": "\u4f60", "speaker": "speaker_0"},+ {"start": 0.5, "end": 1, "text": "\u597d", "speaker": 1},+ {"text": "[S02] untouched", "speaker": None},+ ],+ },+ }++ class Handler(BaseHTTPRequestHandler):+ def log_message(self, *_args):+ pass++ def reply(self, status, payload):+ body = json.dumps(payload).encode()+ self.send_response(status)+ self.send_header("Content-Type", "application/json")+ self.send_header("Content-Length", str(len(body)))+ self.end_headers()+ self.wfile.write(body)++ def do_GET(self):+ state["requests"].append(("GET", self.path, {}))+ self.reply(200 if state["metadata"] else 404, {"path": self.path})++ def do_POST(self):+ body = self.rfile.read(int(self.headers["Content-Length"]))+ message = BytesParser(policy=policy.default).parsebytes(+ ("Content-Type: " + self.headers["Content-Type"] + "\r\n\r\n").encode() + body+ )+ fields = {+ part.get_param("name", header="content-disposition"): part.get_payload(decode=True)+ for part in message.iter_parts()+ }+ state["requests"].append(("POST", self.path, fields))+ self.reply(state["status"], state["payload"])++ server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)+ worker = threading.Thread(target=server.serve_forever, daemon=True)+ worker.start()+ try:+ yield f"http://127.0.0.1:{server.server_port}", state+ finally:+ server.shutdown()+ server.server_close()+ worker.join(timeout=5)+ assert not worker.is_alive()+++def component(demo, label):+ matches = [item for item in demo.config["components"] if item["props"].get("label") == label]+ assert len(matches) == 1+ return matches[0]["props"]+++ "backend,model,formats,default_format",+ [+ ("funasr", "sensevoice", ["json", "verbose_json"], "verbose_json"),+ ("vllm", "moss-transcribe-diarize", ["json", "diarized_json"], "diarized_json"),+ ("sglang-omni", "OpenMOSS-Team/MOSS-Transcribe-Diarize", ["verbose_json"], "verbose_json"),+ ],+)+def test_real_ui_backend_contract(backend, model, formats, default_format):+ demo = app.build_app("http://127.0.0.1:8000", 300, backend=backend)+ try:+ model_control = component(demo, "Model alias")+ assert model_control["value"] == model+ choices = [choice[1] for choice in model_control["choices"]]+ assert model in choices+ if backend == "sglang-omni":+ assert model_control["choices"] == [("MOSS-Transcribe-Diarize", model)]+ if backend == "funasr":+ assert choices == ["sensevoice", "paraformer", "paraformer-en", "fun-asr-nano", "moss-transcribe-diarize"]+ response = component(demo, "Response format")+ assert [choice[0] for choice in response["choices"]] == formats+ assert response["value"] == default_format+ assert component(demo, "API base URL")["value"] == "http://127.0.0.1:8000"+ for label in ["API base URL", "Model alias", "Response format", "Timeout seconds"]:+ assert component(demo, label)["min_width"] >= 240+ assert component(demo, "Audio")["type"] == "filepath"+ finally:+ demo.close()+++def test_original_build_app_call_remains_supported():+ demo = app.build_app("http://127.0.0.1:8000", 300)+ try:+ assert component(demo, "Model alias")["value"] == "sensevoice"+ assert component(demo, "Response format")["value"] == "verbose_json"+ finally:+ demo.close()++[email protected]("backend", ["funasr", "vllm", "sglang-omni"])+def test_served_model_override_is_exact(backend):+ demo = app.build_app("http://127.0.0.1:8000", 300, backend=backend, default_model="operator/custom-model")+ try:+ control = component(demo, "Model alias")+ assert control["value"] == "operator/custom-model"+ assert "operator/custom-model" in [choice[1] for choice in control["choices"]]+ finally:+ demo.close()+++def test_cli_profile_and_model_defaults(monkeypatch):+ for name in ["BASE_URL", "GRADIO_HOST", "GRADIO_PORT", "TIMEOUT"]:+ monkeypatch.delenv(name, raising=False)+ args = app.parse_args([])+ assert (args.backend, args.model, args.host, args.port, args.share) == ("funasr", None, "127.0.0.1", 7860, False)+ args = app.parse_args(["--backend", "vllm", "--model", "served-id", "--base-url", "http://127.0.0.1:8898"])+ assert (args.backend, args.model, args.base_url) == ("vllm", "served-id", "http://127.0.0.1:8898")+ with pytest.raises(SystemExit):+ app.parse_args(["--backend", "not-a-backend"])++[email protected]("model,format_", [+ ("moss-transcribe-diarize", "verbose_json"),+ ("moss-transcribe-diarize", "diarized_json"),+ ("OpenMOSS-Team/MOSS-Transcribe-Diarize", "verbose_json"),+ ("operator/custom-model", "json"),+])+def test_real_http_preserves_fields_and_response(endpoint, audio, model, format_):+ url, state = endpoint+ transcript, raw = app.transcribe_audio(url + "/", str(audio), model, format_, 5)+ assert transcript == state["payload"]["text"]+ assert json.loads(raw) == state["payload"]+ assert state["requests"] == [("POST", "/v1/audio/transcriptions", {+ "file": audio.read_bytes(), "model": model.encode(), "response_format": format_.encode(),+ })]++[email protected]("payload", [{"text": "only text"}, {"text": "", "segments": []}, {"segments": [{"text": "[S00] raw"}]}])+def test_no_speaker_or_segment_fabrication(endpoint, audio, payload):+ url, state = endpoint+ state["payload"] = payload+ text, raw = app.transcribe_audio(url, str(audio), "moss-transcribe-diarize", "verbose_json", 5)+ assert text == payload.get("text", "")+ assert json.loads(raw) == payload+++def test_optional_metadata_failure_does_not_gate_transcription(endpoint, audio):+ url, state = endpoint+ state["metadata"] = False+ assert "HTTP 404" in app.safe_check(url, 5)+ text, raw = app.safe_transcribe(url, str(audio), "moss-transcribe-diarize", "diarized_json", 5)+ assert text == state["payload"]["text"]+ assert json.loads(raw) == state["payload"]+++def test_service_check_and_http_failure(endpoint, audio):+ url, state = endpoint+ assert json.loads(app.check_service(url, 5)) == {+ "health": {"path": "/health"}, "models": {"path": "/v1/models"},+ }+ state["status"] = 422+ state["payload"] = {"detail": "unsupported model"}+ text, raw = app.safe_transcribe(url, str(audio), "bad-model", "verbose_json", 5)+ assert text == ""+ assert "HTTP 422" in raw and "unsupported model" in raw+++def test_missing_audio_never_calls_backend(endpoint):+ url, state = endpoint+ assert app.safe_transcribe(url, None, "sensevoice", "json", 5)[0] == ""+ assert state["requests"] == []++[email protected]("backend,model,format_", [+ ("funasr", "moss-transcribe-diarize", "verbose_json"),+ ("vllm", "moss-transcribe-diarize", "diarized_json"),+ ("sglang-omni", "OpenMOSS-Team/MOSS-Transcribe-Diarize", "verbose_json"),+])+def test_live_gradio_upload_and_event_binding(endpoint, audio, backend, model, format_):+ from gradio_client import Client, handle_file++ url, state = endpoint+ demo = app.build_app(url, 5, backend=backend, default_model=model)+ try:+ _, local_url, _ = demo.launch(server_name="127.0.0.1", prevent_thread_lock=True, quiet=True)+ client = Client(local_url, verbose=False)+ transcript, raw = client.predict(url, handle_file(str(audio)), model, format_, 5, api_name="/safe_transcribe")+ assert transcript == state["payload"]["text"]+ assert json.loads(raw) == state["payload"]+ post = state["requests"][-1]+ assert post[:2] == ("POST", "/v1/audio/transcriptions")+ assert post[2]["model"] == model.encode()+ assert post[2]["response_format"] == format_.encode()+ assert post[2]["file"] == audio.read_bytes()+ finally:+ demo.close()