| |
| |
| """Write THIRD_PARTY_NOTICES.md and LICENSES/crates/: what this project contains or links that others wrote. |
| |
| source env/canonical.sh && python3 tools/third_party_notices.py |
| |
| The Rust crates are the ones `cargo metadata --locked` resolves for the two shipped binaries (the wheel's extension |
| `anuvani_diar._core`, from crates/diar-py, and the gateway, crates/diar-gateway), development-only dependencies left |
| out; each crate's own licence files (LICENSE*, COPYING*, NOTICE*, UNLICENSE*) are copied from its source in the |
| local cargo registry into LICENSES/crates/<name>-<version>/. The other sections are fixed text kept below; their |
| licence texts are in LICENSES/third_party/ (and, for the wheel's bundled libraries, in the wheel's |
| anuvani_diar/_libs/LICENSES/). Run it again after changing Cargo.lock. |
| """ |
| import json |
| import shutil |
| import subprocess |
| from pathlib import Path |
|
|
| PROJ = Path(__file__).resolve().parents[1] |
| FILES = ("LICENSE", "LICENCE", "COPYING", "NOTICE", "UNLICENSE", "COPYRIGHT") |
|
|
| HEAD = """# Third-party notices |
| |
| Anuvani-Diarization's code is licensed under MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`). It contains, ports |
| or links work by others, listed here with their licences. The model weights have their own licences, set by the |
| models they derive from (see the model card): the segmentation network is a fine-tuned derivative of |
| `BUT-FIT/diarizen-wavlm-large-s80-md-v2` and is CC BY-NC 4.0 (non-commercial); the PLDA model (BUT Speech@FIT) and |
| the speaker-embedding network (`pyannote/wespeaker-voxceleb-resnet34-LM`) are CC BY 4.0. |
| |
| ## Code copied or adapted into this project |
| |
| | Upstream | Licence | Where | Licence text | |
| |---|---|---|---| |
| | DiariZen (BUT Speech@FIT), commit 844f555 | MIT | the segmentation network's code, verbatim (`python/anuvani_diar/nn/seg/`; also the frozen release's `hf_port_poc/anuvani_diar_net/`); its VBx and clustering set-up, ported to Rust (`crates/diar-core`) | `LICENSES/third_party/DiariZen-MIT.txt` | |
| | torchaudio 2.1.1 (Facebook, Inc.) | BSD-2-Clause | `kaldi.py` (fbank) and `resample.py`, verbatim; the wav2vec2 building blocks inside DiariZen's code | `LICENSES/third_party/torchaudio-BSD-2-Clause.txt` | |
| | pyannote.audio 3.1.1, DiariZen's fork (CNRS) | MIT | the voiceprint network's fbank, forward and statistics pooling (`voiceprint.py`); window reconstruction and masks, ported to Rust | `LICENSES/third_party/pyannote-audio-MIT.txt` | |
| | WeSpeaker (Shuai Wang), via pyannote.audio | Apache-2.0 | the voiceprint network's ResNet34 (`voiceprint.py`) | `LICENSES/third_party/Apache-2.0.txt` | |
| | VBx (BUT Speech@FIT), via DiariZen's `diarizen/clustering/VBx.py` | Apache-2.0 | variational Bayes clustering, ported to Rust (`crates/diar-core/src/vbx.rs`) | `LICENSES/third_party/Apache-2.0.txt` | |
| | SciPy 1.15.3 (SciPy Developers) | BSD-3-Clause | centroid-linkage AHC and pairwise distances, reimplemented in Rust to give SciPy's exact results | `LICENSES/third_party/scipy-LICENSE.txt` | |
| | NumPy 1.26.4 (NumPy Developers) | BSD-3-Clause | numerical behaviour reproduced in Rust; its OpenBLAS build is bundled (below) | `LICENSES/third_party/numpy-LICENSE.txt` | |
| | python-soundfile 0.14.0 (Bastian Bechtold) | BSD-3-Clause | the sequence of libsndfile calls `sf.read` makes, reproduced in Rust (`crates/diar-audio`) | `LICENSES/third_party/soundfile-LICENSE.txt` | |
| |
| ## Native libraries bundled in the wheel |
| |
| Copied unchanged from the numpy 1.26.4 and soundfile 0.14.0 wheels, each checked by sha256 when it loads; their |
| licence texts are in the wheel (`anuvani_diar/_libs/LICENSES/`, index in its README.txt): |
| |
| | Library | Licence | |
| |---|---| |
| | OpenBLAS 0.3.23.dev (numpy 1.26.4's build) | BSD-3-Clause | |
| | libgfortran 5 | GPL-3.0 with the GCC Runtime Library Exception 3.1 | |
| | libquadmath 0 | LGPL-2.1-or-later | |
| | libsndfile 1.2.2, with FLAC 1.4.3, Ogg 1.3, Vorbis 1.3.7, Opus 1.4, mpg123 1.32.3, LAME 3.100 | LGPL-2.1-or-later (libsndfile, mpg123, LAME); BSD-3-Clause (FLAC, Ogg, Vorbis, Opus) | |
| |
| libsndfile is LGPL: `ANUVANI_DIAR_SNDFILE` (with `ANUVANI_DIAR_SNDFILE_UNCHECKED=1`) runs the engine with another |
| build of it (`docs/WHEEL.md`). The source of the LGPL libraries (libsndfile with its codecs and the script that built |
| it; libquadmath, as the GCC source package it was built from) is in the model repository's `third_party_sources/`, |
| whose README traces each binary to its source. |
| |
| ## Container images the serving kit builds |
| |
| `triton_inference/` builds two images on the user's machine; they are not distributed here. The Triton image starts |
| from `nvcr.io/nvidia/tritonserver:24.10-py3` (NVIDIA Deep Learning Container License) and installs PyTorch and |
| torchaudio 2.1.1 (BSD-3-Clause and BSD-2-Clause) and NVIDIA's cuBLAS and NVRTC wheels (NVIDIA proprietary licence); |
| the service image starts from `ubuntu:22.04` and installs FastAPI and Pydantic (MIT), Starlette and Uvicorn |
| (BSD-3-Clause) and python-multipart (Apache-2.0) (`triton_inference/service/requirements.txt`). |
| |
| ## Rust crates compiled into the wheel and the gateway |
| |
| """ |
|
|
|
|
| def crates(): |
| meta = json.loads(subprocess.run(["cargo", "metadata", "--format-version", "1", "--locked"], cwd=PROJ, |
| capture_output=True, text=True, check=True).stdout) |
| pk = {p["id"]: p for p in meta["packages"]} |
| ws = set(meta["workspace_members"]) |
| nodes = {n["id"]: n for n in meta["resolve"]["nodes"]} |
| stack = [i for i in ws if pk[i]["name"] in ("diar-py", "diar-gateway")] |
| seen = set() |
| while stack: |
| for d in nodes[stack.pop()]["deps"]: |
| if {k["kind"] for k in d["dep_kinds"]} - {"dev"} and d["pkg"] not in seen: |
| seen.add(d["pkg"]) |
| stack.append(d["pkg"]) |
| return sorted((pk[i] for i in seen if i not in ws), key=lambda p: (p["name"], p["version"])) |
|
|
|
|
| def main(): |
| out = PROJ / "LICENSES" / "crates" |
| if out.exists(): |
| shutil.rmtree(out) |
| rows = [] |
| for p in crates(): |
| src = Path(p["manifest_path"]).parent |
| dst = out / f"{p['name']}-{p['version']}" |
| texts = [] |
| for f in sorted(src.iterdir()): |
| if f.is_file() and f.name.upper().startswith(FILES): |
| dst.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(f, dst / f.name) |
| texts.append(f.name) |
| where = f"`LICENSES/crates/{dst.name}/` ({', '.join(texts)})" if texts else "no licence file in the crate's source" |
| rows.append(f"| {p['name']} | {p['version']} | {p['license'] or '(see crate)'} | {where} |") |
| body = (HEAD + f"{len(rows)} crates, resolved by `cargo metadata --locked` (`tools/third_party_notices.py`):\n\n" |
| "| Crate | Version | Licence | Licence files |\n|---|---|---|---|\n" + "\n".join(rows) + "\n") |
| (PROJ / "THIRD_PARTY_NOTICES.md").write_text(body) |
| print(f"THIRD_PARTY_NOTICES.md: {len(rows)} crates; {sum(1 for r in rows if 'no licence file' in r)} without a licence file") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
