Download stream_speechmatics.py from WhissleAI/arc-tagger: direct link, hf CLI and curl.
- Browser
- Download file 4.88 kB
-
https://huggingface.co/WhissleAI/arc-tagger/resolve/main/stream_speechmatics.py
- Command line
-
hf download hf://WhissleAI/arc-tagger/stream_speechmatics.py
-
curl -L -o stream_speechmatics.py https://huggingface.co/WhissleAI/arc-tagger/resolve/main/stream_speechmatics.py
4.88 kB
| """Speechmatics real-time ASR -> Arc Tagger, printed as JSON lines. | |
| Status: tested against the documented message format (offline fixtures in tests/); not yet tested live. | |
| export SPEECHMATICS_API_KEY=... # read from the environment only | |
| pip install websockets # + sounddevice for --mic | |
| python stream_speechmatics.py --wav call.wav --domain talk | |
| python stream_speechmatics.py --mic --domain meeting --seconds 30 | |
| AddPartialTranscript is tagged immediately and replaced by the next partial; AddTranscript freezes the words; EndOfUtterance | |
| (conversation_config.end_of_utterance_silence_trigger) ends the utterance (utterance-level intent, act, safety and role | |
| read-outs). With diarization (default "speaker") the speaker labels are passed to the tagger, which enables speaker roles. | |
| Each output line is {"type": "update", "source": "interim"|"final"|"endpoint", ...summary} (see arctag.asr.summarize); | |
| the last line is {"type": "done", ...}. --result writes the full result (same schema as ArcTagger.tag()). | |
| """ | |
| import argparse, asyncio, json, os, sys | |
| HERE = os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0, HERE) | |
| from arctag import live # noqa: E402 | |
| from arctag.asr import SpeechmaticsAdapter, summarize # noqa: E402 | |
| URL = "wss://eu2.rt.speechmatics.com/v2" | |
| def start_msg(a, sr): | |
| tc = {"language": "en", "enable_partials": True, "max_delay": a.max_delay, "operating_point": a.operating_point, | |
| "conversation_config": {"end_of_utterance_silence_trigger": a.eou_silence}} | |
| if a.diarization != "none": | |
| tc["diarization"] = a.diarization | |
| return {"message": "StartRecognition", "audio_format": {"type": "raw", "encoding": "pcm_s16le", "sample_rate": sr}, | |
| "transcription_config": tc} | |
| async def connect(url, key): | |
| import websockets | |
| hdr = {"Authorization": "Bearer " + key} | |
| try: | |
| return await websockets.connect(url, additional_headers=hdr, max_size=None) | |
| except TypeError: # websockets < 14 | |
| return await websockets.connect(url, extra_headers=hdr, max_size=None) | |
| async def run(a): | |
| key = live.api_key("SPEECHMATICS_API_KEY") | |
| from arctag import ArcTagger | |
| tg = ArcTagger.from_pretrained(a.model_dir) | |
| st = tg.stream(domain=a.domain, tier=a.tier) | |
| ad = SpeechmaticsAdapter(st) | |
| sr, chunks = live.source(a) | |
| try: | |
| ws = await connect(a.url, key) | |
| except Exception as e: | |
| sys.exit("Speechmatics connect failed: " + live.scrub(e, key)) | |
| await ws.send(json.dumps(start_msg(a, sr))) | |
| started = asyncio.Event() | |
| async def send(): | |
| await started.wait() | |
| n = 0 | |
| async for b in chunks: | |
| await ws.send(b); n += 1 # binary frame = AddAudio | |
| await ws.send(json.dumps({"message": "EndOfStream", "last_seq_no": n})) | |
| async def recv(): | |
| async for raw in ws: | |
| if isinstance(raw, bytes): | |
| continue | |
| m = json.loads(raw); t = m.get("message") | |
| if t == "RecognitionStarted": | |
| started.set(); continue | |
| if t == "Error": | |
| live.emit({"type": "error", "message": live.scrub(m.get("reason") or m.get("type") or "", key)}) | |
| break | |
| if t == "EndOfTranscript": | |
| break | |
| src = {"AddPartialTranscript": "interim", "AddTranscript": "final", "EndOfUtterance": "endpoint"}.get(t) | |
| for up in ad(m): | |
| if a.no_interim and src == "interim": | |
| continue | |
| live.emit(dict(type="update", source="endpoint" if up.get("utterances") else src, **summarize(up, st))) | |
| tx = asyncio.create_task(send()) | |
| try: | |
| await recv() | |
| finally: | |
| tx.cancel() | |
| await ws.close() | |
| res = st.finalize() | |
| live.emit({"type": "done", "n_words": len(res["words"]), "redacted_text": res["redacted_text"], | |
| "latency_ms": st.s.stats()}) | |
| if a.result: | |
| json.dump(res, open(a.result, "w"), indent=1, default=str) | |
| def main(): | |
| ap = live.add_common_args(argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)) | |
| ap.add_argument("--url", default=URL, help="real-time endpoint for your region") | |
| ap.add_argument("--max-delay", type=float, default=1.0, help="seconds before a word is final (lower = faster finals)") | |
| ap.add_argument("--operating-point", default="enhanced", choices=["standard", "enhanced"]) | |
| ap.add_argument("--eou-silence", type=float, default=0.5, help="seconds of silence for EndOfUtterance") | |
| ap.add_argument("--diarization", default="speaker", choices=["speaker", "none"]) | |
| try: | |
| asyncio.run(run(ap.parse_args())) | |
| except KeyboardInterrupt: | |
| pass | |
| if __name__ == "__main__": | |
| main() | |