openspeechapi 0.1.0__py3-none-any.whl

openspeech/providers/tts/fish_speech.py

@@ -0,0 +1,158 @@
+"""Fish-Speech TTS provider adapter (HTTP API, in-process)."""
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+import io
+from openspeech.logging_config import logger
+import time
+from typing import Any
+from urllib.parse import urljoin
+import wave
+
+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
+
+@dataclass
+class FishSpeechTTSSettings(BaseSettings):
+    api_url: str = "http://localhost:8080"
+    reference_audio: str | None = None
+    reference_id: str | None = None
+    timeout_s: float = 60.0
+    retries: int = 0
+    health_path: str = "/health"
+    format: str = "wav"
+    latency: str = "balanced"
+    chunk_length: int = 200
+    max_new_tokens: int = 1024
+    top_p: float = 0.8
+    repetition_penalty: float = 1.1
+    temperature: float = 0.8
+    use_memory_cache: str = "on"
+    normalize: bool = True
+
+class FishSpeechTTS(TTSProvider):
+    name = "fish-speech"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = FishSpeechTTSSettings
+    capabilities = {Capability.STREAMING, Capability.VOICE_CLONE}
+    field_options = {
+        "format": ["wav", "mp3", "flac", "opus"],
+        "latency": ["normal", "balanced"],
+    }
+
+    def __init__(self, settings: FishSpeechTTSSettings | None = None) -> None:
+        self.settings = settings or FishSpeechTTSSettings()
+        self._client: Any = 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:
+            try:
+                import httpx
+            except ImportError:
+                raise ImportError(
+                    "Install httpx: pip install openspeech[fish-speech]"
+                )
+            # Ignore process-level proxy env vars by default to avoid accidental SOCKS deps.
+            self._client = httpx.AsyncClient(timeout=self.settings.timeout_s, trust_env=False)
+            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:
+        if self._client is None:
+            return False
+        try:
+            url = urljoin(self.settings.api_url.rstrip("/") + "/", self.settings.health_path.lstrip("/"))
+            resp = await self._client.get(url)
+            return resp.status_code < 500
+        except Exception:
+            return False
+
+    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: dict[str, Any] = {
+            "text": text,
+            "format": self.settings.format,
+            "latency": self.settings.latency,
+            "chunk_length": self.settings.chunk_length,
+            "max_new_tokens": self.settings.max_new_tokens,
+            "top_p": self.settings.top_p,
+            "repetition_penalty": self.settings.repetition_penalty,
+            "temperature": self.settings.temperature,
+            "use_memory_cache": self.settings.use_memory_cache,
+            "normalize": self.settings.normalize,
+        }
+        if opts.voice:
+            payload["voice"] = opts.voice
+        if opts.speed and opts.speed != 1.0:
+            payload["speed"] = opts.speed
+        if self.settings.reference_audio:
+            payload["reference_audio"] = self.settings.reference_audio
+        if self.settings.reference_id:
+            payload["reference_id"] = self.settings.reference_id
+        last_exc: Exception | None = None
+        response = None
+        attempts = max(0, self.settings.retries) + 1
+        for _ in range(attempts):
+            try:
+                response = await self._client.post(
+                    f"{self.settings.api_url}/v1/tts",
+                    json=payload,
+                )
+                break
+            except Exception as exc:  # noqa: BLE001
+                last_exc = exc
+        if response is None:
+            raise RuntimeError(f"Fish-Speech request failed: {last_exc}") from last_exc
+        response.raise_for_status()
+        duration_ms = self._wav_duration_ms(response.content)
+        result = AudioData(
+            data=response.content,
+            sample_rate=44100,
+            channels=1,
+            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]:
+        raise NotImplementedError(
+            "FishSpeechTTS.synthesize_stream() is not yet implemented"
+        )
+        yield  # pragma: no cover
+
+    @staticmethod
+    def _wav_duration_ms(data: bytes) -> int | None:
+        try:
+            with wave.open(io.BytesIO(data), "rb") as wf:
+                sample_rate = wf.getframerate()
+                if sample_rate <= 0:
+                    return None
+                frames = wf.getnframes()
+                return int((frames / sample_rate) * 1000)
+        except Exception:
+            return None

openspeech/providers/tts/google_cloud.py

