byteplus-python-sdk-v2 2.0.1__tar.gz → 2.0.2__tar.gz

{byteplus-python-sdk-v2-2.0.1/byteplus_python_sdk_v2.egg-info → byteplus-python-sdk-v2-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byteplus-python-sdk-v2
-Version: 2.0.1
+Version: 2.0.2
 Summary: Byteplus SDK for Python
 License: Apache License 2.0
 Platform: any

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2/byteplus_python_sdk_v2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byteplus-python-sdk-v2
-Version: 2.0.1
+Version: 2.0.2
 Summary: Byteplus SDK for Python
 License: Apache License 2.0
 Platform: any

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2}/byteplus_python_sdk_v2.egg-info/SOURCES.txt

@@ -112,10 +112,14 @@ byteplussdkarkruntime/_types.py
 byteplussdkarkruntime/_utils/__init__.py
 byteplussdkarkruntime/_utils/_key_agreement.py
 byteplussdkarkruntime/_utils/_logs.py
+byteplussdkarkruntime/_utils/_model_breaker.py
 byteplussdkarkruntime/_utils/_transform.py
 byteplussdkarkruntime/_utils/_typing.py
 byteplussdkarkruntime/_utils/_utils.py
 byteplussdkarkruntime/resources/__init__.py
+byteplussdkarkruntime/resources/batch_chat/__init__.py
+byteplussdkarkruntime/resources/batch_chat/chat.py
+byteplussdkarkruntime/resources/batch_chat/completions.py
 byteplussdkarkruntime/resources/chat/__init__.py
 byteplussdkarkruntime/resources/chat/chat.py
 byteplussdkarkruntime/resources/chat/completions.py

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2}/byteplussdkarkruntime/_base_client.py

@@ -139,7 +139,7 @@ class BaseClient(Generic[_HttpxClientT]):
 
     @property
     def user_agent(self) -> str:
-        return "volc-sdk-python/" + VERSION
+        return "byteplus-sdk-python/" + VERSION
 
     def default_headers(self) -> Dict[str, str]:
         return {
@@ -594,6 +594,29 @@ class SyncAPIClient(BaseClient):
         )
 
         return cast(ResponseT, self.request(cast_to, opts))
+    
+    def post_without_retry(
+            self,
+            path: str,
+            *,
+            cast_to: Type[ResponseT],
+            body: Dict | None = None,
+            options: ExtraRequestOptions = {},
+            files: RequestFiles | None = None,
+            stream: bool = False,
+            stream_cls: type[_StreamT] | None = None,
+    ) -> ResponseT | _StreamT:
+        opts = RequestOptions.construct(  # type: ignore
+            method="post",
+            url=path,
+            body=body,
+            **options,
+        )
+
+        return cast(
+            ResponseT, self.request(cast_to, opts, remaining_retries=0, stream=stream, stream_cls=stream_cls)
+        )
+
 
     def request(
             self,
@@ -754,6 +777,26 @@ class AsyncAPIClient(BaseClient):
         )
 
         return await self.request(cast_to, opts)
