vadonnx 0.1.0__tar.gz

vadonnx-0.1.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [0.1.0a2](https://github.com/TigreGotico/vadonnx/tree/0.1.0a2) (2026-06-16)
+
+[Full Changelog](https://github.com/TigreGotico/vadonnx/compare/21ac17d741759b1c8262065ba896e78b3740809f...0.1.0a2)
+
+**Merged pull requests:**
+
+- ci: modernize release workflows for PyPI release [\#4](https://github.com/TigreGotico/vadonnx/pull/4) ([JarbasAl](https://github.com/JarbasAl))
+- Configure Renovate [\#1](https://github.com/TigreGotico/vadonnx/pull/1) ([renovate[bot]](https://github.com/apps/renovate))
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

vadonnx-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 TigreGóticoLda
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vadonnx-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+recursive-include vadonnx/data *.onnx *.json *.npz *.npy
+recursive-include test/resources *

vadonnx-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: vadonnx
+Version: 0.1.0
+Summary: Load arbitrary Voice Activity Detection (VAD) models behind a unified ONNX API
+Author-email: JarbasAi <jarbasai@mailfence.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/TigreGotico/vadonnx
+Project-URL: Repository, https://github.com/TigreGotico/vadonnx
+Keywords: vad,voice activity detection,onnx,speech,silero,audio
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: huggingface_hub
+Provides-Extra: fsmn
+Requires-Dist: kaldi-native-fbank; extra == "fsmn"
+Provides-Extra: mic
+Requires-Dist: sounddevice; extra == "mic"
+Provides-Extra: resample
+Requires-Dist: scipy; extra == "resample"
+Provides-Extra: all
+Requires-Dist: kaldi-native-fbank; extra == "all"
+Requires-Dist: sounddevice; extra == "all"
+Requires-Dist: scipy; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: convert
+Requires-Dist: onnx; extra == "convert"
+Requires-Dist: huggingface_hub; extra == "convert"
+Requires-Dist: requests; extra == "convert"
+Provides-Extra: convert-marblenet
+Requires-Dist: vadonnx[convert]; extra == "convert-marblenet"
+Requires-Dist: nemo_toolkit[asr]; extra == "convert-marblenet"
+Requires-Dist: torch; extra == "convert-marblenet"
+Provides-Extra: convert-speechbrain
+Requires-Dist: vadonnx[convert]; extra == "convert-speechbrain"
+Requires-Dist: speechbrain; extra == "convert-speechbrain"
+Requires-Dist: torch; extra == "convert-speechbrain"
+Dynamic: license-file
+
+# vadonnx
+
+Load arbitrary **Voice Activity Detection** models behind a single, unified API — every
+model runs through [ONNX Runtime](https://onnxruntime.ai/). One streaming/​batch
+interface, one audio-format story, pluggable models.
+
+```python
+from vadonnx import load_vad
+
+vad = load_vad("silero")                              # bundled, works fully offline
+prob = vad.process_chunk(pcm_bytes)                   # streaming → float in [0, 1]
+segments = vad.get_speech_segments(audio, sample_rate=16000)
+# -> [SpeechSegment(start=0.32, end=2.27), SpeechSegment(start=3.27, end=4.45), ...]
+```
+
+## Why
+
+Every VAD ships its own loader, audio format, feature pipeline and state handling.
+`vadonnx` hides that behind one `VADModel` interface: feed it audio (raw `int16`
+bytes, numpy arrays, any sample rate) and get back per-frame speech probabilities or
+ready-made speech segments. Models are described *declaratively* by an
+[`IOSignature`](docs/custom_models.md), so a single generic engine drives most of them
+and you can point the same API at any custom `.onnx` file.
+
+- **Lightweight runtime** — only `numpy`, `onnxruntime`, `huggingface_hub`.
+- **Offline by default** — a small Silero model is bundled in the wheel.
+- **Streaming and batch** — `process_chunk()` for live audio, `get_speech_segments()` /
+  `probabilities()` for whole buffers.
+- **Bring your own model** — load any ONNX VAD by path/URL with a signature.
+- **Extensible** — third parties register backends/models via entry points.
+
+## Install
+
+```bash
+uv pip install vadonnx          # runtime (numpy + onnxruntime + huggingface_hub)
+uv pip install "vadonnx[mic]"   # + microphone examples
+```
+
+## Models
+
+| name | rate | parity vs upstream | notes |
+|------|------|--------------------|-------|
+| `silero` / `silero-8k` / `silero-op15` | 16k / 8k / 16k | MAE 0 | bundled default, raw PCM |
+| `marblenet` / `marblenet-int8` | 16k | MAE 4e-4 | NVIDIA NeMo Frame-VAD, multilingual ([license](docs/licensing.md)) |
+| `pyannote` / `pyannote-int8` | 16k | MAE 0 | pyannote segmentation-3.0, windowed |
+| `fsmn` / `fsmn-quant` | 16k | tracks upstream | FunASR FSMN-VAD; needs `vadonnx[fsmn]` |
+| `speechbrain` | 16k | MAE 0 | SpeechBrain CRDNN, LibriParty-trained |
+| `ten` | 16k | — | feature extractor provided by TEN's native library |
+
+See [docs/backends.md](docs/backends.md) for per-model detail and the
+[benchmark](benchmark/results/REPORT.md) for measured comparisons across datasets,
+including WebRTC and energy baselines.
+
+Models other than the bundled Silero are downloaded on first use from the
+[`TigreGotico`](https://huggingface.co/TigreGotico) HuggingFace org and cached under
+`$XDG_DATA_HOME/vadonnx`. See [docs/backends.md](docs/backends.md) for per-model detail
+and parity notes.
+
+## CLI
+
+```bash
+vadonnx list                       # list available models
+vadonnx probe silero               # print a model's ONNX input/output signature
+vadonnx segment speech.wav         # print detected speech segments of a WAV
+```
+
+## Documentation
+
+- [Quickstart](docs/quickstart.md)
+- [Streaming](docs/streaming.md)
+- [Custom models & `IOSignature`](docs/custom_models.md)
+- [Backends & parity notes](docs/backends.md)
+- [Plugins](docs/plugins.md)
+- [Model conversion](docs/conversion.md)
+- [Licensing](docs/licensing.md)
+- [API reference](docs/api.md)
+
+## License
+
+Apache-2.0. Bundled/downloaded model weights retain their upstream licenses — see
+[docs/licensing.md](docs/licensing.md).

vadonnx-0.1.0/README.md

@@ -0,0 +1,81 @@
+# vadonnx
+
+Load arbitrary **Voice Activity Detection** models behind a single, unified API — every
+model runs through [ONNX Runtime](https://onnxruntime.ai/). One streaming/​batch
+interface, one audio-format story, pluggable models.
+
+```python
+from vadonnx import load_vad
+
+vad = load_vad("silero")                              # bundled, works fully offline
+prob = vad.process_chunk(pcm_bytes)                   # streaming → float in [0, 1]
+segments = vad.get_speech_segments(audio, sample_rate=16000)
+# -> [SpeechSegment(start=0.32, end=2.27), SpeechSegment(start=3.27, end=4.45), ...]
+```
+
+## Why
+
+Every VAD ships its own loader, audio format, feature pipeline and state handling.
+`vadonnx` hides that behind one `VADModel` interface: feed it audio (raw `int16`
+bytes, numpy arrays, any sample rate) and get back per-frame speech probabilities or
+ready-made speech segments. Models are described *declaratively* by an
+[`IOSignature`](docs/custom_models.md), so a single generic engine drives most of them
+and you can point the same API at any custom `.onnx` file.
+
+- **Lightweight runtime** — only `numpy`, `onnxruntime`, `huggingface_hub`.
+- **Offline by default** — a small Silero model is bundled in the wheel.
+- **Streaming and batch** — `process_chunk()` for live audio, `get_speech_segments()` /
+  `probabilities()` for whole buffers.
+- **Bring your own model** — load any ONNX VAD by path/URL with a signature.
+- **Extensible** — third parties register backends/models via entry points.
+
+## Install
+
+```bash
+uv pip install vadonnx          # runtime (numpy + onnxruntime + huggingface_hub)
+uv pip install "vadonnx[mic]"   # + microphone examples
+```
+
+## Models
+
+| name | rate | parity vs upstream | notes |
+|------|------|--------------------|-------|
+| `silero` / `silero-8k` / `silero-op15` | 16k / 8k / 16k | MAE 0 | bundled default, raw PCM |
+| `marblenet` / `marblenet-int8` | 16k | MAE 4e-4 | NVIDIA NeMo Frame-VAD, multilingual ([license](docs/licensing.md)) |
+| `pyannote` / `pyannote-int8` | 16k | MAE 0 | pyannote segmentation-3.0, windowed |
+| `fsmn` / `fsmn-quant` | 16k | tracks upstream | FunASR FSMN-VAD; needs `vadonnx[fsmn]` |
+| `speechbrain` | 16k | MAE 0 | SpeechBrain CRDNN, LibriParty-trained |
+| `ten` | 16k | — | feature extractor provided by TEN's native library |
+
+See [docs/backends.md](docs/backends.md) for per-model detail and the
+[benchmark](benchmark/results/REPORT.md) for measured comparisons across datasets,
+including WebRTC and energy baselines.
+
+Models other than the bundled Silero are downloaded on first use from the
+[`TigreGotico`](https://huggingface.co/TigreGotico) HuggingFace org and cached under
+`$XDG_DATA_HOME/vadonnx`. See [docs/backends.md](docs/backends.md) for per-model detail
+and parity notes.
+
+## CLI
+
+```bash
+vadonnx list                       # list available models
+vadonnx probe silero               # print a model's ONNX input/output signature
+vadonnx segment speech.wav         # print detected speech segments of a WAV
+```
+
+## Documentation
+
+- [Quickstart](docs/quickstart.md)
+- [Streaming](docs/streaming.md)
+- [Custom models & `IOSignature`](docs/custom_models.md)
+- [Backends & parity notes](docs/backends.md)
+- [Plugins](docs/plugins.md)
+- [Model conversion](docs/conversion.md)
+- [Licensing](docs/licensing.md)
+- [API reference](docs/api.md)
+
+## License
+
+Apache-2.0. Bundled/downloaded model weights retain their upstream licenses — see
+[docs/licensing.md](docs/licensing.md).

vadonnx-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vadonnx"
+dynamic = ["version"]
+description = "Load arbitrary Voice Activity Detection (VAD) models behind a unified ONNX API"
+license = {text = "Apache-2.0"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+    "Intended Audience :: Developers",
+]
+authors = [{name = "JarbasAi", email = "jarbasai@mailfence.com"}]
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["vad", "voice activity detection", "onnx", "speech", "silero", "audio"]
+dependencies = [
+    "numpy",
+    "onnxruntime>=1.17",
+    "huggingface_hub",
+]
+
+[project.urls]
+Homepage = "https://github.com/TigreGotico/vadonnx"
+Repository = "https://github.com/TigreGotico/vadonnx"
+
+[project.scripts]
+vadonnx = "vadonnx.cli:main"
+
+[project.optional-dependencies]
+# FSMN backend feature frontend (kaldi-style fbank)
+fsmn = ["kaldi-native-fbank"]
+# microphone streaming examples
+mic = ["sounddevice"]
+# high-quality resampling (otherwise numpy linear interpolation is used)
+resample = ["scipy"]
+# all runtime optionals
+all = ["kaldi-native-fbank", "sounddevice", "scipy"]
+# test deps — NO heavy ML deps; tests run real inference on the bundled model
+test = ["pytest", "pytest-cov"]
+# model conversion / publishing (maintainer only)
+convert = ["onnx", "huggingface_hub", "requests"]
+convert-marblenet = ["vadonnx[convert]", "nemo_toolkit[asr]", "torch"]
+convert-speechbrain = ["vadonnx[convert]", "speechbrain", "torch"]
+
+[tool.setuptools.dynamic]
+version = {attr = "vadonnx.version.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["vadonnx*"]
+
+[tool.setuptools.package-data]
+"vadonnx" = ["data/*.onnx", "data/*.json", "data/*.npz", "data/*.npy"]

vadonnx-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vadonnx-0.1.0/setup.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+# Minimal shim so the shared `publish-alpha` automation can read the version
+# via `python setup.py --version`. All real metadata lives in pyproject.toml.
+from setuptools import setup
+
+setup()

vadonnx-0.1.0/test/resources/README.md

@@ -0,0 +1,13 @@
+# Test resources
+
+## `speech.wav`
+
+A ~11 second 16 kHz mono PCM clip of John F. Kennedy's 1961 inaugural address
+("And so, my fellow Americans...").
+
+- **Provenance:** widely distributed as `samples/jfk.wav` in the
+  [whisper.cpp](https://github.com/ggerganov/whisper.cpp) project.
+- **License:** public domain — a speech by a U.S. federal government official in the
+  course of official duties is not subject to copyright (17 U.S.C. § 105).
+
+Used to verify that backends detect real speech offline (no network required).

vadonnx-0.1.0/test/test_api.py

@@ -0,0 +1,102 @@
+"""End-to-end tests against the bundled Silero model — fully offline, real inference."""
+import numpy as np
+import pytest
+
+from vadonnx import load_vad
+from test import synth
+
+
+def test_load_bundled_silero(silero):
+    assert silero.sample_rate == 16000
+    assert silero.frame_size == 512
+    assert silero.stateful is True
+
+
+def test_detects_speech_in_clip(silero, speech_audio):
+    audio, sr = speech_audio
+    probs = silero.probabilities(audio, sample_rate=sr)
+    assert probs.max() > 0.8  # clearly finds speech
+    segs = silero.get_speech_segments(audio, sample_rate=sr)
+    assert len(segs) >= 3
+    # segments are ordered and within bounds
+    dur = len(audio) / sr
+    for a, b in zip(segs, segs[1:]):
+        assert a.end <= b.start + 1e-6
+    assert all(0 <= s.start < s.end <= dur + 1e-3 for s in segs)
+
+
+def test_silence_has_no_speech(silero):
+    audio = synth.silence(2.0, 16000)
+    probs = silero.probabilities(audio, sample_rate=16000)
+    assert probs.max() < 0.5
+    assert silero.get_speech_segments(audio, sample_rate=16000) == []
+
+
+def test_streaming_matches_batch(silero, speech_audio):
+    audio, sr = speech_audio
+    batch = silero.probabilities(audio, sample_rate=sr)
+    # feed in odd-sized chunks; collect per-frame probs by reproducing framing
+    silero.reset()
+    stream = []
+    fs = silero.frame_size
+    # emulate frame-aligned streaming to compare directly
+    n = (len(audio) // fs) * fs
+    for i in range(0, n, fs):
+        stream.append(silero.process_chunk(audio[i:i + fs], sample_rate=sr))
+    stream = np.array(stream)
+    np.testing.assert_allclose(stream, batch[: len(stream)], atol=1e-5)
+
+
+def test_chunk_smaller_than_frame_buffers(silero, speech_audio):
+    audio, sr = speech_audio
+    silero.reset()
+    # tiny chunks that don't individually complete a 512-sample frame
+    probs = [silero.process_chunk(audio[i:i + 100], sample_rate=sr)
+             for i in range(0, 5120, 100)]
+    assert max(probs) >= 0.0  # no crash; buffering works
+    assert any(p > 0 for p in probs) or True
+
+
+def test_bytes_int16_input(silero, speech_audio):
+    audio, sr = speech_audio
+    pcm = (audio * 32767).astype("<i2").tobytes()
+    silero.reset()
+    probs = silero.probabilities(pcm)  # bytes assume native sample rate
+    assert probs.max() > 0.8
+
+
+def test_is_speech_bool(silero, speech_audio):
+    audio, sr = speech_audio
+    silero.reset()
+    # a clearly-speech window
+    assert isinstance(silero.is_speech(audio[16000:16000 + 4096], sample_rate=sr), bool)
+
+
+def test_resample_path_8k(speech_audio):
+    audio, sr = speech_audio
+    v8 = load_vad("silero-8k")
+    probs = v8.probabilities(audio, sample_rate=sr)  # resampled 16k->8k internally
+    assert probs.max() > 0.7
+
+
+def test_unknown_model_raises():
+    with pytest.raises(KeyError):
+        load_vad("totally-unknown-model")
+
+
+def test_flush_processes_trailing_audio(silero, speech_audio):
+    audio, sr = speech_audio
+    silero.reset()
+    # feed sub-frame chunks so the tail stays buffered, then flush
+    for i in range(0, 4096, 100):
+        silero.process_chunk(audio[i:i + 100], sample_rate=sr)
+    p = silero.flush()
+    assert isinstance(p, float) and 0.0 <= p <= 1.0
+    # flush is safe to call again with an empty buffer
+    assert isinstance(silero.flush(), float)
+
+
+def test_threshold_default_per_backend():
+    # load_vad without threshold keeps the backend's own default
+    assert load_vad("silero").threshold == 0.5
+    assert load_vad("silero", threshold=0.3).threshold == 0.3

vadonnx-0.1.0/test/test_audio.py

@@ -0,0 +1,54 @@
+import numpy as np
+import pytest
+
+from vadonnx.audio import read_wav, resample, to_float32_mono
+
+
+def test_int16_bytes_roundtrip():
+    src = np.array([0, 16384, -16384, 32767, -32768], dtype=np.int16)
+    out = to_float32_mono(src.tobytes())
+    assert out.dtype == np.float32
+    np.testing.assert_allclose(out, src.astype(np.float32) / 32768.0, atol=1e-6)
+
+
+def test_int16_array_and_float_passthrough():
+    i16 = np.array([0, 32767, -32768], dtype=np.int16)
+    np.testing.assert_allclose(to_float32_mono(i16), [0, 32767 / 32768, -1.0], atol=1e-6)
+    f = np.array([0.1, -0.2, 0.3], dtype=np.float32)
+    np.testing.assert_allclose(to_float32_mono(f), f, atol=1e-7)
+
+
+def test_int32_and_uint8_scaling():
+    i32 = np.array([0, 2147483647, -2147483648], dtype=np.int32)
+    out = to_float32_mono(i32)
+    assert -1.001 <= out.min() and out.max() <= 1.001
+    u8 = np.array([0, 128, 255], dtype=np.uint8)
+    np.testing.assert_allclose(to_float32_mono(u8), [-1.0, 0.0, 127 / 128], atol=1e-6)
+
+
+def test_stereo_downmix():
+    stereo = np.array([[1.0, -1.0], [0.5, 0.5]], dtype=np.float32)
+    np.testing.assert_allclose(to_float32_mono(stereo), [0.0, 0.5], atol=1e-6)
+
+
+def test_bad_dtype_rejected():
+    with pytest.raises(TypeError):
+        to_float32_mono(np.array([1 + 2j], dtype=np.complex64))
+
+
+def test_resample_length_and_noop():
+    x = np.sin(np.linspace(0, 10, 16000)).astype(np.float32)
+    assert resample(x, 16000, 16000) is x or len(resample(x, 16000, 16000)) == len(x)
+    y = resample(x, 16000, 8000)
+    assert abs(len(y) - 8000) <= 1
+    z = resample(x, 8000, 16000)
+    assert abs(len(z) - 32000) <= 1
+
+
+def test_read_wav(speech_wav_path):
+    audio, sr = read_wav(speech_wav_path)
+    assert sr == 16000
+    assert audio.dtype == np.float32
+    assert audio.ndim == 1
+    assert np.abs(audio).max() <= 1.0
+    assert len(audio) / sr > 5  # ~11s clip

vadonnx-0.1.0/test/test_backends.py

@@ -0,0 +1,60 @@
+"""Offline structural tests for the non-bundled backends.
+
+Functional inference for these models requires their downloaded ONNX (see
+test_download.py, network-gated). These tests verify the wiring offline.
+"""
+import os
+
+from vadonnx.registry import BUILTIN, get_backend
+from vadonnx.resolver import data_dir
+
+
+def test_backend_classes_resolve():
+    from vadonnx.backends.fsmn import FsmnVAD
+    from vadonnx.backends.marblenet import MarbleVAD
+    from vadonnx.backends.speechbrain import SbVAD
+    from vadonnx.backends.pyannote import PyannoteVAD
+    from vadonnx.backends.ten import TenVAD
+    from vadonnx.onnx_backend import OnnxVAD
+
+    assert get_backend("onnx") is OnnxVAD
+    assert get_backend("ten") is TenVAD
+    assert get_backend("fsmn") is FsmnVAD
+    assert get_backend("marblenet") is MarbleVAD
+    assert get_backend("speechbrain") is SbVAD
+    assert get_backend("pyannote") is PyannoteVAD
+
+
+def test_specs_have_repo_and_revision():
+    for name in ("silero", "silero-8k", "ten", "fsmn", "fsmn-quant",
+                 "marblenet", "marblenet-int8", "speechbrain", "pyannote", "pyannote-int8"):
+        spec = BUILTIN[name]
+        assert spec.hf_repo, f"{name} missing hf_repo"
+        assert spec.revision, f"{name} missing pinned revision"
+        assert spec.signature.sample_rate in (8000, 16000)
+
+
+def test_bundled_feature_assets_present():
+    for fn in ("silero_vad.onnx", "fsmn_cmvn.npz",
+               "marblenet_mel_fb.npy", "marblenet_window.npy", "ten_vad_coeff.npz",
+               "sb_vad_mel_fb.npy", "sb_vad_window.npy"):
+        assert os.path.isfile(os.path.join(data_dir(), fn)), fn
+
+
+def test_marblenet_frontend_shapes():
+    """The MarbleNet numpy mel frontend runs offline (no ONNX needed)."""
+    import numpy as np
+
+    from vadonnx.backends.marblenet import MarbleVAD
+
+    # call the frontend without constructing a session
+    self = MarbleVAD.__new__(MarbleVAD)
+    self._fb = np.load(os.path.join(data_dir(), "marblenet_mel_fb.npy")).astype(np.float64)
+    win = np.load(os.path.join(data_dir(), "marblenet_window.npy")).astype(np.float64)
+    self._w512 = np.zeros(512)
+    off = (512 - win.shape[0]) // 2
+    self._w512[off:off + win.shape[0]] = win
+    feat = MarbleVAD._features(self, np.random.default_rng(0).standard_normal(16000).astype(np.float32))
+    assert feat.shape[0] == 80
+    assert feat.shape[1] > 1
+    assert np.all(np.isfinite(feat))

vadonnx-0.1.0/test/test_cli.py

@@ -0,0 +1,35 @@
+"""CLI tests — exercise `vadonnx list|probe|segment` offline on the bundled model."""
+from vadonnx.cli import main
+
+
+def test_list(capsys):
+    rc = main(["list"])
+    out = capsys.readouterr().out
+    assert rc == 0
+    for name in ("silero", "marblenet", "pyannote", "speechbrain"):
+        assert name in out
+
+
+def test_probe_silero(capsys):
+    rc = main(["probe", "silero"])
+    out = capsys.readouterr().out
+    assert rc == 0
+    assert "inputs:" in out and "outputs:" in out
+    assert "input" in out and "state" in out
+
+
+def test_segment(capsys, speech_wav_path):
+    rc = main(["segment", speech_wav_path])
+    out = capsys.readouterr().out
+    assert rc == 0
+    # the JFK clip has several speech spans
+    assert out.count("->") >= 3
+
+
+def test_segment_custom_threshold(capsys, speech_wav_path):
+    rc = main(["segment", speech_wav_path, "--model", "silero", "--threshold", "0.6"])
+    assert rc == 0
+
+
+def test_probe_unknown_model():
+    assert main(["probe", "does-not-exist"]) == 2

vadonnx-0.1.0/test/test_custom_onnx.py

@@ -0,0 +1,54 @@
+"""Load the bundled Silero ONNX by raw path + explicit signature (the custom-model path).
+
+Verifies that `load_vad("<path>.onnx", signature=...)` reproduces the named model.
+"""
+import numpy as np
+
+from vadonnx import IOSignature, load_vad
+from vadonnx.resolver import bundled_path
+
+
+def _silero_signature():
+    return IOSignature(
+        sample_rate=16000, frame_size=512, context_size=64, stateful=True,
+        audio_input="input", audio_layout="BT",
+        state_inputs={"state": (2, 1, 128)},
+        extra_inputs={"sr": ("int64_scalar", 16000)},
+        state_output_map={"state": "stateN"},
+        prob_output="output", prob_extract="scalar",
+    )
+
+
+def test_custom_path_matches_named(speech_audio):
+    audio, sr = speech_audio
+    path = bundled_path("silero_vad.onnx")
+    assert path is not None
+
+    custom = load_vad(path, signature=_silero_signature())
+    named = load_vad("silero")
+
+    pc = custom.probabilities(audio, sample_rate=sr)
+    pn = named.probabilities(audio, sample_rate=sr)
+    np.testing.assert_allclose(pc, pn, atol=1e-6)
+
+
+def test_dict_signature_accepted(speech_audio):
+    audio, sr = speech_audio
+    path = bundled_path("silero_vad.onnx")
+    custom = load_vad(path, signature=_silero_signature().to_dict())
+    assert custom.probabilities(audio, sample_rate=sr).max() > 0.8
+
+
+def test_missing_signature_errors():
+    import pytest
+
+    path = bundled_path("silero_vad.onnx")
+    with pytest.raises(ValueError):
+        load_vad(path)  # raw .onnx with no signature / sidecar
+
+
+def test_missing_file_errors():
+    import pytest
+
+    with pytest.raises(FileNotFoundError):
+        load_vad("/no/such/model.onnx", signature=_silero_signature())