Download arctag/driver.py from WhissleAI/arc-tagger: direct link, hf CLI and curl.
- Browser
- Download file 10.1 kB
-
https://huggingface.co/WhissleAI/arc-tagger/resolve/main/arctag/driver.py
- Command line
-
hf download hf://WhissleAI/arc-tagger/arctag/driver.py
-
curl -L -o driver.py https://huggingface.co/WhissleAI/arc-tagger/resolve/main/arctag/driver.py
10.1 kB
| """Session driver: words in -> engine.ArcSession (arctag/_core/engine.py) -> structured JSON. | |
| This module has no package imports: it takes the engine module (`EN`) and a loaded model (`EN.Loaded`) as arguments. | |
| Message flow: | |
| words -> {"type": "words", "from": k, "words": [...]} (append, or revise words[k:] for interim ASR hypotheses) | |
| final -> {"type": "finalize", "upto": n} | |
| end of utterance -> {"type": "endpoint", "at": n} | |
| spans -> ArcSession.spans(tier) after every update; spans with end > a0 are replaced, older ones are kept | |
| fine domain (sports league / court type) from lexicon cues every 25 words (engine.fine_hint) | |
| """ | |
| import re | |
| UI_DOMAINS = ("auto", "talk", "meeting", "court", "assistant", "sports", "news") | |
| END_RE = re.compile(r"[.?!]+[\"')\]]*$") | |
| # redaction placeholders (public_contact is tag-only, so it is not masked) | |
| REDACT = { | |
| "safety.pii.phone_number": "PHONE", "safety.pii.email": "EMAIL", "safety.pii.street_address": "ADDRESS", | |
| "safety.pii.card_account_number": "CARD", "safety.pii.gov_id": "GOV_ID", "safety.pii.date_of_birth": "DOB", | |
| "safety.pii.private_name": "NAME", "safety.pii.url_handle": "HANDLE", | |
| "safety.profanity.mild": "PROFANITY", "safety.profanity.strong": "PROFANITY", | |
| "safety.toxicity.insult_harassment": "TOXIC", "safety.toxicity.hate_identity": "TOXIC", | |
| "safety.toxicity.threat_violence": "TOXIC", "safety.toxicity.sexual_explicit": "TOXIC", "safety.toxicity.self_harm": "TOXIC", | |
| } | |
| def thr_label(th): | |
| """which threshold tables are active: display / events tables, model defaults""" | |
| parts = [] | |
| if th.pref_step is not None: | |
| parts.append("display") | |
| if th.ev_step is not None: | |
| parts.append("events") | |
| if th.own: | |
| parts.append("default") | |
| return " + ".join(parts) or "default 0.5" | |
| def as_words(x, final=True): | |
| """str | [str] | [dict] -> word dicts {"w", "final", optional "t0", "t1", "conf", "spk"}""" | |
| if isinstance(x, str): | |
| x = x.split() | |
| out = [] | |
| for w in x: | |
| if isinstance(w, str): | |
| if w.strip(): | |
| out.append({"w": w.strip(), "final": final}) | |
| else: | |
| d = {k: w[k] for k in ("w", "t0", "t1", "conf", "spk", "final") if k in w and w[k] is not None} | |
| d.setdefault("final", final) | |
| if str(d.get("w", "")).strip(): | |
| d["w"] = str(d["w"]).strip() | |
| out.append(d) | |
| return out | |
| def split_utterances(words): | |
| """utterance boundaries after words ending in . ? ! (and at the end)""" | |
| utts, cur = [], [] | |
| for w in words: | |
| cur.append(w) | |
| if END_RE.search(w["w"]): | |
| utts.append(cur); cur = [] | |
| if cur: | |
| utts.append(cur) | |
| return utts | |
| class Stream: | |
| """one streaming session. push_words() / endpoint() return incremental updates; finalize() returns the full result.""" | |
| def __init__(self, EN, loaded, domain="auto", tier="T0", meta=None): | |
| if domain not in UI_DOMAINS: | |
| raise ValueError(f"domain must be one of {UI_DOMAINS}") | |
| if tier not in ("T0", "T1", "T2"): | |
| raise ValueError("tier must be T0, T1 or T2") | |
| self.EN = EN; self.tier = tier; self.meta = dict(meta or {}) | |
| self.s = EN.ArcSession(loaded, ui_domain=domain, asr="unknown") | |
| self._spans = {} # (tag, a, b) -> span (display tier) | |
| self._n_ev = 0; self._fine_n = -1 | |
| self.events = []; self.utterances = {} # w0 -> utterance dict (built at its endpoint) | |
| # ------------------------------------------------------------------ input | |
| def push_words(self, words, final=True, revise_from=None, endpoint=False): | |
| """append words (or, with revise_from=k, replace words[k:] by them: interim ASR revisions). Returns the update.""" | |
| ws = as_words(words, final=final) | |
| k = len(self.s.words) if revise_from is None else int(revise_from) | |
| evs = [{"type": "words", "from": k, "words": ws}] | |
| if final: | |
| evs.append({"type": "finalize", "upto": k + len(ws)}) | |
| if endpoint: | |
| evs.append({"type": "endpoint", "at": k + len(ws)}) | |
| return self._apply(evs) | |
| def endpoint(self): | |
| """end of the current utterance (ASR speech_final / end-of-turn / VAD): utterance-level read-outs are emitted here""" | |
| n = len(self.s.words) | |
| return self._apply([{"type": "finalize", "upto": n}, {"type": "endpoint", "at": n}]) | |
| def finalize(self): | |
| """close the open utterance (if any) and return the full structured result""" | |
| if self.s.e.n and (not self.s.utt_bounds or self.s.utt_bounds[-1] < self.s.e.n): | |
| self.endpoint() | |
| return self.result() | |
| # ------------------------------------------------------------------ engine | |
| def _apply(self, evs): | |
| s = self.s; EN = self.EN | |
| lo, utt_done = s.apply(evs) | |
| if EN.FINE_REDOMAIN and s.ui_domain in EN.FINE_IX and len(s.words) // 25 != self._fine_n: | |
| self._fine_n = len(s.words) // 25 | |
| fh = EN.fine_hint(s.ui_domain, s.words) | |
| if fh and fh != s.fine: | |
| s.set_domain(s.ui_domain, fine=fh) | |
| a0, sp = s.spans(self.tier) | |
| for key in [key for key, x in self._spans.items() if x["b"] > a0]: | |
| del self._spans[key] | |
| for x in sp: | |
| self._spans[(x["tag"], x["a"], x["b"])] = x | |
| ev_new = [self._event(e) for e in s.events[self._n_ev:]] | |
| self._n_ev = len(s.events) | |
| ev_new = [e for e in ev_new if e] | |
| self.events.extend(ev_new) | |
| utts = [self._utt(u) for u in utt_done] | |
| for u in utts: | |
| self.utterances[u["start"]] = u | |
| return {"n_words": len(s.words), "changed_from": lo, "spans": [self._span(x) for x in sp], "events": ev_new, | |
| "utterances": utts, "running": self._running()} | |
| def _event(self, e): | |
| th = self.s.L.thr | |
| if th.ev_hidden(e["tag"]) or e["tier"] != th.ev_tier(e["tag"]): | |
| return None | |
| return {"tag": e["tag"], "at": e["i"], "word": e["word"], "p": e["p"], "thr": e["thr"], "tier": e["tier"], "read": e["q"]} | |
| def _span(self, x): | |
| out = {"tag": x["tag"], "family": x["fam"], "start": x["a"], "end": x["b"], "text": x["text"], "p": x["p"], "thr": x["thr"]} | |
| for k in ("alt", "ver", "kb", "src"): | |
| if k in x: | |
| out[k] = x[k] | |
| return out | |
| def _on(rows): | |
| return [r["tag"] for r in rows if r["on"]] | |
| AFFECT_GROUPS = ("affect.emotion.", "affect.arousal.", "affect.valence.", "affect.intensity.") | |
| def _emotion(self, j): | |
| """affect.* utt read-outs (text-only, experimental): the top tag of each affect group in the ontology | |
| (emotion, arousal, valence, intensity)""" | |
| s = self.s | |
| if j is None or j not in s.e.pooled: | |
| return [] | |
| import torch | |
| with torch.inference_mode(): | |
| U = s.L.GI.probs("utt", s.e.pooled_logits(j)["utt"][None])[0].numpy() | |
| return [r for g in self.AFFECT_GROUPS for r in s._top("utt", U, g, 1)] | |
| def _utt(self, u): | |
| ro = u["readouts"] | |
| r = {"start": u["w0"], "end": u["w1"], "text": u["text"], | |
| "intent": self._on(ro.get("intent", [])), "act": self._on(ro.get("act", [])), "safety": self._on(ro.get("safety", [])), | |
| "role": self._on(ro.get("role", [])), "item": self._on(ro.get("item", [])), | |
| "state": {g: self._on(v) for g, v in (ro.get("state") or {}).items() if self._on(v)}, | |
| "emotion": self._emotion(ro.get("j")), | |
| "scores": {k: ro.get(k) for k in ("intent", "act", "safety", "role", "item", "state")}} | |
| if ro.get("role_note"): | |
| r["role_note"] = ro["role_note"] | |
| return r | |
| def _running(self): | |
| ro = self.s.readouts(tier=self.tier if self.tier != "T2" else "T1") | |
| if not ro: | |
| return {} | |
| return {"intent": self._on(ro.get("intent", [])), "act": self._on(ro.get("act", [])), "safety": self._on(ro.get("safety", [])), | |
| "state": {g: self._on(v) for g, v in (ro.get("state") or {}).items() if self._on(v)}} | |
| # ------------------------------------------------------------------ output | |
| def spans(self): | |
| return [self._span(x) for x in sorted(self._spans.values(), key=lambda x: (x["a"], -x["b"], x["tag"]))] | |
| def redacted_text(self, spans=None): | |
| ws = [w["w"] for w in self.s.words] | |
| lab = [None] * len(ws) | |
| for x in spans if spans is not None else self.spans(): | |
| L = REDACT.get(x["tag"]) | |
| if L: | |
| for i in range(x["start"], min(x["end"], len(ws))): | |
| lab[i] = lab[i] or (L, x["start"]) | |
| out = []; i = 0 | |
| while i < len(ws): | |
| if lab[i] is None: | |
| out.append(ws[i]); i += 1; continue | |
| j = i | |
| while j < len(ws) and lab[j] == lab[i]: | |
| j += 1 | |
| out.append(f"[{lab[i][0]}]"); i = j | |
| return " ".join(out) | |
| def result(self): | |
| sp = self.spans() | |
| utts = [self.utterances[k] for k in sorted(self.utterances)] | |
| return {"meta": dict(self.meta, domain=self.s.ui_domain, fine_domain=self.s.fine, tier=self.tier, | |
| thresholds=thr_label(self.s.L.thr)), | |
| "words": [w["w"] for w in self.s.words], | |
| "spans": sp, | |
| "entities": [x for x in sp if x["family"] in ("entity", "number")], | |
| "pii": [x for x in sp if x["family"] == "pii"], | |
| "profanity_toxicity": [x for x in sp if x["family"] == "profanity"], | |
| "redacted_text": self.redacted_text(sp), | |
| "utterances": utts, | |
| "events": list(self.events)} | |
| def tag(EN, loaded, x, domain="auto", tier="T0", meta=None): | |
| """offline tagging: text / words -> utterances (split after . ? !) -> one streaming pass -> result""" | |
| st = Stream(EN, loaded, domain=domain, tier=tier, meta=meta) | |
| for u in split_utterances(as_words(x)): | |
| st.push_words(u, final=True, endpoint=True) | |
| return st.finalize() | |