init

stt.py

@@ -0,0 +1,173 @@
+"""Baidu Speech-to-Text integration."""
+import logging
+from typing import Any, Optional
+
+from aip import AipSpeech
+from homeassistant.components.stt import (
+    AudioBitRates,
+    AudioChannels,
+    AudioCodecs,
+    AudioFormats,
+    AudioSampleRates,
+    SpeechToTextEntity,
+    SpeechMetadata,
+    SpeechResult,
+    SpeechResultState,
+    Provider,
+    async_get_provider,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+class BaiduSTTBase:
+    """Base class for Baidu STT functionality."""
+
+    @property
+    def supported_languages(self) -> list[str]:
+        """Return a list of supported languages."""
+        return ["zh-CN"]
+
+    @property
+    def supported_formats(self) -> list[AudioFormats]:
+        """Return a list of supported formats."""
+        return [AudioFormats.WAV, AudioFormats.OGG]
+
+    @property
+    def supported_codecs(self) -> list[AudioCodecs]:
+        """Return a list of supported codecs."""
+        return [AudioCodecs.PCM, AudioCodecs.OPUS]
+
+    @property
+    def supported_bit_rates(self) -> list[AudioBitRates]:
+        """Return a list of supported bit rates."""
+        return [AudioBitRates.BITRATE_16]
+
+    @property
+    def supported_sample_rates(self) -> list[AudioSampleRates]:
+        """Return a list of supported sample rates."""
+        return [AudioSampleRates.SAMPLERATE_16000]
+
+    @property
+    def supported_channels(self) -> list[AudioChannels]:
+        """Return a list of supported channels."""
+        return [AudioChannels.CHANNEL_MONO]
+
+    async def _process_audio(self, audio_data: bytes, client: AipSpeech) -> SpeechResult:
+        """Process audio data using Baidu STT API."""
+        try:
+            if not audio_data:
+                _LOGGER.warning("No audio data received")
+                return SpeechResult("", SpeechResultState.ERROR)
+            
+            _LOGGER.debug("Total audio data size: %d bytes", len(audio_data))
+            
+            # 使用百度语音识别API
+            result = await self.hass.async_add_executor_job(
+                client.asr,
+                audio_data,
+                'pcm',
+                16000,
+                {
+                    'dev_pid': 1537,  # 普通话(支持简单的英文识别)
+                }
+            )
+            
+            _LOGGER.debug("Baidu STT response: %s", result)
+            
+            if result.get('err_no') == 0:
+                text = result.get('result', [""])[0]
+                return SpeechResult(text, SpeechResultState.SUCCESS)
+            else:
+                _LOGGER.error("Baidu STT error: %s", result.get('err_msg'))
+                return SpeechResult("", SpeechResultState.ERROR)
+                
+        except Exception as ex:
+            _LOGGER.error("Error during Baidu STT: %s", ex, exc_info=True)
+            return SpeechResult("", SpeechResultState.ERROR)
+
+async def async_get_engine(
+    hass: HomeAssistant,
+    config: dict,
+    discovery_info: Optional[dict] = None
+) -> Provider:
+    """Set up Baidu STT component."""
+    _LOGGER.debug("Setting up Baidu STT engine")
+    return BaiduSTTProvider(hass)
+
+class BaiduSTTProvider(BaiduSTTBase, Provider):
+    """Baidu STT api provider."""
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize Baidu STT provider."""
+        self.hass = hass
+        self._app_id = hass.data[DOMAIN]["app_id"]
+        self._api_key = hass.data[DOMAIN]["api_key"]
+        self._secret_key = hass.data[DOMAIN]["secret_key"]
+        self._client = AipSpeech(self._app_id, self._api_key, self._secret_key)
+        self.name = "Baidu STT"
+        self._language = "zh-CN"
+        _LOGGER.debug("Initialized Baidu STT provider with language: %s", self._language)
+
+    @property
+    def default_language(self) -> str:
+        """Return the default language."""
+        return self._language
+
+    async def async_process_audio_stream(
+        self, metadata: SpeechMetadata, stream: Any
+    ) -> SpeechResult:
+        """Process an audio stream to STT service."""
+        _LOGGER.debug("Processing audio stream with metadata: %s", metadata)
+        
+        # 读取音频数据
+        audio_data = b""
+        async for chunk in stream:
+            audio_data += chunk
+        
+        return await self._process_audio(audio_data, self._client)
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Baidu STT from a config entry."""
+    provider = await async_get_provider(hass, DOMAIN)
+    if provider:
+        async_add_entities([BaiduSTTEntity(provider, config_entry)])
+
+class BaiduSTTEntity(BaiduSTTBase, SpeechToTextEntity):
+    """Baidu Speech-to-Text entity."""
+
+    def __init__(self, provider: Provider, config_entry: ConfigEntry) -> None:
+        """Initialize Baidu STT entity."""
+        self._provider = provider
+        self._config_entry = config_entry
+        self._attr_name = "Baidu Speech-to-Text"
+        self._attr_unique_id = f"{DOMAIN}_stt"
+        self.hass = provider.hass
+        
+        # 初始化百度语音识别客户端
+        self._client = AipSpeech(
+            config_entry.data["app_id"],
+            config_entry.data["api_key"],
+            config_entry.data["secret_key"]
+        )
+
+    async def async_process_audio_stream(
+        self, metadata: SpeechMetadata, stream: Any
+    ) -> SpeechResult:
+        """Process an audio stream to STT service."""
+        _LOGGER.debug("Processing audio stream with metadata: %s", metadata)
+        
+        # 读取音频数据
+        audio_data = b""
+        async for chunk in stream:
+            audio_data += chunk
+        
+        return await self._process_audio(audio_data, self._client)