+    
+    async def post_without_retry(
+            self,
+            path: str,
+            *,
+            cast_to: Type[ResponseT],
+            body: Dict | None = None,
+            options: ExtraRequestOptions = {},
+            files: RequestFiles | None = None,
+            stream: bool = False,
+            stream_cls: type[_AsyncStreamT] | None = None,
+    ) -> ResponseT | _AsyncStreamT:
+        opts = RequestOptions.construct(
+            method="post",
+            url=path,
+            body=body,
+            **options,
+        )
+
+        return await self.request(cast_to, opts, remaining_retries=0, stream=stream, stream_cls=stream_cls)
 
     async def request(
             self,

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2}/byteplussdkarkruntime/_client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 import threading
@@ -28,6 +29,7 @@ from ._constants import (
 from ._streaming import Stream
 
 from ._utils._key_agreement import key_agreement_client
+from ._utils._model_breaker import ModelBreaker
 
 __all__ = ["Ark", "AsyncArk"]
 
@@ -35,6 +37,9 @@ __all__ = ["Ark", "AsyncArk"]
 class Ark(SyncAPIClient):
     chat: resources.Chat
     context: resources.Context
+    batch_chat: resources.BatchChat
+    model_breaker_map: dict[str, ModelBreaker]
+    model_breaker_lock: threading.Lock
 
     def __init__(
         self,
@@ -90,6 +95,9 @@ class Ark(SyncAPIClient):
 
         self.chat = resources.Chat(self)
         self.context = resources.Context(self)
+        self.batch_chat = resources.BatchChat(self)
+        self.model_breaker_map = defaultdict(ModelBreaker)
+        self.model_breaker_lock = threading.Lock()
         # self.classification = resources.Classification(self)
 
     def _get_endpoint_sts_token(self, endpoint_id: str):
@@ -119,11 +127,18 @@ class Ark(SyncAPIClient):
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
         return {"Authorization": f"Bearer {api_key}"}
+    
+    def get_model_breaker(self, model_name: str) -> ModelBreaker:
+        with self.model_breaker_lock:
+            return self.model_breaker_map[model_name]
 
 
 class AsyncArk(AsyncAPIClient):
     chat: resources.AsyncChat
     context: resources.AsyncContext
+    batch_chat: resources.AsyncBatchChat
+    model_breaker_map: dict[str, ModelBreaker]
+    model_breaker_lock: asyncio.Lock
 
     def __init__(
         self,
@@ -178,6 +193,9 @@ class AsyncArk(AsyncAPIClient):
 
         self.chat = resources.AsyncChat(self)
         self.context = resources.AsyncContext(self)
+        self.batch_chat = resources.AsyncBatchChat(self)
+        self.model_breaker_map = defaultdict(ModelBreaker)
+        self.model_breaker_lock = asyncio.Lock()
         # self.classification = resources.AsyncClassification(self)
 
     def _get_endpoint_sts_token(self, endpoint_id: str):
@@ -200,6 +218,10 @@ class AsyncArk(AsyncAPIClient):
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
         return {"Authorization": f"Bearer {api_key}"}
+    
+    async def get_model_breaker(self, model_name: str) -> ModelBreaker:
+        async with self.model_breaker_lock:
+            return self.model_breaker_map[model_name]
 
 
 class StsTokenManager(object):

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2}/byteplussdkarkruntime/_resource.py

@@ -12,6 +12,7 @@ class SyncAPIResource:
         self._post = client.post
         self._get = client.get
         self._delete = client.delete
+        self._post_without_retry = client.post_without_retry
 
 
 class AsyncAPIResource:
@@ -22,3 +23,4 @@ class AsyncAPIResource:
         self._post = client.post
         self._get = client.get
         self._delete = client.delete
+        self._post_without_retry = client.post_without_retry

byteplus-python-sdk-v2-2.0.2/byteplussdkarkruntime/_utils/_model_breaker.py

@@ -0,0 +1,83 @@
+import asyncio
+import time
+import uuid
+import threading
+
+
+class _QuerySet(object):
+    def __init__(self):
+        self._items = list()
+        self._index = dict()
+        self._lock = threading.Lock()
+
+    def add(self, item: int) -> None:
+        with self._lock:
+            if item in self._index:
+                return
+
+            self._items.append(item)
+            self._index[item] = len(self._items) - 1
+
+    def remove(self, item: int) -> None:
+        with self._lock:
+            if item not in self._index:
+                return
+
+            index = self._index[item]
+            self._items[index] = self._items[-1]
+            self._index[self._items[-1]] = index
+            self._items.pop()
+            del self._index[item]
+
+    def query(self, item: int) -> int:
+        with self._lock:
+            return self._index[item]
+
+
+class ModelBreaker(object):
+    def __init__(self):
+        # 初始化 allow_time 为当前时间
+        self._allow_time = time.perf_counter()
+        self._waiters = _QuerySet()
+
+    def _allow(self, id: int) -> bool:
+        cur = time.perf_counter()
+        # 如果当前时间小于等于 allow_time，不允许通过
+        if cur <= self._allow_time:
+            return 0
+        # 如果当前时间与 allow_time 的差值大于 10，允许通过
+        if cur - self._allow_time > 10:
+            return True
+        # 如果当前时间与 allow_time 的差值小于等于 10，慢启动通过
+        return self._waiters.query(id) < 2 ** (cur - self._allow_time)
+
+    def _get_allowed_duration(self) -> float:
+        # 计算当前时间与 allow_time 之间的持续时间
+        allow_duration = self._allow_time - time.perf_counter()
+
+        # 至少有 1 秒的等待时间
+        return max(allow_duration, 1)
+
+    def _acquire(self) -> int:
+        id = uuid.uuid4().int
+        self._waiters.add(id)
+        return id
+
+    def _release(self, id: int) -> None:
+        self._waiters.remove(id)
+
+    def reset(self, duration: float) -> None:
+        # 将 allow_time 重置为当前时间加上指定的持续时间
+        self._allow_time = time.perf_counter() + duration
+
+    def wait(self) -> None:
+        id = self._acquire()
+        while not self._allow(id):
+            time.sleep(self._get_allowed_duration())
+        self._release(id)
+
+    async def asyncwait(self) -> None:
+        id = self._acquire()
+        while not self._allow(id):
+            await asyncio.sleep(self._get_allowed_duration())
+        self._release(id)

{byteplus-python-sdk-v2-2.0.1 → byteplus-python-sdk-v2-2.0.2}/byteplussdkarkruntime/resources/__init__.py

@@ -1,9 +1,12 @@
 from .chat import Chat, AsyncChat
 from .context import Context, AsyncContext
+from .batch_chat import BatchChat, AsyncBatchChat
 
 __all__ = [
     "Chat",
     "AsyncChat",
     "Context",
     "AsyncContext",
+    "BatchChat",
+    "AsyncBatchChat"
 ]

byteplus-python-sdk-v2-2.0.2/byteplussdkarkruntime/resources/batch_chat/__init__.py

@@ -0,0 +1,3 @@
+from .chat import BatchChat, AsyncBatchChat
+
+__all__ = ["BatchChat", "AsyncBatchChat"]

byteplus-python-sdk-v2-2.0.2/byteplussdkarkruntime/resources/batch_chat/chat.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .completions import Completions, AsyncCompletions
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["BatchChat", "AsyncBatchChat"]
+
+
+class BatchChat(SyncAPIResource):
+    @cached_property
+    def completions(self) -> Completions:
+        return Completions(self._client)
+
+
+class AsyncBatchChat(AsyncAPIResource):
+    @cached_property
+    def completions(self) -> AsyncCompletions:
+        return AsyncCompletions(self._client)

byteplus-python-sdk-v2-2.0.2/byteplussdkarkruntime/resources/batch_chat/completions.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import timedelta, datetime
+from random import random
+from typing import Dict, List, Union, Iterable, Optional, Callable
+from typing_extensions import Literal
+
+import httpx
+
+from ..._exceptions import ArkAPITimeoutError, ArkAPIConnectionError, ArkAPIStatusError
+from ..._types import Body, Query, Headers
+from ..._utils._utils import with_sts_token, async_with_sts_token
+from ..._utils._key_agreement import aes_gcm_decrypt_base64_string
+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,
+)
+from ...types.chat import (
+    ChatCompletion,
+    ChatCompletionMessageParam,
+    completion_create_params,
+    ChatCompletionToolParam,
+    ChatCompletionToolChoiceOptionParam
+)
+from ..._constants import (
+    ARK_E2E_ENCRYPTION_HEADER,
+    INITIAL_RETRY_DELAY,
+    MAX_RETRY_DELAY,
+)
+
+__all__ = ["Completions", "AsyncCompletions"]
+
+
+def _calculate_retry_timeout(retry_times) -> float:
+    nbRetries = min(retry_times, MAX_RETRY_DELAY / INITIAL_RETRY_DELAY)
+    sleep_seconds = min(INITIAL_RETRY_DELAY * pow(2, nbRetries), MAX_RETRY_DELAY)
+    # Apply some jitter, plus-or-minus half a second.
+    jitter = 1 - 0.25 * random()
+    timeout = sleep_seconds * jitter
+    return timeout if timeout >= 0 else 0
+
+
+def _get_retry_after(response):
+    retry_after = response.headers.get("Retry-After")
+    if retry_after is not None:
+        if retry_after.isdigit():
+            return int(retry_after)
+    return None
+
+
+def _should_retry(response):
+    # Retry on request timeouts.
+    if response.status_code == 408:
+        return True
+
+    # Retry on lock timeouts.
+    if response.status_code == 409:
+        return True
+
+    # Retry on rate limits.
+    if response.status_code == 429:
+        return True
+
+    # Retry internal errors.
+    if response.status_code >= 500:
+        return True
+
+    return False
+
+
+class Completions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CompletionsWithRawResponse:
+        return CompletionsWithRawResponse(self)
+
+    def _process_messages(self, messages: Iterable[ChatCompletionMessageParam],
+                          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):
+                    raise TypeError("content type {} is not supported end-to-end encryption".
+                                    format(type(message.get('content'))))
+                else:
+                    raise TypeError("content type {} is not supported end-to-end encryption".
+                                    format(type(message.get('content'))))
+
+    def _encrypt(self, model: str, messages: Iterable[ChatCompletionMessageParam], extra_headers: Headers
+                 ) -> tuple[bytes, bytes]:
+        client = self._client._get_endpoint_certificate(model)
+        _crypto_key, _crypto_nonce, session_token = client.generate_ecies_key_pair()
+        extra_headers['X-Session-Token'] = session_token
+        self._process_messages(messages, lambda x: client.encrypt_string_with_key(_crypto_key,
+                                                                                  _crypto_nonce,
+                                                                                  x))
+        return _crypto_key, _crypto_nonce
+
+    def _decrypt(self, key: bytes, nonce: bytes, resp: ChatCompletion
+                 ) -> ChatCompletion:
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if choice.message is not None and choice.message.content is not None:
+                    choice.message.content = aes_gcm_decrypt_base64_string(key, nonce, choice.message.content)
+                resp.choices[index] = choice
+        return resp
+
+    @with_sts_token
+    def create(
+        self,
+        *,
+        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,
+        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,
+        parallel_tool_calls: Optional[bool] | None = None,
+        service_tier: Optional[Literal["auto", "default"]] | 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,
+    ) -> ChatCompletion:
+        is_encrypt = False
+        if extra_headers is not None and extra_headers.get(ARK_E2E_ENCRYPTION_HEADER, None) == 'true':
+            is_encrypt = True
+            e2e_key, e2e_nonce = self._encrypt(model, messages, extra_headers)
+        retryTimes = 0
+        last_time = self._get_request_last_time(timeout)
+        model_breaker = self._client.get_model_breaker(model)
+        while True:
+            model_breaker.wait()
+            if datetime.now() > last_time:
+                raise ArkAPITimeoutError()
+            try:
+                resp = self._post_without_retry(
+                    "/batch/chat/completions",
+                    body={
+                        "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,
+                        "temperature": temperature,
+                        "tools": tools,
+                        "top_logprobs": top_logprobs,
+                        "top_p": top_p,
+                        "user": user,
+                        "repetition_penalty": repetition_penalty,
+                        "n": n,
+                        "parallel_tool_calls": parallel_tool_calls,
+                        "service_tier": service_tier,
+                        "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=ChatCompletion,
+                )
+            except (ArkAPITimeoutError, ArkAPIConnectionError):
+                waitTime = _calculate_retry_timeout(retryTimes)
+                if datetime.now() + timedelta(seconds=waitTime) > last_time:
+                    raise ArkAPITimeoutError()
+                time.sleep(waitTime)
+                retryTimes = retryTimes + 1
+                continue
+            except ArkAPIStatusError as err:
+                retry_after = _get_retry_after(err.response)
+                if retry_after is not None:
+                    model_breaker.reset(retry_after)
+                if _should_retry(err.response):
+                    continue
+                else:
+                    raise err
+            if is_encrypt:
+                resp = self._decrypt(e2e_key, e2e_nonce, resp)
+            return resp
+
+    def _get_request_last_time(self, timeout):
+        if timeout is None:
+            timeout = self._client.timeout
+        timeoutSeconds = 0
+        if isinstance(timeout, httpx.Timeout):
+            timeoutSeconds = timeout.read
+        elif isinstance(timeout, float):
+            timeoutSeconds = timeout
+        elif isinstance(self._client.timeout, int):
+            timeoutSeconds = timeout
+        else:
+            raise TypeError("timeout type {} is not supported".format(type(self._client.timeout)))
+        return datetime.now() + timedelta(seconds=timeoutSeconds)
+
+
+class AsyncCompletions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCompletionsWithRawResponse:
+        return AsyncCompletionsWithRawResponse(self)
+
+    def _process_messages(self, messages: Iterable[ChatCompletionMessageParam],
+                          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)
+                else:
+                    raise TypeError("content type {} is not supported end-to-end encryption".
+                                    format(type(message.get('content'))))
+
+    def _encrypt(self, model: str, messages: Iterable[ChatCompletionMessageParam], extra_headers: Headers
+                 ) -> tuple[bytes, bytes]:
+        client = self._client._get_endpoint_certificate(model)
+        _crypto_key, _crypto_nonce, session_token = client.generate_ecies_key_pair()
+        extra_headers['X-Session-Token'] = session_token
+        self._process_messages(messages, lambda x: client.encrypt_string_with_key(_crypto_key,
+                                                                                  _crypto_nonce,
+                                                                                  x))
+        return _crypto_key, _crypto_nonce
+
+    async def _decrypt(self, key: bytes, nonce: bytes, resp: ChatCompletion
+                       ) -> ChatCompletion:
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if choice.message is not None and choice.message.content is not None:
+                    choice.message.content = aes_gcm_decrypt_base64_string(key, nonce, choice.message.content)
+                resp.choices[index] = choice
+        return resp
+
+    @async_with_sts_token
+    async def create(
+        self,
+        *,
+        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,
+        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,
+        parallel_tool_calls: Optional[bool] | None = None,
+        service_tier: Optional[Literal["auto", "default"]] | 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,
+    ) -> ChatCompletion:
+        is_encrypt = False
+        if extra_headers is not None and extra_headers.get(ARK_E2E_ENCRYPTION_HEADER, None) == 'true':
+            is_encrypt = True
+            e2e_key, e2e_nonce = self._encrypt(model, messages, extra_headers)
+
+        retryTimes = 0
+        last_time = self._get_request_last_time(timeout)
+        model_breaker = await self._client.get_model_breaker(model)
+        while True:
+            await model_breaker.asyncwait()
+            if datetime.now() > last_time:
+                raise ArkAPITimeoutError()
+            try:
+                resp = await self._post_without_retry(
+                    "/batch/chat/completions",
+                    body={
+                        "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,
+                        "temperature": temperature,
+                        "tools": tools,
+                        "top_logprobs": top_logprobs,
+                        "top_p": top_p,
+                        "user": user,
+                        "repetition_penalty": repetition_penalty,
+                        "n": n,
+                        "parallel_tool_calls": parallel_tool_calls,
+                        "service_tier": service_tier,
+                        "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=ChatCompletion,
+                )
+            except (ArkAPITimeoutError, ArkAPIConnectionError):
+                waitTime = _calculate_retry_timeout(retryTimes)
+                if datetime.now() + timedelta(seconds=waitTime) > last_time:
+                    raise ArkAPITimeoutError()
+                await asyncio.sleep(waitTime)
+                retryTimes = retryTimes + 1
+                continue
+            except ArkAPIStatusError as err:
+                retry_after = _get_retry_after(err.response)
+                if retry_after is not None:
+                    model_breaker.reset(retry_after)
+                if _should_retry(err.response):
+                    continue
+                else:
+                    raise err
+            if is_encrypt:
+                resp = self._decrypt(e2e_key, e2e_nonce, resp)
+                if is_encrypt:
+                    resp = await self._decrypt(e2e_key, e2e_nonce, resp)
+            return resp
+
+    def _get_request_last_time(self, timeout):
+        if timeout is None:
+            timeout = self._client.timeout
+        timeoutSeconds = 0
+        if isinstance(timeout, httpx.Timeout):
+            timeoutSeconds = timeout.read
+        elif isinstance(timeout, float):
+            timeoutSeconds = timeout
+        elif isinstance(self._client.timeout, int):
+            timeoutSeconds = timeout
+        else:
+            raise TypeError("timeout type {} is not supported".format(type(self._client.timeout)))
+        return datetime.now() + timedelta(seconds=timeoutSeconds)
+
+
+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,
+        )