safetensors checkpoint; inference code only

README.md

@@ -41,7 +41,7 @@ It was built to evaluate text-to-speech systems: comparing different renditions
 ## Usage
 
 ```python
-# pip install -r requirements.txt   (torch, torchaudio, librosa, soundfile, numpy, pypinyin, jieba, opencc)
+# pip install -r requirements.txt   (torch, torchaudio, librosa, soundfile, numpy, pypinyin, jieba, opencc, safetensors)
 from huggingface_hub import snapshot_download
 import sys
 path = snapshot_download("JacobLinCool/accent-detective")
@@ -58,7 +58,7 @@ det.score_recording("talk.wav", "第一句話。第二句話。")         # sent
 
 ## Model
 
-Everything is one checkpoint, `model.pt`, of 18.6 M parameters:
+Everything is one checkpoint, `model.safetensors`, of 18.6 M parameters:
 
 - **Encoder:** a Conformer student encoder (4 layers, width 384, log-mel input). It is distilled to predict seven hidden layers of TencentGameMate/chinese-wav2vec2-base. The judges read the predicted layers 4 and 8, with each utterance's mean removed.
 - **Alignment head:** a convolutional CTC head over toneless pinyin letters, trained with a frame-level KL to the MMS forced-alignment model. It replaces a separate 315 M-parameter aligner.

detective.py

@@ -14,5 +14,5 @@ from twjudge.detective import Detective, index, sentence_ids  # noqa: E402,F401
 
 
 def load(device=None, cuda_graphs=True) -> Detective:
-    return Detective(HERE / "model.pt", lexicon=HERE / "lexicon/concised.json.xz",
+    return Detective(HERE / "model.safetensors", lexicon=HERE / "lexicon/concised.json.xz",
                      cedict=HERE / "lexicon/cedict.txt.gz", device=device, cuda_graphs=cuda_graphs)

model.pt → model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:33c2eef92b752fe0886ebbfd8e55ab048dc8f8d9e5ea23be434105afce2d23dd
-size 74379026
+oid sha256:ab6d6189ac1053154f05fd9ea373f323a5f5da1f0e7ed06d90e98efaa9018408
+size 74303292

requirements.txt

@@ -6,3 +6,4 @@ numpy
 pypinyin
 jieba
 opencc
+safetensors

twjudge/accent/compact.py

@@ -119,6 +119,52 @@ def context(chars):
             for k, (t, s, c, f) in enumerate(zip(tones, sandhi_tones(tones), chars, fin))]
 
 
+META_KEYS = ("ssl", "student_config", "n_layers", "ctc_layer", "ctc_arch", "judge_layers", "d_in", "teacher")
+
+
+def save_checkpoint(ck: dict, path) -> None:
+    """A self-contained compact checkpoint (compact_export.py) as safetensors: tensors under the prefixes
+    student. / ctc. / judge.<k>., everything else as JSON in the metadata."""
+    import json
+
+    from safetensors.torch import save_file
+
+    states = ck.get("judge_states") or [ck["judge_state"]]
+    tensors = {f"student.{k}": v for k, v in ck["student_state"].items()}
+    tensors.update({f"ctc.{k}": v for k, v in ck["ctc_state"].items()})
+    for i, st in enumerate(states):
+        tensors.update({f"judge.{i}.{k}": v for k, v in st.items()})
+    meta = {k: ck[k] for k in META_KEYS if k in ck}
+    meta["n_judges"] = len(states)
+    save_file({k: v.contiguous() for k, v in tensors.items()}, str(path),
+              metadata={"accent_detective": json.dumps(meta), "reports": json.dumps(ck.get("reports", {}), default=str)})
+
+
+def load_checkpoint(path) -> dict:
+    """The checkpoint dict of a .pt file, or rebuilt from a .safetensors file written by save_checkpoint."""
+    import torch
+
+    if not str(path).endswith(".safetensors"):
+        return torch.load(path, map_location="cpu")
+    import json
+
+    from safetensors import safe_open
+
+    with safe_open(str(path), framework="pt") as f:
+        meta = json.loads(f.metadata()["accent_detective"])
+        tensors = {k: f.get_tensor(k) for k in f.keys()}
+    ck = dict(meta)
+
+    def part(prefix):
+        return {k[len(prefix):]: v for k, v in tensors.items() if k.startswith(prefix)}
+
+    ck["student_state"] = part("student.")
+    ck["ctc_state"] = part("ctc.")
+    ck["judge_states"] = [part(f"judge.{i}.") for i in range(meta["n_judges"])]
+    ck["judge_state"] = ck["judge_states"][0]
+    return ck
+
+
 class CompactJudge:
     def __init__(self, path: str | Path, readings=None, device: str | None = None):
         import torch
@@ -126,7 +172,7 @@ class CompactJudge:
         from twjudge.accent.neural import SyllableNet
         from twjudge.align.ctc import CTCAligner
 
-        ck = torch.load(path, map_location="cpu")
+        ck = load_checkpoint(path)
         self.ck = ck
         if ck["ssl"] == "student":                    # self-contained checkpoint (compact_export.py)
             from twjudge.accent.ssl_features import device as default_device

twjudge/data/build_corpus.py

@@ -1,142 +0,0 @@
-"""Speaker-disjoint Taiwan / Mainland corpus for the Taiwan-accent judge.
-
-Both sides come from Common Voice, recorded by volunteers on their own devices through the same
-web client, so the recording channel is similar and a classifier cannot win on channel alone.
-
-  Taiwan:   Common Voice 25 zh-TW, self-reported birthplace,
-            when given, in Taiwan.
-  Mainland: Common Voice 21 zh-CN (keeve101/common-voice-21.0-2025-03-14-zh-CN-split), birthplace,
-            when given, in a Mainland province (Taiwan, Hong Kong, Macau and overseas excluded).
-
-Splits are by speaker. The Taiwan speakers of the project's TTS evaluation splits (dev, test, qc)
-all go to the judge's test split so the judge never trains on them; Mainland speakers follow the
-CV split they come from. Each speaker contributes at most PER_SPEAKER clips.
-
-    python -m twjudge.data.build_corpus --out data/judge_corpus
-"""
-
-from __future__ import annotations
-
-import argparse
-import collections
-import csv
-import hashlib
-import json
-import re
-import unicodedata
-from pathlib import Path
-
-import pyarrow.parquet as pq
-
-from twjudge.data.build_manifest import ALLOWED, h, norm_text
-
-PER_SPEAKER = 25
-MIN_CHARS, MAX_CHARS = 6, 40
-TW_TARGET = {"train": 9000, "dev": 900}
-TW_FOREIGN = re.compile(r"中國|中国|香港|澳門|澳门|馬來西亞|马来西亚|新加坡|美國|美国|日本|大陸|大陆")
-CN_EXCLUDE = re.compile(r"台湾|臺灣|台灣|香港|澳门|澳門|马来西亚|馬來西亞|新加坡|海外")
-
-
-def _rank(key: str) -> str:
-    return hashlib.sha256(f"judge-v1|{key}".encode()).hexdigest()
-
-
-def _ok_text(text: str) -> bool:
-    n = len(norm_text(text))
-    return bool(ALLOWED.match(text)) and MIN_CHARS <= n <= MAX_CHARS
-
-
-def taiwan(cv_dir: Path, project_manifests: Path) -> dict[str, list[dict]]:
-    held = set()
-    for s in ("dev", "test", "qc"):
-        held |= {json.loads(l)["speaker"] for l in (project_manifests / f"{s}.jsonl").open()}
-    by_spk = collections.defaultdict(list)
-    for r in csv.DictReader((cv_dir / "validated.tsv").open(), delimiter="\t", quoting=csv.QUOTE_NONE):
-        if int(r["up_votes"]) < 2 or int(r["down_votes"]) > 0 or TW_FOREIGN.search(r["accents"]):
-            continue
-        if not _ok_text(r["sentence"].strip()):
-            continue
-        by_spk[h(r["client_id"])[:16]].append({"path": r["path"], "text": r["sentence"].strip()})
-    splits = {"train": [], "dev": [], "test": []}
-    order = sorted(set(by_spk) - held, key=_rank)
-    for spk in sorted(held & set(by_spk), key=_rank):
-        splits["test"] += _take(by_spk[spk], spk)
-    for spk in order:
-        name = "dev" if len(splits["dev"]) < TW_TARGET["dev"] else "train"
-        if name == "train" and len(splits["train"]) >= TW_TARGET["train"]:
-            break
-        splits[name] += _take(by_spk[spk], spk)
-    return splits
-
-
-def mainland(cn_dir: Path) -> dict[str, list[dict]]:
-    splits = {}
-    for name in ("train", "dev", "test"):
-        by_spk = collections.defaultdict(list)
-        for f in sorted((cn_dir / "data").glob(f"{name}-*.parquet")):
-            t = pq.read_table(f, columns=["client_id", "path", "sentence", "accents", "up_votes", "down_votes"])
-            for r in t.to_pylist():
-                acc = r["accents"] or ""
-                if r["down_votes"] > 0 or CN_EXCLUDE.search(acc) or (acc and "出生地" not in acc):
-                    continue
-                text = unicodedata.normalize("NFKC", r["sentence"]).strip()
-                if not _ok_text(text):
-                    continue
-                by_spk[hashlib.sha256(r["client_id"].encode()).hexdigest()[:16]].append(
-                    {"path": r["path"], "text": text})
-        splits[name] = [c for spk in sorted(by_spk, key=_rank) for c in _take(by_spk[spk], spk)]
-    return splits
-
-
-def _take(clips: list[dict], spk: str) -> list[dict]:
-    return [{**c, "speaker": spk} for c in sorted(clips, key=lambda c: _rank(c["path"]))[:PER_SPEAKER]]
-
-
-def extract(parquets: list[Path], wanted: set[str], dest: Path) -> set[str]:
-    dest.mkdir(parents=True, exist_ok=True)
-    found = set()
-    for f in parquets:
-        for batch in pq.ParquetFile(f).iter_batches(columns=["path", "audio"], batch_size=256):
-            for path, audio in zip(batch.column("path").to_pylist(), batch.column("audio").to_pylist()):
-                name = Path(path).name
-                if name in wanted and name not in found:
-                    (dest / name).write_bytes(audio["bytes"])
-                    found.add(name)
-    return found
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--tw-dir", default="data/cv25")
-    ap.add_argument("--cn-dir", default="data/cv21cn")
-    ap.add_argument("--project-manifests", default="data/manifests_local/cv25")
-    ap.add_argument("--out", default="data/judge_corpus")
-    a = ap.parse_args()
-    out = Path(a.out)
-    sets = {"tw": taiwan(Path(a.tw_dir), Path(a.project_manifests)), "cn": mainland(Path(a.cn_dir))}
-    # the Mainland test split is far larger than needed; keep it about the size of the Taiwan one
-    sets["cn"]["test"] = sets["cn"]["test"][:len(sets["tw"]["test"]) * 2]
-    sets["cn"]["dev"] = sets["cn"]["dev"][:TW_TARGET["dev"]]
-    sets["cn"]["train"] = sets["cn"]["train"][:TW_TARGET["train"]]
-    found = {"tw": extract(sorted(Path(a.tw_dir, "parquet").glob("validated-*.parquet")),
-                           {Path(c["path"]).name for s in sets["tw"].values() for c in s}, out / "clips/tw"),
-             "cn": extract(sorted(Path(a.cn_dir, "data").glob("*.parquet")),
-                           {Path(c["path"]).name for s in sets["cn"].values() for c in s}, out / "clips/cn")}
-    report = {}
-    for split in ("train", "dev", "test"):
-        with (out / f"{split}.jsonl").open("w") as f:
-            for lab in ("tw", "cn"):
-                rows = [c for c in sets[lab][split] if Path(c["path"]).name in found[lab]]
-                for c in rows:
-                    name = Path(c["path"]).name
-                    f.write(json.dumps({"item_id": f"{lab}_{Path(name).stem}", "label": lab, "split": split,
-                                        "speaker": f"{lab}{c['speaker']}", "text": c["text"],
-                                        "wav": str((out / "clips" / lab / name).resolve())},
-                                       ensure_ascii=False) + "\n")
-                report[f"{split}/{lab}"] = {"clips": len(rows), "speakers": len({c["speaker"] for c in rows})}
-    (out / "report.json").write_text(json.dumps(report, indent=1))
-    print(json.dumps(report))
-
-
-if __name__ == "__main__":
-    main()

twjudge/data/build_manifest.py

@@ -1,185 +0,0 @@
-"""Leak-free target splits from Common Voice 25 zh-TW ``validated`` (PLAN §4).
-
-Speaker-disjoint, normalized-text-disjoint splits filled in a fixed order:
-test → dev → qc → train. A speaker belongs to exactly one split and a
-normalized sentence to at most one split, so an earlier split can never leak
-into a later one. Train clips are ordered round-robin over speakers, so every
-prefix is speaker-balanced and the nested subsets 10 ⊂ 60 ⊂ 180 minutes are
-prefixes of one list.
-
-Selection uses only metadata. Waveform-hash de-duplication runs after the
-audio is fetched (``fetch_audio``).
-
-    python -m twjudge.data.build_manifest --cv-dir data/cv25 --out judge/manifests/cv25
-"""
-
-from __future__ import annotations
-
-import argparse
-import csv
-import hashlib
-import json
-import re
-import unicodedata
-from collections import defaultdict
-from pathlib import Path
-
-SOURCE_REPO = "OpenFormosa/common_voice_25_zh-TW"
-SOURCE_REVISION = "9e969df60ad63f812b68a755581c961bc967673d"
-SALT = "accentbridge-cv25-v1"
-
-# (split, target minutes, per-speaker cap minutes; further capped at 10% of the split)
-PLAN = [("test", 30.0, 2.5), ("dev", 20.0, 2.5), ("qc", 10.0, 2.5), ("train", 180.0, 3.0)]
-TRAIN_SUBSETS = (10.0, 60.0, 180.0)
-
-MIN_S, MAX_S = 2.0, 10.0
-MIN_CHARS = 6
-EXCLUDED_ACCENTS = {"香港"}
-ALLOWED = re.compile(r"^[㐀-鿿豈-﫿，。、！？；：「」『』（）—…·．,.!?;:\s]+$")
-STRIP = re.compile(r"[^㐀-鿿豈-﫿]")
-
-
-def h(text: str) -> str:
-    return hashlib.sha256(f"{SALT}|{text}".encode()).hexdigest()
-
-
-def norm_text(s: str) -> str:
-    return STRIP.sub("", unicodedata.normalize("NFKC", s))
-
-
-def load(cv_dir: Path) -> list[dict]:
-    dur = {r["clip"]: int(r["duration[ms]"]) for r in
-           csv.DictReader((cv_dir / "clip_durations.tsv").open(), delimiter="\t")}
-    rows, reasons = [], defaultdict(int)
-    for r in csv.DictReader((cv_dir / "validated.tsv").open(), delimiter="\t", quoting=csv.QUOTE_NONE):
-        d = dur.get(r["path"], 0) / 1000
-        text = r["sentence"].strip()
-        accents = set(r["accents"].split("|")) - {""}
-        if not MIN_S <= d <= MAX_S:
-            reasons["duration"] += 1
-        elif int(r["up_votes"]) < 2 or int(r["down_votes"]) > 0:
-            reasons["votes"] += 1
-        elif accents & EXCLUDED_ACCENTS:
-            reasons["accent_label"] += 1
-        elif not ALLOWED.match(text):
-            reasons["non_cjk_text"] += 1      # digits/latin would go through text normalization
-        elif len(norm_text(text)) < MIN_CHARS:
-            reasons["too_few_chars"] += 1
-        else:
-            rows.append({"clip_id": r["path"], "speaker": h(r["client_id"])[:16],
-                         "sentence_id": r["sentence_id"], "text": text,
-                         "text_key": norm_text(text), "duration_s": d})
-    return rows, dict(reasons)
-
-
-def build(rows: list[dict]) -> dict[str, list[dict]]:
-    by_speaker: dict[str, list[dict]] = defaultdict(list)
-    for r in rows:
-        by_speaker[r["speaker"]].append(r)
-    for clips in by_speaker.values():
-        clips.sort(key=lambda r: h(r["clip_id"]))
-    speakers = sorted(by_speaker, key=h)
-
-    used_text: set[str] = set()
-    taken: set[str] = set()
-    splits: dict[str, list[dict]] = {}
-    cursor = 0
-    for split, target_min, cap_min in PLAN:
-        cap_min = min(cap_min, 0.1 * target_min)   # no speaker above 10% of a split
-        per_speaker: list[list[dict]] = []
-        total = 0.0
-        while total < target_min * 60 and cursor < len(speakers):
-            spk = speakers[cursor]
-            cursor += 1
-            mine, secs, seen = [], 0.0, set()
-            for r in by_speaker[spk]:
-                if r["text_key"] in used_text or r["text_key"] in seen:
-                    continue
-                if secs + r["duration_s"] > cap_min * 60:
-                    break
-                mine.append(r)
-                seen.add(r["text_key"])
-                secs += r["duration_s"]
-            if mine:
-                per_speaker.append(mine)
-                used_text |= seen
-                taken.add(spk)
-                total += secs
-        # round-robin interleave so every prefix is speaker-balanced
-        ordered, k = [], 0
-        while any(k < len(c) for c in per_speaker):
-            ordered += [c[k] for c in per_speaker if k < len(c)]
-            k += 1
-        # trim to the target duration, never exceeding it
-        out, secs = [], 0.0
-        for r in ordered:
-            if secs + r["duration_s"] > target_min * 60:
-                break
-            out.append({**r, "split": split})
-            secs += r["duration_s"]
-        splits[split] = out
-    return splits
-
-
-def summarize(clips: list[dict]) -> dict:
-    spk = defaultdict(float)
-    for r in clips:
-        spk[r["speaker"]] += r["duration_s"]
-    total = sum(spk.values())
-    return {"clips": len(clips), "minutes": round(total / 60, 2), "speakers": len(spk),
-            "max_speaker_share": round(max(spk.values()) / total, 3) if total else None}
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--cv-dir", required=True)
-    ap.add_argument("--out", required=True)
-    args = ap.parse_args()
-    out = Path(args.out)
-    out.mkdir(parents=True, exist_ok=True)
-
-    rows, reasons = load(Path(args.cv_dir))
-    splits = build(rows)
-    train = splits.pop("train")
-    report = {"source_repo": SOURCE_REPO, "source_revision": SOURCE_REVISION, "salt": SALT,
-              "eligible_clips": len(rows), "filtered_out": reasons, "splits": {}}
-    for name, clips in splits.items():
-        report["splits"][name] = summarize(clips)
-        _write(out / f"{name}.jsonl", clips)
-    prev = 0
-    for minutes in TRAIN_SUBSETS:
-        prefix, secs = [], 0.0
-        for r in train:
-            if secs + r["duration_s"] > minutes * 60:
-                break
-            prefix.append(r)
-            secs += r["duration_s"]
-        assert len(prefix) >= prev
-        prev = len(prefix)
-        name = f"train_{int(minutes)}m"
-        report["splits"][name] = summarize(prefix)
-        _write(out / f"{name}.jsonl", [{**r, "split": name} for r in prefix])
-
-    # leak checks across the disjoint splits (train_180m contains the smaller train subsets)
-    names = ["test", "dev", "qc", "train_180m"]
-    sets = {n: [json.loads(l) for l in (out / f"{n}.jsonl").open()] for n in names}
-    for i, a in enumerate(names):
-        for b in names[i + 1:]:
-            for key in ("speaker", "text_key", "clip_id"):
-                overlap = {r[key] for r in sets[a]} & {r[key] for r in sets[b]}
-                assert not overlap, f"{key} overlap between {a} and {b}"
-    report["leak_checks"] = "passed: speaker, normalized text and clip disjoint across test/dev/qc/train"
-    report["target_audio_core_minutes"] = round(sum(
-        report["splits"][n]["minutes"] for n in ("test", "dev", "qc", "train_60m")), 2)
-    (out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
-    print(json.dumps(report, ensure_ascii=False, indent=2))
-
-
-def _write(path: Path, rows: list[dict]) -> None:
-    with path.open("w") as f:
-        for r in rows:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-
-
-if __name__ == "__main__":
-    main()

twjudge/data/fetch_audio.py

@@ -1,98 +0,0 @@
-"""Extract the selected clips from the Common Voice parquet shards and finish the manifests.
-
-Writes each selected clip's original MP3 bytes to ``<clips>/<clip_id>``, adds
-its SHA-256, drops clips whose waveform hash duplicates a clip in an earlier
-split (PLAN §4.3), and writes two manifest sets:
-
-  local/      full rows including transcripts (git-ignored, under data/)
-  published/  shareable rows: IDs, hashes, durations and split only, no audio
-              and no transcript text (PLAN §11)
-
-    python -m twjudge.data.fetch_audio --parquet data/cv25/parquet \
-        --manifests data/manifests_local/cv25 --clips data/cv25/clips --published judge/manifests/cv25
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-
-import pyarrow.parquet as pq
-
-ORDER = ["test", "dev", "qc", "train_180m"]       # earlier split wins a duplicate
-SUBSETS = ["train_10m", "train_60m"]
-PUBLIC_KEYS = ["clip_id", "speaker", "sentence_id", "sentence_hash", "duration_s", "split",
-               "audio_sha256", "license_review_status"]
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--parquet", required=True)
-    ap.add_argument("--manifests", required=True)
-    ap.add_argument("--clips", required=True)
-    ap.add_argument("--published", required=True)
-    args = ap.parse_args()
-    man, clips, pub = Path(args.manifests), Path(args.clips), Path(args.published)
-    clips.mkdir(parents=True, exist_ok=True)
-    pub.mkdir(parents=True, exist_ok=True)
-
-    splits = {n: [json.loads(l) for l in (man / f"{n}.jsonl").open()] for n in ORDER + SUBSETS}
-    wanted = {r["clip_id"] for n in ORDER for r in splits[n]}
-    found: dict[str, str] = {}
-    for shard in sorted(Path(args.parquet).glob("validated-*.parquet")):
-        pf = pq.ParquetFile(shard)
-        for batch in pf.iter_batches(columns=["path", "audio"], batch_size=512):
-            for path, audio in zip(batch.column("path").to_pylist(), batch.column("audio").to_pylist()):
-                if path in wanted and path not in found:
-                    data = audio["bytes"]
-                    (clips / path).write_bytes(data)
-                    found[path] = hashlib.sha256(data).hexdigest()
-    missing = wanted - set(found)
-
-    seen_hash: dict[str, str] = {}
-    dropped = []
-    keep: dict[str, set[str]] = {}
-    for n in ORDER:
-        keep[n] = set()
-        for r in splits[n]:
-            hsh = found.get(r["clip_id"])
-            if hsh is None:
-                dropped.append({"clip_id": r["clip_id"], "split": n, "reason": "missing_audio"})
-            elif hsh in seen_hash:
-                dropped.append({"clip_id": r["clip_id"], "split": n, "reason": f"duplicate_of_{seen_hash[hsh]}"})
-            else:
-                seen_hash[hsh] = n
-                keep[n].add(r["clip_id"])
-    keep_train = keep["train_180m"]
-    report = {"wanted": len(wanted), "extracted": len(found), "missing": len(missing),
-              "dropped": dropped, "splits": {}}
-    for n in ORDER + SUBSETS:
-        allowed = keep_train if n.startswith("train") else keep[n]
-        rows = []
-        for r in splits[n]:
-            if r["clip_id"] not in allowed:
-                continue
-            rows.append({**r, "audio_sha256": found[r["clip_id"]],
-                         "sentence_hash": hashlib.sha256(r["text_key"].encode()).hexdigest()[:16],
-                         "license_review_status": "approved_2026-10-24"})
-        with (man / f"{n}.jsonl").open("w") as f:
-            for r in rows:
-                f.write(json.dumps(r, ensure_ascii=False) + "\n")
-        with (pub / f"{n}.jsonl").open("w") as f:
-            for r in rows:
-                f.write(json.dumps({k: r[k] for k in PUBLIC_KEYS}) + "\n")
-        report["splits"][n] = {"clips": len(rows), "minutes": round(sum(r["duration_s"] for r in rows) / 60, 2)}
-    build_report = json.loads((man / "report.json").read_text())
-    build_report["audio"] = report
-    (man / "report.json").write_text(json.dumps(build_report, ensure_ascii=False, indent=2))
-    public_report = {k: v for k, v in build_report.items() if k != "audio"} | {"audio": {
-        k: v for k, v in report.items() if k != "dropped"} | {"dropped_count": len(dropped)}}
-    (pub / "report.json").write_text(json.dumps(public_report, ensure_ascii=False, indent=2))
-    print(json.dumps({k: v for k, v in report.items() if k != "dropped"} | {"dropped": len(dropped)},
-                     ensure_ascii=False, indent=2))
-
-
-if __name__ == "__main__":
-    main()