Fix: Route params (query or post) with future annotations gives "not fully defined" error #246

Author: zmievsa

CHANGELOG.md

@@ -5,6 +5,11 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+### Added
+
+* Added support for more field attributes in `schema.had()` and `schema.didnt_have()`: `field_title_generator`, `fail_fast`, `coerce_numbers_to_str`, `union_mode`, `allow_mutation`, `pattern`, `discriminator`
+* Added support for forwardrefs in body fields (for example, when you use `from __future__ import annotations` in the file with your routes)
+
 ## [4.5.0]
 
 ### Added

cadwyn/schema_generation.py

@@ -40,6 +40,7 @@
     RootValidatorDecoratorInfo,
     ValidatorDecoratorInfo,
 )
+from pydantic._internal._typing_extra import try_eval_type as pydantic_try_eval_type
 from pydantic.fields import ComputedFieldInfo, FieldInfo
 from typing_extensions import Doc, Self, _AnnotatedAlias, assert_never
 
@@ -418,6 +419,7 @@ def __init__(self, generator: "SchemaGenerator") -> None:
         # because such copies could produce weird behaviors at runtime, especially if you/fastapi do any comparisons.
         # It's defined here and not on the method because of this: https://youtu.be/sVjtp6tGo0g
         self.generator = generator
+        # TODO: Rewrite this to memoize
         self.change_versions_of_a_non_container_annotation = functools.cache(
             self._change_version_of_a_non_container_annotation
         )
@@ -492,6 +494,7 @@ def _change_version_of_a_non_container_annotation(self, annotation: Any) -> Any:
             ) or isinstance(annotation, fastapi.security.base.SecurityBase):
                 return annotation
 
+            # If we do not use modifier, we will get an unhashable module error
             def modifier(annotation: Any):
                 return self.change_version_of_annotation(annotation)
 
