tencentcloud-sdk-python-common 3.0.1388__py2.py3-none-any.whl → 3.1.15__py2.py3-none-any.whl

tencentcloud/__init__.py

@@ -14,4 +14,4 @@
 # limitations under the License.
 
 
-__version__ = '3.0.1388'
+__version__ = '3.1.15'

tencentcloud/common/abstract_client.py

@@ -28,8 +28,10 @@ import logging.handlers
 
 try:
     from urllib.parse import urlencode
+    from urllib.parse import urlparse
 except ImportError:
     from urllib import urlencode
+    from urlparse import urlparse
 
 import tencentcloud
 from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
@@ -133,11 +135,11 @@ class AbstractClient(object):
         elif self.profile.signMethod == "TC3-HMAC-SHA256" or options.get("IsMultipart") is True:
             self._build_req_with_tc3_signature(action, params, req_inter, options)
         elif self.profile.signMethod in ("HmacSHA1", "HmacSHA256"):
-            self._build_req_with_old_signature(action, params, req_inter)
+            self._build_req_with_old_signature(action, params, req_inter, options)
         else:
             raise TencentCloudSDKException("ClientError", "Invalid signature method.")
 
-    def _build_req_with_old_signature(self, action, params, req):
+    def _build_req_with_old_signature(self, action, params, req, options):
         params = copy.deepcopy(self._fix_params(params))
         params['Action'] = action[0].upper() + action[1:]
         params['RequestClient'] = self.request_client
@@ -145,14 +147,16 @@ class AbstractClient(object):
         params['Timestamp'] = int(time.time())
         params['Version'] = self._apiVersion
 
+        cred_secret_id, cred_secret_key, cred_token = self.credential.get_credential_info()
+
         if self.region:
             params['Region'] = self.region
 
-        if self.credential.token:
-            params['Token'] = self.credential.token
+        if cred_token:
+            params['Token'] = cred_token
 
-        if self.credential.secret_id:
-            params['SecretId'] = self.credential.secret_id
+        if cred_secret_id:
+            params['SecretId'] = cred_secret_id
 
         if self.profile.signMethod:
             params['SignatureMethod'] = self.profile.signMethod
@@ -160,8 +164,8 @@ class AbstractClient(object):
         if self.profile.language:
             params['Language'] = self.profile.language
 
-        signInParam = self._format_sign_string(params)
-        params['Signature'] = Sign.sign(str(self.credential.secret_key),
+        signInParam = self._format_sign_string(params, options)
+        params['Signature'] = Sign.sign(str(cred_secret_key),
                                         str(signInParam),
                                         str(self.profile.signMethod))
 
@@ -185,8 +189,9 @@ class AbstractClient(object):
             raise SDKError("ClientError",
                            "Invalid request method GET for multipart.")
 
-        endpoint = self._get_endpoint()
+        endpoint = self._get_endpoint(options=options)
         timestamp = int(time.time())
+        cred_secret_id, cred_secret_key, cred_token = self.credential.get_credential_info()
         req.header["Host"] = endpoint
         req.header["X-TC-Action"] = action[0].upper() + action[1:]
         req.header["X-TC-RequestClient"] = self.request_client
@@ -196,8 +201,8 @@ class AbstractClient(object):
             req.header["X-TC-Content-SHA256"] = "UNSIGNED-PAYLOAD"
         if self.region:
             req.header['X-TC-Region'] = self.region
-        if self.credential.token:
-            req.header['X-TC-Token'] = self.credential.token
+        if cred_token:
+            req.header['X-TC-Token'] = cred_token
         if self.profile.language:
             req.header['X-TC-Language'] = self.profile.language
 
@@ -213,13 +218,13 @@ class AbstractClient(object):
 
         service = self._service
         date = datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d')
-        signature = self._get_tc3_signature(params, req, date, service, options)
+        signature = self._get_tc3_signature(params, req, date, service, cred_secret_key, options)
 
         auth = "TC3-HMAC-SHA256 Credential=%s/%s/%s/tc3_request, SignedHeaders=content-type;host, Signature=%s" % (
-            self.credential.secret_id, date, service, signature)
+            cred_secret_id, date, service, signature)
         req.header["Authorization"] = auth
 
-    def _get_tc3_signature(self, params, req, date, service, options=None):
+    def _get_tc3_signature(self, params, req, date, service, secret_key, options=None):
         options = options or {}
         canonical_uri = req.uri
         canonical_querystring = ""
@@ -256,8 +261,7 @@ class AbstractClient(object):
                                           req.header["X-TC-Timestamp"],
                                           credential_scope,
                                           digest)
-
-        return Sign.sign_tc3(self.credential.secret_key, date, service, string2sign)
+        return Sign.sign_tc3(secret_key, date, service, string2sign)
 
     def _build_req_without_signature(self, action, params, req, options=None):
         content_type = self._default_content_type
@@ -276,7 +280,7 @@ class AbstractClient(object):
             raise SDKError("ClientError",
                            "Invalid request method GET for multipart.")
 
-        endpoint = self._get_endpoint()
+        endpoint = self._get_endpoint(options=options)
         timestamp = int(time.time())
         req.header["Host"] = endpoint
         req.header["X-TC-Action"] = action[0].upper() + action[1:]
@@ -333,20 +337,23 @@ class AbstractClient(object):
             logger.debug("GetResponse: %s", ResponsePrettyFormatter(resp_inter))
             raise TencentCloudSDKException("ServerNetworkError", resp_inter.content)
 
-    def _format_sign_string(self, params):
+    def _format_sign_string(self, params, options=None):
         formatParam = {}
         for k in params:
             formatParam[k.replace('_', '.')] = params[k]
         strParam = '&'.join('%s=%s' % (k, formatParam[k]) for k in sorted(formatParam))
-        msg = '%s%s%s?%s' % (self.profile.httpProfile.reqMethod, self._get_endpoint(), self._requestPath, strParam)
+        msg = '%s%s%s?%s' % (
+            self.profile.httpProfile.reqMethod, self._get_endpoint(options=options), self._requestPath, strParam)
         return msg
 
     def _get_service_domain(self):
         rootDomain = self.profile.httpProfile.rootDomain
         return self._service + "." + rootDomain
 
-    def _get_endpoint(self):
+    def _get_endpoint(self, options=None):
         endpoint = self.profile.httpProfile.endpoint
+        if not endpoint and options:
+            endpoint = urlparse(options.get("Endpoint", "")).hostname
         if endpoint is None:
             endpoint = self._get_service_domain()
         return endpoint
