zenlayercloud-sdk-python 2.0.67__tar.gz → 2.0.69__tar.gz

{zenlayercloud_sdk_python-2.0.67 → zenlayercloud_sdk_python-2.0.69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zenlayercloud-sdk-python
-Version: 2.0.67
+Version: 2.0.69
 Summary: Zenlayer Cloud SDK for Python
 Home-page: https://github.com/zenlayer/zenlayercloud-sdk-python
 Author: Zenlayer Cloud

{zenlayercloud_sdk_python-2.0.67 → zenlayercloud_sdk_python-2.0.69}/zenlayercloud/__init__.py

@@ -1,5 +1,5 @@
 #  Zenlayer.com Inc.
 #  Copyright (c) 2014-2023 All Rights Reserved.
 
-__version__ = "2.0.067"
+__version__ = "2.0.069"
 

{zenlayercloud_sdk_python-2.0.67 → zenlayercloud_sdk_python-2.0.69}/zenlayercloud/ipt/v20240901/ipt_client.py

@@ -10,16 +10,34 @@ class IptClient(AbstractClient):
 
     def DescribeIPTransitDatacenters(self, request):
         """
-        本接口用于连接IP Transit 服务支持的数据中心。
+        查询IP Transit可连接数据中心
         """
         response = self._api_call("DescribeIPTransitDatacenters", request)
         model = models.DescribeIPTransitDatacentersResponse()
         model._deserialize(response)
         return model
 
+    def DescribeIPTransitAvailableAsns(self, request):
+        """
+        查询IP Transit可用 ASN
+        """
+        response = self._api_call("DescribeIPTransitAvailableAsns", request)
+        model = models.DescribeIPTransitAvailableAsnsResponse()
+        model._deserialize(response)
+        return model
+
+    def DescribeIPTransitAvailableCidrBlocks(self, request):
+        """
+        查询IP Transit可用公网地址段
+        """
+        response = self._api_call("DescribeIPTransitAvailableCidrBlocks", request)
+        model = models.DescribeIPTransitAvailableCidrBlocksResponse()
+        model._deserialize(response)
+        return model
+
     def InquiryCreateIPTransitPrice(self, request):
         """
-        创建一条IP Transit 的询价。
+        iP Transit创建询价
         """
         response = self._api_call("InquiryCreateIPTransitPrice", request)
         model = models.InquiryCreateIPTransitPriceResponse()
@@ -28,7 +46,7 @@ class IptClient(AbstractClient):
 
     def CreateIPTransit(self, request):
         """
-        创建一条IP Transit。
+        创建IP Transit
         """
         response = self._api_call("CreateIPTransit", request)
         model = models.CreateIPTransitResponse()
@@ -37,7 +55,7 @@ class IptClient(AbstractClient):
 
     def DescribeIPTransits(self, request):
         """
-        本接口用于查询IP Transit资源列表。
+        查询IP Transit列表
         """
         response = self._api_call("DescribeIPTransits", request)
         model = models.DescribeIPTransitsResponse()
@@ -46,7 +64,7 @@ class IptClient(AbstractClient):
 
     def ModifyIPTransitBandwidth(self, request):
         """
-        修改一条IP Transit的带宽限速。
+        修改IP Transit带宽
         """
         response = self._api_call("ModifyIPTransitBandwidth", request)
         model = models.ModifyIPTransitBandwidthResponse()
@@ -55,7 +73,7 @@ class IptClient(AbstractClient):
 
     def ModifyIPTransitsAttribute(self, request):
         """
-        修改IP Transit的基本信息，包括名称和备注。
+        修改IP Transit属性
         """
         response = self._api_call("ModifyIPTransitsAttribute", request)
         model = models.ModifyIPTransitsAttributeResponse()
@@ -64,7 +82,7 @@ class IptClient(AbstractClient):
 
     def DeleteIPTransit(self, request):
         """
-        删除一条IP Transit。
+        删除IP Transit
         """
         response = self._api_call("DeleteIPTransit", request)
         model = models.DeleteIPTransitResponse()
@@ -73,10 +91,28 @@ class IptClient(AbstractClient):
 
     def DescribeIPTransitTraffic(self, request):
         """
-        查询IP Transit在指定时间段内的带宽数据。
+        查询IP Transit流量
         """
         response = self._api_call("DescribeIPTransitTraffic", request)
         model = models.DescribeIPTransitTrafficResponse()
         model._deserialize(response)
         return model
 
+    def InquiryModifyIPTransitPrice(self, request):
+        """
+        IP Transit变配询价
+        """
+        response = self._api_call("InquiryModifyIPTransitPrice", request)
+        model = models.InquiryModifyIPTransitPriceResponse()
+        model._deserialize(response)
+        return model
+
+    def ModifyIPTransitConfig(self, request):
+        """
+        修改IP Transit配置
+        """
+        response = self._api_call("ModifyIPTransitConfig", request)
+        model = models.ModifyIPTransitConfigResponse()
+        model._deserialize(response)
+        return model
+

{zenlayercloud_sdk_python-2.0.67 → zenlayercloud_sdk_python-2.0.69}/zenlayercloud/ipt/v20240901/models.py

@@ -7,10 +7,12 @@ class DescribeIPTransitDatacentersRequest(AbstractModel):
     def __init__(self):
         self.peerPortId = None
         self.peerDcId = None
+        self.zbgRegionId = None
 
     def _deserialize(self, params):
         self.peerPortId = params.get("peerPortId")
         self.peerDcId = params.get("peerDcId")
+        self.zbgRegionId = params.get("zbgRegionId")
 
 
 class DescribeIPTransitDatacentersResponse(AbstractModel):
@@ -82,11 +84,101 @@ class RemoteIptAvailableRoutingType(AbstractModel):
             self._deserialize(params)
             return
         self.routingType = None
+        self.availableBgpRouteTypes = None
         self.deliveryType = None
+        self.publicInterconnectNetmasks = None
 
     def _deserialize(self, params):
         self.routingType = params.get("routingType")
+        self.availableBgpRouteTypes = params.get("availableBgpRouteTypes")
         self.deliveryType = params.get("deliveryType")
+        self.publicInterconnectNetmasks = params.get("publicInterconnectNetmasks")
+
+
+class DescribeIPTransitAvailableAsnsRequest(AbstractModel):
+    def __init__(self):
+        pass
+
+    def _deserialize(self, params):
+        pass
+
+
+class DescribeIPTransitAvailableAsnsResponse(AbstractModel):
+    def __init__(self):
+        self.requestId = None
+        self.dataSet = None
+
+    def _deserialize(self, params):
+        self.requestId = params.get("requestId")
+        if params.get("dataSet") is not None:
+            self.dataSet = []
+            for item in params.get("dataSet"):
+                obj = AsnInfo(item)
+                self.dataSet.append(obj)
+
+
+class AsnInfo(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.asn = None
+        self.asnType = None
+
+    def _deserialize(self, params):
+        self.asn = params.get("asn")
+        self.asnType = params.get("asnType")
+
+
+class DescribeIPTransitAvailableCidrBlocksRequest(AbstractModel):
+    def __init__(self):
+        self.iptDcId = None
+        self.routingType = None
+        self.zbgRegionId = None
+        self.ipUuid = None
+
+    def _deserialize(self, params):
+        self.iptDcId = params.get("iptDcId")
+        self.routingType = params.get("routingType")
+        self.zbgRegionId = params.get("zbgRegionId")
+        self.ipUuid = params.get("ipUuid")
+
+
+class DescribeIPTransitAvailableCidrBlocksResponse(AbstractModel):
+    def __init__(self):
+        self.requestId = None
+        self.ipv4CidrBlocks = None
+        self.ipv6CidrBlocks = None
+
+    def _deserialize(self, params):
+        self.requestId = params.get("requestId")
+        if params.get("ipv4CidrBlocks") is not None:
+            self.ipv4CidrBlocks = []
+            for item in params.get("ipv4CidrBlocks"):
+                obj = CidrBlock(item)
+                self.ipv4CidrBlocks.append(obj)
+        if params.get("ipv6CidrBlocks") is not None:
+            self.ipv6CidrBlocks = []
+            for item in params.get("ipv6CidrBlocks"):
+                obj = CidrBlock(item)
+                self.ipv6CidrBlocks.append(obj)
+
+
+class CidrBlock(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.netmask = None
+        self.ipNetworkType = None
+
+    def _deserialize(self, params):
+        self.netmask = params.get("netmask")
+        self.ipNetworkType = params.get("ipNetworkType")
 
 
 class InquiryCreateIPTransitPriceRequest(AbstractModel):
@@ -99,6 +191,11 @@ class InquiryCreateIPTransitPriceRequest(AbstractModel):
         self.routingType = None
         self.publicIPv4BlockSize = None
         self.bgpRouteType = None
+        self.ipType = None
+        self.publicIpList = None
+        self.zbgRegionId = None
+        self.haConfig = None
+        self.publicInterconnectNetmask = None
 
     def _deserialize(self, params):
         self.peerPortId = params.get("peerPortId")
@@ -109,6 +206,52 @@ class InquiryCreateIPTransitPriceRequest(AbstractModel):
         self.routingType = params.get("routingType")
         self.publicIPv4BlockSize = params.get("publicIPv4BlockSize")
         self.bgpRouteType = params.get("bgpRouteType")
+        self.ipType = params.get("ipType")
+        if params.get("publicIpList") is not None:
+            self.publicIpList = []
+            for item in params.get("publicIpList"):
+                obj = IPTransitIpRequest(item)
+                self.publicIpList.append(obj)
+        self.zbgRegionId = params.get("zbgRegionId")
+        if params.get("haConfig") is not None:
+            self.haConfig = IPTransitHaConfig(params.get("haConfig"))
+        self.publicInterconnectNetmask = params.get("publicInterconnectNetmask")
+
+
+class IPTransitIpRequest(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.netmask = None
+        self.ipType = None
+        self.ipNetworkType = None
+        self.amount = None
+
+    def _deserialize(self, params):
+        self.netmask = params.get("netmask")
+        self.ipType = params.get("ipType")
+        self.ipNetworkType = params.get("ipNetworkType")
+        self.amount = params.get("amount")
+
+
+class IPTransitHaConfig(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.haMode = None
+        self.secondaryPortId = None
+        self.secondaryPortVlanId = None
+
+    def _deserialize(self, params):
+        self.haMode = params.get("haMode")
+        self.secondaryPortId = params.get("secondaryPortId")
+        self.secondaryPortVlanId = params.get("secondaryPortVlanId")
 
 
 class InquiryCreateIPTransitPriceResponse(AbstractModel):
@@ -117,6 +260,7 @@ class InquiryCreateIPTransitPriceResponse(AbstractModel):
         self.privateConnectPrice = None
         self.iptBandwidthPrice = None
         self.publicIpPrices = None
+        self.publicInterconnectIpPrice = None
 
     def _deserialize(self, params):
         self.requestId = params.get("requestId")
@@ -129,6 +273,8 @@ class InquiryCreateIPTransitPriceResponse(AbstractModel):
             for item in params.get("publicIpPrices"):
                 obj = IPPrice(item)
                 self.publicIpPrices.append(obj)
+        if params.get("publicInterconnectIpPrice") is not None:
+            self.publicInterconnectIpPrice = IPPrice(params.get("publicInterconnectIpPrice"))
 
 
 class PriceItem(AbstractModel):
@@ -199,12 +345,14 @@ class IPPrice(AbstractModel):
         self.price = None
         self.netmask = None
         self.qty = None
+        self.ipNetworkType = None
 
     def _deserialize(self, params):
         if params.get("price") is not None:
             self.price = PriceItem(params.get("price"))
         self.netmask = params.get("netmask")
         self.qty = params.get("qty")
+        self.ipNetworkType = params.get("ipNetworkType")
 
 
 class CreateIPTransitRequest(AbstractModel):
@@ -223,6 +371,10 @@ class CreateIPTransitRequest(AbstractModel):
         self.resourceGroupId = None
         self.bgp = None
         self.tags = None
+        self.publicIpList = None
+        self.zbgRegionId = None
+        self.haConfig = None
+        self.publicInterconnectNetmask = None
 
     def _deserialize(self, params):
         self.iptName = params.get("iptName")
@@ -242,6 +394,15 @@ class CreateIPTransitRequest(AbstractModel):
             self.bgp = RiptBgpConfig(params.get("bgp"))
         if params.get("tags") is not None:
             self.tags = TagAssociation(params.get("tags"))
+        if params.get("publicIpList") is not None:
+            self.publicIpList = []
+            for item in params.get("publicIpList"):
+                obj = IPTransitIpRequest(item)
+                self.publicIpList.append(obj)
+        self.zbgRegionId = params.get("zbgRegionId")
+        if params.get("haConfig") is not None:
+            self.haConfig = IPTransitHaConfig(params.get("haConfig"))
+        self.publicInterconnectNetmask = params.get("publicInterconnectNetmask")
 
 
 class BFDConfig(AbstractModel):
@@ -399,7 +560,13 @@ class IPTransit(AbstractModel):
         self.privateConnectName = None
         self.publicIpv4Addresses = None
         self.iptStatus = None
+        self.connectivityStatus = None
         self.tags = None
+        self.publicIpAddresses = None
+        self.haMode = None
+        self.zbgRegionId = None
+        self.peerPortType = None
+        self.haLinks = None
 
     def _deserialize(self, params):
         self.iptId = params.get("iptId")
@@ -433,8 +600,22 @@ class IPTransit(AbstractModel):
                 obj = IPAddress(item)
                 self.publicIpv4Addresses.append(obj)
         self.iptStatus = params.get("iptStatus")
+        self.connectivityStatus = params.get("connectivityStatus")
         if params.get("tags") is not None:
             self.tags = Tags(params.get("tags"))
+        if params.get("publicIpAddresses") is not None:
+            self.publicIpAddresses = []
+            for item in params.get("publicIpAddresses"):
+                obj = IPTransitIpAddress(item)
+                self.publicIpAddresses.append(obj)
+        self.haMode = params.get("haMode")
+        self.zbgRegionId = params.get("zbgRegionId")
+        self.peerPortType = params.get("peerPortType")
+        if params.get("haLinks") is not None:
+            self.haLinks = []
+            for item in params.get("haLinks"):
+                obj = HaLink(item)
+                self.haLinks.append(obj)
 
 
 class Interconnect(AbstractModel):
@@ -446,10 +627,14 @@ class Interconnect(AbstractModel):
             return
         self.vendorIpv4Address = None
         self.customerIpv4Address = None
+        self.vendorIpv6Address = None
+        self.customerIpv6Address = None
 
     def _deserialize(self, params):
         self.vendorIpv4Address = params.get("vendorIpv4Address")
         self.customerIpv4Address = params.get("customerIpv4Address")
+        self.vendorIpv6Address = params.get("vendorIpv6Address")
+        self.customerIpv6Address = params.get("customerIpv6Address")
 
 
 class IPAddress(AbstractModel):
@@ -486,6 +671,62 @@ class Tags(AbstractModel):
                 self.tags.append(obj)
 
 
+class IPTransitIpAddress(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.ipUuid = None
+        self.ipAddress = None
+        self.netmask = None
+        self.gatewayIpAddress = None
+        self.ipType = None
+        self.ipNetworkType = None
+
+    def _deserialize(self, params):
+        self.ipUuid = params.get("ipUuid")
+        self.ipAddress = params.get("ipAddress")
+        self.netmask = params.get("netmask")
+        self.gatewayIpAddress = params.get("gatewayIpAddress")
+        self.ipType = params.get("ipType")
+        self.ipNetworkType = params.get("ipNetworkType")
+
+
+class HaLink(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.isPrimary = None
+        self.iptStatus = None
+        self.connectivityStatus = None
+        self.privateConnectId = None
+        self.privateConnectName = None
+        self.peerPortId = None
+        self.peerPortName = None
+        self.peerDataCenter = None
+        self.peerPortVlan = None
+        self.interconnect = None
+
+    def _deserialize(self, params):
+        self.isPrimary = params.get("isPrimary")
+        self.iptStatus = params.get("iptStatus")
+        self.connectivityStatus = params.get("connectivityStatus")
+        self.privateConnectId = params.get("privateConnectId")
+        self.privateConnectName = params.get("privateConnectName")
+        self.peerPortId = params.get("peerPortId")
+        self.peerPortName = params.get("peerPortName")
+        if params.get("peerDataCenter") is not None:
+            self.peerDataCenter = DatacenterInfo(params.get("peerDataCenter"))
+        self.peerPortVlan = params.get("peerPortVlan")
+        if params.get("interconnect") is not None:
+            self.interconnect = Interconnect(params.get("interconnect"))
+
+
 class ModifyIPTransitBandwidthRequest(AbstractModel):
     def __init__(self):
         self.iptId = None
@@ -603,3 +844,121 @@ class TrafficData(AbstractModel):
         self.time = params.get("time")
 
 
+class InquiryModifyIPTransitPriceRequest(AbstractModel):
+    def __init__(self):
+        self.iptId = None
+        self.type = None
+        self.bandwidth = None
+        self.commitBandwidth = None
+        self.publicIPv4BlockSize = None
+        self.ipUuid = None
+        self.ipNetworkType = None
+
+    def _deserialize(self, params):
+        self.iptId = params.get("iptId")
+        self.type = params.get("type")
+        self.bandwidth = params.get("bandwidth")
+        self.commitBandwidth = params.get("commitBandwidth")
+        self.publicIPv4BlockSize = params.get("publicIPv4BlockSize")
+        self.ipUuid = params.get("ipUuid")
+        self.ipNetworkType = params.get("ipNetworkType")
+
+
+class InquiryModifyIPTransitPriceResponse(AbstractModel):
+    def __init__(self):
+        self.requestId = None
+        self.privateConnectPrice = None
+        self.privateConnectBandwidth = None
+        self.iptPrice = None
+        self.iptIpPrices = None
+        self.publicInterconnectIpPrice = None
+
+    def _deserialize(self, params):
+        self.requestId = params.get("requestId")
+        if params.get("privateConnectPrice") is not None:
+            self.privateConnectPrice = PriceItem(params.get("privateConnectPrice"))
+        self.privateConnectBandwidth = params.get("privateConnectBandwidth")
+        if params.get("iptPrice") is not None:
+            self.iptPrice = PriceItem(params.get("iptPrice"))
+        if params.get("iptIpPrices") is not None:
+            self.iptIpPrices = []
+            for item in params.get("iptIpPrices"):
+                obj = IPTransitIpPriceItem(item)
+                self.iptIpPrices.append(obj)
+        if params.get("publicInterconnectIpPrice") is not None:
+            self.publicInterconnectIpPrice = IPTransitIpPriceItem(params.get("publicInterconnectIpPrice"))
+
+
+class IPTransitIpPriceItem(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.price = None
+        self.netmask = None
+        self.amount = None
+        self.ipNetworkType = None
+
+    def _deserialize(self, params):
+        if params.get("price") is not None:
+            self.price = PriceItem(params.get("price"))
+        self.netmask = params.get("netmask")
+        self.amount = params.get("amount")
+        self.ipNetworkType = params.get("ipNetworkType")
+
+
+class ModifyIPTransitConfigRequest(AbstractModel):
+    def __init__(self):
+        self.iptId = None
+        self.type = None
+        self.bandwidth = None
+        self.commitBandwidth = None
+        self.bfd = None
+        self.bgp = None
+        self.publicIPv4BlockSize = None
+        self.ipUuid = None
+        self.ipNetworkType = None
+
+    def _deserialize(self, params):
+        self.iptId = params.get("iptId")
+        self.type = params.get("type")
+        self.bandwidth = params.get("bandwidth")
+        self.commitBandwidth = params.get("commitBandwidth")
+        if params.get("bfd") is not None:
+            self.bfd = BFDConfig(params.get("bfd"))
+        if params.get("bgp") is not None:
+            self.bgp = BgpConfigParam(params.get("bgp"))
+        self.publicIPv4BlockSize = params.get("publicIPv4BlockSize")
+        self.ipUuid = params.get("ipUuid")
+        self.ipNetworkType = params.get("ipNetworkType")
+
+
+class BgpConfigParam(AbstractModel):
+    def __init__(self, params=None):
+        if params is None:
+            params = {}
+        if len(params) > 0:
+            self._deserialize(params)
+            return
+        self.routeType = None
+        self.asnList = None
+        self.asSetList = None
+        self.password = None
+
+    def _deserialize(self, params):
+        self.routeType = params.get("routeType")
+        self.asnList = params.get("asnList")
+        self.asSetList = params.get("asSetList")
+        self.password = params.get("password")
+
+
+class ModifyIPTransitConfigResponse(AbstractModel):
+    def __init__(self):
+        self.requestId = None
+
+    def _deserialize(self, params):
+        self.requestId = params.get("requestId")
+
+