@@ -531,6 +534,9 @@ def _modify_callable_annotations(  # pragma: no branch # because of lambdas
         annotation_modifying_wrapper = annotation_modifying_wrapper_factory(call)
         old_params = inspect.signature(call).parameters
         callable_annotations = annotation_modifying_wrapper.__annotations__
+        callable_annotations = {
+            k: v if type(v) is not str else _try_eval_type(v, call.__globals__) for k, v in callable_annotations.items()
+        }
         annotation_modifying_wrapper.__annotations__ = modify_annotations(callable_annotations)
         annotation_modifying_wrapper.__defaults__ = modify_defaults(
             tuple(p.default for p in old_params.values() if p.default is not inspect.Signature.empty),
@@ -977,3 +983,11 @@ def _get_initialization_namespace_for_enum(enum_cls: type[Enum]):
             and k not in _DummyEnum.__dict__
             and (k not in mro_dict or mro_dict[k] is not v)
         }
+
+
+def _try_eval_type(value: Any, globals: dict[str, Any]) -> Any:
+    new_value, success = pydantic_try_eval_type(value, globals)
+    if success:
+        return new_value
+    else:
+        return value

cadwyn/structure/schemas.py

@@ -3,8 +3,9 @@
 from typing import TYPE_CHECKING, Any, Literal, cast
 
 from issubclass import issubclass as lenient_issubclass
-from pydantic import BaseModel, Field
+from pydantic import AliasChoices, AliasPath, BaseModel, Field
 from pydantic._internal._decorators import PydanticDescriptorProxy, unwrap_wrapped_function
+from pydantic.config import JsonDict
 from pydantic.fields import FieldInfo
 
 from cadwyn._utils import Sentinel, fully_unwrap_decorator
@@ -19,57 +20,80 @@
 PossibleFieldAttributes = Literal[
     "default",
     "default_factory",
-    "alias",
+    "alias_priority",
+    "validation_alias",
+    "serialization_alias",
     "title",
+    "field_title_generator",
     "description",
+    "examples",
     "exclude",
     "const",
+    "deprecated",
+    "frozen",
+    "validate_default",
+    "repr",
+    "init",
+    "init_var",
+    "kw_only",
+    "fail_fast",
     "gt",
     "ge",
     "lt",
     "le",
-    "deprecated",
-    "fail_fast",
     "strict",
+    "coerce_numbers_to_str",
     "multiple_of",
     "allow_inf_nan",
     "max_digits",
     "decimal_places",
     "min_length",
     "max_length",
+    "union_mode",
     "allow_mutation",
     "pattern",
     "discriminator",
-    "repr",
 ]
 
 
+# TODO: Add json_schema_extra as a breaking change in a major version
 @dataclass(slots=True)
 class FieldChanges:
     default: Any
     default_factory: Any
-    alias: str
-    title: str
+    alias_priority: int | None
+    validation_alias: str | AliasPath | AliasChoices | None
+    serialization_alias: str | None
+    title: str | None
+    field_title_generator: Callable[[str, FieldInfo], str] | None
     description: str
+    examples: list[Any] | None
     exclude: "AbstractSetIntStr | MappingIntStrAny | Any"
     const: bool
     deprecated: bool
+    frozen: bool | None
+    validate_default: bool | None
+    repr: bool
+    init: bool | None
+    init_var: bool | None
+    kw_only: bool | None
     fail_fast: bool
     gt: float
     ge: float
     lt: float
     le: float
     strict: bool
+    coerce_numbers_to_str: bool | None
     multiple_of: float
     allow_inf_nan: bool
     max_digits: int
     decimal_places: int
     min_length: int
     max_length: int
+    union_mode: Literal["smart", "left_to_right"]
     allow_mutation: bool
     pattern: str
     discriminator: str
-    repr: bool
 
 
 @dataclass(slots=True)
@@ -114,28 +138,39 @@ def had(
         type: Any = Sentinel,
         default: Any = Sentinel,
         default_factory: Callable = Sentinel,
-        alias: str = Sentinel,
+        alias_priority: int = Sentinel,
+        validation_alias: str = Sentinel,
+        serialization_alias: str = Sentinel,
         title: str = Sentinel,
+        field_title_generator: Callable[[str, FieldInfo], str] = Sentinel,
         description: str = Sentinel,
+        examples: list[Any] = Sentinel,
         exclude: "AbstractSetIntStr | MappingIntStrAny | Any" = Sentinel,
         const: bool = Sentinel,
+        deprecated: bool = Sentinel,
+        frozen: bool = Sentinel,
+        validate_default: bool = Sentinel,
+        repr: bool = Sentinel,
+        init: bool = Sentinel,
+        init_var: bool = Sentinel,
+        kw_only: bool = Sentinel,
+        fail_fast: bool = Sentinel,
         gt: float = Sentinel,
         ge: float = Sentinel,
         lt: float = Sentinel,
         le: float = Sentinel,
         strict: bool = Sentinel,
-        deprecated: bool = Sentinel,
+        coerce_numbers_to_str: bool = Sentinel,
         multiple_of: float = Sentinel,
         allow_inf_nan: bool = Sentinel,
         max_digits: int = Sentinel,
         decimal_places: int = Sentinel,
         min_length: int = Sentinel,
         max_length: int = Sentinel,
+        union_mode: Literal["smart", "left_to_right"] = Sentinel,
         allow_mutation: bool = Sentinel,
         pattern: str = Sentinel,
         discriminator: str = Sentinel,
-        repr: bool = Sentinel,
-        fail_fast: bool = Sentinel,
     ) -> FieldHadInstruction:
         return FieldHadInstruction(
             schema=self.schema,
@@ -145,28 +180,39 @@ def had(
             field_changes=FieldChanges(
                 default=default,
                 default_factory=default_factory,
-                alias=alias,
+                alias_priority=alias_priority,
+                validation_alias=validation_alias,
+                serialization_alias=serialization_alias,
                 title=title,
+                field_title_generator=field_title_generator,
                 description=description,
+                examples=examples,
                 exclude=exclude,
                 const=const,
+                deprecated=deprecated,
+                frozen=frozen,
+                validate_default=validate_default,
+                repr=repr,
+                init=init,
+                init_var=init_var,
+                kw_only=kw_only,
+                fail_fast=fail_fast,
                 gt=gt,
                 ge=ge,
                 lt=lt,
                 le=le,
-                deprecated=deprecated,
                 strict=strict,
+                coerce_numbers_to_str=coerce_numbers_to_str,
                 multiple_of=multiple_of,
                 allow_inf_nan=allow_inf_nan,
                 max_digits=max_digits,
                 decimal_places=decimal_places,
                 min_length=min_length,
                 max_length=max_length,
+                union_mode=union_mode,
                 allow_mutation=allow_mutation,
                 pattern=pattern,
                 discriminator=discriminator,
-                repr=repr,
-                fail_fast=fail_fast,
             ),
         )
 

tests/test_router_generation_with_from_future_annotations.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+from pydantic import BaseModel, Field
+
+from cadwyn.applications import Cadwyn
+from cadwyn.route_generation import VersionedAPIRouter
+from cadwyn.structure.schemas import schema
+from cadwyn.structure.versions import Version, VersionBundle, VersionChange
+
+
+class OuterSchema(BaseModel):
+    bar: MySchema
+
+
+class MySchema(BaseModel):
+    foo: str = Field(coerce_numbers_to_str=True)
+
+
+class MyVersionChange(VersionChange):
+    description = "Hello"
+    instructions_to_migrate_to_previous_version = (
+        schema(MySchema).field("foo").had(type=int),
+        schema(MySchema).field("foo").didnt_have("coerce_numbers_to_str"),
+    )
+
+
+app = Cadwyn(versions=VersionBundle(Version("2001-01-01", MyVersionChange), Version("2000-01-01")))
+router = VersionedAPIRouter()
+
+
+@router.post("/test")
+async def test_with_inner_schema_forwardref(dep: MySchema) -> MySchema:
+    return dep
+
+
+@router.post("/test2")
+async def test_with_outer_schema_forwardref(dep: OuterSchema) -> OuterSchema:
+    return dep
+
+
+app.generate_and_include_versioned_routers(router)
+
+
+def test__router_generation__using_forwardref_inner_global_schema_in_body():
+    unversioned_client = TestClient(app)
+    client_2000 = TestClient(app, headers={app.router.api_version_header_name: "2000-01-01"})
+    client_2001 = TestClient(app, headers={app.router.api_version_header_name: "2001-01-01"})
+    assert client_2000.post("/test", json={"foo": 1}).json() == {"foo": 1}
+    assert client_2001.post("/test", json={"foo": 1}).json() == {"foo": "1"}
+    assert unversioned_client.get("/openapi.json?version=2000-01-01").status_code == 200
+    assert unversioned_client.get("/openapi.json?version=2001-01-01").status_code == 200
+
+
+def test__router_generation__using_forwardref_outer_global_schema_in_body():
+    unversioned_client = TestClient(app)
+    client_2000 = TestClient(app, headers={app.router.api_version_header_name: "2000-01-01"})
+    client_2001 = TestClient(app, headers={app.router.api_version_header_name: "2001-01-01"})
+    assert client_2000.post("/test", json={"bar": {"foo": 1}}).json() == {"bar": {"foo": 1}}
+    assert client_2001.post("/test", json={"bar": {"foo": 1}}).json() == {"bar": {"foo": "1"}}
+    assert unversioned_client.get("/openapi.json?version=2000-01-01").status_code == 200
+    assert unversioned_client.get("/openapi.json?version=2001-01-01").status_code == 200