local-coze 0.0.1__py3-none-any.whl

local_coze/voice/asr.py

@@ -0,0 +1,82 @@
+from typing import Dict, Optional, Tuple
+
+from coze_coding_utils.runtime_ctx.context import Context
+from cozeloop.decorator import observe
+
+from ..core.client import BaseClient
+from ..core.config import Config
+from ..core.exceptions import APIError, ValidationError
+from .models import ASRRequest, ASRResponse
+
+
+class ASRClient(BaseClient):
+    def __init__(
+        self,
+        config: Optional[Config] = None,
+        ctx: Optional[Context] = None,
+        custom_headers: Optional[Dict[str, str]] = None,
+        verbose: bool = False,
+    ):
+        super().__init__(config, ctx, custom_headers, verbose)
+        self.base_url = self.config.base_url
+
+    @observe
+    def recognize(
+        self,
+        uid: Optional[str] = None,
+        url: Optional[str] = None,
+        base64_data: Optional[str] = None,
+    ) -> Tuple[str, dict]:
+        """
+        识别音频文件中的语音内容
+
+        音频要求:
+        - 音频时长 ≤ 2小时
+        - 音频大小 ≤ 100MB
+        - 支持编码: WAV/MP3/OGG OPUS
+
+        Args:
+            uid: 用户唯一标识
+            url: 音频文件 URL (与 base64_data 二选一)
+            base64_data: Base64 编码的音频数据 (与 url 二选一)
+
+        Returns:
+            Tuple[str, dict]: 识别的文本和详细响应数据
+        """
+        if not (url or base64_data):
+            raise ValidationError(
+                "必须提供 url 或 base64_data 其中之一", field="url/base64_data"
+            )
+
+        request = ASRRequest(uid=uid, url=url, base64_data=base64_data)
+
+        response = self._request_with_response(
+            method="POST",
+            url=f"{self.base_url}/api/v3/auc/bigmodel/recognize/flash",
+            json=request.to_api_request(),
+        )
+
+        status_code = response.headers.get("X-Api-Status-Code", "0")
+        message = response.headers.get("X-Api-Message", "")
+
+        if status_code != "20000000":
+            raise APIError(
+                f"ASR 识别失败，状态码: {status_code}, 错误信息: {message}",
+                code=status_code,
+                status_code=response.status_code,
+            )
+
+        response.raise_for_status()
+
+        try:
+            data = response.json()
+        except Exception as e:
+            raise APIError(
+                f"响应解析失败: {str(e)}",
+                status_code=response.status_code,
+            )
+
+        result = data.get("result", {})
+        text = result.get("text", "")
+
+        return text, data

local_coze/voice/models.py

@@ -0,0 +1,86 @@
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
+
+
+class TTSConfig:
+    DEFAULT_SPEAKER = "zh_female_xiaohe_uranus_bigtts"
+    DEFAULT_AUDIO_FORMAT = "mp3"
+    DEFAULT_SAMPLE_RATE = 24000
+    DEFAULT_SPEECH_RATE = 0
+    DEFAULT_LOUDNESS_RATE = 0
+
+
+class TTSRequest(BaseModel):
+    uid: str = Field(..., description="用户唯一标识")
+    text: Optional[str] = Field(default=None, description="合成文本")
+    ssml: Optional[str] = Field(default=None, description="SSML格式文本")
+    speaker: str = Field(default=TTSConfig.DEFAULT_SPEAKER, description="音色标识")
+    audio_format: Literal["pcm", "mp3", "ogg_opus"] = Field(
+        default=TTSConfig.DEFAULT_AUDIO_FORMAT,
+        description="音频格式"
+    )
+    sample_rate: Literal[8000, 16000, 22050, 24000, 32000, 44100, 48000] = Field(
+        default=TTSConfig.DEFAULT_SAMPLE_RATE,
+        description="采样率"
+    )
+    speech_rate: int = Field(
+        default=TTSConfig.DEFAULT_SPEECH_RATE,
+        ge=-50,
+        le=100,
+        description="语速"
+    )
+    loudness_rate: int = Field(
+        default=TTSConfig.DEFAULT_LOUDNESS_RATE,
+        ge=-50,
+        le=100,
+        description="音量"
+    )
+    
+    def to_api_request(self) -> dict:
+        params = {
+            "user": {
+                "uid": self.uid,
+            },
+            "req_params": {
+                "speaker": self.speaker,
+                "audio_params": {
+                    "format": self.audio_format,
+                    "sample_rate": self.sample_rate,
+                    "speech_rate": self.speech_rate,
+                    "loudness_rate": self.loudness_rate
+                }
+            },
+        }
+        
+        if self.text:
+            params["req_params"]["text"] = self.text
+        elif self.ssml:
+            params["req_params"]["ssml"] = self.ssml
+        
+        return params
+
+
+class ASRRequest(BaseModel):
+    uid: Optional[str] = Field(default=None, description="用户唯一标识")
+    url: Optional[str] = Field(default=None, description="音频文件URL")
+    base64_data: Optional[str] = Field(default=None, description="音频文件Base64编码")
+    
+    def to_api_request(self) -> dict:
+        audio_data = {}
+        if self.url:
+            audio_data["url"] = self.url
+        elif self.base64_data:
+            audio_data["data"] = self.base64_data
+        
+        return {
+            "user": {
+                "uid": self.uid,
+            },
+            "audio": audio_data,
+        }
+
+
+class ASRResponse(BaseModel):
+    text: str = Field(..., description="识别结果文本")
+    duration: Optional[int] = Field(default=None, description="音频时长(毫秒)")
+    utterances: Optional[list] = Field(default=None, description="详细识别结果")

