cadwyn 3.11.0__py3-none-any.whl → 3.12.0__py3-none-any.whl

cadwyn/applications.py

@@ -19,6 +19,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
@@ -117,26 +118,34 @@ class Cadwyn(FastAPI):
             separate_input_output_schemas=separate_input_output_schemas,
             **extra,
         )
+        self._kwargs_to_router: dict[str, Any] = {
+            "routes": routes,
+            "redirect_slashes": redirect_slashes,
+            "dependency_overrides_provider": self,
+            "on_startup": on_startup,
+            "on_shutdown": on_shutdown,
+            "lifespan": lifespan,
+            "default_response_class": default_response_class,
+            "dependencies": dependencies,
+            "callbacks": callbacks,
+            "deprecated": deprecated,
+            "include_in_schema": include_in_schema,
+            "responses": responses,
+            "generate_unique_id_function": generate_unique_id_function,
+        }
         self.router: _RootHeaderAPIRouter = _RootHeaderAPIRouter(  # pyright: ignore[reportIncompatibleVariableOverride]
-            routes=self.routes,
-            on_startup=on_startup,
-            on_shutdown=on_shutdown,
-            default_response_class=default_response_class,
-            dependencies=dependencies,
-            callbacks=callbacks,
-            deprecated=deprecated,
-            responses=responses,
+            **self._kwargs_to_router,
             api_version_header_name=api_version_header_name,
             api_version_var=self.versions.api_version_var,
-            lifespan=lifespan,
         )
+
         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(routes=routes)
+        unversioned_router = APIRouter(**self._kwargs_to_router)
         self._add_openapi_endpoints(unversioned_router)
         self.add_unversioned_routers(unversioned_router)
         self.add_middleware(
@@ -202,14 +211,14 @@ class Cadwyn(FastAPI):
             terms_of_service=self.terms_of_service,
             contact=self.contact,
             license_info=self.license_info,
-            routes=self.router.unversioned_routes,
+            routes=self.router.routes,
             tags=self.openapi_tags,
             servers=self.servers,
         )
         if unversioned_routes_openapi["paths"]:
             self.swaggers["unversioned"] = unversioned_routes_openapi
 
-        for header_value, routes in self.router.versioned_routes.items():
+        for header_value, router in self.router.versioned_routers.items():
             header_value_str = header_value.isoformat()
             openapi = get_openapi(
                 title=self.title,
@@ -219,7 +228,7 @@ class Cadwyn(FastAPI):
                 terms_of_service=self.terms_of_service,
                 contact=self.contact,
                 license_info=self.license_info,
-                routes=routes,
+                routes=router.routes,
                 tags=self.openapi_tags,
                 servers=self.servers,
             )
@@ -272,33 +281,109 @@ class Cadwyn(FastAPI):
         except ValueError as e:
             raise ValueError("header_value should be in ISO 8601 format") from e
 
-        if header_value_as_dt not in self.router.versioned_routes:  # pragma: no branch
-            self.router.versioned_routes[header_value_as_dt] = []
+        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_routes[header_value_as_dt].append(
-                    Route(path=self.openapi_url, endpoint=self.openapi_jsons, include_in_schema=False)
+                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] = []
         for router in (first_router, *other_routers):
-            added_route_count = len(router.routes)
-
-            self.include_router(
+            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_routes.extend(self.routes[len(self.routes) - added_route_count :])
-        for route in added_routes:
-            self.router.versioned_routes[header_value_as_dt].append(route)
 
         self.enrich_swagger()
         return added_routes
 
+    @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
+
     def add_unversioned_routers(self, *routers: APIRouter):
         for router in routers:
-            self.include_router(router)
-            self.router.unversioned_routes.extend(router.routes)
+            self.router.include_router(router)
         self.enrich_swagger()
 
+    @deprecated("Use add add_unversioned_routers instead")
     def add_unversioned_routes(self, *routes: Route):
-        self.router.unversioned_routes.extend(routes)
+        router = APIRouter(routes=list(routes))
+        self.include_router(router)

cadwyn/routing.py

@@ -1,5 +1,4 @@
 import bisect
-from collections import OrderedDict
 from collections.abc import Sequence
 from contextvars import ContextVar
 from datetime import date
@@ -44,32 +43,25 @@ class _RootHeaderAPIRouter(APIRouter):
         **kwargs: Any,
     ):
         super().__init__(*args, **kwargs)
