wyoming-microsoft-stt 1.3.3__py3-none-any.whl

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests."""

tests/conftest.py

@@ -0,0 +1,15 @@
+"""Fixtures for tests."""
+
+from wyoming_microsoft_stt import SpeechConfig
+import pytest
+import os
+
+
+@pytest.fixture
+def microsoft_stt_args():
+    """Return MicrosoftSTT instance."""
+    args = SpeechConfig(
+        subscription_key=os.environ.get("SPEECH_KEY"),
+        service_region=os.environ.get("SPEECH_REGION"),
+    )
+    return args

tests/test_microsoft_stt.py

@@ -0,0 +1,19 @@
+"""Tests for the MicrosoftTTS class."""
+
+from wyoming_microsoft_stt.microsoft_stt import MicrosoftSTT
+
+
+def test_initialize(microsoft_stt_args):
+    """Test initialization."""
+    microsoft_stt = MicrosoftSTT(microsoft_stt_args)
+    assert microsoft_stt.speech_config is not None
+
+
+def test_set_profanity(microsoft_stt_args):
+    """Test set_profanity."""
+    microsoft_stt = MicrosoftSTT(microsoft_stt_args)
+    assert microsoft_stt.speech_config is not None
+
+    profanity = "masked"
+    microsoft_stt.set_profanity(profanity)
+    # There is currently no way to check the set profanity level

tests/test_multilanguage.py

@@ -0,0 +1,109 @@
+"""Tests for the Microsoft STT service."""
+
+import asyncio
+import re
+import sys
+import os
+import wave
+from asyncio.subprocess import PIPE
+from pathlib import Path
+
+
+import pytest
+from wyoming.asr import Transcript
+from wyoming.audio import AudioStart, AudioStop, wav_to_chunks
+from wyoming.event import async_read_event, async_write_event
+from wyoming.info import Describe, Info
+
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+_DIR = Path(__file__).parent
+_PROGRAM_DIR = _DIR.parent
+_LOCAL_DIR = _PROGRAM_DIR / "local"
+_SAMPLES_PER_CHUNK = 1024
+
+# Need to give time for the model to download
+_START_TIMEOUT = 60
+_TRANSCRIBE_TIMEOUT = 60
+
+
+@pytest.mark.asyncio
+async def test_multilanguage() -> None:
+    """Test the transcription."""
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-m",
+        "wyoming_microsoft_stt",
+        "--uri",
+        "stdio://",
+        "--language",
+        "en-GB",
+        "nl-NL",
+        "--service-region",
+        os.environ.get("SPEECH_REGION"),
+        "--subscription-key",
+        os.environ.get("SPEECH_KEY"),
+        "--debug",
+        stdin=PIPE,
+        stdout=PIPE,
+    )
+    assert proc.stdin is not None
+    assert proc.stdout is not None
+
+    # Check info
+    await async_write_event(Describe().event(), proc.stdin)
+    while True:
+        event = await asyncio.wait_for(
+            async_read_event(proc.stdout), timeout=_START_TIMEOUT
+        )
+        assert event is not None
+
+        if not Info.is_type(event.type):
+            continue
+
+        info = Info.from_event(event)
+        assert len(info.asr) == 1, "Expected one asr service"
+        asr = info.asr[0]
+        assert len(asr.models) > 0, "Expected at least one model"
+        break
+
+    # Test known WAV
+    with wave.open(str(_DIR / "zet_het_licht_aan.wav"), "rb") as example_wav:
+        await async_write_event(
+            AudioStart(
+                rate=example_wav.getframerate(),
+                width=example_wav.getsampwidth(),
+                channels=example_wav.getnchannels(),
+            ).event(),
+            proc.stdin,
+        )
+        for chunk in wav_to_chunks(example_wav, _SAMPLES_PER_CHUNK):
+            await async_write_event(chunk.event(), proc.stdin)
+            _LOGGER.info("Sent bytes of audio data to the server")
+
+        await async_write_event(AudioStop().event(), proc.stdin)
+        _LOGGER.info("Sent audio stop event to the server")
+
+    while True:
+        event = await asyncio.wait_for(
+            async_read_event(proc.stdout), timeout=_TRANSCRIBE_TIMEOUT
+        )
+        assert event is not None
+
+        if not Transcript.is_type(event.type):
+            continue
+
+        transcript = Transcript.from_event(event)
+        _LOGGER.info(f"Received transcript: {transcript.text}")
+        text = transcript.text.lower().strip()
+        text = re.sub(r"[^a-z ]", "", text)
+        assert text == "zet het licht aan"
+        break
+
+    # Need to close stdin for graceful termination
+    proc.stdin.close()
+    _, stderr = await proc.communicate()
+
+    assert proc.returncode == 0, stderr.decode()

tests/test_transcribe.py

@@ -0,0 +1,114 @@
+"""Tests for the Microsoft STT service."""
+
+import asyncio
+import re
+import sys
+import os
+import wave
+from asyncio.subprocess import PIPE
+from pathlib import Path
+
+
+import pytest
+from wyoming.asr import Transcript
+from wyoming.audio import AudioStart, AudioStop, wav_to_chunks
+from wyoming.event import async_read_event, async_write_event
+from wyoming.info import Describe, Info
+
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+_DIR = Path(__file__).parent
+_PROGRAM_DIR = _DIR.parent
+_LOCAL_DIR = _PROGRAM_DIR / "local"
+_SAMPLES_PER_CHUNK = 1024
+
+# Need to give time for the model to download
+_START_TIMEOUT = 60
+_TRANSCRIBE_TIMEOUT = 60
+
+
+@pytest.mark.asyncio
+async def test_transcribe() -> None:
+    """Test the transcription."""
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-m",
+        "wyoming_microsoft_stt",
+        "--uri",
+        "stdio://",
+        "--language",
+        "en-GB",
+        "--service-region",
+        os.environ.get("SPEECH_REGION"),
+        "--subscription-key",
+        os.environ.get("SPEECH_KEY"),
+        "--debug",
+        stdin=PIPE,
+        stdout=PIPE,
+    )
+    assert proc.stdin is not None
+    assert proc.stdout is not None
+
+    # Check info
+    await async_write_event(Describe().event(), proc.stdin)
+    while True:
+        event = await asyncio.wait_for(
+            async_read_event(proc.stdout), timeout=_START_TIMEOUT
+        )
+        assert event is not None
+
+        if not Info.is_type(event.type):
+            continue
+
+        info = Info.from_event(event)
+        assert len(info.asr) == 1, "Expected one asr service"
+        asr = info.asr[0]
+        assert len(asr.models) > 0, "Expected at least one model"
+        break
+
+    # Test known WAV
+    with wave.open(str(_DIR / "long_text.wav"), "rb") as example_wav:
+        await async_write_event(
+            AudioStart(
+                rate=example_wav.getframerate(),
+                width=example_wav.getsampwidth(),
+                channels=example_wav.getnchannels(),
+            ).event(),
+            proc.stdin,
+        )
+        for chunk in wav_to_chunks(example_wav, _SAMPLES_PER_CHUNK):
+            await async_write_event(chunk.event(), proc.stdin)
+            _LOGGER.info("Sent bytes of audio data to the server")
+
+        await async_write_event(AudioStop().event(), proc.stdin)
+        _LOGGER.info("Sent audio stop event to the server")
+
+    while True:
+        event = await asyncio.wait_for(
+            async_read_event(proc.stdout), timeout=_TRANSCRIBE_TIMEOUT
+        )
+        assert event is not None
+
+        if not Transcript.is_type(event.type):
+            continue
+
+        transcript = Transcript.from_event(event)
+        text = transcript.text.lower().strip()
+        text = re.sub(r"[^a-z ]", "", text)
+        _LOGGER.info(f"Received transcript: {text}")
+
+        original_text = "The Netherlands, informally Holland, is a country in Northwestern Europe with overseas territories in the Caribbean. It is the largest of the four constituent countries of the Kingdom of the Netherlands. The Netherlands consists of 12 provinces. It borders Germany to the east and Belgium to the south, with the North Sea coastline to the north and west. It shares maritime borders with the United Kingdom, Germany, and Belgium."
+        # Remove punctuation and convert to lowercase
+        original_text = original_text.lower()
+        original_text = re.sub(r"[^a-z ]", "", original_text)
+
+        assert text == original_text
+        break
+
+    # Need to close stdin for graceful termination
+    proc.stdin.close()
+    _, stderr = await proc.communicate()
+
+    assert proc.returncode == 0, stderr.decode()

wyoming_microsoft_stt/__init__.py

@@ -0,0 +1,159 @@
+"""Wyoming server for Microsoft STT."""
+
+from typing import Literal
+from pydantic import BaseModel
+
+
+class SpeechConfig(BaseModel):
+    """Speech configuration."""
+
+    subscription_key: str
+    service_region: str
+    profanity: Literal["off", "masked", "removed"] = "masked"
+    language: list[
+        Literal[
+            "af-ZA",
+            "am-ET",
+            "ar-AE",
+            "ar-BH",
+            "ar-DZ",
+            "ar-EG",
+            "ar-IL",
+            "ar-IQ",
+            "ar-JO",
+            "ar-KW",
+            "ar-LB",
+            "ar-LY",
+            "ar-MA",
+            "ar-OM",
+            "ar-PS",
+            "ar-QA",
+            "ar-SA",
+            "ar-SY",
+            "ar-TN",
+            "ar-YE",
+            "az-AZ",
+            "bg-BG",
+            "bn-IN",
+            "bs-BA",
+            "ca-ES",
+            "cs-CZ",
+            "cy-GB",
+            "da-DK",
+            "de-AT",
+            "de-CH",
+            "de-DE",
+            "el-GR",
+            "en-AU",
+            "en-CA",
+            "en-GB",
+            "en-GH",
+            "en-HK",
+            "en-IE",
+            "en-IN",
+            "en-KE",
+            "en-NG",
+            "en-NZ",
+            "en-PH",
+            "en-SG",
+            "en-TZ",
+            "en-US",
+            "en-ZA",
+            "es-AR",
+            "es-BO",
+            "es-CL",
+            "es-CO",
+            "es-CR",
+            "es-CU",
+            "es-DO",
+            "es-EC",
+            "es-ES",
+            "es-GQ",
+            "es-GT",
+            "es-HN",
+            "es-MX",
+            "es-NI",
+            "es-PA",
+            "es-PE",
+            "es-PR",
+            "es-PY",
+            "es-SV",
+            "es-US",
+            "es-UY",
+            "es-VE",
+            "et-EE",
+            "eu-ES",
+            "fa-IR",
+            "fi-FI",
+            "fil-PH",
+            "fr-BE",
+            "fr-CA",
+            "fr-CH",
+            "fr-FR",
+            "ga-IE",
+            "gl-ES",
+            "gu-IN",
+            "he-IL",
+            "hi-IN",
+            "hr-HR",
+            "hu-HU",
+            "hy-AM",
+            "id-ID",
+            "is-IS",
+            "it-CH",
+            "it-IT",
+            "ja-JP",
+            "jv-ID",
+            "ka-GE",
+            "kk-KZ",
+            "km-KH",
+            "kn-IN",
+            "ko-KR",
+            "lo-LA",
+            "lt-LT",
+            "lv-LV",
+            "mk-MK",
+            "ml-IN",
+            "mn-MN",
+            "mr-IN",
+            "ms-MY",
+            "mt-MT",
+            "my-MM",
+            "nb-NO",
+            "ne-NP",
+            "nl-BE",
+            "nl-NL",
+            "pa-IN",
+            "pl-PL",
+            "ps-AF",
+            "pt-BR",
+            "pt-PT",
+            "ro-RO",
+            "ru-RU",
+            "si-LK",
+            "sk-SK",
+            "sl-SI",
+            "so-SO",
+            "sq-AL",
+            "sr-RS",
+            "sv-SE",
+            "sw-KE",
+            "sw-TZ",
+            "ta-IN",
+            "te-IN",
+            "th-TH",
+            "tr-TR",
+            "uk-UA",
+            "ur-IN",
+            "uz-UZ",
+            "vi-VN",
+            "wuu-CN",
+            "yue-CN",
+            "zh-CN",
+            "zh-CN-SHANDONG",
+            "zh-CN-SICHUAN",
+            "zh-HK",
+            "zh-TW",
+            "zu-ZA",
+        ]
+    ] = ["en-US"]

wyoming_microsoft_stt/__main__.py

@@ -0,0 +1,176 @@
+import argparse  # noqa: D100
+import asyncio
+import logging
+from functools import partial
+import contextlib
+import os  # Import to access environment variables
+import signal
+import re
+
+from wyoming.info import AsrModel, AsrProgram, Attribution, Info
+from wyoming.server import AsyncServer
+
+from .download import get_languages
+from .microsoft_stt import MicrosoftSTT
+from .handler import MicrosoftEventHandler
+from .version import __version__
+from . import SpeechConfig
+
+_LOGGER = logging.getLogger(__name__)
+
+stop_event = asyncio.Event()
+
+
+def handle_stop_signal(*args):
+    """Handle shutdown signal and set the stop event."""
+    _LOGGER.info("Received stop signal. Shutting down...")
+    stop_event.set()
+
+
+def parse_arguments():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--service-region",
+        default=os.getenv("AZURE_SERVICE_REGION"),
+        help="Microsoft Azure region (e.g., westus2)",
+    )
+    parser.add_argument(
+        "--subscription-key",
+        default=os.getenv("AZURE_SUBSCRIPTION_KEY"),
+        help="Microsoft Azure subscription key",
+    )
+    parser.add_argument(
+        "--uri", default="tcp://0.0.0.0:10300", help="unix:// or tcp://"
+    )
+    parser.add_argument(
+        "--download-dir",
+        default="/tmp/",
+        help="Directory to download languages.json into (default: /tmp/)",
+    )
+    parser.add_argument(
+        "--language",
+        nargs="+",
+        default=["en-GB"],
+        help="List of languages to set for transcription (e.g., en-US fr-FR es-ES)",
+    )
+    parser.add_argument(
+        "--update-languages",
+        action="store_true",
+        help="Download latest languages.json during startup",
+    )
+    parser.add_argument(
+        "--profanity",
+        default="masked",
+        choices=["masked", "removed", "off"],
+        help="Profanity setting for speech recognition",
+    )
+    parser.add_argument("--debug", action="store_true", help="Log DEBUG messages")
+    return parser.parse_args()
+
+
+def validate_args(args):
+    """Validate command-line arguments."""
+    if not args.service_region or not args.subscription_key:
+        raise ValueError(
+            "Both --service-region and --subscription-key must be provided either as command-line arguments or environment variables."
+        )
+    # Reinstate key validation with more flexibility to accommodate complex keys
+    if not re.match(r"^[A-Za-z0-9\-_]{40,}$", args.subscription_key):
+        _LOGGER.warning(
+            "The subscription key does not match the expected format but will attempt to initialize."
+        )
+
+
+async def main() -> None:
+    """Start Wyoming Microsoft STT server."""
+    args = parse_arguments()
+    validate_args(args)
+
+    speech_config = SpeechConfig(
+        subscription_key=args.subscription_key,
+        service_region=args.service_region,
+        profanity=args.profanity,
+        language=args.language,
+    )
+
+    # Set up logging
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
+    _LOGGER.debug("Arguments parsed successfully.")
+
+    # Load languages
+    try:
+        _LOGGER.info("Starting language loading process.")
+        languages = get_languages(
+            args.download_dir,
+            update_languages=args.update_languages,
+            region=args.service_region,
+            key=args.subscription_key,
+        )
+        _LOGGER.info("Languages loaded successfully.")
+    except Exception as e:
+        _LOGGER.error(f"Failed to load languages: {e}")
+        return
+
+    wyoming_info = Info(
+        asr=[
+            AsrProgram(
+                name="Microsoft",
+                description="Microsoft speech transcription",
+                attribution=Attribution(
+                    name="Hugo Bloem",
+                    url="https://github.com/hugobloem/wyoming-microsoft-stt/",
+                ),
+                version=__version__,
+                installed=True,
+                models=[
+                    AsrModel(
+                        name="Microsoft STT",
+                        description="Microsoft speech transcription",
+                        attribution=Attribution(
+                            name="Hugo Bloem",
+                            url="https://github.com/hugobloem/wyoming-microsoft-stt/",
+                        ),
+                        version=__version__,
+                        installed=True,
+                        languages=languages,
+                    )
+                ],
+            )
+        ],
+    )
+
+    # Load Microsoft STT model
+    try:
+        _LOGGER.debug("Loading Microsoft STT")
+        stt_model = MicrosoftSTT(speech_config)
+        _LOGGER.info("Microsoft STT model loaded successfully.")
+    except Exception as e:
+        _LOGGER.error(f"Failed to load Microsoft STT model: {e}")
+        return
+
+    # Initialize server and run
+    server = AsyncServer.from_uri(args.uri)
+    _LOGGER.info("Ready")
+    model_lock = asyncio.Lock()
+    try:
+        await server.run(
+            partial(
+                MicrosoftEventHandler,
+                wyoming_info,
+                args,
+                stt_model,
+                model_lock,
+            )
+        )
+    except Exception as e:
+        _LOGGER.error(f"An error occurred while running the server: {e}")
+
+
+if __name__ == "__main__":
+    # Set up signal handling for graceful shutdown
+    signal.signal(signal.SIGTERM, handle_stop_signal)
+    signal.signal(signal.SIGINT, handle_stop_signal)
+
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(main())

wyoming_microsoft_stt/download.py

@@ -0,0 +1,92 @@
+"""Utility for downloading Microsoft STT languages."""
+
+import logging
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote, urlsplit, urlunsplit
+from urllib.request import urlopen, Request
+import json
+import time
+from urllib.error import URLError
+
+URL_FORMAT = "https://{region}.cognitiveservices.azure.com/speechtotext/v3.1/transcriptions/locales"
+URL_HEADER = "Ocp-Apim-Subscription-Key"
+
+_DIR = Path(__file__).parent
+_LOGGER = logging.getLogger(__name__)
+
+
+def _quote_url(url: str) -> str:
+    """Quote file part of URL in case it contains UTF-8 characters."""
+    parts = list(urlsplit(url))
+    parts[2] = quote(parts[2])
+    return urlunsplit(parts)
+
+
+def transform_languages_files(response):
+    """Transform the languages.json file from the Microsoft API to the format used by Piper."""
+    languages = json.load(response)
+    return languages
+
+
+def get_languages(
+    download_dir: str | Path,
+    update_languages: bool = False,
+    region: str = "westus",
+    key: str = "",
+) -> dict[str, Any]:
+    """Load available languages from downloaded or embedded JSON file."""
+    download_dir = Path(download_dir)
+    if not download_dir.exists():
+        download_dir.mkdir(parents=True)
+    languages_download = download_dir.joinpath("languages.json")
+
+    if update_languages:
+        # Download latest languages.json with retry mechanism
+        MAX_RETRIES = 3
+        RETRY_DELAY = 5  # seconds
+        for attempt in range(MAX_RETRIES):
+            try:
+                languages_url = URL_FORMAT.format(region=region)
+                languages_hdr = {URL_HEADER: key}
+                _LOGGER.debug("Downloading %s to %s", languages_url, languages_download)
+                req = Request(_quote_url(languages_url), headers=languages_hdr)
+                with urlopen(req) as response, open(
+                    languages_download, "w"
+                ) as download_file:
+                    json.dump(
+                        transform_languages_files(response), download_file, indent=4
+                    )
+                _LOGGER.info("Languages downloaded successfully.")
+                break
+            except URLError as e:
+                _LOGGER.warning(
+                    "Failed to download languages.json (attempt %d/%d): %s",
+                    attempt + 1,
+                    MAX_RETRIES,
+                    e,
+                )
+                time.sleep(RETRY_DELAY)
+            except Exception as e:
+                _LOGGER.exception("Failed to download languages.json: %s", e)
+                _LOGGER.error("Failed to update languages list")
+                return {}
+
+    # Prefer downloaded file to embedded
+    if languages_download.exists():
+        try:
+            _LOGGER.debug("Loading %s", languages_download)
+            with open(languages_download, encoding="utf-8") as languages_file:
+                return json.load(languages_file)
+        except Exception:
+            _LOGGER.exception("Failed to load %s", languages_download)
+
+    # Fall back to embedded
+    languages_embedded = _DIR / "languages.json"
+    try:
+        _LOGGER.debug("Loading %s", languages_embedded)
+        with open(languages_embedded, encoding="utf-8") as languages_file:
+            return json.load(languages_file)
+    except Exception:
+        _LOGGER.exception("Failed to load embedded languages.json")
+        return {}

wyoming_microsoft_stt/handler.py

@@ -0,0 +1,105 @@
+"""Event handler for clients of the server."""
+
+import argparse
+import asyncio
+import logging
+import time
+
+from wyoming.asr import Transcribe, Transcript
+from wyoming.audio import AudioChunk, AudioStart, AudioStop
+from wyoming.event import Event
+from wyoming.info import Describe, Info
+from wyoming.server import AsyncEventHandler
+
+from .microsoft_stt import MicrosoftSTT
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MicrosoftEventHandler(AsyncEventHandler):
+    """Event handler for clients."""
+
+    def __init__(
+        self,
+        wyoming_info: Info,
+        cli_args: argparse.Namespace,
+        model: MicrosoftSTT,
+        model_lock: asyncio.Lock,
+        *args,
+        **kwargs,
+    ) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+
+        self.cli_args = cli_args
+        self.wyoming_info_event = wyoming_info.event()
+        self.model = model
+        self.model_lock = model_lock
+
+        if len(self.cli_args.language) > 1:
+            _LOGGER.warning(
+                f"Multiple languages specified, auto-detection will be used for these languages only: {self.cli_args.language}"
+            )
+
+        self._language = self.cli_args.language[0]
+
+    async def handle_event(self, event: Event) -> bool:
+        """Handle an event."""
+        if Describe.is_type(event.type):
+            await self.write_event(self.wyoming_info_event)
+            _LOGGER.debug("Sent info")
+            return True
+
+        if Transcribe.is_type(event.type):
+            transcribe = Transcribe.from_event(event)
+            if transcribe.language:
+                self._language = transcribe.language
+                _LOGGER.debug("Language set to %s", transcribe.language)
+            return True
+
+        if AudioStart.is_type(event.type):
+            start = AudioStart.from_event(event)
+            _LOGGER.debug(
+                f"Receiving audio: {start.width * 8}bit {start.rate}Hz {start.channels}ch"
+            )
+
+            async with self.model_lock:
+                self.model.start_transcribe(
+                    bits_per_sample=start.width * 8,
+                    samples_per_second=start.rate,
+                    channels=start.channels,
+                    language=self._language,
+                )
+
+        if AudioChunk.is_type(event.type):
+            chunk = AudioChunk.from_event(event)
+            async with self.model_lock:
+                self.model.push_audio_chunk(chunk.audio)
+
+            return True
+
+        if AudioStop.is_type(event.type):
+            _LOGGER.debug("Audio stopped")
+
+            async with self.model_lock:
+                try:
+                    start_time = time.time()
+                    _LOGGER.debug("Starting transcription")
+                    text = self.model.transcribe()
+                    _LOGGER.info(
+                        f"Transcription completed in {time.time() - start_time:.2f} seconds"
+                    )
+                except Exception as e:
+                    _LOGGER.error(f"Failed to transcribe audio: {e}")
+                    return True
+
+            _LOGGER.info(text)
+
+            await self.write_event(Transcript(text=text).event())
+            _LOGGER.debug("Completed request")
+
+            # Reset
+            self._language = self.cli_args.language
+            return False
+
+        return True

wyoming_microsoft_stt/languages.json

@@ -0,0 +1,145 @@
+[
+    "af-ZA",
+    "am-ET",
+    "ar-AE",
+    "ar-BH",
+    "ar-DZ",
+    "ar-EG",
+    "ar-IL",
+    "ar-IQ",
+    "ar-JO",
+    "ar-KW",
+    "ar-LB",
+    "ar-LY",
+    "ar-MA",
+    "ar-OM",
+    "ar-PS",
+    "ar-QA",
+    "ar-SA",
+    "ar-SY",
+    "ar-TN",
+    "ar-YE",
+    "az-AZ",
+    "bg-BG",
+    "bn-IN",
+    "bs-BA",
+    "ca-ES",
+    "cs-CZ",
+    "cy-GB",
+    "da-DK",
+    "de-AT",
+    "de-CH",
+    "de-DE",
+    "el-GR",
+    "en-AU",
+    "en-CA",
+    "en-GB",
+    "en-GH",
+    "en-HK",
+    "en-IE",
+    "en-IN",
+    "en-KE",
+    "en-NG",
+    "en-NZ",
+    "en-PH",
+    "en-SG",
+    "en-TZ",
+    "en-US",
+    "en-ZA",
+    "es-AR",
+    "es-BO",
+    "es-CL",
+    "es-CO",
+    "es-CR",
+    "es-CU",
+    "es-DO",
+    "es-EC",
+    "es-ES",
+    "es-GQ",
+    "es-GT",
+    "es-HN",
+    "es-MX",
+    "es-NI",
+    "es-PA",
+    "es-PE",
+    "es-PR",
+    "es-PY",
+    "es-SV",
+    "es-US",
+    "es-UY",
+    "es-VE",
+    "et-EE",
+    "eu-ES",
+    "fa-IR",
+    "fi-FI",
+    "fil-PH",
+    "fr-BE",
+    "fr-CA",
+    "fr-CH",
+    "fr-FR",
+    "ga-IE",
+    "gl-ES",
+    "gu-IN",
+    "he-IL",
+    "hi-IN",
+    "hr-HR",
+    "hu-HU",
+    "hy-AM",
+    "id-ID",
+    "is-IS",
+    "it-CH",
+    "it-IT",
+    "ja-JP",
+    "jv-ID",
+    "ka-GE",
+    "kk-KZ",
+    "km-KH",
+    "kn-IN",
+    "ko-KR",
+    "lo-LA",
+    "lt-LT",
+    "lv-LV",
+    "mk-MK",
+    "ml-IN",
+    "mn-MN",
+    "mr-IN",
+    "ms-MY",
+    "mt-MT",
+    "my-MM",
+    "nb-NO",
+    "ne-NP",
+    "nl-BE",
+    "nl-NL",
+    "pa-IN",
+    "pl-PL",
+    "ps-AF",
+    "pt-BR",
+    "pt-PT",
+    "ro-RO",
+    "ru-RU",
+    "si-LK",
+    "sk-SK",
+    "sl-SI",
+    "so-SO",
+    "sq-AL",
+    "sr-RS",
+    "sv-SE",
+    "sw-KE",
+    "sw-TZ",
+    "ta-IN",
+    "te-IN",
+    "th-TH",
+    "tr-TR",
+    "uk-UA",
+    "ur-IN",
+    "uz-UZ",
+    "vi-VN",
+    "wuu-CN",
+    "yue-CN",
+    "zh-CN",
+    "zh-CN-SHANDONG",
+    "zh-CN-SICHUAN",
+    "zh-HK",
+    "zh-TW",
+    "zu-ZA"
+]

wyoming_microsoft_stt/microsoft_stt.py

@@ -0,0 +1,148 @@
+"""Microsoft STT module for Wyoming."""
+
+import time
+import azure.cognitiveservices.speech as speechsdk  # noqa: D100
+import logging
+from . import SpeechConfig
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MicrosoftSTT:
+    """Class to handle Microsoft STT."""
+
+    def __init__(self, speechconfig: SpeechConfig) -> None:
+        """Initialize."""
+        self.args = speechconfig
+
+        self._stream: speechsdk.audio.PushAudioInputStream | None = None
+        self._speech_recognizer: speechsdk.SpeechRecognizer | None = None
+        self._results: list[speechsdk.SpeechRecognitionResult] = []
+
+        try:
+            # Initialize the speech configuration with the provided subscription key and region
+            self.speech_config = speechsdk.SpeechConfig(
+                subscription=self.args.subscription_key, region=self.args.service_region
+            )
+            _LOGGER.info("Microsoft SpeechConfig initialized successfully.")
+        except Exception as e:
+            _LOGGER.error(f"Failed to initialize Microsoft SpeechConfig: {e}")
+            raise
+
+        self.set_profanity(self.args.profanity)
+
+    def start_transcribe(
+        self,
+        samples_per_second: int = 16000,
+        bits_per_sample: int = 16,
+        channels: int = 1,
+        language=None,
+    ) -> None:
+        """Begin a transcription."""
+        _LOGGER.debug(f"Starting transcription with language: {language}")
+
+        # Configure audio input for speech recognition
+        _LOGGER.debug("Configuring audio input stream...")
+        self._stream = speechsdk.audio.PushAudioInputStream(
+            stream_format=speechsdk.audio.AudioStreamFormat(
+                samples_per_second=samples_per_second,
+                bits_per_sample=bits_per_sample,
+                channels=channels,
+            )
+        )
+        audio_config = speechsdk.audio.AudioConfig(stream=self._stream)
+        # Create a speech recognizer with the configured speech and audio settings
+        self._speech_recognizer = speechsdk.SpeechRecognizer(
+            speech_config=self.speech_config,
+            audio_config=audio_config,
+            **self.get_language(language),
+        )
+
+        self.recognition_done = False
+
+        def session_stopped_cb(evt):
+            """Signal to stop continuous recognition upon receiving an event `evt`."""
+            _LOGGER.debug(f"SESSION STOPPED: {evt}")
+            self.recognition_done = True
+
+        self._speech_recognizer.recognizing.connect(
+            lambda evt: _LOGGER.debug(f"RECOGNIZING: {evt}")
+        )
+        self._speech_recognizer.recognized.connect(
+            lambda evt: _LOGGER.debug(f"RECOGNIZED: {evt}")
+        )
+        self._speech_recognizer.session_started.connect(
+            lambda evt: _LOGGER.debug(f"SESSION STARTED: {evt}")
+        )
+        self._speech_recognizer.session_stopped.connect(session_stopped_cb)
+        self._speech_recognizer.canceled.connect(
+            lambda evt: _LOGGER.debug(f"CANCELED {evt}")
+        )
+
+        _LOGGER.debug("Starting continuous recognition...")
+
+        def recognized(event: speechsdk.SpeechRecognitionEventArgs):
+            _LOGGER.debug(f"{event.result}")
+            self._results = event.result
+
+        self._speech_recognizer.start_continuous_recognition()
+        self._speech_recognizer.recognized.connect(recognized)
+
+    def push_audio_chunk(self, chunk: bytes) -> None:
+        """Push an audio chunk to the recognizer."""
+        self._stream.write(chunk)
+
+    def stop_audio_chunk(self) -> None:
+        """Stop the transcription."""
+        _LOGGER.debug("Stopping transcription...")
+        self._stream.close()
+
+    def transcribe(self):
+        """Get the results of a transcription."""
+        try:
+            self.stop_audio_chunk()
+
+            # Wait for the recognition to finish
+            while not self.recognition_done:
+                time.sleep(0.01)
+
+            self._speech_recognizer.stop_continuous_recognition()
+
+            return self._results.text
+
+        except Exception as e:
+            _LOGGER.error(f"Failed to transcribe audio: {e}")
+            return ""
+
+    def get_language(self, language: str) -> dict:
+        """Get the language code."""
+        if len(self.args.language) > 1:
+            auto_detect_source_language_config = (
+                speechsdk.languageconfig.AutoDetectSourceLanguageConfig(
+                    languages=self.args.language
+                )
+            )
+            return {
+                "auto_detect_source_language_config": auto_detect_source_language_config
+            }
+
+        if language:
+            _LOGGER.debug(f"Language set to {language}")
+            return {"language": language}
+
+        return {"language": self.args.language[0]}
+
+    def set_profanity(self, profanity: str):
+        """Set the profanity filter level."""
+        if profanity == "off":
+            profanity_level = speechsdk.ProfanityOption.Raw
+        elif profanity == "masked":
+            profanity_level = speechsdk.ProfanityOption.Masked
+        elif profanity == "removed":
+            profanity_level = speechsdk.ProfanityOption.Removed
+        else:
+            _LOGGER.error(f"Invalid profanity level: {profanity}")
+            return
+
+        self.speech_config.set_profanity(profanity_level)
+        _LOGGER.debug(f"Profanity filter set to {profanity}")

wyoming_microsoft_stt/version.py

@@ -0,0 +1,3 @@
+"""Version information."""
+
+__version__ = "1.3.3"

wyoming_microsoft_stt-1.3.3.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: wyoming-microsoft-stt
+Version: 1.3.3
+Summary: Add your description here
+Home-page: https://github.com/hugobloem/wyoming-microsoft-stt
+Author: Hugo Bloem
+Author-email: 
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: azure-cognitiveservices-speech>=1.45.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: wyoming>=1.7.2
+Dynamic: author
+Dynamic: home-page
+
+# Wyoming Microsoft STT
+Wyoming protocol server for Microsoft Azure speech-to-text.
+
+This Python package provides a Wyoming integration for Microsoft Azure speech-to-text and can be directly used with [Home Assistant](https://www.home-assistant.io/) voice and [Rhasspy](https://github.com/rhasspy/rhasspy3).
+
+## Azure Speech Service
+This program uses [Microsoft Azure Speech Service](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/). You can sign up to a free Azure account which comes with free tier of 5 audio hours per month, this should be enough for running a voice assistant as each command is relatively short. Once this amount is exceeded Azure could charge you for each second used (Current pricing is $0.36 per audio hour). I am not responsible for any incurred charges and recommend you set up a spending limit to reduce your exposure. However, for normal usage the free tier could suffice and the resource should not switch to a paid service automatically.
+
+If you have not set up a speech resource, you can follow the instructions below. (you only need to do this once and works both for [Speech-to-Text](https://github.com/hugobloem/wyoming-microsoft-stt) and [Text-to-Speech](https://github.com/hugobloem/wyoming-microsoft-tts))
+
+1. Sign in or create an account on [portal.azure.com](https://portal.azure.com).
+2. Create a subscription by searching for `subscription` in the search bar. [Consult Microsoft Learn for more information](https://learn.microsoft.com/en-gb/azure/cost-management-billing/manage/create-subscription#create-a-subscription-in-the-azure-portal).
+3. Create a speech resource by searching for `speech service`.
+4. Select the subscription you created, pick or create a resource group, select a region, pick an identifiable name, and select the pricing tier (you probably want Free F0)
+5. Once created, copy one of the keys from the speech service page. You will need this to run this program.
+
+## Usage
+Depending on the installation method parameters are parsed differently. However, the same options are used for each of the installation methods and can be found in the table below. Your service region and subscription key can be found on the speech service resource page (step 5 the Azure Speech service instructions).
+
+For the bare-metal Python install the program is run as follows:
+```python
+python -m wyoming-microsoft-stt --<key> <value>
+```
+
+| Key | Optional | Description |
+|---|---|---|
+| `service-region` | No | Azure service region e.g., `uksouth` |
+| `subscription-key` | No | Azure subscription key |
+| `language` | Yes | Default language to set for transcription, default: `en-GB`. For auto-detection provide multiple languages. |
+| `uri` | No | Uri where the server will be broadcasted e.g., `tcp://0.0.0.0:10300` |
+| `download-dir` | Yes | Directory to download models into (default: ) |
+| `update-languages` | Yes | Download latest languages.json during startup |
+| `debug` | Yes | Log debug messages |
+
+## Multi-language support
+This add-on can also auto-detect the spoken language from a list of pre-defined languages (max. 10). To do this in Home Assistant provide the languages separated by semi-colons like so:
+<img width="689" alt="Screenshot 2025-05-04 at 11 59 55" src="https://github.com/user-attachments/assets/b3c54fe5-ebf3-404a-a8e8-b0d27efaf76d" />
+
+> [!NOTE]
+> Setting multiple languages will override the options set by Home Assistant's Voice configuration! It will prompt you to select a language but the option is ignored when speech is processed.
+
+
+## Installation
+Depending on your use case there are different installation options.
+
+- **Using pip**
+  Clone the repository and install the package using pip. Please note the platform requirements as noted [here](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/quickstarts/setup-platform?tabs=linux%2Cubuntu%2Cdotnetcli%2Cdotnet%2Cjre%2Cmaven%2Cnodejs%2Cmac%2Cpypi&pivots=programming-language-python#platform-requirements).
+  ```sh
+  pip install .
+  ```
+
+- **Home Assistant Add-On**
+  Add the following repository as an add-on repository to your Home Assistant, or click the button below.
+  [https://github.com/hugobloem/homeassistant-addons](https://github.com/hugobloem/homeassistant-addons)
+
+  [![Open your Home Assistant instance and show the add add-on repository dialog with a specific repository URL pre-filled.](https://my.home-assistant.io/badges/supervisor_add_addon_repository.svg)](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2Fhugobloem%2Fhomeassistant-addons)
+
+- **Docker container**
+  To run as a Docker container use the following command:
+  ```bash
+  docker run ghcr.io/hugobloem/wyoming-microsoft-stt-noha:latest --<key> <value>
+  ```
+  For the relevant keys please look at [the table below](#usage)
+
+- **docker compose**
+
+  Below is a sample for a docker compose file. The azure region + subscription key can be set in environment variables. Everything else needs to be passed via command line arguments.
+  
+  ```yaml
+  wyoming-proxy-azure-stt:
+    image: ghcr.io/hugobloem/wyoming-microsoft-stt-noha
+    container_name: wyoming-azure-stt
+    ports:
+      - "10300:10300"
+    environment:
+      AZURE_SERVICE_REGION: swedencentral
+      AZURE_SUBSCRIPTION_KEY: XXX
+    command: --language=en-GB,nl-NL --uri=tcp://0.0.0.0:10300
+  ```

wyoming_microsoft_stt-1.3.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+tests/__init__.py,sha256=ZEU8_ARBRGIqaAOTcPRsjXxcfHSojBm-5-krYBN-68g,13
+tests/conftest.py,sha256=iSju8g6PiODcg9eY4_lZaVcubXMlfnx1CpyGVsmTAgY,340
+tests/test_microsoft_stt.py,sha256=CO6xyLHFcE1kqJ_XuGprRu0i28zTN2oHaKtomK_aJIU,594
+tests/test_multilanguage.py,sha256=wRtyWuhWBmA5Yf01JNbmgxqoVKmDcE6XHz9QcfSR700,3100
+tests/test_transcribe.py,sha256=BqT-KLZR6UM9RqNI43RZFz6WLkXFcjk2a2WLszhDgso,3674
+wyoming_microsoft_stt/__init__.py,sha256=92Kms90cxU6Zs5XjNZiYvIGLA3Yd-BizN-G8f7n506I,3365
+wyoming_microsoft_stt/__main__.py,sha256=gA0wM3OCLdEq7ewMRrlWs4TVpXvFlITMaX_4lP3ed7E,5577
+wyoming_microsoft_stt/download.py,sha256=mTWZl9kVaE7KGeO2d0SS7wztDN6tGo9AudXWhN8uKhg,3379
+wyoming_microsoft_stt/handler.py,sha256=dWm9etFANRU33IDU-p85enHmWtMtTtW522I3AJbTAxg,3330
+wyoming_microsoft_stt/languages.json,sha256=eDZuPJLzDjdZlh0I4081OTkLPt6nZdUY8ra45c7oMCc,1881
+wyoming_microsoft_stt/microsoft_stt.py,sha256=2Rb9uoOxGFpQfwXux5p3jwop_3poF-75U_84q5QRmt0,5357
+wyoming_microsoft_stt/version.py,sha256=iG_JqR_Z5wfSTlMqH9H1vmrmlcgyFJdbRBRllY0yDgU,50
+wyoming_microsoft_stt-1.3.3.dist-info/METADATA,sha256=Hh7h4BDS_hLd4t3Y8LOEpAMpRzGph7TwfPEliYQA6mA,5792
+wyoming_microsoft_stt-1.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wyoming_microsoft_stt-1.3.3.dist-info/top_level.txt,sha256=aURyYXybYBAybkVTs2RFT5ctnPz5pRa_B7Gn9_SKhL8,28
+wyoming_microsoft_stt-1.3.3.dist-info/RECORD,,

wyoming_microsoft_stt-1.3.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wyoming_microsoft_stt-1.3.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+tests
+wyoming_microsoft_stt