ci: fix duplicate triggers, pin macos-14 to avoid migration warning

refactor: migrate core modules to use TTSBackendMetadata.voices via registry

.github/workflows/test_pip.yml

@@ -1,7 +1,8 @@
 name: pip install
 run-name: pip install
-on: 
+on:
   push:
+    branches: [main]
     paths:
       - '**.py'
       - 'pyproject.toml'
@@ -15,18 +16,18 @@ jobs:
   install-and-run:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-14, windows-latest]
         python-version: ['3.12']
       fail-fast: false
-    continue-on-error: true
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
+          cache: pip
       - name: Install from repository
         run: python -m pip install .
       #- name: Run abogen

.github/workflows/test_publish.yml

@@ -1,63 +1,63 @@
-name: Build multi-arch Docker Image
+name: Build multi-arch Docker Image
-
+
-on:
+on:
-  # Build and push
+  # Build and push
-  #release:
+  #release:
-  #  types: [published]
+  #  types: [published]
-  # Build only
+  # Build only
-  #push: it 
+  #push: it 
-  #  branches: [main]
+  #  branches: [main]
-  # TODO - enable build on pull requests if build times can be reduced
+  # TODO - enable build on pull requests if build times can be reduced
-  # pull_request:
+  # pull_request:
-  workflow_dispatch:
+  workflow_dispatch:
-
+
-env:
+env:
-  IMAGE_REPOSITORY: ghcr.io/denizsafak/abogen
+  IMAGE_REPOSITORY: ghcr.io/denizsafak/abogen
-
+
-jobs:
+jobs:
-  build:
+  build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest
-    steps:
+    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v7
-
+
-    - name: Login to Github Container Registry
+    - name: Login to Github Container Registry
-      # Only if we need to push an image
+      # Only if we need to push an image
-      # if: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+      # if: ${{ github.event_name == 'release' && github.event.action == 'published' }}
-      uses: docker/login-action@v3
+      uses: docker/login-action@v3
-      with:
+      with:
-          registry: ghcr.io
+          registry: ghcr.io
-          username: ${{ github.actor }}
+          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+          password: ${{ secrets.GITHUB_TOKEN }}
-
+
-    # Setup for buildx
+    # Setup for buildx
-    - name: Set up QEMU
+    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v3
+      uses: docker/setup-qemu-action@v3
-
+
-    - name: Set up Docker Buildx
+    - name: Set up Docker Buildx
-      id: buildx
+      id: buildx
-      uses: docker/setup-buildx-action@v3
+      uses: docker/setup-buildx-action@v3
-
+
-    # Debugging information
+    # Debugging information
-    - name: Docker info
+    - name: Docker info
-      run: docker info
+      run: docker info
-
+
-    - name: Buildx inspect
+    - name: Buildx inspect
-      run: docker buildx inspect
+      run: docker buildx inspect
-
+
-    # Build and (optionally) push the image
+    # Build and (optionally) push the image
-    - name: Build image
+    - name: Build image
-      uses: docker/build-push-action@v6
+      uses: docker/build-push-action@v6
-      with:
+      with:
-        context: ./abogen
+        context: ./abogen
-        file: ./abogen/Dockerfile
+        file: ./abogen/Dockerfile
-        # platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
+        # platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
-        # platforms: linux/amd64,linux/arm64
+        # platforms: linux/amd64,linux/arm64
-        platforms: linux/amd64 # using the solution mentioned in https://github.com/denizsafak/abogen/issues/46
+        platforms: linux/amd64 # using the solution mentioned in https://github.com/denizsafak/abogen/issues/46
-        # Only push if we are publishing a release
+        # Only push if we are publishing a release
-        # push: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+        # push: ${{ github.event_name == 'release' && github.event.action == 'published' }}
-        push: true
+        push: true
-        # Use a 'temp' tag, that won't be pushed, for non-release builds
+        # Use a 'temp' tag, that won't be pushed, for non-release builds
-        tags: ${{ env.IMAGE_REPOSITORY }}:${{ github.event.release.tag_name || 'latest' }}
+        tags: ${{ env.IMAGE_REPOSITORY }}:${{ github.event.release.tag_name || 'latest' }}
-        # Use a cache to reduce build times
+        # Use a cache to reduce build times
-        cache-to: type=gha,mode=max
+        cache-to: type=gha,mode=max
-        cache-from: type=gha
+        cache-from: type=gha

