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

tests/__init__.py

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

tests/conftest.py

@@ -0,0 +1,26 @@
+"""Fixtures for tests."""
+
+from types import SimpleNamespace
+import pytest
+from wyoming_microsoft_tts.microsoft_tts import MicrosoftTTS
+import os
+
+
+@pytest.fixture
+def configuration():
+    """Return configuration."""
+    return {
+        "voice": "en-GB-SoniaNeural",
+    }
+
+
+@pytest.fixture
+def microsoft_tts(configuration):
+    """Return MicrosoftTTS instance."""
+    args = SimpleNamespace(
+        subscription_key=os.environ.get("SPEECH_KEY"),
+        service_region=os.environ.get("SPEECH_REGION"),
+        download_dir="/tmp/",
+        **configuration,
+    )
+    return MicrosoftTTS(args)

tests/test_download.py

@@ -0,0 +1,75 @@
+"""Tests for download functionality."""
+
+import logging
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from wyoming_microsoft_tts.download import get_voices
+
+
+def test_get_voices_download_failure_logs_error(caplog):
+    """Test that a failed download logs an error and continues with fallback."""
+    with (
+        tempfile.TemporaryDirectory() as temp_dir,
+        patch("wyoming_microsoft_tts.download.urlopen") as mock_urlopen,
+    ):
+        mock_urlopen.side_effect = Exception("Network error")
+
+        # Capture logs at error level
+        with caplog.at_level(logging.ERROR):
+            # Call get_voices with update_voices=True to trigger download
+            voices = get_voices(
+                download_dir=temp_dir,
+                update_voices=True,
+                region="westus",
+                key="fake_key",
+            )
+
+        # Verify that we got an error log
+        assert len(caplog.records) > 0
+        error_logs = [
+            record for record in caplog.records if record.levelname == "ERROR"
+        ]
+        assert len(error_logs) >= 1
+
+        # Check that the error message is about failed update
+        error_message = error_logs[0].message
+        assert "Failed to update voices list" in error_message
+
+        # Verify that voices are still returned (from embedded file)
+        assert isinstance(voices, dict)
+        assert len(voices) > 0  # Should have voices from embedded file
+
+
+def test_get_voices_download_failure_uses_fallback():
+    """Test that a failed download falls back to embedded voices."""
+    with (
+        tempfile.TemporaryDirectory() as temp_dir,
+        patch("wyoming_microsoft_tts.download.urlopen") as mock_urlopen,
+    ):
+        mock_urlopen.side_effect = Exception("Network error")
+
+        # Call get_voices with update_voices=True to trigger download
+        voices = get_voices(
+            download_dir=temp_dir, update_voices=True, region="westus", key="fake_key"
+        )
+
+        # Verify that voices are still returned from embedded file
+        assert isinstance(voices, dict)
+        assert len(voices) > 0
+
+        # Verify that no downloaded file was created in temp directory
+        download_path = Path(temp_dir) / "voices.json"
+        assert not download_path.exists()
+
+
+def test_get_voices_without_update_uses_embedded():
+    """Test that get_voices works without update flag."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Call get_voices with update_voices=False (default)
+        voices = get_voices(download_dir=temp_dir)
+
+        # Should return voices from embedded file
+        assert isinstance(voices, dict)
+        assert len(voices) > 0

tests/test_microsoft_tts.py

@@ -0,0 +1,17 @@
+"""Tests for the MicrosoftTTS class."""
+
+
+def test_initialize(microsoft_tts, configuration):
+    """Test initialization."""
+    assert microsoft_tts.args.voice == configuration["voice"]
+    assert microsoft_tts.speech_config is not None
+    assert microsoft_tts.output_dir is not None
+
+
+def test_synthesize(microsoft_tts):
+    """Test synthesize."""
+    text = "Hello, world!"
+    voice = "en-US-JennyNeural"
+
+    result = microsoft_tts.synthesize(text, voice)
+    assert result.endswith(".wav")

tests/test_voice_parsing.py

@@ -0,0 +1,169 @@
+"""Tests for voice parsing functionality."""
+
+import json
+from io import StringIO
+
+
+from wyoming_microsoft_tts.download import transform_voices_files
+
+
+def test_voice_parsing_with_script_codes():
+    """Test that voices with script codes in locales are parsed correctly."""
+    # Sample Microsoft API response with problematic locales
+    sample_response = [
+        {
+            "ShortName": "iu-Cans-CA-SiqiniqNeural",
+            "Locale": "iu-Cans-CA",
+            "LocalName": "Siqiniq",
+            "LocaleName": "Inuktitut (Canadian Aboriginal Syllabics, Canada)",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "iu-Latn-CA-TaqqiqNeural",
+            "Locale": "iu-Latn-CA",
+            "LocalName": "Taqqiq",
+            "LocaleName": "Inuktitut (Latin, Canada)",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "sr-Latn-RS-NicholasNeural",
+            "Locale": "sr-Latn-RS",
+            "LocalName": "Nicholas",
+            "LocaleName": "Serbian (Latin, Serbia)",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "en-US-JennyNeural",
+            "Locale": "en-US",
+            "LocalName": "Jenny",
+            "LocaleName": "English (United States)",
+            "VoiceType": "Neural",
+        },
+    ]
+
+    # Create a StringIO object to simulate the API response
+    response_io = StringIO(json.dumps(sample_response))
+
+    # Transform the voices
+    voices = transform_voices_files(response_io)
+
+    # Verify that all voices were processed successfully
+    assert len(voices) == 4, f"Expected 4 voices, got {len(voices)}"
+
+    # Check that the problematic voices are included
+    assert "iu-Cans-CA-SiqiniqNeural" in voices
+    assert "iu-Latn-CA-TaqqiqNeural" in voices
+    assert "sr-Latn-RS-NicholasNeural" in voices
+    assert "en-US-JennyNeural" in voices
+
+    # Check that the voice data is properly structured
+    for _voice_name, voice_data in voices.items():
+        assert "key" in voice_data
+        assert "name" in voice_data
+        assert "language" in voice_data
+        assert "quality" in voice_data
+        assert "region" in voice_data["language"]
+        assert "country_english" in voice_data["language"]
+
+        # Verify that region and country_english are not None
+        assert voice_data["language"]["region"] is not None
+        assert voice_data["language"]["country_english"] is not None
+
+
+def test_voice_parsing_with_secondary_locales():
+    """Test that voices with secondary locales are parsed correctly."""
+    sample_response = [
+        {
+            "ShortName": "en-US-JennyMultilingualNeural",
+            "Locale": "en-US",
+            "LocalName": "Jenny",
+            "LocaleName": "English (United States)",
+            "VoiceType": "Neural",
+            "SecondaryLocaleList": ["de-DE", "es-ES"],
+        }
+    ]
+
+    response_io = StringIO(json.dumps(sample_response))
+    voices = transform_voices_files(response_io)
+
+    # Should have 3 voices: original + 2 secondary locales
+    assert len(voices) == 3
+    assert "en-US-JennyMultilingualNeural" in voices
+    assert "de-DE-JennyMultilingualNeural" in voices
+    assert "es-ES-JennyMultilingualNeural" in voices
+
+
+def test_voice_parsing_with_standard_locales():
+    """Test that standard locale format (lang-COUNTRY) still works correctly."""
+    sample_response = [
+        {
+            "ShortName": "en-US-JennyNeural",
+            "Locale": "en-US",
+            "LocalName": "Jenny",
+            "LocaleName": "English (United States)",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "fr-FR-DeniseNeural",
+            "Locale": "fr-FR",
+            "LocalName": "Denise",
+            "LocaleName": "French (France)",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "de-DE-KatjaNeural",
+            "Locale": "de-DE",
+            "LocalName": "Katja",
+            "LocaleName": "German (Germany)",
+            "VoiceType": "Neural",
+        },
+    ]
+
+    response_io = StringIO(json.dumps(sample_response))
+    voices = transform_voices_files(response_io)
+
+    # Should have all 3 voices
+    assert len(voices) == 3
+
+    # Check country mappings are correct for standard locales
+    assert voices["en-US-JennyNeural"]["language"]["region"] == "US"
+    assert voices["en-US-JennyNeural"]["language"]["country_english"] == "United States"
+
+    assert voices["fr-FR-DeniseNeural"]["language"]["region"] == "FR"
+    assert voices["fr-FR-DeniseNeural"]["language"]["country_english"] == "France"
+
+    assert voices["de-DE-KatjaNeural"]["language"]["region"] == "DE"
+    assert voices["de-DE-KatjaNeural"]["language"]["country_english"] == "Germany"
+
+
+def test_voice_parsing_with_invalid_locales():
+    """Test that voices with completely invalid locales use fallback values."""
+    sample_response = [
+        {
+            "ShortName": "xx-INVALID-TestNeural",
+            "Locale": "xx-INVALID",
+            "LocalName": "Test",
+            "LocaleName": "Test Language",
+            "VoiceType": "Neural",
+        },
+        {
+            "ShortName": "yy-ZZ-FAKE-TestNeural",
+            "Locale": "yy-ZZ-FAKE",
+            "LocalName": "Test2",
+            "LocaleName": "Test Language 2",
+            "VoiceType": "Neural",
+        },
+    ]
+
+    response_io = StringIO(json.dumps(sample_response))
+    voices = transform_voices_files(response_io)
+
+    # Should have both voices with fallback values
+    assert len(voices) == 2
+
+    # Check fallback values are used
+    assert voices["xx-INVALID-TestNeural"]["language"]["region"] == "INVALID"
+    assert voices["xx-INVALID-TestNeural"]["language"]["country_english"] == "Unknown"
+
+    assert voices["yy-ZZ-FAKE-TestNeural"]["language"]["region"] == "FAKE"
+    assert voices["yy-ZZ-FAKE-TestNeural"]["language"]["country_english"] == "Unknown"

wyoming_microsoft_tts/__init__.py

@@ -0,0 +1 @@
+"""Wyoming server for Microsoft TTS."""

wyoming_microsoft_tts/__main__.py

@@ -0,0 +1,208 @@
+import argparse  # noqa: D100
+import asyncio
+import contextlib
+import logging
+import os
+import signal
+from functools import partial
+from typing import Any
+
+from wyoming.info import Attribution, Info, TtsProgram, TtsVoice
+from wyoming.server import AsyncServer
+
+from wyoming_microsoft_tts.download import get_voices
+from wyoming_microsoft_tts.handler import MicrosoftEventHandler
+from wyoming_microsoft_tts.version import __version__
+
+_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()
+    exit(0)
+
+
+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(
+        "--voice",
+        default="en-GB-SoniaNeural",
+        help="Default Microsoft voice to use (e.g., en-GB-SoniaNeural)",
+    )
+    parser.add_argument(
+        "--download-dir",
+        default="/tmp/",
+        type=str,
+        help="Directory to download voices.json into (default: /tmp/)",
+    )
+    parser.add_argument(
+        "--uri", default="tcp://0.0.0.0:10200", help="unix:// or tcp://"
+    )
+    #
+    parser.add_argument(
+        "--speaker", type=str, help="Name or id of speaker for default voice"
+    )
+    #
+    parser.add_argument(
+        "--auto-punctuation", default=".?!", help="Automatically add punctuation"
+    )
+    parser.add_argument(
+        "--no-streaming",
+        action="store_true",
+        help="Disable audio streaming on sentence boundaries",
+    )
+    parser.add_argument("--samples-per-chunk", type=int, default=1024)
+    #
+    parser.add_argument(
+        "--update-voices",
+        action="store_true",
+        help="Download latest voices.json during startup",
+    )
+    #
+    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."
+        )
+
+
+async def main() -> None:
+    """Start Wyoming Microsoft TTS server."""
+    args = parse_arguments()
+    validate_args(args)
+
+    # setup logging
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
+    _LOGGER.debug("Arguments parsed successfully.")
+
+    # Load voice info
+    try:
+        _LOGGER.info("Starting voices loading process.")
+        voices_info = get_voices(
+            args.download_dir,
+            update_voices=args.update_voices,
+            region=args.service_region,
+            key=args.subscription_key,
+        )
+        _LOGGER.info("Voices loaded successfully.")
+    except Exception as e:
+        _LOGGER.error(f"Failed to load voices: {e}")
+        return
+
+    # Resolve aliases for backwards compatibility with old voice names
+    aliases_info: dict[str, Any] = {}
+    for voice_info in voices_info.values():
+        for voice_alias in voice_info.get("aliases", []):
+            aliases_info[voice_alias] = {"_is_alias": True, **voice_info}
+
+    # Make sure default voice is in the list
+    if args.voice not in voices_info:
+        raise ValueError(
+            f"Voice {args.voice} not found in voices.json, please look up the correct voice name here"
+            + "\nhttps://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts"
+        )
+
+    voices_info.update(aliases_info)
+    voices = [
+        TtsVoice(
+            name=voice_name,
+            description=get_description(voice_info),
+            attribution=Attribution(
+                name="Microsoft",
+                url="https://github.com/hugobloem/wyoming-microsoft-tts",
+            ),
+            installed=True,
+            version=__version__,
+            languages=[
+                voice_info.get("language", {}).get(
+                    "code",
+                    voice_info.get("espeak", {}).get("voice", voice_name.split("_")[0]),
+                )
+            ],
+            #
+            # Don't send speakers for now because it overflows StreamReader buffers
+            # speakers=[
+            #     TtsVoiceSpeaker(name=speaker_name)
+            #     for speaker_name in voice_info["speaker_id_map"]
+            # ]
+            # if voice_info.get("speaker_id_map")
+            # else None,
+        )
+        for voice_name, voice_info in voices_info.items()
+        if not voice_info.get("_is_alias", False)
+    ]
+
+    wyoming_info = Info(
+        tts=[
+            TtsProgram(
+                name="microsoft",
+                description="A fast, local, neural text to speech engine",
+                attribution=Attribution(
+                    name="Microsoft",
+                    url="https://github.com/hugobloem/wyoming-microsoft-tts",
+                ),
+                installed=True,
+                version=__version__,
+                voices=sorted(voices, key=lambda v: v.name),
+                supports_synthesize_streaming=not args.no_streaming,
+            )
+        ],
+    )
+
+    # Start server
+    server = AsyncServer.from_uri(args.uri)
+
+    _LOGGER.info("Ready")
+    try:
+        await server.run(
+            partial(
+                MicrosoftEventHandler,
+                wyoming_info,
+                args,
+            )
+        )
+    except Exception as e:
+        _LOGGER.error(f"An error occurred while running the server: {e}")
+
+
+# -----------------------------------------------------------------------------
+
+
+def get_description(voice_info: dict[str, Any]):
+    """Get a human readable description for a voice."""
+    name = voice_info["name"]
+    name = " ".join(name.split("_"))
+    quality = voice_info["quality"]
+
+    return f"{name} ({quality})"
+
+
+# -----------------------------------------------------------------------------
+
+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_tts/download.py

@@ -0,0 +1,182 @@
+"""Utility for downloading Microsoft voices."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote, urlsplit, urlunsplit
+from urllib.request import Request, urlopen
+
+from pycountry import countries
+
+URL_FORMAT = "https://{region}.tts.speech.microsoft.com/cognitiveservices/voices/list"
+URL_HEADER = "Ocp-Apim-Subscription-Key"
+
+
+_DIR = Path(__file__).parent
+_LOGGER = logging.getLogger(__name__)
+
+_SKIP_FILES = {"MODEL_CARD"}
+
+
+class VoiceNotFoundError(Exception):
+    """Raised when a voice is not found."""
+
+    pass
+
+
+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 _get_country_from_locale(locale: str):
+    """Extract country information from a locale string.
+
+    Handles both standard (lang-COUNTRY) and extended (lang-script-COUNTRY) locale formats.
+    """
+    parts = locale.split("-")
+
+    # For extended locales like "iu-Cans-CA", the country code is the last part
+    if len(parts) >= 3:
+        country_code = parts[-1]
+    elif len(parts) == 2:
+        country_code = parts[1]
+    else:
+        return None
+
+    return countries.get(alpha_2=country_code)
+
+
+def transform_voices_files(response):
+    """Transform the voices.json file from the Microsoft API to the format used by Wyoming."""
+    json_response = json.load(response)
+    voices = {}
+    for entry in json_response:
+        if not isinstance(entry, dict):
+            continue
+
+        try:
+            country = _get_country_from_locale(entry["Locale"])
+            # Use fallback values if country lookup fails
+            if country is None:
+                region = entry["Locale"].split("-")[-1]  # Use the last part as region
+                country_name = "Unknown"
+                _LOGGER.warning(
+                    "Could not find country for locale %s, using fallback values",
+                    entry["Locale"],
+                )
+            else:
+                region = country.alpha_2
+                country_name = country.name
+
+            voices[entry["ShortName"]] = {
+                "key": entry["ShortName"],
+                "name": entry["LocalName"],
+                "language": {
+                    "code": entry["Locale"],
+                    "family": entry["Locale"].split("-")[0],
+                    "region": region,
+                    "name_native": entry["LocaleName"],
+                    "name_english": entry["LocaleName"],
+                    "country_english": country_name,
+                },
+                "quality": entry["VoiceType"],
+                "num_speakers": 1,
+                "speaker_id_map": {},
+                "aliases": [],
+            }
+            if "SecondaryLocaleList" in entry:
+                for secondary_locale in entry["SecondaryLocaleList"]:
+                    secondary_country = _get_country_from_locale(secondary_locale)
+
+                    # Use fallback values if country lookup fails
+                    if secondary_country is None:
+                        secondary_region = secondary_locale.split("-")[-1]
+                        secondary_country_name = "Unknown"
+                        _LOGGER.warning(
+                            "Could not find country for secondary locale %s, using fallback values",
+                            secondary_locale,
+                        )
+                    else:
+                        secondary_region = secondary_country.alpha_2
+                        secondary_country_name = secondary_country.name
+
+                    voices[
+                        entry["ShortName"].replace(entry["Locale"], secondary_locale)
+                    ] = {
+                        "key": entry["ShortName"],
+                        "name": entry["LocalName"],
+                        "language": {
+                            "code": secondary_locale,
+                            "family": secondary_locale.split("-")[0],
+                            "region": secondary_region,
+                            "name_native": secondary_locale,
+                            "name_english": secondary_locale,
+                            "country_english": secondary_country_name,
+                        },
+                        "quality": entry["VoiceType"],
+                        "num_speakers": 1,
+                        "speaker_id_map": {},
+                        "aliases": [],
+                    }
+        except Exception as e:
+            _LOGGER.exception(
+                "Failed to parse voice %s", entry.get("ShortName", "Unknown")
+            )
+            _LOGGER.debug("%s: %s", entry.get("ShortName", "Unknown"), e)
+    return voices
+
+
+def get_voices(
+    download_dir: str | Path,
+    update_voices: bool = False,
+    region: str = "westus",
+    key: str = "",
+) -> dict[str, Any]:
+    """Load available voices from downloaded or embedded JSON file."""
+    download_dir = Path(download_dir)
+    download_dir.mkdir(parents=True, exist_ok=True)
+    voices_download = download_dir / "voices.json"
+
+    if update_voices:
+        # Download latest voices.json
+        try:
+            voices_url = URL_FORMAT.format(region=region)
+            voices_hdr = {URL_HEADER: key}
+            _LOGGER.debug("Downloading %s to %s", voices_url, voices_download)
+            req = Request(_quote_url(voices_url), headers=voices_hdr)
+            with urlopen(req) as response, open(voices_download, "w") as download_file:
+                json.dump(transform_voices_files(response), download_file, indent=4)
+        except Exception:
+            _LOGGER.exception("Failed to update voices list")
+
+    # Prefer downloaded file to embedded
+    if voices_download.exists():
+        try:
+            _LOGGER.debug("Loading downloaded file: %s", voices_download)
+            with open(voices_download, encoding="utf-8") as voices_file:
+                return json.load(voices_file)
+        except Exception:
+            _LOGGER.exception("Failed to load %s", voices_download)
+
+    # Fall back to embedded
+    voices_embedded = _DIR / "voices.json"
+    _LOGGER.debug("Loading embedded file: %s", voices_embedded)
+    with open(voices_embedded, encoding="utf-8") as voices_file:
+        return transform_voices_files(voices_file)
+
+
+def find_voice(name: str, download_dir: str | Path) -> dict[str, Any]:
+    """Look for the files for a voice.
+
+    Returns: Dict of voice info
+    """
+    voices = get_voices(download_dir)
+    if name in voices:
+        # Already installed
+        return voices[name]
+
+    raise VoiceNotFoundError(name)