volcengine-python-sdk 1.0.115__tar.gz → 1.0.116__tar.gz

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: volcengine-python-sdk
-Version: 1.0.115
+Version: 1.0.116
 Summary: Volcengine SDK for Python
 Home-page: https://github.com/volcengine/volcengine-python-sdk
 License: Apache License 2.0

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/setup.py

@@ -3,7 +3,7 @@
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "volcengine-python-sdk"
-VERSION = "1.0.115"
+VERSION = "1.0.116"
 # To install the library, run the following
 #
 # python setup.py install

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcengine_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: volcengine-python-sdk
-Version: 1.0.115
+Version: 1.0.116
 Summary: Volcengine SDK for Python
 Home-page: https://github.com/volcengine/volcengine-python-sdk
 License: Apache License 2.0

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcengine_python_sdk.egg-info/SOURCES.txt

@@ -357,6 +357,9 @@ volcenginesdkarkruntime/resources/bot/completions.py
 volcenginesdkarkruntime/resources/chat/__init__.py
 volcenginesdkarkruntime/resources/chat/chat.py
 volcenginesdkarkruntime/resources/chat/completions.py
+volcenginesdkarkruntime/resources/context/__init__.py
+volcenginesdkarkruntime/resources/context/completions.py
+volcenginesdkarkruntime/resources/context/context.py
 volcenginesdkarkruntime/types/__init__.py
 volcenginesdkarkruntime/types/completion_usage.py
 volcenginesdkarkruntime/types/create_classification_response.py
@@ -391,6 +394,12 @@ volcenginesdkarkruntime/types/chat/chat_completion_tool_message_param.py
 volcenginesdkarkruntime/types/chat/chat_completion_tool_param.py
 volcenginesdkarkruntime/types/chat/chat_completion_user_message_param.py
 volcenginesdkarkruntime/types/chat/completion_create_params.py
+volcenginesdkarkruntime/types/context/__init__.py
+volcenginesdkarkruntime/types/context/context_chat_completion.py
+volcenginesdkarkruntime/types/context/context_chat_completion_chunk.py
+volcenginesdkarkruntime/types/context/context_create_params.py
+volcenginesdkarkruntime/types/context/create_context_response.py
+volcenginesdkarkruntime/types/context/truncation_strategy.py
 volcenginesdkarkruntime/types/shared_params/__init__.py
 volcenginesdkarkruntime/types/shared_params/function_definition.py
 volcenginesdkarkruntime/types/shared_params/function_parameters.py

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcenginesdkarkruntime/_client.py

@@ -37,6 +37,7 @@ class Ark(SyncAPIClient):
     bot_chat: resources.BotChat
     embeddings: resources.Embeddings
     tokenization: resources.Tokenization
