various changes

Author: lgarber-akamai

linode_api4/objects/account.py

@@ -601,7 +601,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 +668,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

@@ -57,8 +57,6 @@ def __init__(
                     NOTE: This field is currently only for annotations purposes
                     and does not influence any update or decoding/encoding logic.
         json_object - The JSONObject class this property should be decoded into.
-        json_object_options - The JSONObject class this property should use when
-                              serializing for PUT requests.
         """
         self.mutable = mutable
         self.identifier = identifier
@@ -71,7 +69,6 @@ def __init__(
         self.nullable = nullable
         self.unordered = unordered
         self.json_class = json_object
-        self.json_class_options = json_object_options
 
 
 class MappedObject:
@@ -118,6 +115,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)
 
@@ -127,7 +127,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)
@@ -140,7 +140,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
 
@@ -282,20 +282,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()
-
-        # Hack to minimize PUT contents to the configured json_class_options schema
-        for key, value in data.items():
-            if value is None or key not in type(self).properties:
-                continue
-
-            json_class_options = type(self).properties[key].json_class_options
-            if json_class_options is None:
-                continue
-
-            data[key] = json_class_options.from_json(value).dict
+            data = self._serialize(is_put=True)
 
         resp = self._client.put(type(self).api_endpoint, model=self, data=data)
 
@@ -331,7 +320,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
@@ -360,7 +349,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
 
@@ -518,7 +507,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.
 
@@ -530,15 +519,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

@@ -296,41 +296,47 @@ class ConfigInterfaceIPv4(JSONObject):
 
 
 @dataclass
-class ConfigInterfaceIPv6SLAAC(JSONObject):
+class ConfigInterfaceIPv6SLAACOptions(JSONObject):
     range: str = ""
-    address: str = ""
 
 
 @dataclass
-class ConfigInterfaceIPv6Range(JSONObject):
+class ConfigInterfaceIPv6RangeOptions(JSONObject):
     range: str = ""
 
 
 @dataclass
-class ConfigInterfaceIPv6(JSONObject):
-    slaac: List[ConfigInterfaceIPv6SLAAC] = field(default_factory=lambda: [])
-    ranges: List[ConfigInterfaceIPv6Range] = field(default_factory=lambda: [])
+class ConfigInterfaceIPv6Options(JSONObject):
+    slaac: List[ConfigInterfaceIPv6SLAACOptions] = field(
+        default_factory=lambda: []
+    )
+    ranges: List[ConfigInterfaceIPv6RangeOptions] = field(
+        default_factory=lambda: []
+    )
     is_public: bool = False
 
 
 @dataclass
-class ConfigInterfaceIPv6SLAACOptions(JSONObject):
+class ConfigInterfaceIPv6SLAAC(JSONObject):
+    put_class = ConfigInterfaceIPv6SLAACOptions
+
     range: str = ""
+    address: str = ""
 
 
 @dataclass
-class ConfigInterfaceIPv6RangeOptions(JSONObject):
+class ConfigInterfaceIPv6Range(JSONObject):
+    put_class = ConfigInterfaceIPv6RangeOptions
+
     range: str = ""
 
 
 @dataclass
-class ConfigInterfaceIPv6Options(JSONObject):
-    slaac: List[ConfigInterfaceIPv6SLAACOptions] = field(
-        default_factory=lambda: []
-    )
-    ranges: List[ConfigInterfaceIPv6RangeOptions] = field(
-        default_factory=lambda: []
-    )
+class ConfigInterfaceIPv6(JSONObject):
+    put_class = ConfigInterfaceIPv6Options
+
+    slaac: List[ConfigInterfaceIPv6SLAAC] = field(default_factory=lambda: [])
+    ranges: List[ConfigInterfaceIPv6Range] = field(default_factory=lambda: [])
     is_public: bool = False
 
 
@@ -359,11 +365,7 @@ class NetworkInterface(DerivedBase):
         "vpc_id": Property(id_relationship=VPC),
         "subnet_id": Property(),
         "ipv4": Property(mutable=True, json_object=ConfigInterfaceIPv4),
-        "ipv6": Property(
-            mutable=True,
-            json_object=ConfigInterfaceIPv6,
-            json_object_options=ConfigInterfaceIPv6Options,
-        ),
+        "ipv6": Property(mutable=True, json_object=ConfigInterfaceIPv6),
         "ip_ranges": Property(mutable=True),
     }
 
@@ -389,17 +391,6 @@ def __init__(self, client, id, parent_id, instance_id=None, json=None):
     def __repr__(self):
         return f"Interface: {self.purpose} {self.id}"
 
-    def _serialize(self):
-        result = DerivedBase._serialize(self)
-
-        ipv6 = result.get("ipv6", None)
-
-        if isinstance(ipv6, ConfigInterfaceIPv6):
-            print("SDF")
-            result["ipv6"] = ConfigInterfaceIPv6Options.from_json(ipv6.dict)
-
-        return result
-
     @property
     def subnet(self) -> VPCSubnet:
         """
@@ -458,7 +449,7 @@ class ConfigInterface(JSONObject):
     def __repr__(self):
         return f"Interface: {self.purpose}"
 
-    def _serialize(self):
+    def _serialize(self, is_put: bool = False):
         purpose_formats = {
             "public": {"purpose": "public", "primary": self.primary},
             "vlan": {
@@ -470,16 +461,8 @@ def _serialize(self):
                 "purpose": "vpc",
                 "primary": self.primary,
                 "subnet_id": self.subnet_id,
-                "ipv4": (
-                    self.ipv4.dict
-                    if isinstance(self.ipv4, ConfigInterfaceIPv4)
-                    else self.ipv4
-                ),
-                "ipv6": (
-                    self.ipv6.dict
-                    if isinstance(self.ipv6, ConfigInterfaceIPv6)
-                    else self.ipv6
-                ),
+                "ipv4": self.ipv4,
+                "ipv6": self.ipv6,
                 "ip_ranges": self.ip_ranges,
             },
         }
@@ -489,11 +472,14 @@ def _serialize(self):
                 f"Unknown interface purpose: {self.purpose}",
             )
 
-        return {
-            k: v
-            for k, v in purpose_formats[self.purpose].items()
-            if v is not None
-        }
+        return _flatten_request_body_recursive(
+            {
+                k: v
+                for k, v in purpose_formats[self.purpose].items()
+                if v is not None
+            },
+            is_put=is_put,
+        )
 
 
 class Config(DerivedBase):
@@ -573,16 +559,16 @@ def _populate(self, json):
 
         self._set("devices", MappedObject(**devices))
 
-    def _serialize(self):
+    def _serialize(self, *args, **kwargs):
         """
         Overrides _serialize to transform interfaces into json
         """
-        partial = DerivedBase._serialize(self)
+        partial = DerivedBase._serialize(self, *args, **kwargs)
         interfaces = []
 
         for c in self.interfaces:
             if isinstance(c, ConfigInterface):
-                interfaces.append(c._serialize())
+                interfaces.append(c._serialize(*args, **kwargs))
             else:
                 interfaces.append(c)
 
@@ -1990,8 +1976,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, *args, **kwargs):
+        dct = Base._serialize(self, *args, **kwargs)
         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