openspeechapi 0.1.0__py3-none-any.whl

openspeech/factory.py

@@ -0,0 +1,325 @@
+"""High-level factory — create providers by string name, no class imports needed."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from openspeech.core.base import SpeechProvider
+from openspeech.exceptions import ProviderNotFoundError
+
+# Lazy registry: name → (module_path, class_name, settings_class_name)
+_PROVIDER_MAP: dict[str, tuple[str, str, str]] = {
+    # STT
+    "openai-stt": (
+        "openspeech.providers.stt.openai",
+        "OpenAISTT",
+        "OpenAISTTSettings",
+    ),
+    "faster-whisper": (
+        "openspeech.providers.stt.faster_whisper",
+        "FasterWhisperSTT",
+        "FasterWhisperSTTSettings",
+    ),
+    "whisper": (
+        "openspeech.providers.stt.whisper",
+        "WhisperSTT",
+        "WhisperSTTSettings",
+    ),
+    "deepgram": (
+        "openspeech.providers.stt.deepgram",
+        "DeepgramSTT",
+        "DeepgramSTTSettings",
+    ),
+    "elevenlabs-stt": (
+        "openspeech.providers.stt.elevenlabs",
+        "ElevenLabsSTT",
+        "ElevenLabsSTTSettings",
+    ),
+    "deepgram-tts": (
+        "openspeech.providers.tts.deepgram",
+        "DeepgramTTS",
+        "DeepgramTTSSettings",
+    ),
+    "whisperlivekit-stt": (
+        "openspeech.providers.stt.whisperlivekit",
+        "WhisperLiveKitSTT",
+        "WhisperLiveKitSTTSettings",
+    ),
+    "sherpa-onnx-stt": (
+        "openspeech.providers.stt.sherpa_onnx",
+        "SherpaOnnxSTT",
+        "SherpaOnnxSTTSettings",
+    ),
+    # TTS
+    "openai-tts": (
+        "openspeech.providers.tts.openai",
+        "OpenAITTS",
+        "OpenAITTSSettings",
+    ),
+    "elevenlabs": (
+        "openspeech.providers.tts.elevenlabs",
+        "ElevenLabsTTS",
+        "ElevenLabsTTSSettings",
+    ),
+    "piper": (
+        "openspeech.providers.tts.piper",
+        "PiperTTS",
+        "PiperTTSSettings",
+    ),
+    "coqui": (
+        "openspeech.providers.tts.coqui",
+        "CoquiTTS",
+        "CoquiTTSSettings",
+    ),
+    "cosyvoice": (
+        "openspeech.providers.tts.cosyvoice",
+        "CosyVoiceTTS",
+        "CosyVoiceTTSSettings",
+    ),
+    "fish-speech": (
+        "openspeech.providers.tts.fish_speech",
+        "FishSpeechTTS",
+        "FishSpeechTTSSettings",
+    ),
+    "minimax": (
+        "openspeech.providers.tts.minimax",
+        "MinimaxTTS",
+        "MinimaxTTSSettings",
+    ),
+    "macos-say": (
+        "openspeech.providers.tts.macos_say",
+        "MacOSSayTTS",
+        "MacOSSaySettings",
+    ),
+    "macos-stt": (
+        "openspeech.providers.stt.macos_speech",
+        "MacOSSpeechSTT",
+        "MacOSSpeechSettings",
+    ),
+    # Windows Native
+    "windows-tts": (
+        "openspeech.providers.tts.windows_sapi",
+        "WindowsSapiTTS",
+        "WindowsSapiSettings",
+    ),
+    "windows-stt": (
+        "openspeech.providers.stt.windows_speech",
+        "WindowsSpeechSTT",
+        "WindowsSpeechSettings",
+    ),
+    # Cloud STT
+    "google-stt": (
+        "openspeech.providers.stt.google_cloud",
+        "GoogleCloudSTT",
+        "GoogleCloudSTTSettings",
+    ),
+    "azure-stt": (
+        "openspeech.providers.stt.azure_speech",
+        "AzureSpeechSTT",
+        "AzureSpeechSTTSettings",
+    ),
+    "assemblyai-stt": (
+        "openspeech.providers.stt.assemblyai",
+        "AssemblyAISTT",
+        "AssemblyAISTTSettings",
+    ),
+    "volcengine-stt": (
+        "openspeech.providers.stt.volcengine",
+        "VolcengineSTT",
+        "VolcengineSTTSettings",
+    ),
+    "alibaba-stt": (
+        "openspeech.providers.stt.alibaba",
+        "AlibabaSTT",
+        "AlibabaSTTSettings",
+    ),
+    "tencent-stt": (
+        "openspeech.providers.stt.tencent",
+        "TencentSTT",
+        "TencentSTTSettings",
+    ),
+    "baidu-stt": (
+        "openspeech.providers.stt.baidu",
+        "BaiduSTT",
+        "BaiduSTTSettings",
+    ),
+    "iflytek-stt": (
+        "openspeech.providers.stt.iflytek",
+        "IflytekSTT",
+        "IflytekSTTSettings",
+    ),
+    # Cloud TTS
+    "google-tts": (
+        "openspeech.providers.tts.google_cloud",
+        "GoogleCloudTTS",
+        "GoogleCloudTTSSettings",
+    ),
+    "azure-tts": (
+        "openspeech.providers.tts.azure_speech",
+        "AzureSpeechTTS",
+        "AzureSpeechTTSSettings",
+    ),
+    "volcengine-tts": (
+        "openspeech.providers.tts.volcengine",
+        "VolcengineTTS",
+        "VolcengineTTSSettings",
+    ),
+    "alibaba-tts": (
+        "openspeech.providers.tts.alibaba",
+        "AlibabaTTS",
+        "AlibabaTTSSettings",
+    ),
+    "tencent-tts": (
+        "openspeech.providers.tts.tencent",
+        "TencentTTS",
+        "TencentTTSSettings",
+    ),
+    "baidu-tts": (
+        "openspeech.providers.tts.baidu",
+        "BaiduTTS",
+        "BaiduTTSSettings",
+    ),
+    "iflytek-tts": (
+        "openspeech.providers.tts.iflytek",
+        "IflytekTTS",
+        "IflytekTTSSettings",
+    ),
+}
+
+
+# Platform-generic aliases that resolve to the correct native provider.
+_NATIVE_ALIASES: dict[str, dict[str, str]] = {
+    "native-tts": {"darwin": "macos-say", "win32": "windows-tts"},
+    "native-stt": {"darwin": "macos-stt", "win32": "windows-stt"},
+}
+
+
+def _resolve_native(alias: str) -> str:
+    """Map a ``native-*`` alias to the concrete provider name for this OS."""
+    platform_map = _NATIVE_ALIASES.get(alias)
+    if platform_map is None:
+        raise ProviderNotFoundError(f"Unknown native alias '{alias}'")
+    concrete = platform_map.get(sys.platform)
+    if concrete is None:
+        supported = ", ".join(sorted(platform_map.keys()))
+        raise ProviderNotFoundError(
+            f"No native provider for platform '{sys.platform}'. "
+            f"Supported: {supported}"
+        )
+    return concrete
+
+
+def _resolve(name: str) -> tuple[type, type]:
+    """Lazily import and return (ProviderClass, SettingsClass).
+
+    Raises ``ProviderNotFoundError`` with a ``pip install`` hint when the
+    provider's optional extras are not installed.
+    """
+    import importlib
+
+    # Handle native aliases
+    if name in _NATIVE_ALIASES:
+        name = _resolve_native(name)
+
+    entry = _PROVIDER_MAP.get(name)
+    if entry is None:
+        available = ", ".join(sorted(_PROVIDER_MAP))
+        raise ProviderNotFoundError(
+            f"Unknown provider '{name}'. Available: {available}"
+        )
+
+    module_path, cls_name, settings_name = entry
+    try:
+        mod = importlib.import_module(module_path)
+    except ImportError as e:
+        raise ProviderNotFoundError(
+            f"Provider '{name}' requires optional dependencies that are not installed. "
+            f"Install with:  pip install 'openspeech[{name}]'  "
+            f"(missing: {e.name or e})"
+        ) from e
+    return getattr(mod, cls_name), getattr(mod, settings_name)
+
+
+def _resolve_from_config(prov_cfg) -> tuple[type, type]:
+    """Resolve provider class from a ProviderConfig.
+
+    If the config specifies ``module`` and ``provider_class``, use importlib
+    to load the class dynamically.  Otherwise fall back to the built-in
+    ``_PROVIDER_MAP`` via ``_resolve()``.
+    """
+    import importlib
+
+    if prov_cfg.module and prov_cfg.provider_class:
+        mod = importlib.import_module(prov_cfg.module)
+        provider_cls = getattr(mod, prov_cfg.provider_class)
+        settings_cls = getattr(provider_cls, "settings_cls", None)
+        return provider_cls, settings_cls
+
+    return _resolve(prov_cfg.provider)
+
+
+def _ensure_plugins_dir(project_root: Path | None = None) -> None:
+    """Add ``<project_root>/plugins`` to *sys.path* if the directory exists."""
+    if project_root is None:
+        project_root = Path.cwd()
+    plugins_dir = project_root / "plugins"
+    if plugins_dir.is_dir():
+        plugins_str = str(plugins_dir)
+        if plugins_str not in sys.path:
+            sys.path.insert(0, plugins_str)
+
+
+def create_provider(name: str, **settings: Any) -> SpeechProvider:
+    """Create a provider instance by name.
+
+    Usage::
+
+        tts = create_provider("openai-tts", api_key="sk-...")
+        stt = create_provider("faster-whisper", model_size="tiny")
+
+    """
+    provider_cls, settings_cls = _resolve(name)
+    s = settings_cls(**settings)
+    return provider_cls(settings=s)
+
+
+def list_providers() -> list[str]:
+    """Return all registered provider names."""
+    return sorted(_PROVIDER_MAP)
+
+
+def create_default_registry() -> "ProviderRegistry":
+    """Build a ProviderRegistry pre-populated with all known providers.
+
+    Resolves all entries in ``_PROVIDER_MAP`` and ``_NATIVE_ALIASES``,
+    silently skipping any whose dependencies are missing.
+    """
+    from openspeech.core.registry import ProviderRegistry
+
+    from openspeech.logging_config import logger
+
+    _ensure_plugins_dir()
+    registry = ProviderRegistry()
+    skipped: list[str] = []
+    for name in _PROVIDER_MAP:
+        try:
+            provider_cls, _ = _resolve(name)
+            registry.register(name, provider_cls)
+        except ProviderNotFoundError as e:
+            skipped.append(name)
+            logger.debug(f"skip provider '{name}': {e}")
+        except Exception as e:
+            logger.debug(f"skip provider '{name}' (unexpected): {e}")
+    for alias in _NATIVE_ALIASES:
+        try:
+            provider_cls, _ = _resolve(alias)
+            registry.register(alias, provider_cls)
+        except Exception as e:
+            logger.debug(f"skip native alias '{alias}': {e}")
+    if skipped:
+        logger.info(
+            f"{len(skipped)} provider(s) unavailable due to missing optional deps: "
+            f"{', '.join(skipped)}. Install e.g. `pip install 'openspeech[<name>]'`."
+        )
+    return registry

openspeech/local_engines/__init__.py

@@ -0,0 +1,12 @@
+"""Local engine manager exports."""
+
+from openspeech.local_engines.manager import EngineManager
+from openspeech.local_engines.models import EngineAction, EngineStatus, RuntimeConfig, TaskStatus
+
+__all__ = [
+    "EngineAction",
+    "EngineManager",
+    "EngineStatus",
+    "RuntimeConfig",
+    "TaskStatus",
+]

openspeech/local_engines/aim_resolver.py

@@ -0,0 +1,91 @@
+"""Resolve model paths from AIM CLI output."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+from typing import Any
+
+
+def _run_aim(args: list[str]) -> str:
+    proc = subprocess.run(
+        ["aim", *args],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError((proc.stderr or proc.stdout or "").strip() or f"aim {' '.join(args)} failed")
+    return (proc.stdout or "").strip()
+
+
+def _parse_aim_resolve_json(raw: str) -> dict[str, Any]:
+    data = json.loads(raw)
+    if not isinstance(data, dict):
+        return {}
+    return data
+
+
+def resolve_aim_model_paths(
+    *,
+    model_ids: list[str],
+    provision_engine: str = "whisper",
+    kind: str = "any",
+) -> list[str]:
+    """Return absolute model paths for requested model IDs from AIM CLI.
+
+    Args:
+        model_ids: model IDs in priority order.
+        provision_engine: target engine filter.
+        kind: "file", "dir", or "any".
+    """
+    ids = [x.strip() for x in model_ids if str(x).strip()]
+    if not ids:
+        return []
+
+    out: list[str] = []
+    seen: set[str] = set()
+    for mid in ids:
+        try:
+            resolved = _parse_aim_resolve_json(
+                _run_aim(["resolve", mid, "--engine", provision_engine, "--json"])
+            )
+        except Exception:
+            continue
+        engines = resolved.get("engines", [])
+        if isinstance(engines, list) and engines:
+            if provision_engine and provision_engine not in {str(x).strip() for x in engines}:
+                continue
+
+        resolved_path = str(resolved.get("path", "")).strip()
+        if not resolved_path:
+            continue
+        abs_path = Path(resolved_path).expanduser()
+        abs_str = str(abs_path)
+        if abs_str not in seen:
+            seen.add(abs_str)
+            out.append(abs_str)
+
+        resolved_file = str(resolved.get("resolved_file", "") or "").strip()
+        if resolved_file:
+            rf = str(Path(resolved_file).expanduser())
+            if rf not in seen:
+                seen.add(rf)
+                out.append(rf)
+
+        # whisper-style canonical directory often contains .pt/.bin payload files.
+        if abs_path.is_dir():
+            for p in sorted(abs_path.iterdir()):
+                if p.is_file() and p.suffix.lower() in {".pt", ".bin"}:
+                    f = str(p)
+                    if f not in seen:
+                        seen.add(f)
+                        out.append(f)
+
+    if kind == "any":
+        return out
+    if kind == "file":
+        return [x for x in out if Path(x).is_file() or Path(x).suffix.lower() in {".pt", ".bin"}]
+    if kind == "dir":
+        return [x for x in out if Path(x).is_dir() or (not Path(x).suffix and not x.endswith(".pt"))]
+    return out

openspeech/local_engines/backends/__init__.py

@@ -0,0 +1 @@
+"""Runtime backend implementations."""