✨ Don't create separate class for schemas consisting solely of single anyOf/oneOf/allOf.

Author: rafalkrupinski

src/lapidary/render/model/metamodel.py

@@ -3,7 +3,7 @@
 import dataclasses as dc
 import itertools
 import operator
-from collections.abc import Callable, Iterable, Set
+from collections.abc import Callable, Container, Iterable, Set
 from typing import Any, Self
 
 from openapi_pydantic.v3.v3_1 import schema as schema31
@@ -93,6 +93,22 @@ class MetaModel:
     all_of: list[MetaModel] | None = None
 
     def normalize_model(self) -> MetaModel | None:
+        # if this doesn't have any assertions and only a single sub-schema, return that sub-schema
+        if len(self.any_of or ()) + len(self.one_of or ()) + len(self.all_of or ()) == 1:
+            if self.any_of:
+                candidate = self.any_of[0]
+            elif self.one_of:
+                candidate = self.one_of[0]
+            elif self.all_of:
+                candidate = self.all_of[0]
+            else:
+                raise ValueError
+
+            if self._only_constraints() == MetaModel(stack=self.stack) or self._only_constraints() == MetaModel(
+                stack=self.stack, type_=candidate.type_
+            ):
+                return candidate
+
         if self.type_ is None:
             self.type_ = _all_types()
 
@@ -117,7 +133,7 @@ def normalize_model(self) -> MetaModel | None:
                 if nsub is None:
                     # ignore bottom types
                     continue
-                if dc.replace(sub, description=None) == dc.replace(nsub, stack=sub.stack, description=None):
+                if sub._comparable() == nsub._comparable():
                     # no change
                     nsub = sub
                 items.append(nsub)
@@ -376,7 +392,7 @@ def _as_object_anno(self, root_package: str) -> python.AnnotatedType:
         else:
             return resolve_type_name(root_package, self.stack)
 
-    def _has_annotations(self) -> bool:
+    def _has_annotations(self, excluding: Container[str] = ()) -> bool:
         return (
             any(
                 getattr(self, key) is not None
@@ -396,13 +412,18 @@ def _has_annotations(self) -> bool:
                     'one_of',
                     'all_of',
                 )
+                if key not in excluding
             )
             or self.additional_props is not True
             or bool(self.properties)
             or bool(self.props_required)
             or self.type_ != _all_types()
         )
 
+    def _comparable(self) -> Self:
+        """Return a copy without anotations, useful for comparing."""
+        return dc.replace(self, description=None, title=None, stack=Stack())
+
 
 def _as_class_field(anno: python.AnnotatedType, name: str, required: bool) -> python.AnnotatedVariable:
     python_name = names.maybe_mangle_name(name)

tests/process/test_normalize.py

@@ -0,0 +1,36 @@
+from openapi_pydantic.v3.v3_0 import DataType
+
+from lapidary.render.model.metamodel import MetaModel
+from lapidary.render.model.stack import Stack
+
+
+def test_normalize_single_anyof():
+    schema = MetaModel(
+        stack=Stack.from_str('#/components/schemas/obj'),
+        any_of=[
+            MetaModel(
+                stack=Stack.from_str('#/components/schemas/obj/anyOf/0'),
+                type_={DataType.OBJECT},
+                properties={
+                    'id': MetaModel(
+                        stack=Stack.from_str('#/components/schemas/obj/anyOf/0/properties/id'), type_={DataType.STRING}
+                    )
+                },
+            )
+        ],
+    )
+
+    schema = schema.normalize_model()
+
+    expected = MetaModel(
+        stack=Stack.from_str('#/components/schemas/obj/anyOf/0'),
+        type_={DataType.OBJECT},
+        properties={
+            'id': MetaModel(
+                stack=Stack.from_str('#/components/schemas/obj/anyOf/0/properties/id'),
+                type_={DataType.STRING},
+            )
+        },
+    )
+
+    assert schema == expected