linode-api4 5.46.0__tar.gz → 5.47.0__tar.gz

{linode_api4-5.46.0/linode_api4.egg-info → linode_api4-5.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linode_api4
-Version: 5.46.0
+Version: 5.47.0
 Summary: The official Python SDK for Linode API v4
 Author-email: Linode <devs@linode.com>
 License: BSD-3-Clause

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/groups/vpc.py

@@ -11,6 +11,7 @@ from linode_api4.objects import (
     VPCIPv6RangeOptions,
 )
 from linode_api4.objects.base import _flatten_request_body_recursive
+from linode_api4.objects.vpc import VPCType
 from linode_api4.paginated_list import PaginatedList
 from linode_api4.util import drop_null_keys
 
@@ -44,6 +45,7 @@ class VPCGroup(Group):
         subnets: Optional[List[Dict[str, Any]]] = None,
         ipv6: Optional[List[Union[VPCIPv6RangeOptions, Dict[str, Any]]]] = None,
         ipv4: Optional[List[Union[VPCIPv4RangeOptions, Dict[str, Any]]]] = None,
+        vpc_type: Optional[Union[VPCType, str]] = None,
         **kwargs,
     ) -> VPC:
         """
@@ -61,6 +63,11 @@ class VPCGroup(Group):
         :type subnets: List[Dict[str, Any]]
         :param ipv6: The IPv6 address ranges for this VPC.
         :type ipv6: List[Union[VPCIPv6RangeOptions, Dict[str, Any]]]
+        :param vpc_type: The type of VPC to create. Defaults to ``regular`` on
+                         the API side. Set to ``rdma`` to create a GPUDirect
+                         RDMA VPC (requires the ``GPUDirect RDMA`` account
+                         capability).
+        :type vpc_type: Optional[Union[VPCType, str]]
         :param ipv4: The IPv4 address ranges for this VPC. Note that IPv4 VPCs may not currently be available to all users.
         :type ipv4: List[Union[VPCIPv4RangeOptions, Dict[str, Any]]]
 
@@ -74,6 +81,7 @@ class VPCGroup(Group):
             "ipv4": ipv4,
             "ipv6": ipv6,
             "subnets": subnets,
+            "vpc_type": vpc_type,
         }
 
         if subnets is not None and len(subnets) > 0:

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/login_client.py

@@ -30,10 +30,11 @@ class OAuthScopes:
     Lists of OAuth Scopes are accepted when calling the :any:`generate_login_url`
     method of the :any:`LinodeLoginClient`.
 
-    All contained enumerations of OAuth Scopes have two levels, "read_only" and
+    Most contained enumerations of OAuth Scopes have two levels, "read_only" and
     "read_write".  "read_only" access grants you the ability to get resources and
     of that type, but not to change, create, or delete them.  "read_write" access
-    allows to full access to resources of the requested type.  In the above
+    allows to full access to resources of the requested type.  :any:`OAuthScopes.VPC`
+    is the exception and exposes only "read_write" and "all".  In the above
     example, you are requesting access to view, modify, create, and delete
     Linodes, and to view Domains.
     """
@@ -254,6 +255,47 @@ class OAuthScopes:
                 return "longview:*"
             return "longview:{}".format(self.name)
 
+    class Images(Enum):
+        """
+        Access to Images
+        """
+
+        read_only = 0
+        read_write = 1
+        all = 2
+
+        def __repr__(self):
+            if self.name == "all":
+                return "images:*"
+            return "images:{}".format(self.name)
+
+    class Databases(Enum):
+        """
+        Access to Managed Databases
+        """
+
+        read_only = 0
+        read_write = 1
+        all = 2
+
+        def __repr__(self):
+            if self.name == "all":
+                return "databases:*"
+            return "databases:{}".format(self.name)
+
+    class VPC(Enum):
+        """
+        Access to VPCs and subnets
+        """
+
+        read_write = 1
+        all = 2
+
+        def __repr__(self):
+            if self.name == "all":
+                return "vpc:*"
+            return "vpc:{}".format(self.name)
+
     _scope_families = {
         "linodes": Linodes,
         "domains": Domains,
@@ -271,6 +313,9 @@ class OAuthScopes:
         "object_storage": ObjectStorage,
         "nodebalancers": NodeBalancers,
         "longview": Longview,
+        "images": Images,
+        "databases": Databases,
+        "vpc": VPC,
     }
 
     @staticmethod

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/objects/linode.py