@@ -420,7 +427,7 @@ class AbstractClient(object):
             headers["X-TC-TraceId"] = str(uuid.uuid4())
         if not self.profile.disable_region_breaker:
             return self._call_with_region_breaker(action, params, options, headers)
-        req = RequestInternal(self._get_endpoint(),
+        req = RequestInternal(self._get_endpoint(options=options),
                               self.profile.httpProfile.reqMethod,
                               self._requestPath,
                               header=headers)
@@ -444,7 +451,7 @@ class AbstractClient(object):
         return retryer.send_request(_call_once).content
 
     def _call_with_region_breaker(self, action, params, options=None, headers=None):
-        endpoint = self._get_endpoint()
+        endpoint = self._get_endpoint(options=options)
         generation, need_break = self.circuit_breaker.before_requests()
         if need_break:
             endpoint = self._service + "." + self.profile.region_breaker_profile.backup_endpoint
@@ -470,7 +477,7 @@ class AbstractClient(object):
         self._check_error(resp)
         return resp.content
 
-    def call_octet_stream(self, action, headers, body):
+    def call_octet_stream(self, action, headers, body, options=None):
         """Invoke API with application/ocet-stream content-type.
 
         Note:
@@ -490,12 +497,14 @@ class AbstractClient(object):
         if self.profile.httpProfile.reqMethod != "POST":
             raise SDKError("ClientError", "Invalid request method.")
 
-        req = RequestInternal(self._get_endpoint(),
+        if not options:
+            options = {}
+        req = RequestInternal(self._get_endpoint(options=options),
                               self.profile.httpProfile.reqMethod,
                               self._requestPath,
                               header=headers)
         req.data = body
-        options = {"IsOctetStream": True}
+        options["IsOctetStream"] = True
         self._build_req_inter(action, None, req, options)
 
         resp = self.request.send_request(req)
@@ -538,6 +547,7 @@ class AbstractClient(object):
         :param options: Request options, like {"SkipSign": False, "IsMultipart": False, "IsOctetStream": False, "BinaryParams": []}
         :type options: dict
         """
+
         def _call_once():
             resp = self._call(action, params, options, headers)
             self._check_status(resp)

tencentcloud/common/abstract_client_async.py

@@ -0,0 +1,654 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2017-2021 Tencent Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import copy
+import hashlib
+import json
+import logging
+import logging.handlers
+import random
+import sys
+import time
+import uuid
+import warnings
+from datetime import datetime
+from typing import Dict, Type, Union, List, Callable, Awaitable, Optional
+
+import httpx
+
+import tencentcloud
+from tencentcloud.common.abstract_client import logger, urlparse, urlencode
+from tencentcloud.common.abstract_model import AbstractModel
+from tencentcloud.common.circuit_breaker import CircuitBreaker
+from tencentcloud.common.credential import Credential
+from tencentcloud.common.exception import TencentCloudSDKException
+from tencentcloud.common.http.request_async import ApiRequest, ApiResponse, ResponsePrettyFormatter, \
+    RequestPrettyFormatter
+from tencentcloud.common.profile.client_profile import ClientProfile, RegionBreakerProfile
+from tencentcloud.common.retry_async import NoopRetryer
+from tencentcloud.common.sign import Sign
+
+warnings.filterwarnings("ignore", module="tencentcloud", category=UserWarning)
+
+_json_content = 'application/json'
+_multipart_content = 'multipart/form-data'
+_form_urlencoded_content = 'application/x-www-form-urlencoded'
+_octet_stream = "application/octet-stream"
+
+LOGGER_NAME = "tencentcloud_sdk_common"
+
+InterceptorType = Callable[["RequestChain"], Awaitable]
+ParamsType = Union[Dict, str, bytes]
+
+
+class RequestChain(object):
+    def __init__(self):
+        self.request: Optional[ApiRequest] = None
+
+        self._inters: List[InterceptorType] = []
+        self._idx = 0
+
+    async def proceed(self):
+        interceptor = self._inters[self._idx]
+        snapshot = self._new_snapshot()
+        snapshot._idx += 1
+        return await interceptor(snapshot)
+
+    def add_interceptor(self, inter: InterceptorType, idx=sys.maxsize):
+        self._inters.insert(idx, inter)
+        return self
+
+    def _new_snapshot(self) -> 'RequestChain':
+        new_chain = RequestChain()
+        new_chain.request = self.request
+        new_chain._inters = self._inters
+        new_chain._idx = self._idx
+        return new_chain
+
+
+class AbstractClient(object):
+    _requestPath = '/'
+    _params = {}
+    _apiVersion = ''
+    _endpoint = ''
+    _service = ''
+    _sdkVersion = 'SDK_PYTHON_%s' % tencentcloud.__version__
+    _default_content_type = _form_urlencoded_content
+    FMT = '%(asctime)s %(process)d %(filename)s L%(lineno)s %(levelname)s %(message)s'
+
+    def __init__(self, credential: Credential, region: str, profile: ClientProfile = None):
+        self.credential = credential
+        self.region = region
+        self.profile = profile or ClientProfile()
+        self.circuit_breaker = None
+
+        kwargs: Dict = {"timeout": self.profile.httpProfile.reqTimeout}
+
+        if not self.profile.httpProfile.keepAlive:
+            kwargs["limits"] = httpx.Limits(max_keepalive_connections=0)
+
+        if self.profile.httpProfile.proxy:
+            kwargs["proxies"] = self.profile.httpProfile.proxy
+
+        if self.profile.httpProfile.certification is False:
+            kwargs["verify"] = False
+        elif isinstance(self.profile.httpProfile.certification, str) and self.profile.httpProfile.certification != "":
+            kwargs["cert"] = self.profile.httpProfile.certification
+
+        self.http_client = httpx.AsyncClient(**kwargs)
+
+        if not self.profile.disable_region_breaker:
+            if self.profile.region_breaker_profile is None:
+                self.profile.region_breaker_profile = RegionBreakerProfile()
+            self.circuit_breaker = CircuitBreaker(self.profile.region_breaker_profile)
+        if self.profile.request_client:
+            self.request_client = self._sdkVersion + "; " + self.profile.request_client
+        else:
+            self.request_client = self._sdkVersion
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self):
+        await self.http_client.aclose()
+
+    async def call_and_deserialize(
+            self,
+            action: str,
+            params: ParamsType,
+            resp_cls: Type = dict,
+            headers: Dict[str, str] = None,
+            opts: Dict = None,
+    ):
+        opts = opts or {}
+        headers = headers or {}
+        chain = self._create_default_chain(action, params, resp_cls, headers, opts)
+        return await chain.proceed()
+
+    def _create_default_chain(
+            self,
+            action: str,
+            params: ParamsType,
+            resp_cls: Type,
+            headers: Dict[str, str],
+            opts: Dict,
+    ):
+        chain = RequestChain()
+        chain.add_interceptor(self._inter_retry)
+        chain.add_interceptor(self._inter_deserialize_resp(resp_cls))
+        if self.circuit_breaker:
+            chain.add_interceptor(self._inter_breaker(opts))
+        chain.add_interceptor(self._inter_build_request(action, params, headers, opts))
+        chain.add_interceptor(self._inter_send_request)
+        return chain
+
+    async def _inter_retry(self, chain: RequestChain):
+        retryer = self.profile.retryer or NoopRetryer()
+        return await retryer.send_request(chain.proceed)
+
+    def _inter_build_request(
+            self,
+            action: str,
+            params: ParamsType,
+            headers: Dict[str, str],
+            opts: Dict,
+    ):
+        async def inter(chain: RequestChain):
+            nonlocal action, params, opts, headers
+
+            if headers is None:
+                headers = {}
+
+            if not isinstance(headers, dict):
+                raise TencentCloudSDKException("ClientError", "headers must be a dict.")
+
+            if "x-tc-traceid" not in (k.lower() for k in headers.keys()):
+                headers["X-TC-TraceId"] = str(uuid.uuid4())
+
+            req = self._build_req(action, params, headers, opts)
+
+            if self.profile.httpProfile.apigw_endpoint:
+                req.host = self.profile.httpProfile.apigw_endpoint
+                req.headers["Host"] = req.host
+
+            # 低版本的 httpx 不会使用 Client.timeout, 需要 per request setup
+            req.extensions["timeout"] = self.http_client.timeout.as_dict()
+            chain.request = req
+
+            logger.debug("SendRequest:\n%s", RequestPrettyFormatter(req))
+
+            return await chain.proceed()
+
+        return inter
+
+    def _inter_breaker(self, opts: Dict):
+        async def inter(chain: RequestChain):
+            generation, need_break = self.circuit_breaker.before_requests()
+
+            endpoint = self._get_endpoint(opts=opts)
+            if need_break:
+                endpoint = self._service + "." + self.profile.region_breaker_profile.backup_endpoint
+
+            url = self.profile.httpProfile.scheme + endpoint + self._requestPath
+            chain.request.url = url
+
+            resp = None
+            try:
+                resp = await chain.proceed()
+                self.circuit_breaker.after_requests(generation, True)
+                return resp
+            except httpx.TransportError:
+                self.circuit_breaker.after_requests(generation, False)
+                raise
+            except TencentCloudSDKException as e:
+                success = resp and "RequestId" in (await resp.aread()) and e.code != "InternalError"
+                self.circuit_breaker.after_requests(generation, success)
+                raise
+
+        return inter
+
+    @staticmethod
+    def _inter_deserialize_resp(resp_cls: Type):
+        async def inter(chain: RequestChain):
+            resp = await chain.proceed()
+
+            await check_err(resp)
+
+            content_type = resp.headers["Content-Type"]
+            if content_type == "text/event-stream":
+                return deserialize_sse(resp)
+
+            return await deserialize_json(resp)
+
+        async def check_err(resp: ApiResponse):
+            if resp.status_code != 200:
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug("GetResponse: %s", await ResponsePrettyFormatter(resp, format_body=True).astr())
+                raise TencentCloudSDKException("ServerNetworkError", await resp.aread())
+
+            ct = resp.headers.get('Content-Type')
+            if ct not in ('text/plain', _json_content):
+                return
+
+            content = await resp.aread()
+            data = json.loads(content)
+            if "Error" in data["Response"]:
+                code = data["Response"]["Error"]["Code"]
+                message = data["Response"]["Error"]["Message"]
+                reqid = data["Response"]["RequestId"]
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug("GetResponse: %s", await ResponsePrettyFormatter(resp, format_body=True).astr())
+                raise TencentCloudSDKException(code, message, reqid)
+            if "DeprecatedWarning" in data["Response"]:
+                import warnings
+                warnings.filterwarnings("default")
+                warnings.warn("This action is deprecated, detail: %s" % data["Response"]["DeprecatedWarning"],
+                              DeprecationWarning)
+
+        async def deserialize_json(resp: ApiResponse):
+            try:
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug("GetResponse: %s", await ResponsePrettyFormatter(resp, format_body=True).astr())
+
+                content = await resp.aread()
+                if resp_cls == dict:
+                    return json.loads(content)
+
+                if issubclass(resp_cls, AbstractModel):
+                    resp_model = resp_cls()
+                    resp_model._deserialize(json.loads(content)["Response"])
+                    return resp_model
+
+                raise TencentCloudSDKException("ClientParamsError", "invalid resp_cls %s" % resp_cls)
+            finally:
+                await resp.aclose()
+
+        async def deserialize_sse(resp: ApiResponse):
+            logger.debug("GetResponse:\n%s", ResponsePrettyFormatter(resp, format_body=False))
+            e = {}
+
+            try:
+                async for line in resp.aiter_lines():
+                    line = line.strip()
+                    if not line:
+                        yield e
+                        e = {}
+                        continue
+
+                    logger.debug("GetResponse.Readline: %s", line)
+
+                    # comment
+                    if line[0] == ':':
+                        continue
+
+                    colon_idx = line.find(':')
+                    key = line[:colon_idx]
+                    val = line[colon_idx + 1:]
+                    # If value starts with a U+0020 SPACE character, remove it from value.
+                    if val and val[0] == " ":
+                        val = val[1:]
+                    if key == 'data':
+                        # The spec allows for multiple data fields per event, concatenated them with "\n".
+                        if 'data' not in e:
+                            e['data'] = val
+                        else:
+                            e['data'] += '\n' + val
+                    elif key in ('event', 'id'):
+                        e[key] = val
+                    elif key == 'retry':
+                        e[key] = int(val)
+            finally:
+                await resp.aclose()
+
+        return inter
+
+    async def _inter_send_request(self, chain: RequestChain):
+        return await self.http_client.send(chain.request, stream=True)
+
+    def _get_service_domain(self):
+        root_domain = self.profile.httpProfile.rootDomain
+        return self._service + "." + root_domain
+
+    def _get_endpoint(self, opts=None):
+        endpoint = self.profile.httpProfile.endpoint
+        if not endpoint and opts:
+            endpoint = urlparse(opts.get("Endpoint", "")).hostname
+        if endpoint is None:
+            endpoint = self._get_service_domain()
+        return endpoint
+
+    def _build_req(self, action: str, params: ParamsType, headers: Dict[str, str], opts: Dict) -> ApiRequest:
+        if opts.get('SkipSign'):
+            return self._build_req_without_signature(action, params, headers, opts)
+        elif self.profile.signMethod == "TC3-HMAC-SHA256" or opts.get("IsMultipart") is True:
+            return self._build_req_with_tc3_signature(action, params, headers, opts)
+        elif self.profile.signMethod in ("HmacSHA1", "HmacSHA256"):
+            return self._build_req_with_old_signature(action, params, headers, opts)
+        else:
+            raise TencentCloudSDKException("ClientError", "Invalid signature method.")
+
+    def _build_req_without_signature(
+            self, action: str, params: ParamsType, headers: Dict[str, str], opts: Dict) -> ApiRequest:
+        method = self.profile.httpProfile.reqMethod
+        endpoint = self._get_endpoint(opts=opts)
+        url = "%s://%s%s" % (self.profile.httpProfile.scheme, endpoint, self._requestPath)
+        query = {}
+        body = ""
+
+        content_type = self._default_content_type
+        if method == 'GET':
+            content_type = _form_urlencoded_content
+        elif method == 'POST':
+            content_type = _json_content
+        if opts.get("IsMultipart"):
+            content_type = _multipart_content
+        if opts.get("IsOctetStream"):
+            content_type = _octet_stream
+        headers["Content-Type"] = content_type
+
+        if method == "GET" and content_type == _multipart_content:
+            raise TencentCloudSDKException("ClientError", "Invalid request method GET for multipart.")
+
+        endpoint = self._get_endpoint(opts=opts)
+        timestamp = int(time.time())
+        headers["Host"] = endpoint
+        headers["X-TC-Action"] = action[0].upper() + action[1:]
+        headers["X-TC-RequestClient"] = self.request_client
+        headers["X-TC-Timestamp"] = str(timestamp)
+        headers["X-TC-Version"] = self._apiVersion
+        if self.profile.unsignedPayload is True:
+            headers["X-TC-Content-SHA256"] = "UNSIGNED-PAYLOAD"
+        if self.region:
+            headers['X-TC-Region'] = self.region
+        if self.profile.language:
+            headers['X-TC-Language'] = self.profile.language
+
+        if method == 'GET':
+            params = copy.deepcopy(self._fix_params(params))
+            url += "?" + urlencode(params)
+        elif content_type == _json_content:
+            body = json.dumps(params)
+        elif content_type == _multipart_content:
+            boundary = uuid.uuid4().hex
+            headers["Content-Type"] = content_type + "; boundary=" + boundary
+            body = self._get_multipart_body(params, boundary, opts)
+
+        headers["Authorization"] = "SKIP"
+        return ApiRequest(method, url, params=query, content=body, headers=headers)
+
+    def _build_req_with_tc3_signature(
+            self, action: str, params: ParamsType, headers: Dict[str, str], opts: Dict) -> ApiRequest:
+        method = self.profile.httpProfile.reqMethod
+        endpoint = self._get_endpoint(opts=opts)
+        host = headers.get("Host", endpoint)
+        url = "%s://%s%s" % (self.profile.httpProfile.scheme, endpoint, self._requestPath)
+        query = ""
+        body = ""
+
+        content_type = self._default_content_type
+        if method == 'GET':
+            content_type = _form_urlencoded_content
+        elif method == 'POST':
+            content_type = _json_content
+        if opts.get("IsMultipart"):
+            content_type = _multipart_content
+        elif opts.get("IsOctetStream"):
+            if method != "POST":
+                raise TencentCloudSDKException("ClientError", "Invalid request method.")
+            content_type = _octet_stream
+        headers["Content-Type"] = content_type
+
+        if method == "GET" and content_type == _multipart_content:
+            raise TencentCloudSDKException("ClientError", "Invalid request method GET for multipart.")
+
+        timestamp = int(time.time())
+        cred_secret_id, cred_secret_key, cred_token = self.credential.get_credential_info()
+        headers["Host"] = host
+        headers["X-TC-Action"] = action[0].upper() + action[1:]
+        headers["X-TC-RequestClient"] = self.request_client
+        headers["X-TC-Timestamp"] = str(timestamp)
+        headers["X-TC-Version"] = self._apiVersion
+        if self.profile.unsignedPayload is True:
+            headers["X-TC-Content-SHA256"] = "UNSIGNED-PAYLOAD"
+        if self.region:
+            headers['X-TC-Region'] = self.region
+        if cred_token:
+            headers['X-TC-Token'] = cred_token
+        if self.profile.language:
+            headers['X-TC-Language'] = self.profile.language
+
+        if method == 'GET':
+            query = urlencode(copy.deepcopy(self._fix_params(params)))
+        elif content_type == _json_content:
+            body = json.dumps(params)
+        elif content_type == _multipart_content:
+            boundary = uuid.uuid4().hex
+            headers["Content-Type"] = content_type + "; boundary=" + boundary
+            body = self._get_multipart_body(params, boundary, opts)
+        elif content_type == _octet_stream:
+            body = params
+
+        if isinstance(body, str):
+            body = body.encode("utf-8")
+
+        service = self._service
+        date = datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d')
+        signature = self._get_tc3_signature(
+            method, self._requestPath, query, body, headers, date, service, cred_secret_key, opts)
+
+        auth = "TC3-HMAC-SHA256 Credential=%s/%s/%s/tc3_request, SignedHeaders=content-type;host, Signature=%s" % (
+            cred_secret_id, date, service, signature)
+        headers["Authorization"] = auth
+        # httpx 0.22.0 版本会过滤掉空 value 的 params 如 "a=&b=2"
+        # 不能使用 params 参数, 需要用 url 绕过, 后续版本已经修复, 但是 py36 最高只能安装 0.22.0
+        url += "?" + query
+        return ApiRequest(method, url, content=body, headers=headers)
+
+    def _build_req_with_old_signature(
+            self, action: str, params: ParamsType, headers: Dict[str, str], opts: Dict) -> ApiRequest:
+
+        if opts.get("IsOctetStream"):
+            raise TencentCloudSDKException("ClientError", "Invalid signature method.")
+
+        method = self.profile.httpProfile.reqMethod
+        endpoint = self._get_endpoint(opts=opts)
+        url = "%s://%s%s" % (self.profile.httpProfile.scheme, endpoint, self._requestPath)
+        query = {}
+        body = ""
+
+        params = copy.deepcopy(self._fix_params(params))
+        params['Action'] = action[0].upper() + action[1:]
+        params['RequestClient'] = self.request_client
+        params['Nonce'] = random.randint(1, sys.maxsize)
+        params['Timestamp'] = int(time.time())
+        params['Version'] = self._apiVersion
+
+        cred_secret_id, cred_secret_key, cred_token = self.credential.get_credential_info()
+
+        if self.region:
+            params['Region'] = self.region
+
+        if cred_token:
+            params['Token'] = cred_token
+
+        if cred_secret_id:
+            params['SecretId'] = cred_secret_id
+
+        if self.profile.signMethod:
+            params['SignatureMethod'] = self.profile.signMethod
+
+        if self.profile.language:
+            params['Language'] = self.profile.language
+
+        signInParam = self._format_sign_string(params, opts)
+        params['Signature'] = Sign.sign(str(cred_secret_key),
+                                        str(signInParam),
+                                        str(self.profile.signMethod))
+        if method == "GET":
+            query = params
+        else:
+            body = urlencode(params)
+
+        headers["Content-Type"] = "application/x-www-form-urlencoded"
+        return ApiRequest(method, url, params=query, content=body, headers=headers)
+
+    def _format_sign_string(self, params, opts=None):
+        formatParam = {}
+        for k in params:
+            formatParam[k.replace('_', '.')] = params[k]
+        strParam = '&'.join('%s=%s' % (k, formatParam[k]) for k in sorted(formatParam))
+        msg = '%s%s%s?%s' % (
+            self.profile.httpProfile.reqMethod, self._get_endpoint(opts=opts), self._requestPath, strParam)
+        return msg
+
+    def _fix_params(self, params):
+        if not isinstance(params, (dict,)):
+            return params
+        return self._format_params(None, params)
+
+    def _format_params(self, prefix, params):
+        d = {}
+        if params is None:
+            return d
+
+        if not isinstance(params, (tuple, list, dict)):
+            d[prefix] = params
+            return d
+
+        if isinstance(params, (list, tuple)):
+            for idx, item in enumerate(params):
+                if prefix:
+                    key = "{0}.{1}".format(prefix, idx)
+                else:
+                    key = "{0}".format(idx)
+                d.update(self._format_params(key, item))
+            return d
+
+        if isinstance(params, dict):
+            for k, v in params.items():
+                if prefix:
+                    key = '{0}.{1}'.format(prefix, k)
+                else:
+                    key = '{0}'.format(k)
+                d.update(self._format_params(key, v))
+            return d
+
+        raise TencentCloudSDKException("ClientParamsError", "some params type error")
+
+    def _get_multipart_body(self, params, boundary, options=None):
+        if options is None:
+            options = {}
+        # boundary and params key will never contain unicode characters
+        boundary = boundary.encode()
+        binparas = options.get("BinaryParams", [])
+        body = b''
+        for k, v in params.items():
+            kbytes = k.encode()
+            body += b'--%s\r\n' % boundary
+            body += b'Content-Disposition: form-data; name="%s"' % kbytes
+            if k in binparas:
+                body += b'; filename="%s"\r\n' % kbytes
+            else:
+                body += b"\r\n"
+                if isinstance(v, list) or isinstance(v, dict):
+                    v = json.dumps(v)
+                    body += b'Content-Type: application/json\r\n'
+            if sys.version_info[0] == 3 and isinstance(v, type("")):
+                v = v.encode()
+            body += b'\r\n%s\r\n' % v
+        if body != b'':
+            body += b'--%s--\r\n' % boundary
+        return body
+
+    @staticmethod
+    def _get_tc3_signature(method: str, path: str, query: str, body: bytes, headers: Dict, date: str, service: str,
+                           secret_key: str, opts: Dict):
+        canonical_uri = path
+        canonical_querystring = query
+        payload = body
+
+        if headers.get("X-TC-Content-SHA256") == "UNSIGNED-PAYLOAD":
+            payload = b"UNSIGNED-PAYLOAD"
+
+        payload_hash = hashlib.sha256(payload).hexdigest()
+
+        canonical_headers = 'content-type:%s\nhost:%s\n' % (
+            headers["Content-Type"], headers["Host"])
+        signed_headers = 'content-type;host'
+        canonical_request = '%s\n%s\n%s\n%s\n%s\n%s' % (method,
+                                                        canonical_uri,
+                                                        canonical_querystring,
+                                                        canonical_headers,
+                                                        signed_headers,
+                                                        payload_hash)
+
+        algorithm = 'TC3-HMAC-SHA256'
+        credential_scope = date + '/' + service + '/tc3_request'
+        if sys.version_info[0] == 3:
+            canonical_request = canonical_request.encode("utf8")
+        digest = hashlib.sha256(canonical_request).hexdigest()
+        string2sign = '%s\n%s\n%s\n%s' % (algorithm,
+                                          headers["X-TC-Timestamp"],
+                                          credential_scope,
+                                          digest)
+        return Sign.sign_tc3(secret_key, date, service, string2sign)
+
+    def set_stream_logger(self, stream=None, level=logging.DEBUG, log_format=None):
+        """Add a stream handler
+
+        :param stream: e.g. ``sys.stdout`` ``sys.stdin`` ``sys.stderr``
+        :type stream: IO[str]
+        :param level: Logging level, e.g. ``logging.INFO``
+        :type level: int
+        :param log_format: Log message format
+        :type log_format: str
+        """
+        log = logging.getLogger(LOGGER_NAME)
+        log.setLevel(level)
+        sh = logging.StreamHandler(stream)
+        sh.setLevel(level)
+        if log_format is None:
+            log_format = self.FMT
+        formatter = logging.Formatter(log_format)
+        sh.setFormatter(formatter)
+        log.addHandler(sh)
+
+    def set_file_logger(self, file_path, level=logging.DEBUG, log_format=None):
+        """Add a file handler
+
+        :param file_path: path of log file
+        :type file_path: str
+        :param level: Logging level, e.g. ``logging.INFO``
+        :type level: int
+        :param log_format: Log message format
+        :type log_format: str
+        """
+        log = logging.getLogger(LOGGER_NAME)
+        log.setLevel(level)
+        mb = 1024 * 1024
+        fh = logging.handlers.RotatingFileHandler(file_path, maxBytes=512 * mb, backupCount=10)
+        fh.setLevel(level)
+        if log_format is None:
+            log_format = self.FMT
+        formatter = logging.Formatter(log_format)
+        fh.setFormatter(formatter)
+        log.addHandler(fh)
+
+    def set_default_logger(self):
+        """Set default log handler"""
+        pass

