volcengine-python-sdk 4.0.27__py2.py3-none-any.whl → 4.0.29__py2.py3-none-any.whl

volcenginesdkarkruntime/resources/encryption.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+from .._constants import ARK_E2E_ENCRYPTION_HEADER
+from .._streaming import Stream, AsyncStream
+from ..types.chat import (
+    ChatCompletion,
+    ChatCompletionChunk,
+)
+
+import os
+import json
+import warnings
+from copy import deepcopy
+from typing import (
+    Union,
+    Iterable,
+    Callable,
+    Iterator,
+    AsyncIterator,
+)
+
+from .._utils._key_agreement import aes_gcm_decrypt_base64_string, aes_gcm_decrypt_base64_list, decrypt_validate
+
+
+def _decrypt_chunk(
+    key: bytes, nonce: bytes, resp: Stream[ChatCompletionChunk]
+) -> Iterator[ChatCompletionChunk]:
+    for chunk in resp:
+        if chunk.choices is not None:
+            for index, choice in enumerate(chunk.choices):
+                if (
+                    choice.delta is not None and choice.delta.content is not None
+                    and choice.finish_reason != 'content_filter'
+                ):
+                    choice.delta.content = aes_gcm_decrypt_base64_string(
+                        key, nonce, choice.delta.content
+                    )
+                chunk.choices[index] = choice
+        yield chunk
+
+
+async def _async_decrypt_chunk(
+    key: bytes, nonce: bytes, resp: AsyncStream[ChatCompletionChunk]
+) -> AsyncIterator[ChatCompletionChunk]:
+    async for chunk in resp:
+        if chunk.choices is not None:
+            for index, choice in enumerate(chunk.choices):
+                if (
+                    choice.delta is not None and choice.delta.content is not None
+                    and choice.finish_reason != 'content_filter'
+                ):
+                    choice.delta.content = aes_gcm_decrypt_base64_string(
+                        key, nonce, choice.delta.content
+                    )
+                chunk.choices[index] = choice
+        yield chunk
+
+
+def _decrypt(
+    key: bytes,
+    nonce: bytes,
+    resp: Union[ChatCompletion, Stream[ChatCompletionChunk]]
+) -> ChatCompletion | Stream[ChatCompletionChunk]:
+    if isinstance(resp, ChatCompletion):
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if (
+                    choice.message is not None and choice.finish_reason != 'content_filter'
+                    and choice.message.content is not None
+                ):
+                    try:
+                        content = aes_gcm_decrypt_base64_string(
+                            key, nonce, choice.message.content
+                        )
+                    except Exception:
+                        content = ''
+                    if content == '' or not decrypt_validate(choice.message.content):
+                        content = aes_gcm_decrypt_base64_list(
+                            key, nonce, choice.message.content
+                        )
+                    choice.message.content = content
+                resp.choices[index] = choice
+        return resp
+    else:
+        return Stream._make_stream_from_iterator(
+            _decrypt_chunk(key, nonce, resp)
+        )
+
+
+async def _async_decrypt(
+    key: bytes,
+    nonce: bytes,
+    resp: ChatCompletion | AsyncStream[ChatCompletionChunk],
+) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
+    if isinstance(resp, ChatCompletion):
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if (
+                    choice.message is not None and choice.finish_reason != 'content_filter'
+                    and choice.message.content is not None
+                ):
+                    try:
+                        content = aes_gcm_decrypt_base64_string(
+                            key, nonce, choice.message.content
+                        )
+                    except Exception:
+                        content = ''
+                    if content == '' or not decrypt_validate(choice.message.content):
+                        content = aes_gcm_decrypt_base64_list(
+                            key, nonce, choice.message.content
+                        )
+                    choice.message.content = content
+                resp.choices[index] = choice
+        return resp
+    else:
+        return AsyncStream._make_stream_from_iterator(
+            _async_decrypt_chunk(key, nonce, resp)
+        )
+
+
+def with_e2e_encryption(func):
+    def wrapper(*args, **kwargs):
+        is_encrypt, _crypto_key, _crypto_nonce = _content_encryption(
+            args, kwargs)
+        resp = func(*args, **kwargs)
+        if is_encrypt:
+            resp = _decrypt(_crypto_key, _crypto_nonce, resp)
+        return resp
+
+    return wrapper
+
+
+def async_with_e2e_encryption(func):
+    async def wrapper(*args, **kwargs):
+        is_encrypt, _crypto_key, _crypto_nonce = _content_encryption(
+            args, kwargs)
+        resp = await func(*args, **kwargs)
+        if is_encrypt:
+            resp = await _async_decrypt(_crypto_key, _crypto_nonce, resp)
+        return resp
+
+    return wrapper
+
+
+def _content_encryption(args, kwargs):
+    assert len(args) > 0
+    extra_headers = (
+        kwargs.get("extra_headers") if kwargs.get("extra_headers") else {}
+    )
+    if (
+        extra_headers is not None
+        and extra_headers.get(ARK_E2E_ENCRYPTION_HEADER, None) == "true"
+    ):
+        model: str = kwargs.get("model", "")
+        messages = deepcopy(kwargs["messages"])
+        ark_client = args[0]._client
+        client, ring_id, key_id, exp_time = ark_client._get_endpoint_certificate(
+            model)
+        _crypto_key, _crypto_nonce, session_token = client.generate_ecies_key_pair()
+        extra_headers["X-Session-Token"] = session_token
+        _process_messages(
+            messages,
+            lambda x: client.encrypt_string_with_key(
+                _crypto_key, _crypto_nonce, x),
+        )
+        info = {"ExpireTime": exp_time}
+        if os.environ.get("VOLC_ARK_ENCRYPTION") == "AICC":
+            info["Version"] = 'AICCv0.1'
+            info["KeyID"] = key_id
+            info["RingID"] = ring_id
+        extra_headers["X-Encrypt-Info"] = json.dumps(info)
+        kwargs["extra_headers"] = {**extra_headers}
+        kwargs["messages"] = messages
+        return True, _crypto_key, _crypto_nonce
+    return False, None, None
+
+
+def _process_messages(
+    messages, f: Callable[[str], str]
+):
+    for message in messages:
+        if message.get("content", None) is not None:
+            current_content = message.get("content")
+            if isinstance(current_content, str):
+                message["content"] = f(current_content)
+            elif isinstance(current_content, Iterable):
+                for part in current_content:
+                    if part.get("type", None) == "text":
+                        part["text"] = f(part["text"])
+                    elif part.get("type", None) == "image_url":
+                        if part["image_url"]["url"].startswith("data:"):
+                            part["image_url"]["url"] = f(
+                                part["image_url"]["url"])
+                        else:
+                            warnings.warn(
+                                "encryption is not supported for image url, "
+                                "please use base64 image if you want encryption"
+                            )
+                    else:
+                        raise TypeError(
+                            "encryption is not supported for content type {}".format(
+                                type(part)
+                            )
+                        )
+            else:
+                raise TypeError(
+                    "encryption is not supported for content type {}".format(
+                        type(message.get("content"))
+                    )
+                )

