feat auto update sdk

Author: liyan.90210

Changelog

@@ -1,5 +1,8 @@
 ### Change log
 
+2026-03-12 Bumped to version v1.0.217
+- Updated apis for tls/visual
+
 2026-02-05 Bumped to version v1.0.216
 - Updated apis for content_security
 

volcengine/__init__.py

@@ -1,2 +1,2 @@
 # coding:utf-8
-VERSION='v1.0.216'
+VERSION='v1.0.217'

volcengine/example/visual/example_cv_cancel_task.py

@@ -0,0 +1,18 @@
+# coding:utf-8
+from __future__ import print_function
+
+from volcengine.visual.VisualService import VisualService
+
+if __name__ == '__main__':
+    visual_service = VisualService()
+
+    # call below method if you don't set ak and sk in $HOME/.volc/config
+    visual_service.set_ak('Ak')
+    visual_service.set_sk('Sk')
+
+    form = {
+        "req_key": "xxx",
+        "task_id": "123456"
+    }
+    resp = visual_service.cv_cancel_task(form)
+    print(resp)

volcengine/tls/TLSService.py

@@ -4,8 +4,6 @@
 from __future__ import print_function
 
 import hashlib
-import threading
-import random
 import time
 
 from volcengine.ApiInfo import ApiInfo
@@ -19,6 +17,7 @@
 from volcengine.tls.tls_responses import DescribeETLTaskResponse, ModifyAlarmContentTemplateResponse
 from volcengine.tls.tls_responses import ModifyTraceInstanceResponse
 from volcengine.tls.tls_exception import TLSException
+from volcengine.tls.retry_policy import RetryPolicy
 from volcengine.tls.const import DELETE_TRACE_INSTANCE, DESCRIBE_TRACE_INSTANCE, DESCRIBE_TRACE, SEARCH_TRACES, \
     CREATE_ALARM_CONTENT_TEMPLATE, CREATE_ALARM_WEBHOOK_INTEGRATION, DELETE_ALARM_WEBHOOK_INTEGRATION
 from volcengine.tls.util import get_logger
@@ -161,38 +160,6 @@
 
 
 class TLSService(Service):
-    _instance_lock = threading.Lock()
-    _default_retry_interval_ms = 100
-    _default_retry_counter = 0
-    _default_retry_counter_maximum = 50
-
-    @staticmethod
-    def set_default_retry_counter_maximum(v):
-        TLSService._default_retry_counter_maximum = v
-
-    @staticmethod
-    def increase_retry_counter_by_one():
-        with TLSService._instance_lock:
-            if TLSService._default_retry_counter < TLSService._default_retry_counter_maximum:
-                TLSService._default_retry_counter += 1
-
-    @staticmethod
-    def decrease_retry_counter_by_one():
-        with TLSService._instance_lock:
-            if TLSService._default_retry_counter < TLSService._default_retry_counter_maximum:
-                TLSService._default_retry_counter -= 1
-
-    @staticmethod
-    def calc_backoff_ms(expected_quit_timestamp_ms):
-        current_timestamp_ms = int(time.time() * 1000)
-        counter = TLSService._default_retry_counter
-        sleep_ms = random.random() * counter * TLSService._default_retry_interval_ms
-        if current_timestamp_ms + sleep_ms > expected_quit_timestamp_ms:
-            sleep_ms = expected_quit_timestamp_ms - current_timestamp_ms
-        if sleep_ms < 0:
-            sleep_ms = 0
-        return sleep_ms
-
     def __init__(self, endpoint: str, access_key_id: str, access_key_secret: str, region: str,
                  security_token: str = None, scheme: str = "https", timeout: int = 60,
                  api_version=API_VERSION_V_0_3_0):