tencentcloud/common/common_client_async.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 1999-2017 Tencent Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from tencentcloud.common.abstract_client_async import AbstractClient
+from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
+
+
+class CommonClient(AbstractClient):
+    """General client for all products.
+
+     With CommonClient, you only need to install the tencentcloud-sdk-python-common package to access APIs of all products.
+     See GitHub examples for usage details: https://github.com/TencentCloud/tencentcloud-sdk-python/tree/master/examples/common_client
+
+    :param service: Product name
+    :type service: str
+    :param version: Version of API
+    :type version: str
+    :param credential: Request credential
+    :type credential: tencentcloud.common.credential.Credential or tencentcloud.common.credential.STSAssumeRoleCredential or None
+    :param region: Request region
+    :type region: str
+    :param profile: Request SDK profile
+    :type profile: tencentcloud.common.profile.client_profile.ClientProfile
+    """
+
+    def __init__(self, service, version, credential, region, profile=None):
+        if region is None or version is None or service is None:
+            raise TencentCloudSDKException("CommonClient Parameter Error, "
+                                           "credential region version service all required.")
+        self._apiVersion = version
+        self._service = service
+        super(CommonClient, self).__init__(credential, region, profile)

tencentcloud/common/credential.py

@@ -16,6 +16,7 @@
 import json
 import os
 import time
