Fix array schema object item issues

Previous changes prevented models defined in array schemas from being
built properly. This commit fixes that issue and adds support for
recursive and circular references in array schema item objects, a
behavior that was previously expected but not functioning correctly. This
does not add support for recursive and circular references directly in an
array schema's 'items' section. However, this feature would be
functionally useless, so a warning is logged on detection.

Author: maz808

end_to_end_tests/golden-record/my_test_api_client/models/__init__.py

@@ -6,6 +6,18 @@
 from .all_of_sub_model import AllOfSubModel
 from .all_of_sub_model_type_enum import AllOfSubModelTypeEnum
 from .an_all_of_enum import AnAllOfEnum
+from .an_array_with_a_circular_ref_in_items_object_a_item import AnArrayWithACircularRefInItemsObjectAItem
+from .an_array_with_a_circular_ref_in_items_object_additional_properties_a_item import (
+    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem,
+)
+from .an_array_with_a_circular_ref_in_items_object_additional_properties_b_item import (
+    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem,
+)
+from .an_array_with_a_circular_ref_in_items_object_b_item import AnArrayWithACircularRefInItemsObjectBItem
+from .an_array_with_a_recursive_ref_in_items_object_additional_properties_item import (
+    AnArrayWithARecursiveRefInItemsObjectAdditionalPropertiesItem,
+)
+from .an_array_with_a_recursive_ref_in_items_object_item import AnArrayWithARecursiveRefInItemsObjectItem
 from .an_enum import AnEnum
 from .an_enum_with_null import AnEnumWithNull
 from .an_int_enum import AnIntEnum

end_to_end_tests/golden-record/my_test_api_client/models/an_array_with_a_circular_ref_in_items_object_a_item.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..models.an_array_with_a_circular_ref_in_items_object_b_item import AnArrayWithACircularRefInItemsObjectBItem
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AnArrayWithACircularRefInItemsObjectAItem")
+
+
+@attr.s(auto_attribs=True)
+class AnArrayWithACircularRefInItemsObjectAItem:
+    """
+    Attributes:
+        circular (Union[Unset, List[AnArrayWithACircularRefInItemsObjectBItem]]):
+    """
+
+    circular: Union[Unset, List[AnArrayWithACircularRefInItemsObjectBItem]] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        circular: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.circular, Unset):
+            circular = []
+            for componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item_data in self.circular:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item = (
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item_data.to_dict()
+                )
+
+                circular.append(componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if circular is not UNSET:
+            field_dict["circular"] = circular
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        circular = []
+        _circular = d.pop("circular", UNSET)
+        for componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item_data in _circular or []:
+            componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item = (
+                AnArrayWithACircularRefInItemsObjectBItem.from_dict(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item_data
+                )
+            )
+
+            circular.append(componentsschemas_an_array_with_a_circular_ref_in_items_object_b_item)
+
+        an_array_with_a_circular_ref_in_items_object_a_item = cls(
+            circular=circular,
+        )
+
+        an_array_with_a_circular_ref_in_items_object_a_item.additional_properties = d
+        return an_array_with_a_circular_ref_in_items_object_a_item
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record/my_test_api_client/models/an_array_with_a_circular_ref_in_items_object_additional_properties_a_item.py

@@ -0,0 +1,83 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+from ..models.an_array_with_a_circular_ref_in_items_object_additional_properties_b_item import (
+    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem,
+)
+
+T = TypeVar("T", bound="AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem")
+
+
+@attr.s(auto_attribs=True)
+class AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem:
+    """ """
+
+    additional_properties: Dict[str, List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem]] = attr.ib(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for (
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item_data
+            ) in prop:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item = (
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item_data.to_dict()
+                )
+
+                field_dict[prop_name].append(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item
+                )
+
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        an_array_with_a_circular_ref_in_items_object_additional_properties_a_item = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for (
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item_data
+            ) in _additional_property:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item = (
+                    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem.from_dict(
+                        componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item_data
+                    )
+                )
+
+                additional_property.append(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_b_item
+                )
+
+            additional_properties[prop_name] = additional_property
+
+        an_array_with_a_circular_ref_in_items_object_additional_properties_a_item.additional_properties = (
+            additional_properties
+        )
+        return an_array_with_a_circular_ref_in_items_object_additional_properties_a_item
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem]) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record/my_test_api_client/models/an_array_with_a_circular_ref_in_items_object_additional_properties_b_item.py

@@ -0,0 +1,83 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+from ..models.an_array_with_a_circular_ref_in_items_object_additional_properties_a_item import (
+    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem,
+)
+
+T = TypeVar("T", bound="AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem")
+
+
+@attr.s(auto_attribs=True)
+class AnArrayWithACircularRefInItemsObjectAdditionalPropertiesBItem:
+    """ """
+
+    additional_properties: Dict[str, List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem]] = attr.ib(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for (
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item_data
+            ) in prop:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item = (
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item_data.to_dict()
+                )
+
+                field_dict[prop_name].append(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item
+                )
+
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        an_array_with_a_circular_ref_in_items_object_additional_properties_b_item = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for (
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item_data
+            ) in _additional_property:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item = (
+                    AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem.from_dict(
+                        componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item_data
+                    )
+                )
+
+                additional_property.append(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_additional_properties_a_item
+                )
+
+            additional_properties[prop_name] = additional_property
+
+        an_array_with_a_circular_ref_in_items_object_additional_properties_b_item.additional_properties = (
+            additional_properties
+        )
+        return an_array_with_a_circular_ref_in_items_object_additional_properties_b_item
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: List[AnArrayWithACircularRefInItemsObjectAdditionalPropertiesAItem]) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record/my_test_api_client/models/an_array_with_a_circular_ref_in_items_object_b_item.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..models.an_array_with_a_circular_ref_in_items_object_a_item import AnArrayWithACircularRefInItemsObjectAItem
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AnArrayWithACircularRefInItemsObjectBItem")
+
+
+@attr.s(auto_attribs=True)
+class AnArrayWithACircularRefInItemsObjectBItem:
+    """
+    Attributes:
+        circular (Union[Unset, List[AnArrayWithACircularRefInItemsObjectAItem]]):
+    """
+
+    circular: Union[Unset, List[AnArrayWithACircularRefInItemsObjectAItem]] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        circular: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.circular, Unset):
+            circular = []
+            for componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item_data in self.circular:
+                componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item = (
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item_data.to_dict()
+                )
+
+                circular.append(componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if circular is not UNSET:
+            field_dict["circular"] = circular
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        circular = []
+        _circular = d.pop("circular", UNSET)
+        for componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item_data in _circular or []:
+            componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item = (
+                AnArrayWithACircularRefInItemsObjectAItem.from_dict(
+                    componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item_data
+                )
+            )
+
+            circular.append(componentsschemas_an_array_with_a_circular_ref_in_items_object_a_item)
+
+        an_array_with_a_circular_ref_in_items_object_b_item = cls(
+            circular=circular,
+        )
+
+        an_array_with_a_circular_ref_in_items_object_b_item.additional_properties = d
+        return an_array_with_a_circular_ref_in_items_object_b_item
+
+    @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