@@ -0,0 +1,107 @@
+"""Google Cloud TTS provider adapter (batch, httpx)."""
+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 AudioFormat, Capability, ExecMode, ProviderType
+from openspeech.core.models import AudioChunk, AudioData, TTSOptions
+from openspeech.core.settings import BaseSettings
+
+@dataclass
+class GoogleCloudTTSSettings(BaseSettings):
+    api_key: str = ""
+    language: str = "en-US"
+    voice_name: str = "en-US-Standard-A"
+    speaking_rate: float = 1.0
+
+class GoogleCloudTTS(TTSProvider):
+    name = "google-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.REMOTE
+    settings_cls = GoogleCloudTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"language": ["en-US", "zh-CN", "ja-JP", "ko-KR", "es-ES", "fr-FR", "de-DE", "pt-BR"], "voice_name": ["en-US-Standard-A", "en-US-Standard-B", "en-US-Standard-C", "en-US-Standard-D", "en-US-Wavenet-A", "en-US-Wavenet-B", "zh-CN-Standard-A", "zh-CN-Standard-B", "zh-CN-Standard-C", "zh-CN-Standard-D", "zh-CN-Wavenet-A", "ja-JP-Standard-A", "ja-JP-Standard-B"]}
+
+    def __init__(self, settings: GoogleCloudTTSSettings | None = None) -> None:
+        self.settings = settings or GoogleCloudTTSSettings()
+        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.api_key)
+
+    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()
+        voice_name = opts.voice or self.settings.voice_name
+        language = self.settings.language
+        speaking_rate = opts.speed if opts.speed != 1.0 else self.settings.speaking_rate
+
+        url = (
+            "https://texttospeech.googleapis.com/v1/text:synthesize"
+            f"?key={self.settings.api_key}"
+        )
+        body = {
+            "input": {"text": text},
+            "voice": {
+                "languageCode": language,
+                "name": voice_name,
+            },
+            "audioConfig": {
+                "audioEncoding": "LINEAR16",
+                "speakingRate": speaking_rate,
+            },
+        }
+        response = await self._client.post(url, json=body)
+        if response.status_code != 200:
+            raise RuntimeError(
+                f"Google Cloud TTS API error {response.status_code}: {response.text}"
+            )
+        data = response.json()
+        audio_bytes = base64.b64decode(data["audioContent"])
+        result = AudioData(
+            data=audio_bytes,
+            sample_rate=24000,
+            channels=1,
+            format=AudioFormat.WAV,
+        )
+        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(
+            "Google Cloud TTS batch provider does not support streaming output"
+        )
+        yield  # pragma: no cover

openspeech/providers/tts/iflytek.py

