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

{byteplus-python-sdk-v2-1.0.9/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: 1.0.9
+Version: 2.0.2
 Summary: Byteplus SDK for Python
 License: Apache License 2.0
 Platform: any

byteplus-python-sdk-v2-2.0.2/README.md

@@ -0,0 +1,59 @@
+# byteplus SDK for Python
+
+## 非兼容升级通知
+
+Byteplus SDK for Python 非兼容升级通知
+
+影响版本：`2.0.1` 以及后续版本
+
+变更描述:
+
+从 `2.0.1` 版本开始，发起请求将默认从使用 `HTTP` 协议变成使用 `HTTPS` 协议，请升级到新版本的用户注意是否会产生兼容性风险，做好充分测试。如需继续使用
+`HTTP` 协议，请在发起请求时指定 `scheme` 参数为 `http`(不推荐):
+
+```python
+import byteplussdkcore
+
+configuration = byteplussdkcore.Configuration()
+configuration.scheme = 'http'
+```
+
+## Table of Contents
+
+* Requirements
+* Install
+* Usage
+
+### Requirements ###
+
+Python version >=2.7。
+
+### Install ###
+
+Install via pip
+
+```sh
+pip install byteplus-python-sdk-v2
+```
+
+Install via [Setuptools](http://pypi.python.org/pypi/setuptools).
+
+```sh
+python setup.py install --user
+```
+
+(or `sudo python setup.py install` to install the package for all users)
+
+### Usage ###
+
+1：config Configuration
+
+```python
+configuration = byteplussdkcore.Configuration()
+configuration.client_side_validation = True
+configuration.schema = "http"
+configuration.debug = False
+configuration.logger_file = "sdk.log"
+
+byteplussdkcore.Configuration.set_default(configuration)
+```

{byteplus-python-sdk-v2-1.0.9 → 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: 1.0.9
+Version: 2.0.2
 Summary: Byteplus SDK for Python
 License: Apache License 2.0
 Platform: any

{byteplus-python-sdk-v2-1.0.9 → 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-1.0.9 → 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-1.0.9 → 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-1.0.9 → 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-1.0.9 → 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)