pysilero-vad 2.0.0__tar.gz

pysilero_vad-2.0.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Michael Hansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pysilero_vad-2.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include pysilero_vad/models/*.onnx

pysilero_vad-2.0.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: pysilero_vad
+Version: 2.0.0
+Summary: Pre-packaged voice activity detector using silero-vad
+Home-page: http://github.com/rhasspy/pysilero-vad
+Author: Michael Hansen
+Author-email: mike@rhasspy.org
+License: MIT
+Keywords: voice activity vad
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: onnxruntime<2,>=1.18.0
+Requires-Dist: numpy<2
+
+# pySilero VAD
+
+A pre-packaged voice activity detector using [silero-vad](https://github.com/snakers4/silero-vad).
+
+``` sh
+pip install pysilero-vad
+```
+
+``` python
+from pysilero_vad import SileroVoiceActivityDetector
+
+vad = SileroVoiceActivityDetector()
+
+# Audio must be 16Khz, 16-bit mono PCM
+if vad(audio_bytes) >= 0.5:
+    print("Speech")
+else:
+    print("Silence")
+```
+

pysilero_vad-2.0.0/README.md

@@ -0,0 +1,20 @@
+# pySilero VAD
+
+A pre-packaged voice activity detector using [silero-vad](https://github.com/snakers4/silero-vad).
+
+``` sh
+pip install pysilero-vad
+```
+
+``` python
+from pysilero_vad import SileroVoiceActivityDetector
+
+vad = SileroVoiceActivityDetector()
+
+# Audio must be 16Khz, 16-bit mono PCM
+if vad(audio_bytes) >= 0.5:
+    print("Speech")
+else:
+    print("Silence")
+```
+

pysilero_vad-2.0.0/pysilero_vad/__init__.py

@@ -0,0 +1,107 @@
+import logging
+from pathlib import Path
+from typing import Final, Iterable, Union
+
+import numpy as np
+import onnxruntime
+
+_RATE: Final = 16000  # Khz
+_MAX_WAV: Final = 32767
+_DIR = Path(__file__).parent
+_DEFAULT_ONNX_PATH = _DIR / "models" / "silero_vad.onnx"
+_CONTEXT_SIZE: Final = 64  # 16Khz
+_CHUNK_SAMPLES: Final = 512
+_CHUNK_BYTES: Final = _CHUNK_SAMPLES * 2  # 16-bit
+
+_LOGGER = logging.getLogger()
+
+
+class InvalidChunkSizeError(Exception):
+    """Error raised when chunk size is not correct."""
+
+
+class SileroVoiceActivityDetector:
+    """Detects speech/silence using Silero VAD.
+
+    https://github.com/snakers4/silero-vad
+    """
+
+    def __init__(self, onnx_path: Union[str, Path] = _DEFAULT_ONNX_PATH) -> None:
+        onnx_path = str(onnx_path)
+
+        opts = onnxruntime.SessionOptions()
+        opts.inter_op_num_threads = 1
+        opts.intra_op_num_threads = 1
+
+        self.session = onnxruntime.InferenceSession(
+            onnx_path, providers=["CPUExecutionProvider"], sess_options=opts
+        )
+
+        self._context = np.zeros((1, _CONTEXT_SIZE), dtype=np.float32)
+        self._state = np.zeros((2, 1, 128), dtype=np.float32)
+        self._sr = np.array(_RATE, dtype=np.int64)
+
+    @staticmethod
+    def chunk_samples() -> int:
+        """Return number of samples required for an audio chunk."""
+        return _CHUNK_SAMPLES
+
+    @staticmethod
+    def chunk_bytes() -> int:
+        """Return number of bytes required for an audio chunk."""
+        return _CHUNK_BYTES
+
+    def reset(self) -> None:
+        """Reset state."""
+        self._state = np.zeros((2, 1, 128)).astype("float32")
+
+    def __call__(self, audio: bytes) -> float:
+        """Return probability of speech [0-1] in a single audio chunk.
+
+        Audio *must* be 512 samples of 16Khz 16-bit mono PCM.
+        """
+        return self.process_chunk(audio)
+
+    def process_chunk(self, audio: bytes) -> float:
+        """Return probability of speech [0-1] in a single audio chunk.
+
+        Audio *must* be 512 samples of 16Khz 16-bit mono PCM.
+        """
+        if len(audio) != _CHUNK_BYTES:
+            # Window size is fixed at 512 samples in v5
+            raise InvalidChunkSizeError
+
+        audio_array = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / _MAX_WAV
+
+        # Add batch dimension and context
+        audio_array = np.concatenate(
+            (self._context, audio_array[np.newaxis, :]), axis=1
+        )
+        self._context = audio_array[:, -_CONTEXT_SIZE:]
+
+        # ort_inputs = {"input": audio_array, "state": self._state, "sr": self._sr}
+        ort_inputs = {
+            "input": audio_array[:, : _CHUNK_SAMPLES + _CONTEXT_SIZE],
+            "state": self._state,
+            "sr": self._sr,
+        }
+        ort_outs = self.session.run(None, ort_inputs)
+        out, self._state = ort_outs
+
+        return out.squeeze()
+
+    def process_chunks(self, audio: bytes) -> Iterable[float]:
+        """Return probability of speech in audio [0-1] for each chunk of audio.
+
+        Audio must be 16Khz 16-bit mono PCM.
+        """
+        if len(audio) < _CHUNK_BYTES:
+            # Window size is fixed at 512 samples in v5
+            raise InvalidChunkSizeError
+
+        num_audio_bytes = len(audio)
+        audio_idx = 0
+
+        while (audio_idx + _CHUNK_BYTES) < num_audio_bytes:
+            yield self.process_chunk(audio[audio_idx : audio_idx + _CHUNK_BYTES])
+            audio_idx += _CHUNK_BYTES

pysilero_vad-2.0.0/pysilero_vad.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: pysilero-vad
+Version: 2.0.0
+Summary: Pre-packaged voice activity detector using silero-vad
+Home-page: http://github.com/rhasspy/pysilero-vad
+Author: Michael Hansen
+Author-email: mike@rhasspy.org
+License: MIT
+Keywords: voice activity vad
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: onnxruntime<2,>=1.18.0
+Requires-Dist: numpy<2
+
+# pySilero VAD
+
+A pre-packaged voice activity detector using [silero-vad](https://github.com/snakers4/silero-vad).
+
+``` sh
+pip install pysilero-vad
+```
+
+``` python
+from pysilero_vad import SileroVoiceActivityDetector
+
+vad = SileroVoiceActivityDetector()
+
+# Audio must be 16Khz, 16-bit mono PCM
+if vad(audio_bytes) >= 0.5:
+    print("Speech")
+else:
+    print("Silence")
+```
+

pysilero_vad-2.0.0/pysilero_vad.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.md
+MANIFEST.in
+README.md
+requirements.txt
+setup.cfg
+setup.py
+pysilero_vad/__init__.py
+pysilero_vad/py.typed
+pysilero_vad.egg-info/PKG-INFO
+pysilero_vad.egg-info/SOURCES.txt
+pysilero_vad.egg-info/dependency_links.txt
+pysilero_vad.egg-info/requires.txt
+pysilero_vad.egg-info/top_level.txt
+pysilero_vad/models/silero_vad.onnx
+tests/test_vad.py

pysilero_vad-2.0.0/pysilero_vad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysilero_vad-2.0.0/pysilero_vad.egg-info/requires.txt

@@ -0,0 +1,2 @@
+onnxruntime<2,>=1.18.0
+numpy<2

pysilero_vad-2.0.0/pysilero_vad.egg-info/top_level.txt

@@ -0,0 +1 @@
+pysilero_vad

pysilero_vad-2.0.0/requirements.txt

@@ -0,0 +1,2 @@
+onnxruntime>=1.18.0,<2
+numpy<2

pysilero_vad-2.0.0/setup.cfg

@@ -0,0 +1,21 @@
+[flake8]
+max-line-length = 88
+ignore = 
+	E501,
+	W503,
+	E203,
+	D202,
+	W504
+
+[isort]
+multi_line_output = 3
+include_trailing_comma = True
+force_grid_wrap = 0
+use_parentheses = True
+line_length = 88
+indent = "    "
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pysilero_vad-2.0.0/setup.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+from pathlib import Path
+
+import setuptools
+from setuptools import setup
+
+this_dir = Path(__file__).parent
+module_dir = this_dir / "pysilero_vad"
+
+# -----------------------------------------------------------------------------
+
+# Load README in as long description
+long_description: str = ""
+readme_path = this_dir / "README.md"
+if readme_path.is_file():
+    long_description = readme_path.read_text(encoding="utf-8")
+
+requirements = []
+requirements_path = this_dir / "requirements.txt"
+if requirements_path.is_file():
+    with open(requirements_path, "r", encoding="utf-8") as requirements_file:
+        requirements = requirements_file.read().splitlines()
+
+# -----------------------------------------------------------------------------
+
+setup(
+    name="pysilero_vad",
+    version="2.0.0",
+    description="Pre-packaged voice activity detector using silero-vad",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="http://github.com/rhasspy/pysilero-vad",
+    author="Michael Hansen",
+    author_email="mike@rhasspy.org",
+    license="MIT",
+    packages=setuptools.find_packages(),
+    package_data={
+        "pysilero_vad": ["py.typed", "models/silero_vad.onnx"],
+    },
+    install_requires=requirements,
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Multimedia :: Sound/Audio :: Speech",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    keywords="voice activity vad",
+)

pysilero_vad-2.0.0/tests/test_vad.py

@@ -0,0 +1,44 @@
+import wave
+from pathlib import Path
+from typing import Union
+
+import pytest
+from pysilero_vad import SileroVoiceActivityDetector, InvalidChunkSizeError
+
+_DIR = Path(__file__).parent
+
+
+def _load_wav(wav_path: Union[str, Path]) -> bytes:
+    """Return audio bytes from a WAV file."""
+    with wave.open(str(wav_path), "rb") as wav_file:
+        assert wav_file.getframerate() == 16000
+        assert wav_file.getsampwidth() == 2
+        assert wav_file.getnchannels() == 1
+
+        return wav_file.readframes(wav_file.getnframes())
+
+
+def test_silence() -> None:
+    """Test VAD on recorded silence."""
+    vad = SileroVoiceActivityDetector()
+    assert all(p < 0.5 for p in vad.process_chunks(_load_wav(_DIR / "silence.wav")))
+
+
+def test_speech() -> None:
+    """Test VAD on recorded speech."""
+    vad = SileroVoiceActivityDetector()
+    assert any(p >= 0.5 for p in vad.process_chunks(_load_wav(_DIR / "speech.wav")))
+
+def test_invalid_chunk_size() -> None:
+    """Test that chunk size must be 512 samples."""
+    vad = SileroVoiceActivityDetector()
+
+    # Should work
+    vad(bytes(SileroVoiceActivityDetector.chunk_bytes()))
+
+    # Should fail
+    with pytest.raises(InvalidChunkSizeError):
+        vad(bytes(SileroVoiceActivityDetector.chunk_bytes() * 2))
+
+    with pytest.raises(InvalidChunkSizeError):
+        vad(bytes(SileroVoiceActivityDetector.chunk_bytes() // 2))