cadwyn 5.1.1__tar.gz → 5.1.3__tar.gz

{cadwyn-5.1.1 → cadwyn-5.1.3}/CHANGELOG.md

@@ -5,6 +5,25 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+## [5.1.3]
+
+### Fixed
+
+* `__doc__` attribute is now copied from the original enum to the generated enum
+* Python 3.12 type aliases and their typing_extensions backports are now supported (including `pydantic.JsonValue` and other `typing_extensions.TypeAliasType` instances)
+* The bug when solve_dependencies error on the migration of a request to the latest version responds with a non-json serializable error and cadwyn showed a failed to serialize error instead of the actual error
+* Updated minimum fastapi version to 0.112.4 because embed_body_fields was added in 0.112.4
+
+## [5.1.2]
+
+### Fixed
+
+* Generators not being called when fastapi validates the initial request
+
+### Added
+
+* `cadwyn.current_dependency_solver` function to check whether cadwyn or fastapi is currently solving dependencies. It can be used as a dependency for versioned endpoints like so: `current_dependency_solver: Annotated[Literal["fastapi", "cadwyn"], Depends(current_dependency_solver)]`. If your dependency has side effects, you would likely want to only run it once per request. If you want to run it once we migrated the request to the latest version, you should only run it when `current_dependency_solver` is `"cadwyn"`. If you want your dependency to run at the very beginning of handling the request, you should only run it when `current_dependency_solver` is `"fastapi"`.
+
 ## [5.1.1]
 
 ### Fixed