+import threading
 
 try:
     # py3
@@ -70,6 +71,9 @@ class Credential(object):
     @property
     def secretKey(self):
         return self.secret_key
+    
+    def get_credential_info(self):
+        return self.secret_id, self.secret_key, self.token
 
 
 class CVMRoleCredential(object):
@@ -91,6 +95,7 @@ class CVMRoleCredential(object):
         self._secret_key = None
         self._token = None
         self._expired_ts = 0
+        self._lock = threading.Lock()
 
     @property
     def secretId(self):
@@ -98,8 +103,9 @@ class CVMRoleCredential(object):
 
     @property
     def secret_id(self):
-        self.update_credential()
-        return self._secret_id
+        with self._lock:
+            self.update_credential()
+            return self._secret_id
 
     @property
     def secretKey(self):
@@ -107,13 +113,15 @@ class CVMRoleCredential(object):
 
     @property
     def secret_key(self):
-        self.update_credential()
-        return self._secret_key
+        with self._lock:
+            self.update_credential()
+            return self._secret_key
 
     @property
     def token(self):
-        self.update_credential()
-        return self._token
+        with self._lock:
+            self.update_credential()
+            return self._token
 
     def get_role_name(self):
         if self.role:
@@ -159,6 +167,11 @@ class CVMRoleCredential(object):
             return None
         return self
 
