Fix conflict

Author: lgarber-akamai

linode_api4/objects/account.py

@@ -16,6 +16,7 @@
 from linode_api4.objects.networking import Firewall
 from linode_api4.objects.nodebalancer import NodeBalancer
 from linode_api4.objects.profile import PersonalAccessToken
+from linode_api4.objects.serializable import StrEnum
 from linode_api4.objects.support import SupportTicket
 from linode_api4.objects.volume import Volume
 from linode_api4.objects.vpc import VPC
@@ -179,6 +180,24 @@ class Login(Base):
     }
 
 
+class AccountSettingsInterfacesForNewLinodes(StrEnum):
+    """
+    A string enum corresponding to valid values
+    for the AccountSettings(...).interfaces_for_new_linodes field.
+
+    NOTE: This feature may not currently be available to all users.
+    """
+
+    legacy_config_only = "legacy_config_only"
+    legacy_config_default_but_linode_allowed = (
+        "legacy_config_default_but_linode_allowed"
+    )
+    linode_default_but_legacy_config_allowed = (
+        "linode_default_but_legacy_config_allowed"
+    )
+    linode_only = "linode_only"
+
+
 class AccountSettings(Base):
     """
     Information related to your Account settings.
@@ -197,6 +216,7 @@ class AccountSettings(Base):
         ),
         "object_storage": Property(),
         "backups_enabled": Property(mutable=True),
+        "interfaces_for_new_linodes": Property(mutable=True),
     }
 
 
@@ -601,7 +621,7 @@ def entity(self):
             )
         return self.cls(self._client, self.id)
 
-    def _serialize(self):
+    def _serialize(self, *args, **kwargs):
         """
         Returns this grant in as JSON the api will accept.  This is only relevant
         in the context of UserGrants.save
@@ -668,7 +688,7 @@ def _grants_dict(self):
 
         return grants
 
-    def _serialize(self):
+    def _serialize(self, *args, **kwargs):
         """
         Returns the user grants in as JSON the api will accept.
         This is only relevant in the context of UserGrants.save

linode_api4/objects/base.py

@@ -114,6 +114,9 @@ def _flatten_base_subclass(obj: "Base") -> Optional[Dict[str, Any]]:
 
     @property
     def dict(self):
+        return self._serialize()
+
+    def _serialize(self, is_put: bool = False) -> Dict[str, Any]:
         result = vars(self).copy()
         cls = type(self)
 
@@ -123,7 +126,7 @@ def dict(self):
             elif isinstance(v, list):
                 result[k] = [
                     (
-                        item.dict
+                        item._serialize(is_put=is_put)
                         if isinstance(item, (cls, JSONObject))
                         else (
                             self._flatten_base_subclass(item)
@@ -136,7 +139,7 @@ def dict(self):
             elif isinstance(v, Base):
                 result[k] = self._flatten_base_subclass(v)
             elif isinstance(v, JSONObject):
-                result[k] = v.dict
+                result[k] = v._serialize(is_put=is_put)
 
         return result
 
@@ -278,9 +281,9 @@ def save(self, force=True) -> bool:
                     data[key] = None
 
             # Ensure we serialize any values that may not be already serialized
-            data = _flatten_request_body_recursive(data)
+            data = _flatten_request_body_recursive(data, is_put=True)
         else:
-            data = self._serialize()
+            data = self._serialize(is_put=True)
 
         resp = self._client.put(type(self).api_endpoint, model=self, data=data)
 
@@ -316,7 +319,7 @@ def invalidate(self):
 
         self._set("_populated", False)
 
-    def _serialize(self):
+    def _serialize(self, is_put: bool = False):
         """
         A helper method to build a dict of all mutable Properties of
         this object
@@ -345,7 +348,7 @@ def _serialize(self):
 
         # Resolve the underlying IDs of results
         for k, v in result.items():
-            result[k] = _flatten_request_body_recursive(v)
+            result[k] = _flatten_request_body_recursive(v, is_put=is_put)
 
         return result
 
@@ -503,7 +506,7 @@ def make_instance(cls, id, client, parent_id=None, json=None):
         return Base.make(id, client, cls, parent_id=parent_id, json=json)
 
 
-def _flatten_request_body_recursive(data: Any) -> Any:
+def _flatten_request_body_recursive(data: Any, is_put: bool = False) -> Any:
     """
     This is a helper recursively flatten the given data for use in an API request body.
 
@@ -515,15 +518,18 @@ def _flatten_request_body_recursive(data: Any) -> Any:
     """
 
     if isinstance(data, dict):
-        return {k: _flatten_request_body_recursive(v) for k, v in data.items()}
+        return {
+            k: _flatten_request_body_recursive(v, is_put=is_put)
+            for k, v in data.items()
+        }
 
     if isinstance(data, list):
