tencentcloud-sdk-python-ckafka 3.1.122__tar.gz → 3.1.151__tar.gz

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tencentcloud-sdk-python-ckafka
-Version: 3.1.122
+Version: 3.1.151
 Summary: Tencent Cloud Ckafka SDK for Python
 Home-page: https://github.com/TencentCloud/tencentcloud-sdk-python
 Author: Tencent Cloud
@@ -15,7 +15,7 @@ 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: tencentcloud-sdk-python-common<4.0.0,>=3.1.122
+Requires-Dist: tencentcloud-sdk-python-common<4.0.0,>=3.1.151
 
 ============================
 Tencent Cloud SDK for Python

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/setup.py

@@ -8,7 +8,7 @@ ROOT = os.path.dirname(__file__)
 
 setup(
     name='tencentcloud-sdk-python-ckafka',
-    install_requires=["tencentcloud-sdk-python-common>=3.1.122,<4.0.0"],
+    install_requires=["tencentcloud-sdk-python-common>=3.1.151,<4.0.0"],
     
     version=tencentcloud.__version__,
     description='Tencent Cloud Ckafka SDK for Python',

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/tencentcloud/__init__.py

@@ -14,4 +14,4 @@
 # limitations under the License.
 
 
-__version__ = '3.1.122'
+__version__ = '3.1.151'

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/tencentcloud/ckafka/v20190819/ckafka_client.py

@@ -509,6 +509,29 @@ class CkafkaClient(AbstractClient):
                 raise TencentCloudSDKException(type(e).__name__, str(e))
 
 
+    def CreateThrottleRule(self, request):
+        r"""实例限流规则相关接口
+
+        :param request: Request instance for CreateThrottleRule.
+        :type request: :class:`tencentcloud.ckafka.v20190819.models.CreateThrottleRuleRequest`
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.CreateThrottleRuleResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("CreateThrottleRule", params, headers=headers)
+            response = json.loads(body)
+            model = models.CreateThrottleRuleResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
     def CreateToken(self, request):
         r"""创建最高权限的token
 
@@ -854,6 +877,29 @@ class CkafkaClient(AbstractClient):
                 raise TencentCloudSDKException(type(e).__name__, str(e))
 
 
+    def DeleteThrottleRule(self, request):
+        r"""删除实例限流规则
+
+        :param request: Request instance for DeleteThrottleRule.
+        :type request: :class:`tencentcloud.ckafka.v20190819.models.DeleteThrottleRuleRequest`
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.DeleteThrottleRuleResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("DeleteThrottleRule", params, headers=headers)
+            response = json.loads(body)
+            model = models.DeleteThrottleRuleResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
     def DeleteTopic(self, request):
         r"""删除ckafka主题
 
@@ -1498,6 +1544,29 @@ class CkafkaClient(AbstractClient):
                 raise TencentCloudSDKException(type(e).__name__, str(e))
 
 
+    def DescribeThrottleRules(self, request):
+        r"""获取实例限流规则列表
+
+        :param request: Request instance for DescribeThrottleRules.
+        :type request: :class:`tencentcloud.ckafka.v20190819.models.DescribeThrottleRulesRequest`
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.DescribeThrottleRulesResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("DescribeThrottleRules", params, headers=headers)
+            response = json.loads(body)
+            model = models.DescribeThrottleRulesResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
     def DescribeTopic(self, request):
         r"""接口请求域名：https://ckafka.tencentcloudapi.com
         本接口（DescribeTopic）用于在用户获取消息队列 CKafka 实例的主题列表
@@ -1867,6 +1936,29 @@ class CkafkaClient(AbstractClient):
                 raise TencentCloudSDKException(type(e).__name__, str(e))
 
 
+    def IsolatedInstancePre(self, request):
+        r"""隔离预付费实例，该接口会对实例执行隔离的动作，执行成功后实例会被隔离
+
+        :param request: Request instance for IsolatedInstancePre.
+        :type request: :class:`tencentcloud.ckafka.v20190819.models.IsolatedInstancePreRequest`
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.IsolatedInstancePreResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("IsolatedInstancePre", params, headers=headers)
+            response = json.loads(body)
+            model = models.IsolatedInstancePreResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
     def ModifyAccessPolicy(self, request):
         r"""修改实例公网IP白名单列表接口
 
@@ -2097,6 +2189,29 @@ class CkafkaClient(AbstractClient):
                 raise TencentCloudSDKException(type(e).__name__, str(e))
 
 
+    def ModifyThrottleRule(self, request):
+        r"""修改限流规则接口
+
+        :param request: Request instance for ModifyThrottleRule.
+        :type request: :class:`tencentcloud.ckafka.v20190819.models.ModifyThrottleRuleRequest`
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.ModifyThrottleRuleResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("ModifyThrottleRule", params, headers=headers)
+            response = json.loads(body)
+            model = models.ModifyThrottleRuleResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
     def ModifyTopicAttributes(self, request):
         r"""本接口用于修改主题属性。
 

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/tencentcloud/ckafka/v20190819/ckafka_client_async.py

@@ -403,6 +403,24 @@ class CkafkaClient(AbstractClient):
         
         return await self.call_and_deserialize(**kwargs)
         
+    async def CreateThrottleRule(
+            self,
+            request: models.CreateThrottleRuleRequest,
+            opts: Dict = None,
+    ) -> models.CreateThrottleRuleResponse:
+        """
+        实例限流规则相关接口
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "CreateThrottleRule"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.CreateThrottleRuleResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
     async def CreateToken(
             self,
             request: models.CreateTokenRequest,
@@ -673,6 +691,24 @@ class CkafkaClient(AbstractClient):
         
         return await self.call_and_deserialize(**kwargs)
         
+    async def DeleteThrottleRule(
+            self,
+            request: models.DeleteThrottleRuleRequest,
+            opts: Dict = None,
+    ) -> models.DeleteThrottleRuleResponse:
+        """
+        删除实例限流规则
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "DeleteThrottleRule"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.DeleteThrottleRuleResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
     async def DeleteTopic(
             self,
             request: models.DeleteTopicRequest,
@@ -1177,6 +1213,24 @@ class CkafkaClient(AbstractClient):
         
         return await self.call_and_deserialize(**kwargs)
         
+    async def DescribeThrottleRules(
+            self,
+            request: models.DescribeThrottleRulesRequest,
+            opts: Dict = None,
+    ) -> models.DescribeThrottleRulesResponse:
+        """
+        获取实例限流规则列表
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "DescribeThrottleRules"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.DescribeThrottleRulesResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
     async def DescribeTopic(
             self,
             request: models.DescribeTopicRequest,
@@ -1466,6 +1520,24 @@ class CkafkaClient(AbstractClient):
         
         return await self.call_and_deserialize(**kwargs)
         
+    async def IsolatedInstancePre(
+            self,
+            request: models.IsolatedInstancePreRequest,
+            opts: Dict = None,
+    ) -> models.IsolatedInstancePreResponse:
+        """
+        隔离预付费实例，该接口会对实例执行隔离的动作，执行成功后实例会被隔离
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "IsolatedInstancePre"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.IsolatedInstancePreResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
     async def ModifyAccessPolicy(
             self,
             request: models.ModifyAccessPolicyRequest,
@@ -1646,6 +1718,24 @@ class CkafkaClient(AbstractClient):
         
         return await self.call_and_deserialize(**kwargs)
         
+    async def ModifyThrottleRule(
+            self,
+            request: models.ModifyThrottleRuleRequest,
+            opts: Dict = None,
+    ) -> models.ModifyThrottleRuleResponse:
+        """
+        修改限流规则接口
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "ModifyThrottleRule"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.ModifyThrottleRuleResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
     async def ModifyTopicAttributes(
             self,
             request: models.ModifyTopicAttributesRequest,

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/tencentcloud/ckafka/v20190819/models.py

@@ -7360,6 +7360,192 @@ class CreateRouteResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class CreateThrottleRuleRequest(AbstractModel):
+    r"""CreateThrottleRule请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: <p>实例Id</p>
+        :type InstanceId: str
+        :param _ThrottleType: <p>限流类型:</p><p>枚举值：</p><ul><li>1： 用户/客户端限流</li><li>2： 消费组维度限流</li><li>3： Topic限流</li></ul>
+        :type ThrottleType: int
+        :param _GroupNameList: <p>消费组名</p>
+        :type GroupNameList: list of str
+        :param _ConsumeThrottle: <p>消费限流值,生产消费限流值,必填一个单位MB/s</p>
+        :type ConsumeThrottle: int
+        :param _ProduceThrottle: <p>生产限流值,生产消费限流值,单位MB/s</p>
+        :type ProduceThrottle: int
+        :param _ClientIdList: <p>用户客户端id</p>
+        :type ClientIdList: list of str
+        :param _UserNameList: <p>用户名</p>
+        :type UserNameList: list of str
+        :param _TopicNameList: <p>topic名称</p>
+        :type TopicNameList: list of str
+        """
+        self._InstanceId = None
+        self._ThrottleType = None
+        self._GroupNameList = None
+        self._ConsumeThrottle = None
+        self._ProduceThrottle = None
+        self._ClientIdList = None
+        self._UserNameList = None
+        self._TopicNameList = None
+
+    @property
+    def InstanceId(self):
+        r"""<p>实例Id</p>
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def ThrottleType(self):
+        r"""<p>限流类型:</p><p>枚举值：</p><ul><li>1： 用户/客户端限流</li><li>2： 消费组维度限流</li><li>3： Topic限流</li></ul>
+        :rtype: int
+        """
+        return self._ThrottleType
+
+    @ThrottleType.setter
+    def ThrottleType(self, ThrottleType):
+        self._ThrottleType = ThrottleType
+
+    @property
+    def GroupNameList(self):
+        r"""<p>消费组名</p>
+        :rtype: list of str
+        """
+        return self._GroupNameList
+
+    @GroupNameList.setter
+    def GroupNameList(self, GroupNameList):
+        self._GroupNameList = GroupNameList
+
+    @property
+    def ConsumeThrottle(self):
+        r"""<p>消费限流值,生产消费限流值,必填一个单位MB/s</p>
+        :rtype: int
+        """
+        return self._ConsumeThrottle
+
+    @ConsumeThrottle.setter
+    def ConsumeThrottle(self, ConsumeThrottle):
+        self._ConsumeThrottle = ConsumeThrottle
+
+    @property
+    def ProduceThrottle(self):
+        r"""<p>生产限流值,生产消费限流值,单位MB/s</p>
+        :rtype: int
+        """
+        return self._ProduceThrottle
+
+    @ProduceThrottle.setter
+    def ProduceThrottle(self, ProduceThrottle):
+        self._ProduceThrottle = ProduceThrottle
+
+    @property
+    def ClientIdList(self):
+        r"""<p>用户客户端id</p>
+        :rtype: list of str
+        """
+        return self._ClientIdList
+
+    @ClientIdList.setter
+    def ClientIdList(self, ClientIdList):
+        self._ClientIdList = ClientIdList
+
+    @property
+    def UserNameList(self):
+        r"""<p>用户名</p>
+        :rtype: list of str
+        """
+        return self._UserNameList
+
+    @UserNameList.setter
+    def UserNameList(self, UserNameList):
+        self._UserNameList = UserNameList
+
+    @property
+    def TopicNameList(self):
+        r"""<p>topic名称</p>
+        :rtype: list of str
+        """
+        return self._TopicNameList
+
+    @TopicNameList.setter
+    def TopicNameList(self, TopicNameList):
+        self._TopicNameList = TopicNameList
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        self._ThrottleType = params.get("ThrottleType")
+        self._GroupNameList = params.get("GroupNameList")
+        self._ConsumeThrottle = params.get("ConsumeThrottle")
+        self._ProduceThrottle = params.get("ProduceThrottle")
+        self._ClientIdList = params.get("ClientIdList")
+        self._UserNameList = params.get("UserNameList")
+        self._TopicNameList = params.get("TopicNameList")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class CreateThrottleRuleResponse(AbstractModel):
+    r"""CreateThrottleRule返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: <p>返回信息</p>
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""<p>返回信息</p>
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("Result") is not None:
+            self._Result = JgwOperateResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class CreateTokenRequest(AbstractModel):
     r"""CreateToken请求参数结构体
 
@@ -10486,6 +10672,102 @@ class DeleteRouteTriggerTimeResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DeleteThrottleRuleRequest(AbstractModel):
+    r"""DeleteThrottleRule请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _ThrottleRuleId: 限流规则Id
+        :type ThrottleRuleId: str
+        :param _InstanceId: 实例标识
+        :type InstanceId: str
+        """
+        self._ThrottleRuleId = None
+        self._InstanceId = None
+
+    @property
+    def ThrottleRuleId(self):
+        r"""限流规则Id
+        :rtype: str
+        """
+        return self._ThrottleRuleId
+
+    @ThrottleRuleId.setter
+    def ThrottleRuleId(self, ThrottleRuleId):
+        self._ThrottleRuleId = ThrottleRuleId
+
+    @property
+    def InstanceId(self):
+        r"""实例标识
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+
+    def _deserialize(self, params):
+        self._ThrottleRuleId = params.get("ThrottleRuleId")
+        self._InstanceId = params.get("InstanceId")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DeleteThrottleRuleResponse(AbstractModel):
+    r"""DeleteThrottleRule返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 返回信息
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""返回信息
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("Result") is not None:
+            self._Result = JgwOperateResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class DeleteTopicRequest(AbstractModel):
     r"""DeleteTopic请求参数结构体
 
@@ -15631,6 +15913,147 @@ class DescribeTaskStatusResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DescribeThrottleRulesRequest(AbstractModel):
+    r"""DescribeThrottleRules请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: <p>实例Id</p>
+        :type InstanceId: str
+        :param _SearchWord: <p>关键字</p>
+        :type SearchWord: str
+        :param _Limit: <p>返回数量，不填则默认为20，最大值200</p>
+        :type Limit: int
+        :param _Offset: <p>偏移数，默认为0</p>
+        :type Offset: int
+        :param _ThrottleDimension: <p>限流维度</p><p>枚举值：</p><ul><li>1： 实例维度限流</li><li>2： topic维度限流</li></ul><p>默认值：1</p>
+        :type ThrottleDimension: int
+        """
+        self._InstanceId = None
+        self._SearchWord = None
+        self._Limit = None
+        self._Offset = None
+        self._ThrottleDimension = None
+
+    @property
+    def InstanceId(self):
+        r"""<p>实例Id</p>
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def SearchWord(self):
+        r"""<p>关键字</p>
+        :rtype: str
+        """
+        return self._SearchWord
+
+    @SearchWord.setter
+    def SearchWord(self, SearchWord):
+        self._SearchWord = SearchWord
+
+    @property
+    def Limit(self):
+        r"""<p>返回数量，不填则默认为20，最大值200</p>
+        :rtype: int
+        """
+        return self._Limit
+
+    @Limit.setter
+    def Limit(self, Limit):
+        self._Limit = Limit
+
+    @property
+    def Offset(self):
+        r"""<p>偏移数，默认为0</p>
+        :rtype: int
+        """
+        return self._Offset
+
+    @Offset.setter
+    def Offset(self, Offset):
+        self._Offset = Offset
+
+    @property
+    def ThrottleDimension(self):
+        r"""<p>限流维度</p><p>枚举值：</p><ul><li>1： 实例维度限流</li><li>2： topic维度限流</li></ul><p>默认值：1</p>
+        :rtype: int
+        """
+        return self._ThrottleDimension
+
+    @ThrottleDimension.setter
+    def ThrottleDimension(self, ThrottleDimension):
+        self._ThrottleDimension = ThrottleDimension
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        self._SearchWord = params.get("SearchWord")
+        self._Limit = params.get("Limit")
+        self._Offset = params.get("Offset")
+        self._ThrottleDimension = params.get("ThrottleDimension")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DescribeThrottleRulesResponse(AbstractModel):
+    r"""DescribeThrottleRules返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: <p>返回信息</p>
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.ThrottleRuleResult`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""<p>返回信息</p>
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.ThrottleRuleResult`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("Result") is not None:
+            self._Result = ThrottleRuleResult()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class DescribeTopicAttributesRequest(AbstractModel):
     r"""DescribeTopicAttributes请求参数结构体
 
@@ -23308,35 +23731,116 @@ class IpWhitelistDTO(AbstractModel):
         r"""<p>放通IP或网段</p>
         :rtype: str
         """
-        return self._CidrBlock
+        return self._CidrBlock
+
+    @CidrBlock.setter
+    def CidrBlock(self, CidrBlock):
+        self._CidrBlock = CidrBlock
+
+    @property
+    def PolicyDescription(self):
+        r"""<p>描述</p>
+        :rtype: str
+        """
+        return self._PolicyDescription
+
+    @PolicyDescription.setter
+    def PolicyDescription(self, PolicyDescription):
+        self._PolicyDescription = PolicyDescription
+
+
+    def _deserialize(self, params):
+        self._CidrBlock = params.get("CidrBlock")
+        self._PolicyDescription = params.get("PolicyDescription")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class IsolatedInstancePreRequest(AbstractModel):
+    r"""IsolatedInstancePre请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: ckafka集群实例Id
+        :type InstanceId: str
+        """
+        self._InstanceId = None
+
+    @property
+    def InstanceId(self):
+        r"""ckafka集群实例Id
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class IsolatedInstancePreResponse(AbstractModel):
+    r"""IsolatedInstancePre返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 返回结果
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.CreateInstancePreResp`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""返回结果
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.CreateInstancePreResp`
+        """
+        return self._Result
 
-    @CidrBlock.setter
-    def CidrBlock(self, CidrBlock):
-        self._CidrBlock = CidrBlock
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
 
     @property
-    def PolicyDescription(self):
-        r"""<p>描述</p>
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :rtype: str
         """
-        return self._PolicyDescription
+        return self._RequestId
 
-    @PolicyDescription.setter
-    def PolicyDescription(self, PolicyDescription):
-        self._PolicyDescription = PolicyDescription
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
 
 
     def _deserialize(self, params):
-        self._CidrBlock = params.get("CidrBlock")
-        self._PolicyDescription = params.get("PolicyDescription")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
+        if params.get("Result") is not None:
+            self._Result = CreateInstancePreResp()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
 
 
 class JgwOperateResponse(AbstractModel):
@@ -26549,6 +27053,117 @@ class ModifyRoutineMaintenanceTaskResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class ModifyThrottleRuleRequest(AbstractModel):
+    r"""ModifyThrottleRule请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _ThrottleRuleId: 规则标识
+        :type ThrottleRuleId: int
+        :param _InstanceId: 实例Id
+        :type InstanceId: str
+        :param _ConsumeThrottle: 消费限流值单位MB/s
+        :type ConsumeThrottle: int
+        """
+        self._ThrottleRuleId = None
+        self._InstanceId = None
+        self._ConsumeThrottle = None
+
+    @property
+    def ThrottleRuleId(self):
+        r"""规则标识
+        :rtype: int
+        """
+        return self._ThrottleRuleId
+
+    @ThrottleRuleId.setter
+    def ThrottleRuleId(self, ThrottleRuleId):
+        self._ThrottleRuleId = ThrottleRuleId
+
+    @property
+    def InstanceId(self):
+        r"""实例Id
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def ConsumeThrottle(self):
+        r"""消费限流值单位MB/s
+        :rtype: int
+        """
+        return self._ConsumeThrottle
+
+    @ConsumeThrottle.setter
+    def ConsumeThrottle(self, ConsumeThrottle):
+        self._ConsumeThrottle = ConsumeThrottle
+
+
+    def _deserialize(self, params):
+        self._ThrottleRuleId = params.get("ThrottleRuleId")
+        self._InstanceId = params.get("InstanceId")
+        self._ConsumeThrottle = params.get("ConsumeThrottle")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifyThrottleRuleResponse(AbstractModel):
+    r"""ModifyThrottleRule返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 返回信息
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""返回信息
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("Result") is not None:
+            self._Result = JgwOperateResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class ModifyTopicAttributesRequest(AbstractModel):
     r"""ModifyTopicAttributes请求参数结构体
 
@@ -32215,6 +32830,203 @@ class TdwParam(AbstractModel):
         
 
 
+class ThrottleRuleDetail(AbstractModel):
+    r"""限流规则详情
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _ThrottleRuleId: <p>限流规则标识</p>
+        :type ThrottleRuleId: int
+        :param _ThrottleType: <p>限流类型</p><p>枚举值：</p><ul><li>1： 用户/客户端限流</li><li>2： 消费组限流</li><li>3： topic限流</li></ul>
+        :type ThrottleType: int
+        :param _ClientId: <p>客户端id</p>
+        :type ClientId: str
+        :param _UserName: <p>用户名</p>
+        :type UserName: str
+        :param _ConsumeThrottle: <p>消费限流值,单位MB/s</p>
+        :type ConsumeThrottle: int
+        :param _UpdateTime: <p>更新时间</p>
+        :type UpdateTime: str
+        :param _TopicName: <p>topic名称</p>
+        :type TopicName: str
+        :param _TopicId: <p>topicId</p>
+        :type TopicId: str
+        """
+        self._ThrottleRuleId = None
+        self._ThrottleType = None
+        self._ClientId = None
+        self._UserName = None
+        self._ConsumeThrottle = None
+        self._UpdateTime = None
+        self._TopicName = None
+        self._TopicId = None
+
+    @property
+    def ThrottleRuleId(self):
+        r"""<p>限流规则标识</p>
+        :rtype: int
+        """
+        return self._ThrottleRuleId
+
+    @ThrottleRuleId.setter
+    def ThrottleRuleId(self, ThrottleRuleId):
+        self._ThrottleRuleId = ThrottleRuleId
+
+    @property
+    def ThrottleType(self):
+        r"""<p>限流类型</p><p>枚举值：</p><ul><li>1： 用户/客户端限流</li><li>2： 消费组限流</li><li>3： topic限流</li></ul>
+        :rtype: int
+        """
+        return self._ThrottleType
+
+    @ThrottleType.setter
+    def ThrottleType(self, ThrottleType):
+        self._ThrottleType = ThrottleType
+
+    @property
+    def ClientId(self):
+        r"""<p>客户端id</p>
+        :rtype: str
+        """
+        return self._ClientId
+
+    @ClientId.setter
+    def ClientId(self, ClientId):
+        self._ClientId = ClientId
+
+    @property
+    def UserName(self):
+        r"""<p>用户名</p>
+        :rtype: str
+        """
+        return self._UserName
+
+    @UserName.setter
+    def UserName(self, UserName):
+        self._UserName = UserName
+
+    @property
+    def ConsumeThrottle(self):
+        r"""<p>消费限流值,单位MB/s</p>
+        :rtype: int
+        """
+        return self._ConsumeThrottle
+
+    @ConsumeThrottle.setter
+    def ConsumeThrottle(self, ConsumeThrottle):
+        self._ConsumeThrottle = ConsumeThrottle
+
+    @property
+    def UpdateTime(self):
+        r"""<p>更新时间</p>
+        :rtype: str
+        """
+        return self._UpdateTime
+
+    @UpdateTime.setter
+    def UpdateTime(self, UpdateTime):
+        self._UpdateTime = UpdateTime
+
+    @property
+    def TopicName(self):
+        r"""<p>topic名称</p>
+        :rtype: str
+        """
+        return self._TopicName
+
+    @TopicName.setter
+    def TopicName(self, TopicName):
+        self._TopicName = TopicName
+
+    @property
+    def TopicId(self):
+        r"""<p>topicId</p>
+        :rtype: str
+        """
+        return self._TopicId
+
+    @TopicId.setter
+    def TopicId(self, TopicId):
+        self._TopicId = TopicId
+
+
+    def _deserialize(self, params):
+        self._ThrottleRuleId = params.get("ThrottleRuleId")
+        self._ThrottleType = params.get("ThrottleType")
+        self._ClientId = params.get("ClientId")
+        self._UserName = params.get("UserName")
+        self._ConsumeThrottle = params.get("ConsumeThrottle")
+        self._UpdateTime = params.get("UpdateTime")
+        self._TopicName = params.get("TopicName")
+        self._TopicId = params.get("TopicId")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ThrottleRuleResult(AbstractModel):
+    r"""限流规则列表返回
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TotalCount: 总数量
+        :type TotalCount: int
+        :param _ThrottleRuleList: 规则列表
+        :type ThrottleRuleList: list of ThrottleRuleDetail
+        """
+        self._TotalCount = None
+        self._ThrottleRuleList = None
+
+    @property
+    def TotalCount(self):
+        r"""总数量
+        :rtype: int
+        """
+        return self._TotalCount
+
+    @TotalCount.setter
+    def TotalCount(self, TotalCount):
+        self._TotalCount = TotalCount
+
+    @property
+    def ThrottleRuleList(self):
+        r"""规则列表
+        :rtype: list of ThrottleRuleDetail
+        """
+        return self._ThrottleRuleList
+
+    @ThrottleRuleList.setter
+    def ThrottleRuleList(self, ThrottleRuleList):
+        self._ThrottleRuleList = ThrottleRuleList
+
+
+    def _deserialize(self, params):
+        self._TotalCount = params.get("TotalCount")
+        if params.get("ThrottleRuleList") is not None:
+            self._ThrottleRuleList = []
+            for item in params.get("ThrottleRuleList"):
+                obj = ThrottleRuleDetail()
+                obj._deserialize(item)
+                self._ThrottleRuleList.append(obj)
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
 class Topic(AbstractModel):
     r"""返回的topic对象
 

{tencentcloud_sdk_python_ckafka-3.1.122 → tencentcloud_sdk_python_ckafka-3.1.151}/tencentcloud_sdk_python_ckafka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tencentcloud-sdk-python-ckafka
-Version: 3.1.122
+Version: 3.1.151
 Summary: Tencent Cloud Ckafka SDK for Python
 Home-page: https://github.com/TencentCloud/tencentcloud-sdk-python
 Author: Tencent Cloud
@@ -15,7 +15,7 @@ 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: tencentcloud-sdk-python-common<4.0.0,>=3.1.122
+Requires-Dist: tencentcloud-sdk-python-common<4.0.0,>=3.1.151
 
 ============================
 Tencent Cloud SDK for Python

tencentcloud_sdk_python_ckafka-3.1.151/tencentcloud_sdk_python_ckafka.egg-info/requires.txt

@@ -0,0 +1 @@
+tencentcloud-sdk-python-common<4.0.0,>=3.1.151

tencentcloud_sdk_python_ckafka-3.1.122/tencentcloud_sdk_python_ckafka.egg-info/requires.txt

@@ -1 +0,0 @@
-tencentcloud-sdk-python-common<4.0.0,>=3.1.122