volcengine-python-sdk-aicc 0.0.41__tar.gz → 0.0.42__tar.gz

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: volcengine-python-sdk-aicc
-Version: 0.0.41
+Version: 0.0.42
 Summary: Volcengine AICC Python SDK for confidential and secure AI inference
 Author-email: Volcengine AICC SDK Team <volcengine@bytedance.com>
 License-Expression: Apache-2.0
@@ -45,7 +45,7 @@ Dynamic: license-file
 # Volcengine AICC SDK for Python
 
 The official Python SDK for Volcengine AICC, providing confidential and secure
-AI inference clients (chat, vision, video generation, ASR, etc.) with remote
+AI inference clients (chat, vision, video generation, ASR, TTS, etc.) with remote
 attestation verification.
 
 ## Installation
@@ -54,21 +54,38 @@ attestation verification.
 pip install volcengine-python-sdk-aicc
 ```
 
-The distribution name is `volcengine-python-sdk-aicc`; the Python import
-package is `bytedance.volcengine_aicc_sdk`.
-
-## Quick start
+## Quick start (recommended public import)
 
 ```python
-from bytedance.volcengine_aicc_sdk import AICCClient
-from bytedance.volcengine_aicc_sdk.secure_http_client import AICCConfig
+from volcengine.aicc import AICCClient, AICCConfig
 
 client = AICCClient(config=AICCConfig(base_url="<YOUR_BASE_URL>", api_key="<YOUR_API_KEY>"))
 ```
 
+## Legacy import compatibility
+
+Existing customer code remains supported unchanged:
+
+```python
+from bytedance.volcengine_aicc_sdk import AICCClient
+from bytedance.volcengine_aicc_sdk.secure_http_client import AICCConfig, SecureHttpClient
+```
+
+The distribution name is `volcengine-python-sdk-aicc`. `volcengine.aicc` is the recommended
+public import facade; `bytedance.volcengine_aicc_sdk` remains the implementation and legacy
+compatibility path. Both expose the same class objects.
+
+## Available clients
+
+`AICCClient`, `AICCConfig`, `SecureHttpClient`, `AsyncSecureHttpClient`,
+`AICCInference`, `ARKClient`, `DeepSeekClient`, `CUClient`, `AUCClient`,
+`ASRClient`, `AsrWebSocketClient`, `SeedanceClient`, `SeedreamClient`,
+`TTSClient`, and `TTSResponse`.
+
 ## Project layout
 
-- `bytedance.volcengine_aicc_sdk`: AICC inference clients.
+- `volcengine.aicc`: recommended public import facade.
+- `bytedance.volcengine_aicc_sdk`: implementation and legacy import path.
 - `bytedance.jeddak_secure_channel`: confidential-computing secure channel and
   remote attestation report verification.
 - `bytedance.jeddak_secure_model`: secure model helpers.

volcengine_python_sdk_aicc-0.0.42/README.md

@@ -0,0 +1,52 @@
+# Volcengine AICC SDK for Python
+
+The official Python SDK for Volcengine AICC, providing confidential and secure
+AI inference clients (chat, vision, video generation, ASR, TTS, etc.) with remote
+attestation verification.
+
+## Installation
+
+```bash
+pip install volcengine-python-sdk-aicc
+```
+
+## Quick start (recommended public import)
+
+```python
+from volcengine.aicc import AICCClient, AICCConfig
+
+client = AICCClient(config=AICCConfig(base_url="<YOUR_BASE_URL>", api_key="<YOUR_API_KEY>"))
+```
+
+## Legacy import compatibility
+
+Existing customer code remains supported unchanged:
+
+```python
+from bytedance.volcengine_aicc_sdk import AICCClient
+from bytedance.volcengine_aicc_sdk.secure_http_client import AICCConfig, SecureHttpClient
+```
+
+The distribution name is `volcengine-python-sdk-aicc`. `volcengine.aicc` is the recommended
+public import facade; `bytedance.volcengine_aicc_sdk` remains the implementation and legacy
+compatibility path. Both expose the same class objects.
+
+## Available clients
+
+`AICCClient`, `AICCConfig`, `SecureHttpClient`, `AsyncSecureHttpClient`,
+`AICCInference`, `ARKClient`, `DeepSeekClient`, `CUClient`, `AUCClient`,
+`ASRClient`, `AsrWebSocketClient`, `SeedanceClient`, `SeedreamClient`,
+`TTSClient`, and `TTSResponse`.
+
+## Project layout
+
+- `volcengine.aicc`: recommended public import facade.
+- `bytedance.volcengine_aicc_sdk`: implementation and legacy import path.
+- `bytedance.jeddak_secure_channel`: confidential-computing secure channel and
+  remote attestation report verification.
+- `bytedance.jeddak_secure_model`: secure model helpers.
+- `bytedance.tks`: trusted key service helpers.
+
+## License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE).

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/bytedance/volcengine_aicc_sdk/__init__.py

@@ -4,7 +4,7 @@ __all__ = [
     "__version__",
 ]
 
-__version__ = "0.0.41"
+__version__ = "0.0.42"
 
 from .aicc_client import AICCModelType
 from .aicc_client import AICCClient

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/bytedance/volcengine_aicc_sdk/aicc_client.py

@@ -1,5 +1,6 @@
 from bytedance.volcengine_aicc_sdk.seedance_inference_client import SeedanceClient
 from bytedance.volcengine_aicc_sdk.seedream_inference_client import SeedreamClient
+from bytedance.volcengine_aicc_sdk.tts_client import TTSClient
 from typing import Any, List, Optional, Union
 """
 AICC访问客户端
@@ -200,6 +201,10 @@ class AICCClient:
     def get_secure_http_client(self) -> SecureHttpClient:
         return self.secure_http_client
 
+    def get_tts_client(self) -> TTSClient:
+        """复用当前客户端的安全传输与 Router 凭据创建 TTS 客户端。"""
+        return TTSClient(self.base_url, self.api_key, self.secure_http_client)
+
     def _init_secure_http_client(self) -> SecureHttpClient:
         if self.aicc_config:
             return SecureHttpClient(aicc_config=self.aicc_config)

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/bytedance/volcengine_aicc_sdk/secure_http_client.py

@@ -316,6 +316,10 @@ class SecureHttpClient(httpx.Client):
 
         resp = super().send(request, *args, **kwargs)
 
+        if request.extensions.get("aicc_raw_response"):
+            resp.extensions["aicc_response_key"] = encrypt_key
+            return resp
+
         if 200 <= resp.status_code < 300:
             if encrypt_key:
                 if not kwargs.get("stream", False):

volcengine_python_sdk_aicc-0.0.42/bytedance/volcengine_aicc_sdk/tts_client.py

@@ -0,0 +1,295 @@
+import base64
+import binascii
+import json
+from typing import Any, Dict, Iterator, Union
+
+import httpx
+
+from .common.error import AICCException
+from .common.log import logger
+from .secure_http_client import SecureHttpClient
+
+
+_ENCRYPTION_FORMAT = "X-AICC-Encryption-Format"
+_ENCRYPTION_CHUNK_SIZE = "X-AICC-Encryption-Chunk-Size"
+_AUDIO_CONTENT_TYPE = "X-AICC-Audio-Content-Type"
+_NDJSON_V1 = "jsc-ndjson-v1"
+_MAX_ENCRYPTED_LINE = 64 * 1024
+_MAX_AUDIO_BLOCK = 4096
+_MAX_ERROR_BODY = 1024 * 1024
+_MAX_SSE_EVENT_DATA = 1024 * 1024
+_MAX_PLAINTEXT_SSE_LINE = 1024 * 1024
+
+
+class TTSResponse:
+    """Streaming TTS response whose bytes are authenticated before delivery."""
+
+    def __init__(self, response: httpx.Response, audio: Iterator[bytes]):
+        self._response = response
+        self._audio = audio
+        self.headers = response.headers
+        self.status_code = response.status_code
+
+    def iter_bytes(self) -> Iterator[bytes]:
+        return self._audio
+
+    def read(self) -> bytes:
+        return b"".join(self._audio)
+
+    def close(self) -> None:
+        self._response.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+class TTSClient:
+    """Client for the Router `/audio/speech` streaming API.
+
+    流式 PCM 用法说明:
+      - 推荐生产用法: ``stream_format="audio"`` 搭配 ``stream=True`` 与
+        ``response_format="pcm"``, SDK 的 audio 分支按 HTTP chunked 原样透传
+        (底层走 ``response.iter_raw()``), 调用方可通过
+        :meth:`TTSResponse.iter_bytes` 边合成边消费 PCM 字节, 实现低延迟实时播放。
+      - ``stream_format="sse"`` 仅作为 OpenAI 契约兼容保留, Router 后端不再实现,
+        调用会返回 502 BACKEND_PROTOCOL_ERROR, 不建议使用。
+    """
+
+    def __init__(self, base_url: str, api_key: str, secure_http_client: SecureHttpClient):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.secure_http_client = secure_http_client
+
+    def synthesize(
+        self,
+        model: str,
+        input: str,
+        voice: Union[str, Dict[str, Any]],
+        stream_format: str = "audio",
+        **extra: Any,
+    ) -> TTSResponse:
+        """Start synthesis and return a streaming plaintext audio response."""
+        request_url = self.base_url.rstrip("/") + "/audio/speech"
+        logger.info(
+            f"TTS synthesis started, url={request_url}, model={model}, "
+            f"stream_format={stream_format}"
+        )
+        response = None
+        try:
+            payload = self._build_payload(model, input, voice, stream_format, extra)
+            request = self.secure_http_client.build_request(
+                "POST",
+                request_url,
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=payload,
+            )
+            request.extensions["aicc_raw_response"] = True
+            response = self.secure_http_client.send(request, stream=True)
+
+            if not 200 <= response.status_code < 300:
+                error_body = self._read_error_body(response)
+                raise AICCException(
+                    f"TTS request failed: status={response.status_code}, response={error_body}"
+                )
+
+            response_key = response.extensions.get("aicc_response_key")
+            if self.secure_http_client.aicc_config is not None and response_key is None:
+                raise AICCException("TTS response decryption key is unavailable")
+
+            if stream_format == "sse":
+                audio = self._iter_sse_audio(response, response_key)
+            else:
+                audio = self._iter_audio(response, response_key)
+                if response_key is not None:
+                    content_type = response.headers.get(_AUDIO_CONTENT_TYPE)
+                    if content_type:
+                        response.headers["Content-Type"] = content_type
+
+            logger.info(
+                f"TTS synthesis response ready, url={request_url}, "
+                f"status={response.status_code}, stream_format={stream_format}"
+            )
+            return TTSResponse(
+                response,
+                self._log_stream_failures(audio, response, request_url),
+            )
+        except Exception as exc:
+            if response is not None:
+                response.close()
+            logger.error(
+                f"TTS synthesis failed, url={request_url}, model={model}, "
+                f"stream_format={stream_format}, error={exc}"
+            )
+            raise
+
+    @staticmethod
+    def _build_payload(
+        model: str,
+        input: str,
+        voice: Union[str, Dict[str, Any]],
+        stream_format: str,
+        extra: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        if not isinstance(model, str) or not model.strip():
+            raise ValueError("TTS model is required")
+        if not isinstance(input, str) or not input.strip():
+            raise ValueError("TTS input is required")
+        if isinstance(voice, str):
+            if not voice.strip():
+                raise ValueError("TTS voice is required")
+        elif (
+            not isinstance(voice, dict)
+            or not isinstance(voice.get("id"), str)
+            or not voice["id"].strip()
+        ):
+            raise ValueError(
+                "TTS voice must be a non-empty string or an object with a non-empty id"
+            )
+        if stream_format not in ("audio", "sse"):
+            raise ValueError("TTS stream_format must be audio or sse")
+
+        conflicts = {"model", "input", "voice", "stream_format"}.intersection(extra)
+        if conflicts:
+            raise ValueError(f"TTS extra fields conflict with declared fields: {sorted(conflicts)}")
+        return {
+            "model": model,
+            "input": input,
+            "voice": voice,
+            "stream_format": stream_format,
+            **extra,
+        }
+
+    @staticmethod
+    def _read_error_body(response: httpx.Response) -> str:
+        body = bytearray()
+        for chunk in response.iter_raw():
+            body.extend(chunk[: _MAX_ERROR_BODY - len(body)])
+            if len(body) == _MAX_ERROR_BODY:
+                break
+        return body.decode("utf-8", errors="replace")
+
+    @staticmethod
+    def _iter_lines(
+        response: httpx.Response,
+        require_lf: bool,
+        max_line: int = _MAX_ENCRYPTED_LINE,
+    ) -> Iterator[bytes]:
+        buffer = bytearray()
+        for chunk in response.iter_raw():
+            buffer.extend(chunk)
+            while True:
+                newline = buffer.find(b"\n")
+                if newline < 0:
+                    if len(buffer) > max_line:
+                        raise AICCException("TTS response line exceeds size limit")
+                    break
+                if newline > max_line:
+                    raise AICCException("TTS response line exceeds size limit")
+                line = bytes(buffer[:newline])
+                del buffer[: newline + 1]
+                yield line[:-1] if line.endswith(b"\r") else line
+        if buffer:
+            if require_lf:
+                raise AICCException("TTS truncated encrypted audio record")
+            yield bytes(buffer[:-1] if buffer.endswith(b"\r") else buffer)
+
+    def _iter_audio(self, response: httpx.Response, response_key: Any) -> Iterator[bytes]:
+        if response_key is None:
+            yield from response.iter_raw()
+            return
+        if response.headers.get(_ENCRYPTION_FORMAT) != _NDJSON_V1:
+            raise AICCException(f"TTS unexpected {_ENCRYPTION_FORMAT} header")
+        if response.headers.get(_ENCRYPTION_CHUNK_SIZE) != str(_MAX_AUDIO_BLOCK):
+            raise AICCException(f"TTS unexpected {_ENCRYPTION_CHUNK_SIZE} header")
+
+        for envelope in self._iter_lines(response, require_lf=True):
+            try:
+                plaintext = response_key.decrypt(envelope)
+            except Exception as exc:
+                raise AICCException(f"TTS failed to decrypt audio record: {exc}") from exc
+            if not 1 <= len(plaintext) <= _MAX_AUDIO_BLOCK:
+                raise AICCException(
+                    f"TTS invalid decrypted audio block size {len(plaintext)}"
+                )
+            yield plaintext
+
+    def _iter_sse_audio(self, response: httpx.Response, response_key: Any) -> Iterator[bytes]:
+        event_name = ""
+        data_lines = []
+        data_size = 0
+
+        def dispatch():
+            nonlocal event_name, data_lines, data_size
+            if not data_lines:
+                event_name = ""
+                return None, False
+            try:
+                payload = json.loads("\n".join(data_lines))
+            except (TypeError, ValueError) as exc:
+                raise AICCException(f"TTS failed to decode SSE data: {exc}") from exc
+            current_event = event_name or payload.get("type", "")
+            event_name = ""
+            data_lines = []
+            data_size = 0
+            if current_event == "speech.audio.delta":
+                try:
+                    return base64.b64decode(payload.get("audio", ""), validate=True), False
+                except (binascii.Error, ValueError) as exc:
+                    raise AICCException(f"TTS failed to decode SSE audio: {exc}") from exc
+            if current_event == "speech.audio.done":
+                return None, True
+            if current_event == "error":
+                raise AICCException("TTS speech backend returned an SSE error")
+            return None, False
+
+        max_line = (
+            _MAX_ENCRYPTED_LINE
+            if response_key is not None
+            else _MAX_PLAINTEXT_SSE_LINE
+        )
+        lines = self._iter_lines(response, require_lf=False, max_line=max_line)
+        for raw_line in lines:
+            if response_key is not None:
+                try:
+                    raw_line = response_key.decrypt(raw_line)
+                except Exception as exc:
+                    raise AICCException(f"TTS failed to decrypt SSE line: {exc}") from exc
+            line = raw_line.decode("utf-8")
+            if not line:
+                audio, done = dispatch()
+                if audio is not None:
+                    yield audio
+                if done:
+                    response.close()
+                    return
+                continue
+            if line.startswith("event:"):
+                event_name = line[6:].lstrip()
+            elif line.startswith("data:"):
+                value = line[5:].lstrip()
+                data_size += len(value.encode("utf-8")) + (1 if data_lines else 0)
+                if data_size > _MAX_SSE_EVENT_DATA:
+                    raise AICCException("TTS SSE event data exceeds size limit")
+                data_lines.append(value)
+        audio, _ = dispatch()
+        if audio is not None:
+            yield audio
+
+    @staticmethod
+    def _log_stream_failures(
+        audio: Iterator[bytes],
+        response: httpx.Response,
+        request_url: str,
+    ) -> Iterator[bytes]:
+        try:
+            yield from audio
+        except Exception as exc:
+            response.close()
+            logger.error(f"TTS stream failed, url={request_url}, error={exc}")
+            raise

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/pyproject.toml

@@ -41,22 +41,17 @@ dependencies = [
 ]
 
 [project.urls]
-# 公开源码仓库地址待开源仓库确认后补充（例如 GitHub 仓库）。
 Homepage = "https://pypi.org/project/volcengine-python-sdk-aicc/"
 
-# Build configurations
-
 [build-system]
-requires = [
-  "setuptools >= 75.3, < 100",
-]
+requires = ["setuptools >= 75.3, < 100"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.dynamic]
 version = { attr = "bytedance.volcengine_aicc_sdk.__version__" }
 
 [tool.setuptools.packages.find]
-include = ["bytedance*"]
+include = ["bytedance*", "volcengine*"]
 
 [tool.setuptools]
 include-package-data = false
@@ -74,9 +69,7 @@ addopts = ["--import-mode=importlib"]
 testpaths = ["tests"]
 
 [tool.coverage.run]
-omit = [
-  "example"
-]
+omit = ["example"]
 
 [tool.black]
 line-length = 100

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/tests/test_secure_http_client.py

@@ -22,14 +22,6 @@ sys.modules['bytedance.jeddak_secure_channel.crypto'] = mock_crypto
 mock_crypto.aes = mock.MagicMock()
 mock_crypto.rsa = mock.MagicMock()
 
-# 模拟 httpx 模块
-mock_httpx = mock.MagicMock()
-sys.modules['httpx'] = mock_httpx
-# 定义必要的类和方法
-mock_httpx.Client = mock.MagicMock()
-mock_httpx.Request = mock.MagicMock()
-mock_httpx.SyncByteStream = mock.MagicMock()
-
 # 模拟 volcenginesdkarkruntime 及其子模块
 sys.modules['volcenginesdkarkruntime'] = mock.MagicMock()
 sys.modules['volcenginesdkarkruntime._utils'] = mock.MagicMock()

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/tests/test_seedance_inference_client.py

@@ -25,14 +25,6 @@ sys.modules['cryptography.hazmat.primitives.asymmetric'] = mock.MagicMock()
 sys.modules['cryptography.hazmat.backends'] = mock.MagicMock()
 sys.modules['cryptography.hazmat.backends.openssl'] = mock.MagicMock()
 
-sys.modules['httpx'] = mock.MagicMock()
-sys.modules['httpx._types'] = mock.MagicMock()
-
-import urllib
-sys.modules['urllib.request'] = mock.MagicMock()
-if not hasattr(urllib, 'request'):
-    urllib.request = sys.modules['urllib.request']
-
 sys.modules['bytedance.volcengine_aicc_sdk.common.aes'] = mock.MagicMock()
 sys.modules['bytedance.volcengine_aicc_sdk.common.log'] = mock.MagicMock()
 

{volcengine_python_sdk_aicc-0.0.41 → volcengine_python_sdk_aicc-0.0.42}/tests/test_tos_utils.py

@@ -25,15 +25,6 @@ sys.modules['cryptography.hazmat.primitives.asymmetric'] = mock.MagicMock()
 sys.modules['cryptography.hazmat.backends'] = mock.MagicMock()
 sys.modules['cryptography.hazmat.backends.openssl'] = mock.MagicMock()
 
-mock_httpx = mock.MagicMock()
-sys.modules['httpx'] = mock_httpx
-sys.modules['httpx._types'] = mock.MagicMock()
-
-import urllib
-sys.modules['urllib.request'] = mock.MagicMock()
-if not hasattr(urllib, 'request'):
-    urllib.request = sys.modules['urllib.request']
-
 sys.modules['bytedance.volcengine_aicc_sdk.common.aes'] = mock.MagicMock()
 sys.modules['bytedance.volcengine_aicc_sdk.common.log'] = mock.MagicMock()