+    def get_credential_info(self):
+        with self._lock:
+            self.update_credential()
+            return self._secret_id, self._secret_key, self._token
+
 
 class STSAssumeRoleCredential(object):
     """Tencent Cloud Credential via STS service
@@ -200,31 +213,42 @@ class STSAssumeRoleCredential(object):
         self._tmp_credential = None
         if endpoint:
             self._endpoint = endpoint
+        self._lock = threading.Lock()
 
     @property
     def secretId(self):
-        self._need_refresh()
-        return self._tmp_secret_id
+        with self._lock:
+            self._need_refresh()
+            return self._tmp_secret_id
 
     @property
     def secretKey(self):
-        self._need_refresh()
-        return self._tmp_secret_key
+        with self._lock:
+            self._need_refresh()
+            return self._tmp_secret_key
 
     @property
     def secret_id(self):
-        self._need_refresh()
-        return self._tmp_secret_id
+        with self._lock:
+            self._need_refresh()
+            return self._tmp_secret_id
 
     @property
     def secret_key(self):
-        self._need_refresh()
-        return self._tmp_secret_key
+        with self._lock:
+            self._need_refresh()
+            return self._tmp_secret_key
 
     @property
     def token(self):
-        self._need_refresh()
-        return self._token
+        with self._lock:
+            self._need_refresh()
+            return self._token
+    
+    def get_credential_info(self):
+        with self._lock:
+            self._need_refresh()
+            return self._tmp_secret_id, self._tmp_secret_key, self._token
 
     def _need_refresh(self):
         if None in [self._token, self._tmp_secret_key, self._tmp_secret_id] or self._expired_time < int(time.time()):
@@ -283,9 +307,8 @@ class ProfileCredential(object):
     """
 
     def get_credential(self):
