baiducloud-python-sdk-vpc 0.0.3__py2.py3-none-any.whl

baiducloud_python_sdk_vpc/__init__.py

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

baiducloud_python_sdk_vpc/api/vpc_client.py

@@ -0,0 +1,225 @@
+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_vpc.models.create_a_reserved_network_segment_response import CreateAReservedNetworkSegmentResponse
+from baiducloud_python_sdk_vpc.models.create_subnet_response import CreateSubnetResponse
+from baiducloud_python_sdk_vpc.models.create_vpc_response import CreateVpcResponse
+from baiducloud_python_sdk_vpc.models.query_specified_subnet_response import QuerySpecifiedSubnetResponse
+from baiducloud_python_sdk_vpc.models.query_specified_vpc_response import QuerySpecifiedVpcResponse
+from baiducloud_python_sdk_vpc.models.query_subnet_list_response import QuerySubnetListResponse
+from baiducloud_python_sdk_vpc.models.query_the_ip_addresses_occupied_by_products_within_vpc_response import QueryTheIpAddressesOccupiedByProductsWithinVpcResponse
+from baiducloud_python_sdk_vpc.models.query_the_reserved_network_segment_list_response import QueryTheReservedNetworkSegmentListResponse
+from baiducloud_python_sdk_vpc.models.query_vpc_intranet_ip_response import QueryVpcIntranetIpResponse
+from baiducloud_python_sdk_vpc.models.query_vpc_list_response import QueryVpcListResponse
+
+_logger = logging.getLogger(__name__)
+
+
+class VpcClient(BceBaseClient):
+
+    VERSION_V1 = b'/v1'
+
+    CONSTANT_VPC = b'vpc'
+
+    CONSTANT_SHUTDOWN_RELAY = b'shutdownRelay'
+
+    CONSTANT_RESOURCE_IP = b'resourceIp'
+
+    CONSTANT_SUBNET = b'subnet'
+
+    CONSTANT_IPRESERVE = b'ipreserve'
+
+    CONSTANT_OPEN_RELAY = b'openRelay'
+
+    CONSTANT_PRIVATE_IP_ADDRESS_INFO = b'privateIpAddressInfo'
+
+    def __init__(self, config=None):
+        bce_base_client.BceBaseClient.__init__(self, config)
+
+    def close_vpc_relay(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, VpcClient.CONSTANT_SHUTDOWN_RELAY, request.vpc_id)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , params=params, config=config)
+
+    def create_a_reserved_network_segment(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, VpcClient.CONSTANT_IPRESERVE)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config, model=CreateAReservedNetworkSegmentResponse)
+
+    def create_subnet(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config, model=CreateSubnetResponse)
+
+    def create_vpc(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.POST, path=path
+                                , body=request.to_json_string(), params=params, config=config, model=CreateVpcResponse)
+
+    def delete_reserved_network_segment(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, VpcClient.CONSTANT_IPRESERVE, request.ip_reserve_id)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def delete_subnet(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, request.subnet_id)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def delete_vpc(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, request.vpc_id)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.DELETE, path=path
+                                , params=params, config=config)
+
+    def enable_vpc_relay(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, VpcClient.CONSTANT_OPEN_RELAY, request.vpc_id)
+        params = {
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , params=params, config=config)
+
+    def query_specified_subnet(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, request.subnet_id)
+        return self._send_request(http_methods.GET, path=path
+                                , config=config, model=QuerySpecifiedSubnetResponse)
+
+    def query_specified_vpc(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, request.vpc_id)
+        return self._send_request(http_methods.GET, path=path
+                                , config=config, model=QuerySpecifiedVpcResponse)
+
+    def query_subnet_list(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET)
+        params = {
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+            'vpcId' : request.vpc_id,
+            'zoneName' : request.zone_name,
+            'subnetType' : request.subnet_type,
+            'subnetIds' : request.subnet_ids,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=QuerySubnetListResponse)
+
+    def query_the_ip_addresses_occupied_by_products_within_vpc(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, VpcClient.CONSTANT_RESOURCE_IP)
+        params = {
+            'vpcId' : request.vpc_id,
+            'subnetId' : request.subnet_id,
+            'resourceType' : request.resource_type,
+            'pageNo' : request.page_no,
+            'pageSize' : request.page_size,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=QueryTheIpAddressesOccupiedByProductsWithinVpcResponse)
+
+    def query_the_reserved_network_segment_list(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, VpcClient.CONSTANT_IPRESERVE)
+        params = {
+            'subnetId' : request.subnet_id,
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=QueryTheReservedNetworkSegmentListResponse)
+
+    def query_vpc_intranet_ip(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, request.vpc_id, VpcClient.CONSTANT_PRIVATE_IP_ADDRESS_INFO)
+        params = {
+            'privateIpAddresses' : ','.join(request.private_ip_addresses) if request.private_ip_addresses else None,
+            'privateIpRange' : request.private_ip_range,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=QueryVpcIntranetIpResponse)
+
+    def query_vpc_list(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC)
+        params = {
+            'marker' : request.marker,
+            'maxKeys' : request.max_keys,
+            'isDefault' : request.is_default,
+            'vpcIds' : request.vpc_ids,
+        }
+        return self._send_request(http_methods.GET, path=path
+                                , params=params, config=config, model=QueryVpcListResponse)
+
+    def update_subnet(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_SUBNET, request.subnet_id)
+        params = {
+            'modifyAttribute' : None,
+            'clientToken' : request.client_token,
+        }
+        return self._send_request(http_methods.PUT, path=path
+                                , body=request.to_json_string(), params=params, config=config)
+
+    def update_vpc(self, request, config=None):
+        path = utils.append_uri(VpcClient.VERSION_V1, VpcClient.CONSTANT_VPC, request.vpc_id)
+        params = {
+            'modifyAttribute' : 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_vpc/models/close_vpc_relay_request.py

@@ -0,0 +1,24 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class CloseVpcRelayRequest(AbstractModel):
+    
+    def __init__(self, vpc_id, client_token=None):
+        super().__init__()
+        self.vpc_id = vpc_id
+        self.client_token = client_token
+
+    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('vpcId') is not None:
+            self.vpc_id = m.get('vpcId')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        return self

baiducloud_python_sdk_vpc/models/create_a_reserved_network_segment_request.py

@@ -0,0 +1,41 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class CreateAReservedNetworkSegmentRequest(AbstractModel):
+    
+    def __init__(self, subnet_id, ip_cidr, ip_version, client_token=None, description=None):
+        super().__init__()
+        self.client_token = client_token
+        self.subnet_id = subnet_id
+        self.ip_cidr = ip_cidr
+        self.ip_version = ip_version
+        self.description = description
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.subnet_id is not None:
+            result['subnetId'] = self.subnet_id
+        if self.ip_cidr is not None:
+            result['ipCidr'] = self.ip_cidr
+        if self.ip_version is not None:
+            result['ipVersion'] = self.ip_version
+        if self.description is not None:
+            result['description'] = self.description
+        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('subnetId') is not None:
+            self.subnet_id = m.get('subnetId')
+        if m.get('ipCidr') is not None:
+            self.ip_cidr = m.get('ipCidr')
+        if m.get('ipVersion') is not None:
+            self.ip_version = m.get('ipVersion')
+        if m.get('description') is not None:
+            self.description = m.get('description')
+        return self

baiducloud_python_sdk_vpc/models/create_a_reserved_network_segment_response.py

@@ -0,0 +1,27 @@
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+class CreateAReservedNetworkSegmentResponse(BceResponse):
+    """
+    CreateAReservedNetworkSegmentResponse
+    """
+    def __init__(self, ip_reserve_id=None):
+        super().__init__()
+        self.ip_reserve_id = ip_reserve_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.ip_reserve_id is not None:
+            result['ipReserveId'] = self.ip_reserve_id
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('ipReserveId') is not None:
+            self.ip_reserve_id = m.get('ipReserveId')
+        return self

baiducloud_python_sdk_vpc/models/create_subnet_request.py

@@ -0,0 +1,70 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+from baiducloud_python_sdk_vpc.models.tag_model import TagModel
+
+class CreateSubnetRequest(AbstractModel):
+    
+    def __init__(self, name, zone_name, cidr, vpc_id, client_token=None, enable_ipv6=None, vpc_secondary_cidr=None, subnet_type=None, description=None, tags=None):
+        super().__init__()
+        self.client_token = client_token
+        self.name = name
+        self.enable_ipv6 = enable_ipv6
+        self.zone_name = zone_name
+        self.cidr = cidr
+        self.vpc_id = vpc_id
+        self.vpc_secondary_cidr = vpc_secondary_cidr
+        self.subnet_type = subnet_type
+        self.description = description
+        self.tags = tags
+
+    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.enable_ipv6 is not None:
+            result['enableIpv6'] = self.enable_ipv6
+        if self.zone_name is not None:
+            result['zoneName'] = self.zone_name
+        if self.cidr is not None:
+            result['cidr'] = self.cidr
+        if self.vpc_id is not None:
+            result['vpcId'] = self.vpc_id
+        if self.vpc_secondary_cidr is not None:
+            result['vpcSecondaryCidr'] = self.vpc_secondary_cidr
+        if self.subnet_type is not None:
+            result['subnetType'] = self.subnet_type
+        if self.description is not None:
+            result['description'] = self.description
+        if self.tags is not None:
+            result['tags'] = [i.to_dict() for i in self.tags]
+        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('enableIpv6') is not None:
+            self.enable_ipv6 = m.get('enableIpv6')
+        if m.get('zoneName') is not None:
+            self.zone_name = m.get('zoneName')
+        if m.get('cidr') is not None:
+            self.cidr = m.get('cidr')
+        if m.get('vpcId') is not None:
+            self.vpc_id = m.get('vpcId')
+        if m.get('vpcSecondaryCidr') is not None:
+            self.vpc_secondary_cidr = m.get('vpcSecondaryCidr')
+        if m.get('subnetType') is not None:
+            self.subnet_type = m.get('subnetType')
+        if m.get('description') is not None:
+            self.description = m.get('description')
+        if m.get('tags') is not None:
+            self.tags = [
+            TagModel().from_dict(i)
+            for i in m.get('tags')
+            ]
+        return self

baiducloud_python_sdk_vpc/models/create_subnet_response.py

@@ -0,0 +1,27 @@
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+class CreateSubnetResponse(BceResponse):
+    """
+    CreateSubnetResponse
+    """
+    def __init__(self, subnet_id=None):
+        super().__init__()
+        self.subnet_id = subnet_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.subnet_id is not None:
+            result['subnetId'] = self.subnet_id
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('subnetId') is not None:
+            self.subnet_id = m.get('subnetId')
+        return self

baiducloud_python_sdk_vpc/models/create_vpc_request.py

@@ -0,0 +1,50 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+from baiducloud_python_sdk_vpc.models.tag_model import TagModel
+
+class CreateVpcRequest(AbstractModel):
+    
+    def __init__(self, name, cidr, client_token=None, description=None, enable_ipv6=None, tags=None):
+        super().__init__()
+        self.client_token = client_token
+        self.name = name
+        self.description = description
+        self.cidr = cidr
+        self.enable_ipv6 = enable_ipv6
+        self.tags = tags
+
+    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.description is not None:
+            result['description'] = self.description
+        if self.cidr is not None:
+            result['cidr'] = self.cidr
+        if self.enable_ipv6 is not None:
+            result['enableIpv6'] = self.enable_ipv6
+        if self.tags is not None:
+            result['tags'] = [i.to_dict() for i in self.tags]
+        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('description') is not None:
+            self.description = m.get('description')
+        if m.get('cidr') is not None:
+            self.cidr = m.get('cidr')
+        if m.get('enableIpv6') is not None:
+            self.enable_ipv6 = m.get('enableIpv6')
+        if m.get('tags') is not None:
+            self.tags = [
+            TagModel().from_dict(i)
+            for i in m.get('tags')
+            ]
+        return self

baiducloud_python_sdk_vpc/models/create_vpc_response.py

@@ -0,0 +1,27 @@
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+class CreateVpcResponse(BceResponse):
+    """
+    CreateVpcResponse
+    """
+    def __init__(self, vpc_id=None):
+        super().__init__()
+        self.vpc_id = vpc_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.vpc_id is not None:
+            result['vpcId'] = self.vpc_id
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('vpcId') is not None:
+            self.vpc_id = m.get('vpcId')
+        return self

baiducloud_python_sdk_vpc/models/delete_reserved_network_segment_request.py

@@ -0,0 +1,24 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class DeleteReservedNetworkSegmentRequest(AbstractModel):
+    
+    def __init__(self, ip_reserve_id, client_token=None):
+        super().__init__()
+        self.ip_reserve_id = ip_reserve_id
+        self.client_token = client_token
+
+    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('ipReserveId') is not None:
+            self.ip_reserve_id = m.get('ipReserveId')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        return self

baiducloud_python_sdk_vpc/models/delete_subnet_request.py

@@ -0,0 +1,24 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class DeleteSubnetRequest(AbstractModel):
+    
+    def __init__(self, subnet_id, client_token=None):
+        super().__init__()
+        self.subnet_id = subnet_id
+        self.client_token = client_token
+
+    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('subnetId') is not None:
+            self.subnet_id = m.get('subnetId')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        return self

baiducloud_python_sdk_vpc/models/delete_vpc_request.py

@@ -0,0 +1,24 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class DeleteVpcRequest(AbstractModel):
+    
+    def __init__(self, vpc_id, client_token=None):
+        super().__init__()
+        self.vpc_id = vpc_id
+        self.client_token = client_token
+
+    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('vpcId') is not None:
+            self.vpc_id = m.get('vpcId')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        return self

baiducloud_python_sdk_vpc/models/enable_vpc_relay_request.py

@@ -0,0 +1,24 @@
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+class EnableVpcRelayRequest(AbstractModel):
+    
+    def __init__(self, vpc_id, client_token=None):
+        super().__init__()
+        self.vpc_id = vpc_id
+        self.client_token = client_token
+
+    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('vpcId') is not None:
+            self.vpc_id = m.get('vpcId')
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
+        return self

baiducloud_python_sdk_vpc/models/ip_reserve.py

@@ -0,0 +1,57 @@
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class IpReserve(AbstractModel):
+    """
+    IpReserve
+    """
+    def __init__(self, ip_reserve_id=None, subnet_id=None, ip_cidr=None, ip_version=None, description=None, created_time=None, updated_time=None):
+        super().__init__()
+        self.ip_reserve_id = ip_reserve_id
+        self.subnet_id = subnet_id
+        self.ip_cidr = ip_cidr
+        self.ip_version = ip_version
+        self.description = description
+        self.created_time = created_time
+        self.updated_time = updated_time
+
+    def to_dict(self):
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.ip_reserve_id is not None:
+            result['ipReserveId'] = self.ip_reserve_id
+        if self.subnet_id is not None:
+            result['subnetId'] = self.subnet_id
+        if self.ip_cidr is not None:
+            result['ipCidr'] = self.ip_cidr
+        if self.ip_version is not None:
+            result['ipVersion'] = self.ip_version
+        if self.description is not None:
+            result['description'] = self.description
+        if self.created_time is not None:
+            result['createdTime'] = self.created_time
+        if self.updated_time is not None:
+            result['updatedTime'] = self.updated_time
+        return result
+
+
+    def from_dict(self, m):
+        m = m or dict()
+        if m.get('ipReserveId') is not None:
+            self.ip_reserve_id = m.get('ipReserveId')
+        if m.get('subnetId') is not None:
+            self.subnet_id = m.get('subnetId')
+        if m.get('ipCidr') is not None:
+            self.ip_cidr = m.get('ipCidr')
+        if m.get('ipVersion') is not None:
+            self.ip_version = m.get('ipVersion')
+        if m.get('description') is not None:
+            self.description = m.get('description')
+        if m.get('createdTime') is not None:
+            self.created_time = m.get('createdTime')
+        if m.get('updatedTime') is not None:
+            self.updated_time = m.get('updatedTime')
+        return self