cadwyn 3.12.1__tar.gz → 3.13.0__tar.gz

{cadwyn-3.12.1 → cadwyn-3.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 3.12.1
+Version: 3.13.0
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Home-page: https://github.com/zmievsa/cadwyn
 License: MIT
@@ -34,6 +34,7 @@ Classifier: Typing :: Typed
 Provides-Extra: cli
 Requires-Dist: better-ast-comments (>=1.2.1,<1.3.0)
 Requires-Dist: fastapi (>=0.110.0)
+Requires-Dist: issubclass (>=0.1.2,<0.2.0)
 Requires-Dist: jinja2 (>=3.1.2)
 Requires-Dist: pydantic (>=1.0.0)
 Requires-Dist: starlette (>=0.36.3)

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/_asts.py

@@ -10,6 +10,7 @@ from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
     List,
+    cast,
     get_args,
     get_origin,
 )
@@ -32,7 +33,7 @@ _RE_CAMEL_TO_SNAKE = re.compile(r"(?<!^)(?=[A-Z])")
 
 
 # A parent type of typing._GenericAlias
-_BaseGenericAlias = type(List[int]).mro()[1]  # noqa: UP006
+_BaseGenericAlias = cast(type, type(List[int])).mro()[1]  # noqa: UP006
 
 # type(list[int]) and type(List[int]) are different which is why we have to do this.
 # Please note that this problem is much wider than just lists which is why we use typing._BaseGenericAlias
@@ -134,7 +135,7 @@ def transform_auto(_: auto) -> Any:
     return PlainRepr("auto()")
 
 
-def transform_union(value: UnionType) -> Any:  # pyright: ignore[reportInvalidTypeForm]
+def transform_union(value: UnionType) -> Any:
     return "typing.Union[" + (", ".join(get_fancy_repr(a) for a in get_args(value))) + "]"
 
 

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/_compat.py

@@ -61,7 +61,7 @@ class PydanticFieldWrapper:
 
     annotation: Any
 
-    init_model_field: dataclasses.InitVar[ModelField]  # pyright: ignore[reportInvalidTypeForm]
+    init_model_field: dataclasses.InitVar[ModelField]
     field_info: FieldInfo = dataclasses.field(init=False)
 
     annotation_ast: ast.expr | None = None
@@ -69,7 +69,7 @@ class PydanticFieldWrapper:
     # the value_ast is "None" and "Field(default=None)" respectively
     value_ast: ast.expr | None = None
 
-    def __post_init__(self, init_model_field: ModelField):  # pyright: ignore[reportInvalidTypeForm]
+    def __post_init__(self, init_model_field: ModelField):
         if isinstance(init_model_field, FieldInfo):
             self.field_info = init_model_field
         else:
@@ -111,6 +111,13 @@ class PydanticFieldWrapper:
             return attributes | extras
 
 
+def get_annotation_from_model_field(model: ModelField) -> Any:
+    if PYDANTIC_V2:
+        return model.field_info.annotation
+    else:
+        return model.annotation
+
+
 def model_fields(model: type[BaseModel]) -> dict[str, FieldInfo]:
     if PYDANTIC_V2:
         return model.model_fields

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/exceptions.py

@@ -46,6 +46,18 @@ class RouterPathParamsModifiedError(RouterGenerationError):
     pass
 
 
+class RouteResponseBySchemaConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
+class RouteRequestBySchemaConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
+class RouteByPathConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
 class RouteAlreadyExistsError(RouterGenerationError):
     def __init__(self, *routes: APIRoute):
         self.routes = routes

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/route_generation.py