abogen/tts_backend.py

@@ -18,11 +18,13 @@ class TTSBackendMetadata:
         id: Unique backend identifier (e.g. ``"kokoro"``, ``"supertonic"``).
         name: Human-readable display name.
         description: Short description of the backend.
+        voices: Tuple of supported voice identifiers.
     """
 
     id: str
     name: str
     description: str
+    voices: tuple[str, ...] = ()
 
 
 class TTSBackend(Protocol):

abogen/tts_backend_registry.py

@@ -66,6 +66,19 @@ def register_backend(
     _registry.register(metadata, factory)
 
 
+def get_metadata(backend_id: str) -> TTSBackendMetadata:
+    """Get metadata for a specific backend by id.
+
+    Ensures all backends are registered by importing the tts_backends
+    package on first access.
+
+    Raises:
+        KeyError: If backend with given id is not registered.
+    """
+    import abogen.tts_backends  # noqa: F401  — triggers backend registration
+    return _registry.get_metadata(backend_id)
+
+
 def create_backend(backend_id: str, **kwargs: Any) -> TTSBackend:
     """Create a TTS backend instance by provider id."""
     return _registry.create_backend(backend_id, **kwargs)

abogen/tts_backends/kokoro.py

@@ -10,6 +10,16 @@ from typing import Any, Dict, Iterator, List, Optional
 
 import numpy as np
 
+from abogen.constants import VOICES_INTERNAL
+from abogen.tts_backend import TTSBackendMetadata
+
+_KOKORO_METADATA = TTSBackendMetadata(
+    id="kokoro",
+    name="Kokoro",
+    description="Kokoro TTS engine",
+    voices=tuple(VOICES_INTERNAL),
+)
+
 
 def _load_kpipeline():
     """Lazy-load Kokoro dependencies."""
@@ -39,14 +49,8 @@ class KokoroBackend:
         self._lang_code = lang_code
 
     @property
-    def metadata(self):
+    def metadata(self) -> TTSBackendMetadata:
-        from abogen.tts_backend import TTSBackendMetadata
+        return _KOKORO_METADATA
-
-        return TTSBackendMetadata(
-            id="kokoro",
-            name="Kokoro",
-            description="Kokoro TTS engine",
-        )
 
     def __call__(
         self,
@@ -89,9 +93,7 @@ class KokoroBackend:
 
     def get_available_voices(self) -> List[str]:
         """Return known Kokoro voice identifiers."""
-        from abogen.constants import VOICES_INTERNAL
+        return list(self.metadata.voices)
-
-        return list(VOICES_INTERNAL)
 
     def get_supported_formats(self) -> List[str]:
         """Kokoro outputs raw PCM float32 audio."""
@@ -111,14 +113,9 @@ def create_kokoro_backend(**kwargs: Any) -> KokoroBackend:
 
 
 # --- Registration ---
-from abogen.tts_backend import TTSBackendMetadata  # noqa: E402
 from abogen.tts_backend_registry import register_backend  # noqa: E402
 
 register_backend(
-    metadata=TTSBackendMetadata(
+    metadata=_KOKORO_METADATA,
-        id="kokoro",
-        name="Kokoro",
-        description="Kokoro TTS engine",
-    ),
     factory=create_kokoro_backend,
 )

abogen/tts_backends/supertonic.py

@@ -15,6 +15,15 @@ logger = logging.getLogger(__name__)
 
 DEFAULT_SUPERTONIC_VOICES = ("M1", "M2", "M3", "M4", "M5", "F1", "F2", "F3", "F4", "F5")
 
+from abogen.tts_backend import TTSBackendMetadata
+
+_SUPERTONIC_METADATA = TTSBackendMetadata(
+    id="supertonic",
+    name="SuperTonic",
+    description="SuperTonic TTS engine",
+    voices=DEFAULT_SUPERTONIC_VOICES,
+)
+
 
 @dataclass
 class SupertonicSegment:
@@ -282,12 +291,8 @@ class SupertonicBackend:
     """
 
     @property