@@ -204,6 +171,7 @@ def __init__(self, endpoint: str, access_key_id: str, access_key_secret: str, re
         self.__scheme = scheme
         self.__timeout = timeout
         self.__api_version = api_version
+        self.__retry_policy = None
 
         self.check_scheme_and_endpoint()
 
@@ -278,8 +246,10 @@ def __request(self, api: str, params: dict = None, body: dict = None, request_he
         method = self.api_info[api].method
         url = request.build()
 
-        expected_quit_timestamp = int(time.time() * 1000 + self.__timeout * 1500)
+        policy = self.get_retry_policy()
+        deadline = time.monotonic() + policy.total_timeout
         try_count = 0
+        retry_index = 0
         while True:
             try_count += 1
             try:
@@ -288,27 +258,25 @@ def __request(self, api: str, params: dict = None, body: dict = None, request_he
                 response = self.session.request(method, url, headers=request.headers, data=request.body,
                                                 timeout=self.__timeout)
             except Exception as e:
-                TLSService.increase_retry_counter_by_one()
-                sleep_ms = TLSService.calc_backoff_ms(expected_quit_timestamp)
-                if try_count < 5 and sleep_ms > 0:
-                    # HTTP请求未响应, 尝试重试
-                    time.sleep(sleep_ms / 1000)
-                else:
-                    # 已超出重试上限, 退出
+                if self.__can_retry(try_count, policy) is False or self.__should_retry_exception(e) is False:
                     raise TLSException(error_code=e.__class__.__name__, error_message=e.__str__())
+                sleep_seconds = self.__calc_backoff_seconds(policy, retry_index + 1, deadline)
+                if sleep_seconds <= 0:
+                    raise TLSException(error_code="RequestTimeout",
+                                       error_message="Request exceeded retry total timeout")
+                time.sleep(sleep_seconds)
+                retry_index += 1
             else:
                 if response.status_code == 200:
                     # self.__logger.info("TLS client successfully got the response for requesting {}".format(api))
-                    TLSService.decrease_retry_counter_by_one()
                     return response
-                elif try_count < 5 and response.status_code in [429, 500, 502, 503]:
-                    TLSService.increase_retry_counter_by_one()
-                    sleep_ms = TLSService.calc_backoff_ms(expected_quit_timestamp)
-                    if sleep_ms > 0:
-                        # HTTP请求未响应, 尝试重试
-                        time.sleep(sleep_ms / 1000)
-                    else:
-                        raise TLSException(response)
+                elif response.status_code in [429, 500, 502, 503] and self.__can_retry(try_count, policy):
+                    sleep_seconds = self.__calc_backoff_seconds(policy, retry_index + 1, deadline)
+                    if sleep_seconds > 0:
+                        time.sleep(sleep_seconds)
+                        retry_index += 1
+                        continue
+                    raise TLSException(response)
                 else:
                     raise TLSException(response)
 
@@ -322,6 +290,40 @@ def set_timeout(self, timeout: int):
         self.__timeout = timeout
         self.service_info = self.get_service_info()
 
+    def set_retry_policy(self, policy):
+        if policy is None:
+            self.__retry_policy = None
+            return
+        self.__retry_policy = policy.normalize()
+
+    def get_retry_policy(self):
+        if self.__retry_policy is None:
+            return RetryPolicy.default_policy()
+        return self.__retry_policy.normalize()
+
+    def __can_retry(self, attempts, policy):
+        if policy.max_attempts <= 0:
+            return True
+        return attempts < policy.max_attempts
+
+    def __calc_backoff_seconds(self, policy, retry_index, deadline):
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return 0
+        sleep_seconds = policy.backoff_seconds(retry_index)
+        if sleep_seconds > remaining:
+            sleep_seconds = remaining
+        return sleep_seconds
+
+    def __should_retry_exception(self, e):
+        try:
+            from requests import exceptions as req_exc
+        except Exception:
+            return True
+
+        return isinstance(e, (req_exc.Timeout, req_exc.ConnectionError, req_exc.ChunkedEncodingError,
+                              req_exc.ContentDecodingError))
+
     def create_project(self, create_project_request: CreateProjectRequest) -> CreateProjectResponse:
         if create_project_request.check_validation() is False:
             raise TLSException(error_code="InvalidArgument", error_message="Invalid request, please check it")

volcengine/tls/const.py

@@ -216,6 +216,14 @@
 COLD_TTL = "ColdTtl"
 ARCHIVE_TTL = "ArchiveTtl"
 ENCRYPT_CONF = "EncryptConf"
+BIND_PROCESSOR = "BindProcessor"
+PROCESSOR_ID = "ProcessorID"
+PROCESSOR_NAME = "ProcessorName"
+METERING_MODE = "MeteringMode"
+TLS_VERSION = "TLSVersion"
+REGIONS = "Regions"
+FUZZY_SEARCH_KEY = "FuzzySearchKey"
+ORDER_BY_PROJECT = "OrderByProject"
 
 FULL_TEXT = "FullText"
 KEY_VALUE = "KeyValue"
@@ -449,6 +457,7 @@
 JSON_INFO = "JsonInfo"
 CSV_INFO = "CsvInfo"
 TRN = "trn"
+FROM_TLS = "from_tls"
 ENABLE_ENCRYPT_CONF = "enable"
 ENCRYPT_TYPE = "encrypt_type"
 REGION_ID = "region_id"

volcengine/tls/data.py

@@ -145,25 +145,30 @@ def get_tags(self):
 
 
 class EncryptUserCmkConf(TLSData):
-    def __init__(self, user_cmk_id: str, trn: str, region_id: str):
+    def __init__(self, user_cmk_id: str, trn: str, region_id: str, from_tls: bool = None):
         self.user_cmk_id = user_cmk_id
         self.trn = trn
         self.region_id = region_id
+        self.from_tls = from_tls
 
     @classmethod
     def set_attributes(cls, data):
         user_cmk_id = data.get(USER_CMK_ID)
         trn = data.get(TRN)
         region_id = data.get(REGION_ID)
+        from_tls = data.get(FROM_TLS)
 
-        return cls(user_cmk_id, trn, region_id)
+        return cls(user_cmk_id, trn, region_id, from_tls)
 
     def json(self):
-        return {
+        res = {
             USER_CMK_ID: self.user_cmk_id,
             TRN: self.trn,
             REGION_ID: self.region_id,
         }
+        if self.from_tls is not None:
+            res[FROM_TLS] = self.from_tls
+        return res
 
 
 class EncryptConf(TLSData):
@@ -176,7 +181,10 @@ def __init__(self, enable: bool = False, encrypt_type: str = "default", user_cmk
     def set_attributes(cls, data):
         enable = data.get(ENABLE_ENCRYPT_CONF)
         encrypt_type = data.get(ENCRYPT_TYPE)
-        user_cmk_info = data.get(USER_CMK_INFO)
+        user_cmk_info = None
+        user_cmk_info_data = data.get(USER_CMK_INFO)
+        if user_cmk_info_data is not None and isinstance(user_cmk_info_data, dict):
+            user_cmk_info = EncryptUserCmkConf.set_attributes(data=user_cmk_info_data)
 
         return cls(enable, encrypt_type, user_cmk_info)
 
@@ -188,13 +196,32 @@ def json(self):
         }
 
 
+class BindProcessor(TLSData):
+    def __init__(self, processor_id: str = None, processor_name: str = None):
+        self.processor_id = processor_id
+        self.processor_name = processor_name
+
+    @classmethod
+    def set_attributes(cls, data: dict):
+        processor_id = data.get(PROCESSOR_ID)
+        processor_name = data.get(PROCESSOR_NAME)
+        return cls(processor_id, processor_name)
+
+    def json(self):
+        return {
+            PROCESSOR_ID: self.processor_id,
+            PROCESSOR_NAME: self.processor_name,
+        }
+
+
 class TopicInfo(TLSData):
     def __init__(self, topic_name: str = None, topic_id: str = None, project_id: str = None, ttl: int = None,
                  create_time: str = None, modify_time: str = None, shard_count: int = None, description: str = None,
                  auto_split: bool = None, max_split_shard: int = None, enable_tracking: bool = None,
                  time_key: str = None, time_format: str = None, tags: List[TagInfo] = None, log_public_ip: bool = None,
                  enable_hot_ttl: bool = None, hot_ttl: int = None, cold_ttl: int = None, archive_ttl: int = None,
-                 encrypt_conf: EncryptConf = None):
+                 encrypt_conf: EncryptConf = None, bind_processor=None, metering_mode: str = None,
+                 project_name: str = None, region: str = None, tls_version: str = None):
         self.topic_name = topic_name
         self.topic_id = topic_id
         self.project_id = project_id
@@ -215,12 +242,25 @@ def __init__(self, topic_name: str = None, topic_id: str = None, project_id: str
         self.cold_ttl = cold_ttl
         self.archive_ttl = archive_ttl
         self.encrypt_conf = encrypt_conf
+        self.bind_processor = bind_processor
+        self.metering_mode = metering_mode
+        self.project_name = project_name
+        self.region = region
+        self.tls_version = tls_version
 
     @classmethod
     def set_attributes(cls, data: dict):
+        bind_processor = None
+        bind_processor_data = data.get(BIND_PROCESSOR)
+        if bind_processor_data is not None and isinstance(bind_processor_data, dict):
+            bind_processor = BindProcessor.set_attributes(data=bind_processor_data)
+        metering_mode = data.get(METERING_MODE)
         topic_name = data.get(TOPIC_NAME)
         topic_id = data.get(TOPIC_ID)
         project_id = data.get(PROJECT_ID)
+        project_name = data.get(PROJECT_NAME)
+        region = data.get(REGION)
+        tls_version = data.get(TLS_VERSION)
         ttl = data.get(TTL)
         create_time = data.get(CREATE_TIME)
         modify_time = data.get(MODIFY_TIME)
@@ -237,7 +277,10 @@ def set_attributes(cls, data: dict):
         hot_ttl = data.get(HOT_TTL)
         cold_ttl = data.get(COLD_TTL)
         archive_ttl = data.get(ARCHIVE_TTL)
-        encrypt_conf = data.get(ENCRYPT_CONF)
+        encrypt_conf = None
+        encrypt_conf_data = data.get(ENCRYPT_CONF)
+        if encrypt_conf_data is not None and isinstance(encrypt_conf_data, dict):
+            encrypt_conf = EncryptConf.set_attributes(data=encrypt_conf_data)
 
         tags = data.get(TAGS)
         if tags is not None:
@@ -248,7 +291,8 @@ def set_attributes(cls, data: dict):
 
         return cls(topic_name, topic_id, project_id, ttl, create_time, modify_time, shard_count, description,
                    auto_split, max_split_shard, enable_tracking, time_key, time_format, topic_tags, log_public_ip,
-                   enable_hot_ttl, hot_ttl, cold_ttl, archive_ttl, encrypt_conf)
+                   enable_hot_ttl, hot_ttl, cold_ttl, archive_ttl, encrypt_conf, bind_processor, metering_mode,
+                   project_name, region, tls_version)
 
     def get_create_time(self):
         """