cadwyn 3.15.1__tar.gz → 3.15.3__tar.gz

{cadwyn-3.15.1 → cadwyn-3.15.3}/PKG-INFO

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

{cadwyn-3.15.1 → cadwyn-3.15.3}/cadwyn/applications.py

@@ -24,6 +24,7 @@ from starlette.routing import BaseRoute, Route
 from starlette.types import Lifespan
 from typing_extensions import Self, deprecated
 
+from cadwyn._utils import same_definition_as_in
 from cadwyn.middleware import HeaderVersioningMiddleware, _get_api_version_dependency
 from cadwyn.route_generation import generate_versioned_routers
 from cadwyn.routing import _RootHeaderAPIRouter
@@ -58,8 +59,13 @@ class Cadwyn(FastAPI):
         swagger_ui_oauth2_redirect_url: str | None = "/docs/oauth2-redirect",
         swagger_ui_init_oauth: dict[str, Any] | None = None,
         middleware: Sequence[Middleware] | None = None,
-        exception_handlers: dict[int | type[Exception], Callable[[Request, Any], Coroutine[Any, Any, Response]]]
-        | None = None,
+        exception_handlers: (
+            dict[
+                int | type[Exception],
+                Callable[[Request, Any], Coroutine[Any, Any, Response]],
+            ]
+            | None
+        ) = None,
         on_startup: Sequence[Callable[[], Any]] | None = None,
         on_shutdown: Sequence[Callable[[], Any]] | None = None,
         lifespan: Lifespan[Self] | None = None,
@@ -75,7 +81,9 @@ class Cadwyn(FastAPI):
         deprecated: bool | None = None,
         include_in_schema: bool = True,
         swagger_ui_parameters: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(generate_unique_id),  # noqa: B008
+        generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(  # noqa: B008
+            generate_unique_id
+        ),
         separate_input_output_schemas: bool = True,
         **extra: Any,
     ) -> None:
@@ -143,8 +151,6 @@ class Cadwyn(FastAPI):
             api_version_var=self.versions.api_version_var,
         )
 
-        self.add_event_handler("startup", self.enrich_swagger)
-
         self.docs_url = docs_url
         self.redoc_url = redoc_url
         self.openapi_url = openapi_url
@@ -229,7 +235,7 @@ class Cadwyn(FastAPI):
             terms_of_service=self.terms_of_service,
             contact=self.contact,
             license_info=self.license_info,
-            routes=self.router.routes,
+            routes=self.router.unversioned_routes,
             tags=self.openapi_tags,
             servers=self.servers,
         )
@@ -317,29 +323,118 @@ class Cadwyn(FastAPI):
         except ValueError as e:
             raise ValueError("header_value should be in ISO 8601 format") from e
 
+        added_routes: list[BaseRoute] = []
         if header_value_as_dt not in self.router.versioned_routers:  # pragma: no branch
             self.router.versioned_routers[header_value_as_dt] = APIRouter(**self._kwargs_to_router)
-            if self.openapi_url is not None:  # pragma: no branch
-                self.router.versioned_routers[header_value_as_dt].add_route(
-                    path=self.openapi_url,
-                    endpoint=self.openapi_jsons,
-                    include_in_schema=False,
-                )
 
-        added_routes: list[BaseRoute] = []
+        versioned_router = self.router.versioned_routers[header_value_as_dt]
+        if self.openapi_url is not None:  # pragma: no branch
+            versioned_router.add_route(
+                path=self.openapi_url,
+                endpoint=self.openapi_jsons,
+                include_in_schema=False,
+            )
+            added_routes.append(versioned_router.routes[-1])
+
+        added_route_count = 0
         for router in (first_router, *other_routers):
             self.router.versioned_routers[header_value_as_dt].include_router(
                 router,
                 dependencies=[Depends(_get_api_version_dependency(self.router.api_version_header_name, header_value))],
             )
+            added_route_count += len(router.routes)
+
+        added_routes.extend(versioned_router.routes[-added_route_count:])
+        self.router.routes.extend(added_routes)
 
+        self.enrich_swagger()
         return added_routes
 
     def add_unversioned_routers(self, *routers: APIRouter):
         for router in routers:
             self.router.include_router(router)
+        self.enrich_swagger()
 
     @deprecated("Use add add_unversioned_routers instead")
     def add_unversioned_routes(self, *routes: Route):
         router = APIRouter(routes=list(routes))
         self.include_router(router)
