Merge main and reimplement

Author: forest-benchling

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## 0.8.0 - Unreleased
 
+### Breaking Changes
+
+- Generated clients will no longer pass through `None` to query parameters. Previously, any query params set to `None` would surface as empty strings (per the default behavior of `httpx`). This is contrary to the defaults indicated by the OpenAPI 3.0.3 spec. Ommitting these parameters makes us more compliant. If you require a style of `null` to be passed to your query parameters, please request support for the OpenAPI "style" attribute. Thank you to @forest-benchling and @bowenwr for a ton of input on this.
+
 ### Additions
 
 - New `--meta` command line option for specifying what type of metadata should be generated:
@@ -22,6 +26,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Lowered the minimum version of `python-dateutil` to 2.8.0 for improved compatibility (#298 & #299). Thanks @bowenwr!
 - The `from_dict` method on generated models is now a `@classmethod` instead of `@staticmethod` (#215 & #292). Thanks @forest-benchling!
+- Renamed all templates to end in `.jinja`, and all python-templates to end in `.py.jinja` to fix confusion with the latest version of mypy. Note **this will break existing custom templates until you update your template file names**.
+
+### Fixes
+
+- Parser will softly ignore value error during schema responses' status code convertion from string to integer (not a number). Errors will be reported to the end user and parsing will continue to proceed (#327).
+- The generated `from_dict` and `to_dict` methods of models will now properly handle `nullable` and `not required` properties that are themselves generated models (#315). Thanks @forest-benchling!
 
 ## 0.7.3 - 2020-12-21
 

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py

@@ -95,29 +95,21 @@ def httpx_request(
     if not isinstance(model_prop, Unset):
         json_model_prop = model_prop.to_dict()
 
-    params: Dict[str, Any] = {}
-    if not isinstance(string_prop, Unset) and string_prop is not None:
-        params["string_prop"] = string_prop
-    if not isinstance(json_datetime_prop, Unset) and json_datetime_prop is not None:
-        params["datetime_prop"] = json_datetime_prop
-    if not isinstance(json_date_prop, Unset) and json_date_prop is not None:
-        params["date_prop"] = json_date_prop
-    if not isinstance(float_prop, Unset) and float_prop is not None:
-        params["float_prop"] = float_prop
-    if not isinstance(int_prop, Unset) and int_prop is not None:
-        params["int_prop"] = int_prop
-    if not isinstance(boolean_prop, Unset) and boolean_prop is not None:
-        params["boolean_prop"] = boolean_prop
-    if not isinstance(json_list_prop, Unset) and json_list_prop is not None:
-        params["list_prop"] = json_list_prop
-    if not isinstance(json_union_prop, Unset) and json_union_prop is not None:
-        params["union_prop"] = json_union_prop
-    if not isinstance(json_union_prop_with_ref, Unset) and json_union_prop_with_ref is not None:
-        params["union_prop_with_ref"] = json_union_prop_with_ref
-    if not isinstance(json_enum_prop, Unset) and json_enum_prop is not None:
-        params["enum_prop"] = json_enum_prop
-    if not isinstance(json_model_prop, Unset) and json_model_prop is not None:
+    params: Dict[str, Any] = {
+        "string_prop": string_prop,
+        "datetime_prop": json_datetime_prop,
+        "date_prop": json_date_prop,
+        "float_prop": float_prop,
+        "int_prop": int_prop,
+        "boolean_prop": boolean_prop,
+        "list_prop": json_list_prop,
+        "union_prop": json_union_prop,
+        "union_prop_with_ref": json_union_prop_with_ref,
+        "enum_prop": json_enum_prop,
+    }
+    if not isinstance(json_model_prop, Unset):
         params.update(json_model_prop)
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "post",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/get_user_list.py

@@ -62,6 +62,7 @@ def httpx_request(
         "an_enum_value": json_an_enum_value,
         "some_date": json_some_date,
     }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "get",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/int_enum_tests_int_enum_post.py

@@ -44,6 +44,7 @@ def httpx_request(
     params: Dict[str, Any] = {
         "int_enum": json_int_enum,
     }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "post",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/optional_value_tests_optional_query_param.py

@@ -43,9 +43,10 @@ def httpx_request(
     if not isinstance(query_param, Unset):
         json_query_param = query_param
 
-    params: Dict[str, Any] = {}
-    if not isinstance(json_query_param, Unset) and json_query_param is not None:
-        params["query_param"] = json_query_param
+    params: Dict[str, Any] = {
+        "query_param": json_query_param,
+    }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "get",

end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py

@@ -1,6 +1,10 @@
 """ Contains all the data models used in inputs/outputs """
 
 from .a_model import AModel
+from .a_model_model import AModelModel
+from .a_model_not_required_model import AModelNotRequiredModel
+from .a_model_not_required_nullable_model import AModelNotRequiredNullableModel
+from .a_model_nullable_model import AModelNullableModel
 from .an_enum import AnEnum
 from .an_int_enum import AnIntEnum
 from .body_upload_file_tests_upload_post import BodyUploadFileTestsUploadPost

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

@@ -4,6 +4,10 @@
 import attr
 from dateutil.parser import isoparse
 
+from ..models.a_model_model import AModelModel
+from ..models.a_model_not_required_model import AModelNotRequiredModel
+from ..models.a_model_not_required_nullable_model import AModelNotRequiredNullableModel
+from ..models.a_model_nullable_model import AModelNullableModel
 from ..models.an_enum import AnEnum
 from ..models.different_enum import DifferentEnum
 from ..types import UNSET, Unset
@@ -19,12 +23,16 @@ class AModel:
     a_camel_date_time: Union[datetime.datetime, datetime.date]
     a_date: datetime.date
     required_not_nullable: str
+    model: AModelModel
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
+    nullable_model: Optional[AModelNullableModel]
     nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = UNSET
     attr_1_leading_digit: Union[Unset, str] = UNSET
     not_required_nullable: Union[Unset, Optional[str]] = UNSET
     not_required_not_nullable: Union[Unset, str] = UNSET
+    not_required_model: Union[AModelNotRequiredModel, Unset] = UNSET
+    not_required_nullable_model: Union[Optional[AModelNotRequiredNullableModel], Unset] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
@@ -37,6 +45,8 @@ def to_dict(self) -> Dict[str, Any]:
 
         a_date = self.a_date.isoformat()
         required_not_nullable = self.required_not_nullable
+        model = self.model.to_dict()
+
         nested_list_of_enums: Union[Unset, List[Any]] = UNSET
         if not isinstance(self.nested_list_of_enums, Unset):
             nested_list_of_enums = []
@@ -54,6 +64,17 @@ def to_dict(self) -> Dict[str, Any]:
         required_nullable = self.required_nullable
         not_required_nullable = self.not_required_nullable
         not_required_not_nullable = self.not_required_not_nullable
+        nullable_model = self.nullable_model.to_dict() if self.nullable_model else None
+
+        not_required_model: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.not_required_model, Unset):
+            not_required_model = self.not_required_model.to_dict()
+
+        not_required_nullable_model: Union[None, Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.not_required_nullable_model, Unset):
+            not_required_nullable_model = (
+                self.not_required_nullable_model.to_dict() if self.not_required_nullable_model else None
+            )
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(
@@ -62,8 +83,10 @@ def to_dict(self) -> Dict[str, Any]:
                 "aCamelDateTime": a_camel_date_time,
                 "a_date": a_date,
                 "required_not_nullable": required_not_nullable,
+                "model": model,
                 "a_nullable_date": a_nullable_date,
                 "required_nullable": required_nullable,
+                "nullable_model": nullable_model,
             }
         )
         if nested_list_of_enums is not UNSET:
@@ -74,6 +97,10 @@ def to_dict(self) -> Dict[str, Any]:
             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
+        if not_required_model is not UNSET:
+            field_dict["not_required_model"] = not_required_model
+        if not_required_nullable_model is not UNSET:
+            field_dict["not_required_nullable_model"] = not_required_nullable_model
 
         return field_dict
 
@@ -101,6 +128,8 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
 
         required_not_nullable = d.pop("required_not_nullable")
 
+        model = AModelModel.from_dict(d.pop("model"))
+
         nested_list_of_enums = []
         _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET)
         for nested_list_of_enums_item_data in _nested_list_of_enums or []:
@@ -126,17 +155,38 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
 
         not_required_not_nullable = d.pop("not_required_not_nullable", UNSET)
 
+        nullable_model = None
+        _nullable_model = d.pop("nullable_model")
+        if _nullable_model is not None:
+            nullable_model = AModelNullableModel.from_dict(cast(Dict[str, Any], _nullable_model))
+
+        not_required_model: Union[AModelNotRequiredModel, Unset] = UNSET
+        _not_required_model = d.pop("not_required_model", UNSET)
+        if not isinstance(_not_required_model, Unset):
+            not_required_model = AModelNotRequiredModel.from_dict(cast(Dict[str, Any], _not_required_model))
+
+        not_required_nullable_model = None
+        _not_required_nullable_model = d.pop("not_required_nullable_model", UNSET)
+        if _not_required_nullable_model is not None and not isinstance(_not_required_nullable_model, Unset):
+            not_required_nullable_model = AModelNotRequiredNullableModel.from_dict(
+                cast(Dict[str, Any], _not_required_nullable_model)
+            )
+
         a_model = cls(
             an_enum_value=an_enum_value,
             a_camel_date_time=a_camel_date_time,
             a_date=a_date,
             required_not_nullable=required_not_nullable,
+            model=model,
             nested_list_of_enums=nested_list_of_enums,
             a_nullable_date=a_nullable_date,
             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,
+            nullable_model=nullable_model,
+            not_required_model=not_required_model,
+            not_required_nullable_model=not_required_nullable_model,
         )
 
         return a_model

end_to_end_tests/golden-record-custom/custom_e2e/models/a_model_model.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="AModelModel")
+
+
+@attr.s(auto_attribs=True)
+class AModelModel:
+    """  """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        a_model_model = cls()
+
+        a_model_model.additional_properties = d
+        return a_model_model
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record-custom/custom_e2e/models/a_model_not_required_model.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="AModelNotRequiredModel")
+
+
+@attr.s(auto_attribs=True)
+class AModelNotRequiredModel:
+    """  """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        a_model_not_required_model = cls()
+
+        a_model_not_required_model.additional_properties = d
+        return a_model_not_required_model
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record-custom/custom_e2e/models/a_model_not_required_nullable_model.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="AModelNotRequiredNullableModel")
+
+
+@attr.s(auto_attribs=True)
+class AModelNotRequiredNullableModel:
+    """  """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        a_model_not_required_nullable_model = cls()
+
+        a_model_not_required_nullable_model.additional_properties = d
+        return a_model_not_required_nullable_model
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties