fix: nullable passthrough in single union refs

Author: dbanty

Diff for: end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py

@@ -29,8 +29,8 @@ def _get_kwargs(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    nullable_required_model_prop: ModelWithUnionProperty,
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Dict[str, Any]:
     url = "{}/tests/defaults".format(client.base_url)
 
@@ -92,11 +92,11 @@ def _get_kwargs(
 
     json_required_model_prop = required_model_prop.to_dict()
 
-    json_nullable_model_prop: Union[Unset, Dict[str, Any]] = UNSET
+    json_nullable_model_prop: Union[Unset, None, Dict[str, Any]] = UNSET
     if not isinstance(nullable_model_prop, Unset):
-        json_nullable_model_prop = nullable_model_prop.to_dict()
+        json_nullable_model_prop = nullable_model_prop.to_dict() if nullable_model_prop else None
 
-    json_nullable_required_model_prop = nullable_required_model_prop.to_dict()
+    json_nullable_required_model_prop = nullable_required_model_prop.to_dict() if nullable_required_model_prop else None
 
     params: Dict[str, Any] = {
         "string_prop": string_prop,
@@ -116,9 +116,10 @@ def _get_kwargs(
     if not isinstance(json_model_prop, Unset):
         params.update(json_model_prop)
     params.update(json_required_model_prop)
-    if not isinstance(json_nullable_model_prop, Unset):
+    if not isinstance(json_nullable_model_prop, Unset) and json_nullable_model_prop is not None:
         params.update(json_nullable_model_prop)
-    params.update(json_nullable_required_model_prop)
+    if json_nullable_required_model_prop is not None:
+        params.update(json_nullable_required_model_prop)
     params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     return {
@@ -169,8 +170,8 @@ def sync_detailed(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    nullable_required_model_prop: ModelWithUnionProperty,
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -218,8 +219,8 @@ def sync(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    nullable_required_model_prop: ModelWithUnionProperty,
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Optional[Union[None, HTTPValidationError]]:
     """  """
 
@@ -263,8 +264,8 @@ async def asyncio_detailed(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    nullable_required_model_prop: ModelWithUnionProperty,
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -311,8 +312,8 @@ async def asyncio(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    nullable_required_model_prop: ModelWithUnionProperty,
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Optional[Union[None, HTTPValidationError]]:
     """  """
 

Diff for: end_to_end_tests/golden-record/my_test_api_client/models/a_model.py

@@ -23,10 +23,10 @@ class AModel:
     required_not_nullable: str
     one_of_models: Union[FreeFormModel, ModelWithUnionProperty]
     model: ModelWithUnionProperty
-    nullable_model: ModelWithUnionProperty
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
     nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None]
+    nullable_model: Optional[ModelWithUnionProperty]
     nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = UNSET
     a_not_required_date: Union[Unset, datetime.date] = UNSET
     attr_1_leading_digit: Union[Unset, str] = UNSET
@@ -35,7 +35,7 @@ class AModel:
     not_required_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, Unset] = UNSET
     not_required_nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str] = UNSET
     not_required_model: Union[Unset, ModelWithUnionProperty] = UNSET
-    not_required_nullable_model: Union[Unset, ModelWithUnionProperty] = UNSET
+    not_required_nullable_model: Union[Unset, None, ModelWithUnionProperty] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
@@ -56,8 +56,6 @@ def to_dict(self) -> Dict[str, Any]:
 
         model = self.model.to_dict()
 
-        nullable_model = self.nullable_model.to_dict()
-
         nested_list_of_enums: Union[Unset, List[List[str]]] = UNSET
         if not isinstance(self.nested_list_of_enums, Unset):
             nested_list_of_enums = []
@@ -119,13 +117,17 @@ def to_dict(self) -> Dict[str, Any]:
         else:
             not_required_nullable_one_of_models = self.not_required_nullable_one_of_models
 
+        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[Unset, Dict[str, Any]] = UNSET
+        not_required_nullable_model: Union[Unset, None, Dict[str, Any]] = UNSET
         if not isinstance(self.not_required_nullable_model, Unset):
-            not_required_nullable_model = self.not_required_nullable_model.to_dict()
+            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(
@@ -136,10 +138,10 @@ def to_dict(self) -> Dict[str, Any]:
                 "required_not_nullable": required_not_nullable,
                 "one_of_models": one_of_models,
                 "model": model,
-                "nullable_model": nullable_model,
                 "a_nullable_date": a_nullable_date,
                 "required_nullable": required_nullable,
                 "nullable_one_of_models": nullable_one_of_models,
+                "nullable_model": nullable_model,
             }
         )
         if nested_list_of_enums is not UNSET:
@@ -212,8 +214,6 @@ def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionPro
 
         model = ModelWithUnionProperty.from_dict(d.pop("model"))
 
-        nullable_model = ModelWithUnionProperty.from_dict(d.pop("nullable_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 []:
@@ -333,14 +333,19 @@ def _parse_not_required_nullable_one_of_models(
             d.pop("not_required_nullable_one_of_models", UNSET)
         )
 
+        nullable_model = None
+        _nullable_model = d.pop("nullable_model")
+        if _nullable_model is not None:
+            nullable_model = ModelWithUnionProperty.from_dict(_nullable_model)
+
         not_required_model: Union[Unset, ModelWithUnionProperty] = UNSET
         _not_required_model = d.pop("not_required_model", UNSET)
         if not isinstance(_not_required_model, Unset):
             not_required_model = ModelWithUnionProperty.from_dict(_not_required_model)
 
-        not_required_nullable_model: Union[Unset, ModelWithUnionProperty] = UNSET
+        not_required_nullable_model = None
         _not_required_nullable_model = d.pop("not_required_nullable_model", UNSET)
-        if not isinstance(_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 = ModelWithUnionProperty.from_dict(_not_required_nullable_model)
 
         a_model = cls(
@@ -350,7 +355,6 @@ def _parse_not_required_nullable_one_of_models(
             required_not_nullable=required_not_nullable,
             one_of_models=one_of_models,
             model=model,
-            nullable_model=nullable_model,
             nested_list_of_enums=nested_list_of_enums,
             a_nullable_date=a_nullable_date,
             a_not_required_date=a_not_required_date,
@@ -361,6 +365,7 @@ def _parse_not_required_nullable_one_of_models(
             nullable_one_of_models=nullable_one_of_models,
             not_required_one_of_models=not_required_one_of_models,
             not_required_nullable_one_of_models=not_required_nullable_one_of_models,
+            nullable_model=nullable_model,
             not_required_model=not_required_model,
             not_required_nullable_model=not_required_nullable_model,
         )

Diff for: openapi_python_client/parser/properties/__init__.py

@@ -407,7 +407,7 @@ def _property_from_ref(
     existing = schemas.classes_by_reference.get(ref_path)
     if existing:
         return (
-            attr.evolve(existing, required=required, name=name),
+            attr.evolve(existing, required=required, name=name, nullable=nullable),
             schemas,
         )
     return PropertyError(data=data, detail="Could not find reference in parsed models or enums"), schemas