@@ -2115,10 +2115,22 @@ class Instance(Base):
         :param vpc: The VPC-specific configuration of the new interface.
                     If set, the new instance will be a VPC interface.
 
+        .. note::
+           RDMA VPC interfaces (``rdma_vpc``) cannot be added via this
+           endpoint. They may only be specified at instance creation time via
+           :func:`linode_api4.LinodeGroup.instance_create`.
+
         :returns: The newly created Linode Interface.
         :rtype: LinodeInterface
         """
 
+        if kwargs.get("rdma_vpc") is not None:
+            raise ValueError(
+                "RDMA VPC interfaces (rdma_vpc) cannot be added via "
+                "interface_create(). They may only be specified at instance "
+                "creation time via LinodeGroup.instance_create()."
+            )
+
         params = {
             "firewall_id": firewall,
             "default_route": default_route,

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/objects/linode_interfaces.py

@@ -187,6 +187,47 @@ class LinodeInterfaceVLANOptions(JSONObject):
     ipam_address: Optional[str] = None
 
 
+@dataclass
+class LinodeInterfaceRDMAVPCIPv4AddressOptions(JSONObject):
+    """
+    Options accepted for a single address when creating or updating the IPv4
+    configuration of an RDMA VPC Linode Interface.
+
+    Only one address is supported per RDMA VPC interface, and it must be
+    marked as primary.
+    """
+
+    address: Optional[str] = None
+    primary: Optional[bool] = None
+
+
+@dataclass
+class LinodeInterfaceRDMAVPCIPv4Options(JSONObject):
+    """
+    Options accepted when creating or updating the IPv4 configuration of an
+    RDMA VPC Linode Interface.
+
+    The ``addresses`` list MUST contain exactly one element. If omitted, the
+    API defaults to a single primary ``auto`` address.
+    """
+
+    addresses: Optional[List[LinodeInterfaceRDMAVPCIPv4AddressOptions]] = None
+
+
+@dataclass
+class LinodeInterfaceRDMAVPCOptions(JSONObject):
+    """
+    RDMA-VPC-exclusive options accepted when creating or updating a Linode
+    Interface.
+
+    Used for GPUDirect RDMA interfaces. Default routes and NAT 1:1 addresses
+    are not supported on RDMA VPC interfaces.
+    """
+
+    subnet_id: int = 0
+    ipv4: Optional[LinodeInterfaceRDMAVPCIPv4Options] = None
+
+
 @dataclass
 class LinodeInterfaceOptions(JSONObject):
     """
@@ -204,6 +245,7 @@ class LinodeInterfaceOptions(JSONObject):
     vpc: Optional[LinodeInterfaceVPCOptions] = None
     public: Optional[LinodeInterfacePublicOptions] = None
     vlan: Optional[LinodeInterfaceVLANOptions] = None
+    rdma_vpc: Optional[LinodeInterfaceRDMAVPCOptions] = None
 
 
 # Interface GET Response
@@ -409,6 +451,45 @@ class LinodeInterfaceVLAN(JSONObject):
     ipam_address: Optional[str] = None
 
 
