Merge branch 'feature/add-unset-value-and-model-to-dict-params' into support_inline_object_schemas

Author: dbanty

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update minimum Pydantic version to support Python 3.9
 
 ### Additions
+- Better compatibility for "required" (whether or not the field must be included) and "nullable" (whether or not the field can be null) (#205 & #208). Thanks @bowenwr & @emannguitar!
 
 - Allow specifying the generated client's version using `package_version_override` in a config file. (#225 - Thanks @fyhertz!)
 

end_to_end_tests/golden-record-custom/my_test_api_client/models/a_model.py

@@ -6,24 +6,27 @@
 
 from ..models.an_enum import AnEnum
 from ..models.different_enum import DifferentEnum
+from ..types import UNSET, Unset
 
 
 @attr.s(auto_attribs=True)
 class AModel:
     """ A Model for testing all the ways custom objects can be used  """
 
     an_enum_value: AnEnum
-    some_dict: Optional[Dict[Any, Any]]
     a_camel_date_time: Union[datetime.datetime, datetime.date]
     a_date: datetime.date
-    nested_list_of_enums: Optional[List[List[DifferentEnum]]] = None
-    attr_1_leading_digit: Optional[str] = None
+    required_not_nullable: str
+    nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = UNSET
+    some_dict: Optional[Dict[Any, Any]] = None
+    attr_1_leading_digit: Union[Unset, str] = UNSET
+    required_nullable: Optional[str] = None
+    not_required_nullable: Union[Unset, Optional[str]] = UNSET
+    not_required_not_nullable: Union[Unset, str] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
 
-        some_dict = self.some_dict
-
         if isinstance(self.a_camel_date_time, datetime.datetime):
             a_camel_date_time = self.a_camel_date_time.isoformat()
 
@@ -32,9 +35,9 @@ def to_dict(self) -> Dict[str, Any]:
 
         a_date = self.a_date.isoformat()
 
-        if self.nested_list_of_enums is None:
-            nested_list_of_enums = None
-        else:
+        required_not_nullable = self.required_not_nullable
+        nested_list_of_enums: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self.nested_list_of_enums, Unset):
             nested_list_of_enums = []
             for nested_list_of_enums_item_data in self.nested_list_of_enums:
                 nested_list_of_enums_item = []
@@ -45,23 +48,36 @@ def to_dict(self) -> Dict[str, Any]:
 
                 nested_list_of_enums.append(nested_list_of_enums_item)
 
+        some_dict = self.some_dict if self.some_dict else None
+
         attr_1_leading_digit = self.attr_1_leading_digit
+        required_nullable = self.required_nullable
+        not_required_nullable = self.not_required_nullable
+        not_required_not_nullable = self.not_required_not_nullable
 
-        return {
+        field_dict = {
             "an_enum_value": an_enum_value,
-            "some_dict": some_dict,
             "aCamelDateTime": a_camel_date_time,
             "a_date": a_date,
-            "nested_list_of_enums": nested_list_of_enums,
-            "1_leading_digit": attr_1_leading_digit,
+            "required_not_nullable": required_not_nullable,
+            "some_dict": some_dict,
+            "required_nullable": required_nullable,
         }
+        if nested_list_of_enums is not UNSET:
+            field_dict["nested_list_of_enums"] = nested_list_of_enums
+        if attr_1_leading_digit is not UNSET:
+            field_dict["1_leading_digit"] = attr_1_leading_digit
+        if not_required_nullable is not UNSET:
+            field_dict["not_required_nullable"] = not_required_nullable
+        if not_required_not_nullable is not UNSET:
+            field_dict["not_required_not_nullable"] = not_required_not_nullable
+
+        return field_dict
 
     @staticmethod
     def from_dict(d: Dict[str, Any]) -> "AModel":
         an_enum_value = AnEnum(d["an_enum_value"])
 
-        some_dict = d["some_dict"]
-
         def _parse_a_camel_date_time(data: Dict[str, Any]) -> Union[datetime.datetime, datetime.date]:
             a_camel_date_time: Union[datetime.datetime, datetime.date]
             try:
@@ -78,8 +94,10 @@ def _parse_a_camel_date_time(data: Dict[str, Any]) -> Union[datetime.datetime, d
 
         a_date = isoparse(d["a_date"]).date()
 
+        required_not_nullable = d["required_not_nullable"]
+
         nested_list_of_enums = []
-        for nested_list_of_enums_item_data in d.get("nested_list_of_enums") or []:
+        for nested_list_of_enums_item_data in d.get("nested_list_of_enums", UNSET) or []:
             nested_list_of_enums_item = []
             for nested_list_of_enums_item_item_data in nested_list_of_enums_item_data:
                 nested_list_of_enums_item_item = DifferentEnum(nested_list_of_enums_item_item_data)
@@ -88,13 +106,25 @@ def _parse_a_camel_date_time(data: Dict[str, Any]) -> Union[datetime.datetime, d
 
             nested_list_of_enums.append(nested_list_of_enums_item)
 
-        attr_1_leading_digit = d.get("1_leading_digit")
+        some_dict = d["some_dict"]
+
+        attr_1_leading_digit = d.get("1_leading_digit", UNSET)
+
+        required_nullable = d["required_nullable"]
+
+        not_required_nullable = d.get("not_required_nullable", UNSET)
+
+        not_required_not_nullable = d.get("not_required_not_nullable", UNSET)
 
         return AModel(
             an_enum_value=an_enum_value,
-            some_dict=some_dict,
             a_camel_date_time=a_camel_date_time,
             a_date=a_date,
+            required_not_nullable=required_not_nullable,
             nested_list_of_enums=nested_list_of_enums,
+            some_dict=some_dict,
             attr_1_leading_digit=attr_1_leading_digit,
+            required_nullable=required_nullable,
+            not_required_nullable=not_required_nullable,
+            not_required_not_nullable=not_required_not_nullable,
         )

end_to_end_tests/golden-record-custom/my_test_api_client/models/http_validation_error.py

@@ -1,34 +1,36 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Union
 
 import attr
 
 from ..models.validation_error import ValidationError
+from ..types import UNSET, Unset
 
 
 @attr.s(auto_attribs=True)
 class HTTPValidationError:
     """  """
 
-    detail: Optional[List[ValidationError]] = None
+    detail: Union[Unset, List[ValidationError]] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
-        if self.detail is None:
-            detail = None
-        else:
+        detail: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self.detail, Unset):
             detail = []
             for detail_item_data in self.detail:
                 detail_item = detail_item_data.to_dict()
 
                 detail.append(detail_item)
 
-        return {
-            "detail": detail,
-        }
+        field_dict = {}
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
 
     @staticmethod
     def from_dict(d: Dict[str, Any]) -> "HTTPValidationError":
         detail = []
-        for detail_item_data in d.get("detail") or []:
+        for detail_item_data in d.get("detail", UNSET) or []:
             detail_item = ValidationError.from_dict(detail_item_data)
 
             detail.append(detail_item)