volcenginesdkarkruntime/resources/images/images.py

@@ -21,10 +21,11 @@ from ..._types import NOT_GIVEN, NotGiven
 from ..._base_client import make_request_options
 from ..._utils._utils import apikey_required, async_apikey_required
 from ..._resource import SyncAPIResource, AsyncAPIResource
-from ...types.images import SequentialImageGenerationOptions, ImagesResponse
+from ...types.images import OptimizePromptOptions, SequentialImageGenerationOptions, ImagesResponse
 from ...types.images.image_gen_stream_event import ImageGenStreamEvent
 from ..._types import Body, Query, Headers
 from ..._streaming import Stream
+from ...types.images.images import OptimizePromptOptions
 
 
 class Images(SyncAPIResource):
@@ -41,6 +42,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -72,6 +74,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -95,6 +98,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -118,6 +122,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -138,6 +143,10 @@ class Images(SyncAPIResource):
                 "guidance_scale": guidance_scale,
                 "watermark": watermark,
                 "optimize_prompt": optimize_prompt,
+                "optimize_prompt_options": (
+                    optimize_prompt_options.model_dump(mode="json")
+                    if optimize_prompt_options is not None else None
+                ),
                 "sequential_image_generation": sequential_image_generation,
                 "sequential_image_generation_options": (
                     sequential_image_generation_options.model_dump(mode="json")
@@ -162,70 +171,73 @@ class Images(SyncAPIResource):
 class AsyncImages(AsyncAPIResource):
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
     ) -> ImagesResponse:
         ...
 
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: Literal[True],
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: Literal[True],
     ) -> Stream[ImageGenStreamEvent]:
         ...
 
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: bool,
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: bool,
     ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
         ...
 