+@dataclass
+class LinodeInterfaceRDMAVPCIPv4Address(JSONObject):
+    """
+    A single address under the IPv4 configuration of an RDMA VPC Linode Interface.
+    """
+
+    put_class = LinodeInterfaceRDMAVPCIPv4AddressOptions
+
+    address: str = ""
+    primary: bool = False
+
+
+@dataclass
+class LinodeInterfaceRDMAVPCIPv4(JSONObject):
+    """
+    The IPv4 configuration of an RDMA VPC Linode Interface.
+    """
+
+    put_class = LinodeInterfaceRDMAVPCIPv4Options
+
+    addresses: List[LinodeInterfaceRDMAVPCIPv4Address] = field(
+        default_factory=list
+    )
+
+
+@dataclass
+class LinodeInterfaceRDMAVPC(JSONObject):
+    """
+    RDMA VPC-specific configuration field for a Linode Interface.
+    """
+
+    put_class = LinodeInterfaceRDMAVPCOptions
+
+    vpc_id: int = 0
+    subnet_id: int = 0
+
+    ipv4: Optional[LinodeInterfaceRDMAVPCIPv4] = None
+
+
 class LinodeInterface(DerivedBase):
     """
     A Linode's network interface.
@@ -449,6 +530,7 @@ class LinodeInterface(DerivedBase):
         "public": Property(mutable=True, json_object=LinodeInterfacePublic),
         "vlan": Property(mutable=True, json_object=LinodeInterfaceVLAN),
         "vpc": Property(mutable=True, json_object=LinodeInterfaceVPC),
+        "rdma_vpc": Property(mutable=True, json_object=LinodeInterfaceRDMAVPC),
     }
 
     def firewalls(self, *filters) -> List[Firewall]:

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/objects/region.py

@@ -67,6 +67,7 @@ class Capability(StrEnum):
     ruleset = "Cloud Firewall Rule Set"
     prefixlists = "Cloud Firewall Prefix Lists"
     current_prefixlists = "Cloud Firewall Prefix List Current References"
+    gpudirect_rdma = "GPUDirect RDMA"
 
 
 @dataclass

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/objects/vpc.py

@@ -5,11 +5,20 @@ from linode_api4.errors import UnexpectedResponseError
 from linode_api4.objects import Base, DerivedBase, Property, Region
 from linode_api4.objects.base import _flatten_request_body_recursive
 from linode_api4.objects.networking import VPCIPAddress
-from linode_api4.objects.serializable import JSONObject
+from linode_api4.objects.serializable import JSONObject, StrEnum
 from linode_api4.paginated_list import PaginatedList
 from linode_api4.util import drop_null_keys
 
 
+class VPCType(StrEnum):
+    """
+    VPCType represents the supported VPC types.
+    """
+
+    regular = "regular"
+    rdma = "rdma"
+
+
 @dataclass
 class VPCIPv4DefaultRange(JSONObject):
     """
@@ -119,6 +128,7 @@ class VPCSubnet(DerivedBase):
         "ipv6": Property(json_object=VPCSubnetIPv6Range, unordered=True),
         "linodes": Property(json_object=VPCSubnetLinode, unordered=True),
         "databases": Property(json_object=VPCSubnetDatabase, unordered=True),
+        "vpc_type": Property(),
         "created": Property(is_datetime=True),
         "updated": Property(is_datetime=True),
     }
@@ -144,6 +154,7 @@ class VPC(Base):
         ),
         "ipv6": Property(json_object=VPCIPv6Range, unordered=True),
         "subnets": Property(derived_class=VPCSubnet),
+        "vpc_type": Property(),
         "created": Property(is_datetime=True),
         "updated": Property(is_datetime=True),
     }

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4/version.py