-        home_path = os.environ.get('HOME') or os.environ.get('HOMEPATH')
-        if os.path.exists(home_path + "/.tencentcloud/credentials"):
-            file_path = home_path + "/.tencentcloud/credentials"
+        if os.path.exists(os.path.expanduser("~/.tencentcloud/credentials")):
+            file_path = os.path.expanduser("~/.tencentcloud/credentials")
         elif os.path.exists("/etc/tencentcloud/credentials"):
             file_path = "/etc/tencentcloud/credentials"
         else:
@@ -389,45 +412,67 @@ class OIDCRoleArnCredential(object):
     _service = "sts"
     _action = 'AssumeRoleWithWebIdentity'
     _default_session_name = 'tencentcloud-python-sdk-'
+    _endpoint = "sts.tencentcloudapi.com"
 
-    def __init__(self, region, provider_id, web_identity_token, role_arn, role_session_name, duration_seconds=7200):
+    def __init__(self, region, provider_id, web_identity_token, role_arn, role_session_name, duration_seconds=7200, endpoint=None):
         self._region = region
         self._provider_id = provider_id
         self._web_identity_token = web_identity_token
         self._role_arn = role_arn
         self._role_session_name = role_session_name
         self._duration_seconds = duration_seconds
+        if endpoint:
+            self._endpoint = endpoint
 
         self._token = None
         self._tmp_secret_id = None
         self._tmp_secret_key = None
         self._expired_time = 0
         self._is_tke = False
