byteplus-python-sdk-v2 3.0.60__py2.py3-none-any.whl → 3.0.62__py2.py3-none-any.whl

byteplussdkcore/auth/providers/sts_provider.py

@@ -5,7 +5,7 @@ from datetime import datetime
 
 import dateutil.parser
 
-from byteplussdkcore import UniversalApi, UniversalInfo, ApiClient, Configuration
+from byteplussdkcore import UniversalApi, UniversalInfo, ApiClient
 from .provider import Provider, CredentialValue
 
 
@@ -20,7 +20,8 @@ class AssumeRoleCredentials:
 
 class StsCredentialProvider(Provider):
     def __init__(self, ak, sk, role_name, account_id, duration_seconds=3600, scheme='https',
-                 host='sts.ap-southeast-1.byteplusapi.com', region='ap-southeast-1', timeout=30, expired_buffer_seconds=60, policy=None, max_retries=3, retry_interval=1):
+                 host='sts.ap-southeast-1.byteplusapi.com', region='ap-southeast-1', timeout=30, expired_buffer_seconds=60, policy=None, max_retries=3, retry_interval=1,
+                 proxy_url=None, ca_file=None, insecure_skip_verify=False):
         self.ak = ak
         self.sk = sk
         self.role_name = role_name
@@ -36,6 +37,13 @@ class StsCredentialProvider(Provider):
         self.scheme = scheme
         self.policy = policy
 
+        # Proxy / TLS customization for reaching the STS endpoint. All optional;
+        # empty by default so RESTClientObject keeps its normal behavior
+        # (including HTTP_PROXY / HTTPS_PROXY env-var fallback).
+        self.proxy_url = proxy_url or None
+        self.ca_file = ca_file or None
+        self.insecure_skip_verify = bool(insecure_skip_verify)
+
         self.expired_time = None
         if expired_buffer_seconds > 600:
             raise ValueError('expired_buffer_seconds must be less than or equal to 600')
@@ -69,18 +77,39 @@ class StsCredentialProvider(Provider):
         }
         if self.policy is not None:
             params['Policy'] = self.policy
-        configuration = type.__call__(Configuration)
+        # Bound clients retain the default STS transport settings from binding.
+        # Direct provider use still inherits the current default configuration.
+        from byteplussdkcore.auth.provider_binding import new_sts_configuration
+        configuration = new_sts_configuration(self)
+        # Break recursion: this AssumeRole call signs with the explicit ak/sk
+        # below, so it must NOT re-enter a credential provider (which could be
+        # this very provider via the inherited default configuration).
+        configuration.credential_provider = None
         configuration.ak = self.ak
         configuration.sk = self.sk
+        configuration.session_token = ""
         configuration.host = self.host
         configuration.region = self.region
         configuration.scheme = self.scheme
         configuration.read_timeout = self.timeout
 
+        # Provider max_retries controls total attempts independently of business retry.
+        configuration.auto_retry = True
         configuration.num_max_retries = max(self.max_retries - 1, 0)
         delay_ms = int(self.retry_interval * 1000)
         configuration.min_retry_delay_ms = delay_ms
         configuration.max_retry_delay_ms = delay_ms
+
+        # Proxy / TLS customization for reaching the STS endpoint. Only applied
+        # when the caller opted in; otherwise the configuration keeps its
+        # default proxy/TLS settings (including HTTP_PROXY / HTTPS_PROXY
+        # env-var fallback in RESTClientObject).
+        from byteplussdkcore.auth.sts_http_config import StsHttpConfig
+        StsHttpConfig(
+            self.proxy_url or getattr(self, '_proxy_fallback', None),
+            self.ca_file, self.insecure_skip_verify
+        ).apply_to_configuration(configuration)
+
         c = UniversalApi(ApiClient(configuration))
         info = UniversalInfo(method='GET', service='sts', version='2018-01-01', action='AssumeRole',
                              content_type='text/plain')

byteplussdkcore/auth/providers/sts_saml_provider.py

