openspeechapi 0.1.0__py3-none-any.whl

openspeech/providers/stt/windows_speech.py

@@ -0,0 +1,249 @@
+"""Windows native STT provider using System.Speech.Recognition via PowerShell.
+
+Uses PowerShell to invoke the .NET System.Speech.Recognition.SpeechRecognitionEngine,
+which is available on all Windows 10+ systems without extra dependencies.
+Results are exchanged through a temporary JSON file.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from openspeech.logging_config import logger
+import shutil
+import sys
+import tempfile
+import time
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from openspeech.core.base import STTProvider
+from openspeech.core.enums import Capability, ExecMode, ProviderType
+from openspeech.core.models import AudioData, STTOptions, Transcription
+from openspeech.core.settings import BaseSettings
+from openspeech.utils.audio_converter import AudioConverter
+
+# PowerShell script that performs speech recognition and outputs JSON.
+_PS_RECOGNIZE_SCRIPT = r"""
+param(
+    [Parameter(Mandatory=$true)][string]$AudioPath,
+    [Parameter(Mandatory=$true)][string]$OutputPath,
+    [string]$Language = "zh-CN"
+)
+
+try {
+    Add-Type -AssemblyName System.Speech
+
+    $culture = New-Object System.Globalization.CultureInfo($Language)
+    $engine = New-Object System.Speech.Recognition.SpeechRecognitionEngine($culture)
+    $grammar = New-Object System.Speech.Recognition.DictationGrammar
+    $engine.LoadGrammar($grammar)
+    $engine.SetInputToWaveFile($AudioPath)
+
+    $result = $engine.Recognize()
+    $engine.Dispose()
+
+    if ($result -ne $null) {
+        $output = @{
+            status = "ok"
+            text = $result.Text
+            confidence = [math]::Round($result.Confidence, 4)
+            language = $Language
+        }
+    } else {
+        $output = @{
+            status = "ok"
+            text = ""
+            confidence = 0
+            language = $Language
+        }
+    }
+} catch {
+    $output = @{
+        status = "error"
+        error = $_.Exception.Message
+    }
+}
+
+$output | ConvertTo-Json -Compress | Out-File -FilePath $OutputPath -Encoding UTF8
+"""
+
+@dataclass
+class WindowsSpeechSettings(BaseSettings):
+    language: str = "zh-CN"
+
+class WindowsSpeechSTT(STTProvider):
+    """Windows native STT via System.Speech.Recognition (PowerShell)."""
+
+    name = "windows-stt"
+    provider_type = ProviderType.STT
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = WindowsSpeechSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"language": ["zh-CN", "en-US", "ja-JP", "ko-KR", "fr-FR", "de-DE", "es-ES"]}
+
+    def __init__(self, settings: WindowsSpeechSettings | None = None) -> None:
+        self.settings = settings or WindowsSpeechSettings()
+        self._available: bool = False
+        self._powershell: str | None = None
+
+    # -- lifecycle ------------------------------------------------------------
+
+    @staticmethod
+    def _find_powershell() -> str | None:
+        """Locate PowerShell executable — try PATH first, then well-known paths."""
+        ps = shutil.which("powershell") or shutil.which("pwsh")
+        if ps:
+            return ps
+        # Fallback: well-known Windows paths
+        for candidate in (
+            Path(r"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"),
+            Path(r"C:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe"),
+        ):
+            if candidate.exists():
+                return str(candidate)
+        return None
+
+    async def start(self) -> None:
+        if sys.platform != "win32":
+            raise RuntimeError(
+                "Windows STT (System.Speech) is only available on Windows"
+            )
+        # Locate PowerShell
+        ps = self._find_powershell()
+        if ps is None:
+            raise RuntimeError("PowerShell not found on this system")
+        self._powershell = ps
+        logger.debug("Using PowerShell: {}", ps)
+
+        # Verify System.Speech is available
+        ok = await self._check_system_speech()
+        if not ok:
+            raise RuntimeError(
+                "System.Speech assembly not available. "
+                "Ensure Windows Speech Recognition is installed."
+            )
+        self._available = True
+        logger.info("{} provider started", self.name)
+
+    async def stop(self) -> None:
+        self._available = False
+        self._powershell = None
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        if self._available:
+            return True
+        if sys.platform != "win32":
+            return False
+        return self._find_powershell() is not None
+
+    # -- transcription --------------------------------------------------------
+
+    async def transcribe(
+        self, audio: AudioData, opts: STTOptions | None = None
+    ) -> Transcription:
+        if not self._available or self._powershell is None:
+            raise RuntimeError("Provider not started — call start() first")
+        logger.info("{}: request received, audio={} bytes", self.name, len(audio.data))
+        _t0 = time.perf_counter()
+
+        opts = opts or STTOptions()
+        language = opts.language or self.settings.language
+
+        # Convert to WAV (16-bit PCM) for System.Speech
+        wav_audio = AudioConverter.to_wav(audio)
+
+        tmp_wav: str | None = None
+        tmp_out: str | None = None
+        tmp_ps: str | None = None
+        try:
+            # Write WAV to temp file
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                f.write(wav_audio.data)
+                tmp_wav = f.name
+
+            # Output file for JSON result
+            with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+                tmp_out = f.name
+
+            # Write PowerShell script to temp file
+            with tempfile.NamedTemporaryFile(
+                suffix=".ps1", delete=False, mode="w", encoding="utf-8"
+            ) as f:
+                f.write(_PS_RECOGNIZE_SCRIPT)
+                tmp_ps = f.name
+
+            # Run PowerShell
+            cmd = [
+                self._powershell,
+                "-ExecutionPolicy", "Bypass",
+                "-NoProfile",
+                "-File", tmp_ps,
+                "-AudioPath", tmp_wav,
+                "-OutputPath", tmp_out,
+                "-Language", language,
+            ]
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await proc.communicate()
+
+            # Read JSON result
+            out_path = Path(tmp_out)
+            if not out_path.exists() or out_path.stat().st_size == 0:
+                err_msg = stderr.decode(errors="replace").strip() if stderr else "no output"
+                raise RuntimeError(f"Windows STT failed: {err_msg}")
+
+            raw = out_path.read_text(encoding="utf-8-sig").strip()
+            result = json.loads(raw)
+
+            if result.get("status") == "error":
+                raise RuntimeError(
+                    f"Windows STT error: {result.get('error', 'unknown')}"
+                )
+
+            transcription = Transcription(
+                text=result.get("text", ""),
+                language=result.get("language"),
+                confidence=result.get("confidence"),
+            )
+            logger.info("{}: completed in {:.0f}ms, result={} chars", self.name, (time.perf_counter() - _t0) * 1000, len(transcription.text))
+            return transcription
+        finally:
+            for p in (tmp_wav, tmp_out, tmp_ps):
+                if p is not None:
+                    try:
+                        Path(p).unlink(missing_ok=True)
+                    except OSError:
+                        pass
+
+    def transcribe_stream(
+        self, stream: AsyncIterator[bytes]
+    ) -> AsyncIterator[Any]:
+        raise NotImplementedError(
+            "Windows System.Speech does not support streaming via this provider"
+        )
+
+    # -- internal helpers -----------------------------------------------------
+
+    async def _check_system_speech(self) -> bool:
+        """Verify that System.Speech assembly is loadable."""
+        check_script = (
+            'try { Add-Type -AssemblyName System.Speech; '
+            'Write-Output "ok" } '
+            'catch { Write-Output "fail" }'
+        )
+        proc = await asyncio.create_subprocess_exec(
+            self._powershell,
+            "-ExecutionPolicy", "Bypass",
+            "-NoProfile",
+            "-Command", check_script,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        return stdout.decode(errors="replace").strip() == "ok"

openspeech/providers/tts/alibaba.py

@@ -0,0 +1,95 @@
+"""Alibaba Cloud (Bailian/DashScope) TTS provider adapter — OpenAI-compatible."""
+from __future__ import annotations
+
+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 AlibabaTTSSettings(BaseSettings):
+    api_key: str = ""
+    model: str = "cosyvoice-v1"
+    voice: str = "longxiaochun"
+    base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+
+class AlibabaTTS(TTSProvider):
+    name = "alibaba-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = AlibabaTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"model": ["cosyvoice-v1", "sambert-v1"], "voice": ["longxiaochun", "longhua", "longxiaoxia", "longlaotie", "longshu"]}
+
+    def __init__(self, settings: AlibabaTTSSettings | None = None) -> None:
+        self.settings = settings or AlibabaTTSSettings()
+        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 = opts.voice or self.settings.voice
+        url = f"{self.settings.base_url}/audio/speech"
+
+        headers = {
+            "Authorization": f"Bearer {self.settings.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": self.settings.model,
+            "input": text,
+            "voice": voice,
+        }
+
+        resp = await self._client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+
+        result = AudioData(
+            data=resp.content,
+            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("Alibaba TTS streaming not implemented")
+        yield  # noqa: unreachable — makes this an async generator

openspeech/providers/tts/azure_speech.py

@@ -0,0 +1,123 @@
+"""Azure Speech TTS provider adapter (batch, httpx)."""
+from __future__ import annotations
+
+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 AzureSpeechTTSSettings(BaseSettings):
+    subscription_key: str = ""
+    region: str = "eastus"
+    voice: str = "en-US-JennyNeural"
+    language: str = "en-US"
+
+class AzureSpeechTTS(TTSProvider):
+    name = "azure-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.REMOTE
+    settings_cls = AzureSpeechTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"language": ["en-US", "zh-CN", "ja-JP", "ko-KR", "es-ES", "fr-FR", "de-DE"], "voice": ["en-US-JennyNeural", "en-US-GuyNeural", "en-US-AriaNeural", "zh-CN-XiaoxiaoNeural", "zh-CN-YunxiNeural", "zh-CN-XiaoyiNeural", "ja-JP-NanamiNeural", "ko-KR-SunHiNeural"], "region": ["eastus", "westus2", "westeurope", "eastasia", "southeastasia"]}
+
+    def __init__(self, settings: AzureSpeechTTSSettings | None = None) -> None:
+        self.settings = settings or AzureSpeechTTSSettings()
+        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.subscription_key)
+
+    async def _get_access_token(self) -> str:
+        """Fetch a short-lived access token from the Azure token endpoint."""
+        if self._client is None:
+            raise RuntimeError("Provider not started — call start() first")
+        url = (
+            f"https://{self.settings.region}.api.cognitive.microsoft.com"
+            f"/sts/v1.0/issueToken"
+        )
+        headers = {
+            "Ocp-Apim-Subscription-Key": self.settings.subscription_key,
+            "Content-Length": "0",
+        }
+        response = await self._client.post(url, headers=headers, content=b"")
+        if response.status_code != 200:
+            raise RuntimeError(
+                f"Azure token endpoint error {response.status_code}: {response.text}"
+            )
+        return response.text
+
+    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 = opts.voice or self.settings.voice
+        language = self.settings.language
+
+        token = await self._get_access_token()
+
+        url = (
+            f"https://{self.settings.region}.tts.speech.microsoft.com"
+            f"/cognitiveservices/v1"
+        )
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/ssml+xml",
+            "X-Microsoft-OutputFormat": "riff-24khz-16bit-mono-pcm",
+        }
+        ssml = (
+            f"<speak version='1.0' xml:lang='{language}'>"
+            f"<voice name='{voice}'>{text}</voice>"
+            f"</speak>"
+        )
+        response = await self._client.post(url, headers=headers, content=ssml)
+        if response.status_code != 200:
+            raise RuntimeError(
+                f"Azure Speech TTS API error {response.status_code}: {response.text}"
+            )
+        result = AudioData(
+            data=response.content,
+            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(
+            "Azure Speech TTS batch provider does not support streaming output"
+        )
+        yield  # pragma: no cover

openspeech/providers/tts/baidu.py

@@ -0,0 +1,143 @@
+"""Baidu Cloud TTS provider adapter."""
+from __future__ import annotations
+
+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 BaiduTTSSettings(BaseSettings):
+    api_key: str = ""
+    secret_key: str = ""
+    per: int = 0    # 0=female, 1=male, 3=度逍遥, 4=度丫丫
+    spd: int = 5    # speed 0-15
+    pit: int = 5    # pitch 0-15
+    vol: int = 5    # volume 0-15
+
+class BaiduTTS(TTSProvider):
+    name = "baidu-tts"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = BaiduTTSSettings
+    capabilities = {Capability.BATCH, Capability.MULTILINGUAL}
+    field_options = {"per": [0, 1, 3, 4, 5, 103, 106, 110, 111]}
+
+    def __init__(self, settings: BaiduTTSSettings | None = None) -> None:
+        self.settings = settings or BaiduTTSSettings()
+        self._client: httpx.AsyncClient | None = None
+        self._owns_client: bool = True
+        self._token: str | None = None
+        self._token_expires_at: float = 0.0
+
+    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
+        self._token = None
+        self._token_expires_at = 0.0
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        return bool(self.settings.api_key) and bool(self.settings.secret_key)
+
+    async def _get_token(self) -> str:
+        """Fetch or return cached OAuth access token."""
+        if self._token and time.time() < self._token_expires_at:
+            return self._token
+
+        if self._client is None:
+            raise RuntimeError("Provider not started — call start() first")
+
+        resp = await self._client.get(
+            "https://aip.baidubce.com/oauth/2.0/token",
+            params={
+                "grant_type": "client_credentials",
+                "client_id": self.settings.api_key,
+                "client_secret": self.settings.secret_key,
+            },
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        if "access_token" not in data:
+            raise RuntimeError(
+                f"Baidu OAuth error: {data.get('error_description', 'unknown')}"
+            )
+
+        self._token = data["access_token"]
+        self._token_expires_at = time.time() + data.get("expires_in", 2592000) - 60
+        return self._token  # type: ignore[return-value]
+
+    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()
+
+        token = await self._get_token()
+
+        form_data = {
+            "tex": text,
+            "tok": token,
+            "cuid": "openspeech",
+            "ctp": "1",
+            "lan": "zh",
+            "spd": str(self.settings.spd),
+            "pit": str(self.settings.pit),
+            "vol": str(self.settings.vol),
+            "per": str(self.settings.per),
+            "aue": "6",  # 6 = WAV format
+        }
+
+        resp = await self._client.post(
+            "https://tsn.baidu.com/text2audio",
+            data=form_data,
+        )
+        resp.raise_for_status()
+
+        content_type = resp.headers.get("content-type", "")
+        if "audio" in content_type:
+            result = AudioData(
+                data=resp.content,
+                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
+
+        # JSON response means error
+        error_data = resp.json()
+        raise RuntimeError(
+            f"Baidu TTS error [{error_data.get('err_no')}]: "
+            f"{error_data.get('err_msg', 'unknown')}"
+        )
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        raise NotImplementedError("Baidu TTS streaming not implemented")
+        yield  # noqa: unreachable — makes this an async generator

openspeech/providers/tts/coqui.py

@@ -0,0 +1,64 @@
+"""Coqui TTS provider adapter (voice clone + multilingual, in-process)."""
+from __future__ import annotations
+
+from openspeech.logging_config import logger
+import time
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+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 CoquiTTSSettings(BaseSettings):
+    model_name: str = "tts_models/en/ljspeech/tacotron2-DDC"
+    vocoder_name: str | None = None
+    use_cuda: bool = False
+    speaker_wav: str | None = None
+    language: str | None = None
+
+class CoquiTTS(TTSProvider):
+    name = "coqui"
+    provider_type = ProviderType.TTS
+    execution_mode = ExecMode.IN_PROCESS
+    settings_cls = CoquiTTSSettings
+    capabilities = {Capability.VOICE_CLONE, Capability.MULTILINGUAL}
+
+    def __init__(self, settings: CoquiTTSSettings | None = None) -> None:
+        self.settings = settings or CoquiTTSSettings()
+        self._client: Any = None
+
+    async def start(self) -> None:
+        try:
+            from TTS.api import TTS  # noqa: F401
+            self._client = object()  # sentinel
+        except ImportError:
+            raise ImportError(
+                "Install coqui TTS: pip install openspeech[coqui]"
+            )
+        logger.info("{} provider started", self.name)
+
+    async def stop(self) -> None:
+        self._client = None
+        logger.info("{} provider stopped", self.name)
+
+    async def health_check(self) -> bool:
+        return self._client is not None
+
+    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))
+        raise NotImplementedError("CoquiTTS.synthesize() is not yet implemented")
+
+    async def synthesize_stream(
+        self, text: str, opts: TTSOptions | None = None
+    ) -> AsyncIterator[AudioChunk]:
+        raise NotImplementedError("CoquiTTS does not support streaming synthesis")
+        yield  # pragma: no cover