+        self._lock = threading.Lock()
 
     @property
     def secretId(self):
-        self._keep_fresh()
-        return self._tmp_secret_id
+        with self._lock:
+            self._keep_fresh()
+            return self._tmp_secret_id
 
     @property
     def secretKey(self):
-        self._keep_fresh()
-        return self._tmp_secret_key
+        with self._lock:
+            self._keep_fresh()
+            return self._tmp_secret_key
 
     @property
     def secret_id(self):
-        self._keep_fresh()
-        return self._tmp_secret_id
+        with self._lock:
+            self._keep_fresh()
+            return self._tmp_secret_id
 
     @property
     def secret_key(self):
-        self._keep_fresh()
-        return self._tmp_secret_key
+        with self._lock:
+            self._keep_fresh()
+            return self._tmp_secret_key
 
     @property
     def token(self):
-        self._keep_fresh()
-        return self._token
+        with self._lock:
+            self._keep_fresh()
+            return self._token
+        
+    def get_credential_info(self):
+        with self._lock:
+            self._keep_fresh()
+            return self._tmp_secret_id, self._tmp_secret_key, self._token
+
+    @property
+    def endpoint(self):
+        return self._endpoint
+    
+    @endpoint.setter
+    def endpoint(self, endpoint):
+        self._endpoint = endpoint
 
     def _keep_fresh(self):
         if None in [self._token, self._tmp_secret_key, self._tmp_secret_id] or self._expired_time < int(time.time()):
@@ -436,7 +481,14 @@ class OIDCRoleArnCredential(object):
     def refresh(self):
         if self._is_tke:
             self._init_from_tke()