@@ -2,4 +2,4 @@
 The version of this linode_api4 package.
 """
 
-__version__ = "v5.46.0"
+__version__ = "v5.47.0"

{linode_api4-5.46.0 → linode_api4-5.47.0/linode_api4.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linode_api4
-Version: 5.46.0
+Version: 5.47.0
 Summary: The official Python SDK for Linode API v4
 Author-email: Linode <devs@linode.com>
 License: BSD-3-Clause

{linode_api4-5.46.0 → linode_api4-5.47.0}/linode_api4.egg-info/SOURCES.txt

@@ -165,6 +165,7 @@ test/fixtures/linode_instances_124_interfaces_123.json
 test/fixtures/linode_instances_124_interfaces_123_firewalls.json
 test/fixtures/linode_instances_124_interfaces_456.json
 test/fixtures/linode_instances_124_interfaces_789.json
+test/fixtures/linode_instances_124_interfaces_999.json
 test/fixtures/linode_instances_124_interfaces_settings.json
 test/fixtures/linode_instances_124_upgrade-interfaces.json
 test/fixtures/linode_stackscripts_10079.json

linode_api4-5.47.0/test/fixtures/linode_instances_124_interfaces_999.json

@@ -0,0 +1,27 @@
+{
+    "id": 999,
+    "mac_address": "22:00:f2:9e:d3:48",
+    "created": "2026-03-12T09:54:34",
+    "updated": "2026-03-12T09:54:35",
+    "default_route": {
+        "ipv4": false,
+        "ipv6": false
+    },
+    "version": 1,
+    "public": null,
+    "vpc": null,
+    "vlan": null,
+    "rdma_vpc": {
+        "vpc_id": 7,
+        "subnet_id": 8,
+        "ipv4": {
+            "addresses": [
+                {
+                    "address": "10.0.0.2",
+                    "primary": true
+                }
+            ]
+        }
+    }
+}
+

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/fixtures/vpcs.json

@@ -5,6 +5,7 @@
       "id": 123456,
       "description": "A very real VPC.",
       "region": "us-southeast",
+      "vpc_type": "regular",
       "ipv4": [
         {
           "range": "10.0.0.0/8"

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/fixtures/vpcs_123456.json

@@ -3,6 +3,7 @@
   "id": 123456,
   "description": "A very real VPC.",
   "region": "us-southeast",
+  "vpc_type": "regular",
   "ipv4": [
     {
       "range": "10.0.0.0/8"

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/fixtures/vpcs_123456_subnets.json

@@ -35,6 +35,7 @@
           ]
         }
       ],
+      "vpc_type": "regular",
       "created": "2018-01-01T00:01:01",
       "updated": "2018-01-01T00:01:01"
     }

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/fixtures/vpcs_123456_subnets_789.json

@@ -7,6 +7,7 @@
       "range": "fd71:1140:a9d0::/52"
     }
   ],
+  "vpc_type": "regular",
   "linodes": [
     {
       "id": 12345,

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/integration/conftest.py

@@ -286,6 +286,7 @@ def test_linode_client():
         token,
         base_url=api_url,
         ca_path=api_ca_file,
+        retry_statuses=[504],
     )
     return client
 
@@ -316,7 +317,7 @@ def test_domain(test_linode_client):
         domain.invalidate()
         return domain.status == "active"
 
-    wait_for_condition(3, 30, get_domain_status)
+    wait_for_condition(3, 45, get_domain_status)
 
     # Create a SRV record
     domain.record_create(
@@ -467,7 +468,6 @@ def test_oauth_client(test_linode_client):
 @pytest.fixture(scope="session")
 def create_vpc(test_linode_client):
     client = test_linode_client
-
     label = get_test_label(length=10)
 
     vpc = client.vpcs.create(
@@ -479,6 +479,7 @@ def create_vpc(test_linode_client):
                 "VPC IPv6 Stack",
                 "Linode Interfaces",
                 "Custom VPC IPv4 Ranges",
+                "Linodes",
             },
         ),
         description="test description",
@@ -489,6 +490,27 @@ def create_vpc(test_linode_client):
     vpc.delete()
 
 
+@pytest.fixture
+def create_vpc_with_rdma_type(test_linode_client):
+    client = test_linode_client
+    label = get_test_label(length=10)
+
+    # GPUDirect RDMA capability not available for now
+    region = get_region(
+        test_linode_client, {"VPCs", "VPC IPv6 Stack", "Linode Interfaces"}
+    )
+
+    vpc = client.vpcs.create(
+        label=label,
+        region=region,
+        description="test description",
+        vpc_type="rdma",
+    )
+    yield vpc
+
+    vpc.delete()
+
+
 @pytest.fixture(scope="session")
 def create_vpc_with_subnet(test_linode_client, create_vpc):
     subnet = create_vpc.subnet_create(
@@ -524,6 +546,21 @@ def create_vpc_with_subnet_and_linode(
     instance.delete()
 
 
+@pytest.fixture
+def create_vpc_with_subnet_and_rdma_type(create_vpc_with_rdma_type):
+    vpc_rdma = create_vpc_with_rdma_type
+    label = get_test_label(length=10)
+
+    subnet_rdma = vpc_rdma.subnet_create(
+        label=label,
+        ipv4="10.0.0.0/24",
+    )
+
+    yield vpc_rdma, subnet_rdma
+
+    subnet_rdma.delete()
+
+
 @pytest.fixture
 def create_vpc_with_ipv4(test_linode_client):
     client = test_linode_client

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/integration/models/account/test_account.py

@@ -39,6 +39,9 @@ def test_get_account(test_linode_client):
     assert account_get.tax_id == account.tax_id
 
 
+@pytest.mark.skip(
+    reason="Test fails for E2E test user with [504] Server Timeout due to enormous amount of logins. More details: ARB-7420"
+)
 def test_get_login(test_linode_client):
     client = test_linode_client
     login = retry_sending_request(3, client.load, Login(client, "", {}), "")
@@ -91,6 +94,8 @@ def test_update_maintenance_policy(test_linode_client):
     assert updated.maintenance_policy == original_policy
 
 
+# May fail due to multiple events occurring on the test user in the same time
+@pytest.mark.flaky(reruns=2, reruns_delay=5)
 @pytest.mark.smoke
 def test_latest_get_event(test_linode_client, e2e_test_firewall):
     client = test_linode_client
@@ -115,7 +120,7 @@ def test_latest_get_event(test_linode_client, e2e_test_firewall):
     wait_for_condition(5, 150, get_linode_status)
 
     events = client.load(Event, "")
-    latest_events = events._raw_json.get("data")[:15]
+    latest_events = events._raw_json.get("data")[:50]
 
     linode.delete()
 
@@ -123,7 +128,7 @@ def test_latest_get_event(test_linode_client, e2e_test_firewall):
         if label == event["entity"]["label"]:
             break
     else:
-        assert False, f"Linode '{label}' not found in the last 15 events"
+        assert False, f"Linode '{label}' not found in the last 50 events"
 
 
 def test_get_user(test_linode_client):

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/integration/models/image/test_image.py

@@ -43,12 +43,10 @@ def image_upload_url(test_linode_client):
 
     region = get_image_upload_regions(test_linode_client)[0]
 
-    test_linode_client.image_create_upload(
+    image, _ = test_linode_client.image_create_upload(
         label, region.id, "integration test image upload"
     )
 
-    image = test_linode_client.images()[0]
-
     yield image
 
     image.delete()

{linode_api4-5.46.0 → linode_api4-5.47.0}/test/integration/models/linode/interfaces/test_interfaces.py

@@ -1,6 +1,7 @@
 import copy
 import ipaddress
-from test.integration.helpers import get_test_label
+import os
+from test.integration.helpers import get_test_label, wait_for_condition
 
 import pytest
 
@@ -16,6 +17,9 @@ from linode_api4 import (
     LinodeInterfacePublicIPv6Options,
     LinodeInterfacePublicIPv6RangeOptions,
     LinodeInterfacePublicOptions,
+    LinodeInterfaceRDMAVPCIPv4AddressOptions,
+    LinodeInterfaceRDMAVPCIPv4Options,
+    LinodeInterfaceRDMAVPCOptions,
     LinodeInterfaceVLANOptions,
     LinodeInterfaceVPCIPv4AddressOptions,
     LinodeInterfaceVPCIPv4Options,
@@ -43,6 +47,22 @@ def build_interface_public_ipv4(firewall, ip_address):
     )
 
 
+def build_interface_rdma_vpc_ipv4(subnet_id: int):
+    return LinodeInterfaceOptions(
+        firewall_id=-1,
+        rdma_vpc=LinodeInterfaceRDMAVPCOptions(
+            subnet_id=subnet_id,
+            ipv4=LinodeInterfaceRDMAVPCIPv4Options(
+                addresses=[
+                    LinodeInterfaceRDMAVPCIPv4AddressOptions(
+                        address="auto", primary=True
+                    )
+                ]
+            ),
+        ),
+    )
+
+
 def create_linode_with_legacy_config(
     client, ip_address, label, firewall, authorized_key
 ):
@@ -75,6 +95,22 @@ def create_linode_with_standard_interfaces(
     return linode
 
 
+def create_multiple_rdma_interfaces(amount: int, subnet_id: int):
+    """
+    Creates multiple VPC RDMA interfaces that may be needed for RDMA Linode instance
+
+    Note:
+    At least 8 separate VPC RDMA interfaces need to be created for a single RDMA linode instance
+    """
+    interfaces = list()
+
+    for _ in range(amount):
+        rdma_iface = build_interface_rdma_vpc_ipv4(subnet_id)
+        interfaces.append(rdma_iface)
+
+    return interfaces
+
+
 def test_linode_create_with_linode_interfaces(
     create_vpc_with_subnet,
     linode_with_linode_interfaces,
@@ -458,3 +494,88 @@ def test_linode_interfaces_with_reserved_ips(
     assert reserved_ips_list[0].reserved == True
     assert reserved_ips_list[0].linode_id is None
     assert reserved_ips_list[0].assigned_entity is None
+
+
+@pytest.mark.skipif(
+    os.getenv("RUN_RDMA_TESTS", "").strip().lower() not in {"yes", "true"},
+    reason="Linode with RDMA interfaces requires manual infra changes; set RUN_RDMA_TESTS=yes to enable",
+)
+def test_linode_interfaces_with_rdma_vpc_type(
+    request,
+    test_linode_client,
+):
+    client = test_linode_client
+    region = "us-rno-1"
+
+    # Create a regular VPC with a subnet in us-rno-1
+    vpc = client.vpcs.create(
+        label=get_test_label(length=10),
+        region=region,
+        description="test description",
+        ipv6=[{"range": "auto"}],
+    )
+    request.addfinalizer(vpc.delete)
+    subnet = vpc.subnet_create(
+        label="test-subnet",
+        ipv4="10.0.0.0/24",
+        ipv6=[{"range": "auto"}],
+    )
+    request.addfinalizer(subnet.delete)
+
+    # Create an RDMA VPC with a subnet in us-rno-1
+    vpc_rdma = client.vpcs.create(
+        label=get_test_label(length=10),
+        region=region,
+        description="test description",
+        vpc_type="rdma",
+    )
+    request.addfinalizer(vpc_rdma.delete)
+    subnet_rdma = vpc_rdma.subnet_create(
+        label=get_test_label(length=10),
+        ipv4="10.0.0.0/24",
+    )
+    request.addfinalizer(subnet_rdma.delete)
+
+    # Include RDMA VPC interfaces
+    multi_ifaces = create_multiple_rdma_interfaces(8, subnet_rdma.id)
+
+    # Include (at least one) regular interface
+    multi_ifaces.append(
+        LinodeInterfaceOptions(
+            firewall_id=-1,
+            default_route=LinodeInterfaceDefaultRouteOptions(
+                ipv4=True,
+            ),
+            vpc=LinodeInterfaceVPCOptions(
+                subnet_id=subnet.id,
+                ipv4=LinodeInterfaceVPCIPv4Options(
+                    addresses=[
+                        LinodeInterfaceVPCIPv4AddressOptions(
+                            address="auto",
+                            primary=True,
+                        )
+                    ],
+                ),
+            ),
+        ),
+    )
+
+    instance = client.linode.instance_create(
+        label="python-test-rdma-" + get_test_label(),
+        root_pass="aComplex@Password123",
+        image="linode/ubuntu24.04",
+        region=vpc.region,
+        ltype="g3-gpu-rtxpro6000-blackwell-rdma-8",
+        interface_generation=InterfaceGeneration.LINODE,
+        interfaces=multi_ifaces,
+        booted=False,
+    )
+    request.addfinalizer(instance.delete)
+
+    def get_linode_status():
+        instance.invalidate()
+        return instance.status == "offline"
+
+    wait_for_condition(5, 180, get_linode_status)
+
+    assert len(instance.linode_interfaces) == len(multi_ifaces)