@@ -0,0 +1,209 @@
+"""iFlytek (讯飞) TTS provider adapter — WebSocket-based."""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+from openspeech.logging_config import logger
+import urllib.parse
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from email.utils import formatdate
+from typing import Any
+
+import httpx
+import websockets
+
+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 IflytekTTSSettings(BaseSettings):
+    app_id: str = ""
+    api_key: str = ""
+    api_secret: str = ""
+    voice: str = "xiaoyan"
+    speed: int = 50
+
+class IflytekTTS(TTSProvider):
+    name = "iflytek-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = IflytekTTSSettings
+    capabilities = {Capability.BATCH, Capability.STREAMING, Capability.MULTILINGUAL}
+    field_options = {"voice": [
+        "xiaoyan", "aisjiuxu", "aisxping", "aisjinger", "aisbabyxu",
+        "x4_lingxiaolu_em", "x4_lingfeizhe_em", "xiaoyu", "xiaoqi",
+        "xiaofeng", "xiaomei", "xiaolin", "xiaorong", "xiaoqian",
+        "catherine", "john", "laura", "yuka", "xiaoqiukor",
+    ]}
+
+    _WS_HOST = "tts-api.xfyun.cn"
+    _WS_PATH = "/v2/tts"
+
+    def __init__(self, settings: IflytekTTSSettings | None = None) -> None:
+        self.settings = settings or IflytekTTSSettings()
+        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
+
+    async def stop(self) -> None:
+        if self._client is not None and self._owns_client:
+            await self._client.aclose()
+        self._client = None
+
+    async def health_check(self) -> bool:
+        return bool(self.settings.app_id) and bool(self.settings.api_key) and bool(self.settings.api_secret)
+
+    def _build_auth_url(self) -> str:
+        """Build HMAC-SHA256 signed WebSocket URL."""
+        now = datetime.now(tz=timezone.utc)
+        date = formatdate(timeval=now.timestamp(), localtime=False, usegmt=True)
+
+        signature_origin = (
+            f"host: {self._WS_HOST}\n"
+            f"date: {date}\n"
+            f"GET {self._WS_PATH} HTTP/1.1"
+        )
+        signature_sha = hmac.new(
+            self.settings.api_secret.encode("utf-8"),
+            signature_origin.encode("utf-8"),
+            hashlib.sha256,
+        ).digest()
+        signature = base64.b64encode(signature_sha).decode("utf-8")
+
+        authorization_origin = (
+            f'api_key="{self.settings.api_key}", '
+            f'algorithm="hmac-sha256", '
+            f'headers="host date request-line", '
+            f'signature="{signature}"'
+        )
+        authorization = base64.b64encode(
+            authorization_origin.encode("utf-8")
+        ).decode("utf-8")
+
+        params = urllib.parse.urlencode(
+            {"authorization": authorization, "date": date, "host": self._WS_HOST}
+        )
+        return f"wss://{self._WS_HOST}{self._WS_PATH}?{params}"
+
+    async def synthesize(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AudioData:
+        """Batch synthesize by collecting all stream chunks."""
+        parts: list[bytes] = []
+        async for chunk in self.synthesize_stream(text, opts):
+            parts.append(chunk.data)
+        audio_bytes = b"".join(parts)
+        logger.info("iFlytek TTS: {} chunks, {} MP3 bytes total", len(parts), len(audio_bytes))
+        return AudioData(
+            data=audio_bytes,
+            sample_rate=16000,
+            channels=1,
+            format="mp3",
+        )
+
+    # iFlytek voice catalog — vcn → (display name, language, group)
+    _VOICES = [
+        # 中文
+        ("xiaoyan",           "小燕 — 中文女声",         "zh_cn", "中文"),
+        ("aisjiuxu",          "许久 — 中文男声",         "zh_cn", "中文"),
+        ("aisxping",          "小萍 — 中文女声",         "zh_cn", "中文"),
+        ("aisjinger",         "小婧 — 中文女声",         "zh_cn", "中文"),
+        ("aisbabyxu",         "许小宝 — 童声",           "zh_cn", "中文"),
+        ("x4_lingxiaolu_em",  "凌小路 — 情感男声",       "zh_cn", "中文"),
+        ("x4_lingfeizhe_em",  "凌飞哲 — 情感男声",       "zh_cn", "中文"),
+        ("xiaoyu",            "小宇 — 中文男声",         "zh_cn", "中文"),
+        ("xiaoqi",            "小琪 — 中文女声",         "zh_cn", "中文"),
+        ("xiaofeng",          "小峰 — 中文男声",         "zh_cn", "中文"),
+        ("xiaomei",           "小梅 — 粤语女声",         "zh_cn", "粤语"),
+        ("xiaolin",           "小林 — 台湾女声",         "zh_cn", "中文"),
+        ("xiaorong",          "小蓉 — 四川女声",         "zh_cn", "方言"),
+        ("xiaoqian",          "小芊 — 东北女声",         "zh_cn", "方言"),
+        # English
+        ("catherine",         "Catherine — English Female", "en_us", "English"),
+        ("john",              "John — English Male",        "en_us", "English"),
+        ("laura",             "Laura — English Female",     "en_us", "English"),
+        # Japanese
+        ("yuka",              "Yuka — Japanese Female",     "ja_jp", "日本語"),
+        # Korean
+        ("xiaoqiukor",        "小秋 — Korean Female",       "ko_kr", "한국어"),
+    ]
+
+    def _build_ws_message(self, text: str, voice: str | None = None, speed: float | None = None) -> dict:
+        """Build the WebSocket request message."""
+        vcn = voice or self.settings.voice
+        spd = int(speed * 50) if speed and speed != 1.0 else self.settings.speed
+        text_b64 = base64.b64encode(text.encode("utf-8")).decode("utf-8")
+        return {
+            "common": {"app_id": self.settings.app_id},
+            "business": {
+                "aue": "lame",
+                "sfl": 1,
+                "vcn": vcn,
+                "speed": spd,
+                "tte": "UTF8",
+            },
+            "data": {
+                "status": 2,
+                "text": text_b64,
+            },
+        }
+
+    async def list_voices(self) -> list[dict]:
+        """Return available iFlytek voices."""
+        return [
+            {"name": vcn, "description": desc, "language": lang, "group": group}
+            for vcn, desc, lang, group in self._VOICES
+        ]
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        """Stream MP3 audio chunks as they arrive from iFlytek WebSocket."""
+        if self._client is None:
+            raise RuntimeError("Provider not started — call start() first")
+        opts = opts or TTSOptions()
+
+        voice = opts.voice or self.settings.voice
+        speed = opts.speed if opts.speed != 1.0 else None
+        logger.info("iFlytek stream: voice={}, speed={}, text={} chars", voice, speed, len(text))
+
+        url = self._build_auth_url()
+        msg = self._build_ws_message(text, voice=voice, speed=speed)
+        seq = 0
+
+        async with websockets.connect(url) as ws:
+            await ws.send(json.dumps(msg))
+
+            async for message in ws:
+                resp = json.loads(message)
+                code = resp.get("code", -1)
+                if code != 0:
+                    raise RuntimeError(
+                        f"iFlytek TTS error [{code}]: {resp.get('message', 'unknown')}"
+                    )
+
+                data = resp.get("data", {})
+                audio_b64 = data.get("audio", "")
+                is_final = data.get("status") == 2
+
+                if audio_b64:
+                    chunk_bytes = base64.b64decode(audio_b64)
+                    yield AudioChunk(data=chunk_bytes, sequence=seq, is_final=is_final)
+                    seq += 1
+
+                if is_final:
+                    break