@@ -15,7 +15,6 @@ from typing import (
     Annotated,
     Any,
     Generic,
-    TypeAlias,
     TypeVar,
     _BaseGenericAlias,  # pyright: ignore[reportAttributeAccessIssue]
     cast,
@@ -29,6 +28,7 @@ import fastapi.params
 import fastapi.routing
 import fastapi.security.base
 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
@@ -39,6 +39,7 @@ from fastapi.dependencies.utils import (
 )
 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,
@@ -46,12 +47,15 @@ from starlette.routing import (
 )
 from typing_extensions import Self, assert_never, deprecated
 
-from cadwyn._compat import model_fields, rebuild_fastapi_body_param
+from cadwyn._compat import get_annotation_from_model_field, model_fields, rebuild_fastapi_body_param
 from cadwyn._package_utils import get_version_dir_path
 from cadwyn._utils import Sentinel, UnionType, get_another_version_of_cls
 from cadwyn.exceptions import (
     CadwynError,
     RouteAlreadyExistsError,
+    RouteByPathConverterDoesNotApplyToAnythingError,
+    RouteRequestBySchemaConverterDoesNotApplyToAnythingError,
+    RouteResponseBySchemaConverterDoesNotApplyToAnythingError,
     RouterGenerationError,
     RouterPathParamsModifiedError,
 )
@@ -68,8 +72,6 @@ _T = TypeVar("_T", 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"
-_EndpointPath: TypeAlias = str
-_EndpointMethod: TypeAlias = str
 
 
 @dataclass(slots=True, frozen=True, eq=True)
@@ -78,13 +80,6 @@ class _EndpointInfo:
     endpoint_methods: frozenset[str]
 
 
-@dataclass(slots=True)
-class _RouterInfo(Generic[_R]):
-    router: _R
-    routes_with_migrated_requests: dict[_EndpointPath, set[_EndpointMethod]]
-    route_bodies_with_migrated_requests: set[type[BaseModel]]
-
-
 @deprecated("It will soon be deleted. Use HeadVersion version changes instead.")
 class InternalRepresentationOf:
     def __class_getitem__(cls, original_schema: type, /) -> type[Self]:
@@ -161,22 +156,15 @@ class _EndpointTransformer(Generic[_R]):
             self.parent_router
         )
         router = deepcopy(self.parent_router)
-        router_infos: dict[VersionDate, _RouterInfo] = {}
-        routes_with_migrated_requests = {}
-        route_bodies_with_migrated_requests: set[type[BaseModel]] = set()
+        routers: dict[VersionDate, _R] = {}
+
         for version in self.versions:
             self.annotation_transformer.migrate_router_to_version(router, version)
 
-            router_infos[version.value] = _RouterInfo(
-                router,
-                routes_with_migrated_requests,
-                route_bodies_with_migrated_requests,
-            )
+            self._validate_all_data_converters_are_applied(router, version)
+
+            routers[version.value] = router
             # Applying changes for the next version
-            routes_with_migrated_requests = _get_migrated_routes_by_path(version)
-            route_bodies_with_migrated_requests = {
-                schema for change in version.version_changes for schema in change.alter_request_by_schema_instructions
-            }
             router = deepcopy(router)
             self._apply_endpoint_changes_to_router(router, version)
 
@@ -194,21 +182,21 @@ class _EndpointTransformer(Generic[_R]):
                 continue
             _add_request_and_response_params(head_route)
             copy_of_dependant = deepcopy(head_route.dependant)
-            # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
-            if len(copy_of_dependant.body_params) == 1:
+
+            if _route_has_a_simple_body_schema(head_route):
                 self._replace_internal_representation_with_the_versioned_schema(
                     copy_of_dependant,
                     schema_to_internal_request_body_representation,
                 )
 
-            for older_router_info in list(router_infos.values()):
-                older_route = older_router_info.router.routes[route_index]
+            for older_router in list(routers.values()):
+                older_route = older_router.routes[route_index]
 
                 # We know they are APIRoutes because of the check at the very beginning of the top loop.
                 # I.e. Because head_route is an APIRoute, both routes are  APIRoutes too
                 older_route = cast(APIRoute, older_route)
                 # Wait.. Why do we need this code again?
-                if older_route.body_field is not None and len(older_route.dependant.body_params) == 1:
+                if older_route.body_field is not None and _route_has_a_simple_body_schema(older_route):
                     template_older_body_model = self.annotation_transformer._change_version_of_annotations(
                         older_route.body_field.type_,
                         self.annotation_transformer.head_version_dir,
@@ -224,13 +212,99 @@ class _EndpointTransformer(Generic[_R]):
                     copy_of_dependant,
                     self.versions,
                 )
-        for _, router_info in router_infos.items():
-            router_info.router.routes = [
+        for _, router in routers.items():
+            router.routes = [
                 route
-                for route in router_info.router.routes
+                for route in router.routes
                 if not (isinstance(route, fastapi.routing.APIRoute) and _DELETED_ROUTE_TAG in route.tags)
             ]
-        return {version: router_info.router for version, router_info in router_infos.items()}
+        return routers
+
+    def _validate_all_data_converters_are_applied(self, router: APIRouter, version: Version):
+        path_to_route_methods_mapping, head_response_models, head_request_bodies = self._extract_all_routes_identifiers(
+            router
+        )
+
+        for version_change in version.version_changes:
+            for by_path_converters in [
+                *version_change.alter_response_by_path_instructions.values(),
+                *version_change.alter_request_by_path_instructions.values(),
+            ]:
+                for by_path_converter in by_path_converters:
+                    missing_methods = by_path_converter.methods.difference(
+                        path_to_route_methods_mapping[by_path_converter.path]
+                    )
+
+                    if missing_methods:
+                        raise RouteByPathConverterDoesNotApplyToAnythingError(
+                            f"{by_path_converter.repr_name} "
+                            f'"{version_change.__name__}.{by_path_converter.transformer.__name__}" '
+                            f"failed to find routes with the following methods: {list(missing_methods)}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                            "Please, check whether the path and methods are correct. (hint: path must include "
+                            "all path variables and have a name that was used in the version that this "
+                            "VersionChange resides in)"
+                        )
+
+            for by_schema_converters in version_change.alter_request_by_schema_instructions.values():
+                for by_schema_converter in by_schema_converters:
+                    missing_models = set(by_schema_converter.schemas) - head_request_bodies
+                    if missing_models:
+                        raise RouteRequestBySchemaConverterDoesNotApplyToAnythingError(
+                            f"Request by body schema converter "
+                            f'"{version_change.__name__}.{by_schema_converter.transformer.__name__}" '
+                            f"failed to find routes with the following body schemas: "
+                            f"{[m.__name__ for m in missing_models]}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                        )
+            for by_schema_converters in version_change.alter_response_by_schema_instructions.values():
+                for by_schema_converter in by_schema_converters:
+                    missing_models = set(by_schema_converter.schemas) - head_response_models
+                    if missing_models:
+                        raise RouteResponseBySchemaConverterDoesNotApplyToAnythingError(
+                            f"Response by response model converter "
+                            f'"{version_change.__name__}.{by_schema_converter.transformer.__name__}" '
+                            f"failed to find routes with the following response models: "
+                            f"{[m.__name__ for m in missing_models]}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                        )
+
+    def _extract_all_routes_identifiers(
+        self, router: APIRouter
+    ) -> tuple[defaultdict[str, set[str]], set[Any], set[Any]]:
+        response_models: set[Any] = set()
+        request_bodies: set[Any] = set()
+        path_to_route_methods_mapping: dict[str, set[str]] = defaultdict(set)
+
+        for route in router.routes:
+            if isinstance(route, APIRoute):
+                if route.response_model is not None and lenient_issubclass(route.response_model, BaseModel):
+                    # FIXME: This is going to fail on Pydantic 1
+                    response_models.add(route.response_model)
+                    # Not sure if it can ever be None when it's a simple schema. Eh, I would rather be safe than sorry
+                if _route_has_a_simple_body_schema(route) and route.body_field is not None:
+                    annotation = get_annotation_from_model_field(route.body_field)
+                    if lenient_issubclass(annotation, BaseModel):
+                        # FIXME: This is going to fail on Pydantic 1
+                        request_bodies.add(annotation)
+                path_to_route_methods_mapping[route.path] |= route.methods
+
+        head_response_models = {
+            self.annotation_transformer._change_version_of_annotations(
+                model,
+                self.versions.versioned_directories_with_head[0],
+            )
+            for model in response_models
+        }
+        head_request_bodies = {
+            self.annotation_transformer._change_version_of_annotations(
+                body,
+                self.versions.versioned_directories_with_head[0],
+            )
+            for body in request_bodies
+        }
+
+        return path_to_route_methods_mapping, head_response_models, head_request_bodies
 
     def _replace_internal_representation_with_the_versioned_schema(
         self,
@@ -422,8 +496,8 @@ class _AnnotationTransformer:
         self.versions = versions
         self.versions.head_schemas_package = head_schemas_package
         self.head_schemas_package = head_schemas_package
-        self.head_version_dir = min(versions.versioned_directories)  # "head" < "v0000_00_00"
-        self.latest_version_dir = max(versions.versioned_directories)  # "v2005_11_11" > "v2000_11_11"
+        self.head_version_dir = min(versions.versioned_directories_with_head)  # "head" < "v0000_00_00"
+        self.latest_version_dir = max(versions.versioned_directories_with_head)  # "v2005_11_11" > "v2000_11_11"
 
         # This cache is not here for speeding things up. It's for preventing the creation of copies of the same object
         # because such copies could produce weird behaviors at runtime, especially if you/fastapi do any comparisons.
@@ -537,7 +611,7 @@ class _AnnotationTransformer:
                     )
                 else:
                     self._validate_source_file_is_located_in_template_dir(annotation, source_file)
-            return get_another_version_of_cls(annotation, version_dir, self.versions.versioned_directories)
+            return get_another_version_of_cls(annotation, version_dir, self.versions.versioned_directories_with_head)
         else:
             return annotation
 
@@ -550,7 +624,7 @@ class _AnnotationTransformer:
         if (
             source_file.startswith(dir_with_versions)
             and not source_file.startswith(template_dir)
-            and any(source_file.startswith(str(d)) for d in self.versions.versioned_directories)
+            and any(source_file.startswith(str(d)) for d in self.versions.versioned_directories_with_head)
         ):
             raise RouterGenerationError(
                 f'"{annotation}" is not defined in "{self.head_version_dir}" even though it must be. '
@@ -725,18 +799,6 @@ def _get_route_from_func(
     return None
 
 
-def _get_migrated_routes_by_path(version: Version) -> dict[_EndpointPath, set[_EndpointMethod]]:
-    request_by_path_migration_instructions = [
-        version_change.alter_request_by_path_instructions for version_change in version.version_changes
-    ]
-    migrated_routes = defaultdict(set)
-    for instruction_dict in request_by_path_migration_instructions:
-        for path, instruction_list in instruction_dict.items():
-            for instruction in instruction_list:
-                migrated_routes[path] |= instruction.methods
-    return migrated_routes
-
-
 def _copy_function(function: _T) -> _T:
     while hasattr(function, "__alt_wrapped__"):
         function = function.__alt_wrapped__
@@ -768,3 +830,8 @@ def _copy_function(function: _T) -> _T:
     del annotation_modifying_wrapper.__wrapped__
 
     return cast(_T, annotation_modifying_wrapper)
+
+
+def _route_has_a_simple_body_schema(route: APIRoute) -> bool:
+    # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
+    return len(route.dependant.body_params) == 1

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/structure/data.py

@@ -8,6 +8,7 @@ from fastapi import Request, Response
 from starlette.datastructures import MutableHeaders
 
 from cadwyn._utils import same_definition_as_in
+from cadwyn.structure.endpoints import _validate_that_strings_are_valid_http_methods
 
 _P = ParamSpec("_P")
 
@@ -96,14 +97,15 @@ class _BaseAlterRequestInstruction(_AlterDataInstruction):
 
 
 @dataclass
-class AlterRequestBySchemaInstruction(_BaseAlterRequestInstruction):
+class _AlterRequestBySchemaInstruction(_BaseAlterRequestInstruction):
     schemas: tuple[Any, ...]
 
 
 @dataclass
-class AlterRequestByPathInstruction(_BaseAlterRequestInstruction):
+class _AlterRequestByPathInstruction(_BaseAlterRequestInstruction):
     path: str
     methods: set[str]
+    repr_name = "Request by path converter"
 
 
 @overload
@@ -126,7 +128,7 @@ def convert_request_to_next_version_for(
 
     def decorator(transformer: Callable[[RequestInfo], None]) -> Any:
         if isinstance(schema_or_path, str):
-            return AlterRequestByPathInstruction(
+            return _AlterRequestByPathInstruction(
                 path=schema_or_path,
                 methods=set(cast(list, methods_or_second_schema)),
                 transformer=transformer,
@@ -136,7 +138,7 @@ def convert_request_to_next_version_for(
                 schemas = (schema_or_path,)
             else:
                 schemas = (schema_or_path, methods_or_second_schema, *additional_schemas)
-            return AlterRequestBySchemaInstruction(
+            return _AlterRequestBySchemaInstruction(
                 schemas=schemas,
                 transformer=transformer,
             )
@@ -156,14 +158,15 @@ class _BaseAlterResponseInstruction(_AlterDataInstruction):
 
 
 @dataclass
-class AlterResponseBySchemaInstruction(_BaseAlterResponseInstruction):
+class _AlterResponseBySchemaInstruction(_BaseAlterResponseInstruction):
     schemas: tuple[Any, ...]
 
 
 @dataclass
-class AlterResponseByPathInstruction(_BaseAlterResponseInstruction):
+class _AlterResponseByPathInstruction(_BaseAlterResponseInstruction):
     path: str
     methods: set[str]
+    repr_name = "Response by path converter"
 
 
 @overload
@@ -197,7 +200,7 @@ def convert_response_to_previous_version_for(
     def decorator(transformer: Callable[[ResponseInfo], None]) -> Any:
         if isinstance(schema_or_path, str):
             # The validation above checks that methods is not None
-            return AlterResponseByPathInstruction(
+            return _AlterResponseByPathInstruction(
                 path=schema_or_path,
                 methods=set(cast(list, methods_or_second_schema)),
                 transformer=transformer,
@@ -208,7 +211,7 @@ def convert_response_to_previous_version_for(
                 schemas = (schema_or_path,)
             else:
                 schemas = (schema_or_path, methods_or_second_schema, *additional_schemas)
-            return AlterResponseBySchemaInstruction(
+            return _AlterResponseBySchemaInstruction(
                 schemas=schemas,
                 transformer=transformer,
                 migrate_http_errors=migrate_http_errors,
@@ -219,10 +222,11 @@ def convert_response_to_previous_version_for(
 
 def _validate_decorator_args(
     schema_or_path: type | str, methods_or_second_schema: list[str] | type | None, additional_schemas: tuple[type, ...]
-):
+) -> None:
     if isinstance(schema_or_path, str):
         if not isinstance(methods_or_second_schema, list):
             raise TypeError("If path was provided as a first argument, methods must be provided as a second argument")
+        _validate_that_strings_are_valid_http_methods(methods_or_second_schema)
         if additional_schemas:
             raise TypeError("If path was provided as a first argument, then additional schemas cannot be added")
 

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/structure/endpoints.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Collection, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
@@ -148,6 +148,12 @@ class EndpointInstructionFactory:
 
 
 def endpoint(path: str, methods: list[str], /, *, func_name: str | None = None) -> EndpointInstructionFactory:
+    _validate_that_strings_are_valid_http_methods(methods)
+
+    return EndpointInstructionFactory(path, set(methods), func_name)
+
+
+def _validate_that_strings_are_valid_http_methods(methods: Collection[str]):
     invalid_methods = set(methods) - HTTP_METHODS
     if invalid_methods:
         invalid_methods = ", ".join(sorted(invalid_methods))
@@ -156,7 +162,5 @@ def endpoint(path: str, methods: list[str], /, *, func_name: str | None = None)
             "Please use valid HTTP methods such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.",
         )
 
-    return EndpointInstructionFactory(path, set(methods), func_name)
-
 
 AlterEndpointSubInstruction = EndpointDidntExistInstruction | EndpointExistedInstruction | EndpointHadInstruction

{cadwyn-3.12.1 → cadwyn-3.13.0}/cadwyn/structure/versions.py

@@ -39,12 +39,12 @@ from cadwyn.exceptions import CadwynError, CadwynHeadRequestValidationError, Cad
 from .._utils import Sentinel
 from .common import Endpoint, VersionDate, VersionedModel
 from .data import (
-    AlterRequestByPathInstruction,
-    AlterRequestBySchemaInstruction,
-    AlterResponseByPathInstruction,
-    AlterResponseBySchemaInstruction,
     RequestInfo,
     ResponseInfo,
+    _AlterRequestByPathInstruction,
+    _AlterRequestBySchemaInstruction,
+    _AlterResponseByPathInstruction,
+    _AlterResponseBySchemaInstruction,
     _BaseAlterResponseInstruction,
 )
 from .endpoints import AlterEndpointSubInstruction
@@ -74,12 +74,12 @@ class VersionChange:
     alter_enum_instructions: ClassVar[list[AlterEnumSubInstruction]] = Sentinel
     alter_module_instructions: ClassVar[list[AlterModuleInstruction]] = Sentinel
     alter_endpoint_instructions: ClassVar[list[AlterEndpointSubInstruction]] = Sentinel
-    alter_request_by_schema_instructions: ClassVar[dict[type[BaseModel], list[AlterRequestBySchemaInstruction]]] = (
+    alter_request_by_schema_instructions: ClassVar[dict[type[BaseModel], list[_AlterRequestBySchemaInstruction]]] = (
         Sentinel
     )
-    alter_request_by_path_instructions: ClassVar[dict[str, list[AlterRequestByPathInstruction]]] = Sentinel
-    alter_response_by_schema_instructions: ClassVar[dict[type, list[AlterResponseBySchemaInstruction]]] = Sentinel
-    alter_response_by_path_instructions: ClassVar[dict[str, list[AlterResponseByPathInstruction]]] = Sentinel
+    alter_request_by_path_instructions: ClassVar[dict[str, list[_AlterRequestByPathInstruction]]] = Sentinel
+    alter_response_by_schema_instructions: ClassVar[dict[type, list[_AlterResponseBySchemaInstruction]]] = Sentinel
+    alter_response_by_path_instructions: ClassVar[dict[str, list[_AlterResponseByPathInstruction]]] = Sentinel
     _bound_version_bundle: "VersionBundle | None"
 
     def __init_subclass__(cls, _abstract: bool = False) -> None:
@@ -96,15 +96,15 @@ class VersionChange:
     @classmethod
     def _extract_body_instructions_into_correct_containers(cls):
         for instruction in cls.__dict__.values():
-            if isinstance(instruction, AlterRequestBySchemaInstruction):
+            if isinstance(instruction, _AlterRequestBySchemaInstruction):
                 for schema in instruction.schemas:
                     cls.alter_request_by_schema_instructions[schema].append(instruction)
-            elif isinstance(instruction, AlterRequestByPathInstruction):
+            elif isinstance(instruction, _AlterRequestByPathInstruction):
                 cls.alter_request_by_path_instructions[instruction.path].append(instruction)
-            elif isinstance(instruction, AlterResponseBySchemaInstruction):
+            elif isinstance(instruction, _AlterResponseBySchemaInstruction):
                 for schema in instruction.schemas:
                     cls.alter_response_by_schema_instructions[schema].append(instruction)
-            elif isinstance(instruction, AlterResponseByPathInstruction):
+            elif isinstance(instruction, _AlterResponseByPathInstruction):
                 cls.alter_response_by_path_instructions[instruction.path].append(instruction)
 
     @classmethod
@@ -154,10 +154,10 @@ class VersionChange:
         for attr_name, attr_value in cls.__dict__.items():
             if not isinstance(
                 attr_value,
-                AlterRequestBySchemaInstruction
-                | AlterRequestByPathInstruction
-                | AlterResponseBySchemaInstruction
-                | AlterResponseByPathInstruction,
+                _AlterRequestBySchemaInstruction
+                | _AlterRequestByPathInstruction
+                | _AlterResponseBySchemaInstruction
+                | _AlterResponseByPathInstruction,
             ) and attr_name not in {
                 "description",
                 "side_effects",
@@ -385,7 +385,7 @@ class VersionBundle:
         }
 
     @functools.cached_property
-    def versioned_directories(self) -> tuple[Path, ...]:
+    def versioned_directories_with_head(self) -> tuple[Path, ...]:
         if self.head_schemas_package is None:
             raise CadwynError(
                 f"You cannot call 'VersionBundle.{self.migrate_response_body.__name__}' because it has no access to "
@@ -397,6 +397,10 @@ class VersionBundle:
             + [get_version_dir_path(self.head_schemas_package, version.value) for version in self]
         )
 
+    @functools.cached_property
+    def versioned_directories_without_head(self) -> tuple[Path, ...]:
+        return self.versioned_directories_with_head[1:]
+
     def migrate_response_body(self, latest_response_model: type[BaseModel], *, latest_body: Any, version: VersionDate):
         """Convert the data to a specific version by applying all version changes from latest until that version
         in reverse order and wrapping the result in the correct version of latest_response_model.
@@ -411,11 +415,10 @@ class VersionBundle:
         )
 
         version = self._get_closest_lesser_version(version)
-        # + 1 comes from latest also being in the versioned_directories list
-        version_dir = self.versioned_directories[self.version_dates.index(version) + 1]
+        version_dir = self.versioned_directories_without_head[self.version_dates.index(version)]
 
         versioned_response_model: type[BaseModel] = get_another_version_of_cls(
-            latest_response_model, version_dir, self.versioned_directories
+            latest_response_model, version_dir, self.versioned_directories_with_head
         )
         return versioned_response_model.parse_obj(migrated_response.body)
 
@@ -455,7 +458,7 @@ class VersionBundle:
                         instruction(request_info)
                 if path in version_change.alter_request_by_path_instructions:
                     for instruction in version_change.alter_request_by_path_instructions[path]:
-                        if method in instruction.methods:
+                        if method in instruction.methods:  # pragma: no branch # safe branch to skip
                             instruction(request_info)
         request.scope["headers"] = tuple((key.encode(), value.encode()) for key, value in request_info.headers.items())
         del request._headers
@@ -507,7 +510,7 @@ class VersionBundle:
 
                 if path in version_change.alter_response_by_path_instructions:
                     for instruction in version_change.alter_response_by_path_instructions[path]:
-                        if method in instruction.methods:
+                        if method in instruction.methods:  # pragma: no branch # Safe branch to skip
                             migrations_to_apply.append(instruction)
 
                 for migration in migrations_to_apply:
@@ -723,7 +726,7 @@ class VersionBundle:
             and body_field_alias in kwargs
         ):
             raw_body: BaseModel | None = kwargs.get(body_field_alias)
-            if raw_body is None:
+            if raw_body is None:  # pragma: no cover # This is likely an impossible case but we would like to be safe
                 body = None
             # It means we have a dict or a list instead of a full model.
             # This covers the following use case in the endpoint definition: "payload: dict = Body(None)"

{cadwyn-3.12.1 → cadwyn-3.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cadwyn"
-version = "3.12.1"
+version = "3.13.0"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = ["Stanislav Zmiev <zmievsa@gmail.com>"]
 license = "MIT"
@@ -58,6 +58,7 @@ pydantic = ">=1.0.0"
 typer = {version = ">=0.7.0", optional = true}
 better-ast-comments = "~1.2.1"
 jinja2 = ">=3.1.2"
+issubclass = "^0.1.2"
 
 [tool.poetry.extras]
 cli = ["typer"]
@@ -81,10 +82,6 @@ pytest-sugar = "^1.0.0"
 [tool.poetry.scripts]
 cadwyn = "cadwyn.__main__:app"
 
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-
 [tool.coverage.report]
 skip_covered = true
 skip_empty = true
@@ -130,6 +127,7 @@ reportUnnecessaryTypeIgnoreComment = true
 reportMissingSuperCall = true
 reportFunctionMemberAccess = false
 reportCircularImports = true
+reportInvalidTypeForm = false
 
 
 [build-system]