-        common_client = CommonClient(credential=None, region=self._region, version=self._version, service=self._service)
+            
+        http_profile = HttpProfile()
+        http_profile.endpoint = self._endpoint
+        client_profile = ClientProfile()
+        client_profile.httpProfile = http_profile
+        
+        common_client = CommonClient(credential=None, region=self._region, version=self._version, 
+                                     service=self._service, profile=client_profile)
         params = {
             "ProviderId": self._provider_id,
             "WebIdentityToken": self._web_identity_token,

tencentcloud/common/http/request_async.py

@@ -0,0 +1,62 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+import httpx
+
+__all__ = ["ApiRequest", "ApiResponse", "RequestPrettyFormatter", "ResponsePrettyFormatter"]
+
+ApiRequest = httpx.Request
+ApiResponse = httpx.Response
+
+
+class RequestPrettyFormatter(object):
+    def __init__(self, req: ApiRequest, format_body=True, delimiter="\n"):
+        self._req = req
+        self._format_body = format_body
+        self._delimiter = delimiter
+
+    def __str__(self):
+        lines = ["%s %s" % (self._req.method, self._req.url)]
+        for k, v in self._req.headers.items():
+            lines.append("%s: %s" % (k, v))
+        lines.append("")
+        if self._format_body:
+            try:
+                lines.append(self._req.content.decode("utf-8"))
+            except UnicodeDecodeError:
+                # binary body
+                import base64
+                lines.append("base64_body:" + base64.standard_b64encode(self._req.content).decode())
+        return self._delimiter.join(lines)
+
+
+class ResponsePrettyFormatter(object):
+    def __init__(self, resp: ApiResponse, format_body=True, delimiter="\n"):
+        self._resp = resp
+        self._format_body = format_body
+        self._delimiter = delimiter
+
+    def __str__(self):
+        lines = ['%s %d %s' % (self.str_ver(self._resp.http_version), self._resp.status_code, self._resp.reason_phrase)]
+        for k, v in self._resp.headers.items():
+            lines.append('%s: %s' % (k, v))
+        return self._delimiter.join(lines)
+
+    async def astr(self):
+        lines = ['%s %d %s' % (self.str_ver(self._resp.http_version), self._resp.status_code, self._resp.reason_phrase)]
+        for k, v in self._resp.headers.items():
+            lines.append('%s: %s' % (k, v))
+        if self._format_body:
+            lines.append('')
+            lines.append((await self._resp.aread()).decode("utf-8"))
+        return self._delimiter.join(lines)
+
+    @staticmethod
+    def str_ver(ver):
+        if ver == 10:
+            return "HTTP/1.0"
+        elif ver == 11:
+            return "HTTP/1.1"
+        elif ver == 20:
+            return "HTTP/2.0"
+        else:
+            return str(ver)

tencentcloud/common/retry_async.py

@@ -0,0 +1,87 @@
+import asyncio
+import logging
+
+import httpx
+
+from tencentcloud.common.exception import TencentCloudSDKException
+
+
+class NoopRetryer(object):
+    """configuration without retry
+
+    NoopRetryer is a retry policy that does nothing.
+    It is useful when you don't want to retry.
+    """
+
+    async def send_request(self, fn):
+        return await fn()
+
+
+class StandardRetryer(object):
+    """Retry configuration
+
+    StandardRetryer is a retry policy that retries on network errors or frequency limitation.
+    :param max_attempts: Maximum number of attempts.
+    :type max_attempts: int
+    :param backoff_fn: A function that takes the number of attempts and returns the number of seconds to sleep before the next retry.
+       Default sleep time is 2^n seconds, n is the number of attempts.
+    :type backoff_fn: function
+    :param logger: A logger to log retry attempts. If not provided, no logging will be performed.
+    :type logger: logging.Logger
+    """
+
+    def __init__(self, max_attempts=3, backoff_fn=None, logger=None):
+        self._max_attempts = max_attempts
+        self._backoff_fn = backoff_fn or self.backoff
+        self._logger = logger
+
+    async def send_request(self, fn):
+        resp = None
+        err = None
+
+        for n in range(self._max_attempts):
+            try:
+                resp = await fn()
+            except TencentCloudSDKException as e:
+                err = e
+            except httpx.TransportError as e:
+                err = e
+
+            if not await self.should_retry(resp, err):
+                if err:
+                    raise err
+                return resp
+
+            sleep = await self._backoff_fn(n)
+            await self.on_retry(n, sleep, resp, err)
+            await asyncio.sleep(sleep)
+
+        raise err
+
+    @staticmethod
+    async def should_retry(resp, err):
+        if not err:
+            return False
+
+        if isinstance(err, httpx.TransportError):
+            return True
+
+        if not isinstance(err, TencentCloudSDKException):
+            return False
+
+        ec = err.get_code()
+        if ec in (
+                "ClientNetworkError", "ServerNetworkError", "RequestLimitExceeded",
+                "RequestLimitExceeded.UinLimitExceeded", "RequestLimitExceeded.GlobalRegionUinLimitExceeded"
+        ):
+            return True
+
+        return False
+
+    @staticmethod
+    async def backoff(n):
+        return 2 ** n
+
+    async def on_retry(self, n, sleep, resp, err):
+        if self._logger:
+            self._logger.debug("retry: n=%d sleep=%ss err=%s", n, sleep, err)

{tencentcloud_sdk_python_common-3.0.1388.dist-info → tencentcloud_sdk_python_common-3.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tencentcloud-sdk-python-common
-Version: 3.0.1388
+Version: 3.1.15
 Summary: Tencent Cloud Common SDK for Python
 Home-page: https://github.com/TencentCloud/tencentcloud-sdk-python
 Author: Tencent Cloud
@@ -15,7 +15,9 @@ Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
-Requires-Dist: requests (>=2.16.0)
+Requires-Dist: requests >=2.16.0
+Provides-Extra: async
+Requires-Dist: httpx >=0.22.0 ; extra == 'async'
 
 ============================
 Tencent Cloud SDK for Python
@@ -44,5 +46,3 @@ or download source code from github and install:
     $ cd tencentcloud-sdk-python
     $ python package.py --components common common
 
-
-

{tencentcloud_sdk_python_common-3.0.1388.dist-info → tencentcloud_sdk_python_common-3.1.15.dist-info}/RECORD

@@ -1,21 +1,25 @@
-tencentcloud/__init__.py,sha256=P_6PiW8DYNHHHgqiC-uyC2CmatjXuaUnBhcwC2nkIBg,631
+tencentcloud/__init__.py,sha256=JuMsQkc9Aytx9jig2NEn0vw6wd4IjT_uL9_Se91Cm4Y,629
 tencentcloud/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tencentcloud/common/abstract_client.py,sha256=W-kuyBPX23VbUV3sNpqhVMEivSg_Un7IRI_yk9IFCpQ,25100
+tencentcloud/common/abstract_client.py,sha256=hqnD1TruJPHxITCOgFrfZUovb27UWYbt71S-qJB3Bzw,25608
+tencentcloud/common/abstract_client_async.py,sha256=mf9wiOwyB8lV1X1fqbJw_HjMfMUc92rRr5gePsThLkY,25945
 tencentcloud/common/abstract_model.py,sha256=LJ9BkK1Djh_gdx3Cy3trEOtJRGtrM-ikeqRzO1PgwiY,2418
 tencentcloud/common/circuit_breaker.py,sha256=p_6ssklMRtR-YKNGcFLd3ClUvZPs8ZLnVkhjcOZA0DY,4301
 tencentcloud/common/common_client.py,sha256=1Dr96VCEoJgDPmnurI46ko_cSROtRQbcHef_qeOKZco,2043
-tencentcloud/common/credential.py,sha256=nKOvRoHS5w2tNDyZN626iXU-H6CCEbXkGJtfcNFRqE0,16602
+tencentcloud/common/common_client_async.py,sha256=UHVB6ziHrbYceoCzFOTynP5jOC3TQa6xApOJ5w4F-C0,2027
+tencentcloud/common/credential.py,sha256=hTZ0ROxdCkd4rCF0dplMg6lMrb3HK0euMNrhGD3WjiA,18254
 tencentcloud/common/retry.py,sha256=4h6lG2KEVezhnfZt1BvSkftNupuu98g-n1g1EKu62IE,2323
+tencentcloud/common/retry_async.py,sha256=9276QKafeQwnEv3PaBJ81U1YK2Kt9CPyNhkBlavVVQU,2554
 tencentcloud/common/sign.py,sha256=Mm51G6huhhT91yayB-KKWCQFIuy59dFzdSwolNfSuwM,1568
 tencentcloud/common/exception/__init__.py,sha256=xK4vqaAlCWY5pGTDaz21vzIO6izEBESCNDeBNvojqYo,735
 tencentcloud/common/exception/tencent_cloud_sdk_exception.py,sha256=aFTVjvZC-mp74oEjELqI3BFrfgXi1yLKppNd5XzvqFY,760
 tencentcloud/common/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tencentcloud/common/http/pre_conn.py,sha256=aeEqmTc2JKO8Wd6r_SwLofCyrfPv-A0hQV00SZAgpU0,2488
 tencentcloud/common/http/request.py,sha256=Qgo3BI4cbbEv1Y2EvlB8KQSh1brvPKRypSdfnY_Yay0,5642
+tencentcloud/common/http/request_async.py,sha256=4AOLDdeVgYi10hrjlzOknx3ash-K_RZqToyRlorMvok,2131
 tencentcloud/common/profile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tencentcloud/common/profile/client_profile.py,sha256=gvqlN4orPjQKA7kfZw0GMLuwXkKnSMgLo2S-6Mq3qh0,5221
 tencentcloud/common/profile/http_profile.py,sha256=4or_nmNoy-Yd9MWpxxPhvbaeaAjx3ZYTNgTl6nt6ETU,2256
-tencentcloud_sdk_python_common-3.0.1388.dist-info/METADATA,sha256=UA9VfQRN5nmA_smnX-4BweUfxGIWjW-6YlqpXFCRRtw,1487
-tencentcloud_sdk_python_common-3.0.1388.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
-tencentcloud_sdk_python_common-3.0.1388.dist-info/top_level.txt,sha256=g-8OyzoqI6O6LiS85zkeNzhB-osEnRIPZMdyRd_0eL0,13
-tencentcloud_sdk_python_common-3.0.1388.dist-info/RECORD,,
+tencentcloud_sdk_python_common-3.1.15.dist-info/METADATA,sha256=Y6ZyZDlnrSx4j6hl90cCM8LKwwPR8jiVYrYNogmFNPM,1552
+tencentcloud_sdk_python_common-3.1.15.dist-info/WHEEL,sha256=Ll72iyqtt6Rbxp-Q7FSafYA1LeRv98X15xcZWRsFEmY,109
+tencentcloud_sdk_python_common-3.1.15.dist-info/top_level.txt,sha256=g-8OyzoqI6O6LiS85zkeNzhB-osEnRIPZMdyRd_0eL0,13
+tencentcloud_sdk_python_common-3.1.15.dist-info/RECORD,,

{tencentcloud_sdk_python_common-3.0.1388.dist-info → tencentcloud_sdk_python_common-3.1.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any