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,12 +6,11 @@ authors = [
 ]
 dependencies = [
     "PyYaml",
-    "pydantic",
+    "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"
@@ -50,9 +49,6 @@ Repository = "https://github.com/commonism/aiopenapi3"
 auth = [
     "httpx-auth>=0.21.0",
 ]
-socks = [
-    "httpx-socks",
-]
 types =[
     "pydantic-extra-types>=2.10.1",
 ]
@@ -89,7 +85,9 @@ filterwarnings = [
     "ignore:unclosed <socket.socket fd=:ResourceWarning",
     "ignore:Ignoring Schema with additionalProperties and named properties:UserWarning",
     "ignore:'flask.Markup' is deprecated and will be removed in Flask 2.4. Import 'markupsafe.Markup' instead.:DeprecationWarning",
-    "ignore:unclosed resource <TCPTransport:ResourceWarning"
+    "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,13 @@ 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)]
+            # FIXME - merge annotations
+            ru: object = Annotated[Union[tuple(r)], items[0].anno]
             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
@@ -326,9 +330,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=None)
+            classinfo.root = _t
         elif _type == "array":
             """anyOf/oneOf is taken care in in createAnnotation"""
             classinfo.root = Model.createAnnotation(schema, _type="array")
@@ -355,9 +358,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 +375,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 +452,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 +717,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

@@ -121,12 +121,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)]