+        self.enrich_swagger()
+
+    @same_definition_as_in(FastAPI.include_router)
+    def include_router(self, *args: Any, **kwargs: Any):
+        route = super().include_router(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.post)
+    def post(self, *args: Any, **kwargs: Any):
+        route = super().post(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.get)
+    def get(self, *args: Any, **kwargs: Any):
+        route = super().get(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.patch)
+    def patch(self, *args: Any, **kwargs: Any):
+        route = super().patch(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.delete)
+    def delete(self, *args: Any, **kwargs: Any):
+        route = super().delete(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.put)
+    def put(self, *args: Any, **kwargs: Any):
+        route = super().put(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.trace)
+    def trace(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        route = super().trace(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.options)
+    def options(self, *args: Any, **kwargs: Any):
+        route = super().options(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.head)
+    def head(self, *args: Any, **kwargs: Any):
+        route = super().head(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.add_api_route)
+    def add_api_route(self, *args: Any, **kwargs: Any):
+        route = super().add_api_route(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.api_route)
+    def api_route(self, *args: Any, **kwargs: Any):
+        route = super().api_route(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.add_api_websocket_route)
+    def add_api_websocket_route(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        route = super().add_api_websocket_route(*args, **kwargs)
+        self.enrich_swagger()
+        return route
+
+    @same_definition_as_in(FastAPI.websocket)
+    def websocket(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        route = super().websocket(*args, **kwargs)
+        self.enrich_swagger()
+        return route

{cadwyn-3.15.1 → cadwyn-3.15.3}/cadwyn/routing.py

@@ -9,10 +9,15 @@ from typing import Any
 from fastapi.routing import APIRouter
 from starlette.datastructures import URL
 from starlette.responses import RedirectResponse
-from starlette.routing import BaseRoute, Match
+from starlette.routing import BaseRoute, Match, Route
 from starlette.types import Receive, Scope, Send
 
-from .route_generation import InternalRepresentationOf, generate_versioned_routers  # pyright: ignore[reportDeprecated]
+from cadwyn._utils import same_definition_as_in
+
+from .route_generation import (
+    InternalRepresentationOf,
+    generate_versioned_routers,
+)
 
 # TODO: Remove this in a major version. This is only here for backwards compatibility
 __all__ = ["InternalRepresentationOf", "generate_versioned_routers"]
@@ -46,6 +51,7 @@ class _RootHeaderAPIRouter(APIRouter):
         self.versioned_routers: dict[date, APIRouter] = {}
         self.api_version_header_name = api_version_header_name.lower()
         self.api_version_var = api_version_var
+        self.unversioned_routes: list[Route] = []
 
     @cached_property
     def sorted_versions(self):
@@ -68,13 +74,19 @@ class _RootHeaderAPIRouter(APIRouter):
             # then the request version is older that the oldest route we have
             _logger.info(
                 "Request version is older than the oldest version. No route can match this version",
-                extra={"oldest_version": self.min_routes_version.isoformat(), "request_version": request_version},
+                extra={
+                    "oldest_version": self.min_routes_version.isoformat(),
+                    "request_version": request_version,
+                },
             )
             return []
         version_chosen = self.find_closest_date_but_not_new(request_header_value)
         _logger.info(
             "Partial match. The endpoint with a lower version was selected for the API call",
-            extra={"version_chosen": version_chosen, "request_version": request_version},
+            extra={
+                "version_chosen": version_chosen,
+                "request_version": request_version,
+            },
         )
         return self.versioned_routers[version_chosen].routes
 
@@ -94,13 +106,33 @@ class _RootHeaderAPIRouter(APIRouter):
         # if header_value is None, then it's an unversioned request and we need to use the unversioned routes
         # if there will be a value, we search for the most suitable version
         if not header_value:
-            routes = self.routes
+            routes = self.unversioned_routes
         elif header_value in self.versioned_routers:
             routes = self.versioned_routers[header_value].routes
         else:
             routes = self.pick_version(request_header_value=header_value)
         await self.process_request(scope=scope, receive=receive, send=send, routes=routes)
 
+    @same_definition_as_in(APIRouter.add_api_route)
+    def add_api_route(self, *args: Any, **kwargs: Any):
+        super().add_api_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_route)
+    def add_route(self, *args: Any, **kwargs: Any):
+        super().add_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_api_websocket_route)
+    def add_api_websocket_route(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        super().add_api_websocket_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_websocket_route)
+    def add_websocket_route(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        super().add_websocket_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
     async def process_request(self, scope: Scope, receive: Receive, send: Send, routes: Sequence[BaseRoute]) -> None:
         """
         its a copy-paste from starlette.routing.Router

{cadwyn-3.15.1 → cadwyn-3.15.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cadwyn"
-version = "3.15.1"
+version = "3.15.3"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = ["Stanislav Zmiev <zmievsa@gmail.com>"]
 license = "MIT"