-    def metadata(self) -> "TTSBackendMetadata":
+    def metadata(self) -> TTSBackendMetadata:
-        return TTSBackendMetadata(
+        return _SUPERTONIC_METADATA
-            id="supertonic",
-            name="SuperTonic",
-            description="SuperTonic TTS engine",
-        )
 
     def __init__(self, **kwargs: Any) -> None:
         self._pipeline = SupertonicPipeline(
@@ -333,7 +338,7 @@ class SupertonicBackend:
 
     def get_available_voices(self) -> List[str]:
         """Return the list of built-in SuperTonic voice identifiers."""
-        return list(DEFAULT_SUPERTONIC_VOICES)
+        return list(self.metadata.voices)
 
     def get_supported_formats(self) -> List[str]:
         return ["wav"]
@@ -379,14 +384,9 @@ def create_supertonic_backend(**kwargs: Any) -> SupertonicBackend:
     return SupertonicBackend(**kwargs)
 
 
-from abogen.tts_backend import TTSBackendMetadata
+from abogen.tts_backend_registry import register_backend  # noqa: E402
-from abogen.tts_backend_registry import register_backend
 
 register_backend(
-    metadata=TTSBackendMetadata(
+    metadata=_SUPERTONIC_METADATA,
-        id="supertonic",
-        name="SuperTonic",
-        description="SuperTonic TTS engine",
-    ),
     factory=create_supertonic_backend,
 )

abogen/voice_cache.py

@@ -17,7 +17,7 @@ if LocalEntryNotFoundError is None:  # pragma: no cover - fallback for tests
         pass
 
 
-from abogen.constants import VOICES_INTERNAL
+from abogen.tts_backend_registry import get_metadata
 
 _CACHE_LOCK = threading.Lock()
 _CACHED_VOICES: Set[str] = set()
@@ -26,8 +26,9 @@ _BOOTSTRAPPED = False
 
 
 def _normalize_targets(voices: Optional[Iterable[str]]) -> Set[str]:
+    kokoro_voices = get_metadata("kokoro").voices
     if not voices:
-        return set(VOICES_INTERNAL)
+        return set(kokoro_voices)
     normalized: Set[str] = set()
     for voice in voices:
         if not voice:
@@ -35,7 +36,7 @@ def _normalize_targets(voices: Optional[Iterable[str]]) -> Set[str]:
         voice_id = str(voice).strip()
         if not voice_id:
             continue
-        if voice_id in VOICES_INTERNAL:
+        if voice_id in kokoro_voices:
             normalized.add(voice_id)
     return normalized
 

abogen/voice_formulas.py

@@ -1,7 +1,7 @@
 import re
 from typing import List, Tuple
 
-from abogen.constants import VOICES_INTERNAL
+from abogen.tts_backend_registry import get_metadata
 
 
 # Calls parsing and loads the voice to gpu or cpu
@@ -22,6 +22,7 @@ def parse_formula_terms(formula: str) -> List[Tuple[str, float]]:
         raise ValueError("Empty voice formula")
 
     terms: List[Tuple[str, float]] = []
+    kokoro_voices = get_metadata("kokoro").voices
     for segment in formula.split("+"):
         part = segment.strip()
         if not part:
@@ -30,7 +31,7 @@ def parse_formula_terms(formula: str) -> List[Tuple[str, float]]:
             raise ValueError("Each component must be in the form voice*weight")
         voice_name, raw_weight = part.split("*", 1)
         voice_name = voice_name.strip()
-        if voice_name not in VOICES_INTERNAL:
+        if voice_name not in kokoro_voices:
             raise ValueError(f"Unknown voice: {voice_name}")
         try:
             weight = float(raw_weight.strip())

abogen/voice_profiles.py

@@ -2,8 +2,7 @@ import json
 import os
 from typing import Any, Dict, Iterable, List, Tuple
 
-from abogen.constants import VOICES_INTERNAL
+from abogen.tts_backend_registry import get_metadata
-from abogen.tts_backends.supertonic import DEFAULT_SUPERTONIC_VOICES
 from abogen.utils import get_user_config_path
 
 
@@ -70,7 +69,8 @@ def serialize_profiles() -> Dict[str, Dict[str, Iterable[Tuple[str, float]]]]:
 
 def _normalize_supertonic_voice(value: Any) -> str:
     raw = str(value or "").strip().upper()
-    return raw if raw in DEFAULT_SUPERTONIC_VOICES else "M1"
+    supertonic_voices = get_metadata("supertonic").voices
+    return raw if raw in supertonic_voices else "M1"
 
 
 def _coerce_supertonic_steps(value: Any) -> int:
@@ -135,6 +135,7 @@ def normalize_profile_entry(entry: Any) -> Dict[str, Any]:
 
 def _normalize_voice_entries(entries: Iterable) -> List[Tuple[str, float]]:
     normalized: List[Tuple[str, float]] = []
+    kokoro_voices = get_metadata("kokoro").voices
     for item in entries or []:
         if isinstance(item, dict):
             voice = item.get("id") or item.get("voice")
@@ -143,7 +144,7 @@ def _normalize_voice_entries(entries: Iterable) -> List[Tuple[str, float]]:
             voice, weight = item[0], item[1]
         else:
             continue
-        if voice not in VOICES_INTERNAL:
+        if voice not in kokoro_voices:
             continue
         if weight is None:
             continue

abogen/webui/Dockerfile

@@ -27,8 +27,6 @@ RUN python3 -m venv "$VIRTUAL_ENV"
 WORKDIR /app
 
 COPY pyproject.toml README.md ./
-COPY abogen ./abogen
-
 RUN pip install --upgrade pip \
   && if [ -n "$TORCH_VERSION" ]; then \
        pip install torch=="$TORCH_VERSION" torchvision=="$TORCH_VERSION" torchaudio=="$TORCH_VERSION" --index-url "$TORCH_INDEX_URL"; \
@@ -39,6 +37,8 @@ RUN pip install --upgrade pip \
     https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl \
   && pip install --no-cache-dir "mutagen>=1.47.0"
 
+COPY abogen ./abogen
+
 # Install onnxruntime-gpu for CUDA acceleration (supertonic uses ONNX Runtime)
 # Set USE_GPU=false to skip this for CPU-only deployments
 RUN if [ "$USE_GPU" = "true" ]; then \

tests/test_tts_backend.py

@@ -1,149 +1,204 @@
-from dataclasses import dataclass
+from dataclasses import dataclass
-
+
-from abogen.tts_backend import TTSBackendMetadata
+from abogen.tts_backend import TTSBackendMetadata
-from abogen.tts_backend_registry import TTSBackendRegistry
+from abogen.tts_backend_registry import TTSBackendRegistry
-
+
-
+
-class TestTTSBackendMetadata:
+class TestTTSBackendMetadata:
-    def test_is_frozen_dataclass(self):
+    def test_is_frozen_dataclass(self):
-        assert dataclass(TTSBackendMetadata)
+        assert dataclass(TTSBackendMetadata)
-
+
-    def test_fields_are_present(self):
+    def test_fields_are_present(self):
-        meta = TTSBackendMetadata(
+        meta = TTSBackendMetadata(
-            id="test",
+            id="test",
-            name="Test Backend",
+            name="Test Backend",
-            description="A test backend",
+            description="A test backend",
-        )
+        )
-        assert meta.id == "test"
+        assert meta.id == "test"
-        assert meta.name == "Test Backend"
+        assert meta.name == "Test Backend"
-        assert meta.description == "A test backend"
+        assert meta.description == "A test backend"
-
+
-    def test_is_immutable(self):
+    def test_voices_field_default_empty(self):
-        import pytest
+        meta = TTSBackendMetadata(
-
+            id="test",
-        meta = TTSBackendMetadata(
+            name="Test",
-            id="kokoro",
+            description="Test backend",
-            name="Kokoro",
+        )
-            description="Test",
+        assert meta.voices == ()
-        )
+
-        with pytest.raises(Exception):
+    def test_voices_field_stored(self):
-            meta.id = "changed"
+        meta = TTSBackendMetadata(
-
+            id="test",
-
+            name="Test",
-class TestTTSBackendRegistry:
+            description="Test backend",
-    def test_register_and_list(self):
+            voices=("v1", "v2"),
-        registry = TTSBackendRegistry()
+        )
-        meta = TTSBackendMetadata(id="a", name="A", description="Backend A")
+        assert meta.voices == ("v1", "v2")
-        registry.register(metadata=meta, factory=lambda: None)
+
-
+    def test_is_immutable(self):
-        backends = registry.list_backends()
+        import pytest
-        assert len(backends) == 1
+
-        assert backends[0].id == "a"
+        meta = TTSBackendMetadata(
-
+            id="kokoro",
-    def test_list_multiple(self):
+            name="Kokoro",
-        registry = TTSBackendRegistry()
+            description="Test",
-        meta_a = TTSBackendMetadata(id="a", name="A", description="A")
+        )
-        meta_b = TTSBackendMetadata(id="b", name="B", description="B")
+        with pytest.raises(Exception):
-        registry.register(metadata=meta_a, factory=lambda: None)
+            meta.id = "changed"
-        registry.register(metadata=meta_b, factory=lambda: None)
+
-
+
-        backends = registry.list_backends()
+class TestTTSBackendRegistry:
-        ids = [b.id for b in backends]
+    def test_register_and_list(self):
-        assert "a" in ids
+        registry = TTSBackendRegistry()
-        assert "b" in ids
+        meta = TTSBackendMetadata(id="a", name="A", description="Backend A")
-
+        registry.register(metadata=meta, factory=lambda: None)
-    def test_get_metadata(self):
+
-        registry = TTSBackendRegistry()
+        backends = registry.list_backends()
-        meta = TTSBackendMetadata(id="x", name="X", description="X backend")
+        assert len(backends) == 1
-        registry.register(metadata=meta, factory=lambda: None)
+        assert backends[0].id == "a"
-
+
-        result = registry.get_metadata("x")
+    def test_list_multiple(self):
-        assert result.id == "x"
+        registry = TTSBackendRegistry()
-        assert result.name == "X"
+        meta_a = TTSBackendMetadata(id="a", name="A", description="A")
-
+        meta_b = TTSBackendMetadata(id="b", name="B", description="B")
-    def test_get_metadata_unknown_raises(self):
+        registry.register(metadata=meta_a, factory=lambda: None)
-        import pytest
+        registry.register(metadata=meta_b, factory=lambda: None)
-
+
-        registry = TTSBackendRegistry()
+        backends = registry.list_backends()
-        with pytest.raises(KeyError, match="Unknown backend: nope"):
+        ids = [b.id for b in backends]
-            registry.get_metadata("nope")
+        assert "a" in ids
-
+        assert "b" in ids
-    def test_create_backend(self):
+
-        registry = TTSBackendRegistry()
+    def test_get_metadata(self):
-        meta = TTSBackendMetadata(id="test", name="Test", description="Test backend")
+        registry = TTSBackendRegistry()
-
+        meta = TTSBackendMetadata(id="x", name="X", description="X backend")
-        def factory(**kwargs):
+        registry.register(metadata=meta, factory=lambda: None)
-            return {"created": True, "kwargs": kwargs}
+
-
+        result = registry.get_metadata("x")
-        registry.register(metadata=meta, factory=factory)
+        assert result.id == "x"
-        result = registry.create_backend("test", foo="bar")
+        assert result.name == "X"
-
+
-        assert result == {"created": True, "kwargs": {"foo": "bar"}}
+    def test_get_metadata_unknown_raises(self):
-
+        import pytest
-    def test_create_backend_unknown_raises(self):
+
-        import pytest
+        registry = TTSBackendRegistry()
-
+        with pytest.raises(KeyError, match="Unknown backend: nope"):
-        registry = TTSBackendRegistry()
+            registry.get_metadata("nope")
-        with pytest.raises(KeyError, match="Unknown backend: missing"):
+
-            registry.create_backend("missing")
+    def test_create_backend(self):
-
+        registry = TTSBackendRegistry()
-    def test_register_overwrites(self):
+        meta = TTSBackendMetadata(id="test", name="Test", description="Test backend")
-        registry = TTSBackendRegistry()
+
-        meta1 = TTSBackendMetadata(id="x", name="V1", description="First")
+        def factory(**kwargs):
-        meta2 = TTSBackendMetadata(id="x", name="V2", description="Second")
+            return {"created": True, "kwargs": kwargs}
-        registry.register(metadata=meta1, factory=lambda: "v1")
+
-        registry.register(metadata=meta2, factory=lambda: "v2")
+        registry.register(metadata=meta, factory=factory)
-
+        result = registry.create_backend("test", foo="bar")
-        result = registry.get_metadata("x")
+
-        assert result.name == "V2"
+        assert result == {"created": True, "kwargs": {"foo": "bar"}}
-        assert registry.create_backend("x") == "v2"
+
-
+    def test_create_backend_unknown_raises(self):
-
+        import pytest
-class TestBackendRegistration:
+
-    """Tests that existing backends are auto-registered."""
+        registry = TTSBackendRegistry()
-
+        with pytest.raises(KeyError, match="Unknown backend: missing"):
-    def test_import_triggers_registration(self):
+            registry.create_backend("missing")
-        import abogen.tts_backends  # noqa: F401
+
-
+    def test_register_overwrites(self):
-        from abogen.tts_backend_registry import _registry
+        registry = TTSBackendRegistry()
-
+        meta1 = TTSBackendMetadata(id="x", name="V1", description="First")
-        backends = _registry.list_backends()
+        meta2 = TTSBackendMetadata(id="x", name="V2", description="Second")
-        ids = [b.id for b in backends]
+        registry.register(metadata=meta1, factory=lambda: "v1")
-        assert "kokoro" in ids
+        registry.register(metadata=meta2, factory=lambda: "v2")
-        assert "supertonic" in ids
+
-
+        result = registry.get_metadata("x")
-    def test_kokoro_metadata(self):
+        assert result.name == "V2"
-        import abogen.tts_backends  # noqa: F401
+        assert registry.create_backend("x") == "v2"
-
+
-        from abogen.tts_backend_registry import _registry
+
-
+class TestBackendRegistration:
-        meta = _registry.get_metadata("kokoro")
+    """Tests that existing backends are auto-registered."""
-        assert meta.id == "kokoro"
+
-        assert meta.name == "Kokoro"
+    def test_import_triggers_registration(self):
-        assert "Kokoro" in meta.description
+        import abogen.tts_backends  # noqa: F401
-
+
-    def test_supertonic_metadata(self):
+        from abogen.tts_backend_registry import _registry
-        import abogen.tts_backends  # noqa: F401
+
-
+        backends = _registry.list_backends()
-        from abogen.tts_backend_registry import _registry
+        ids = [b.id for b in backends]
-
+        assert "kokoro" in ids
-        meta = _registry.get_metadata("supertonic")
+        assert "supertonic" in ids
-        assert meta.id == "supertonic"
+
-        assert meta.name == "SuperTonic"
+    def test_kokoro_metadata(self):
-        assert "SuperTonic" in meta.description
+        import abogen.tts_backends  # noqa: F401
-
+
-    def test_kokoro_factory_callable(self):
+        from abogen.tts_backend_registry import _registry
-        import abogen.tts_backends  # noqa: F401
+
-
+        meta = _registry.get_metadata("kokoro")
-        from abogen.tts_backend_registry import _registry
+        assert meta.id == "kokoro"
-
+        assert meta.name == "Kokoro"
-        factory = _registry._factories["kokoro"]
+        assert "Kokoro" in meta.description
-        assert callable(factory)
+
-
+    def test_supertonic_metadata(self):
-    def test_supertonic_factory_callable(self):
+        import abogen.tts_backends  # noqa: F401
-        import abogen.tts_backends  # noqa: F401
+
-
+        from abogen.tts_backend_registry import _registry
-        from abogen.tts_backend_registry import _registry
+
-
+        meta = _registry.get_metadata("supertonic")
-        factory = _registry._factories["supertonic"]
+        assert meta.id == "supertonic"
-        assert callable(factory)
+        assert meta.name == "SuperTonic"
+        assert "SuperTonic" in meta.description
+
+    def test_kokoro_metadata_has_voices(self):
+        import abogen.tts_backends  # noqa: F401
+
+        from abogen.tts_backend_registry import _registry
+
+        meta = _registry.get_metadata("kokoro")
+        assert isinstance(meta.voices, tuple)
+        assert len(meta.voices) > 0
+        assert all(isinstance(v, str) for v in meta.voices)
+
+    def test_supertonic_metadata_has_voices(self):
+        import abogen.tts_backends  # noqa: F401
+
+        from abogen.tts_backend_registry import _registry
+
+        meta = _registry.get_metadata("supertonic")
+        assert isinstance(meta.voices, tuple)
+        assert len(meta.voices) == 10
+        assert meta.voices == ("M1", "M2", "M3", "M4", "M5", "F1", "F2", "F3", "F4", "F5")
+
+    def test_kokoro_factory_callable(self):
+        import abogen.tts_backends  # noqa: F401
+
+        from abogen.tts_backend_registry import _registry
+
+        factory = _registry._factories["kokoro"]
+        assert callable(factory)
+
+    def test_supertonic_factory_callable(self):
+        import abogen.tts_backends  # noqa: F401
+
+        from abogen.tts_backend_registry import _registry
+
+        factory = _registry._factories["supertonic"]
+        assert callable(factory)
+
+    def test_kokoro_metadata_voices_match_registry(self):
+        """Ensure the metadata property on the instance shares voices with registry."""
+        from abogen.tts_backends.kokoro import _KOKORO_METADATA
+        from abogen.tts_backend_registry import _registry
+
+        registry_meta = _registry.get_metadata("kokoro")
+        assert _KOKORO_METADATA is registry_meta
+        assert _KOKORO_METADATA.voices == registry_meta.voices
+
+    def test_supertonic_metadata_voices_match_registry(self):
+        """Ensure the metadata property on the instance shares voices with registry."""
+        from abogen.tts_backends.supertonic import _SUPERTONIC_METADATA
+        from abogen.tts_backend_registry import _registry
+
+        registry_meta = _registry.get_metadata("supertonic")
+        assert _SUPERTONIC_METADATA is registry_meta
+        assert _SUPERTONIC_METADATA.voices == registry_meta.voices