File size: 4,084 Bytes
83a951c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Deepgram live ASR -> Arc Tagger, printed as JSON lines.

    export DEEPGRAM_API_KEY=...            # read from the environment only
    pip install websockets                 # + sounddevice for --mic
    python stream_deepgram.py --wav call.wav --domain talk
    python stream_deepgram.py --mic --domain assistant --seconds 30

Interim results (is_final=false) are tagged immediately and revised when Deepgram revises them; is_final freezes the words;
speech_final / UtteranceEnd end the utterance (utterance-level intent, act, safety and role read-outs). With --diarize
(default on) Deepgram speaker ids 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, urllib.parse

HERE = os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0, HERE)
from arctag import live                                   # noqa: E402
from arctag.asr import DeepgramAdapter, summarize         # noqa: E402

URL = "wss://api.deepgram.com/v1/listen"


def dg_url(a, sr):
    q = dict(model=a.dg_model, language="en", encoding="linear16", sample_rate=sr, channels=1, interim_results="true",
             punctuate="true", smart_format="true", diarize="true" if a.diarize else "false", vad_events="true",
             utterance_end_ms=a.utterance_end_ms, endpointing=a.endpointing)
    return URL + "?" + urllib.parse.urlencode(q)


async def connect(url, key):
    import websockets
    hdr = {"Authorization": "Token " + 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("DEEPGRAM_API_KEY")
    from arctag import ArcTagger
    tg = ArcTagger.from_pretrained(a.model_dir)
    st = tg.stream(domain=a.domain, tier=a.tier)
    ad = DeepgramAdapter(st)
    sr, chunks = live.source(a)
    try:
        ws = await connect(dg_url(a, sr), key)
    except Exception as e:
        sys.exit("Deepgram connect failed: " + live.scrub(e, key))

    async def send():
        async for b in chunks:
            await ws.send(b)
        await ws.send(json.dumps({"type": "CloseStream"}))

    async def recv():
        async for raw in ws:
            if isinstance(raw, bytes):
                continue
            m = json.loads(raw)
            if m.get("type") == "Error":
                live.emit({"type": "error", "message": live.scrub(m.get("description") or m.get("message") or "", key)})
                continue
            src = ("endpoint" if m.get("type") == "UtteranceEnd" else "final" if m.get("is_final") else "interim")
            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()
    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("--dg-model", default="nova-3")
    ap.add_argument("--no-diarize", dest="diarize", action="store_false")
    ap.add_argument("--endpointing", type=int, default=300, help="ms of silence for speech_final")
    ap.add_argument("--utterance-end-ms", type=int, default=1000)
    try:
        asyncio.run(run(ap.parse_args()))
    except KeyboardInterrupt:
        pass


if __name__ == "__main__":
    main()