-        self.versioned_routes: dict[date, list[BaseRoute]] = {}
-        self.unversioned_routes: list[BaseRoute] = []
+        self.versioned_routers: dict[date, APIRouter] = {}
         self.api_version_header_name = api_version_header_name.lower()
         self.api_version_var = api_version_var
 
     @cached_property
-    def sorted_versioned_routes(self):
-        sorted_routes = sorted(self.versioned_routes.items())
-        return OrderedDict(sorted_routes)
+    def sorted_versions(self):
+        return sorted(self.versioned_routers.keys())
 
     @cached_property
     def min_routes_version(self):
-        return min(self.sorted_versioned_routes.keys())
+        return min(self.sorted_versions)
 
-    def find_closest_date_but_not_new(self, request_version: date):
-        routes = list(self.sorted_versioned_routes.keys())
-        index = bisect.bisect_left(routes, request_version)
+    def find_closest_date_but_not_new(self, request_version: date) -> date:
+        index = bisect.bisect_left(self.sorted_versions, request_version)
         # as bisect_left returns the index where to insert item x in list a, assuming a is sorted
         # we need to get the previous item and that will be a match
-        return routes[index - 1]
+        return self.sorted_versions[index - 1]
 
-    def pick_version(
-        self,
-        request_header_value: date,
-    ) -> list[BaseRoute]:
-        routes = []
+    def pick_version(self, request_header_value: date) -> list[BaseRoute]:
         request_version = request_header_value.isoformat()
 
         if self.min_routes_version > request_header_value:
@@ -79,13 +71,13 @@ class _RootHeaderAPIRouter(APIRouter):
                 f"is older than the oldest "
                 f"version {self.min_routes_version.isoformat()} ",
             )
-            return routes
+            return []
         version_chosen = self.find_closest_date_but_not_new(request_header_value)
         _logger.info(
             f"Partial match. The endpoint with {version_chosen} "
             f"version was selected for API call version {request_version}",
         )
