cadwyn 4.5.0__tar.gz → 4.6.0__tar.gz

{cadwyn-4.5.0 → cadwyn-4.6.0}/.github/workflows/ci.yaml

@@ -102,6 +102,16 @@ jobs:
           python -m pip install uv
           uv pip install --system pre-commit pre-commit-uv
           pre-commit run --all-files
+
+  Validate-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-python-uv
+        with:
+          # When this version is updated,
+          # update the pyright `base_python` version in `tox.ini`, too.
+          python-version: "3.10"
       - run: tox run -e docs
       - name: Validate links
         uses: umbrelladocs/action-linkspector@v1

{cadwyn-4.5.0 → cadwyn-4.6.0}/CHANGELOG.md

@@ -5,6 +5,14 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+## [4.6.0]
+
+### 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`
+* Support for forwardrefs in body fields (for example, when you use `from __future__ import annotations` in the file with your routes)
+* Support for forwardrefs in route dependencies
+
 ## [4.5.0]
 
 ### Added

{cadwyn-4.5.0 → cadwyn-4.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cadwyn
-Version: 4.5.0
+Version: 4.6.0
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Project-URL: Source code, https://github.com/zmievsa/cadwyn
 Project-URL: Documentation, https://docs.cadwyn.dev

{cadwyn-4.5.0 → cadwyn-4.6.0}/cadwyn/applications.py

@@ -279,7 +279,7 @@ class Cadwyn(FastAPI):
         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 @@ class Cadwyn(FastAPI):
             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-4.5.0 → cadwyn-4.6.0}/cadwyn/schema_generation.py

@@ -40,6 +40,7 @@ from pydantic._internal._decorators import (
     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
 
@@ -231,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:
@@ -239,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__
     }
 
@@ -263,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,
     )
 
 
@@ -355,6 +374,7 @@ class _PydanticModelWrapper(Generic[_T_PYDANTIC_MODEL]):
             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__),
@@ -418,6 +438,7 @@ class _AnnotationTransformer:
         # 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
         )
@@ -531,6 +552,9 @@ class _AnnotationTransformer:
         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),
@@ -631,8 +655,6 @@ class SchemaGenerator:
 
         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)
@@ -655,6 +677,8 @@ class SchemaGenerator:
             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):
@@ -977,3 +1001,11 @@ class _EnumWrapper(Generic[_T_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:  # pragma: no cover # Can't imagine when this would happen
+        return value

{cadwyn-4.5.0 → cadwyn-4.6.0}/cadwyn/structure/schemas.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 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.fields import FieldInfo
 
@@ -18,58 +18,83 @@ if TYPE_CHECKING:
 
 PossibleFieldAttributes = Literal[
     "default",
-    "default_factory",
     "alias",
+    "alias_priority",
+    "default_factory",
+    "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
+    alias: str | None
     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)
@@ -113,29 +138,41 @@ class AlterFieldInstructionFactory:
         name: str = Sentinel,
         type: Any = Sentinel,
         default: Any = Sentinel,
+        alias: str | None = 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 +182,40 @@ class AlterFieldInstructionFactory:
             field_changes=FieldChanges(
                 default=default,
                 default_factory=default_factory,
+                alias_priority=alias_priority,
                 alias=alias,
+                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,
             ),
         )
 

{cadwyn-4.5.0 → cadwyn-4.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cadwyn"
-version = "4.5.0"
+version = "4.6.0"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = [{ name = "Stanislav Zmiev", email = "zmievsa@gmail.com" }]
 license = "MIT"

cadwyn-4.6.0/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 route_with_inner_schema_forwardref(dep: MySchema) -> MySchema:
+    return dep
+
+
+@router.post("/test2")
+async def route_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("/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