linode-api4 5.40.0__tar.gz → 5.42.0__tar.gz

{linode_api4-5.40.0/linode_api4.egg-info → linode_api4-5.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linode_api4
-Version: 5.40.0
+Version: 5.42.0
 Summary: The official Python SDK for Linode API v4
 Author-email: Linode <devs@linode.com>
 License: BSD-3-Clause
@@ -14,11 +14,12 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: requests

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/common.py

@@ -1,5 +1,5 @@
-import os
 from dataclasses import dataclass
+from pathlib import Path
 
 from linode_api4.objects import JSONObject
 
@@ -47,9 +47,9 @@ def load_and_validate_keys(authorized_keys):
             ret.append(k)
         else:
             # it doesn't appear to be a key.. is it a path to the key?
-            k = os.path.expanduser(k)
-            if os.path.isfile(k):
-                with open(k) as f:
+            k_path = Path(k).expanduser()
+            if k_path.is_file():
+                with open(k_path) as f:
                     ret.append(f.read().rstrip())
             else:
                 raise ValueError(

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/groups/linode.py

@@ -1,5 +1,5 @@
 import base64
-import os
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 from linode_api4.common import load_and_validate_keys
@@ -457,8 +457,9 @@ class LinodeGroup(Group):
         script_body = script
         if not script.startswith("#!"):
             # it doesn't look like a stackscript body, let's see if it's a file
-            if os.path.isfile(script):
-                with open(script) as f:
+            script_path = Path(script)
+            if script_path.is_file():
+                with open(script_path) as f:
                     script_body = f.read()
             else:
                 raise ValueError(

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/groups/profile.py

@@ -1,5 +1,5 @@
-import os
 from datetime import datetime
+from pathlib import Path
 
 from linode_api4 import UnexpectedResponseError
 from linode_api4.common import SSH_KEY_TYPES
@@ -322,9 +322,9 @@ class ProfileGroup(Group):
         """
         if not key.startswith(SSH_KEY_TYPES):
             # this might be a file path - look for it
-            path = os.path.expanduser(key)
-            if os.path.isfile(path):
-                with open(path) as f:
+            key_path = Path(key).expanduser()
+            if key_path.is_file():
+                with open(key_path) as f:
                     key = f.read().strip()
             if not key.startswith(SSH_KEY_TYPES):
                 raise ValueError("Invalid SSH Public Key")

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/groups/region.py

@@ -1,6 +1,9 @@
 from linode_api4.groups import Group
 from linode_api4.objects import Region
-from linode_api4.objects.region import RegionAvailabilityEntry
+from linode_api4.objects.region import (
+    RegionAvailabilityEntry,
+    RegionVPCAvailability,
+)
 
 
 class RegionGroup(Group):
@@ -43,3 +46,34 @@ class RegionGroup(Group):
         return self.client._get_and_filter(
             RegionAvailabilityEntry, *filters, endpoint="/regions/availability"
         )
+
+    def vpc_availability(self, *filters):
+        """
+        Returns VPC availability data for all regions.
+
+        NOTE: IPv6 VPCs may not currently be available to all users.
+
+        This endpoint supports pagination with the following parameters:
+        - page: Page number (>= 1)
+        - page_size: Number of items per page (25-500)
+
+        Pagination is handled automatically by PaginatedList. To configure page_size,
+        set it when creating the LinodeClient:
+
+            client = LinodeClient(token, page_size=100)
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/get-regions-vpc-availability
+
+        :param filters: Any number of filters to apply to this query.
+                        See :doc:`Filtering Collections</linode_api4/objects/filtering>`
+                        for more details on filtering.
+
+        :returns: A list of VPC availability data for regions.
+        :rtype: PaginatedList of RegionVPCAvailability
+        """
+
+        return self.client._get_and_filter(
+            RegionVPCAvailability,
+            *filters,
+            endpoint="/regions/vpc-availability",
+        )

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/objects/database.py

@@ -1,11 +1,8 @@
 from dataclasses import dataclass, field
 from typing import Optional
 
-from deprecated import deprecated
-
 from linode_api4.objects import (
     Base,
-    DerivedBase,
     JSONObject,
     MappedObject,
     Property,
@@ -86,69 +83,6 @@ class DatabasePrivateNetwork(JSONObject):
     public_access: Optional[bool] = None
 
 
-@deprecated(
-    reason="Backups are not supported for non-legacy database clusters."
-)
-class DatabaseBackup(DerivedBase):
-    """
-    A generic Managed Database backup.
-
-    This class is not intended to be used on its own.
-    Use the appropriate subclasses for the corresponding database engine. (e.g. MySQLDatabaseBackup)
-    """
-
-    api_endpoint = ""
-    derived_url_path = "backups"
-    parent_id_name = "database_id"
-
-    properties = {
-        "created": Property(is_datetime=True),
-        "id": Property(identifier=True),
-        "label": Property(),
-        "type": Property(),
-    }
-
-    def restore(self):
-        """
-        Restore a backup to a Managed Database on your Account.
-
-        API Documentation:
-
-            - MySQL: https://techdocs.akamai.com/linode-api/reference/post-databases-mysql-instance-backup-restore
-            - PostgreSQL: https://techdocs.akamai.com/linode-api/reference/post-databases-postgre-sql-instance-backup-restore
-        """
-
-        return self._client.post(
-            "{}/restore".format(self.api_endpoint), model=self
-        )
-
-
-@deprecated(
-    reason="Backups are not supported for non-legacy database clusters."
-)
-class MySQLDatabaseBackup(DatabaseBackup):
-    """
-    A backup for an accessible Managed MySQL Database.
-
-    API Documentation: https://techdocs.akamai.com/linode-api/reference/get-databases-mysql-instance-backup
-    """
-
-    api_endpoint = "/databases/mysql/instances/{database_id}/backups/{id}"
-
-
-@deprecated(
-    reason="Backups are not supported for non-legacy database clusters."
-)
-class PostgreSQLDatabaseBackup(DatabaseBackup):
-    """
-    A backup for an accessible Managed PostgreSQL Database.
-
-    API Documentation: https://techdocs.akamai.com/linode-api/reference/get-databases-postgresql-instance-backup
-    """
-
-    api_endpoint = "/databases/postgresql/instances/{database_id}/backups/{id}"
-
-
 @dataclass
 class MySQLDatabaseConfigMySQLOptions(JSONObject):
     """
@@ -296,7 +230,6 @@ class MySQLDatabase(Base):
         "id": Property(identifier=True),
         "label": Property(mutable=True),
         "allow_list": Property(mutable=True, unordered=True),
-        "backups": Property(derived_class=MySQLDatabaseBackup),
         "cluster_size": Property(mutable=True),
         "created": Property(is_datetime=True),
         "encrypted": Property(),
@@ -304,7 +237,6 @@ class MySQLDatabase(Base):
         "hosts": Property(),
         "port": Property(),
         "region": Property(),
-        "replication_type": Property(),
         "ssl_connection": Property(),
         "status": Property(volatile=True),
         "type": Property(mutable=True),
@@ -393,28 +325,6 @@ class MySQLDatabase(Base):
             "{}/patch".format(MySQLDatabase.api_endpoint), model=self
         )
 
-    @deprecated(
-        reason="Backups are not supported for non-legacy database clusters."
-    )
-    def backup_create(self, label, **kwargs):
-        """
-        Creates a snapshot backup of a Managed MySQL Database.
-
-        API Documentation: https://techdocs.akamai.com/linode-api/reference/post-databases-mysql-instance-backup
-        """
-
-        params = {
-            "label": label,
-        }
-        params.update(kwargs)
-
-        self._client.post(
-            "{}/backups".format(MySQLDatabase.api_endpoint),
-            model=self,
-            data=params,
-        )
-        self.invalidate()
-
     def invalidate(self):
         """
         Clear out cached properties.
@@ -464,7 +374,6 @@ class PostgreSQLDatabase(Base):
         "id": Property(identifier=True),
         "label": Property(mutable=True),
         "allow_list": Property(mutable=True, unordered=True),
-        "backups": Property(derived_class=PostgreSQLDatabaseBackup),
         "cluster_size": Property(mutable=True),
         "created": Property(is_datetime=True),
         "encrypted": Property(),
@@ -472,8 +381,6 @@ class PostgreSQLDatabase(Base):
         "hosts": Property(),
         "port": Property(),
         "region": Property(),
-        "replication_commit_type": Property(),
-        "replication_type": Property(),
         "ssl_connection": Property(),
         "status": Property(volatile=True),
         "type": Property(mutable=True),
@@ -563,28 +470,6 @@ class PostgreSQLDatabase(Base):
             "{}/patch".format(PostgreSQLDatabase.api_endpoint), model=self
         )
 
-    @deprecated(
-        reason="Backups are not supported for non-legacy database clusters."
-    )
-    def backup_create(self, label, **kwargs):
-        """
-        Creates a snapshot backup of a Managed PostgreSQL Database.
-
-        API Documentation: https://techdocs.akamai.com/linode-api/reference/post-databases-postgre-sql-instance-backup
-        """
-
-        params = {
-            "label": label,
-        }
-        params.update(kwargs)
-
-        self._client.post(
-            "{}/backups".format(PostgreSQLDatabase.api_endpoint),
-            model=self,
-            data=params,
-        )
-        self.invalidate()
-
     def invalidate(self):
         """
         Clear out cached properties.

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/objects/linode.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import copy
 import string
 import sys
@@ -40,9 +42,16 @@ from linode_api4.objects.region import Region
 from linode_api4.objects.serializable import JSONObject, StrEnum
 from linode_api4.objects.vpc import VPC, VPCSubnet
 from linode_api4.paginated_list import PaginatedList
-from linode_api4.util import drop_null_keys
+from linode_api4.util import (
+    drop_null_keys,
+    generate_device_suffixes,
+    normalize_as_list,
+)
 
 PASSWORD_CHARS = string.ascii_letters + string.digits + string.punctuation
+MIN_DEVICE_LIMIT = 8
+MB_PER_GB = 1024
+MAX_DEVICE_LIMIT = 64
 
 
 class InstanceDiskEncryptionType(StrEnum):
@@ -1243,14 +1252,14 @@ class Instance(Base):
     # create derived objects
     def config_create(
         self,
-        kernel=None,
-        label=None,
-        devices=[],
-        disks=[],
-        volumes=[],
-        interfaces=[],
+        kernel: Kernel | str | None = None,
+        label: str | None = None,
+        devices: "Disk | Volume | dict[str, Any] | list[Disk | Volume | dict[str, Any]] | None" = None,
+        disks: Disk | int | list[Disk | int] | None = None,
+        volumes: "Volume | int | list[Volume | int] | None" = None,
+        interfaces: list[ConfigInterface | dict[str, Any]] | None = None,
         **kwargs,
-    ):
+    ) -> Config:
         """
         Creates a Linode Config with the given attributes.
 
@@ -1260,10 +1269,13 @@ class Instance(Base):
         :param label: The config label
         :param disks: The list of disks, starting at sda, to map to this config.
         :param volumes: The volumes, starting after the last disk, to map to this
-            config
+                        config.
         :param devices: A list of devices to assign to this config, in device
-            index order.  Values must be of type Disk or Volume. If this is
-            given, you may not include disks or volumes.
+                        index order, a raw device mapping dict to pass directly to the API
+                        (e.g. ``{"sda": {"disk_id": 123}, "sdb": Volume(...)}``), or
+                        a single Disk or Volume.
+                        If this is given, you may not include disks or volumes.
+        :param interfaces: A list of ConfigInterface objects or dicts to assign to this config.
         :param **kwargs: Any other arguments accepted by the api.
 
         :returns: A new Linode Config
@@ -1271,56 +1283,99 @@ class Instance(Base):
         # needed here to avoid circular imports
         from .volume import Volume  # pylint: disable=import-outside-toplevel
 
+        interfaces = [] if interfaces is None else interfaces
+
         hypervisor_prefix = "sd" if self.hypervisor == "kvm" else "xvd"
+
+        device_limit = int(
+            max(
+                MIN_DEVICE_LIMIT,
+                min(self.specs.memory // MB_PER_GB, MAX_DEVICE_LIMIT),
+            )
+        )
+
         device_names = [
-            hypervisor_prefix + string.ascii_lowercase[i] for i in range(0, 8)
+            hypervisor_prefix + suffix
+            for suffix in generate_device_suffixes(device_limit)
         ]
-        device_map = {
-            device_names[i]: None for i in range(0, len(device_names))
-        }
 
+        def _flatten_device(device: Disk | Volume | dict | None):
+            if device is None:
+                return None
+            elif isinstance(device, Disk):
+                return {"disk_id": device.id}
+            elif isinstance(device, Volume):
+                return {"volume_id": device.id}
+            elif isinstance(device, dict):
+                return device
+
+            raise TypeError("Disk, Volume, or dict expected!")
+
+        def _device_entry(device: Disk | Volume | int, key: str):
+            if isinstance(device, (Disk, Volume)):
+                return _flatten_device(device)
+
+            try:
+                device_id = int(device)
+            except (TypeError, ValueError):
+                raise TypeError(
+                    "Disk, Volume, or integer ID expected!"
+                ) from None
+
+            return {key: device_id}
+
+        def _build_devices():
+            # Devices is a dict, flatten and pass through
+            if isinstance(devices, dict):
+                return {
+                    k: (
+                        _flatten_device(v)
+                        if isinstance(v, (Disk, Volume))
+                        else v
+                    )
+                    for k, v in devices.items()
+                }
+
+            device_list = []
+
+            if devices:
+                device_list += [
+                    _flatten_device(device)
+                    for device in normalize_as_list(devices)
+                ]
+
+            if disks:
+                device_list += [
+                    _device_entry(disk, "disk_id") if disk is not None else None
+                    for disk in normalize_as_list(disks)
+                ]
+
+            if volumes:
+                device_list += [
+                    (
+                        _device_entry(volume, "volume_id")
+                        if volume is not None
+                        else None
+                    )
+                    for volume in normalize_as_list(volumes)
+                ]
+
+            return {
+                device_names[i]: device for i, device in enumerate(device_list)
+            }
+
+        # This validation is enforced for backwards compatibility but isn't
+        # technically needed anymore
         if devices and (disks or volumes):
             raise ValueError(
                 'You may not call config_create with "devices" and '
                 'either of "disks" or "volumes" specified!'
             )
 
-        if not devices:
-            if not isinstance(disks, list):
-                disks = [disks]
-            if not isinstance(volumes, list):
-                volumes = [volumes]
-
-            devices = []
-
-            for d in disks:
-                if d is None:
-                    devices.append(None)
-                elif isinstance(d, Disk):
-                    devices.append(d)
-                else:
-                    devices.append(Disk(self._client, int(d), self.id))
-
-            for v in volumes:
-                if v is None:
-                    devices.append(None)
-                elif isinstance(v, Volume):
-                    devices.append(v)
-                else:
-                    devices.append(Volume(self._client, int(v)))
-
-        if not devices:
-            raise ValueError("Must include at least one disk or volume!")
+        device_map = _build_devices()
 
-        for i, d in enumerate(devices):
-            if d is None:
-                pass
-            elif isinstance(d, Disk):
-                device_map[device_names[i]] = {"disk_id": d.id}
-            elif isinstance(d, Volume):
-                device_map[device_names[i]] = {"volume_id": d.id}
-            else:
-                raise TypeError("Disk or Volume expected!")
+        if len(device_map) < 1:
+            raise ValueError("Must include at least one disk or volume!")
 
         param_interfaces = []
         for interface in interfaces:
@@ -1832,8 +1887,8 @@ class Instance(Base):
         to_linode=None,
         region=None,
         instance_type=None,
-        configs=[],
-        disks=[],
+        configs=None,
+        disks=None,
         label=None,
         group=None,
         with_backups=None,
@@ -1889,7 +1944,10 @@ class Instance(Base):
                 'You may only specify one of "to_linode" and "region"'
             )
 
-        if region and not type:
+        configs = [] if configs is None else configs
+        disks = [] if disks is None else disks
+
+        if region and not instance_type:
             raise ValueError('Specifying a region requires a "service" as well')
 
         if not isinstance(configs, list) and not isinstance(

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/objects/lke.py

@@ -8,6 +8,7 @@ from linode_api4.objects import (
     Base,
     DerivedBase,
     Instance,
+    InstanceDiskEncryptionType,
     JSONObject,
     MappedObject,
     Property,
@@ -422,6 +423,9 @@ class LKECluster(Base):
         ] = None,
         update_strategy: Optional[str] = None,
         label: str = None,
+        disk_encryption: Optional[
+            Union[str, InstanceDiskEncryptionType]
+        ] = None,
         **kwargs,
     ):
         """
@@ -443,6 +447,9 @@ class LKECluster(Base):
         :param update_strategy: The strategy to use when updating this node pool.
                                 NOTE: This field is specific to enterprise clusters.
         :type update_strategy: str
+        :param disk_encryption: Local disk encryption setting for this LKE node pool.
+                                One of 'enabled' or 'disabled'. Defaults to 'disabled'.
+        :type disk_encryption: str or InstanceDiskEncryptionType
         :param kwargs: Any other arguments to pass to the API.  See the API docs
                        for possible values.
 
@@ -459,6 +466,7 @@ class LKECluster(Base):
             "taints": taints,
             "k8s_version": k8s_version,
             "update_strategy": update_strategy,
+            "disk_encryption": disk_encryption,
         }
         params.update(kwargs)
 

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/objects/nodebalancer.py

@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
 from urllib import parse
 
 from linode_api4.common import Price, RegionPrice
@@ -220,12 +220,14 @@ class NodeBalancerConfig(DerivedBase):
 
         # we're disabling warnings here because these attributes are defined dynamically
         # through linode.objects.Base, and pylint isn't privy
-        if os.path.isfile(os.path.expanduser(cert_file)):
-            with open(os.path.expanduser(cert_file)) as f:
+        cert_path = Path(cert_file).expanduser()
+        if cert_path.is_file():
+            with open(cert_path) as f:
                 self.ssl_cert = f.read()
 
-        if os.path.isfile(os.path.expanduser(key_file)):
-            with open(os.path.expanduser(key_file)) as f:
+        key_path = Path(key_file).expanduser()
+        if key_path.is_file():
+            with open(key_path) as f:
                 self.ssl_key = f.read()
 
 

{linode_api4-5.40.0 → linode_api4-5.42.0}/linode_api4/objects/region.py

@@ -125,6 +125,29 @@ class Region(Base):
 
         return [RegionAvailabilityEntry.from_json(v) for v in result]
 
+    @property
+    def vpc_availability(self) -> "RegionVPCAvailability":
+        """
+        Returns VPC availability data for this region.
+
+        NOTE: IPv6 VPCs may not currently be available to all users.
+
+        API Documentation: https://techdocs.akamai.com/linode-api/reference/get-region-vpc-availability
+
+        :returns: VPC availability data for this region.
+        :rtype: RegionVPCAvailability
+        """
+        result = self._client.get(
+            f"{self.api_endpoint}/vpc-availability", model=self
+        )
+
+        if result is None:
+            raise UnexpectedResponseError(
+                "Expected VPC availability data, got None."
+            )
+
+        return RegionVPCAvailability.from_json(result)
+
 
 @dataclass
 class RegionAvailabilityEntry(JSONObject):
@@ -137,3 +160,18 @@ class RegionAvailabilityEntry(JSONObject):
     region: Optional[str] = None
     plan: Optional[str] = None
     available: bool = False
+
+
+@dataclass
+class RegionVPCAvailability(JSONObject):
+    """
+    Represents the VPC availability data for a region.
+
+    API Documentation: https://techdocs.akamai.com/linode-api/reference/get-regions-vpc-availability
+
+    NOTE: IPv6 VPCs may not currently be available to all users.
+    """
+
+    region: Optional[str] = None
+    available: bool = False
+    available_ipv6_prefix_lengths: Optional[List[int]] = None