From 3e2b86a40b059421cef09efa87f854d7797dd461 Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Wed, 17 Mar 2021 11:49:40 -0400 Subject: [PATCH 1/6] Prevent union of one model from generating new model --- .../api/tests/defaults_tests_defaults_post.py | 153 ++++++++ .../custom_e2e/models/__init__.py | 28 ++ .../custom_e2e/models/a_model.py | 368 ++++++++++++++++++ .../api/tests/defaults_tests_defaults_post.py | 43 +- .../my_test_api_client/models/__init__.py | 4 - .../my_test_api_client/models/a_model.py | 45 +-- .../models/a_model_model.py | 93 ----- .../models/a_model_not_required_model.py | 93 ----- .../a_model_not_required_nullable_model.py | 93 ----- .../models/a_model_nullable_model.py | 93 ----- .../parser/properties/__init__.py | 32 +- 11 files changed, 608 insertions(+), 437 deletions(-) create mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py create mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py create mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py delete mode 100644 end_to_end_tests/golden-record/my_test_api_client/models/a_model_model.py delete mode 100644 end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_model.py delete mode 100644 end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_nullable_model.py delete mode 100644 end_to_end_tests/golden-record/my_test_api_client/models/a_model_nullable_model.py diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py b/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py new file mode 100644 index 000000000..3cb463a18 --- /dev/null +++ b/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py @@ -0,0 +1,153 @@ +from typing import Optional + +import httpx + +from ...types import Response + +Client = httpx.Client + +import datetime +from typing import Dict, List, Optional, Union + +from dateutil.parser import isoparse + +from ...models.an_enum import AnEnum +from ...models.http_validation_error import HTTPValidationError +from ...models.model_with_union_property import ModelWithUnionProperty +from ...types import UNSET, Unset + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[None, HTTPValidationError]]: + if response.status_code == 200: + response_200 = None + + return response_200 + if response.status_code == 422: + response_422 = HTTPValidationError.from_dict(response.json()) + + return response_422 + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[None, HTTPValidationError]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def httpx_request( + *, + client: Client, + string_prop: Union[Unset, str] = "the default string", + not_required_not_nullable_datetime_prop: Union[Unset, datetime.datetime] = isoparse("1010-10-10T00:00:00"), + not_required_nullable_datetime_prop: Union[Unset, None, datetime.datetime] = isoparse("1010-10-10T00:00:00"), + required_not_nullable_datetime_prop: datetime.datetime = isoparse("1010-10-10T00:00:00"), + required_nullable_datetime_prop: Optional[datetime.datetime] = isoparse("1010-10-10T00:00:00"), + date_prop: Union[Unset, datetime.date] = isoparse("1010-10-10").date(), + float_prop: Union[Unset, float] = 3.14, + int_prop: Union[Unset, int] = 7, + boolean_prop: Union[Unset, bool] = False, + list_prop: Union[Unset, List[AnEnum]] = UNSET, + union_prop: Union[Unset, float, str] = "not a float", + union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6, + 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, +) -> Response[Union[None, HTTPValidationError]]: + + json_not_required_not_nullable_datetime_prop: Union[Unset, str] = UNSET + if not isinstance(not_required_not_nullable_datetime_prop, Unset): + json_not_required_not_nullable_datetime_prop = not_required_not_nullable_datetime_prop.isoformat() + + json_not_required_nullable_datetime_prop: Union[Unset, None, str] = UNSET + if not isinstance(not_required_nullable_datetime_prop, Unset): + json_not_required_nullable_datetime_prop = ( + not_required_nullable_datetime_prop.isoformat() if not_required_nullable_datetime_prop else None + ) + + json_required_not_nullable_datetime_prop = required_not_nullable_datetime_prop.isoformat() + + json_required_nullable_datetime_prop = ( + required_nullable_datetime_prop.isoformat() if required_nullable_datetime_prop else None + ) + + json_date_prop: Union[Unset, str] = UNSET + if not isinstance(date_prop, Unset): + json_date_prop = date_prop.isoformat() + + json_list_prop: Union[Unset, List[str]] = UNSET + if not isinstance(list_prop, Unset): + json_list_prop = [] + for list_prop_item_data in list_prop: + list_prop_item = list_prop_item_data.value + + json_list_prop.append(list_prop_item) + + json_union_prop: Union[Unset, float, str] + if isinstance(union_prop, Unset): + json_union_prop = UNSET + else: + json_union_prop = union_prop + + json_union_prop_with_ref: Union[Unset, float, str] + if isinstance(union_prop_with_ref, Unset): + json_union_prop_with_ref = UNSET + elif isinstance(union_prop_with_ref, AnEnum): + json_union_prop_with_ref = UNSET + if not isinstance(union_prop_with_ref, Unset): + json_union_prop_with_ref = union_prop_with_ref.value + + else: + json_union_prop_with_ref = union_prop_with_ref + + json_enum_prop: Union[Unset, str] = UNSET + if not isinstance(enum_prop, Unset): + json_enum_prop = enum_prop.value + + json_model_prop: Union[Unset, Dict[str, Any]] = UNSET + if not isinstance(model_prop, Unset): + json_model_prop = model_prop.to_dict() + + json_required_model_prop = required_model_prop.to_dict() + + json_nullable_model_prop: Union[Unset, Dict[str, Any]] = UNSET + if not isinstance(nullable_model_prop, Unset): + json_nullable_model_prop = nullable_model_prop.to_dict() + + json_nullable_required_model_prop = nullable_required_model_prop.to_dict() + + params: Dict[str, Any] = { + "string_prop": string_prop, + "not_required_not_nullable_datetime_prop": json_not_required_not_nullable_datetime_prop, + "not_required_nullable_datetime_prop": json_not_required_nullable_datetime_prop, + "required_not_nullable_datetime_prop": json_required_not_nullable_datetime_prop, + "required_nullable_datetime_prop": json_required_nullable_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.update(json_required_model_prop) + if not isinstance(json_nullable_model_prop, Unset): + params.update(json_nullable_model_prop) + 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} + + response = client.request( + "post", + "/tests/defaults", + params=params, + ) + + return _build_response(response=response) diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py b/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py new file mode 100644 index 000000000..61c8c56c3 --- /dev/null +++ b/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py @@ -0,0 +1,28 @@ +""" Contains all the data models used in inputs/outputs """ + +from .a_model import AModel +from .all_of_sub_model import AllOfSubModel +from .an_enum import AnEnum +from .an_int_enum import AnIntEnum +from .another_all_of_sub_model import AnotherAllOfSubModel +from .body_upload_file_tests_upload_post import BodyUploadFileTestsUploadPost +from .different_enum import DifferentEnum +from .free_form_model import FreeFormModel +from .http_validation_error import HTTPValidationError +from .model_from_all_of import ModelFromAllOf +from .model_with_additional_properties_inlined import ModelWithAdditionalPropertiesInlined +from .model_with_additional_properties_inlined_additional_property import ( + ModelWithAdditionalPropertiesInlinedAdditionalProperty, +) +from .model_with_additional_properties_refed import ModelWithAdditionalPropertiesRefed +from .model_with_any_json_properties import ModelWithAnyJsonProperties +from .model_with_any_json_properties_additional_property_type0 import ModelWithAnyJsonPropertiesAdditionalPropertyType0 +from .model_with_primitive_additional_properties import ModelWithPrimitiveAdditionalProperties +from .model_with_primitive_additional_properties_a_date_holder import ModelWithPrimitiveAdditionalPropertiesADateHolder +from .model_with_union_property import ModelWithUnionProperty +from .model_with_union_property_inlined import ModelWithUnionPropertyInlined +from .model_with_union_property_inlined_fruit_type0 import ModelWithUnionPropertyInlinedFruitType0 +from .model_with_union_property_inlined_fruit_type1 import ModelWithUnionPropertyInlinedFruitType1 +from .test_inline_objects_json_body import TestInlineObjectsJsonBody +from .test_inline_objects_response_200 import TestInlineObjectsResponse_200 +from .validation_error import ValidationError diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py b/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py new file mode 100644 index 000000000..29a98a19f --- /dev/null +++ b/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py @@ -0,0 +1,368 @@ +import datetime +from typing import Any, Dict, List, Optional, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.an_enum import AnEnum +from ..models.different_enum import DifferentEnum +from ..models.free_form_model import FreeFormModel +from ..models.model_with_union_property import ModelWithUnionProperty +from ..types import UNSET, Unset + +T = TypeVar("T", bound="AModel") + + +@attr.s(auto_attribs=True) +class AModel: + """ A Model for testing all the ways custom objects can be used """ + + an_enum_value: AnEnum + a_camel_date_time: Union[datetime.date, datetime.datetime] + a_date: datetime.date + 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] + 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 + not_required_nullable: Union[Unset, None, str] = UNSET + not_required_not_nullable: Union[Unset, str] = UNSET + 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 + + def to_dict(self) -> Dict[str, Any]: + an_enum_value = self.an_enum_value.value + + if isinstance(self.a_camel_date_time, datetime.datetime): + a_camel_date_time = self.a_camel_date_time.isoformat() + + else: + a_camel_date_time = self.a_camel_date_time.isoformat() + + a_date = self.a_date.isoformat() + required_not_nullable = self.required_not_nullable + if isinstance(self.one_of_models, FreeFormModel): + one_of_models = self.one_of_models.to_dict() + + else: + one_of_models = self.one_of_models.to_dict() + + 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 = [] + for nested_list_of_enums_item_data in self.nested_list_of_enums: + 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 = nested_list_of_enums_item_item_data.value + + nested_list_of_enums_item.append(nested_list_of_enums_item_item) + + nested_list_of_enums.append(nested_list_of_enums_item) + + a_nullable_date = self.a_nullable_date.isoformat() if self.a_nullable_date else None + a_not_required_date: Union[Unset, str] = UNSET + if not isinstance(self.a_not_required_date, Unset): + a_not_required_date = self.a_not_required_date.isoformat() + + 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 + nullable_one_of_models: Union[Dict[str, Any], None] + if self.nullable_one_of_models is None: + nullable_one_of_models = None + elif isinstance(self.nullable_one_of_models, FreeFormModel): + nullable_one_of_models = self.nullable_one_of_models.to_dict() + + else: + nullable_one_of_models = self.nullable_one_of_models.to_dict() + + not_required_one_of_models: Union[Dict[str, Any], Unset] + if isinstance(self.not_required_one_of_models, Unset): + not_required_one_of_models = UNSET + elif isinstance(self.not_required_one_of_models, FreeFormModel): + not_required_one_of_models = UNSET + if not isinstance(self.not_required_one_of_models, Unset): + not_required_one_of_models = self.not_required_one_of_models.to_dict() + + else: + not_required_one_of_models = UNSET + if not isinstance(self.not_required_one_of_models, Unset): + not_required_one_of_models = self.not_required_one_of_models.to_dict() + + not_required_nullable_one_of_models: Union[Dict[str, Any], None, Unset, str] + if isinstance(self.not_required_nullable_one_of_models, Unset): + not_required_nullable_one_of_models = UNSET + elif self.not_required_nullable_one_of_models is None: + not_required_nullable_one_of_models = None + elif isinstance(self.not_required_nullable_one_of_models, FreeFormModel): + not_required_nullable_one_of_models = UNSET + if not isinstance(self.not_required_nullable_one_of_models, Unset): + not_required_nullable_one_of_models = self.not_required_nullable_one_of_models.to_dict() + + elif isinstance(self.not_required_nullable_one_of_models, ModelWithUnionProperty): + not_required_nullable_one_of_models = UNSET + if not isinstance(self.not_required_nullable_one_of_models, Unset): + not_required_nullable_one_of_models = self.not_required_nullable_one_of_models.to_dict() + + else: + not_required_nullable_one_of_models = self.not_required_nullable_one_of_models + + 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 + if not isinstance(self.not_required_nullable_model, Unset): + not_required_nullable_model = self.not_required_nullable_model.to_dict() + + field_dict: Dict[str, Any] = {} + field_dict.update( + { + "an_enum_value": an_enum_value, + "aCamelDateTime": a_camel_date_time, + "a_date": a_date, + "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, + } + ) + if nested_list_of_enums is not UNSET: + field_dict["nested_list_of_enums"] = nested_list_of_enums + if a_not_required_date is not UNSET: + field_dict["a_not_required_date"] = a_not_required_date + 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 + if not_required_one_of_models is not UNSET: + field_dict["not_required_one_of_models"] = not_required_one_of_models + if not_required_nullable_one_of_models is not UNSET: + field_dict["not_required_nullable_one_of_models"] = not_required_nullable_one_of_models + 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 + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + an_enum_value = AnEnum(d.pop("an_enum_value")) + + def _parse_a_camel_date_time(data: object) -> Union[datetime.date, datetime.datetime]: + try: + a_camel_date_time_type0: datetime.datetime + if not isinstance(data, str): + raise TypeError() + a_camel_date_time_type0 = isoparse(data) + + return a_camel_date_time_type0 + except: # noqa: E722 + pass + if not isinstance(data, str): + raise TypeError() + a_camel_date_time_type1: datetime.date + a_camel_date_time_type1 = isoparse(data).date() + + return a_camel_date_time_type1 + + a_camel_date_time = _parse_a_camel_date_time(d.pop("aCamelDateTime")) + + a_date = isoparse(d.pop("a_date")).date() + + required_not_nullable = d.pop("required_not_nullable") + + def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty]: + try: + one_of_models_type0: FreeFormModel + if not isinstance(data, dict): + raise TypeError() + one_of_models_type0 = FreeFormModel.from_dict(data) + + return one_of_models_type0 + except: # noqa: E722 + pass + if not isinstance(data, dict): + raise TypeError() + one_of_models_type1: ModelWithUnionProperty + one_of_models_type1 = ModelWithUnionProperty.from_dict(data) + + return one_of_models_type1 + + one_of_models = _parse_one_of_models(d.pop("one_of_models")) + + 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 []: + nested_list_of_enums_item = [] + _nested_list_of_enums_item = nested_list_of_enums_item_data + for nested_list_of_enums_item_item_data in _nested_list_of_enums_item: + nested_list_of_enums_item_item = DifferentEnum(nested_list_of_enums_item_item_data) + + nested_list_of_enums_item.append(nested_list_of_enums_item_item) + + nested_list_of_enums.append(nested_list_of_enums_item) + + a_nullable_date = None + _a_nullable_date = d.pop("a_nullable_date") + if _a_nullable_date is not None: + a_nullable_date = isoparse(_a_nullable_date).date() + + a_not_required_date: Union[Unset, datetime.date] = UNSET + _a_not_required_date = d.pop("a_not_required_date", UNSET) + if not isinstance(_a_not_required_date, Unset): + a_not_required_date = isoparse(_a_not_required_date).date() + + attr_1_leading_digit = d.pop("1_leading_digit", UNSET) + + required_nullable = d.pop("required_nullable") + + not_required_nullable = d.pop("not_required_nullable", UNSET) + + not_required_not_nullable = d.pop("not_required_not_nullable", UNSET) + + def _parse_nullable_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty, None]: + if data is None: + return data + try: + nullable_one_of_models_type0: FreeFormModel + if not isinstance(data, dict): + raise TypeError() + nullable_one_of_models_type0 = FreeFormModel.from_dict(data) + + return nullable_one_of_models_type0 + except: # noqa: E722 + pass + if not isinstance(data, dict): + raise TypeError() + nullable_one_of_models_type1: ModelWithUnionProperty + nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(data) + + return nullable_one_of_models_type1 + + nullable_one_of_models = _parse_nullable_one_of_models(d.pop("nullable_one_of_models")) + + def _parse_not_required_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty, Unset]: + if isinstance(data, Unset): + return data + try: + not_required_one_of_models_type0: Union[Unset, FreeFormModel] + if not isinstance(data, dict): + raise TypeError() + not_required_one_of_models_type0 = UNSET + _not_required_one_of_models_type0 = data + if not isinstance(_not_required_one_of_models_type0, Unset): + not_required_one_of_models_type0 = FreeFormModel.from_dict(_not_required_one_of_models_type0) + + return not_required_one_of_models_type0 + except: # noqa: E722 + pass + if not isinstance(data, dict): + raise TypeError() + not_required_one_of_models_type1: Union[Unset, ModelWithUnionProperty] + not_required_one_of_models_type1 = UNSET + _not_required_one_of_models_type1 = data + if not isinstance(_not_required_one_of_models_type1, Unset): + not_required_one_of_models_type1 = ModelWithUnionProperty.from_dict(_not_required_one_of_models_type1) + + return not_required_one_of_models_type1 + + not_required_one_of_models = _parse_not_required_one_of_models(d.pop("not_required_one_of_models", UNSET)) + + def _parse_not_required_nullable_one_of_models( + data: object, + ) -> Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str]: + if data is None: + return data + if isinstance(data, Unset): + return data + try: + not_required_nullable_one_of_models_type0: Union[Unset, FreeFormModel] + if not isinstance(data, dict): + raise TypeError() + not_required_nullable_one_of_models_type0 = UNSET + _not_required_nullable_one_of_models_type0 = data + if not isinstance(_not_required_nullable_one_of_models_type0, Unset): + not_required_nullable_one_of_models_type0 = FreeFormModel.from_dict( + _not_required_nullable_one_of_models_type0 + ) + + return not_required_nullable_one_of_models_type0 + except: # noqa: E722 + pass + try: + not_required_nullable_one_of_models_type1: Union[Unset, ModelWithUnionProperty] + if not isinstance(data, dict): + raise TypeError() + not_required_nullable_one_of_models_type1 = UNSET + _not_required_nullable_one_of_models_type1 = data + if not isinstance(_not_required_nullable_one_of_models_type1, Unset): + not_required_nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict( + _not_required_nullable_one_of_models_type1 + ) + + return not_required_nullable_one_of_models_type1 + except: # noqa: E722 + pass + return cast(Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str], data) + + not_required_nullable_one_of_models = _parse_not_required_nullable_one_of_models( + d.pop("not_required_nullable_one_of_models", UNSET) + ) + + 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 = d.pop("not_required_nullable_model", UNSET) + if not isinstance(_not_required_nullable_model, Unset): + not_required_nullable_model = ModelWithUnionProperty.from_dict(_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, + 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, + 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_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, + not_required_model=not_required_model, + not_required_nullable_model=not_required_nullable_model, + ) + + return a_model diff --git a/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py b/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py index b6aaaea6e..29d16b1d2 100644 --- a/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py +++ b/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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: ModelWithUnionProperty, ) -> Dict[str, Any]: url = "{}/tests/defaults".format(client.base_url) @@ -92,21 +92,11 @@ def _get_kwargs( json_required_model_prop = required_model_prop.to_dict() - json_nullable_model_prop: Union[Dict[str, Any], None, Unset] - if isinstance(nullable_model_prop, Unset): - json_nullable_model_prop = UNSET - elif nullable_model_prop is None: - json_nullable_model_prop = None - else: - json_nullable_model_prop = UNSET - if not isinstance(nullable_model_prop, Unset): - json_nullable_model_prop = nullable_model_prop.to_dict() + json_nullable_model_prop: Union[Unset, Dict[str, Any]] = UNSET + if not isinstance(nullable_model_prop, Unset): + json_nullable_model_prop = nullable_model_prop.to_dict() - json_nullable_required_model_prop: Union[Dict[str, Any], None] - if nullable_required_model_prop is None: - json_nullable_required_model_prop = None - else: - json_nullable_required_model_prop = nullable_required_model_prop.to_dict() + json_nullable_required_model_prop = nullable_required_model_prop.to_dict() params: Dict[str, Any] = { "string_prop": string_prop, @@ -122,12 +112,13 @@ def _get_kwargs( "union_prop": json_union_prop, "union_prop_with_ref": json_union_prop_with_ref, "enum_prop": json_enum_prop, - "nullable_model_prop": json_nullable_model_prop, - "nullable_required_model_prop": json_nullable_required_model_prop, } 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): + params.update(json_nullable_model_prop) + 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 { @@ -178,8 +169,8 @@ def sync_detailed( enum_prop: Union[Unset, AnEnum] = UNSET, model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, required_model_prop: ModelWithUnionProperty, - nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: ModelWithUnionProperty, ) -> Response[Union[None, HTTPValidationError]]: kwargs = _get_kwargs( client=client, @@ -227,8 +218,8 @@ def sync( enum_prop: Union[Unset, AnEnum] = UNSET, model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, required_model_prop: ModelWithUnionProperty, - nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: ModelWithUnionProperty, ) -> Optional[Union[None, HTTPValidationError]]: """ """ @@ -272,8 +263,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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: ModelWithUnionProperty, ) -> Response[Union[None, HTTPValidationError]]: kwargs = _get_kwargs( client=client, @@ -320,8 +311,8 @@ async def asyncio( enum_prop: Union[Unset, AnEnum] = UNSET, model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, required_model_prop: ModelWithUnionProperty, - nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: ModelWithUnionProperty, ) -> Optional[Union[None, HTTPValidationError]]: """ """ diff --git a/end_to_end_tests/golden-record/my_test_api_client/models/__init__.py b/end_to_end_tests/golden-record/my_test_api_client/models/__init__.py index 97515ed35..61c8c56c3 100644 --- a/end_to_end_tests/golden-record/my_test_api_client/models/__init__.py +++ b/end_to_end_tests/golden-record/my_test_api_client/models/__init__.py @@ -1,10 +1,6 @@ """ 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 .all_of_sub_model import AllOfSubModel from .an_enum import AnEnum from .an_int_enum import AnIntEnum diff --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py index 91b62c01b..29a98a19f 100644 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py +++ b/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py @@ -4,10 +4,6 @@ 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 ..models.free_form_model import FreeFormModel @@ -26,11 +22,11 @@ class AModel: a_date: datetime.date required_not_nullable: str one_of_models: Union[FreeFormModel, ModelWithUnionProperty] - model: AModelModel + 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[AModelNullableModel] 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 @@ -38,8 +34,8 @@ class AModel: not_required_not_nullable: Union[Unset, str] = UNSET 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, AModelNotRequiredModel] = UNSET - not_required_nullable_model: Union[Unset, None, AModelNotRequiredNullableModel] = UNSET + not_required_model: Union[Unset, ModelWithUnionProperty] = UNSET + not_required_nullable_model: Union[Unset, ModelWithUnionProperty] = UNSET def to_dict(self) -> Dict[str, Any]: an_enum_value = self.an_enum_value.value @@ -60,6 +56,8 @@ 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 = [] @@ -121,17 +119,13 @@ 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, None, Dict[str, Any]] = UNSET + not_required_nullable_model: Union[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 - ) + not_required_nullable_model = self.not_required_nullable_model.to_dict() field_dict: Dict[str, Any] = {} field_dict.update( @@ -142,10 +136,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: @@ -216,7 +210,9 @@ def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionPro one_of_models = _parse_one_of_models(d.pop("one_of_models")) - model = AModelModel.from_dict(d.pop("model")) + 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) @@ -337,20 +333,15 @@ 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 = AModelNullableModel.from_dict(_nullable_model) - - not_required_model: Union[Unset, AModelNotRequiredModel] = UNSET + 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 = AModelNotRequiredModel.from_dict(_not_required_model) + not_required_model = ModelWithUnionProperty.from_dict(_not_required_model) - not_required_nullable_model = None + not_required_nullable_model: Union[Unset, ModelWithUnionProperty] = UNSET _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(_not_required_nullable_model) + if not isinstance(_not_required_nullable_model, Unset): + not_required_nullable_model = ModelWithUnionProperty.from_dict(_not_required_nullable_model) a_model = cls( an_enum_value=an_enum_value, @@ -359,6 +350,7 @@ 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, @@ -369,7 +361,6 @@ 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 --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model_model.py deleted file mode 100644 index 0a7a54bd6..000000000 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_model.py +++ /dev/null @@ -1,93 +0,0 @@ -from typing import Any, Dict, List, Type, TypeVar, Union - -import attr - -from ..models.an_enum import AnEnum -from ..models.an_int_enum import AnIntEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="AModelModel") - - -@attr.s(auto_attribs=True) -class AModelModel: - """ """ - - a_property: Union[AnEnum, AnIntEnum, Unset] = UNSET - additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) - - def to_dict(self) -> Dict[str, Any]: - a_property: Union[Unset, int, str] - if isinstance(self.a_property, Unset): - a_property = UNSET - elif isinstance(self.a_property, AnEnum): - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - else: - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - field_dict: Dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if a_property is not UNSET: - field_dict["a_property"] = a_property - - return field_dict - - @classmethod - def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: - d = src_dict.copy() - - def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]: - if isinstance(data, Unset): - return data - try: - a_property_type0: Union[Unset, AnEnum] - if not isinstance(data, str): - raise TypeError() - a_property_type0 = UNSET - _a_property_type0 = data - if not isinstance(_a_property_type0, Unset): - a_property_type0 = AnEnum(_a_property_type0) - - return a_property_type0 - except: # noqa: E722 - pass - if not isinstance(data, int): - raise TypeError() - a_property_type1: Union[Unset, AnIntEnum] - a_property_type1 = UNSET - _a_property_type1 = data - if not isinstance(_a_property_type1, Unset): - a_property_type1 = AnIntEnum(_a_property_type1) - - return a_property_type1 - - a_property = _parse_a_property(d.pop("a_property", UNSET)) - - a_model_model = cls( - a_property=a_property, - ) - - 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 diff --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_model.py deleted file mode 100644 index fd568db52..000000000 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_model.py +++ /dev/null @@ -1,93 +0,0 @@ -from typing import Any, Dict, List, Type, TypeVar, Union - -import attr - -from ..models.an_enum import AnEnum -from ..models.an_int_enum import AnIntEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="AModelNotRequiredModel") - - -@attr.s(auto_attribs=True) -class AModelNotRequiredModel: - """ """ - - a_property: Union[AnEnum, AnIntEnum, Unset] = UNSET - additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) - - def to_dict(self) -> Dict[str, Any]: - a_property: Union[Unset, int, str] - if isinstance(self.a_property, Unset): - a_property = UNSET - elif isinstance(self.a_property, AnEnum): - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - else: - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - field_dict: Dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if a_property is not UNSET: - field_dict["a_property"] = a_property - - return field_dict - - @classmethod - def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: - d = src_dict.copy() - - def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]: - if isinstance(data, Unset): - return data - try: - a_property_type0: Union[Unset, AnEnum] - if not isinstance(data, str): - raise TypeError() - a_property_type0 = UNSET - _a_property_type0 = data - if not isinstance(_a_property_type0, Unset): - a_property_type0 = AnEnum(_a_property_type0) - - return a_property_type0 - except: # noqa: E722 - pass - if not isinstance(data, int): - raise TypeError() - a_property_type1: Union[Unset, AnIntEnum] - a_property_type1 = UNSET - _a_property_type1 = data - if not isinstance(_a_property_type1, Unset): - a_property_type1 = AnIntEnum(_a_property_type1) - - return a_property_type1 - - a_property = _parse_a_property(d.pop("a_property", UNSET)) - - a_model_not_required_model = cls( - a_property=a_property, - ) - - 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 diff --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_nullable_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_nullable_model.py deleted file mode 100644 index 6413e7f9a..000000000 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_not_required_nullable_model.py +++ /dev/null @@ -1,93 +0,0 @@ -from typing import Any, Dict, List, Type, TypeVar, Union - -import attr - -from ..models.an_enum import AnEnum -from ..models.an_int_enum import AnIntEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="AModelNotRequiredNullableModel") - - -@attr.s(auto_attribs=True) -class AModelNotRequiredNullableModel: - """ """ - - a_property: Union[AnEnum, AnIntEnum, Unset] = UNSET - additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) - - def to_dict(self) -> Dict[str, Any]: - a_property: Union[Unset, int, str] - if isinstance(self.a_property, Unset): - a_property = UNSET - elif isinstance(self.a_property, AnEnum): - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - else: - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - field_dict: Dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if a_property is not UNSET: - field_dict["a_property"] = a_property - - return field_dict - - @classmethod - def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: - d = src_dict.copy() - - def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]: - if isinstance(data, Unset): - return data - try: - a_property_type0: Union[Unset, AnEnum] - if not isinstance(data, str): - raise TypeError() - a_property_type0 = UNSET - _a_property_type0 = data - if not isinstance(_a_property_type0, Unset): - a_property_type0 = AnEnum(_a_property_type0) - - return a_property_type0 - except: # noqa: E722 - pass - if not isinstance(data, int): - raise TypeError() - a_property_type1: Union[Unset, AnIntEnum] - a_property_type1 = UNSET - _a_property_type1 = data - if not isinstance(_a_property_type1, Unset): - a_property_type1 = AnIntEnum(_a_property_type1) - - return a_property_type1 - - a_property = _parse_a_property(d.pop("a_property", UNSET)) - - a_model_not_required_nullable_model = cls( - a_property=a_property, - ) - - 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 diff --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_nullable_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model_nullable_model.py deleted file mode 100644 index cc6484d5f..000000000 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model_nullable_model.py +++ /dev/null @@ -1,93 +0,0 @@ -from typing import Any, Dict, List, Type, TypeVar, Union - -import attr - -from ..models.an_enum import AnEnum -from ..models.an_int_enum import AnIntEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="AModelNullableModel") - - -@attr.s(auto_attribs=True) -class AModelNullableModel: - """ """ - - a_property: Union[AnEnum, AnIntEnum, Unset] = UNSET - additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) - - def to_dict(self) -> Dict[str, Any]: - a_property: Union[Unset, int, str] - if isinstance(self.a_property, Unset): - a_property = UNSET - elif isinstance(self.a_property, AnEnum): - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - else: - a_property = UNSET - if not isinstance(self.a_property, Unset): - a_property = self.a_property.value - - field_dict: Dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if a_property is not UNSET: - field_dict["a_property"] = a_property - - return field_dict - - @classmethod - def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: - d = src_dict.copy() - - def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]: - if isinstance(data, Unset): - return data - try: - a_property_type0: Union[Unset, AnEnum] - if not isinstance(data, str): - raise TypeError() - a_property_type0 = UNSET - _a_property_type0 = data - if not isinstance(_a_property_type0, Unset): - a_property_type0 = AnEnum(_a_property_type0) - - return a_property_type0 - except: # noqa: E722 - pass - if not isinstance(data, int): - raise TypeError() - a_property_type1: Union[Unset, AnIntEnum] - a_property_type1 = UNSET - _a_property_type1 = data - if not isinstance(_a_property_type1, Unset): - a_property_type1 = AnIntEnum(_a_property_type1) - - return a_property_type1 - - a_property = _parse_a_property(d.pop("a_property", UNSET)) - - a_model_nullable_model = cls( - a_property=a_property, - ) - - a_model_nullable_model.additional_properties = d - return a_model_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 diff --git a/openapi_python_client/parser/properties/__init__.py b/openapi_python_client/parser/properties/__init__.py index dfa832468..8379517d2 100644 --- a/openapi_python_client/parser/properties/__init__.py +++ b/openapi_python_client/parser/properties/__init__.py @@ -378,6 +378,23 @@ def build_list_property( ) +def _property_from_ref( + name: str, + required: bool, + nullable: bool, + data: oai.Reference, + schemas: Schemas, +) -> Tuple[Union[Property, PropertyError], Schemas]: + reference = Reference.from_ref(data.ref) + existing = schemas.enums.get(reference.class_name) or schemas.models.get(reference.class_name) + if existing: + return ( + 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 + + def _property_from_data( name: str, required: bool, @@ -388,14 +405,13 @@ def _property_from_data( """ Generate a Property from the OpenAPI dictionary representation of it """ name = utils.remove_string_escapes(name) if isinstance(data, oai.Reference): - reference = Reference.from_ref(data.ref) - existing = schemas.enums.get(reference.class_name) or schemas.models.get(reference.class_name) - if existing: - return ( - attr.evolve(existing, required=required, name=name), - schemas, - ) - return PropertyError(data=data, detail="Could not find reference in parsed models or enums"), schemas + return _property_from_ref(name=name, required=required, nullable=False, data=data, schemas=schemas) + + for attribute in ["allOf", "anyOf", "oneOf"]: + sub_data = getattr(data, attribute) + if sub_data and len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference): + return _property_from_ref(name=name, required=required, nullable=False, data=sub_data[0], schemas=schemas) + if data.enum: return build_enum_property( data=data, name=name, required=required, schemas=schemas, enum=data.enum, parent_name=parent_name From 1bd832b37e64305932c308681a7a295159fc8a7d Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Wed, 17 Mar 2021 11:54:17 -0400 Subject: [PATCH 2/6] Regen with nullable --- .../api/tests/defaults_tests_defaults_post.py | 15 ++++----- .../custom_e2e/models/a_model.py | 29 ++++++++++------- .../api/tests/defaults_tests_defaults_post.py | 31 ++++++++++--------- .../my_test_api_client/models/a_model.py | 29 ++++++++++------- .../parser/properties/__init__.py | 2 +- 5 files changed, 59 insertions(+), 47 deletions(-) diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py b/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py index 3cb463a18..07b93817f 100644 --- a/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py +++ b/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py @@ -56,8 +56,8 @@ def httpx_request( 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]]: json_not_required_not_nullable_datetime_prop: Union[Unset, str] = UNSET @@ -115,11 +115,11 @@ def httpx_request( 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, @@ -139,9 +139,10 @@ def httpx_request( 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} response = client.request( diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py b/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py index 29a98a19f..b79f2e8d4 100644 --- a/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py +++ b/end_to_end_tests/golden-record-custom/custom_e2e/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 --git a/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py b/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py index 29d16b1d2..88e4421f4 100644 --- a/end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py +++ b/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 --git a/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py b/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py index 29a98a19f..b79f2e8d4 100644 --- a/end_to_end_tests/golden-record/my_test_api_client/models/a_model.py +++ b/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 --git a/openapi_python_client/parser/properties/__init__.py b/openapi_python_client/parser/properties/__init__.py index 8379517d2..e645b078f 100644 --- a/openapi_python_client/parser/properties/__init__.py +++ b/openapi_python_client/parser/properties/__init__.py @@ -410,7 +410,7 @@ def _property_from_data( for attribute in ["allOf", "anyOf", "oneOf"]: sub_data = getattr(data, attribute) if sub_data and len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference): - return _property_from_ref(name=name, required=required, nullable=False, data=sub_data[0], schemas=schemas) + return _property_from_ref(name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas) if data.enum: return build_enum_property( From 48b9de9fd335ed1b7dcb7fcf476b6a6824b70965 Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Wed, 17 Mar 2021 12:10:56 -0400 Subject: [PATCH 3/6] Add unit test --- .../test_parser/test_properties/test_init.py | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/tests/test_parser/test_properties/test_init.py b/tests/test_parser/test_properties/test_init.py index 69a1289d1..4365e5654 100644 --- a/tests/test_parser/test_properties/test_init.py +++ b/tests/test_parser/test_properties/test_init.py @@ -793,6 +793,49 @@ def test_property_from_data_union(self, mocker): data=data, name=name, required=required, schemas=schemas, parent_name="parent" ) + def test_property_from_data_union_of_one_element(self, mocker): + from openapi_python_client.parser.properties import ModelProperty, Reference, Schemas, property_from_data + + name = "new_name" + required = False + class_name = "MyModel" + existing_model = ModelProperty( + name="old_name", + required=True, + nullable=False, + default=None, + reference=Reference(class_name=class_name, module_name="my_model"), + required_properties=[], + optional_properties=[], + description="", + relative_imports=set(), + additional_properties=False, + ) + schemas = Schemas(models={class_name: existing_model}) + + data = oai.Schema.construct( + allOf=[oai.Reference.construct(ref=class_name)], + nullable=True, + ) + build_union_property = mocker.patch(f"{MODULE_NAME}.build_union_property") + mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name) + + prop, schemas = property_from_data(name=name, required=required, data=data, schemas=schemas, parent_name="parent") + + assert prop == ModelProperty( + name=name, + required=required, + nullable=True, + default=None, + reference=Reference(class_name=class_name, module_name="my_model"), + required_properties=[], + optional_properties=[], + description="", + relative_imports=set(), + additional_properties=False, + ) + build_union_property.assert_not_called() + def test_property_from_data_unsupported_type(self, mocker): name = mocker.MagicMock() required = mocker.MagicMock() From 30f69bcf54049b04104e582808d758d8991265d8 Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Wed, 17 Mar 2021 12:12:28 -0400 Subject: [PATCH 4/6] Lint --- openapi_python_client/parser/properties/__init__.py | 4 +++- tests/test_parser/test_properties/test_init.py | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/openapi_python_client/parser/properties/__init__.py b/openapi_python_client/parser/properties/__init__.py index e645b078f..d6b9bd9ab 100644 --- a/openapi_python_client/parser/properties/__init__.py +++ b/openapi_python_client/parser/properties/__init__.py @@ -410,7 +410,9 @@ def _property_from_data( for attribute in ["allOf", "anyOf", "oneOf"]: sub_data = getattr(data, attribute) if sub_data and len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference): - return _property_from_ref(name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas) + return _property_from_ref( + name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas + ) if data.enum: return build_enum_property( diff --git a/tests/test_parser/test_properties/test_init.py b/tests/test_parser/test_properties/test_init.py index 4365e5654..749db4d44 100644 --- a/tests/test_parser/test_properties/test_init.py +++ b/tests/test_parser/test_properties/test_init.py @@ -820,7 +820,9 @@ def test_property_from_data_union_of_one_element(self, mocker): build_union_property = mocker.patch(f"{MODULE_NAME}.build_union_property") mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name) - prop, schemas = property_from_data(name=name, required=required, data=data, schemas=schemas, parent_name="parent") + prop, schemas = property_from_data( + name=name, required=required, data=data, schemas=schemas, parent_name="parent" + ) assert prop == ModelProperty( name=name, From f0fed567e63fb60417a5af90637910dd89c152d9 Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Sun, 28 Mar 2021 20:08:57 -0400 Subject: [PATCH 5/6] Remove golden-record-custom --- .../api/tests/defaults_tests_defaults_post.py | 154 -------- .../custom_e2e/models/__init__.py | 28 -- .../custom_e2e/models/a_model.py | 373 ------------------ 3 files changed, 555 deletions(-) delete mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py delete mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py delete mode 100644 end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py b/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py deleted file mode 100644 index 07b93817f..000000000 --- a/end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py +++ /dev/null @@ -1,154 +0,0 @@ -from typing import Optional - -import httpx - -from ...types import Response - -Client = httpx.Client - -import datetime -from typing import Dict, List, Optional, Union - -from dateutil.parser import isoparse - -from ...models.an_enum import AnEnum -from ...models.http_validation_error import HTTPValidationError -from ...models.model_with_union_property import ModelWithUnionProperty -from ...types import UNSET, Unset - - -def _parse_response(*, response: httpx.Response) -> Optional[Union[None, HTTPValidationError]]: - if response.status_code == 200: - response_200 = None - - return response_200 - if response.status_code == 422: - response_422 = HTTPValidationError.from_dict(response.json()) - - return response_422 - return None - - -def _build_response(*, response: httpx.Response) -> Response[Union[None, HTTPValidationError]]: - return Response( - status_code=response.status_code, - content=response.content, - headers=response.headers, - parsed=_parse_response(response=response), - ) - - -def httpx_request( - *, - client: Client, - string_prop: Union[Unset, str] = "the default string", - not_required_not_nullable_datetime_prop: Union[Unset, datetime.datetime] = isoparse("1010-10-10T00:00:00"), - not_required_nullable_datetime_prop: Union[Unset, None, datetime.datetime] = isoparse("1010-10-10T00:00:00"), - required_not_nullable_datetime_prop: datetime.datetime = isoparse("1010-10-10T00:00:00"), - required_nullable_datetime_prop: Optional[datetime.datetime] = isoparse("1010-10-10T00:00:00"), - date_prop: Union[Unset, datetime.date] = isoparse("1010-10-10").date(), - float_prop: Union[Unset, float] = 3.14, - int_prop: Union[Unset, int] = 7, - boolean_prop: Union[Unset, bool] = False, - list_prop: Union[Unset, List[AnEnum]] = UNSET, - union_prop: Union[Unset, float, str] = "not a float", - union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6, - enum_prop: Union[Unset, AnEnum] = UNSET, - model_prop: Union[Unset, ModelWithUnionProperty] = UNSET, - required_model_prop: ModelWithUnionProperty, - nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET, - nullable_required_model_prop: Optional[ModelWithUnionProperty], -) -> Response[Union[None, HTTPValidationError]]: - - json_not_required_not_nullable_datetime_prop: Union[Unset, str] = UNSET - if not isinstance(not_required_not_nullable_datetime_prop, Unset): - json_not_required_not_nullable_datetime_prop = not_required_not_nullable_datetime_prop.isoformat() - - json_not_required_nullable_datetime_prop: Union[Unset, None, str] = UNSET - if not isinstance(not_required_nullable_datetime_prop, Unset): - json_not_required_nullable_datetime_prop = ( - not_required_nullable_datetime_prop.isoformat() if not_required_nullable_datetime_prop else None - ) - - json_required_not_nullable_datetime_prop = required_not_nullable_datetime_prop.isoformat() - - json_required_nullable_datetime_prop = ( - required_nullable_datetime_prop.isoformat() if required_nullable_datetime_prop else None - ) - - json_date_prop: Union[Unset, str] = UNSET - if not isinstance(date_prop, Unset): - json_date_prop = date_prop.isoformat() - - json_list_prop: Union[Unset, List[str]] = UNSET - if not isinstance(list_prop, Unset): - json_list_prop = [] - for list_prop_item_data in list_prop: - list_prop_item = list_prop_item_data.value - - json_list_prop.append(list_prop_item) - - json_union_prop: Union[Unset, float, str] - if isinstance(union_prop, Unset): - json_union_prop = UNSET - else: - json_union_prop = union_prop - - json_union_prop_with_ref: Union[Unset, float, str] - if isinstance(union_prop_with_ref, Unset): - json_union_prop_with_ref = UNSET - elif isinstance(union_prop_with_ref, AnEnum): - json_union_prop_with_ref = UNSET - if not isinstance(union_prop_with_ref, Unset): - json_union_prop_with_ref = union_prop_with_ref.value - - else: - json_union_prop_with_ref = union_prop_with_ref - - json_enum_prop: Union[Unset, str] = UNSET - if not isinstance(enum_prop, Unset): - json_enum_prop = enum_prop.value - - json_model_prop: Union[Unset, Dict[str, Any]] = UNSET - if not isinstance(model_prop, Unset): - json_model_prop = model_prop.to_dict() - - json_required_model_prop = required_model_prop.to_dict() - - 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() if nullable_model_prop else None - - 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, - "not_required_not_nullable_datetime_prop": json_not_required_not_nullable_datetime_prop, - "not_required_nullable_datetime_prop": json_not_required_nullable_datetime_prop, - "required_not_nullable_datetime_prop": json_required_not_nullable_datetime_prop, - "required_nullable_datetime_prop": json_required_nullable_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.update(json_required_model_prop) - if not isinstance(json_nullable_model_prop, Unset) and json_nullable_model_prop is not None: - params.update(json_nullable_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} - - response = client.request( - "post", - "/tests/defaults", - params=params, - ) - - return _build_response(response=response) diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py b/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py deleted file mode 100644 index 61c8c56c3..000000000 --- a/end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py +++ /dev/null @@ -1,28 +0,0 @@ -""" Contains all the data models used in inputs/outputs """ - -from .a_model import AModel -from .all_of_sub_model import AllOfSubModel -from .an_enum import AnEnum -from .an_int_enum import AnIntEnum -from .another_all_of_sub_model import AnotherAllOfSubModel -from .body_upload_file_tests_upload_post import BodyUploadFileTestsUploadPost -from .different_enum import DifferentEnum -from .free_form_model import FreeFormModel -from .http_validation_error import HTTPValidationError -from .model_from_all_of import ModelFromAllOf -from .model_with_additional_properties_inlined import ModelWithAdditionalPropertiesInlined -from .model_with_additional_properties_inlined_additional_property import ( - ModelWithAdditionalPropertiesInlinedAdditionalProperty, -) -from .model_with_additional_properties_refed import ModelWithAdditionalPropertiesRefed -from .model_with_any_json_properties import ModelWithAnyJsonProperties -from .model_with_any_json_properties_additional_property_type0 import ModelWithAnyJsonPropertiesAdditionalPropertyType0 -from .model_with_primitive_additional_properties import ModelWithPrimitiveAdditionalProperties -from .model_with_primitive_additional_properties_a_date_holder import ModelWithPrimitiveAdditionalPropertiesADateHolder -from .model_with_union_property import ModelWithUnionProperty -from .model_with_union_property_inlined import ModelWithUnionPropertyInlined -from .model_with_union_property_inlined_fruit_type0 import ModelWithUnionPropertyInlinedFruitType0 -from .model_with_union_property_inlined_fruit_type1 import ModelWithUnionPropertyInlinedFruitType1 -from .test_inline_objects_json_body import TestInlineObjectsJsonBody -from .test_inline_objects_response_200 import TestInlineObjectsResponse_200 -from .validation_error import ValidationError diff --git a/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py b/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py deleted file mode 100644 index b79f2e8d4..000000000 --- a/end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py +++ /dev/null @@ -1,373 +0,0 @@ -import datetime -from typing import Any, Dict, List, Optional, Type, TypeVar, Union, cast - -import attr -from dateutil.parser import isoparse - -from ..models.an_enum import AnEnum -from ..models.different_enum import DifferentEnum -from ..models.free_form_model import FreeFormModel -from ..models.model_with_union_property import ModelWithUnionProperty -from ..types import UNSET, Unset - -T = TypeVar("T", bound="AModel") - - -@attr.s(auto_attribs=True) -class AModel: - """ A Model for testing all the ways custom objects can be used """ - - an_enum_value: AnEnum - a_camel_date_time: Union[datetime.date, datetime.datetime] - a_date: datetime.date - required_not_nullable: str - one_of_models: Union[FreeFormModel, ModelWithUnionProperty] - 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 - not_required_nullable: Union[Unset, None, str] = UNSET - not_required_not_nullable: Union[Unset, str] = UNSET - 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, None, ModelWithUnionProperty] = UNSET - - def to_dict(self) -> Dict[str, Any]: - an_enum_value = self.an_enum_value.value - - if isinstance(self.a_camel_date_time, datetime.datetime): - a_camel_date_time = self.a_camel_date_time.isoformat() - - else: - a_camel_date_time = self.a_camel_date_time.isoformat() - - a_date = self.a_date.isoformat() - required_not_nullable = self.required_not_nullable - if isinstance(self.one_of_models, FreeFormModel): - one_of_models = self.one_of_models.to_dict() - - else: - one_of_models = self.one_of_models.to_dict() - - model = self.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 = [] - for nested_list_of_enums_item_data in self.nested_list_of_enums: - 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 = nested_list_of_enums_item_item_data.value - - nested_list_of_enums_item.append(nested_list_of_enums_item_item) - - nested_list_of_enums.append(nested_list_of_enums_item) - - a_nullable_date = self.a_nullable_date.isoformat() if self.a_nullable_date else None - a_not_required_date: Union[Unset, str] = UNSET - if not isinstance(self.a_not_required_date, Unset): - a_not_required_date = self.a_not_required_date.isoformat() - - 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 - nullable_one_of_models: Union[Dict[str, Any], None] - if self.nullable_one_of_models is None: - nullable_one_of_models = None - elif isinstance(self.nullable_one_of_models, FreeFormModel): - nullable_one_of_models = self.nullable_one_of_models.to_dict() - - else: - nullable_one_of_models = self.nullable_one_of_models.to_dict() - - not_required_one_of_models: Union[Dict[str, Any], Unset] - if isinstance(self.not_required_one_of_models, Unset): - not_required_one_of_models = UNSET - elif isinstance(self.not_required_one_of_models, FreeFormModel): - not_required_one_of_models = UNSET - if not isinstance(self.not_required_one_of_models, Unset): - not_required_one_of_models = self.not_required_one_of_models.to_dict() - - else: - not_required_one_of_models = UNSET - if not isinstance(self.not_required_one_of_models, Unset): - not_required_one_of_models = self.not_required_one_of_models.to_dict() - - not_required_nullable_one_of_models: Union[Dict[str, Any], None, Unset, str] - if isinstance(self.not_required_nullable_one_of_models, Unset): - not_required_nullable_one_of_models = UNSET - elif self.not_required_nullable_one_of_models is None: - not_required_nullable_one_of_models = None - elif isinstance(self.not_required_nullable_one_of_models, FreeFormModel): - not_required_nullable_one_of_models = UNSET - if not isinstance(self.not_required_nullable_one_of_models, Unset): - not_required_nullable_one_of_models = self.not_required_nullable_one_of_models.to_dict() - - elif isinstance(self.not_required_nullable_one_of_models, ModelWithUnionProperty): - not_required_nullable_one_of_models = UNSET - if not isinstance(self.not_required_nullable_one_of_models, Unset): - not_required_nullable_one_of_models = self.not_required_nullable_one_of_models.to_dict() - - 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, 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() if self.not_required_nullable_model else None - ) - - field_dict: Dict[str, Any] = {} - field_dict.update( - { - "an_enum_value": an_enum_value, - "aCamelDateTime": a_camel_date_time, - "a_date": a_date, - "required_not_nullable": required_not_nullable, - "one_of_models": one_of_models, - "model": 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: - field_dict["nested_list_of_enums"] = nested_list_of_enums - if a_not_required_date is not UNSET: - field_dict["a_not_required_date"] = a_not_required_date - 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 - if not_required_one_of_models is not UNSET: - field_dict["not_required_one_of_models"] = not_required_one_of_models - if not_required_nullable_one_of_models is not UNSET: - field_dict["not_required_nullable_one_of_models"] = not_required_nullable_one_of_models - 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 - - @classmethod - def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: - d = src_dict.copy() - an_enum_value = AnEnum(d.pop("an_enum_value")) - - def _parse_a_camel_date_time(data: object) -> Union[datetime.date, datetime.datetime]: - try: - a_camel_date_time_type0: datetime.datetime - if not isinstance(data, str): - raise TypeError() - a_camel_date_time_type0 = isoparse(data) - - return a_camel_date_time_type0 - except: # noqa: E722 - pass - if not isinstance(data, str): - raise TypeError() - a_camel_date_time_type1: datetime.date - a_camel_date_time_type1 = isoparse(data).date() - - return a_camel_date_time_type1 - - a_camel_date_time = _parse_a_camel_date_time(d.pop("aCamelDateTime")) - - a_date = isoparse(d.pop("a_date")).date() - - required_not_nullable = d.pop("required_not_nullable") - - def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty]: - try: - one_of_models_type0: FreeFormModel - if not isinstance(data, dict): - raise TypeError() - one_of_models_type0 = FreeFormModel.from_dict(data) - - return one_of_models_type0 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - one_of_models_type1: ModelWithUnionProperty - one_of_models_type1 = ModelWithUnionProperty.from_dict(data) - - return one_of_models_type1 - - one_of_models = _parse_one_of_models(d.pop("one_of_models")) - - model = ModelWithUnionProperty.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 []: - nested_list_of_enums_item = [] - _nested_list_of_enums_item = nested_list_of_enums_item_data - for nested_list_of_enums_item_item_data in _nested_list_of_enums_item: - nested_list_of_enums_item_item = DifferentEnum(nested_list_of_enums_item_item_data) - - nested_list_of_enums_item.append(nested_list_of_enums_item_item) - - nested_list_of_enums.append(nested_list_of_enums_item) - - a_nullable_date = None - _a_nullable_date = d.pop("a_nullable_date") - if _a_nullable_date is not None: - a_nullable_date = isoparse(_a_nullable_date).date() - - a_not_required_date: Union[Unset, datetime.date] = UNSET - _a_not_required_date = d.pop("a_not_required_date", UNSET) - if not isinstance(_a_not_required_date, Unset): - a_not_required_date = isoparse(_a_not_required_date).date() - - attr_1_leading_digit = d.pop("1_leading_digit", UNSET) - - required_nullable = d.pop("required_nullable") - - not_required_nullable = d.pop("not_required_nullable", UNSET) - - not_required_not_nullable = d.pop("not_required_not_nullable", UNSET) - - def _parse_nullable_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty, None]: - if data is None: - return data - try: - nullable_one_of_models_type0: FreeFormModel - if not isinstance(data, dict): - raise TypeError() - nullable_one_of_models_type0 = FreeFormModel.from_dict(data) - - return nullable_one_of_models_type0 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - nullable_one_of_models_type1: ModelWithUnionProperty - nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(data) - - return nullable_one_of_models_type1 - - nullable_one_of_models = _parse_nullable_one_of_models(d.pop("nullable_one_of_models")) - - def _parse_not_required_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty, Unset]: - if isinstance(data, Unset): - return data - try: - not_required_one_of_models_type0: Union[Unset, FreeFormModel] - if not isinstance(data, dict): - raise TypeError() - not_required_one_of_models_type0 = UNSET - _not_required_one_of_models_type0 = data - if not isinstance(_not_required_one_of_models_type0, Unset): - not_required_one_of_models_type0 = FreeFormModel.from_dict(_not_required_one_of_models_type0) - - return not_required_one_of_models_type0 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - not_required_one_of_models_type1: Union[Unset, ModelWithUnionProperty] - not_required_one_of_models_type1 = UNSET - _not_required_one_of_models_type1 = data - if not isinstance(_not_required_one_of_models_type1, Unset): - not_required_one_of_models_type1 = ModelWithUnionProperty.from_dict(_not_required_one_of_models_type1) - - return not_required_one_of_models_type1 - - not_required_one_of_models = _parse_not_required_one_of_models(d.pop("not_required_one_of_models", UNSET)) - - def _parse_not_required_nullable_one_of_models( - data: object, - ) -> Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - not_required_nullable_one_of_models_type0: Union[Unset, FreeFormModel] - if not isinstance(data, dict): - raise TypeError() - not_required_nullable_one_of_models_type0 = UNSET - _not_required_nullable_one_of_models_type0 = data - if not isinstance(_not_required_nullable_one_of_models_type0, Unset): - not_required_nullable_one_of_models_type0 = FreeFormModel.from_dict( - _not_required_nullable_one_of_models_type0 - ) - - return not_required_nullable_one_of_models_type0 - except: # noqa: E722 - pass - try: - not_required_nullable_one_of_models_type1: Union[Unset, ModelWithUnionProperty] - if not isinstance(data, dict): - raise TypeError() - not_required_nullable_one_of_models_type1 = UNSET - _not_required_nullable_one_of_models_type1 = data - if not isinstance(_not_required_nullable_one_of_models_type1, Unset): - not_required_nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict( - _not_required_nullable_one_of_models_type1 - ) - - return not_required_nullable_one_of_models_type1 - except: # noqa: E722 - pass - return cast(Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str], data) - - not_required_nullable_one_of_models = _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 = 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 = ModelWithUnionProperty.from_dict(_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, - one_of_models=one_of_models, - model=model, - nested_list_of_enums=nested_list_of_enums, - a_nullable_date=a_nullable_date, - a_not_required_date=a_not_required_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_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, - ) - - return a_model From da5c8a9d14a0f0cb32e5cdaefd70ed4a7d52211b Mon Sep 17 00:00:00 2001 From: Forest Tong Date: Sun, 28 Mar 2021 20:16:06 -0400 Subject: [PATCH 6/6] Use suggestion --- openapi_python_client/parser/properties/__init__.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/openapi_python_client/parser/properties/__init__.py b/openapi_python_client/parser/properties/__init__.py index d6b9bd9ab..e7ff2b137 100644 --- a/openapi_python_client/parser/properties/__init__.py +++ b/openapi_python_client/parser/properties/__init__.py @@ -407,12 +407,11 @@ def _property_from_data( if isinstance(data, oai.Reference): return _property_from_ref(name=name, required=required, nullable=False, data=data, schemas=schemas) - for attribute in ["allOf", "anyOf", "oneOf"]: - sub_data = getattr(data, attribute) - if sub_data and len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference): - return _property_from_ref( - name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas - ) + sub_data = (data.allOf or []) + data.anyOf + data.oneOf + if len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference): + return _property_from_ref( + name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas + ) if data.enum: return build_enum_property(