{cadwyn-5.1.1 → cadwyn-5.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cadwyn
-Version: 5.1.1
+Version: 5.1.3
 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
@@ -35,7 +35,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Requires-Dist: backports-strenum<2,>=1.3.1; python_version < '3.11'
-Requires-Dist: fastapi>=0.112.3
+Requires-Dist: fastapi>=0.112.4
 Requires-Dist: issubclass>=0.1.2
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: pydantic>=2.0.0

{cadwyn-5.1.1 → cadwyn-5.1.3}/cadwyn/__init__.py

@@ -2,6 +2,7 @@ import importlib.metadata
 
 from .applications import Cadwyn
 from .changelogs import hidden
+from .dependencies import current_dependency_solver
 from .route_generation import VersionedAPIRouter, generate_versioned_routers
 from .schema_generation import generate_versioned_models, migrate_response_body
 from .structure import (
@@ -32,6 +33,7 @@ __all__ = [
     "VersionedAPIRouter",
     "convert_request_to_next_version_for",
     "convert_response_to_previous_version_for",
+    "current_dependency_solver",
     "endpoint",
     "enum",
     "generate_versioned_models",

cadwyn-5.1.3/cadwyn/dependencies.py

@@ -0,0 +1,5 @@
+from cadwyn.structure.versions import _CURRENT_DEPENDENCY_SOLVER_OPTIONS, _CURRENT_DEPENDENCY_SOLVER_VAR
+
+
+async def current_dependency_solver() -> _CURRENT_DEPENDENCY_SOLVER_OPTIONS:
+    return _CURRENT_DEPENDENCY_SOLVER_VAR.get("fastapi")

{cadwyn-5.1.1 → cadwyn-5.1.3}/cadwyn/exceptions.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any
 
 from fastapi.routing import APIRoute
@@ -21,7 +20,7 @@ class CadwynHeadRequestValidationError(CadwynError):
             f"We failed to migrate the request with version={self.version}. "
             "This means that there is some error in your migrations or schema structure that makes it impossible "
             "to migrate the request of that version to latest.\n"
-            f"body={self.body}\n\nerrors={json.dumps(self.errors, indent=4, ensure_ascii=False)}"
+            f"body={self.body}\n\nerrors={self.errors}"
         )
 
 

{cadwyn-5.1.1 → cadwyn-5.1.3}/cadwyn/schema_generation.py

@@ -20,6 +20,7 @@ import pydantic
 import pydantic._internal._decorators
 import typing_extensions
 from fastapi import Response
+from fastapi.dependencies.utils import is_async_gen_callable, is_coroutine_callable, is_gen_callable
 from fastapi.routing import APIRoute
 from pydantic import BaseModel, Field, RootModel
 from pydantic._internal import _decorators
@@ -39,6 +40,7 @@ from typing_extensions import (
     NewType,
     Self,
     TypeAlias,
+    TypeAliasType,
     TypeVar,
     _AnnotatedAlias,
     assert_never,
@@ -77,6 +79,7 @@ from cadwyn.structure.versions import _CADWYN_REQUEST_PARAM_NAME, _CADWYN_RESPON
 if TYPE_CHECKING:
     from cadwyn.structure.versions import HeadVersion, Version, VersionBundle
 
+
 if sys.version_info >= (3, 10):
     from typing import _BaseGenericAlias  # pyright: ignore[reportAttributeAccessIssue]
 else:
@@ -98,6 +101,7 @@ PYDANTIC_DECORATOR_TYPE_TO_DECORATOR_MAP = {
     ModelSerializerDecoratorInfo: pydantic.model_serializer,
     ComputedFieldInfo: pydantic.computed_field,
 }
+_PYDANTIC_ALL_EXPORTED_NAMES = set(pydantic.__all__)
 
 
 VALIDATOR_CONFIG_KEY = "__validators__"
@@ -486,6 +490,7 @@ class _CallableWrapper:
         self._original_callable = original_callable
         if not is_regular_function(original_callable):
             original_callable = original_callable.__call__
+
         functools.update_wrapper(self, original_callable)
 
     @property
@@ -510,6 +515,17 @@ class _AsyncCallableWrapper(_CallableWrapper):
         return await self._original_callable(*args, **kwargs)
 
 
+class _GeneratorCallableWrapper(_CallableWrapper):
+    def __call__(self, *args: Any, **kwargs: Any):
+        yield from self._original_callable(*args, **kwargs)
+
+
+class _AsyncGeneratorCallableWrapper(_CallableWrapper):
+    async def __call__(self, *args: Any, **kwargs: Any):
+        async for value in self._original_callable(*args, **kwargs):
+            yield value
+
+
 @final
 class _AnnotationTransformer:
     def __init__(self, generator: "SchemaGenerator") -> None:
@@ -566,6 +582,17 @@ class _AnnotationTransformer:
     def _change_version_of_a_non_container_annotation(self, annotation: Any) -> Any:
         if isinstance(annotation, (_BaseGenericAlias, types.GenericAlias)):
             return get_origin(annotation)[tuple(self.change_version_of_annotation(arg) for arg in get_args(annotation))]
+        elif isinstance(annotation, TypeAliasType):
+            if (
+                annotation.__module__ is not None and (annotation.__module__.startswith("pydantic."))
+            ) or annotation.__name__ in _PYDANTIC_ALL_EXPORTED_NAMES:
+                return annotation
+            else:
+                return TypeAliasType(  # pyright: ignore[reportGeneralTypeIssues]
+                    name=annotation.__name__,
+                    value=self.change_version_of_annotation(annotation.__value__),
+                    type_params=self.change_version_of_annotation(annotation.__type_params__),
+                )
         elif isinstance(annotation, fastapi.params.Security):
             return fastapi.params.Security(
                 self.change_version_of_annotation(annotation.dependency),
@@ -690,8 +717,12 @@ class _AnnotationTransformer:
             actual_call = call.__call__
         else:
             actual_call = call
-        if inspect.iscoroutinefunction(actual_call):
+        if is_async_gen_callable(actual_call):
+            return _AsyncGeneratorCallableWrapper(call)
+        elif is_coroutine_callable(actual_call):
             return _AsyncCallableWrapper(call)
+        elif is_gen_callable(actual_call):
+            return _GeneratorCallableWrapper(call)
         else:
             return _CallableWrapper(call)
 
@@ -1061,6 +1092,7 @@ class _EnumWrapper(Generic[_T_ENUM]):
         initialization_namespace = self._get_initialization_namespace_for_enum(self.cls) | raw_member_map
         for attr_name, attr in initialization_namespace.items():
             enum_dict[attr_name] = attr
+        enum_dict["__doc__"] = self.cls.__doc__
         model_copy = cast(type[_T_ENUM], type(self.name, self.cls.__bases__, enum_dict))
         model_copy.__cadwyn_original_model__ = self.cls  # pyright: ignore[reportAttributeAccessIssue]
         return model_copy

{cadwyn-5.1.1 → cadwyn-5.1.3}/cadwyn/structure/versions.py

@@ -23,7 +23,7 @@ from fastapi.routing import APIRoute, _prepare_response_content
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from starlette._utils import is_async_callable
-from typing_extensions import Any, ParamSpec, TypeAlias, TypeVar, assert_never, deprecated, get_args
+from typing_extensions import Any, Literal, ParamSpec, TypeAlias, TypeVar, assert_never, deprecated, get_args
 
 from cadwyn._utils import classproperty
 from cadwyn.exceptions import (
@@ -51,6 +51,11 @@ _CADWYN_REQUEST_PARAM_NAME = "cadwyn_request_param"
 _CADWYN_RESPONSE_PARAM_NAME = "cadwyn_response_param"
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
+_CURRENT_DEPENDENCY_SOLVER_OPTIONS = Literal["cadwyn", "fastapi"]
+_CURRENT_DEPENDENCY_SOLVER_VAR: ContextVar[_CURRENT_DEPENDENCY_SOLVER_OPTIONS] = ContextVar(
+    "cadwyn_dependencies_dry_run"
+)
+
 PossibleInstructions: TypeAlias = Union[
     AlterSchemaSubInstruction, AlterEndpointSubInstruction, AlterEnumSubInstruction, SchemaHadInstruction, staticmethod
 ]
@@ -276,6 +281,7 @@ class VersionBundle:
 
         if api_version_var is None:
             api_version_var = ContextVar("cadwyn_api_version")
+
         self.version_values = tuple(version.value for version in self.versions)
         self.reversed_version_values = tuple(reversed(self.version_values))
         self.api_version_var = api_version_var
@@ -379,6 +385,8 @@ class VersionBundle:
                             instruction(request_info)
         request.scope["headers"] = tuple((key.encode(), value.encode()) for key, value in request_info.headers.items())
         del request._headers
+        # This gives us the ability to tell the user whether cadwyn is running its dependencies or FastAPI
+        _CURRENT_DEPENDENCY_SOLVER_VAR.set("cadwyn")
         # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
         result = await solve_dependencies(
             request=request,

{cadwyn-5.1.1 → cadwyn-5.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cadwyn"
-version = "5.1.1"
+version = "5.1.3"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = [{ name = "Stanislav Zmiev", email = "zmievsa@gmail.com" }]
 license = "MIT"
@@ -51,7 +51,7 @@ classifiers = [
     "Topic :: Internet :: WWW/HTTP",
 ]
 dependencies = [
-    "fastapi >=0.112.3",
+    "fastapi >=0.112.4",
     "starlette >=0.30.0",
     "pydantic >=2.0.0",
     "jinja2 >=3.1.2",
@@ -73,7 +73,8 @@ dev-dependencies = [
     "svcs ~=24.1.0",
     "httpx >=0.26.0",
     "pytest-fixture-classes >=1.0.3",
-    "pytest >=7.2.1",
+    # pytest==8.3.5 has a bug that fails our windows python 3.10 tests
+    "pytest==8.3.4",
     "pytest-cov >=4.0.0",
     "dirty-equals >=0.6.0",
     "uvicorn ~=0.23.0",
@@ -87,6 +88,7 @@ dev-dependencies = [
     "mike >=2.1.2, <3",
     "pdbpp>=0.10.3",
     "markdown-include-variants>=0.0.4",
+    "inline-snapshot>=0.20.7",
 ]
 
 [project.urls]
@@ -97,6 +99,8 @@ Documentation = "https://docs.cadwyn.dev"
 [project.scripts]
 cadwyn = "cadwyn.__main__:app"
 
+[tool.inline-snapshot]
+format-command = "ruff format --stdin-filename {filename}"
 
 [tool.coverage.run]
 parallel = true

{cadwyn-5.1.1 → cadwyn-5.1.3}/tests/test_router_generation.py

@@ -13,12 +13,14 @@ from fastapi.routing import APIRoute
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from fastapi.security.http import HTTPBasic
 from fastapi.testclient import TestClient
-from pydantic import BaseModel
+from inline_snapshot import snapshot
+from pydantic import BaseModel, JsonValue
 from pytest_fixture_classes import fixture_class
 from starlette.responses import FileResponse
-from typing_extensions import Any, NewType, TypeAlias, get_args
+from typing_extensions import Any, NewType, TypeAlias, TypeAliasType, get_args
 
 from cadwyn import VersionBundle, VersionedAPIRouter
+from cadwyn.dependencies import current_dependency_solver
 from cadwyn.exceptions import CadwynError, RouterGenerationError, RouterPathParamsModifiedError
 from cadwyn.route_generation import generate_versioned_routers
 from cadwyn.schema_generation import generate_versioned_models
@@ -798,7 +800,7 @@ def test__router_generation__using_unversioned_models(
     assert routes_2001[3].dependant.body_params[0].type_ is schemas["2001-01-01"][UnversionedSchema3]
 
 
-def test__router_generation__using_weird_typehints(
+def test__router_generation__using_newtype_and_union_typehints(
     router: VersionedAPIRouter,
     create_versioned_api_routes: CreateVersionedAPIRoutes,
 ):
@@ -820,7 +822,7 @@ def test__router_generation__using_weird_typehints(
     assert getattr(routes_2001[1].dependant.body_params[1], TYPE_ATTR) == Union[str, int]
 
 
-def test__router_generation__using_pydantic_typehints__internal_pydantic_typehints_should_work(
+def test__router_generation__using_uploadfile_typehint(
     router: VersionedAPIRouter,
     create_versioned_api_routes: CreateVersionedAPIRoutes,
 ):
@@ -835,6 +837,54 @@ def test__router_generation__using_pydantic_typehints__internal_pydantic_typehin
     # We are intentionally not checking anything here. Our goal is to validate that there is no exception
 
 
+def test__router_generation__using_jsonvalue_typehint(
+    router: VersionedAPIRouter,
+    create_versioned_clients: CreateVersionedClients,
+):
+    @router.post("/test")
+    async def test(param1: JsonValue = Body()):
+        return param1
+
+    clients = create_versioned_clients(
+        version_change(endpoint("/test", ["POST"]).had(response_model=dict[str, str])),
+    )
+    assert clients["2000-01-01"].post("/test", json={"foo": "bar"}).json() == {"foo": "bar"}
+    assert clients["2001-01-01"].post("/test", json={"foo": "bar"}).json() == {"foo": "bar"}
+
+
+def test__router_generation__using_typealias_type_typehint(
+    router: VersionedAPIRouter,
+    create_versioned_clients: CreateVersionedClients,
+):
+    class MySchema(BaseModel):
+        foo: str
+
+    typealias = TypeAliasType("typealias", list[MySchema])  # pyright: ignore[reportGeneralTypeIssues]
+
+    @router.post("/test")
+    async def test(param1: typealias = Body()):
+        return param1
+
+    clients = create_versioned_clients(
+        version_change(schema(MySchema).field("foo").had(name="baz")),
+    )
+    assert clients["2000-01-01"].post("/test", json=[{"foo": "bar"}]).json() == snapshot(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", 0, "baz"],
+                    "msg": "Field required",
+                    "input": {
+                        "foo": "bar",
+                    },
+                }
+            ]
+        }
+    )
+    assert clients["2001-01-01"].post("/test", json=[{"foo": "bar"}]).json() == [{"foo": "bar"}]
+
+
 def test__router_generation__updating_request_depends(
     router: VersionedAPIRouter, create_versioned_app: CreateVersionedApp
 ):
@@ -1205,6 +1255,60 @@ def test__basic_router_generation__subclass_of_security_class_based_dependency_w
     ]
 
 
+def test__router_generation__with_generator_dependencies(
+    router: VersionedAPIRouter,
+    create_versioned_app: CreateVersionedApp,
+):
+    dependency_cache = []
+
+    async def my_async_dependency(current_dependency_runner: Annotated[str, Depends(current_dependency_solver)]):
+        dependency_cache.append(f"{current_dependency_runner} async dependency start")
+        yield "async dependency"
+        dependency_cache.append(f"{current_dependency_runner} async dependency end")
+
+    def my_sync_dependency(current_dependency_runner: Annotated[str, Depends(current_dependency_solver)]):
+        dependency_cache.append(f"{current_dependency_runner} sync dependency start")
+        yield "sync dependency"
+        dependency_cache.append(f"{current_dependency_runner} sync dependency end")
+
+    @router.get("/test")
+    async def test(
+        my_async_dep: Annotated[str, Depends(my_async_dependency)],
+        my_sync_dep: Annotated[str, Depends(my_sync_dependency)],
+    ):
+        assert my_async_dep == "async dependency"
+        assert my_sync_dep == "sync dependency"
+
+    client = TestClient(create_versioned_app(version_change()))
+    assert client.get("/test", headers={"x-api-version": "2000-01-01"}).status_code == 200
+    assert dependency_cache == snapshot(
+        [
+            "fastapi async dependency start",
+            "fastapi sync dependency start",
+            "cadwyn async dependency start",
+            "cadwyn sync dependency start",
+            "cadwyn sync dependency end",
+            "cadwyn async dependency end",
+            "fastapi sync dependency end",
+            "fastapi async dependency end",
+        ]
+    )
+    dependency_cache.clear()
+    assert client.get("/test", headers={"x-api-version": "2001-01-01"}).status_code == 200
+    assert dependency_cache == snapshot(
+        [
+            "fastapi async dependency start",
+            "fastapi sync dependency start",
+            "cadwyn async dependency start",
+            "cadwyn sync dependency start",
+            "cadwyn sync dependency end",
+            "cadwyn async dependency end",
+            "fastapi sync dependency end",
+            "fastapi async dependency end",
+        ]
+    )
+
+
 ######################
 # External lib testing
 ######################

{cadwyn-5.1.1 → cadwyn-5.1.3}/tests/test_schema_generation/test_enum.py

@@ -11,7 +11,7 @@ from tests.conftest import CreateRuntimeSchemas, serialize_enum, version_change
 
 
 class EmptyEnum(Enum):
-    pass
+    """My docstring"""
 
 
 class EnumWithOneMember(Enum):
@@ -34,6 +34,12 @@ class EnumWithOneMemberAndMethods(Enum):
         return cls.world_member  # pyright: ignore[reportAttributeAccessIssue]
 
 
+def test__enum_had__should_copy_docstring_too(create_runtime_schemas: CreateRuntimeSchemas):
+    models = create_runtime_schemas(version_change(enum(EmptyEnum).had(b=auto())))
+    assert models["2000-01-01"][EmptyEnum].__doc__ == "My docstring"
+    assert models["2001-01-01"][EmptyEnum].__doc__ == "My docstring"
+
+
 def test__enum_had__original_enum_is_empty(create_runtime_schemas: CreateRuntimeSchemas):
     models = create_runtime_schemas(version_change(enum(EmptyEnum).had(b=auto())))
     assert serialize_enum(models["2000-01-01"][EmptyEnum]) == {"b": 1}