@@ -24,7 +24,8 @@ class StsSamlCredentialProvider(Provider):
     def __init__(self, role_name=None, account_id=None, provider_name=None, saml_resp=None,
                  duration_seconds=3600, scheme='https',
                  host='sts.ap-southeast-1.byteplusapi.com', region='ap-southeast-1', timeout=30, expired_buffer_seconds=60,
-                 policy=None, role_trn=None, saml_provider_trn=None, max_retries=3, retry_interval=1):
+                 policy=None, role_trn=None, saml_provider_trn=None, max_retries=3, retry_interval=1,
+                 proxy_url=None, ca_file=None, insecure_skip_verify=False):
         self.role_name = role_name
         self.account_id = account_id
         self.provider_name = provider_name
@@ -58,6 +59,13 @@ class StsSamlCredentialProvider(Provider):
         self.scheme = scheme
         self.policy = policy
 
+        # Proxy / TLS customization for reaching the STS endpoint. All optional;
+        # empty by default so RESTClientObject keeps its normal behavior
+        # (including HTTP_PROXY / HTTPS_PROXY env-var fallback).
+        self.proxy_url = proxy_url or None
+        self.ca_file = ca_file or None
+        self.insecure_skip_verify = bool(insecure_skip_verify)
+
         self.expired_time = None
         if expired_buffer_seconds > 600:
             raise ValueError('expired_buffer_seconds must be less than or equal to 600')
@@ -117,8 +125,17 @@ class StsSamlCredentialProvider(Provider):
         }
         if self.policy is not None:
             params['Policy'] = self.policy
