baiducloud-python-sdk-eip 0.0.1__tar.gz → 0.0.3__tar.gz

{baiducloud_python_sdk_eip-0.0.1/baiducloud_python_sdk_eip.egg-info → baiducloud_python_sdk_eip-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baiducloud-python-sdk-eip
-Version: 0.0.1
+Version: 0.0.3
 Summary: Baidu Cloud eipApi SDK Library for Python
 Home-page: https://github.com/baidubce/baiducloud-python-sdk
 Author: Baidu Cloud SDK
@@ -8,7 +8,7 @@ Author-email:
 License: Apache License 2.0
 Project-URL: Source, https://github.com/baidubce/baiducloud-python-sdk
 Project-URL: Documentation, https://github.com/baidubce/baiducloud-python-sdk/tree/master/docs
-Project-URL: Changelog, https://github.com/baidubce/baiducloud-python-sdk/blob/master/baiducloud-python-sdk-core/ChangeLog.md
+Project-URL: Changelog, https://github.com/baidubce/baiducloud-python-sdk/blob/master/baiducloud-python-sdk-eip/ChangeLog.md
 Keywords: baiducloud,eip
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/__init__.py

@@ -0,0 +1 @@
+SDK_VERSION = b'0.0.3'

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/api/eip_client.py

@@ -0,0 +1,297 @@
+import copy
+import logging
+import uuid
+
+from baiducloud_python_sdk_core import utils, bce_base_client
+from baiducloud_python_sdk_core.auth import bce_v1_signer
+from baiducloud_python_sdk_core.bce_base_client import BceBaseClient
+from baiducloud_python_sdk_core.http import bce_http_client
+from baiducloud_python_sdk_core.http import handler
+from baiducloud_python_sdk_core.http import http_methods
+from baiducloud_python_sdk_eip.models.bandwidth_package_inquiry_response import BandwidthPackageInquiryResponse
+from baiducloud_python_sdk_eip.models.create_tbsp_response import CreateTbspResponse
+from baiducloud_python_sdk_eip.models.detail_tbsp_response import DetailTbspResponse
+from baiducloud_python_sdk_eip.models.eip_inquiry_response import EipInquiryResponse
+from baiducloud_python_sdk_eip.models.list_tbsp_response import ListTbspResponse
+from baiducloud_python_sdk_eip.models.list_tbsp_area_blocking_response import ListTbspAreaBlockingResponse
+from baiducloud_python_sdk_eip.models.list_tbsp_ip_clean_response import ListTbspIpCleanResponse
+from baiducloud_python_sdk_eip.models.list_tbsp_ip_whitelist_response import ListTbspIpWhitelistResponse
+from baiducloud_python_sdk_eip.models.list_tbsp_protocol_blocking_response import ListTbspProtocolBlockingResponse
+from baiducloud_python_sdk_eip.models.shared_bandwidth_inquiry_response import SharedBandwidthInquiryResponse
+from baiducloud_python_sdk_eip.models.shared_data_package_inquiry_response import SharedDataPackageInquiryResponse
+
+_logger = logging.getLogger(__name__)
+
+
+class EipClient(BceBaseClient):
+
+    VERSION_V1 = b'/v1'
+
+    CONSTANT_TBSP = b'tbsp'
+
+    CONSTANT_AREA_BLOCKING = b'areaBlocking'
+
+    CONSTANT_EIP = b'eip'
+
+    CONSTANT_PRICE = b'price'
+
+    CONSTANT_PROTOCOL_BLOCKING = b'protocolBlocking'
+
+    CONSTANT_EIPBP = b'eipbp'
+
+    CONSTANT_IP_PROTECT_LEVEL = b'ipProtectLevel'
+
+    CONSTANT_IP_CLEAN = b'ipClean'
+
+    CONSTANT_IP_WHITELIST = b'ipWhitelist'
+
+    CONSTANT_EIPTP = b'eiptp'
+
+    CONSTANT_EIPGROUP = b'eipgroup'
+
+    def __init__(self, config=None):
+        bce_base_client.BceBaseClient.__init__(self, config)
+
+    def add_tbsp_area_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_AREA_BLOCKING)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def add_tbsp_ip_whitelist(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_WHITELIST)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def add_tbsp_protocol_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_PROTOCOL_BLOCKING)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def bandwidth_package_inquiry(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_EIPBP, EipClient.CONSTANT_PRICE)
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), config=config, model=BandwidthPackageInquiryResponse)
+
+    def bind_tbsp_protection_object(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id)
+        params = {
+            'bind' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def create_tbsp(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config, model=CreateTbspResponse)
+
+    def detail_tbsp(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id)
+        return self._send_request(http_methods.GET, path=path
+                                , config=config, model=DetailTbspResponse)
+
+    def disable_tbsp_ip_clean(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_CLEAN)
+        params = {
+            'turnOffClean' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def eip_inquiry(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_EIP, EipClient.CONSTANT_PRICE)
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), config=config, model=EipInquiryResponse)
+
+    def enable_tbsp_ip_clean(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_CLEAN)
+        params = {
+            'turnOnClean' : None,
+            'clientToken' : request.client_token,
+            'ip' : request.ip,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , params=params, config=config)
+
+    def list_tbsp(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP)
+        params = {
+            'id' : request.id,
+            'name' : request.name,
+            'status' : request.status,
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=ListTbspResponse)
+
+    def list_tbsp_area_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_AREA_BLOCKING)
+        params = {
+            'ip' : request.ip,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=ListTbspAreaBlockingResponse)
+
+    def list_tbsp_ip_clean(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_CLEAN)
+        params = {
+            'ip' : request.ip,
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=ListTbspIpCleanResponse)
+
+    def list_tbsp_ip_whitelist(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_WHITELIST)
+        params = {
+            'ip' : request.ip,
+            'ipCidr' : request.ip_cidr,
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=ListTbspIpWhitelistResponse)
+
+    def list_tbsp_protocol_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_PROTOCOL_BLOCKING)
+        params = {
+            'ip' : request.ip,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=ListTbspProtocolBlockingResponse)
+
+    def modify_tbsp_ip_clean_threshold(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_CLEAN)
+        params = {
+            'modifyThreshold' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def modify_tbsp_ip_protect_level(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_PROTECT_LEVEL)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def remove_tbsp_area_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_AREA_BLOCKING)
+        params = {
+            'ip' : request.ip,
+            'blockType' : request.block_type,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def remove_tbsp_ip_whitelist(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_IP_WHITELIST)
+        params = {
+            'clientToken' : request.client_token,
+            'ip' : request.ip,
+            'whitelistId' : request.whitelist_id,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def remove_tbsp_protocol_blocking(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id, EipClient.CONSTANT_PROTOCOL_BLOCKING)
+        params = {
+            'ip' : request.ip,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def renew_tbsp(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id)
+        params = {
+            'purchaseReserved' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def resize_tbsp(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id)
+        params = {
+            'resize' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def shared_bandwidth_inquiry(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_EIPGROUP, EipClient.CONSTANT_PRICE)
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), config=config, model=SharedBandwidthInquiryResponse)
+
+    def shared_data_package_inquiry(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_EIPTP, EipClient.CONSTANT_PRICE)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config, model=SharedDataPackageInquiryResponse)
+
+    def unbind_tbsp_protection_object(self, request, config=None):
+        path = utils.append_uri(EipClient.VERSION_V1, EipClient.CONSTANT_TBSP, request.id)
+        params = {
+            'unbind' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+
+
+    @staticmethod
+    def _generate_default_client_token():
+        """
+        default client token by uuid1
+        """
+        return uuid.uuid1()
+
+    def _merge_config(self, config=None):
+        """
+        :param config:
+        :type config: baiducloud_python_sdk_core.BceClientConfiguration
+        """
+        if config is None:
+            return self.config
+        else:
+            new_config = copy.copy(self.config)
+            new_config.merge_non_none_values(config)
+            return new_config
+
+    def _send_request(self, http_method, path,
+                      body=None, headers=None, params=None,
+                      config=None, body_parser=None, model=None):
+        config = self._merge_config(config)
+        if body_parser is None:
+            body_parser = handler.parse_json
+        if headers is None:
+            headers = {b'Accept': b'*/*', b'Content-Type':
+                b'application/json;charset=utf-8'}
+        return bce_http_client.send_request(
+            config, bce_v1_signer.sign, [handler.parse_error, body_parser],
+            http_method, path, body, headers, params, model=model)

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/add_tbsp_area_blocking_request.py

@@ -0,0 +1,39 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class AddTbspAreaBlockingRequest(AbstractModel):
+    
+    def __init__(self, id, client_token=None, ip=None, block_time=None, block_type=None):
+        super().__init__()
+        self.id = id
+        self.client_token = client_token
+        self.ip = ip
+        self.block_time = block_time
+        self.block_type = block_type
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.ip is not None:
+            result['ip'] = self.ip
+        if self.block_time is not None:
+            result['blockTime'] = self.block_time
+        if self.block_type is not None:
+            result['blockType'] = self.block_type
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        if m.get('ip') is not None:
+            self.ip = m.get('ip')
+        if m.get('blockTime') is not None:
+            self.block_time = m.get('blockTime')
+        if m.get('blockType') is not None:
+            self.block_type = m.get('blockType')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/add_tbsp_ip_whitelist_request.py

@@ -0,0 +1,34 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class AddTbspIpWhitelistRequest(AbstractModel):
+    
+    def __init__(self, id, client_token=None, ip=None, ip_cidr_list=None):
+        super().__init__()
+        self.id = id
+        self.client_token = client_token
+        self.ip = ip
+        self.ip_cidr_list = ip_cidr_list
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.ip is not None:
+            result['ip'] = self.ip
+        if self.ip_cidr_list is not None:
+            result['ipCidrList'] = self.ip_cidr_list
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        if m.get('ip') is not None:
+            self.ip = m.get('ip')
+        if m.get('ipCidrList') is not None:
+            self.ip_cidr_list = m.get('ipCidrList')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/add_tbsp_protocol_blocking_request.py

@@ -0,0 +1,38 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+from baiducloud_python_sdk_eip.models.tbsp_protocol_port_model import TbspProtocolPortModel
+
+class AddTbspProtocolBlockingRequest(AbstractModel):
+    
+    def __init__(self, id, client_token=None, ip=None, protocol_port_list=None):
+        super().__init__()
+        self.id = id
+        self.client_token = client_token
+        self.ip = ip
+        self.protocol_port_list = protocol_port_list
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.ip is not None:
+            result['ip'] = self.ip
+        if self.protocol_port_list is not None:
+            result['protocolPortList'] = [i.to_dict() for i in self.protocol_port_list]
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        if m.get('ip') is not None:
+            self.ip = m.get('ip')
+        if m.get('protocolPortList') is not None:
+            self.protocol_port_list = [
+            TbspProtocolPortModel().from_dict(i)
+            for i in m.get('protocolPortList')
+            ]
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/bandwidth_package_inquiry_request.py

@@ -0,0 +1,33 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class BandwidthPackageInquiryRequest(AbstractModel):
+    
+    def __init__(self, bandwidth_in_mbps, count=None, type=None):
+        super().__init__()
+        self.bandwidth_in_mbps = bandwidth_in_mbps
+        self.count = count
+        self.type = type
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.bandwidth_in_mbps is not None:
+            result['bandwidthInMbps'] = self.bandwidth_in_mbps
+        if self.count is not None:
+            result['count'] = self.count
+        if self.type is not None:
+            result['type'] = self.type
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('bandwidthInMbps') is not None:
+            self.bandwidth_in_mbps = m.get('bandwidthInMbps')
+        if m.get('count') is not None:
+            self.count = m.get('count')
+        if m.get('type') is not None:
+            self.type = m.get('type')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/bandwidth_package_inquiry_response.py

@@ -0,0 +1,27 @@
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+class BandwidthPackageInquiryResponse(BceResponse):
+    """
+    BandwidthPackageInquiryResponse
+    """
+    def __init__(self, prices=None):
+        super().__init__()
+        self.prices = prices
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.metadata is not None:
+            result['metadata'] = self.metadata
+        if self.prices is not None:
+            result['prices'] = self.prices
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('prices') is not None:
+            self.prices = m.get('prices')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/billing.py

@@ -0,0 +1,39 @@
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+from baiducloud_python_sdk_eip.models.reservation import Reservation
+
+
+class Billing(AbstractModel):
+    """
+    Billing
+    """
+    def __init__(self, payment_timing=None, billing_method=None, reservation=None):
+        super().__init__()
+        self.payment_timing = payment_timing
+        self.billing_method = billing_method
+        self.reservation = reservation
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.payment_timing is not None:
+            result['paymentTiming'] = self.payment_timing
+        if self.billing_method is not None:
+            result['billingMethod'] = self.billing_method
+        if self.reservation is not None:
+            result['reservation'] = self.reservation.to_dict()
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('paymentTiming') is not None:
+            self.payment_timing = m.get('paymentTiming')
+        if m.get('billingMethod') is not None:
+            self.billing_method = m.get('billingMethod')
+        if m.get('reservation') is not None:
+            self.reservation = Reservation().from_dict(m.get('reservation'))
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/bind_tbsp_protection_object_request.py

@@ -0,0 +1,29 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class BindTbspProtectionObjectRequest(AbstractModel):
+    
+    def __init__(self, id, ip_list, client_token=None):
+        super().__init__()
+        self.id = id
+        self.client_token = client_token
+        self.ip_list = ip_list
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.ip_list is not None:
+            result['ipList'] = self.ip_list
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        if m.get('ipList') is not None:
+            self.ip_list = m.get('ipList')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/create_tbsp_request.py

@@ -0,0 +1,56 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class CreateTbspRequest(AbstractModel):
+    
+    def __init__(self, name, line_type, ip_capacity, reservation_length, reservation_time_unit, client_token=None, auto_renew_time=None, auto_renew_time_unit=None):
+        super().__init__()
+        self.client_token = client_token
+        self.name = name
+        self.line_type = line_type
+        self.ip_capacity = ip_capacity
+        self.reservation_length = reservation_length
+        self.reservation_time_unit = reservation_time_unit
+        self.auto_renew_time = auto_renew_time
+        self.auto_renew_time_unit = auto_renew_time_unit
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.name is not None:
+            result['name'] = self.name
+        if self.line_type is not None:
+            result['lineType'] = self.line_type
+        if self.ip_capacity is not None:
+            result['ipCapacity'] = self.ip_capacity
+        if self.reservation_length is not None:
+            result['reservationLength'] = self.reservation_length
+        if self.reservation_time_unit is not None:
+            result['reservationTimeUnit'] = self.reservation_time_unit
+        if self.auto_renew_time is not None:
+            result['autoRenewTime'] = self.auto_renew_time
+        if self.auto_renew_time_unit is not None:
+            result['autoRenewTimeUnit'] = self.auto_renew_time_unit
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('lineType') is not None:
+            self.line_type = m.get('lineType')
+        if m.get('ipCapacity') is not None:
+            self.ip_capacity = m.get('ipCapacity')
+        if m.get('reservationLength') is not None:
+            self.reservation_length = m.get('reservationLength')
+        if m.get('reservationTimeUnit') is not None:
+            self.reservation_time_unit = m.get('reservationTimeUnit')
+        if m.get('autoRenewTime') is not None:
+            self.auto_renew_time = m.get('autoRenewTime')
+        if m.get('autoRenewTimeUnit') is not None:
+            self.auto_renew_time_unit = m.get('autoRenewTimeUnit')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/create_tbsp_response.py

@@ -0,0 +1,27 @@
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+class CreateTbspResponse(BceResponse):
+    """
+    CreateTbspResponse
+    """
+    def __init__(self, id=None):
+        super().__init__()
+        self.id = id
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.metadata is not None:
+            result['metadata'] = self.metadata
+        if self.id is not None:
+            result['id'] = self.id
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        return self

baiducloud_python_sdk_eip-0.0.3/baiducloud_python_sdk_eip/models/detail_tbsp_request.py

@@ -0,0 +1,21 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class DetailTbspRequest(AbstractModel):
+    
+    def __init__(self, id):
+        super().__init__()
+        self.id = id
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('id') is not None:
+            self.id = m.get('id')
+        return self