Add support for forwardrefs in fields

Author: zmievsa

cadwyn/applications.py

@@ -279,7 +279,7 @@ async def openapi_jsons(self, req: Request) -> JSONResponse:
         except (ValueError, TypeError):
             version = raw_version
 
-        if version in self.router.versioned_routers:
+        if isinstance(version, date) and version in self.router.versioned_routers:
             routes = self.router.versioned_routers[version].routes
             formatted_version = version.isoformat()
         elif version == "unversioned" and self._there_are_public_unversioned_routes():
@@ -296,7 +296,7 @@ async def openapi_jsons(self, req: Request) -> JSONResponse:
             self.servers.insert(0, {"url": root_path})
 
         webhook_routes = None
-        if version in self._versioned_webhook_routers:
+        if isinstance(version, date) and version in self._versioned_webhook_routers:
             webhook_routes = self._versioned_webhook_routers[version].routes
 
         return JSONResponse(

cadwyn/schema_generation.py

@@ -232,6 +232,12 @@ def _is_dunder(attr_name: str):
 
 
 def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapper[_T_PYDANTIC_MODEL]":
+    # In case we have a forwardref within one of the fields
+    # For example, when "from __future__ import annotations" is used in the file with the schema
+    if model is not BaseModel:
+        model.model_rebuild(raise_errors=False)
+    model = cast(type[_T_PYDANTIC_MODEL], model)
+
     decorators = _get_model_decorators(model)
     validators = {}
     for decorator_wrapper in decorators:
@@ -240,8 +246,20 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapp
 
         wrapped_validator = _wrap_validator(decorator_wrapper.func, decorator_wrapper.shim, decorator_wrapper.info)
         validators[decorator_wrapper.cls_var_name] = wrapped_validator
+
+    annotations = {
+        name: value
+        if not isinstance(value, str)
+        else model.model_fields[name].annotation or model.__annotations__[name]
+        for name, value in model.__annotations__.items()
+    }
+
     fields = {
-        field_name: PydanticFieldWrapper(model.model_fields[field_name], model.__annotations__[field_name], field_name)
+        field_name: PydanticFieldWrapper(
+            model.model_fields[field_name],
+            annotations[field_name],
+            field_name,
+        )
         for field_name in model.__annotations__
     }
 
@@ -264,7 +282,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapp
         fields=fields,
         other_attributes=other_attributes,
         validators=validators,
-        annotations=model.__annotations__.copy(),
+        annotations=annotations,
     )
 
 
@@ -356,6 +374,7 @@ def generate_model_copy(self, generator: "SchemaGenerator") -> type[_T_PYDANTIC_
             if not validator.is_deleted and type(validator) == _ValidatorWrapper  # noqa: E721
         }
         fields = {name: field.generate_field_copy(generator) for name, field in self.fields.items()}
+
         model_copy = type(self.cls)(
             self.name,
             tuple(generator[cast(type[BaseModel], base)] for base in self.cls.__bases__),
@@ -494,7 +513,6 @@ 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)
 
@@ -637,8 +655,6 @@ def __getitem__(self, model: type[_T_ANY_MODEL], /) -> type[_T_ANY_MODEL]:
 
         if model in self.concrete_models:
             return self.concrete_models[model]
-        else:
-            wrapper = self._get_wrapper_for_model(model)
 
         wrapper = self._get_wrapper_for_model(model)
         model_copy = wrapper.generate_model_copy(self)
@@ -661,6 +677,8 @@ def _get_wrapper_for_model(
             return self.model_bundle.enums[model]
 
         if lenient_issubclass(model, BaseModel):
+            # TODO: My god, what if one of its fields is in our concrete schemas and we don't use it? :O
+            # TODO: Add an argument with our concrete schemas for _wrap_pydantic_model
             wrapper = _wrap_pydantic_model(model)
             self.model_bundle.schemas[model] = wrapper
         elif lenient_issubclass(model, Enum):
@@ -989,5 +1007,5 @@ 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:
+    else:  # pragma: no cover # Can't imagine when this would happen
         return value

cadwyn/structure/schemas.py

@@ -19,8 +19,9 @@
 
 PossibleFieldAttributes = Literal[
     "default",
-    "default_factory",
+    "alias",
     "alias_priority",
+    "default_factory",
     "validation_alias",
     "serialization_alias",
     "title",
@@ -60,6 +61,7 @@
 @dataclass(slots=True)
 class FieldChanges:
     default: Any
+    alias: str | None
     default_factory: Any
     alias_priority: int | None
     validation_alias: str | AliasPath | AliasChoices | None
@@ -137,6 +139,7 @@ def had(
         name: str = Sentinel,
         type: Any = Sentinel,
         default: Any = Sentinel,
+        alias: str | None = Sentinel,
         default_factory: Callable = Sentinel,
         alias_priority: int = Sentinel,
         validation_alias: str = Sentinel,
@@ -181,6 +184,7 @@ def had(
                 default=default,
                 default_factory=default_factory,
                 alias_priority=alias_priority,
+                alias=alias,
                 validation_alias=validation_alias,
                 serialization_alias=serialization_alias,
                 title=title,

tests/test_router_generation_with_from_future_annotations.py

@@ -30,12 +30,12 @@ class MyVersionChange(VersionChange):
 
 
 @router.post("/test")
-async def test_with_inner_schema_forwardref(dep: MySchema) -> MySchema:
+async def route_with_inner_schema_forwardref(dep: MySchema) -> MySchema:
     return dep
 
 
 @router.post("/test2")
-async def test_with_outer_schema_forwardref(dep: OuterSchema) -> OuterSchema:
+async def route_with_outer_schema_forwardref(dep: OuterSchema) -> OuterSchema:
     return dep
 
 
@@ -56,7 +56,7 @@ 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 client_2000.post("/test2", json={"bar": {"foo": 1}}).json() == {"bar": {"foo": 1}}
+    assert client_2001.post("/test2", 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