-        from byteplussdkcore import ApiClient, Configuration
-        resp_result = ApiClient(Configuration())._sts_call(
+        from byteplussdkcore import ApiClient
+        from byteplussdkcore.auth.provider_binding import new_sts_configuration
+        from byteplussdkcore.auth.sts_http_config import StsHttpConfig
+        configuration = new_sts_configuration(self)
+        configuration.scheme = self.scheme
+        # Apply overrides before ApiClient constructs its REST transport.
+        StsHttpConfig(
+            self.proxy_url or getattr(self, '_proxy_fallback', None),
+            self.ca_file, self.insecure_skip_verify
+        ).apply_to_configuration(configuration)
+        resp_result = ApiClient(configuration)._sts_call(
             action='AssumeRoleWithSAML',
             version='2018-01-01',
             params=params,
@@ -129,6 +146,9 @@ class StsSamlCredentialProvider(Provider):
             max_retries=self.max_retries,
             retry_interval=self.retry_interval,
             provider_name=self.PROVIDER_NAME,
+            proxy_url=self.proxy_url or getattr(self, '_proxy_fallback', None),
+            ca_file=self.ca_file,
+            insecure_skip_verify=self.insecure_skip_verify,
         )
         if 'Credentials' not in resp_result:
             raise RuntimeError(

byteplussdkcore/auth/sts_http_config.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+"""Proxy / TLS customization shared by the STS credential providers.
+
+This mirrors the Go SDK's ``ProxyConfig`` (see ``byteplus/credentials/
+http_client.go``). It bundles the three public knobs used when reaching the
+STS endpoint and knows how to project them onto an SDK ``Configuration``:
+
+    proxy_url            -> configuration.proxy
+    ca_file              -> configuration.ssl_ca_cert
+    insecure_skip_verify -> configuration.verify_ssl (inverted)
+
+Unlike the Go SDK -- which builds a dedicated ``*http.Transport`` -- the
+Python SDK already routes every request (including STS federation calls)
+through ``RESTClientObject``, which reads these ``Configuration`` fields
+directly. So the only thing this helper needs to do is set the fields.
+
+An explicit provider ``proxy_url`` wins over its client-local fallback.
+When both are empty, the transport retains default configuration and
+``HTTP_PROXY`` / ``HTTPS_PROXY`` lookup; it does not implement ``NO_PROXY``.
+
+TLS priority also matches Go's ``tls.Config``: ``insecure_skip_verify``
+takes precedence over ``ca_file`` (when verification is skipped the custom
+CA is irrelevant).
+"""
+
+from __future__ import absolute_import
+
+import base64
+
+import six
+from six.moves.urllib.parse import unquote, urlparse
+
+
+class StsHttpConfig(object):
+    """Carries proxy / TLS options for a single STS request path.
+
+    :param proxy_url: Forward proxy address, ``scheme://[user:password@]host:port``.
+                      Empty preserves default configuration and environment lookup.
+    :param ca_file: Path to a custom CA bundle (PEM) used to verify the STS
+                    server certificate. Restores verification unless skipped.
+                    Empty inherits ssl_ca_cert, otherwise REST uses certifi.
+    :param insecure_skip_verify: When True, skip TLS certificate/hostname
+                    verification. For debugging only; never use in production.
+    """
+
+    def __init__(self, proxy_url=None, ca_file=None, insecure_skip_verify=False):
+        self.proxy_url = proxy_url or None
+        self.ca_file = ca_file or None
+        self.insecure_skip_verify = bool(insecure_skip_verify)
+
+    def is_empty(self):
+        """True when no proxy/TLS option is configured.
+
+        Callers use this to leave the underlying ``Configuration`` untouched,
+        so existing behavior (including BYTEPLUS env-var proxies) is
+        preserved when the user did not opt in. Mirrors Go's ``IsZero``.
+        """
+        return (not self.proxy_url) and (not self.ca_file) and (not self.insecure_skip_verify)
+
+    def apply_to_configuration(self, configuration):
+        """Project the configured options onto ``configuration`` in place.
+
+        No-op when :meth:`is_empty` is True.
+        """
+        if self.is_empty():
+            return configuration
+
+        if self.proxy_url:
+            # Highest-priority proxy source; RESTClientObject honors this over
+            # http_proxy / https_proxy / env vars.
+            configuration.proxy = self.proxy_url
+
+        # TLS: insecure_skip_verify wins over ca_file (same as Go's tls.Config,
+        # where RootCAs is ignored once InsecureSkipVerify is set).
+        if self.insecure_skip_verify:
+            configuration.verify_ssl = False
+            configuration.ssl_ca_cert = None
+        elif self.ca_file:
+            configuration.verify_ssl = True
+            configuration.ssl_ca_cert = self.ca_file
+
+        return configuration
+
+    def proxy_authorization_header(self):
+        """Return the ``Proxy-Authorization`` header value, or None.
+
+        Delegates to :func:`build_proxy_authorization_header` using this
+        config's ``proxy_url``.
+        """
+        return build_proxy_authorization_header(self.proxy_url)
+
+
+def build_proxy_authorization_header(proxy_url):
+    """Build a ``Basic`` ``Proxy-Authorization`` value from an embedded userinfo.
+
+    urllib3 (v2) does NOT automatically forward the ``user:password@`` embedded
+    in a proxy URL as a ``Proxy-Authorization`` header, whereas Go's
+    ``http.ProxyURL`` / ``http.ProxyFromEnvironment`` do. To keep behavior
+    aligned with the Go SDK, callers extract this header explicitly and pass it
+    to ``ProxyManager(proxy_headers=...)``.
+
+    Returns None when ``proxy_url`` is empty or carries no userinfo. Raises
+    ``ValueError`` when ``proxy_url`` cannot be parsed.
+    """
+    if not proxy_url:
+        return None
+
+    try:
+        parsed = urlparse(proxy_url)
+    except (ValueError, AttributeError) as e:
+        raise ValueError("invalid proxy url {0!r}: {1}".format(proxy_url, e))
+
+    username = parsed.username
+    if username is None:
+        return None
+    password = parsed.password or ""
+
+    # Go's http.Transport derives proxy Basic auth from url.Userinfo, whose
+    # Username()/Password() return the PERCENT-DECODED values. urlparse keeps
+    # userinfo raw, so decode here to stay byte-for-byte identical with the Go
+    # SDK (e.g. a "p%40ss" password must be sent as "p@ss").
+    # Python 2 unquote accepts UTF-8 bytes; Python 3 accepts text.
+    if six.PY2:
+        username = username.encode("utf-8") if isinstance(username, six.text_type) else username
+        password = password.encode("utf-8") if isinstance(password, six.text_type) else password
+    username = unquote(username)
+    password = unquote(password)
+    if isinstance(username, six.text_type):
+        username = username.encode("utf-8")
+    if isinstance(password, six.text_type):
+        password = password.encode("utf-8")
+    # urllib3.make_headers uses Latin-1, which cannot encode UTF-8 userinfo.
+    return "Basic " + base64.b64encode(username + b":" + password).decode("ascii")

byteplussdkcore/configuration.py

@@ -302,7 +302,7 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
                "OS: {env}\n" \
                "Python Version: {pyversion}\n" \
                "Version of the API: 0.1.0\n" \
-               "SDK Package Version: 3.0.60".\
+               "SDK Package Version: 3.0.62".\
             format(env=sys.platform, pyversion=sys.version)
 
     @property

byteplussdkcore/feature/rds/connect_utils.py

@@ -6,9 +6,8 @@ This module provides utilities for generating authentication tokens for RDS MySQ
 """
 
 from byteplussdkcore.endpoint.providers.standard_provider import StandardEndpointResolver
-from byteplussdkcore.interceptor import InterceptorChain, InterceptorContext, SignRequestInterceptor, \
+from byteplussdkcore.interceptor import InterceptorChain, InterceptorContext, \
     ResolveEndpointInterceptor
-from byteplussdkcore.interceptor import Request
 
 DEFAULT_SERVICE = 'rds_mysql'
 DEFAULT_API_VERSION = '2022-01-01'
@@ -58,11 +57,10 @@ def build_auth_token(api_client, db_user, instance_id, expires=None):
     }
 
     # Create Request with presign mode
-    request = Request(configuration,
-                      resource_path='/{}/{}/{}/get/text_plain/'.format(DEFAULT_API, DEFAULT_API_VERSION,
-                                                                       DEFAULT_SERVICE),
-                      method='GET',
-                      query_params=query)
+    request = api_client._create_request(
+        resource_path='/{}/{}/{}/get/text_plain/'.format(
+            DEFAULT_API, DEFAULT_API_VERSION, DEFAULT_SERVICE),
+        method='GET', query_params=query)
     request.endpoint_provider = StandardEndpointResolver()
     request.service = DEFAULT_SERVICE
     request.is_presign = True
@@ -82,7 +80,7 @@ def build_auth_token(api_client, db_user, instance_id, expires=None):
 
     # Step 3: Sign request (host is None, won't be included in signature)
     sign_chain = InterceptorChain()
-    sign_chain.append_request_interceptor(SignRequestInterceptor())
+    sign_chain.append_request_interceptor(api_client.sign_request_interceptor)
     context = sign_chain.execute_request(context)
 
     return context.request.signed_query

byteplussdkcore/interceptor/interceptors/request.py

@@ -57,6 +57,10 @@ class Request(object):
         self.session_token = configuration.session_token
         self.region = configuration.region
         self.scheme = configuration.scheme
+        # Business proxy snapshot; credential routing belongs to ApiClient's binding.
+        self.proxy = configuration.proxy
+        self.http_proxy = configuration.http_proxy
+        self.https_proxy = configuration.https_proxy
         self.endpoint_provider = configuration.endpoint_provider
         self.custom_bootstrap_region = configuration.custom_bootstrap_region
         self.use_dual_stack = configuration.use_dual_stack
@@ -64,6 +68,7 @@ class Request(object):
         # ApiClient injects its private base retryer before interception.
         self.auto_retry = configuration.auto_retry
         self.retryer = None
+        # ApiClient replaces this with its persistent binding before signing.
         self.credential_provider = configuration.credential_provider
         self.invocation_id = str(uuid.uuid4())
         self.retry_count = 0

byteplussdkcore/rest.py

@@ -147,6 +147,11 @@ class RESTClientObject(object):
         )
 
         if proxy_url:
+            # urllib3 (v2) does not forward the ``user:password@`` embedded in
+            # the proxy URL as a Proxy-Authorization header, unlike Go's
+            # http.ProxyURL. Extract it explicitly so proxies requiring Basic
+            # auth work the same way across SDKs.
+            proxy_headers = self.__proxy_authorization_headers(proxy_url)
             self.pool_manager = urllib3.ProxyManager(
                 num_pools=pools_size,
                 maxsize=maxsize,
@@ -155,6 +160,7 @@ class RESTClientObject(object):
                 cert_file=configuration.cert_file,
                 key_file=configuration.key_file,
                 proxy_url=proxy_url,
+                proxy_headers=proxy_headers,
                 timeout=timeout,
                 retries=Retry(total=False),
                 **addition_pool_args
@@ -191,6 +197,27 @@ class RESTClientObject(object):
                     proxy_url = os.getenv('https_proxy')
         return proxy_url
 
+    @staticmethod
+    def __proxy_authorization_headers(proxy_url):
+        """Build proxy_headers carrying Proxy-Authorization, or None.
+
+        Returns a dict ``{'Proxy-Authorization': 'Basic ...'}`` when the proxy
+        URL embeds a ``user:password@`` userinfo, otherwise None (so urllib3
+        keeps its default empty proxy headers). Never raises: a malformed proxy
+        URL simply yields no auth header and lets the connection attempt (and
+        its clearer downstream error) proceed.
+        """
+        try:
+            from byteplussdkcore.auth.sts_http_config import (
+                build_proxy_authorization_header,
+            )
+            value = build_proxy_authorization_header(proxy_url)
+        except Exception:
+            return None
+        if not value:
+            return None
+        return {"Proxy-Authorization": value}
+
     def request(self, method, url, query_params=None, headers=None,
                 body=None, post_params=None, _preload_content=True,
                 _request_timeout=None):

byteplussdkcore/retryer/retry_condition.py

@@ -1,10 +1,13 @@
+import errno
 import json
 import logging
 import socket
+import ssl
 import traceback
 from abc import abstractmethod
 
 import urllib3
+from six.moves.http_client import BadStatusLine
 
 from byteplussdkcore.observability.debugger import sdk_core_logger
 from byteplussdkcore.rest import ApiException, RESTResponse
@@ -73,7 +76,7 @@ class DefaultRetryCondition(RetryCondition):
         Returns:
             bool: True if the request should be retried, False otherwise.
         """
-        if err is not None and isinstance(err, self.__retry_exceptions):
+        if err is not None and self._is_retryable_exception(err):
             sdk_core_logger.debug_retry("retry for retryable exception, err: %s", err)
             return True
 
@@ -105,6 +108,31 @@ class DefaultRetryCondition(RetryCondition):
         sdk_core_logger.debug_retry("no need to retry")
         return False
 
+    @classmethod
+    def _is_retryable_exception(cls, err):
+        # Retry the underlying connection failure, not every proxy failure.
+        # In particular, a CONNECT 407 or a TLS/configuration error must stop.
+        seen = set()
+        while isinstance(err, (urllib3.exceptions.ProxyError, urllib3.exceptions.MaxRetryError)):
+            if id(err) in seen:
+                return False
+            seen.add(id(err))
+            if isinstance(err, urllib3.exceptions.ProxyError):
+                err = err.original_error
+            else:
+                err = err.reason
+        if isinstance(err, (ssl.SSLError, urllib3.exceptions.SSLError)):
+            return False
+        if isinstance(err, cls.__retry_exceptions):
+            return True
+        # RemoteDisconnected on Python 3, empty BadStatusLine on Python 2.
+        if isinstance(err, BadStatusLine) and err.line in ("", "''"):
+            return True
+        return isinstance(err, socket.error) and err.errno in (
+            errno.ECONNRESET, errno.ECONNREFUSED, errno.ECONNABORTED,
+            errno.EPIPE, errno.ETIMEDOUT, errno.ENETUNREACH, errno.EHOSTUNREACH,
+        )
+
     @staticmethod
     def __json_loads(data):
         """

byteplussdkcr/__init__.py

@@ -93,12 +93,16 @@ from byteplussdkcr.models.status_for_list_registries_output import StatusForList
 from byteplussdkcr.models.success_for_delete_tags_output import SuccessForDeleteTagsOutput
 from byteplussdkcr.models.update_public_endpoint_request import UpdatePublicEndpointRequest
 from byteplussdkcr.models.update_public_endpoint_response import UpdatePublicEndpointResponse
+from byteplussdkcr.models.update_registry_request import UpdateRegistryRequest
+from byteplussdkcr.models.update_registry_response import UpdateRegistryResponse
 from byteplussdkcr.models.update_repository_request import UpdateRepositoryRequest
 from byteplussdkcr.models.update_repository_response import UpdateRepositoryResponse
 from byteplussdkcr.models.update_robot_account_password_request import UpdateRobotAccountPasswordRequest
 from byteplussdkcr.models.update_robot_account_password_response import UpdateRobotAccountPasswordResponse
 from byteplussdkcr.models.update_robot_account_request import UpdateRobotAccountRequest
 from byteplussdkcr.models.update_robot_account_response import UpdateRobotAccountResponse
+from byteplussdkcr.models.update_tag_description_request import UpdateTagDescriptionRequest
+from byteplussdkcr.models.update_tag_description_response import UpdateTagDescriptionResponse
 from byteplussdkcr.models.update_vpc_endpoint_request import UpdateVpcEndpointRequest
 from byteplussdkcr.models.update_vpc_endpoint_response import UpdateVpcEndpointResponse
 from byteplussdkcr.models.vpc_for_get_vpc_endpoint_output import VpcForGetVpcEndpointOutput

byteplussdkcr/api/cr_api.py

@@ -2361,6 +2361,103 @@ class CRApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_registry(self, body, **kwargs):  # noqa: E501
+        """update_registry  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_registry(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateRegistryRequest body: (required)
+        :return: UpdateRegistryResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_registry_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_registry_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_registry_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_registry  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_registry_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateRegistryRequest body: (required)
+        :return: UpdateRegistryResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_registry" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_registry`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateRegistry/2022-05-12/cr/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateRegistryResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def update_repository(self, body, **kwargs):  # noqa: E501
         """update_repository  # noqa: E501
 
@@ -2652,6 +2749,103 @@ class CRApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_tag_description(self, body, **kwargs):  # noqa: E501
+        """update_tag_description  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_tag_description(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateTagDescriptionRequest body: (required)
+        :return: UpdateTagDescriptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.update_tag_description_with_http_info(body, **kwargs)  # noqa: E501
+        else:
+            (data) = self.update_tag_description_with_http_info(body, **kwargs)  # noqa: E501
+            return data
+
+    def update_tag_description_with_http_info(self, body, **kwargs):  # noqa: E501
+        """update_tag_description  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.update_tag_description_with_http_info(body, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UpdateTagDescriptionRequest body: (required)
+        :return: UpdateTagDescriptionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_tag_description" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if self.api_client.client_side_validation and ('body' not in params or
+                                                       params['body'] is None):  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `update_tag_description`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['byteplusSign']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/UpdateTagDescription/2022-05-12/cr/post/application_json/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UpdateTagDescriptionResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def update_vpc_endpoint(self, body, **kwargs):  # noqa: E501
         """update_vpc_endpoint  # noqa: E501
 

byteplussdkcr/models/__init__.py

@@ -89,12 +89,16 @@ from byteplussdkcr.models.status_for_list_registries_output import StatusForList
 from byteplussdkcr.models.success_for_delete_tags_output import SuccessForDeleteTagsOutput
 from byteplussdkcr.models.update_public_endpoint_request import UpdatePublicEndpointRequest
 from byteplussdkcr.models.update_public_endpoint_response import UpdatePublicEndpointResponse
+from byteplussdkcr.models.update_registry_request import UpdateRegistryRequest
+from byteplussdkcr.models.update_registry_response import UpdateRegistryResponse
 from byteplussdkcr.models.update_repository_request import UpdateRepositoryRequest
 from byteplussdkcr.models.update_repository_response import UpdateRepositoryResponse
 from byteplussdkcr.models.update_robot_account_password_request import UpdateRobotAccountPasswordRequest
 from byteplussdkcr.models.update_robot_account_password_response import UpdateRobotAccountPasswordResponse
 from byteplussdkcr.models.update_robot_account_request import UpdateRobotAccountRequest
 from byteplussdkcr.models.update_robot_account_response import UpdateRobotAccountResponse
+from byteplussdkcr.models.update_tag_description_request import UpdateTagDescriptionRequest
+from byteplussdkcr.models.update_tag_description_response import UpdateTagDescriptionResponse
 from byteplussdkcr.models.update_vpc_endpoint_request import UpdateVpcEndpointRequest
 from byteplussdkcr.models.update_vpc_endpoint_response import UpdateVpcEndpointResponse
 from byteplussdkcr.models.vpc_for_get_vpc_endpoint_output import VpcForGetVpcEndpointOutput