Spaces:
Running on Zero
Running on Zero
| #!/usr/bin/env python3 | |
| """Minimal, dependency-light client for the English STT + TTS Space. | |
| Calls the two stable named endpoints: | |
| POST/GET /gradio_api/call/transcribe (api_name="/transcribe") | |
| POST/GET /gradio_api/call/speak (api_name="/speak") | |
| gradio_client hides the two-step enqueue->stream protocol, so use it unless you need to | |
| speak HTTP directly (the raw form is documented at the bottom of this file). | |
| Environment (never hardcode credentials): | |
| EN_SPEECH_SPACE Space id "user/space" or a full https URL. REQUIRED. | |
| HF_TOKEN Optional Hugging Face token. Sending one matters: an anonymous call | |
| draws the shared anonymous ZeroGPU allowance (~2 min/day) instead of | |
| your account quota, and fails with "ZeroGPU quota exceeded" on an | |
| HTTP 200 response. If unset, gradio_client falls back to the token | |
| saved by `hf auth login` (~/.cache/huggingface/token). | |
| Examples: | |
| EN_SPEECH_SPACE=user/en-stt-tts HF_TOKEN=hf_xxx \ | |
| python client_example.py audio speech.wav | |
| EN_SPEECH_SPACE=user/en-stt-tts HF_TOKEN=hf_xxx \ | |
| python client_example.py tts "The quick brown fox." --voice bf_emma --speed 1.1 | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import os | |
| import sys | |
| from pathlib import Path | |
| def get_client(): | |
| """Build an authenticated gradio_client for the Space named in EN_SPEECH_SPACE.""" | |
| from gradio_client import Client | |
| space = (os.environ.get("EN_SPEECH_SPACE") or "").strip() | |
| if not space: | |
| sys.exit("Set EN_SPEECH_SPACE to the Space id (e.g. user/en-stt-tts) or its URL.") | |
| # token=None makes gradio_client use the locally saved HF token, if any. | |
| token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN") | |
| return Client(space, token=token, verbose=False) | |
| def transcribe(client, audio_path: str, max_seconds: float = 300.0): | |
| """Upload an audio file, return (transcript, status).""" | |
| from gradio_client import handle_file | |
| transcript, status = client.predict( | |
| handle_file(audio_path), # -> first positional input (gr.Audio, filepath) | |
| max_seconds, # -> second positional input (gr.Slider) | |
| api_name="/transcribe", | |
| ) | |
| return transcript, status | |
| def speak(client, text: str, voice: str = "af_heart", speed: float = 1.0, | |
| max_chars: int = 5000): | |
| """Synthesise text, return (local_wav_path, status). | |
| gradio_client downloads the generated WAV to a local temp dir and returns its path. | |
| """ | |
| wav_path, status = client.predict( | |
| text, # gr.Textbox | |
| voice, # gr.Dropdown (value, e.g. "af_heart") | |
| speed, # gr.Slider (0.5 - 2.0) | |
| max_chars, # gr.Slider (maximum text length) | |
| api_name="/speak", | |
| ) | |
| return wav_path, status | |
| def main() -> int: | |
| ap = argparse.ArgumentParser(description=__doc__, | |
| formatter_class=argparse.RawDescriptionHelpFormatter) | |
| sub = ap.add_subparsers(dest="cmd", required=True) | |
| p_audio = sub.add_parser("audio", help="transcribe an audio file") | |
| p_audio.add_argument("file") | |
| p_audio.add_argument("--max-seconds", type=float, default=300.0) | |
| p_tts = sub.add_parser("tts", help="synthesise speech from text") | |
| p_tts.add_argument("text") | |
| p_tts.add_argument("--voice", default="af_heart") | |
| p_tts.add_argument("--speed", type=float, default=1.0) | |
| p_tts.add_argument("--max-chars", type=int, default=5000) | |
| p_tts.add_argument("--out", default=None, help="copy the WAV here (optional)") | |
| args = ap.parse_args() | |
| client = get_client() | |
| if args.cmd == "audio": | |
| path = Path(args.file) | |
| if not path.is_file(): | |
| sys.exit(f"No such file: {path}") | |
| transcript, status = transcribe(client, str(path), args.max_seconds) | |
| print(f"status : {status}") | |
| print(f"transcript : {transcript!r}") | |
| return 0 if transcript else 1 | |
| wav_path, status = speak(client, args.text, args.voice, args.speed, args.max_chars) | |
| print(f"status : {status}") | |
| print(f"wav : {wav_path}") | |
| if args.out: | |
| Path(args.out).write_bytes(Path(wav_path).read_bytes()) | |
| print(f"copied : {args.out}") | |
| return 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |
| # --------------------------------------------------------------------------------------- | |
| # Raw HTTP, no gradio_client (for reference — the enqueue + SSE dance): | |
| # | |
| # import json, os, requests | |
| # base = "https://<user>-<space>.hf.space" | |
| # hdr = {"Authorization": f"Bearer {os.environ['HF_TOKEN']}"} | |
| # r = requests.post(f"{base}/gradio_api/call/transcribe", | |
| # json={"data": ["<local path or FileData>", 300]}, headers=hdr) | |
| # event_id = r.json()["event_id"] | |
| # for line in requests.get(f"{base}/gradio_api/call/transcribe/{event_id}", | |
| # headers=hdr, stream=True).iter_lines(): | |
| # ... # lines look like: b'data: ["transcript", "status"]' | |
| # | |
| # A refusal (quota, queue, auth) arrives as an *error envelope inside the SSE payload* | |
| # with HTTP 200 — check for an "error" key before trusting the result. | |