parser / correct recursive {direct,indirect} ref detection logic | todo: cleanup

Author: p1-ra

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

@@ -1,6 +1,7 @@
 """ Contains all the data models used in inputs/outputs """
 
 from .a_model import AModel
+from .a_model_with_direct_self_reference_property import AModelWithDirectSelfReferenceProperty
 from .a_model_with_indirect_reference_property import AModelWithIndirectReferenceProperty
 from .a_model_with_indirect_self_reference_property import AModelWithIndirectSelfReferenceProperty
 from .all_of_sub_model import AllOfSubModel

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

@@ -0,0 +1,63 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AModelWithDirectSelfReferenceProperty")
+
+
+@attr.s(auto_attribs=True)
+class AModelWithDirectSelfReferenceProperty:
+    """ """
+
+    required_self_ref: AModelWithDirectSelfReferenceProperty
+    optional_self_ref: Union[Unset, AModelWithDirectSelfReferenceProperty] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        required_self_ref = self.required_self_ref
+        optional_self_ref = self.optional_self_ref
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "required_self_ref": required_self_ref,
+            }
+        )
+        if optional_self_ref is not UNSET:
+            field_dict["optional_self_ref"] = optional_self_ref
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        required_self_ref = d.pop("required_self_ref")
+
+        optional_self_ref = d.pop("optional_self_ref", UNSET)
+
+        a_model_with_direct_self_reference_property = cls(
+            required_self_ref=required_self_ref,
+            optional_self_ref=optional_self_ref,
+        )
+
+        a_model_with_direct_self_reference_property.additional_properties = d
+        return a_model_with_direct_self_reference_property
+
+    @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/openapi.json

@@ -1210,6 +1210,20 @@
       "AnEnumIndirectReference": {
         "$ref": "#/components/schemas/AnEnum"
       },
+      "AModelWithDirectSelfReferenceProperty": {
+        "type": "object",
+        "properties": {
+          "required_self_ref": {
+            "$ref": "#/components/schemas/AModelWithDirectSelfReferenceProperty",
+          },
+          "optional_self_ref": {
+            "$ref": "#/components/schemas/AModelWithDirectSelfReferenceProperty",
+          }
+        },
+        "required": [
+          "required_self_ref"
+        ]
+      },
       "AModelWithIndirectSelfReferenceProperty": {
         "type": "object",
         "properties": {

openapi_python_client/parser/properties/__init__.py

@@ -466,7 +466,7 @@ def _property_from_ref(
 
     existing = schemas.classes_by_reference.get(ref_path)
     if not existing or not existing.data:
-        return PropertyError(data=data, detail="Could not find reference in parsed models or enums"), schemas
+        return PropertyError(data=data, detail=f"Could not find reference {ref_path} in parsed models or enums"), schemas
 
     if isinstance(existing.data, RecursiveReferenceInterupt):
         return (
@@ -613,6 +613,7 @@ def build_schemas(
     recursive_references_waiting_reprocess: Dict[str, Union[oai.Reference, oai.Schema]] = dict()
     visited: Set[_ReferencePath] = set()
     depth = 0
+
     # References could have forward References so keep going as long as we are making progress
     while still_making_progress:
         still_making_progress = False
@@ -626,17 +627,18 @@ def build_schemas(
                 schemas.errors.append(PropertyError(detail=ref_path.detail, data=data))
                 continue
 
-            visited.add(ref_path)
             schemas_or_err = update_schemas_with(
-                ref_path=ref_path, data=data, schemas=schemas, visited=visited, config=config
+                ref_path=ref_path, data=data, schemas=schemas, visited=(ref_path, visited), config=config
             )
+            visited.add(ref_path)
             if isinstance(schemas_or_err, PropertyError):
                 if isinstance(schemas_or_err, RecursiveReferenceInterupt):
                     up_schemas = schemas_or_err.schemas
                     assert isinstance(up_schemas, Schemas)  # TODO fix typedef in RecursiveReferenceInterupt
                     schemas_or_err = up_schemas
                     recursive_references_waiting_reprocess[name] = data
                 else:
+                    visited.remove(ref_path)
                     next_round.append((name, data))
                     errors.append(schemas_or_err)
                     continue

openapi_python_client/parser/properties/schemas.py

@@ -1,6 +1,6 @@
 __all__ = ["Class", "Schemas", "parse_reference_path", "update_schemas_with", "_ReferencePath"]
 
-from typing import TYPE_CHECKING, Dict, Generic, List, NewType, Optional, Set, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Dict, Generic, List, NewType, Optional, Set, Tuple, TypeVar, Union, cast
 from urllib.parse import urlparse
 
 import attr
@@ -77,7 +77,7 @@ def update_schemas_with(
     ref_path: _ReferencePath,
     data: Union[oai.Reference, oai.Schema],
     schemas: Schemas,
-    visited: Set[_ReferencePath],
+    visited: Tuple[_ReferencePath, Set[_ReferencePath]],
     config: Config,
 ) -> Union[Schemas, PropertyError]:
     if isinstance(data, oai.Reference):
@@ -89,12 +89,14 @@ def update_schemas_with(
 
 
 def _update_schemas_with_reference(
-    *, ref_path: _ReferencePath, data: oai.Reference, schemas: Schemas, visited: Set[_ReferencePath], config: Config
+    *, ref_path: _ReferencePath, data: oai.Reference, schemas: Schemas, visited: Tuple[_ReferencePath, Set[_ReferencePath]], config: Config
 ) -> Union[Schemas, PropertyError]:
     reference_pointer = parse_reference_path(data.ref)
     if isinstance(reference_pointer, ParseError):
         return PropertyError(detail=reference_pointer.detail, data=data)
 
+    curr, previous = visited
+    previous.add(reference_pointer)
     resolved_reference = schemas.classes_by_reference.get(reference_pointer)
     if resolved_reference:
         return attr.evolve(schemas, classes_by_reference={ref_path: resolved_reference, **schemas.classes_by_reference})
@@ -103,7 +105,7 @@ def _update_schemas_with_reference(
 
 
 def _update_schemas_with_data(
-    *, ref_path: _ReferencePath, data: oai.Schema, schemas: Schemas, visited: Set[_ReferencePath], config: Config
+    *, ref_path: _ReferencePath, data: oai.Schema, schemas: Schemas, visited: Tuple[_ReferencePath, Set[_ReferencePath]], config: Config
 ) -> Union[Schemas, PropertyError]:
     from . import build_enum_property, build_model_property
 
@@ -119,7 +121,8 @@ def _update_schemas_with_data(
 
     holder = schemas.classes_by_reference.get(ref_path)
     if isinstance(prop, PropertyError):
-        if ref_path in visited and not holder:
+        curr, previous = visited
+        if (ref_path in previous or curr in f"{prop.data}") and not holder:
             holder = _Holder(data=RecursiveReferenceInterupt())
             schemas = attr.evolve(schemas, classes_by_reference={ref_path: holder, **schemas.classes_by_reference})
             return RecursiveReferenceInterupt(schemas=schemas)