@@ -242,6 +254,7 @@ class AsyncImages(AsyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -262,6 +275,10 @@ class AsyncImages(AsyncAPIResource):
                 "guidance_scale": guidance_scale,
                 "watermark": watermark,
                 "optimize_prompt": optimize_prompt,
+                "optimize_prompt_options": (
+                    optimize_prompt_options.model_dump(mode="json")
+                    if optimize_prompt_options is not None else None
+                ),
                 "sequential_image_generation": sequential_image_generation,
                 "sequential_image_generation_options": (
                     sequential_image_generation_options.model_dump(mode="json")

volcenginesdkarkruntime/types/content_generation/content_generation_task.py

@@ -27,6 +27,9 @@ class Content(BaseModel):
     last_frame_url: str
     """The URL of the last frame of the generated video, if any."""
 
+    file_url: str
+    """The URL of the generated file, if any."""
+
 
 class ContentGenerationError(BaseModel):
     message: str
@@ -55,6 +58,18 @@ class ContentGenerationTask(BaseModel):
     usage: Usage
     """The usage information for the task."""
 
+    subdivisionlevel: str
+    """The subdivision level of the task."""
+
+    fileformat: str
+    """The file format of the generated content."""
+
+    frames: int
+    """The number of frames in the generated content."""
+
+    framespersecond: int
+    """The number of frames per second in the generated content."""
+
     created_at: int
     """The Unix timestamp when the task was created."""
 

volcenginesdkarkruntime/types/images/__init__.py

@@ -10,7 +10,7 @@
 #
 # This modified file is released under the same license.
 
-from .images import SequentialImageGenerationOptions, ImagesResponse
+from .images import OptimizePromptOptions, SequentialImageGenerationOptions, ImagesResponse
 
 
-__all__ = ["SequentialImageGenerationOptions", "ImagesResponse"]
+__all__ = ["OptimizePromptOptions", "SequentialImageGenerationOptions", "ImagesResponse"]

volcenginesdkarkruntime/types/images/images.py

@@ -14,13 +14,19 @@ from typing import List, Optional
 
 from volcenginesdkarkruntime._models import BaseModel
 
-__all__ = ["SequentialImageGenerationOptions", "ImagesResponse"]
+__all__ = ["OptimizePromptOptions", "SequentialImageGenerationOptions", "ImagesResponse"]
+
+
+class OptimizePromptOptions(BaseModel):
+    thinking: Optional[str] = None
+    mode: Optional[str] = None
 
 
 class SequentialImageGenerationOptions(BaseModel):
     max_images: Optional[int] = None
     """ Maximum number of images to generate in this request; effective only when the multi-image feature is enabled """
 
+
 class Usage(BaseModel):
     generated_images: int
     """The number of images generated."""

volcenginesdkarkruntime/types/shared/reasoning_effort.py

@@ -0,0 +1,17 @@
+
+# Copyright (c) [2025] [OpenAI]
+# Copyright (c) [2025] [ByteDance Ltd. and/or its affiliates.]
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file has been modified by [ByteDance Ltd. and/or its affiliates.] on 2025.7
+#
+# Original file was released under Apache License Version 2.0, with the full license text
+# available at https://github.com/openai/openai-python/blob/main/LICENSE.
+#
+# This modified file is released under the same license.
+from typing import Optional
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["ReasoningEffort"]
+
+ReasoningEffort: TypeAlias = Optional[Literal["minimal", "low", "medium", "high"]]

volcenginesdkcore/api_client.py

@@ -64,7 +64,7 @@ class ApiClient(object):
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'volcstack-python-sdk/4.0.27'
+        self.user_agent = 'volcstack-python-sdk/4.0.29'
         self.client_side_validation = configuration.client_side_validation
 
         self.interceptor_chain = InterceptorChain()

volcenginesdkcore/configuration.py

@@ -272,7 +272,7 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
                "OS: {env}\n" \
                "Python Version: {pyversion}\n" \
                "Version of the API: 0.1.0\n" \
-               "SDK Package Version: 4.0.27".\
+               "SDK Package Version: 4.0.29".\
             format(env=sys.platform, pyversion=sys.version)
 
     @property