cadwyn 3.15.5__tar.gz → 3.15.7__tar.gz

{cadwyn-3.15.5 → cadwyn-3.15.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 3.15.5
+Version: 3.15.7
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Home-page: https://github.com/zmievsa/cadwyn
 License: MIT

{cadwyn-3.15.5 → cadwyn-3.15.7}/cadwyn/__init__.py

@@ -7,7 +7,7 @@ from .route_generation import (
     VersionedAPIRouter,
     generate_versioned_routers,
 )
-from .structure import VersionBundle
+from .structure import HeadVersion, Version, VersionBundle
 
 __version__ = importlib.metadata.version("cadwyn")
 __all__ = [
@@ -15,6 +15,8 @@ __all__ = [
     "VersionedAPIRouter",
     "generate_code_for_versioned_packages",
     "VersionBundle",
+    "HeadVersion",
+    "Version",
     "generate_versioned_routers",
     "InternalRepresentationOf",
 ]

{cadwyn-3.15.5 → cadwyn-3.15.7}/cadwyn/route_generation.py

@@ -12,6 +12,7 @@ from enum import Enum
 from pathlib import Path
 from types import GenericAlias, MappingProxyType, ModuleType
 from typing import (
+    TYPE_CHECKING,
     Annotated,
     Any,
     Generic,
@@ -31,20 +32,11 @@ import fastapi.utils
 from fastapi import APIRouter
 from fastapi._compat import ModelField as FastAPIModelField
 from fastapi._compat import create_body_model
-from fastapi.dependencies.models import Dependant
-from fastapi.dependencies.utils import (
-    get_body_field,
-    get_dependant,
-    get_parameterless_sub_dependant,
-)
 from fastapi.params import Depends
 from fastapi.routing import APIRoute
 from issubclass import issubclass as lenient_issubclass
 from pydantic import BaseModel
-from starlette.routing import (
-    BaseRoute,
-    request_response,
-)
+from starlette.routing import BaseRoute
 from typing_extensions import Self, assert_never, deprecated
 
 from cadwyn._compat import get_annotation_from_model_field, model_fields, rebuild_fastapi_body_param
@@ -68,7 +60,10 @@ from cadwyn.structure.endpoints import (
 )
 from cadwyn.structure.versions import _CADWYN_REQUEST_PARAM_NAME, _CADWYN_RESPONSE_PARAM_NAME, VersionChange
 
-_T = TypeVar("_T", bound=Callable[..., Any])
+if TYPE_CHECKING:
+    from fastapi.dependencies.models import Dependant
+
+_Call = TypeVar("_Call", bound=Callable[..., Any])
 _R = TypeVar("_R", bound=fastapi.routing.APIRouter)
 # This is a hack we do because we can't guarantee how the user will use the router.
 _DELETED_ROUTE_TAG = "_CADWYN_DELETED_ROUTE"
@@ -122,7 +117,7 @@ def generate_versioned_routers(
 
 
 class VersionedAPIRouter(fastapi.routing.APIRouter):
-    def only_exists_in_older_versions(self, endpoint: _T) -> _T:
+    def only_exists_in_older_versions(self, endpoint: _Call) -> _Call:
         route = _get_route_from_func(self.routes, endpoint)
         if route is None:
             raise LookupError(
@@ -308,7 +303,7 @@ class _EndpointTransformer(Generic[_R]):
 
     def _replace_internal_representation_with_the_versioned_schema(
         self,
-        copy_of_dependant: Dependant,
+        copy_of_dependant: "Dependant",
         schema_to_internal_request_body_representation: dict[type[BaseModel], type[BaseModel]],
     ):
         body_param: FastAPIModelField = copy_of_dependant.body_params[0]
@@ -467,9 +462,10 @@ def _extract_internal_request_schemas_from_router(
 
     for route in router.routes:
         if isinstance(route, APIRoute):  # pragma: no branch
-            route.endpoint = _modify_callable(
+            route.endpoint = _modify_callable_annotations(
                 route.endpoint,
                 modify_annotations=_extract_internal_request_schemas_from_annotations,
+                annotation_modifying_wrapper_factory=_copy_endpoint,
             )
             _remake_endpoint_dependencies(route)
     return schema_to_internal_request_body_representation
@@ -576,7 +572,12 @@ class _AnnotationTransformer:
             def modifier(annotation: Any):
                 return self._change_version_of_annotations(annotation, version_dir)
 
-            return _modify_callable(annotation, modifier, modifier)
+            return _modify_callable_annotations(
+                annotation,
+                modifier,
+                modifier,
+                annotation_modifying_wrapper_factory=_copy_function_through_class_based_wrapper,
+            )
         else:
             return annotation
 
@@ -637,12 +638,14 @@ class _AnnotationTransformer:
             )
 
 
-def _modify_callable(
-    call: Callable,
+def _modify_callable_annotations(
+    call: _Call,
     modify_annotations: Callable[[dict[str, Any]], dict[str, Any]] = lambda a: a,
     modify_defaults: Callable[[tuple[Any, ...]], tuple[Any, ...]] = lambda a: a,
-):
-    annotation_modifying_wrapper = _copy_function(call)
+    *,
+    annotation_modifying_wrapper_factory: Callable[[_Call], _Call],
+) -> _Call:
+    annotation_modifying_wrapper = annotation_modifying_wrapper_factory(call)
     old_params = inspect.signature(call).parameters
     callable_annotations = annotation_modifying_wrapper.__annotations__
     annotation_modifying_wrapper.__annotations__ = modify_annotations(callable_annotations)
@@ -658,15 +661,12 @@ def _modify_callable(
 
 
 def _remake_endpoint_dependencies(route: fastapi.routing.APIRoute):
-    route.dependant = get_dependant(path=route.path_format, call=route.endpoint)
+    # Unlike get_dependant, APIRoute is the public API of FastAPI and it's (almost) guaranteed to be stable.
+
+    route_copy = fastapi.routing.APIRoute(route.path, route.endpoint, dependencies=route.dependencies)
+    route.dependant = route_copy.dependant
+    route.body_field = route_copy.body_field
     _add_request_and_response_params(route)
-    route.body_field = get_body_field(dependant=route.dependant, name=route.unique_id)
-    for depends in route.dependencies[::-1]:
-        route.dependant.dependencies.insert(
-            0,
-            get_parameterless_sub_dependant(depends=depends, path=route.path_format),
-        )
-    route.app = request_response(route.get_route_handler())
 
 
 def _add_request_and_response_params(route: APIRoute):
@@ -681,7 +681,7 @@ def _add_data_migrations_to_route(
     head_route: Any,
     template_body_field: type[BaseModel] | None,
     template_body_field_name: str | None,
-    dependant_for_request_migrations: Dependant,
+    dependant_for_request_migrations: "Dependant",
     versions: VersionBundle,
 ):
     if not (route.dependant.request_param_name and route.dependant.response_param_name):  # pragma: no cover
@@ -802,37 +802,78 @@ def _get_route_from_func(
     return None
 
 
-def _copy_function(function: _T) -> _T:
-    while hasattr(function, "__alt_wrapped__"):
-        function = function.__alt_wrapped__
-    if not isinstance(function, types.FunctionType | types.MethodType):
-        # This means that the callable is actually an instance of a regular class
-        function = function.__call__
-    if inspect.iscoroutinefunction(function):
+def _copy_endpoint(function: Any) -> Any:
+    function = _unwrap_callable(function)
+    function_copy: Any = types.FunctionType(
+        function.__code__,
+        function.__globals__,
+        name=function.__name__,
+        argdefs=function.__defaults__,
+        closure=function.__closure__,
+    )
+    function_copy = functools.update_wrapper(function_copy, function)
+    # Otherwise it will have the same signature as __wrapped__ due to how inspect module works
+    del function_copy.__wrapped__
+
+    function_copy._original_callable = function
+    function.__kwdefaults__ = function.__kwdefaults__.copy() if function.__kwdefaults__ is not None else {}
+
+    return function_copy
+
 
-        @functools.wraps(function)
-        async def annotation_modifying_wrapper(  # pyright: ignore[reportRedeclaration]
-            *args: Any,
-            **kwargs: Any,
-        ) -> Any:
-            return await function(*args, **kwargs)
+class _CallableWrapper:
+    """__eq__ and __hash__ are needed to make sure that dependency overrides work correctly.
+    They are based on putting dependencies (functions) as keys for the dictionary so if we want to be able to
+    override the wrapper, we need to make sure that it is equivalent to the original in __hash__ and __eq__
+    """
 
+    def __init__(self, original_callable: Callable) -> None:
+        super().__init__()
+        self._original_callable = original_callable
+        functools.update_wrapper(self, original_callable)
+
+    @property
+    def __globals__(self):
+        """FastAPI uses __globals__ to resolve forward references in type hints
+        It's supposed to be an attribute on the function but we use it as property to prevent python
+        from trying to pickle globals when we deepcopy this wrapper
+        """
+        #
+        return self._original_callable.__globals__
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        return self._original_callable(*args, **kwargs)
+
+    def __hash__(self):
+        return hash(self._original_callable)
+
+    def __eq__(self, value: object) -> bool:
+        return self._original_callable == value  # pyright: ignore[reportUnnecessaryComparison]
+
+
+class _AsyncCallableWrapper(_CallableWrapper):
+    async def __call__(self, *args: Any, **kwargs: Any):
+        return await self._original_callable(*args, **kwargs)
+
+
+def _copy_function_through_class_based_wrapper(call: Any):
+    """Separate from copy_endpoint because endpoints MUST be functions in FastAPI, they cannot be cls instances"""
+    call = _unwrap_callable(call)
+
+    if inspect.iscoroutinefunction(call):
+        return _AsyncCallableWrapper(call)
     else:
+        return _CallableWrapper(call)
 
-        @functools.wraps(function)
-        def annotation_modifying_wrapper(
-            *args: Any,
-            **kwargs: Any,
-        ) -> Any:
-            return function(*args, **kwargs)
 
-    # Otherwise it will have the same signature as __wrapped__ due to how inspect module works
-    annotation_modifying_wrapper.__alt_wrapped__ = (  # pyright: ignore[reportAttributeAccessIssue]
-        annotation_modifying_wrapper.__wrapped__
-    )
-    del annotation_modifying_wrapper.__wrapped__
+def _unwrap_callable(call: Any) -> Any:
+    while hasattr(call, "_original_callable"):
+        call = call._original_callable
+    if not isinstance(call, types.FunctionType | types.MethodType):
+        # This means that the callable is actually an instance of a regular class
+        call = call.__call__
 
-    return cast(_T, annotation_modifying_wrapper)
+    return call
 
 
 def _route_has_a_simple_body_schema(route: APIRoute) -> bool:

{cadwyn-3.15.5 → cadwyn-3.15.7}/cadwyn/structure/versions.py

@@ -285,6 +285,8 @@ class VersionBundle:
             raise CadwynStructureError(
                 "Versions are not sorted correctly. Please sort them in descending order.",
             )
+        if not self.versions:
+            raise CadwynStructureError("You must define at least one non-head version in a VersionBundle.")
         if self.versions[-1].version_changes:
             raise CadwynStructureError(
                 f'The first version "{self.versions[-1].value}" cannot have any version changes. '
@@ -325,7 +327,7 @@ class VersionBundle:
             raise CadwynStructureError(
                 f'The head schemas package must be a package. "{head_schemas_package.__name__}" is not a package.',
             )
-        elif head_schemas_package.__name__.endswith(".head"):
+        elif head_schemas_package.__name__.endswith(".head") or head_schemas_package.__name__ == "head":
             return "head"
         elif head_schemas_package.__name__.endswith(".latest"):
             warnings.warn(
@@ -463,7 +465,6 @@ class VersionBundle:
         request.scope["headers"] = tuple((key.encode(), value.encode()) for key, value in request_info.headers.items())
         del request._headers
         # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
-
         dependencies, errors, _, _, _ = await solve_dependencies(
             request=request,
             response=response,
@@ -803,7 +804,7 @@ async def _get_body(
         ) from e
     except HTTPException:
         raise
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         raise HTTPException(status_code=400, detail="There was an error parsing the body") from e
     return body
 

{cadwyn-3.15.5 → cadwyn-3.15.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cadwyn"
-version = "3.15.5"
+version = "3.15.7"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = ["Stanislav Zmiev <zmievsa@gmail.com>"]
 license = "MIT"
@@ -68,7 +68,6 @@ cli = ["typer"]
 pytest = ">=7.2.1"
 pytest-cov = ">=4.0.0"
 uvicorn = "*"
-devtools = "*"
 pdbpp = "^0.10.3"
 httpx = "*"
 pytest-fixture-classes = ">=1.0.3"
@@ -78,6 +77,8 @@ mkdocs-material = ">=9.3.1"
 python-multipart = ">=0.0.6"
 mkdocs-simple-hooks = ">=0.1.5"
 pytest-sugar = "^1.0.0"
+better-devtools = "^0.13.3"
+svcs = "^24.1.0"
 
 [tool.poetry.scripts]
 cadwyn = "cadwyn.__main__:app"