openspeechapi 0.1.0__py3-none-any.whl

openspeech/providers/tts/tencent.py

@@ -0,0 +1,189 @@
+"""Tencent Cloud TTS provider adapter (TC3-HMAC-SHA256 signed)."""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+from openspeech.logging_config import logger
+import time
+import uuid
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+import httpx
+
+from openspeech.core.base import TTSProvider
+
+from openspeech.core.enums import Capability, ExecMode, ProviderType
+from openspeech.core.models import AudioChunk, AudioData, TTSOptions
+from openspeech.core.settings import BaseSettings
+
+@dataclass
+class TencentTTSSettings(BaseSettings):
+    secret_id: str = ""
+    secret_key: str = ""
+    voice_type: int = 1001
+    region: str = "ap-guangzhou"
+
+class TencentTTS(TTSProvider):
+    name = "tencent-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = TencentTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"voice_type": [1001, 1002, 1003, 1004, 1005, 1007, 1008, 1009, 1010, 1017, 1018, 101001, 101002], "region": ["ap-guangzhou", "ap-shanghai", "ap-beijing"]}
+
+    _SERVICE = "tts"
+    _HOST = "tts.tencentcloudapi.com"
+
+    def __init__(self, settings: TencentTTSSettings | None = None) -> None:
+        self.settings = settings or TencentTTSSettings()
+        self._client: httpx.AsyncClient | None = None
+        self._owns_client: bool = True
+
+    def set_http_client(self, client) -> None:
+        self._client = client
+        self._owns_client = False
+
+    async def start(self) -> None:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=60.0)
+            self._owns_client = True
+        logger.info("{} provider started", self.name)
+
+    async def stop(self) -> None:
+        if self._client is not None and self._owns_client:
+            await self._client.aclose()
+        self._client = None
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        return bool(self.settings.secret_id) and bool(self.settings.secret_key)
+
+    # ---- TC3-HMAC-SHA256 signing ------------------------------------------------
+
+    def _sign_request(
+        self, action: str, version: str, payload_json: str
+    ) -> dict[str, str]:
+        """Build Tencent Cloud API v3 signed headers."""
+        timestamp = int(time.time())
+        date = datetime.fromtimestamp(timestamp, tz=timezone.utc).strftime(
+            "%Y-%m-%d"
+        )
+
+        # 1. Canonical request
+        http_method = "POST"
+        canonical_uri = "/"
+        canonical_querystring = ""
+        ct = "application/json; charset=utf-8"
+        canonical_headers = (
+            f"content-type:{ct}\nhost:{self._HOST}\nx-tc-action:{action.lower()}\n"
+        )
+        signed_headers = "content-type;host;x-tc-action"
+        hashed_payload = hashlib.sha256(payload_json.encode("utf-8")).hexdigest()
+        canonical_request = (
+            f"{http_method}\n{canonical_uri}\n{canonical_querystring}\n"
+            f"{canonical_headers}\n{signed_headers}\n{hashed_payload}"
+        )
+
+        # 2. String to sign
+        algorithm = "TC3-HMAC-SHA256"
+        credential_scope = f"{date}/{self._SERVICE}/tc3_request"
+        hashed_canonical = hashlib.sha256(
+            canonical_request.encode("utf-8")
+        ).hexdigest()
+        string_to_sign = (
+            f"{algorithm}\n{timestamp}\n{credential_scope}\n{hashed_canonical}"
+        )
+
+        # 3. Signing key
+        secret_date = hmac.new(
+            ("TC3" + self.settings.secret_key).encode("utf-8"),
+            date.encode("utf-8"),
+            hashlib.sha256,
+        ).digest()
+        secret_service = hmac.new(
+            secret_date, self._SERVICE.encode("utf-8"), hashlib.sha256
+        ).digest()
+        secret_signing = hmac.new(
+            secret_service, b"tc3_request", hashlib.sha256
+        ).digest()
+
+        # 4. Signature
+        signature = hmac.new(
+            secret_signing, string_to_sign.encode("utf-8"), hashlib.sha256
+        ).hexdigest()
+
+        authorization = (
+            f"{algorithm} Credential={self.settings.secret_id}/{credential_scope}, "
+            f"SignedHeaders={signed_headers}, Signature={signature}"
+        )
+
+        return {
+            "Authorization": authorization,
+            "Content-Type": ct,
+            "Host": self._HOST,
+            "X-TC-Action": action,
+            "X-TC-Version": version,
+            "X-TC-Timestamp": str(timestamp),
+            "X-TC-Region": self.settings.region,
+        }
+
+    # ---- API call ----------------------------------------------------------------
+
+    async def synthesize(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AudioData:
+        if self._client is None:
+            raise RuntimeError("Provider not started — call start() first")
+        logger.info("{}: request received, text={} chars", self.name, len(text))
+        _t0 = time.perf_counter()
+        opts = opts or TTSOptions()
+
+        session_id = uuid.uuid4().hex
+        payload = {
+            "Text": text,
+            "SessionId": session_id,
+            "VoiceType": self.settings.voice_type,
+            "Codec": "wav",
+            "Volume": 0,
+            "Speed": 0,
+        }
+        payload_json = json.dumps(payload)
+        headers = self._sign_request("TextToVoice", "2019-08-23", payload_json)
+
+        resp = await self._client.post(
+            f"https://{self._HOST}",
+            content=payload_json,
+            headers=headers,
+        )
+        resp.raise_for_status()
+        result = resp.json()
+
+        response = result.get("Response", {})
+        if "Error" in response:
+            err = response["Error"]
+            raise RuntimeError(
+                f"Tencent TTS error [{err.get('Code')}]: {err.get('Message')}"
+            )
+
+        audio_b64 = response.get("Audio", "")
+        audio_bytes = base64.b64decode(audio_b64)
+
+        result = AudioData(
+            data=audio_bytes,
+            sample_rate=16000,
+            channels=1,
+            format=opts.output_format,
+        )
+        logger.info("{}: completed in {:.0f}ms, output={} bytes", self.name, (time.perf_counter() - _t0) * 1000, len(result.data))
+        return result
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        raise NotImplementedError("Tencent TTS streaming not implemented")
+        yield  # noqa: unreachable — makes this an async generator

openspeech/providers/tts/volcengine.py

@@ -0,0 +1,117 @@
+"""Volcengine (ByteDance) TTS provider adapter."""
+from __future__ import annotations
+
+import base64
+from openspeech.logging_config import logger
+import time
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from openspeech.core.base import TTSProvider
+
+from openspeech.core.enums import Capability, ExecMode, ProviderType
+from openspeech.core.models import AudioChunk, AudioData, TTSOptions
+from openspeech.core.settings import BaseSettings
+
+@dataclass
+class VolcengineTTSSettings(BaseSettings):
+    access_token: str = ""
+    app_id: str = ""
+    cluster: str = "volcano_tts"
+    voice_type: str = "BV001_streaming"
+
+class VolcengineTTS(TTSProvider):
+    name = "volcengine-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = VolcengineTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"voice_type": ["BV001_streaming", "BV002_streaming", "BV700_streaming", "BV406_streaming", "BV407_streaming"]}
+
+    def __init__(self, settings: VolcengineTTSSettings | None = None) -> None:
+        self.settings = settings or VolcengineTTSSettings()
+        self._client: httpx.AsyncClient | None = None
+        self._owns_client: bool = True
+
+    def set_http_client(self, client) -> None:
+        self._client = client
+        self._owns_client = False
+
+    async def start(self) -> None:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=60.0)
+            self._owns_client = True
+        logger.info("{} provider started", self.name)
+
+    async def stop(self) -> None:
+        if self._client is not None and self._owns_client:
+            await self._client.aclose()
+        self._client = None
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        return bool(self.settings.access_token) and bool(self.settings.app_id)
+
+    async def synthesize(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AudioData:
+        if self._client is None:
+            raise RuntimeError("Provider not started — call start() first")
+        logger.info("{}: request received, text={} chars", self.name, len(text))
+        _t0 = time.perf_counter()
+        opts = opts or TTSOptions()
+
+        payload = {
+            "app": {
+                "appid": self.settings.app_id,
+                "cluster": self.settings.cluster,
+            },
+            "user": {"uid": "openspeech"},
+            "audio": {
+                "voice_type": self.settings.voice_type,
+                "encoding": "wav",
+                "speed_ratio": opts.speed,
+            },
+            "request": {
+                "text": text,
+                "operation": "query",
+            },
+        }
+        headers = {
+            "Authorization": f"Bearer;{self.settings.access_token}",
+            "Content-Type": "application/json",
+        }
+
+        resp = await self._client.post(
+            "https://openspeech.bytedance.com/api/v1/tts",
+            json=payload,
+            headers=headers,
+        )
+        resp.raise_for_status()
+        result = resp.json()
+
+        if result.get("code") != 0 and result.get("code") is not None:
+            raise RuntimeError(
+                f"Volcengine TTS error: {result.get('message', 'unknown error')}"
+            )
+
+        audio_b64 = result.get("data", "")
+        audio_bytes = base64.b64decode(audio_b64)
+
+        result = AudioData(
+            data=audio_bytes,
+            sample_rate=24000,
+            channels=1,
+            format=opts.output_format,
+        )
+        logger.info("{}: completed in {:.0f}ms, output={} bytes", self.name, (time.perf_counter() - _t0) * 1000, len(result.data))
+        return result
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        raise NotImplementedError("Volcengine TTS streaming not implemented")
+        yield  # noqa: unreachable — makes this an async generator

openspeech/providers/tts/windows_sapi.py

@@ -0,0 +1,234 @@
+"""Windows native TTS provider using SAPI5 via ``pyttsx3``."""
+from __future__ import annotations
+
+import asyncio
+import io
+from openspeech.logging_config import logger
+import os
+import sys
+import tempfile
+import time
+import wave
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from pathlib import Path
+
+from openspeech.core.base import TTSProvider
+
+from openspeech.core.enums import AudioFormat, Capability, ExecMode, ProviderType
+from openspeech.core.models import AudioChunk, AudioData, TTSOptions
+from openspeech.core.settings import BaseSettings
+
+# Language prefix → human-readable group name (reuse same map as macos_say)
+_LANG_GROUP_MAP: dict[str, str] = {
+    "zh": "中文",
+    "en": "English",
+    "ja": "日本語",
+    "ko": "한국어",
+    "fr": "Français",
+    "de": "Deutsch",
+    "es": "Español",
+    "it": "Italiano",
+    "pt": "Português",
+    "ru": "Русский",
+    "ar": "العربية",
+}
+
+@dataclass
+class WindowsSapiSettings(BaseSettings):
+    default_voice: str = ""      # Empty = system default; or voice name substring
+    default_rate: int = 200      # pyttsx3 rate (words per minute)
+
+class WindowsSapiTTS(TTSProvider):
+    """Windows native TTS via SAPI5 (pyttsx3)."""
+
+    name = "windows-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = WindowsSapiSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+
+    def __init__(self, settings: WindowsSapiSettings | None = None) -> None:
+        self.settings = settings or WindowsSapiSettings()
+        self._available: bool = False
+        self._voices_cache: list[dict] | None = None
+
+    # -- lifecycle ------------------------------------------------------------
+
+    async def start(self) -> None:
+        if sys.platform != "win32":
+            raise RuntimeError(
+                "Windows TTS (SAPI5) is only available on Windows"
+            )
+        try:
+            import pyttsx3  # noqa: F401
+        except ImportError:
+            raise RuntimeError(
+                "pyttsx3 is required for Windows TTS. "
+                "Install with: pip install pyttsx3"
+            )
+        # Quick validation: ensure engine can be created
+        await asyncio.to_thread(self._validate_engine)
+        self._available = True
+        logger.info("{} provider started", self.name)
+
+    async def stop(self) -> None:
+        self._available = False
+        self._voices_cache = None
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        if self._available:
+            return True
+        if sys.platform != "win32":
+            return False
+        try:
+            import pyttsx3  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    # -- synthesis ------------------------------------------------------------
+
+    async def synthesize(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AudioData:
+        if not self._available:
+            raise RuntimeError("Provider not started — call start() first")
+        logger.info("{}: request received, text={} chars", self.name, len(text))
+        _t0 = time.perf_counter()
+
+        opts = opts or TTSOptions()
+        voice_hint = opts.voice or self.settings.default_voice
+        rate = int(self.settings.default_rate * opts.speed)
+
+        wav_bytes = await asyncio.to_thread(
+            self._synthesize_sync, text, voice_hint, rate,
+        )
+
+        # Parse WAV to extract real sample_rate/channels/duration
+        with wave.open(io.BytesIO(wav_bytes), "rb") as wf:
+            sample_rate = wf.getframerate()
+            channels = wf.getnchannels()
+            n_frames = wf.getnframes()
+            duration_ms = int(n_frames / sample_rate * 1000) if sample_rate else 0
+
+        result = AudioData(
+            data=wav_bytes,
+            sample_rate=sample_rate,
+            channels=channels,
+            format=AudioFormat.WAV,
+            duration_ms=duration_ms,
+        )
+        logger.info("{}: completed in {:.0f}ms, output={} bytes", self.name, (time.perf_counter() - _t0) * 1000, len(result.data))
+        return result
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        """Batch-then-chunk fallback: synthesize full audio, then yield chunks."""
+        logger.info("{}: stream request, text={} chars", self.name, len(text))
+        _t0 = time.perf_counter()
+        result = await self.synthesize(text, opts)
+        chunk_size = 4096
+        sequence = 0
+        chunk_count = 0
+        for i in range(0, len(result.data), chunk_size):
+            chunk_data = result.data[i : i + chunk_size]
+            logger.debug("{}: chunk #{}, {} bytes", self.name, sequence, len(chunk_data))
+            yield AudioChunk(data=chunk_data, sequence=sequence)
+            sequence += 1
+            chunk_count += 1
+        yield AudioChunk(data=b"", sequence=sequence, is_final=True)
+        logger.info("{}: stream complete, {} chunks in {:.0f}ms", self.name, chunk_count, (time.perf_counter() - _t0) * 1000)
+
+    # -- voices ---------------------------------------------------------------
+
+    async def list_voices(self) -> list[dict]:
+        if self._voices_cache is not None:
+            return self._voices_cache
+
+        voices = await asyncio.to_thread(self._list_voices_sync)
+        self._voices_cache = voices
+        return self._voices_cache
+
+    # -- internal helpers (sync, run in thread) --------------------------------
+
+    @staticmethod
+    def _validate_engine() -> None:
+        """Create and immediately dispose a pyttsx3 engine to verify SAPI5."""
+        import pyttsx3
+        engine = pyttsx3.init("sapi5")
+        engine.stop()
+
+    @staticmethod
+    def _synthesize_sync(text: str, voice_hint: str, rate: int) -> bytes:
+        """Synchronous TTS: create engine, synthesize to WAV, return bytes."""
+        import pyttsx3
+
+        engine = pyttsx3.init("sapi5")
+        try:
+            # Set rate
+            engine.setProperty("rate", rate)
+
+            # Resolve and set voice
+            if voice_hint:
+                voices = engine.getProperty("voices")
+                hint_lower = voice_hint.lower()
+                for v in voices:
+                    if hint_lower in v.name.lower() or hint_lower in v.id.lower():
+                        engine.setProperty("voice", v.id)
+                        break
+
+            # Synthesize to temp WAV file
+            fd, tmp_path = tempfile.mkstemp(suffix=".wav")
+            os.close(fd)
+            try:
+                engine.save_to_file(text, tmp_path)
+                engine.runAndWait()
+                wav_bytes = Path(tmp_path).read_bytes()
+            finally:
+                try:
+                    Path(tmp_path).unlink(missing_ok=True)
+                except OSError:
+                    pass
+
+            return wav_bytes
+        finally:
+            engine.stop()
+
+    @staticmethod
+    def _list_voices_sync() -> list[dict]:
+        """List SAPI5 voices synchronously."""
+        import pyttsx3
+
+        engine = pyttsx3.init("sapi5")
+        try:
+            voices = engine.getProperty("voices")
+            result: list[dict] = []
+            for v in voices:
+                # SAPI voice language is in v.languages (list of bytes)
+                # or can be parsed from v.id
+                lang_str = ""
+                if v.languages:
+                    # pyttsx3 gives languages as list; first entry is primary
+                    raw = v.languages[0]
+                    if isinstance(raw, bytes):
+                        lang_str = raw.decode("utf-8", errors="replace").strip("\x00")
+                    elif isinstance(raw, str):
+                        lang_str = raw
+
+                # Derive group from language
+                lang_prefix = lang_str.split("-")[0].split("_")[0].lower() if lang_str else ""
+                group = _LANG_GROUP_MAP.get(lang_prefix, lang_prefix.upper()) if lang_prefix else "Other"
+
+                result.append({
+                    "name": v.name,
+                    "language": lang_str,
+                    "description": getattr(v, "description", "") or "",
+                    "group": group,
+                    "id": v.id,
+                })
+            return result
+        finally:
+            engine.stop()

openspeech/server/__init__.py

@@ -0,0 +1 @@
+"""OpenSpeech FastAPI server."""

openspeech/server/app.py

@@ -0,0 +1,72 @@
+"""FastAPI application wrapping ServiceDispatcher."""
+from __future__ import annotations
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, Request
+
+from openspeech.config import load_config
+from openspeech.core.registry import ProviderRegistry
+from openspeech.dispatch.dispatcher import ServiceDispatcher
+from openspeech.dispatch.watcher import ConfigWatcher
+from openspeech.local_engines import EngineManager
+from openspeech.logging_config import ensure_configured
+from openspeech.server.middleware import RequestContextMiddleware
+from openspeech.server.routes import stt, tts, management, webui
+from openspeech.server.ws import stt_stream, tts_stream
+
+
+def create_app(config_path: Path, registry: ProviderRegistry) -> FastAPI:
+    """Create FastAPI app with dispatcher lifecycle."""
+    ensure_configured()
+    dispatcher = ServiceDispatcher.from_config(config_path, registry)
+    config = load_config(config_path)
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        await dispatcher.start()
+
+        async def _on_reload() -> dict:
+            return await dispatcher.reload_config(config_path, registry)
+
+        watcher = ConfigWatcher(config_path, on_reload=_on_reload)
+        watcher.start()
+
+        yield
+
+        await watcher.stop()
+        await dispatcher.stop()
+
+    app = FastAPI(title="OpenSpeech API", version="0.1.0", lifespan=lifespan)
+    app.state.dispatcher = dispatcher
+    app.state.config_path = config_path
+    app.state.registry = registry
+    app.state.server_config = config.server
+    app.state.engine_manager = EngineManager()
+
+    # Request-scoped logging context (request_id + route timing) — added first
+    # so that auth-middleware rejections still get logged with a request_id.
+    app.add_middleware(RequestContextMiddleware)
+
+    # Conditionally add authentication middleware
+    if config.server.auth_enabled and config.server.api_keys:
+        from openspeech.server.auth import AuthMiddleware
+        app.add_middleware(AuthMiddleware, api_keys=config.server.api_keys)
+
+    # Register routes
+    app.include_router(stt.router, prefix="/v1/stt", tags=["STT"])
+    app.include_router(tts.router, prefix="/v1/tts", tags=["TTS"])
+    app.include_router(management.router, prefix="/v1", tags=["Management"])
+    app.include_router(webui.router, tags=["WebUI"])
+
+    # Register WebSocket endpoints
+    app.include_router(stt_stream.router, prefix="/v1/stt", tags=["STT Streaming"])
+    app.include_router(tts_stream.router, prefix="/v1/tts", tags=["TTS Streaming"])
+
+    return app
+
+
+def get_dispatcher(request: Request) -> ServiceDispatcher:
+    """Dependency to get dispatcher from app state."""
+    return request.app.state.dispatcher

openspeech/server/auth.py

@@ -0,0 +1,42 @@
+"""API Key authentication middleware."""
+from __future__ import annotations
+import json
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+# Exempt paths (no auth required)
+EXEMPT_PATHS = {"/v1/health", "/docs", "/openapi.json", "/redoc"}
+EXEMPT_PREFIXES = ("/ui",)
+
+
+def _unauthorized(detail: str) -> JSONResponse:
+    return JSONResponse(status_code=401, content={"detail": detail})
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, api_keys: list[str]) -> None:
+        super().__init__(app)
+        self._api_keys = set(api_keys)
+
+    async def dispatch(self, request: Request, call_next):
+        # Skip auth for exempt paths
+        if request.url.path in EXEMPT_PATHS:
+            return await call_next(request)
+        if request.url.path.startswith(EXEMPT_PREFIXES):
+            return await call_next(request)
+
+        # Skip auth for WebSocket (handled separately via query param)
+        if request.scope.get("type") == "websocket":
+            return await call_next(request)
+
+        # Check Bearer token
+        auth_header = request.headers.get("Authorization", "")
+        if not auth_header.startswith("Bearer "):
+            return _unauthorized("Missing or invalid Authorization header")
+
+        token = auth_header[7:]  # Strip "Bearer "
+        if token not in self._api_keys:
+            return _unauthorized("Invalid API key")
+
+        return await call_next(request)