Add allOf support for responses definitions

Author: dtkav

openapi_python_client/parser/openapi.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum
@@ -217,11 +220,43 @@ class Model:
     """
 
     reference: Reference
+    references: List[oai.Reference]
     required_properties: List[Property]
     optional_properties: List[Property]
     description: str
     relative_imports: Set[str]
 
+    def resolve_references(self, schemas) -> Union[List[Property], ParseError]:
+        required_set = set()
+        props = {}
+        while self.references:
+            reference = self.references.pop()
+            prop = schemas[Reference.from_ref(reference.ref).class_name]
+            props.update(prop.properties or {})
+            for sub_prop in prop.allOf or []:
+                if isinstance(sub_prop, oai.Reference):
+                    self.references += [sub_prop]
+                else:
+                    props.update(sub_prop.properties)
+            if isinstance(prop.required, Iterable):
+                for sub_prop_name in prop.required:
+                    required_set.add(sub_prop_name)
+
+        for key, value in (props or {}).items():
+            required = key in required_set
+            p = property_from_data(name=key, required=required, data=value)
+            if isinstance(p, ParseError):
+                return p
+            if required:
+                self.required_properties.append(p)
+                # Remove the optional version
+                self.optional_properties = [op for op in self.optional_properties if op.name != p.name]
+            elif not any(ep for ep in (self.optional_properties + self.required_properties) if ep.name == p.name):
+                self.optional_properties.append(p)
+            self.relative_imports.update(p.get_imports(prefix=".."))
+
+        return self.required_properties + self.optional_properties
+
     @staticmethod
     def from_data(*, data: oai.Schema, name: str) -> Union["Model", ParseError]:
         """A single Model from its OAI data
@@ -235,11 +270,24 @@ def from_data(*, data: oai.Schema, name: str) -> Union["Model", ParseError]:
         required_properties: List[Property] = []
         optional_properties: List[Property] = []
         relative_imports: Set[str] = set()
+        references: List[Reference] = []
 
         ref = Reference.from_ref(data.title or name)
+        all_props = data.properties or {}
 
-        for key, value in (data.properties or {}).items():
+        if not isinstance(data, oai.Reference) and data.allOf:
+            for sub_prop in data.allOf:
+                if isinstance(sub_prop, oai.Reference):
+                    references += [sub_prop]
+                else:
+                    all_props.update(sub_prop.properties)
+                    required_set.update(sub_prop.required or [])
+
+        for key, value in all_props.items():
             required = key in required_set
+            if not isinstance(value, oai.Reference) and value.allOf:
+                # resolved later
+                continue
             p = property_from_data(name=key, required=required, data=value)
             if isinstance(p, ParseError):
                 return p