-        return self.versioned_routes[version_chosen]
+        return self.versioned_routers[version_chosen].routes
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         """
@@ -103,9 +95,9 @@ 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.unversioned_routes
-        elif header_value in self.versioned_routes:
-            routes = self.versioned_routes[header_value]
+            routes = self.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)

cadwyn/structure/versions.py

@@ -343,18 +343,22 @@ class VersionBundle:
                 f'Received "{head_schemas_package.__name__}" instead.',
             )
 
+    @functools.cached_property
+    def _all_versions(self):
+        return (self.head_version, *self.versions)
+
     @functools.cached_property
     def versioned_schemas(self) -> dict[IdentifierPythonPath, type[VersionedModel]]:
         altered_schemas = {
             get_cls_pythonpath(instruction.schema): instruction.schema
-            for version in (self.head_version, *self.versions)
+            for version in self._all_versions
             for version_change in version.version_changes
             for instruction in list(version_change.alter_schema_instructions)
         }
 
         migrated_schemas = {
             get_cls_pythonpath(schema): schema
-            for version in self.versions
+            for version in self._all_versions
             for version_change in version.version_changes
             for schema in list(version_change.alter_request_by_schema_instructions.keys())
         }
@@ -365,7 +369,7 @@ class VersionBundle:
     def versioned_enums(self) -> dict[IdentifierPythonPath, type[Enum]]:
         return {
             get_cls_pythonpath(instruction.enum): instruction.enum
-            for version in self.versions
+            for version in self._all_versions
             for version_change in version.version_changes
             for instruction in version_change.alter_enum_instructions
         }
@@ -377,7 +381,7 @@ class VersionBundle:
             # the __init__.py file directly instead of the package itself
             # which results in this extra `.__init__` suffix in the name
             instruction.module.__name__.removesuffix(".__init__"): instruction.module
-            for version in self.versions
+            for version in self._all_versions
             for version_change in version.version_changes
             for instruction in version_change.alter_module_instructions
         }

{cadwyn-3.11.0.dist-info → cadwyn-3.12.0.dist-info}/METADATA

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

{cadwyn-3.11.0.dist-info → cadwyn-3.12.0.dist-info}/RECORD

@@ -4,7 +4,7 @@ cadwyn/_asts.py,sha256=S-x9fVKTENZZxwWfabm0PbztcHyX2MJkI6Cwv5XgVrI,10138
 cadwyn/_compat.py,sha256=6QwtzbXn53mIhEFfEizmFjd-f894oLsM6ITxqq2rCpc,5408
 cadwyn/_package_utils.py,sha256=trxTYLmppv-10SKhScfyDQJh21rsQGFoLaOtHycKKR0,1443
 cadwyn/_utils.py,sha256=BFsfZBpdoL5RMAaT1V1cXJVpTZCmwksQ-Le2MTHivGI,4841
-cadwyn/applications.py,sha256=sz4x_GoD3s1snm3M1Wgx22mdAICQXciVd9rhGWZk0II,12826
+cadwyn/applications.py,sha256=MAVsgYojgQO4PrUETVMAsp49k6baW4h4LtS6z12gTZs,15767
 cadwyn/codegen/README.md,sha256=hc7AE87LsEsvbh-wX1H10JEWh-8bLHoe-1CkY3h00FI,879
 cadwyn/codegen/__init__.py,sha256=JgddDjxMTjSfVrMXHwNu1ODgdn2QfPWpccrRKquBV6k,355
 cadwyn/codegen/_common.py,sha256=FTI4fqpUFGBMACVlPiDMHTWhqwW_-zQNa_4Qh7m-hCA,5877
@@ -20,7 +20,7 @@ cadwyn/main.py,sha256=kt2Vn7TIA4ZnD_xrgz57TOjUk-4zVP8SV8nuTZBEaaU,218
 cadwyn/middleware.py,sha256=8cuBri_yRkl0goe6G0MLwtL04WGbW9Infah3wy9hUVM,3372
 cadwyn/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cadwyn/route_generation.py,sha256=7nHe_IP7Uz1rXmnItJsQ2yIuqe3lRgtOr8_MP_6Vg8c,35704
-cadwyn/routing.py,sha256=nswSMfpGMYk-TSbNY6NmH7NuWM0GoWwK_McTzPiKluk,6392
+cadwyn/routing.py,sha256=s_-PxzDq0GT0pW-JtRLQrcR51tDQfd420oyWBP9S-sg,6158
 cadwyn/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cadwyn/static/docs.html,sha256=WNm5ANJVy51TcIUFOaqKf1Z8eF86CC85TTHPxACtkzw,3455
 cadwyn/structure/__init__.py,sha256=HjaNd6H4m4Cia42-dCO7A7sLWuVII7oldjaCabhbs_o,697
@@ -30,9 +30,9 @@ cadwyn/structure/endpoints.py,sha256=VngfAydGBwekhV2tBOtNDPVgl3X1IgYxUCw--VZ5cQY
 cadwyn/structure/enums.py,sha256=iMokxA2QYJ61SzyB-Pmuq3y7KL7-e6TsnjLVUaVZQnw,954
 cadwyn/structure/modules.py,sha256=1FK-lLm-zOTXEvn-QtyBH38aDRht5PDQiZrOPCsBlM4,1268
 cadwyn/structure/schemas.py,sha256=0ylArAkUw626VkUOJSulOwJs7CS6lrGBRECEG5HFD4Q,8897
-cadwyn/structure/versions.py,sha256=aVmI71vBtMpyu9dT5m732feTJWdKOXNpPZQb80G8y9c,36078
-cadwyn-3.11.0.dist-info/LICENSE,sha256=KeCWewiDQYpmSnzF-p_0YpoWiyDcUPaCuG8OWQs4ig4,1072
-cadwyn-3.11.0.dist-info/METADATA,sha256=6bHtgZeWr378YbnPVUELXHlcyga0DH0UFJbsmK-Nsb8,4360
-cadwyn-3.11.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-cadwyn-3.11.0.dist-info/entry_points.txt,sha256=eO05hLn9GoRzzpwT9GONPmXKsonjuMNssM2D2WHWKGk,46
-cadwyn-3.11.0.dist-info/RECORD,,
+cadwyn/structure/versions.py,sha256=SjrVqwWFIgUQEazaIW8xXjwMhgJSdSNakbAyfHSArwA,36188
+cadwyn-3.12.0.dist-info/LICENSE,sha256=KeCWewiDQYpmSnzF-p_0YpoWiyDcUPaCuG8OWQs4ig4,1072
+cadwyn-3.12.0.dist-info/METADATA,sha256=YWd0MSdFsQe6ZedoasOrtI_8J-RKlRL8TkSylw8XuYk,4360
+cadwyn-3.12.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+cadwyn-3.12.0.dist-info/entry_points.txt,sha256=eO05hLn9GoRzzpwT9GONPmXKsonjuMNssM2D2WHWKGk,46
+cadwyn-3.12.0.dist-info/RECORD,,