pydantic 2.13 - fix UnsupportedFieldAttributeWarning

Union[Annotated[str, Field(default=None)], Annotated[int, Field(default=None)],]
->
Annotated[Union[str, int], Field(default=None)]

c.f. pydantic/pydantic#12530

Author: commonism

pyproject.toml

@@ -6,11 +6,12 @@ authors = [
 ]
 dependencies = [
     "PyYaml",
-    "pydantic == 2.11.9",
+    "pydantic @ git+https://github.com/pydantic/pydantic.git",
     "email-validator",
     "yarl",
     "httpx",
     "more-itertools",
+    'typing_extensions; python_version<"3.10"',
     "jmespath",
 ]
 requires-python = ">=3.10"
@@ -87,6 +88,7 @@ filterwarnings = [
     "ignore:'flask.Markup' is deprecated and will be removed in Flask 2.4. Import 'markupsafe.Markup' instead.:DeprecationWarning",
     "ignore:unclosed resource <TCPTransport:ResourceWarning",
     "ignore:co_lnotab is deprecated, use co_lines instead:DeprecationWarning",
+#    "ignore::pydantic.warnings.UnsupportedFieldAttributeWarning",
 ]
 asyncio_mode = "strict"
 asyncio_default_fixture_loop_scope = "session"

src/aiopenapi3/model.py

@@ -113,6 +113,7 @@ class _PropertyInfo:
     type_: str
 
     root: Any = None
+    anno: pydantic.Field = None
     config: dict[str, Any] = dataclasses.field(default_factory=dict)
     properties: dict[str, _PropertyInfo] = dataclasses.field(
         default_factory=lambda: collections.defaultdict(lambda: _ClassInfo._PropertyInfo())
@@ -257,10 +258,17 @@ def collapse(cls, type_name, items: list["_ClassInfo"]) -> type[BaseModel]:
         r = [i.model() for i in items]
 
         if len(r) > 1:
-            ru: object = Union[tuple(r)]
+            # Annotations are collected, last element has all of them
+            #            ru: object = Annotated[Union[tuple(r)], items[-1].anno]
+            v = list()
+            for i in range(len(items)):
+                v.append(Annotated[r[i], items[i].anno])
+            ru = Annotated[Union[tuple(v)], Field(default=None)]
             m: type[RootModel] = create_model(type_name, __base__=(ConfiguredRootModel[ru],), __module__=me.__name__)
         elif len(r) == 1:
             m: type[BaseModel] = cast(type[BaseModel], r[0])
+            if items[0].anno:
+                m = Annotated[m, items[0].anno]
             if not is_basemodel(m):
                 m = create_model(type_name, __base__=(ConfiguredRootModel[m],), __module__=me.__name__)
         else:  # == 0
@@ -299,7 +307,8 @@ def from_schema(
         r: list[_ClassInfo] = list()
 
         for _type in Model.types(schema):
-            r.append(Model.createClassInfo(schema, _type, schemanames, discriminators, extra))
+            args = dict()
+            r.append(Model.createClassInfo(schema, _type, schemanames, discriminators, extra, args))
 
         m = _ClassInfo.collapse(schema._get_identity("L8"), r)
 
@@ -313,6 +322,7 @@ def createClassInfo(
         schemanames: list[str],
         discriminators: list["DiscriminatorType"],
         extra: list["SchemaType"] | None,
+        args: dict[str, Any] = None,
     ) -> _ClassInfo:
         from . import v20, v30, v31
 
@@ -326,9 +336,8 @@ def createClassInfo(
             for primitive types the anyOf/oneOf is taken care of in Model.createAnnotation
             """
             if typing.get_origin(_t := Model.createAnnotation(schema, _type=_type)) != Literal:
-                classinfo.root = Annotated[_t, Model.createField(schema, _type=_type, args=None)]
-            else:
-                classinfo.root = _t
+                classinfo.anno = Model.createField(schema, _type=_type, args=args)
+            classinfo.root = _t
         elif _type == "array":
             """anyOf/oneOf is taken care in in createAnnotation"""
             classinfo.root = Model.createAnnotation(schema, _type="array")
@@ -355,9 +364,8 @@ def createClassInfo(
                     if _type in Model.types(i)
                 )
                 if schema.discriminator and schema.discriminator.mapping:
-                    classinfo.root = Annotated[
-                        Union[t], Field(discriminator=Model.nameof(schema.discriminator.propertyName))
-                    ]
+                    classinfo.root = Union[t]
+                    classinfo.anno = Field(discriminator=Model.nameof(schema.discriminator.propertyName))
                 else:
                     if len(t):
                         classinfo.root = Union[t]
@@ -373,9 +381,8 @@ def createClassInfo(
                     if _type in Model.types(i)
                 )
                 if schema.discriminator and schema.discriminator.mapping:
-                    classinfo.root = Annotated[
-                        Union[t], Field(discriminator=Model.nameof(schema.discriminator.propertyName))
-                    ]
+                    classinfo.root = Union[t]
+                    classinfo.anno = Field(discriminator=Model.nameof(schema.discriminator.propertyName))
                 else:
                     if len(t):
                         classinfo.root = Union[t]
@@ -451,8 +458,8 @@ def validate_patternProperties(self_):
             """
             assert isinstance(schema, v20.Schema)
             schema_ = v20.Schema(type="string", format="binary")
-            _t = Model.createAnnotation(schema_, _type="string")
-            classinfo.root = Annotated[_t, Model.createField(schema_, _type="string", args=None)]
+            classinfo.root = Model.createAnnotation(schema_, _type="string")
+            classinfo.anno = Model.createField(schema_, _type="string", args=None)
         else:
             raise ValueError(_type)
 
@@ -716,7 +723,7 @@ def booleanFalse(schema: Optional["SchemaType"]) -> bool:
             raise ValueError(schema)
 
     @staticmethod
-    def createField(schema: "SchemaType", _type=None, args=None):
+    def createField(schema: "SchemaType", _type=None, args=None) -> Field:
         if args is None:
             args = dict(default=getattr(schema, "default", None))
 

tests/schema_test.py

@@ -122,12 +122,10 @@ def test_schema_regex_engine(with_schema_regex_engine):
     import pydantic_core._pydantic_core
 
     with pytest.raises(pydantic_core._pydantic_core.SchemaError, match="error: unclosed character class$"):
-        annotations = typing.get_args(Root.model_fields["root"].annotation)
-        assert len(annotations) == 2 and annotations[0] == str and isinstance(annotations[1], FieldInfo), annotations
-        metadata = annotations[1].metadata
-        assert len(metadata) == 1, metadata
-        pattern = metadata[0].pattern
-        assert isinstance(pattern, str), pattern
+        t = Root.model_fields["root"]
+        assert t.annotation == str
+        assert isinstance(t.metadata[0].pattern, str)
+        pattern = t.metadata[0].pattern
         from typing import Annotated
 
         C = Annotated[str, pydantic.Field(pattern=pattern)]