local_coze/voice/tts.py

@@ -0,0 +1,94 @@
+import base64
+import json
+from typing import Dict, Optional, Tuple
+
+from coze_coding_utils.runtime_ctx.context import Context
+from cozeloop.decorator import observe
+
+from ..core.client import BaseClient
+from ..core.config import Config
+from ..core.exceptions import APIError, ValidationError
+from .models import TTSConfig, TTSRequest
+
+
+class TTSClient(BaseClient):
+    def __init__(
+        self,
+        config: Optional[Config] = None,
+        ctx: Optional[Context] = None,
+        custom_headers: Optional[Dict[str, str]] = None,
+        verbose: bool = False,
+    ):
+        super().__init__(config, ctx, custom_headers, verbose)
+        self.base_url = self.config.base_url
+
+    @observe
+    def synthesize(
+        self,
+        uid: str,
+        text: Optional[str] = None,
+        ssml: Optional[str] = None,
+        speaker: str = TTSConfig.DEFAULT_SPEAKER,
+        audio_format: str = TTSConfig.DEFAULT_AUDIO_FORMAT,
+        sample_rate: int = TTSConfig.DEFAULT_SAMPLE_RATE,
+        speech_rate: int = TTSConfig.DEFAULT_SPEECH_RATE,
+        loudness_rate: int = TTSConfig.DEFAULT_LOUDNESS_RATE,
+    ) -> Tuple[str, int]:
+        if not (text or ssml):
+            raise ValidationError("必须提供 text 或 ssml 其中之一", field="text/ssml")
+
+        request = TTSRequest(
+            uid=uid,
+            text=text,
+            ssml=ssml,
+            speaker=speaker,
+            audio_format=audio_format,
+            sample_rate=sample_rate,
+            speech_rate=speech_rate,
+            loudness_rate=loudness_rate,
+        )
+
+        response = self._request_stream(
+            method="POST",
+            url=f"{self.base_url}/api/v3/tts/unidirectional",
+            json=request.to_api_request(),
+            headers={"Connection": "keep-alive"},
+        )
+
+        try:
+            audio_uri = None
+            audio_data = bytearray()
+            total_audio_size = 0
+
+            for chunk in response.iter_lines(decode_unicode=False):
+                if not chunk:
+                    continue
+
+                chunk_str = chunk.decode("utf-8").replace("data:", "")
+                data = json.loads(chunk_str)
+
+                if data.get("code", 0) == 0 and "data" in data and data["data"]:
+                    chunk_audio = base64.b64decode(data["data"])
+                    audio_size = len(chunk_audio)
+                    total_audio_size += audio_size
+                    audio_data.extend(chunk_audio)
+
+                elif data.get("code", 0) == 20000000:
+                    if "url" in data and data["url"]:
+                        audio_uri = data["url"]
+                    break
+
+                elif data.get("code", 0) > 0:
+                    raise APIError(
+                        f"合成音频失败: {data.get('message', '')}",
+                        code=str(data.get("code", 0)),
+                    )
+
+            return audio_uri or "", total_audio_size
+
+        except json.JSONDecodeError as e:
+            raise APIError(f"响应解析失败: {str(e)}")
+        except Exception as e:
+            raise APIError(f"合成异常: {str(e)}")
+        finally:
+            response.close()