@@ -251,6 +299,7 @@ def from_data(*, data: oai.Schema, name: str) -> Union["Model", ParseError]:
 
         model = Model(
             reference=ref,
+            references=references,
             required_properties=required_properties,
             optional_properties=optional_properties,
             relative_imports=relative_imports,
@@ -289,6 +338,8 @@ def build(*, schemas: Dict[str, Union[oai.Reference, oai.Schema]]) -> "Schemas":
                 result.errors.append(s)
             else:
                 result.models[s.reference.class_name] = s
+        for model in result.models.values():
+            model.resolve_references(schemas)
         return result
 
 

openapi_python_client/parser/properties.py

@@ -520,7 +520,9 @@ def _property_from_data(
             nullable=data.nullable,
         )
     if not data.type:
-        return PropertyError(data=data, detail="Schemas must either have one of enum, anyOf, or type defined.")
+        return PropertyError(
+            data=data, detail="Schemas must either have one of enum, anyOf, oneOf, allOf, or type defined."
+        )
     if data.type == "string":
         return _string_based_property(name=name, required=required, data=data)
     elif data.type == "number":

tests/test_openapi_parser/test_openapi.py

@@ -71,21 +71,23 @@ class TestModel:
     def test_from_data(self, mocker):
         from openapi_python_client.parser.properties import Property
 
+        required_property = mocker.MagicMock(autospec=Property)
+        required_property.allOf = None
+        required_imports = mocker.MagicMock()
+        required_property.get_imports.return_value = {required_imports}
+        optional_property = mocker.MagicMock(autospec=Property)
+        optional_property.allOf = None
+        optional_imports = mocker.MagicMock()
+        optional_property.get_imports.return_value = {optional_imports}
         in_data = oai.Schema.construct(
             title=mocker.MagicMock(),
             description=mocker.MagicMock(),
             required=["RequiredEnum"],
             properties={
-                "RequiredEnum": mocker.MagicMock(),
-                "OptionalDateTime": mocker.MagicMock(),
+                "RequiredEnum": required_property,
+                "OptionalDateTime": optional_property,
             },
         )
-        required_property = mocker.MagicMock(autospec=Property)
-        required_imports = mocker.MagicMock()
-        required_property.get_imports.return_value = {required_imports}
-        optional_property = mocker.MagicMock(autospec=Property)
-        optional_imports = mocker.MagicMock()
-        optional_property.get_imports.return_value = {optional_imports}
         property_from_data = mocker.patch(
             f"{MODULE_NAME}.property_from_data",
             side_effect=[required_property, optional_property],
@@ -107,6 +109,7 @@ def test_from_data(self, mocker):
         optional_property.get_imports.assert_called_once_with(prefix="..")
         assert result == Model(
             reference=from_ref(),
+            references=[],
             required_properties=[required_property],
             optional_properties=[optional_property],
             relative_imports={
@@ -117,14 +120,17 @@ def test_from_data(self, mocker):
         )
 
     def test_from_data_property_parse_error(self, mocker):
+        from openapi_python_client.parser.properties import Property
+
+        required_property = mocker.MagicMock(autospec=Property)
+        required_property.allOf = None
+        optional_property = mocker.MagicMock(autospec=Property)
+        optional_property.allOf = None
         in_data = oai.Schema.construct(
             title=mocker.MagicMock(),
             description=mocker.MagicMock(),
             required=["RequiredEnum"],
-            properties={
-                "RequiredEnum": mocker.MagicMock(),
-                "OptionalDateTime": mocker.MagicMock(),
-            },
+            properties={"RequiredEnum": required_property, "OptionalDateTime": optional_property},
         )
         parse_error = ParseError(data=mocker.MagicMock())
         property_from_data = mocker.patch(
@@ -144,6 +150,57 @@ def test_from_data_property_parse_error(self, mocker):
 
         assert result == parse_error
 
+    def test_resolve_references(self, mocker):
+
+        schemas = {
+            "RefA": oai.Schema.construct(
+                title=mocker.MagicMock(),
+                description=mocker.MagicMock(),
+                required=["String"],
+                properties={
+                    "String": oai.Schema.construct(type="string"),
+                    "Enum": oai.Schema.construct(type="string", enum=["aValue"]),
+                    "DateTime": oai.Schema.construct(type="string", format="date-time"),
+                },
+            ),
+            "RefB": oai.Schema.construct(
+                title=mocker.MagicMock(),
+                description=mocker.MagicMock(),
+                required=["DateTime"],
+                properties={
+                    "Int": oai.Schema.construct(type="integer"),
+                    "DateTime": oai.Schema.construct(type="string", format="date-time"),
+                    "Float": oai.Schema.construct(type="number", format="float")
+                },
+            ),
+        }
+
+        model_schema = oai.Schema.construct(
+            allOf=[
+                oai.Reference.construct(ref="#/components/schemas/RefA"),
+                oai.Reference.construct(ref="#/components/schemas/RefB"),
+                oai.Schema.construct(
+                    title=mocker.MagicMock(),
+                    description=mocker.MagicMock(),
+                    required=["Float"],
+                    properties={
+                        "String": oai.Schema.construct(type="string"),
+                        "Float": oai.Schema.construct(type="number", format="float"),
+                    },
+                ),
+            ]
+        )
+
+        from openapi_python_client.parser.openapi import Model
+
+        model = Model.from_data(data=model_schema, name="Model")
+        model.resolve_references(schemas)
+        print(f"{model=}")
+        assert sorted(p.name for p in model.required_properties) == ["DateTime", "Float", "String"]
+        assert all(p.required for p in model.required_properties)
+        assert sorted(p.name for p in model.optional_properties) == ["Enum", "Int"]
+        assert all(not p.required for p in model.optional_properties)
+
 
 class TestSchemas:
     def test_build(self, mocker):
@@ -159,6 +216,8 @@ def test_build(self, mocker):
         result = Schemas.build(schemas=in_data)
 
         from_data.assert_has_calls([mocker.call(data=value, name=name) for (name, value) in in_data.items()])
+        schema_1.resolve_references.assert_called_once_with(in_data)
+        schema_2.resolve_references.assert_called_once_with(in_data)
         assert result == Schemas(
             models={
                 schema_1.reference.class_name: schema_1,

tests/test_openapi_parser/test_properties.py

@@ -614,9 +614,7 @@ def test_property_from_data_enum(self, mocker):
         data.title = mocker.MagicMock()
 
         property_from_data(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         EnumProperty.assert_called_once_with(
             name=name,
@@ -688,19 +686,14 @@ def test_property_from_data_simple_types(self, mocker, openapi_type, python_type
         data.nullable = mocker.MagicMock()
 
         property_from_data(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         clazz.assert_called_once_with(name=name, required=required, default=data.default, nullable=data.nullable)
 
     def test_property_from_data_array(self, mocker):
         name = mocker.MagicMock()
         required = mocker.MagicMock()
-        data = oai.Schema(
-            type="array",
-            items={"type": "number", "default": "0.0"},
-        )
+        data = oai.Schema(type="array", items={"type": "number", "default": "0.0"},)
         ListProperty = mocker.patch(f"{MODULE_NAME}.ListProperty")
         FloatProperty = mocker.patch(f"{MODULE_NAME}.FloatProperty")
         mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
@@ -729,10 +722,7 @@ def test_property_from_data_array_no_items(self, mocker):
     def test_property_from_data_array_invalid_items(self, mocker):
         name = mocker.MagicMock()
         required = mocker.MagicMock()
-        data = oai.Schema(
-            type="array",
-            items={},
-        )
+        data = oai.Schema(type="array", items={},)
         mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
 
         from openapi_python_client.parser.properties import property_from_data
@@ -744,12 +734,7 @@ def test_property_from_data_array_invalid_items(self, mocker):
     def test_property_from_data_union(self, mocker):
         name = mocker.MagicMock()
         required = mocker.MagicMock()
-        data = oai.Schema(
-            anyOf=[{"type": "number", "default": "0.0"}],
-            oneOf=[
-                {"type": "integer", "default": "0"},
-            ],
-        )
+        data = oai.Schema(anyOf=[{"type": "number", "default": "0.0"}], oneOf=[{"type": "integer", "default": "0"},],)
         UnionProperty = mocker.patch(f"{MODULE_NAME}.UnionProperty")
         FloatProperty = mocker.patch(f"{MODULE_NAME}.FloatProperty")
         IntProperty = mocker.patch(f"{MODULE_NAME}.IntProperty")
@@ -800,7 +785,7 @@ def test_property_from_data_no_valid_props_in_data(self):
 
         data = oai.Schema()
         assert property_from_data(name="blah", required=True, data=data) == PropertyError(
-            data=data, detail="Schemas must either have one of enum, anyOf, or type defined."
+            data=data, detail="Schemas must either have one of enum, anyOf, oneOf, allOf, or type defined."
         )
 
     def test_property_from_data_validation_error(self, mocker):
@@ -837,9 +822,7 @@ def test__string_based_property_no_format(self, mocker):
         data.pattern = mocker.MagicMock()
 
         _string_based_property(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         StringProperty.assert_called_once_with(
             name=name, required=required, pattern=data.pattern, default=data.default, nullable=data.nullable
@@ -863,9 +846,7 @@ def test__string_based_property_datetime_format(self, mocker):
         data.default = mocker.MagicMock()
 
         _string_based_property(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         DateTimeProperty.assert_called_once_with(
             name=name, required=required, default=data.default, nullable=data.nullable
@@ -888,9 +869,7 @@ def test__string_based_property_date_format(self, mocker):
         data.default = mocker.MagicMock()
 
         _string_based_property(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         DateProperty.assert_called_once_with(name=name, required=required, default=data.default, nullable=data.nullable)
 
@@ -911,9 +890,7 @@ def test__string_based_property_binary_format(self, mocker):
         data.default = mocker.MagicMock()
 
         _string_based_property(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         FileProperty.assert_called_once_with(name=name, required=required, default=data.default, nullable=data.nullable)
 
@@ -939,9 +916,7 @@ def test__string_based_property_unsupported_format(self, mocker):
         data.pattern = mocker.MagicMock()
 
         _string_based_property(
-            name=name,
-            required=required,
-            data=data,
+            name=name, required=required, data=data,
         )
         StringProperty.assert_called_once_with(
             name=name, required=required, pattern=data.pattern, default=data.default, nullable=data.nullable