pipecat-moonshine 0.1.0__tar.gz

pipecat_moonshine-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, pipecat-moonshine contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pipecat_moonshine-0.1.0/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: pipecat-moonshine
+Version: 0.1.0
+Summary: Moonshine ASR (speech-to-text) community integration for Pipecat
+Author: pipecat-moonshine contributors
+License: BSD-2-Clause
+Project-URL: Homepage, https://github.com/ubopod/pipecat-moonshine
+Project-URL: Source, https://github.com/ubopod/pipecat-moonshine
+Project-URL: Issues, https://github.com/ubopod/pipecat-moonshine/issues
+Project-URL: Changelog, https://github.com/ubopod/pipecat-moonshine/blob/main/CHANGELOG.md
+Keywords: pipecat,moonshine,asr,stt,speech-to-text,voice,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pipecat-ai[websockets-base]>=1.2.1
+Requires-Dist: useful-moonshine-onnx>=20251121
+Requires-Dist: numpy<3,>=1.26.4
+Requires-Dist: loguru<1,>=0.7.0
+Provides-Extra: examples
+Requires-Dist: python-dotenv<2,>=1.0.0; extra == "examples"
+Requires-Dist: pyaudio~=0.2.14; extra == "examples"
+Provides-Extra: dev
+Requires-Dist: ruff<1,>=0.12.11; extra == "dev"
+Requires-Dist: pytest<10,>=9.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio<2,>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# pipecat-moonshine
+
+[Moonshine ASR](https://github.com/moonshine-ai/moonshine) speech-to-text
+integration for [Pipecat](https://github.com/pipecat-ai/pipecat).
+
+Moonshine is a family of small, fast automatic-speech-recognition models
+optimized for resource-constrained devices. The Tiny English model is roughly
+26 M parameters, the Base English model roughly 58 M — both run on CPU via
+ONNX Runtime with no GPU required. That makes Moonshine an attractive choice
+for low-latency, on-device transcription in Pipecat pipelines that already
+handle VAD upstream.
+
+This package provides `MoonshineSTTService`, a `SegmentedSTTService`
+subclass that plugs straight into any Pipecat pipeline.
+
+## Status
+
+Community-maintained integration. See
+[Pipecat's Community Integrations guide](https://github.com/pipecat-ai/pipecat/blob/main/COMMUNITY_INTEGRATIONS.md)
+for what that means — in short, the Pipecat team does not maintain or
+support this package; please file issues here.
+
+**Tested with Pipecat v1.2.1.**
+
+## Installation
+
+```bash
+pip install pipecat-moonshine
+```
+
+This pulls in [`useful-moonshine-onnx`](https://pypi.org/project/useful-moonshine-onnx/)
+and `pipecat-ai` automatically. The first time you instantiate the service,
+the chosen model weights are downloaded from Hugging Face
+(`UsefulSensors/moonshine`) and cached locally.
+
+For the included foundational example you also need the local-audio extras:
+
+```bash
+pip install 'pipecat-moonshine[examples]'
+```
+
+## Usage
+
+```python
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat_moonshine import MoonshineSTTService, Model
+
+stt = MoonshineSTTService(model=Model.TINY_EN)
+
+pipeline = Pipeline([
+    transport.input(),
+    vad_processor,     # MUST run upstream of the STT — see below
+    stt,
+    # ... downstream processors
+])
+```
+
+`MoonshineSTTService` subclasses `SegmentedSTTService`, so a VAD-driven
+processor (e.g. `VADProcessor` with `SileroVADAnalyzer`) must produce
+`VADUserStartedSpeakingFrame` / `VADUserStoppedSpeakingFrame` upstream of
+it. Each detected speech segment is decoded into a single final
+`TranscriptionFrame` — Moonshine does not emit interim results.
+
+### Configuring the model at runtime
+
+Pass an explicit model or a fully-built settings object:
+
+```python
+# Convenience kwarg
+stt = MoonshineSTTService(model=Model.BASE_EN)
+
+# Or via Settings (e.g. when you want to update at runtime)
+stt = MoonshineSTTService(
+    settings=MoonshineSTTService.Settings(model="moonshine/base"),
+)
+```
+
+## Running the example
+
+```bash
+git clone https://github.com/ubopod/pipecat-moonshine
+cd pipecat-moonshine
+pip install -e '.[examples]'
+python examples/transcription-moonshine.py
+```
+
+Speak into your default mic; lines like `Transcription: hello world` will be
+printed for each detected utterance.
+
+## Audio format requirements
+
+Moonshine expects **16 kHz, mono, 16-bit signed PCM** input. Pipecat's
+default `LocalAudioTransport` and most WebRTC transports already provide
+this. If your pipeline runs at a different sample rate the service will log
+a warning on the first segment and transcription quality may degrade — add
+a resampler upstream if you need a different rate.
+
+Moonshine also enforces a per-segment duration window: speech segments
+shorter than 0.1 s or longer than 64 s are silently dropped (the service
+logs at `DEBUG` level when this happens).
+
+## Supported models
+
+| Constant         | Model name         | Params | Notes                                |
+| ---------------- | ------------------ | ------ | ------------------------------------ |
+| `Model.TINY_EN`  | `moonshine/tiny`   | 26 M   | English-only, MIT-licensed weights.  |
+| `Model.BASE_EN`  | `moonshine/base`   | 58 M   | English-only, MIT-licensed weights.  |
+
+### Multilingual models — important license note
+
+Moonshine also publishes multilingual checkpoints (Spanish, Japanese,
+Arabic, Korean, Mandarin, Vietnamese, Ukrainian, …). Those weights are
+released under the **Moonshine Community License**, which is *non-commercial*.
+
+For that reason they are intentionally **not** enumerated in the `Model`
+enum. If you want to use one you must:
+
+1. Read and accept the upstream Moonshine Community License.
+2. Pass the model name as a string explicitly, e.g.:
+
+   ```python
+   stt = MoonshineSTTService(model="moonshine/base")
+   # then load the appropriate language checkpoint via your own download flow
+   ```
+
+This package does not bundle, mirror, or auto-download non-commercial
+weights, and the maintainers make no representation that doing so complies
+with your use case.
+
+## Frames
+
+| In                                  | Out                                                        |
+| ----------------------------------- | ---------------------------------------------------------- |
+| `VADUserStartedSpeakingFrame`       | (no output — buffers audio internally)                     |
+| `VADUserStoppedSpeakingFrame`       | one `TranscriptionFrame` per segment (final), or nothing   |
+| Any non-VAD audio                   | buffered/forwarded according to `SegmentedSTTService`      |
+
+Errors during transcription are pushed as `ErrorFrame`s; the pipeline is
+not torn down so other services can continue.
+
+## Metrics
+
+`can_generate_metrics()` returns `True`. Per-segment processing time is
+recorded via `start_processing_metrics` / `stop_processing_metrics`, so
+enabling metrics on your `PipelineTask` will surface Moonshine latency
+alongside the rest of your pipeline.
+
+## Maintainer
+
+Community-maintained. Not affiliated with Moonshine AI or Daily.
+
+## License
+
+BSD-2-Clause — see [LICENSE](./LICENSE). Note that the Moonshine model
+*weights* are governed by their own license (MIT for English models,
+Moonshine Community License for others) — see the section above.
+
+## Versioning and changelog
+
+See [CHANGELOG.md](./CHANGELOG.md). This package follows semantic
+versioning.
+
+## Getting help
+
+- Pipecat Discord: <https://discord.gg/pipecat> (`#community-integrations`)
+- Pipecat changelog (track upstream changes that may affect this integration):
+  <https://github.com/pipecat-ai/pipecat/blob/main/CHANGELOG.md>
+- Issues for this integration: file them in this repo.

pipecat_moonshine-0.1.0/README.md

@@ -0,0 +1,168 @@
+# pipecat-moonshine
+
+[Moonshine ASR](https://github.com/moonshine-ai/moonshine) speech-to-text
+integration for [Pipecat](https://github.com/pipecat-ai/pipecat).
+
+Moonshine is a family of small, fast automatic-speech-recognition models
+optimized for resource-constrained devices. The Tiny English model is roughly
+26 M parameters, the Base English model roughly 58 M — both run on CPU via
+ONNX Runtime with no GPU required. That makes Moonshine an attractive choice
+for low-latency, on-device transcription in Pipecat pipelines that already
+handle VAD upstream.
+
+This package provides `MoonshineSTTService`, a `SegmentedSTTService`
+subclass that plugs straight into any Pipecat pipeline.
+
+## Status
+
+Community-maintained integration. See
+[Pipecat's Community Integrations guide](https://github.com/pipecat-ai/pipecat/blob/main/COMMUNITY_INTEGRATIONS.md)
+for what that means — in short, the Pipecat team does not maintain or
+support this package; please file issues here.
+
+**Tested with Pipecat v1.2.1.**
+
+## Installation
+
+```bash
+pip install pipecat-moonshine
+```
+
+This pulls in [`useful-moonshine-onnx`](https://pypi.org/project/useful-moonshine-onnx/)
+and `pipecat-ai` automatically. The first time you instantiate the service,
+the chosen model weights are downloaded from Hugging Face
+(`UsefulSensors/moonshine`) and cached locally.
+
+For the included foundational example you also need the local-audio extras:
+
+```bash
+pip install 'pipecat-moonshine[examples]'
+```
+
+## Usage
+
+```python
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat_moonshine import MoonshineSTTService, Model
+
+stt = MoonshineSTTService(model=Model.TINY_EN)
+
+pipeline = Pipeline([
+    transport.input(),
+    vad_processor,     # MUST run upstream of the STT — see below
+    stt,
+    # ... downstream processors
+])
+```
+
+`MoonshineSTTService` subclasses `SegmentedSTTService`, so a VAD-driven
+processor (e.g. `VADProcessor` with `SileroVADAnalyzer`) must produce
+`VADUserStartedSpeakingFrame` / `VADUserStoppedSpeakingFrame` upstream of
+it. Each detected speech segment is decoded into a single final
+`TranscriptionFrame` — Moonshine does not emit interim results.
+
+### Configuring the model at runtime
+
+Pass an explicit model or a fully-built settings object:
+
+```python
+# Convenience kwarg
+stt = MoonshineSTTService(model=Model.BASE_EN)
+
+# Or via Settings (e.g. when you want to update at runtime)
+stt = MoonshineSTTService(
+    settings=MoonshineSTTService.Settings(model="moonshine/base"),
+)
+```
+
+## Running the example
+
+```bash
+git clone https://github.com/ubopod/pipecat-moonshine
+cd pipecat-moonshine
+pip install -e '.[examples]'
+python examples/transcription-moonshine.py
+```
+
+Speak into your default mic; lines like `Transcription: hello world` will be
+printed for each detected utterance.
+
+## Audio format requirements
+
+Moonshine expects **16 kHz, mono, 16-bit signed PCM** input. Pipecat's
+default `LocalAudioTransport` and most WebRTC transports already provide
+this. If your pipeline runs at a different sample rate the service will log
+a warning on the first segment and transcription quality may degrade — add
+a resampler upstream if you need a different rate.
+
+Moonshine also enforces a per-segment duration window: speech segments
+shorter than 0.1 s or longer than 64 s are silently dropped (the service
+logs at `DEBUG` level when this happens).
+
+## Supported models
+
+| Constant         | Model name         | Params | Notes                                |
+| ---------------- | ------------------ | ------ | ------------------------------------ |
+| `Model.TINY_EN`  | `moonshine/tiny`   | 26 M   | English-only, MIT-licensed weights.  |
+| `Model.BASE_EN`  | `moonshine/base`   | 58 M   | English-only, MIT-licensed weights.  |
+
+### Multilingual models — important license note
+
+Moonshine also publishes multilingual checkpoints (Spanish, Japanese,
+Arabic, Korean, Mandarin, Vietnamese, Ukrainian, …). Those weights are
+released under the **Moonshine Community License**, which is *non-commercial*.
+
+For that reason they are intentionally **not** enumerated in the `Model`
+enum. If you want to use one you must:
+
+1. Read and accept the upstream Moonshine Community License.
+2. Pass the model name as a string explicitly, e.g.:
+
+   ```python
+   stt = MoonshineSTTService(model="moonshine/base")
+   # then load the appropriate language checkpoint via your own download flow
+   ```
+
+This package does not bundle, mirror, or auto-download non-commercial
+weights, and the maintainers make no representation that doing so complies
+with your use case.
+
+## Frames
+
+| In                                  | Out                                                        |
+| ----------------------------------- | ---------------------------------------------------------- |
+| `VADUserStartedSpeakingFrame`       | (no output — buffers audio internally)                     |
+| `VADUserStoppedSpeakingFrame`       | one `TranscriptionFrame` per segment (final), or nothing   |
+| Any non-VAD audio                   | buffered/forwarded according to `SegmentedSTTService`      |
+
+Errors during transcription are pushed as `ErrorFrame`s; the pipeline is
+not torn down so other services can continue.
+
+## Metrics
+
+`can_generate_metrics()` returns `True`. Per-segment processing time is
+recorded via `start_processing_metrics` / `stop_processing_metrics`, so
+enabling metrics on your `PipelineTask` will surface Moonshine latency
+alongside the rest of your pipeline.
+
+## Maintainer
+
+Community-maintained. Not affiliated with Moonshine AI or Daily.
+
+## License
+
+BSD-2-Clause — see [LICENSE](./LICENSE). Note that the Moonshine model
+*weights* are governed by their own license (MIT for English models,
+Moonshine Community License for others) — see the section above.
+
+## Versioning and changelog
+
+See [CHANGELOG.md](./CHANGELOG.md). This package follows semantic
+versioning.
+
+## Getting help
+
+- Pipecat Discord: <https://discord.gg/pipecat> (`#community-integrations`)
+- Pipecat changelog (track upstream changes that may affect this integration):
+  <https://github.com/pipecat-ai/pipecat/blob/main/CHANGELOG.md>
+- Issues for this integration: file them in this repo.

pipecat_moonshine-0.1.0/pyproject.toml

@@ -0,0 +1,86 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pipecat-moonshine"
+version = "0.1.0"
+description = "Moonshine ASR (speech-to-text) community integration for Pipecat"
+readme = "README.md"
+license = { text = "BSD-2-Clause" }
+requires-python = ">=3.11"
+keywords = ["pipecat", "moonshine", "asr", "stt", "speech-to-text", "voice", "ai"]
+authors = [
+    { name = "pipecat-moonshine contributors" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    # ``websockets-base`` extra is required because pipecat's
+    # ``stt_service`` module imports ``websockets.protocol.State`` at module
+    # top-level, even for services that don't use websockets themselves.
+    "pipecat-ai[websockets-base]>=1.2.1",
+    "useful-moonshine-onnx>=20251121",
+    "numpy>=1.26.4,<3",
+    "loguru>=0.7.0,<1",
+]
+
+[project.urls]
+Homepage = "https://github.com/ubopod/pipecat-moonshine"
+Source = "https://github.com/ubopod/pipecat-moonshine"
+Issues = "https://github.com/ubopod/pipecat-moonshine/issues"
+Changelog = "https://github.com/ubopod/pipecat-moonshine/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+examples = [
+    "python-dotenv>=1.0.0,<2",
+    "pyaudio~=0.2.14",
+]
+dev = [
+    "ruff>=0.12.11,<1",
+    "pytest>=9.0.0,<10",
+    "pytest-asyncio>=1.0.0,<2",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"pipecat_moonshine" = ["py.typed"]
+
+[tool.ruff]
+exclude = [".git", ".venv"]
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "D",   # pydocstyle
+    "I",   # isort
+    "UP",  # pyupgrade
+]
+ignore = [
+    "D105",  # missing docstring in magic methods
+]
+
+[tool.ruff.lint.per-file-ignores]
+"examples/**/*.py" = ["D"]
+"tests/**/*.py" = ["D"]
+"**/__init__.py" = ["D104"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.pytest.ini_options]
+addopts = "--verbose"
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_default_fixture_loop_scope = "function"

pipecat_moonshine-0.1.0/setup.cfg

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

pipecat_moonshine-0.1.0/src/pipecat_moonshine/__init__.py

@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2026, pipecat-moonshine contributors
+#
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+"""Moonshine ASR (speech-to-text) integration for Pipecat."""
+
+from pipecat_moonshine.stt import (
+    MOONSHINE_SAMPLE_RATE,
+    Model,
+    MoonshineSTTService,
+    MoonshineSTTSettings,
+    language_to_moonshine_language,
+)
+
+__all__ = [
+    "MOONSHINE_SAMPLE_RATE",
+    "Model",
+    "MoonshineSTTService",
+    "MoonshineSTTSettings",
+    "language_to_moonshine_language",
+]

pipecat_moonshine-0.1.0/src/pipecat_moonshine/stt.py

@@ -0,0 +1,287 @@
+#
+# Copyright (c) 2026, pipecat-moonshine contributors
+#
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+"""Moonshine speech-to-text service for Pipecat.
+
+This module integrates the Moonshine ASR family of models (via the
+``useful-moonshine-onnx`` package) with Pipecat's ``SegmentedSTTService``
+interface, allowing fast, on-device transcription of audio segments produced
+by VAD-driven pipelines.
+"""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+import numpy as np
+from loguru import logger
+from pipecat.frames.frames import ErrorFrame, Frame, TranscriptionFrame
+from pipecat.services.settings import STTSettings, assert_given
+from pipecat.services.stt_service import SegmentedSTTService
+from pipecat.transcriptions.language import Language, resolve_language
+from pipecat.utils.time import time_now_iso8601
+from pipecat.utils.tracing.service_decorators import traced_stt
+
+if TYPE_CHECKING:
+    try:
+        from moonshine_onnx import MoonshineOnnxModel
+    except ModuleNotFoundError as e:
+        logger.error(f"Exception: {e}")
+        logger.error(
+            "In order to use Moonshine STT, you need to `pip install useful-moonshine-onnx`."
+        )
+        raise Exception(f"Missing module: {e}") from e
+
+
+# Moonshine's input contract: 16 kHz, mono, float32 in [-1, 1].
+MOONSHINE_SAMPLE_RATE = 16000
+
+# Per moonshine_onnx.transcribe.assert_audio_size: 0.1s < duration < 64s.
+_MIN_AUDIO_SECONDS = 0.1
+_MAX_AUDIO_SECONDS = 64.0
+
+
+class Model(Enum):
+    """Moonshine model selection options.
+
+    Parameters:
+        TINY_EN: 26 M-parameter English-only model, fastest inference.
+        BASE_EN: 58 M-parameter English-only model, better accuracy.
+
+    Note:
+        Only the English models are enumerated here because their weights are
+        released under the permissive MIT license. Multilingual Moonshine
+        weights (Spanish, Japanese, Arabic, Korean, Mandarin, etc.) are
+        released under the non-commercial **Moonshine Community License** and
+        must be opted into explicitly by passing the model-name string
+        directly. By doing so you accept the upstream license terms.
+    """
+
+    TINY_EN = "moonshine/tiny"
+    BASE_EN = "moonshine/base"
+
+
+def language_to_moonshine_language(language: Language) -> str | None:
+    """Map a pipecat ``Language`` enum to a Moonshine language code.
+
+    The ONNX models bundled with ``useful-moonshine-onnx`` are currently
+    English-only; this helper returns ``"en"`` for any English variant and
+    ``None`` for anything else (logging a warning via ``resolve_language``).
+
+    Args:
+        language: A ``Language`` enum value.
+
+    Returns:
+        The Moonshine language code, or ``None`` if not supported.
+    """
+    return resolve_language(language, {Language.EN: "en"}, use_base_code=True)
+
+
+@dataclass
+class MoonshineSTTSettings(STTSettings):
+    """Runtime-updatable settings for ``MoonshineSTTService``.
+
+    Inherits the standard ``model`` and ``language`` fields from
+    ``STTSettings``. The Moonshine ONNX inference path currently exposes no
+    additional runtime knobs; add new fields here as the upstream API grows.
+    """
+
+
+class MoonshineSTTService(SegmentedSTTService):
+    """Transcribe audio with a locally-downloaded Moonshine ONNX model.
+
+    Moonshine is a family of small, fast ASR models optimized for on-device
+    inference. This service wraps :func:`moonshine_onnx.transcribe` and is
+    designed to plug directly into Pipecat pipelines that perform VAD
+    upstream: each speech segment yielded by VAD is fed to ``run_stt`` as
+    16-bit PCM, converted to float32 in ``[-1, 1]``, and decoded into a
+    single final ``TranscriptionFrame``.
+
+    The first time a given model is requested it is downloaded from
+    ``huggingface.co/UsefulSensors/moonshine``. Subsequent runs read from the
+    local Hugging Face cache.
+
+    Audio format: 16 kHz, mono, 16-bit signed PCM. Pipecat's default
+    audio-in sample rate matches this; other rates will trigger a warning
+    and may degrade accuracy.
+
+    Example::
+
+        from pipecat_moonshine import MoonshineSTTService, Model
+
+        stt = MoonshineSTTService(model=Model.TINY_EN)
+        pipeline = Pipeline([transport.input(), vad_processor, stt, llm, ...])
+    """
+
+    Settings = MoonshineSTTSettings
+    _settings: Settings
+
+    def __init__(
+        self,
+        *,
+        model: str | Model | None = None,
+        settings: Settings | None = None,
+        **kwargs,
+    ):
+        """Initialize the Moonshine STT service.
+
+        Args:
+            model: Convenience shortcut for setting the model. Accepts a
+                ``Model`` enum value or a model-name string (e.g.
+                ``"moonshine/tiny"``). Equivalent to passing
+                ``settings=MoonshineSTTService.Settings(model=...)``.
+            settings: Runtime-updatable settings. When both ``settings`` and
+                ``model`` are provided, fields in ``settings`` win.
+            **kwargs: Additional arguments passed to ``SegmentedSTTService``.
+        """
+        # 1. Hardcoded defaults.
+        default_settings = self.Settings(
+            model=Model.TINY_EN.value,
+            language=Language.EN,
+        )
+
+        # 2. Convenience kwarg overrides.
+        if model is not None:
+            default_settings.model = model.value if isinstance(model, Model) else model
+
+        # 3. Settings delta (canonical API, always wins).
+        if settings is not None:
+            default_settings.apply_update(settings)
+
+        super().__init__(settings=default_settings, **kwargs)
+
+        self._model_obj: MoonshineOnnxModel | None = None
+        self._sample_rate_warned = False
+        self._load()
+
+    def can_generate_metrics(self) -> bool:
+        """Indicate whether this service emits processing metrics.
+
+        Returns:
+            ``True`` — Moonshine STT records per-segment processing time.
+        """
+        return True
+
+    def language_to_service_language(self, language: Language) -> str | None:
+        """Map a pipecat ``Language`` to a Moonshine language code.
+
+        Args:
+            language: The ``Language`` enum value to convert.
+
+        Returns:
+            The Moonshine code, or ``None`` if unsupported.
+        """
+        return language_to_moonshine_language(language)
+
+    def _load(self):
+        """Load the configured Moonshine ONNX model.
+
+        Note:
+            The first invocation for a given model downloads weights from the
+            Hugging Face Hub (``UsefulSensors/moonshine``); subsequent calls
+            reuse the local cache.
+        """
+        try:
+            from moonshine_onnx import MoonshineOnnxModel
+
+            model_name = assert_given(self._settings.model)
+            if model_name is None:
+                raise ValueError("Moonshine model must be specified")
+            logger.debug(f"Loading Moonshine model {model_name}...")
+            self._model_obj = MoonshineOnnxModel(model_name=model_name)
+            logger.debug(f"Loaded Moonshine model {model_name}")
+        except ModuleNotFoundError as e:
+            logger.error(f"Exception: {e}")
+            logger.error(
+                "In order to use Moonshine STT, you need to `pip install useful-moonshine-onnx`."
+            )
+            self._model_obj = None
+
+    @traced_stt
+    async def _handle_transcription(
+        self, transcript: str, is_final: bool, language: Language | None = None
+    ):
+        """Handle a transcription result with tracing.
+
+        Decorated with ``@traced_stt`` so OpenTelemetry spans are emitted
+        when Pipecat tracing is enabled. The body is intentionally empty;
+        the decorator does the work.
+        """
+        pass
+
+    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
+        """Transcribe a single VAD-delimited speech segment.
+
+        Args:
+            audio: Raw 16-bit signed PCM audio bytes for one speech segment.
+
+        Yields:
+            Either a single ``TranscriptionFrame`` containing the decoded
+            text, or an ``ErrorFrame`` on failure. Out-of-range segments
+            (too short or too long for Moonshine) are silently dropped.
+        """
+        if self._model_obj is None:
+            yield ErrorFrame("Moonshine model not available")
+            return
+
+        if not self._sample_rate_warned and self.sample_rate != MOONSHINE_SAMPLE_RATE:
+            logger.warning(
+                f"Moonshine expects {MOONSHINE_SAMPLE_RATE} Hz audio; pipeline is "
+                f"providing {self.sample_rate} Hz. Transcription quality may degrade."
+            )
+            self._sample_rate_warned = True
+
+        await self.start_processing_metrics()
+
+        # Signed 16-bit PCM -> float32 in [-1, 1].
+        audio_float = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / 32768.0
+
+        duration = audio_float.size / max(self.sample_rate, 1)
+        if duration <= _MIN_AUDIO_SECONDS or duration >= _MAX_AUDIO_SECONDS:
+            logger.debug(
+                f"Skipping Moonshine transcription: segment duration {duration:.2f}s "
+                f"is outside the supported ({_MIN_AUDIO_SECONDS}, {_MAX_AUDIO_SECONDS}) range."
+            )
+            await self.stop_processing_metrics()
+            return
+
+        try:
+            import moonshine_onnx
+
+            results = await asyncio.to_thread(
+                moonshine_onnx.transcribe, audio_float, self._model_obj
+            )
+        except Exception as e:
+            await self.stop_processing_metrics()
+            logger.exception(f"{self} Moonshine transcription error")
+            yield ErrorFrame(error=f"Moonshine transcription error: {e}")
+            return
+
+        await self.stop_processing_metrics()
+
+        text = (results[0] if results else "").strip()
+        if not text:
+            return
+
+        # STTSettings normalises ``language`` to a service-code string during
+        # init, so ``self._settings.language`` is e.g. ``"en"`` rather than
+        # ``Language.EN``. Map common codes back to the enum for the frame;
+        # anything we don't recognise (e.g. a user-overridden code) falls
+        # through as None — runtime callers can still read it from the frame.
+        language_setting = assert_given(self._settings.language)
+        language: Language | None
+        if isinstance(language_setting, Language):
+            language = language_setting
+        elif language_setting == "en":
+            language = Language.EN
+        else:
+            language = None
+
+        await self._handle_transcription(text, True, language)
+        logger.debug(f"Transcription: [{text}]")
+        yield TranscriptionFrame(text, self._user_id, time_now_iso8601(), language)

pipecat_moonshine-0.1.0/src/pipecat_moonshine.egg-info/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: pipecat-moonshine
+Version: 0.1.0
+Summary: Moonshine ASR (speech-to-text) community integration for Pipecat
+Author: pipecat-moonshine contributors
+License: BSD-2-Clause
+Project-URL: Homepage, https://github.com/ubopod/pipecat-moonshine
+Project-URL: Source, https://github.com/ubopod/pipecat-moonshine
+Project-URL: Issues, https://github.com/ubopod/pipecat-moonshine/issues
+Project-URL: Changelog, https://github.com/ubopod/pipecat-moonshine/blob/main/CHANGELOG.md
+Keywords: pipecat,moonshine,asr,stt,speech-to-text,voice,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pipecat-ai[websockets-base]>=1.2.1
+Requires-Dist: useful-moonshine-onnx>=20251121
+Requires-Dist: numpy<3,>=1.26.4
+Requires-Dist: loguru<1,>=0.7.0
+Provides-Extra: examples
+Requires-Dist: python-dotenv<2,>=1.0.0; extra == "examples"
+Requires-Dist: pyaudio~=0.2.14; extra == "examples"
+Provides-Extra: dev
+Requires-Dist: ruff<1,>=0.12.11; extra == "dev"
+Requires-Dist: pytest<10,>=9.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio<2,>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# pipecat-moonshine
+
+[Moonshine ASR](https://github.com/moonshine-ai/moonshine) speech-to-text
+integration for [Pipecat](https://github.com/pipecat-ai/pipecat).
+
+Moonshine is a family of small, fast automatic-speech-recognition models
+optimized for resource-constrained devices. The Tiny English model is roughly
+26 M parameters, the Base English model roughly 58 M — both run on CPU via
+ONNX Runtime with no GPU required. That makes Moonshine an attractive choice
+for low-latency, on-device transcription in Pipecat pipelines that already
+handle VAD upstream.
+
+This package provides `MoonshineSTTService`, a `SegmentedSTTService`
+subclass that plugs straight into any Pipecat pipeline.
+
+## Status
+
+Community-maintained integration. See
+[Pipecat's Community Integrations guide](https://github.com/pipecat-ai/pipecat/blob/main/COMMUNITY_INTEGRATIONS.md)
+for what that means — in short, the Pipecat team does not maintain or
+support this package; please file issues here.
+
+**Tested with Pipecat v1.2.1.**
+
+## Installation
+
+```bash
+pip install pipecat-moonshine
+```
+
+This pulls in [`useful-moonshine-onnx`](https://pypi.org/project/useful-moonshine-onnx/)
+and `pipecat-ai` automatically. The first time you instantiate the service,
+the chosen model weights are downloaded from Hugging Face
+(`UsefulSensors/moonshine`) and cached locally.
+
+For the included foundational example you also need the local-audio extras:
+
+```bash
+pip install 'pipecat-moonshine[examples]'
+```
+
+## Usage
+
+```python
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat_moonshine import MoonshineSTTService, Model
+
+stt = MoonshineSTTService(model=Model.TINY_EN)
+
+pipeline = Pipeline([
+    transport.input(),
+    vad_processor,     # MUST run upstream of the STT — see below
+    stt,
+    # ... downstream processors
+])
+```
+
+`MoonshineSTTService` subclasses `SegmentedSTTService`, so a VAD-driven
+processor (e.g. `VADProcessor` with `SileroVADAnalyzer`) must produce
+`VADUserStartedSpeakingFrame` / `VADUserStoppedSpeakingFrame` upstream of
+it. Each detected speech segment is decoded into a single final
+`TranscriptionFrame` — Moonshine does not emit interim results.
+
+### Configuring the model at runtime
+
+Pass an explicit model or a fully-built settings object:
+
+```python
+# Convenience kwarg
+stt = MoonshineSTTService(model=Model.BASE_EN)
+
+# Or via Settings (e.g. when you want to update at runtime)
+stt = MoonshineSTTService(
+    settings=MoonshineSTTService.Settings(model="moonshine/base"),
+)
+```
+
+## Running the example
+
+```bash
+git clone https://github.com/ubopod/pipecat-moonshine
+cd pipecat-moonshine
+pip install -e '.[examples]'
+python examples/transcription-moonshine.py
+```
+
+Speak into your default mic; lines like `Transcription: hello world` will be
+printed for each detected utterance.
+
+## Audio format requirements
+
+Moonshine expects **16 kHz, mono, 16-bit signed PCM** input. Pipecat's
+default `LocalAudioTransport` and most WebRTC transports already provide
+this. If your pipeline runs at a different sample rate the service will log
+a warning on the first segment and transcription quality may degrade — add
+a resampler upstream if you need a different rate.
+
+Moonshine also enforces a per-segment duration window: speech segments
+shorter than 0.1 s or longer than 64 s are silently dropped (the service
+logs at `DEBUG` level when this happens).
+
+## Supported models
+
+| Constant         | Model name         | Params | Notes                                |
+| ---------------- | ------------------ | ------ | ------------------------------------ |
+| `Model.TINY_EN`  | `moonshine/tiny`   | 26 M   | English-only, MIT-licensed weights.  |
+| `Model.BASE_EN`  | `moonshine/base`   | 58 M   | English-only, MIT-licensed weights.  |
+
+### Multilingual models — important license note
+
+Moonshine also publishes multilingual checkpoints (Spanish, Japanese,
+Arabic, Korean, Mandarin, Vietnamese, Ukrainian, …). Those weights are
+released under the **Moonshine Community License**, which is *non-commercial*.
+
+For that reason they are intentionally **not** enumerated in the `Model`
+enum. If you want to use one you must:
+
+1. Read and accept the upstream Moonshine Community License.
+2. Pass the model name as a string explicitly, e.g.:
+
+   ```python
+   stt = MoonshineSTTService(model="moonshine/base")
+   # then load the appropriate language checkpoint via your own download flow
+   ```
+
+This package does not bundle, mirror, or auto-download non-commercial
+weights, and the maintainers make no representation that doing so complies
+with your use case.
+
+## Frames
+
+| In                                  | Out                                                        |
+| ----------------------------------- | ---------------------------------------------------------- |
+| `VADUserStartedSpeakingFrame`       | (no output — buffers audio internally)                     |
+| `VADUserStoppedSpeakingFrame`       | one `TranscriptionFrame` per segment (final), or nothing   |
+| Any non-VAD audio                   | buffered/forwarded according to `SegmentedSTTService`      |
+
+Errors during transcription are pushed as `ErrorFrame`s; the pipeline is
+not torn down so other services can continue.
+
+## Metrics
+
+`can_generate_metrics()` returns `True`. Per-segment processing time is
+recorded via `start_processing_metrics` / `stop_processing_metrics`, so
+enabling metrics on your `PipelineTask` will surface Moonshine latency
+alongside the rest of your pipeline.
+
+## Maintainer
+
+Community-maintained. Not affiliated with Moonshine AI or Daily.
+
+## License
+
+BSD-2-Clause — see [LICENSE](./LICENSE). Note that the Moonshine model
+*weights* are governed by their own license (MIT for English models,
+Moonshine Community License for others) — see the section above.
+
+## Versioning and changelog
+
+See [CHANGELOG.md](./CHANGELOG.md). This package follows semantic
+versioning.
+
+## Getting help
+
+- Pipecat Discord: <https://discord.gg/pipecat> (`#community-integrations`)
+- Pipecat changelog (track upstream changes that may affect this integration):
+  <https://github.com/pipecat-ai/pipecat/blob/main/CHANGELOG.md>
+- Issues for this integration: file them in this repo.

pipecat_moonshine-0.1.0/src/pipecat_moonshine.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/pipecat_moonshine/__init__.py
+src/pipecat_moonshine/py.typed
+src/pipecat_moonshine/stt.py
+src/pipecat_moonshine.egg-info/PKG-INFO
+src/pipecat_moonshine.egg-info/SOURCES.txt
+src/pipecat_moonshine.egg-info/dependency_links.txt
+src/pipecat_moonshine.egg-info/requires.txt
+src/pipecat_moonshine.egg-info/top_level.txt

pipecat_moonshine-0.1.0/src/pipecat_moonshine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pipecat_moonshine-0.1.0/src/pipecat_moonshine.egg-info/requires.txt

@@ -0,0 +1,13 @@
+pipecat-ai[websockets-base]>=1.2.1
+useful-moonshine-onnx>=20251121
+numpy<3,>=1.26.4
+loguru<1,>=0.7.0
+
+[dev]
+ruff<1,>=0.12.11
+pytest<10,>=9.0.0
+pytest-asyncio<2,>=1.0.0
+
+[examples]
+python-dotenv<2,>=1.0.0
+pyaudio~=0.2.14

pipecat_moonshine-0.1.0/src/pipecat_moonshine.egg-info/top_level.txt

@@ -0,0 +1 @@
+pipecat_moonshine