+    context: resources.Context
 
     def __init__(
         self,
@@ -93,6 +94,7 @@ class Ark(SyncAPIClient):
         self.bot_chat = resources.BotChat(self)
         self.embeddings = resources.Embeddings(self)
         self.tokenization = resources.Tokenization(self)
+        self.context = resources.Context(self)
         # self.classification = resources.Classification(self)
 
     def _get_endpoint_sts_token(self, endpoint_id: str):
@@ -129,6 +131,7 @@ class AsyncArk(AsyncAPIClient):
     bot_chat: resources.AsyncBotChat
     embeddings: resources.AsyncEmbeddings
     tokenization: resources.AsyncTokenization
+    context: resources.AsyncContext
 
     def __init__(
         self,
@@ -184,6 +187,7 @@ class AsyncArk(AsyncAPIClient):
         self.bot_chat = resources.AsyncBotChat(self)
         self.embeddings = resources.AsyncEmbeddings(self)
         self.tokenization = resources.AsyncTokenization(self)
+        self.context = resources.AsyncContext(self)
         # self.classification = resources.AsyncClassification(self)
 
     def _get_endpoint_sts_token(self, endpoint_id: str):

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcenginesdkarkruntime/resources/__init__.py

@@ -3,6 +3,7 @@ from .embeddings import Embeddings, AsyncEmbeddings
 from .tokenization import Tokenization, AsyncTokenization
 from .classification import Classification, AsyncClassification
 from .bot import BotChat, AsyncBotChat
+from .context import Context, AsyncContext
 
 __all__ = [
     "Chat",
@@ -12,5 +13,7 @@ __all__ = [
     "Embeddings",
     "AsyncEmbeddings",
     "Tokenization",
-    "AsyncTokenization"
+    "AsyncTokenization",
+    "Context",
+    "AsyncContext"
 ]

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/resources/context/__init__.py

@@ -0,0 +1,3 @@
+from .context import Context, AsyncContext
+
+__all__ = ["Context", "AsyncContext"]

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/resources/context/completions.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+
+import httpx
+from typing_extensions import Literal
+
+from ..._types import Body, Query, Headers
+from ..._utils._utils import with_sts_token, async_with_sts_token
+from ..._base_client import make_request_options
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._compat import cached_property
+
+from ..._response import (
+    to_raw_response_wrapper,
+    async_to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..._streaming import Stream, AsyncStream
+from ...types.context import (
+    ContextChatCompletion,
+    ContextChatCompletionChunk
+)
+from ...types.chat import (
+    ChatCompletionMessageParam,
+    completion_create_params,
+    ChatCompletionStreamOptionsParam,
+    ChatCompletionToolParam,
+    ChatCompletionToolChoiceOptionParam
+)
+
+__all__ = ["Completions", "AsyncCompletions"]
+
+
+class Completions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CompletionsWithRawResponse:
+        return CompletionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CompletionsWithStreamingResponse:
+        return CompletionsWithStreamingResponse(self)
+
+    @with_sts_token
+    def create(
+        self,
+        *,
+        context_id: str,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: str,
+        frequency_penalty: Optional[float] | None = None,
+        function_call: completion_create_params.FunctionCall | None = None,
+        logit_bias: Optional[Dict[str, int]] | None = None,
+        logprobs: Optional[bool] | None = None,
+        max_tokens: Optional[int] | None = None,
+        presence_penalty: Optional[float] | None = None,
+        stop: Union[Optional[str], List[str]] | None = None,
+        stream: Optional[Literal[False]] | Literal[True] | None = None,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | None = None,
+        temperature: Optional[float] | None = None,
+        tools: Iterable[ChatCompletionToolParam] | None = None,
+        top_logprobs: Optional[int] | None = None,
+        top_p: Optional[float] | None = None,
+        repetition_penalty: Optional[float] | None = None,
+        n: Optional[int] | None = None,
+        tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
+        response_format: completion_create_params.ResponseFormat | None = None,
+        user: str | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> ContextChatCompletion | Stream[ContextChatCompletionChunk]:
+        return self._post(
+            "/context/chat/completions",
+            body={
+                "context_id": context_id,
+                "messages": messages,
+                "model": model,
+                "frequency_penalty": frequency_penalty,
+                "function_call": function_call,
+                "logit_bias": logit_bias,
+                "logprobs": logprobs,
+                "max_tokens": max_tokens,
+                "presence_penalty": presence_penalty,
+                "stop": stop,
+                "stream": stream,
+                "stream_options": stream_options,
+                "temperature": temperature,
+                "tools": tools,
+                "top_logprobs": top_logprobs,
+                "top_p": top_p,
+                "user": user,
+                "repetition_penalty": repetition_penalty,
+                "n": n,
+                "tool_choice": tool_choice,
+                "response_format": response_format,
+            },
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ContextChatCompletion,
+            stream=stream or False,
+            stream_cls=Stream[ContextChatCompletionChunk],
+        )
+
+
+class AsyncCompletions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCompletionsWithRawResponse:
+        return AsyncCompletionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCompletionsWithStreamingResponse:
+        return AsyncCompletionsWithStreamingResponse(self)
+
+    @async_with_sts_token
+    async def create(
+        self,
+        *,
+        context_id: str,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: str,
+        frequency_penalty: Optional[float] | None = None,
+        function_call: completion_create_params.FunctionCall | None = None,
+        logit_bias: Optional[Dict[str, int]] | None = None,
+        logprobs: Optional[bool] | None = None,
+        max_tokens: Optional[int] | None = None,
+        presence_penalty: Optional[float] | None = None,
+        stop: Union[Optional[str], List[str]] | None = None,
+        stream: Optional[Literal[False]] | Literal[True] | None = None,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | None = None,
+        temperature: Optional[float] | None = None,
+        tools: Iterable[ChatCompletionToolParam] | None = None,
+        top_logprobs: Optional[int] | None = None,
+        top_p: Optional[float] | None = None,
+        user: str | None = None,
+        repetition_penalty: Optional[float] | None = None,
+        n: Optional[int] | None = None,
+        tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
+        response_format: completion_create_params.ResponseFormat | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> ContextChatCompletion | AsyncStream[ContextChatCompletionChunk]:
+        return await self._post(
+            "/context/chat/completions",
+            body={
+                "context_id": context_id,
+                "messages": messages,
+                "model": model,
+                "frequency_penalty": frequency_penalty,
+                "function_call": function_call,
+                "logit_bias": logit_bias,
+                "logprobs": logprobs,
+                "max_tokens": max_tokens,
+                "presence_penalty": presence_penalty,
+                "stop": stop,
+                "stream": stream,
+                "stream_options": stream_options,
+                "temperature": temperature,
+                "tools": tools,
+                "top_logprobs": top_logprobs,
+                "top_p": top_p,
+                "user": user,
+                "repetition_penalty": repetition_penalty,
+                "n": n,
+                "tool_choice": tool_choice,
+                "response_format": response_format,
+            },
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ContextChatCompletion,
+            stream=stream or False,
+            stream_cls=AsyncStream[ContextChatCompletionChunk],
+        )
+
+
+class CompletionsWithRawResponse:
+    def __init__(self, completions: Completions) -> None:
+        self._completions = completions
+
+        self.create = to_raw_response_wrapper(
+            completions.create,
+        )
+
+
+class AsyncCompletionsWithRawResponse:
+    def __init__(self, completions: AsyncCompletions) -> None:
+        self._completions = completions
+
+        self.create = async_to_raw_response_wrapper(
+            completions.create,
+        )
+
+
+class CompletionsWithStreamingResponse:
+    def __init__(self, completions: Completions) -> None:
+        self._completions = completions
+
+        self.create = to_streamed_response_wrapper(
+            completions.create,
+        )
+
+
+class AsyncCompletionsWithStreamingResponse:
+    def __init__(self, completions: AsyncCompletions) -> None:
+        self._completions = completions
+
+        self.create = async_to_streamed_response_wrapper(
+            completions.create,
+        )

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/resources/context/context.py

@@ -0,0 +1,97 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+import httpx
+
+from typing import Iterable, Optional, Literal
+
+from ..._types import Body, Query, Headers
+from .completions import Completions, AsyncCompletions
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._utils._utils import with_sts_token, async_with_sts_token
+from ..._base_client import (
+    make_request_options,
+)
+from ...types.context import CreateContextResponse
+from ...types.context.context_create_params import TTLTypes, TruncationStrategy, to_optional_ttl
+from ...types.chat import ChatCompletionMessageParam
+
+__all__ = ["Context", "AsyncContext"]
+
+
+class Context(SyncAPIResource):
+    @cached_property
+    def completions(self) -> Completions:
+        return Completions(self._client)
+
+    @with_sts_token
+    def create(
+            self,
+            *,
+            model: str,
+            messages: Iterable[ChatCompletionMessageParam],
+            ttl: Optional[TTLTypes] | None = None,
+            mode: Literal["session", "common_prefix"] = "session",
+            truncation_strategy: Optional[TruncationStrategy] | None = None,
+            extra_headers: Headers | None = None,
+            extra_query: Query | None = None,
+            extra_body: Body | None = None,
+            timeout: float | httpx.Timeout | None = None,
+    ) -> CreateContextResponse:
+        ttl = to_optional_ttl(ttl)
+        return self._post(
+            "/context/create",
+            body={
+                "model": model,
+                "mode": mode,
+                "messages": messages,
+                "ttl": ttl,
+                "truncation_strategy": truncation_strategy,
+            },
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=CreateContextResponse,
+        )
+
+class AsyncContext(AsyncAPIResource):
+    @cached_property
+    def completions(self) -> AsyncCompletions:
+        return AsyncCompletions(self._client)
+
+    @async_with_sts_token
+    async def create(
+            self,
+            *,
+            model: str,
+            mode: Literal["session", "common_prefix"] = "session",
+            messages: Iterable[ChatCompletionMessageParam],
+            ttl: Optional[TTLTypes] | None = None,
+            truncation_strategy: Optional[TruncationStrategy] | None = None,
+            extra_headers: Headers | None = None,
+            extra_query: Query | None = None,
+            extra_body: Body | None = None,
+            timeout: float | httpx.Timeout | None = None,
+    ) -> CreateContextResponse:
+        ttl = to_optional_ttl(ttl)
+        return await self._post(
+            "/context/create",
+            body={
+                "model": model,
+                "mode": mode,
+                "messages": messages,
+                "ttl": ttl,
+                "truncation_strategy": truncation_strategy,
+            },
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=CreateContextResponse,
+        )

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcenginesdkarkruntime/types/completion_usage.py

@@ -1,8 +1,14 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from pydantic import BaseModel
+from typing import Optional
 
-__all__ = ["CompletionUsage"]
+__all__ = ["CompletionUsage", "PromptTokensDetails"]
+
+
+class PromptTokensDetails(BaseModel):
+    cached_tokens: int
+    """Number of tokens hit cache."""
 
 
 class CompletionUsage(BaseModel):
@@ -14,3 +20,6 @@ class CompletionUsage(BaseModel):
 
     total_tokens: int
     """Total number of tokens used in the request (prompt + completion)."""
+
+    prompt_tokens_details: Optional[PromptTokensDetails] = None
+    """Prompt tokens details."""

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/__init__.py

@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .context_chat_completion_chunk import ContextChatCompletionChunk
+from .context_chat_completion import ContextChatCompletion
+from .create_context_response import CreateContextResponse
+from .context_create_params import TruncationStrategy, TTLTypes

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/context_chat_completion.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..chat.chat_completion import Choice
+from ..completion_usage import CompletionUsage
+
+__all__ = [
+    "ContextChatCompletion",
+]
+
+
+class ContextChatCompletion(BaseModel):
+    id: str
+    """A unique identifier for the chat completion."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created."""
+
+    model: str
+    """The model used for the chat completion."""
+
+    object: Literal["chat.completion"]
+    """The object type, which is always `chat.completion`."""
+
+    usage: Optional[CompletionUsage] = None
+    """Usage statistics for the completion request."""

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/context_chat_completion_chunk.py

@@ -0,0 +1,41 @@
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..chat.chat_completion_chunk import Choice
+from ..completion_usage import CompletionUsage
+
+__all__ = [
+    "ContextChatCompletionChunk",
+]
+
+
+class ContextChatCompletionChunk(BaseModel):
+    id: str
+    """A unique identifier for the chat completion. Each chunk has the same ID."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created.
+
+    Each chunk has the same timestamp.
+    """
+
+    model: str
+    """The model to generate the completion."""
+
+    object: Literal["chat.completion.chunk"]
+    """The object type, which is always `chat.completion.chunk`."""
+
+    usage: Optional[CompletionUsage] = None
+    """
+    An optional field that will only be present when you set
+    `stream_options: {"include_usage": true}` in your request. When present, it
+    contains a null value except for the last chunk which contains the token usage
+    statistics for the entire request.
+    """

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/context_create_params.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import datetime
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = [
+    "TruncationStrategy",
+    "TTLTypes",
+    "to_optional_ttl"
+]
+
+
+class TruncationStrategy(TypedDict, total=False):
+    type: Required[Literal["last_history_tokens", "rolling_tokens"]]
+    """The truncation strategy to use for the context. The default is last_history_tokens."""
+    last_history_tokens: Optional[int]
+    """The number of most recent tokens from the context when constructing the chat completion."""
+    rolling_tokens: Optional[bool]
+    """If true, the context will not rolling when reach the max tokens limit."""
+
+
+TTLTypes = Union[int, datetime.timedelta]
+
+
+def to_optional_ttl(ttl: TTLTypes | None) -> int | None:
+    if ttl is None:
+        return None
+    elif isinstance(ttl, datetime.timedelta):
+        return int(ttl.total_seconds())
+    elif isinstance(ttl, int):
+        return ttl
+    else:
+        raise TypeError(
+            f"Could not convert input to `ttl` \n'" f"  type: {type(ttl)}\n",
+            ttl,
+        )

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/create_context_response.py

@@ -0,0 +1,25 @@
+from ..._models import BaseModel
+from ..completion_usage import CompletionUsage
+from .truncation_strategy import TruncationStrategy
+
+__all__ = ["CreateContextResponse"]
+
+
+class CreateContextResponse(BaseModel):
+    id: str
+    """A unique identifier for the context."""
+    model: str
+    """The endpoint used for the context."""
+    mode: str
+    """The mode used for the context."""
+    ttl: int
+    """The time to live (TTL) for the context in seconds."""
+    truncation_strategy: TruncationStrategy
+    """
+    Controls for how a context will be truncated prior to the run. 
+    Use this to control the context window for the chat completion.
+    """
+    usage: CompletionUsage
+    """
+    usage for context create.
+    """

volcengine-python-sdk-1.0.116/volcenginesdkarkruntime/types/context/truncation_strategy.py

@@ -0,0 +1,13 @@
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TruncationStrategy"]
+
+
+class TruncationStrategy(BaseModel):
+    type: Literal["last_history_tokens"]
+    """The truncation strategy to use for the context. The default is last_history_tokens."""
+    last_history_tokens: Optional[int] = None
+    """The number of most recent tokens from the context when constructing the chat completion."""

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcenginesdkcore/api_client.py

@@ -67,7 +67,7 @@ class ApiClient(object):
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'volcstack-python-sdk/1.0.115'
+        self.user_agent = 'volcstack-python-sdk/1.0.116'
         self.client_side_validation = configuration.client_side_validation
 
     def __del__(self):

{volcengine-python-sdk-1.0.115 → volcengine-python-sdk-1.0.116}/volcenginesdkcore/configuration.py

@@ -221,5 +221,5 @@ 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: 1.0.115".\
+               "SDK Package Version: 1.0.116".\
                format(env=sys.platform, pyversion=sys.version)