-        return [_flatten_request_body_recursive(v) for v in data]
+        return [_flatten_request_body_recursive(v, is_put=is_put) for v in data]
 
     if isinstance(data, Base):
         return data.id
 
     if isinstance(data, MappedObject) or issubclass(type(data), JSONObject):
-        return data.dict
+        return data._serialize(is_put=is_put)
 
     return data

linode_api4/objects/linode.py

@@ -408,7 +408,7 @@ class ConfigInterface(JSONObject):
     def __repr__(self):
         return f"Interface: {self.purpose}"
 
-    def _serialize(self):
+    def _serialize(self, *args, **kwargs):
         purpose_formats = {
             "public": {"purpose": "public", "primary": self.primary},
             "vlan": {
@@ -519,16 +519,16 @@ def _populate(self, json):
 
         self._set("devices", MappedObject(**devices))
 
-    def _serialize(self):
+    def _serialize(self, is_put: bool = False):
         """
         Overrides _serialize to transform interfaces into json
         """
-        partial = DerivedBase._serialize(self)
+        partial = DerivedBase._serialize(self, is_put=is_put)
         interfaces = []
 
         for c in self.interfaces:
             if isinstance(c, ConfigInterface):
-                interfaces.append(c._serialize())
+                interfaces.append(c._serialize(is_put=is_put))
             else:
                 interfaces.append(c)
 
@@ -2068,8 +2068,8 @@ def _populate(self, json):
         ndist = [Image(self._client, d) for d in self.images]
         self._set("images", ndist)
 
-    def _serialize(self):
-        dct = Base._serialize(self)
+    def _serialize(self, is_put: bool = False):
+        dct = Base._serialize(self, is_put=is_put)
         dct["images"] = [d.id for d in self.images]
         return dct
 

linode_api4/objects/serializable.py

@@ -1,5 +1,5 @@
 import inspect
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
 from enum import Enum
 from types import SimpleNamespace
 from typing import (
@@ -9,6 +9,7 @@
     List,
     Optional,
     Set,
+    Type,
     Union,
     get_args,
     get_origin,
@@ -71,6 +72,13 @@ class JSONObject(metaclass=JSONFilterableMetaclass):
     are None.
     """
 
+    put_class: ClassVar[Optional[Type["JSONObject"]]] = None
+    """
+    An alternative JSONObject class to use as the schema for PUT requests.
+    This prevents read-only fields from being included in PUT request bodies,
+    which in theory will result in validation errors from the API.
+    """
+
     def __init__(self):
         raise NotImplementedError(
             "JSONObject is not intended to be constructed directly"
@@ -154,19 +162,25 @@ def from_json(cls, json: Dict[str, Any]) -> Optional["JSONObject"]:
 
         return obj
 
-    def _serialize(self) -> Dict[str, Any]:
+    def _serialize(self, is_put: bool = False) -> Dict[str, Any]:
         """
         Serializes this object into a JSON dict.
         """
         cls = type(self)
+
+        if is_put and cls.put_class is not None:
+            cls = cls.put_class
+
+        cls_field_keys = {field.name for field in fields(cls)}
+
         type_hints = get_type_hints(cls)
 
         def attempt_serialize(value: Any) -> Any:
             """
             Attempts to serialize the given value, else returns the value unchanged.
             """
             if issubclass(type(value), JSONObject):
-                return value._serialize()
+                return value._serialize(is_put=is_put)
 
             return value
 
@@ -175,6 +189,10 @@ def should_include(key: str, value: Any) -> bool:
             Returns whether the given key/value pair should be included in the resulting dict.
             """
 
+            # During PUT operations, keys not present in the put_class should be excluded
+            if key not in cls_field_keys:
+                return False
+
             if cls.include_none_values or key in cls.always_include:
                 return True
 

test/fixtures/account.json

@@ -16,7 +16,8 @@
     "Linodes",
     "NodeBalancers",
     "Block Storage",
-    "Object Storage"
+    "Object Storage",
+    "Linode Interfaces"
   ],
   "active_promotions": [
     {

test/fixtures/account_settings.json

@@ -3,5 +3,6 @@
   "managed": false,
   "network_helper": false,
   "object_storage": "active",
-  "backups_enabled": true
+  "backups_enabled": true,
+  "interfaces_for_new_linodes": "linode_default_but_legacy_config_allowed"
 }

test/integration/login_client/test_login_client.py

@@ -97,6 +97,7 @@ def test_linode_login_client_generate_login_url_with_scope(linode_login_client):
     assert "scopes=linodes%3Aread_write" in url
 
 
+@pytest.mark.skip("Endpoint may be deprecated")
 def test_linode_login_client_expire_token(
     linode_login_client, test_oauth_client
 ):

test/integration/models/account/test_account.py

@@ -59,6 +59,7 @@ def test_get_account_settings(test_linode_client):
     assert "longview_subscription" in str(account_settings._raw_json)
     assert "backups_enabled" in str(account_settings._raw_json)
     assert "object_storage" in str(account_settings._raw_json)
+    assert isinstance(account_settings.interfaces_for_new_linodes, str)
 
 
 @pytest.mark.smoke

test/integration/models/domain/test_domain.py

@@ -23,8 +23,6 @@ def test_save_null_values_excluded(test_linode_client, test_domain):
     domain.master_ips = ["127.0.0.1"]
     res = domain.save()
 
-    assert res
-
 
 def test_zone_file_view(test_linode_client, test_domain):
     domain = test_linode_client.load(Domain, test_domain.id)

test/integration/models/linode/test_linode.py

@@ -9,7 +9,6 @@
 
 import pytest
 
-from linode_api4 import VPCIPAddress
 from linode_api4.errors import ApiError
 from linode_api4.objects import (
     Config,
@@ -181,7 +180,7 @@ def create_linode_for_long_running_tests(test_linode_client, e2e_test_firewall):
 def linode_with_disk_encryption(test_linode_client, request):
     client = test_linode_client
 
-    target_region = get_region(client, {"Disk Encryption"})
+    target_region = get_region(client, {"LA Disk Encryption"})
     label = get_test_label(length=8)
 
     disk_encryption = request.param
@@ -236,7 +235,7 @@ def test_linode_transfer(test_linode_client, linode_with_volume_firewall):
 def test_linode_rebuild(test_linode_client):
     client = test_linode_client
 
-    region = get_region(client, {"Disk Encryption"})
+    region = get_region(client, {"LA Disk Encryption"})
 
     label = get_test_label() + "_rebuild"
 
@@ -535,6 +534,7 @@ def test_linode_create_disk(test_linode_client, linode_for_disk_tests):
     assert disk.linode_id == linode.id
 
 
+@pytest.mark.flaky(reruns=3, reruns_delay=2)
 def test_linode_instance_password(create_linode_for_pass_reset):
     linode = create_linode_for_pass_reset[0]
     password = create_linode_for_pass_reset[1]
@@ -775,10 +775,10 @@ def test_create_vpc(
         assert vpc_range_ip.address_range == "10.0.0.5/32"
         assert not vpc_range_ip.active
 
+        # TODO:: Add `VPCIPAddress.filters.linode_id == linode.id` filter back
+
         # Attempt to resolve the IP from /vpcs/ips
-        all_vpc_ips = test_linode_client.vpcs.ips(
-            VPCIPAddress.filters.linode_id == linode.id
-        )
+        all_vpc_ips = test_linode_client.vpcs.ips()
         assert all_vpc_ips[0].dict == vpc_ip.dict
 
         # Test getting the ips under this specific VPC

test/integration/models/lke/test_lke.py

@@ -32,7 +32,9 @@ def lke_cluster(test_linode_client):
     node_type = test_linode_client.linode.types()[1]  # g6-standard-1
     version = test_linode_client.lke.versions()[0]
 
-    region = get_region(test_linode_client, {"Kubernetes", "Disk Encryption"})
+    region = get_region(
+        test_linode_client, {"Kubernetes", "LA Disk Encryption"}
+    )
 
     node_pools = test_linode_client.lke.node_pool(node_type, 3)
     label = get_test_label() + "_cluster"
@@ -115,7 +117,9 @@ def lke_cluster_with_labels_and_taints(test_linode_client):
 def lke_cluster_with_apl(test_linode_client):
     version = test_linode_client.lke.versions()[0]
 
-    region = get_region(test_linode_client, {"Kubernetes", "Disk Encryption"})
+    region = get_region(
+        test_linode_client, {"Kubernetes", "LA Disk Encryption"}
+    )
 
     # NOTE: g6-dedicated-4 is the minimum APL-compatible Linode type
     node_pools = test_linode_client.lke.node_pool("g6-dedicated-4", 3)
@@ -145,7 +149,7 @@ def lke_cluster_enterprise(test_linode_client):
     )[0]
 
     region = get_region(
-        test_linode_client, {"Kubernetes Enterprise", "Disk Encryption"}
+        test_linode_client, {"Kubernetes Enterprise", "LA Disk Encryption"}
     )
 
     node_pools = test_linode_client.lke.node_pool(
@@ -204,7 +208,7 @@ def _to_comparable(p: LKENodePool) -> Dict[str, Any]:
 
     assert _to_comparable(cluster.pools[0]) == _to_comparable(pool)
 
-    assert pool.disk_encryption == InstanceDiskEncryptionType.enabled
+    assert pool.disk_encryption == InstanceDiskEncryptionType.disabled
 
 
 def test_cluster_dashboard_url_view(lke_cluster):