cadwyn 3.15.3a2__tar.gz → 3.15.5__tar.gz

{cadwyn-3.15.3a2 → cadwyn-3.15.5}/PKG-INFO

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

{cadwyn-3.15.3a2 → cadwyn-3.15.5}/cadwyn/applications.py

@@ -1,3 +1,5 @@
+import dataclasses
+import datetime
 from collections.abc import Callable, Coroutine, Sequence
 from datetime import date
 from logging import getLogger
@@ -24,7 +26,6 @@ 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
@@ -34,6 +35,11 @@ CURR_DIR = Path(__file__).resolve()
 logger = getLogger(__name__)
 
 
+@dataclasses.dataclass(slots=True)
+class FakeDependencyOverridesProvider:
+    dependency_overrides: dict[Callable[..., Any], Callable[..., Any]]
+
+
 class Cadwyn(FastAPI):
     _templates = Jinja2Templates(directory=CURR_DIR.parent / "static")
 
@@ -81,20 +87,18 @@ 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_function: Callable[[routing.APIRoute], str] = Default(  # noqa: B008
             generate_unique_id
-        ),  # noqa: B008
+        ),
         separate_input_output_schemas: bool = True,
         **extra: Any,
     ) -> None:
         self.versions = versions
         # TODO: Remove argument entirely in any major version.
-        latest_schemas_package = (
-            extra.pop("latest_schemas_package", None)
-            or self.versions.head_schemas_package
-        )
+        latest_schemas_package = extra.pop("latest_schemas_package", None) or self.versions.head_schemas_package
         self.versions.head_schemas_package = latest_schemas_package
         self._latest_schemas_package = cast(ModuleType, latest_schemas_package)
+        self._dependency_overrides_provider = FakeDependencyOverridesProvider({})
 
         super().__init__(
             debug=debug,
@@ -148,23 +152,20 @@ class Cadwyn(FastAPI):
             "responses": responses,
             "generate_unique_id_function": generate_unique_id_function,
         }
-        self.router: _RootHeaderAPIRouter = (
-            _RootHeaderAPIRouter(  # pyright: ignore[reportIncompatibleVariableOverride]
-                **self._kwargs_to_router,
-                api_version_header_name=api_version_header_name,
-                api_version_var=self.versions.api_version_var,
-            )
+        self.router: _RootHeaderAPIRouter = _RootHeaderAPIRouter(  # pyright: ignore[reportIncompatibleVariableOverride]
+            **self._kwargs_to_router,
+            api_version_header_name=api_version_header_name,
+            api_version_var=self.versions.api_version_var,
         )
 
         self.docs_url = docs_url
         self.redoc_url = redoc_url
         self.openapi_url = openapi_url
         self.redoc_url = redoc_url
-        self.swaggers = {}
 
         unversioned_router = APIRouter(**self._kwargs_to_router)
         self._add_openapi_endpoints(unversioned_router)
-        self.add_unversioned_routers(unversioned_router)
+        self.include_router(unversioned_router)
         self.add_middleware(
             HeaderVersioningMiddleware,
             api_version_header_name=self.router.api_version_header_name,
@@ -172,17 +173,27 @@ class Cadwyn(FastAPI):
             default_response_class=default_response_class,
         )
 
+    @property
+    def dependency_overrides(self) -> dict[Callable[..., Any], Callable[..., Any]]:
+        # This is only necessary because we cannot send self to versioned router generator
+        # because it takes a deepcopy of the router and self.versions.head_schemas_package is a module
+        # which cannot be copied.
+        return self._dependency_overrides_provider.dependency_overrides
+
+    @dependency_overrides.setter
+    def dependency_overrides(  # pyright: ignore[reportIncompatibleVariableOverride]
+        self,
+        value: dict[Callable[..., Any], Callable[..., Any]],
+    ) -> None:
+        self._dependency_overrides_provider.dependency_overrides = value
+
     @property  # pragma: no cover
-    @deprecated(
-        "It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead"
-    )
+    @deprecated("It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead")
     def latest_schemas_package(self):
         return self._latest_schemas_package
 
     @latest_schemas_package.setter  # pragma: no cover
-    @deprecated(
-        "It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead"
-    )
+    @deprecated("It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead")
     def latest_schemas_package(self, value: ModuleType | None):
         self._latest_schemas_package = value
 
@@ -219,7 +230,7 @@ class Cadwyn(FastAPI):
                 )
 
     def generate_and_include_versioned_routers(self, *routers: APIRouter) -> None:
-        root_router = APIRouter()
+        root_router = APIRouter(dependency_overrides_provider=self._dependency_overrides_provider)
         for router in routers:
             root_router.include_router(router)
         router_versions = generate_versioned_routers(
@@ -229,57 +240,45 @@ class Cadwyn(FastAPI):
         for version, router in router_versions.items():
             self.add_header_versioned_routers(router, header_value=version.isoformat())
 
-    def enrich_swagger(self):
-        """
-        This method goes through all header-based apps and collect a dict[openapi_version, openapi_json]
-
-        For each route a `X-API-VERSION` header with value is added
-
-        """
-        unversioned_routes_openapi = get_openapi(
-            title=self.title,
-            version=self.version,
-            openapi_version=self.openapi_version,
-            description=self.description,
-            terms_of_service=self.terms_of_service,
-            contact=self.contact,
-            license_info=self.license_info,
-            routes=self.router.unversioned_routes,
-            tags=self.openapi_tags,
-            servers=self.servers,
+    async def openapi_jsons(self, req: Request) -> JSONResponse:
+        raw_version = req.query_params.get("version") or req.headers.get(self.router.api_version_header_name)
+        not_found_error = HTTPException(
+            status_code=404,
+            detail=f"OpenApi file of with version `{raw_version}` not found",
         )
-        if unversioned_routes_openapi["paths"]:
-            self.swaggers["unversioned"] = unversioned_routes_openapi
-
-        for header_value, router in self.router.versioned_routers.items():
-            header_value_str = header_value.isoformat()
-            openapi = get_openapi(
+        try:
+            version = datetime.date.fromisoformat(raw_version)  # pyright: ignore[reportArgumentType]
+        # TypeError when raw_version is None
+        # ValueError when raw_version is of the non-iso format
+        except (ValueError, TypeError):
+            version = raw_version
+
+        if 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():
+            routes = self.router.unversioned_routes
+            formatted_version = "unversioned"
+        else:
+            raise not_found_error
+
+        return JSONResponse(
+            get_openapi(
                 title=self.title,
-                version=header_value.isoformat(),
+                version=formatted_version,
                 openapi_version=self.openapi_version,
                 description=self.description,
                 terms_of_service=self.terms_of_service,
                 contact=self.contact,
                 license_info=self.license_info,
-                routes=router.routes,
+                routes=routes,
                 tags=self.openapi_tags,
                 servers=self.servers,
             )
-            # in current implementation we expect header_value to be a date
-            self.swaggers[header_value_str] = openapi
-
-    async def openapi_jsons(self, req: Request) -> JSONResponse:
-        version = req.query_params.get("version") or req.headers.get(
-            self.router.api_version_header_name
         )
-        openapi_of_a_version = self.swaggers.get(version)
-        if not openapi_of_a_version:
-            raise HTTPException(
-                status_code=404,
-                detail=f"OpenApi file of with version `{version}` not found",
-            )
 
-        return JSONResponse(openapi_of_a_version)
+    def _there_are_public_unversioned_routes(self):
+        return any(isinstance(route, Route) and route.include_in_schema for route in self.router.unversioned_routes)
 
     async def swagger_dashboard(self, req: Request) -> Response:
         version = req.query_params.get("version")
@@ -305,9 +304,7 @@ class Cadwyn(FastAPI):
         if version:
             root_path = self._extract_root_path(req)
             openapi_url = root_path + f"{self.openapi_url}?version={version}"
-            return get_redoc_html(
-                openapi_url=openapi_url, title=f"{self.title} - ReDoc"
-            )
+            return get_redoc_html(openapi_url=openapi_url, title=f"{self.title} - ReDoc")
 
         return self._render_docs_dashboard(req, docs_url=cast(str, self.redoc_url))
 
@@ -316,15 +313,12 @@ class Cadwyn(FastAPI):
 
     def _render_docs_dashboard(self, req: Request, docs_url: str):
         base_url = str(req.base_url).rstrip("/")
+        table = {version: f"{base_url}{docs_url}?version={version}" for version in self.router.sorted_versions}
+        if self._there_are_public_unversioned_routes():
+            table |= {"unversioned": f"{base_url}{docs_url}?version=unversioned"}
         return self._templates.TemplateResponse(
             "docs.html",
-            {
-                "request": req,
-                "table": {
-                    version: f"{base_url}{docs_url}?version={version}"
-                    for version in sorted(self.swaggers)
-                },
-            },
+            {"request": req, "table": table},
         )
 
     def add_header_versioned_routers(
@@ -339,126 +333,41 @@ 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
+            self.router.versioned_routers[header_value_as_dt] = APIRouter(**self._kwargs_to_router)
+
+        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,
             )
-            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.append(versioned_router.routes[-1])
 
-        version_router = self.router.versioned_routers[header_value_as_dt]
-        added_routes: list[BaseRoute] = []
         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
-                        )
-                    )
-                ],
+                dependencies=[Depends(_get_api_version_dependency(self.router.api_version_header_name, header_value))],
             )
             added_route_count += len(router.routes)
 
-        added_routes = (
-            version_router.routes[-added_route_count :]
-        )
+        added_routes.extend(versioned_router.routes[-added_route_count:])
         self.router.routes.extend(added_routes)
 
-        self.enrich_swagger()
         return added_routes
 
+    @deprecated("Use builtin FastAPI methods such as include_router instead")
     def add_unversioned_routers(self, *routers: APIRouter):
         for router in routers:
-            self.router.include_router(router)
-        self.enrich_swagger()
+            self.include_router(router)
 
-    @deprecated("Use add add_unversioned_routers instead")
+    @deprecated("Use builtin FastAPI methods such as add_api_route 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
+
+    @deprecated("It no longer does anything")
+    def enrich_swagger(self): ...

{cadwyn-3.15.3a2 → cadwyn-3.15.5}/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, Route
+from starlette.routing import BaseRoute, Match
 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,  # pyright: ignore[reportDeprecated]
+    generate_versioned_routers,
+)
 
 # TODO: Remove this in a major version. This is only here for backwards compatibility
 __all__ = ["InternalRepresentationOf", "generate_versioned_routers"]
@@ -46,7 +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] = []
+        self.unversioned_routes: list[BaseRoute] = []
 
     @cached_property
     def sorted_versions(self):
@@ -69,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
 
@@ -102,19 +113,23 @@ class _RootHeaderAPIRouter(APIRouter):
             routes = self.pick_version(request_header_value=header_value)
         await self.process_request(scope=scope, receive=receive, send=send, routes=routes)
 
-    def add_api_route(self, *args, **kwargs): 
+    @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])
 
-    def add_route(self, *args, **kwargs): 
+    @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])
 
-    def add_api_websocket_route(self, *args, **kwargs): 
+    @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])
 
-    def add_websocket_route(self, *args, **kwargs): 
+    @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])
 

{cadwyn-3.15.3a2 → cadwyn-3.15.5}/pyproject.toml

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