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..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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + 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,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, 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: 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() if nullable_required_model_prop else None params: Dict[str, Any] = { "string_prop": string_prop, @@ -122,12 +112,14 @@ 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) 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} return { @@ -178,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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: Optional[ModelWithUnionProperty], ) -> Response[Union[None, HTTPValidationError]]: kwargs = _get_kwargs( client=client, @@ -227,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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: Optional[ModelWithUnionProperty], ) -> Optional[Union[None, HTTPValidationError]]: """ """ @@ -272,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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET, + nullable_required_model_prop: Optional[ModelWithUnionProperty], ) -> Response[Union[None, HTTPValidationError]]: kwargs = _get_kwargs( client=client, @@ -320,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[ModelWithUnionProperty, None, Unset] = UNSET, - nullable_required_model_prop: Union[ModelWithUnionProperty, None], + 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/__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..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 @@ -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 a_nullable_date: Optional[datetime.date] required_nullable: Optional[str] nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None] - nullable_model: Optional[AModelNullableModel] + 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 @@ -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, None, ModelWithUnionProperty] = UNSET def to_dict(self) -> Dict[str, Any]: an_enum_value = self.an_enum_value.value @@ -216,7 +212,7 @@ 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")) nested_list_of_enums = [] _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET) @@ -340,17 +336,17 @@ def _parse_not_required_nullable_one_of_models( nullable_model = None _nullable_model = d.pop("nullable_model") if _nullable_model is not None: - nullable_model = AModelNullableModel.from_dict(_nullable_model) + nullable_model = ModelWithUnionProperty.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 = 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) + not_required_nullable_model = ModelWithUnionProperty.from_dict(_not_required_nullable_model) a_model = cls( an_enum_value=an_enum_value, 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..e7ff2b137 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,14 @@ 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) + + 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( data=data, name=name, required=required, schemas=schemas, enum=data.enum, parent_name=parent_name diff --git a/tests/test_parser/test_properties/test_init.py b/tests/test_parser/test_properties/test_init.py index 69a1289d1..749db4d44 100644 --- a/tests/test_parser/test_properties/test_init.py +++ b/tests/test_parser/test_properties/test_init.py @@ -793,6 +793,51 @@ 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()