cadwyn 4.1.0__py3-none-any.whl → 4.2.1__py3-none-any.whl

cadwyn/schema_generation.py

@@ -20,6 +20,7 @@ from typing import (
     final,
     get_args,
     get_origin,
+    overload,
 )
 
 import fastapi.params
@@ -104,6 +105,8 @@ class PydanticFieldWrapper:
     init_model_field: dataclasses.InitVar[FieldInfo]
 
     annotation: Any
+    name_from_newer_version: str
+
     passed_field_attributes: dict[str, Any] = dataclasses.field(init=False)
 
     def __post_init__(self, init_model_field: FieldInfo):
@@ -136,7 +139,7 @@ def _extract_passed_field_attributes(field_info: FieldInfo):
 @dataclasses.dataclass(slots=True)
 class _ModelBundle:
     enums: dict[type[Enum], "_EnumWrapper"]
-    schemas: dict[type[BaseModel], "_PydanticRuntimeModelWrapper"]
+    schemas: dict[type[BaseModel], "_PydanticModelWrapper"]
 
 
 @dataclasses.dataclass(slots=True, kw_only=True)
@@ -222,7 +225,7 @@ def _is_dunder(attr_name: str):
     return attr_name.startswith("__") and attr_name.endswith("__")
 
 
-def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeModelWrapper[_T_PYDANTIC_MODEL]":
+def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapper[_T_PYDANTIC_MODEL]":
     decorators = _get_model_decorators(model)
     validators = {}
     for decorator_wrapper in decorators:
@@ -232,7 +235,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
         wrapped_validator = _wrap_validator(decorator_wrapper.func, decorator_wrapper.shim, decorator_wrapper.info)
         validators[decorator_wrapper.cls_var_name] = wrapped_validator
     fields = {
-        field_name: PydanticFieldWrapper(model.model_fields[field_name], model.__annotations__[field_name])
+        field_name: PydanticFieldWrapper(model.model_fields[field_name], model.__annotations__[field_name], field_name)
         for field_name in model.__annotations__
     }
 
@@ -248,7 +251,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
         "__module__": model.__module__,
         "__qualname__": model.__qualname__,
     }
-    return _PydanticRuntimeModelWrapper(
+    return _PydanticModelWrapper(
         model,
         name=model.__name__,
         doc=model.__doc__,
@@ -261,20 +264,20 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
 
 @final
 @dataclasses.dataclass(slots=True)
-class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
-    cls: type[_T_PYDANTIC_MODEL]
+class _PydanticModelWrapper(Generic[_T_PYDANTIC_MODEL]):
+    cls: type[_T_PYDANTIC_MODEL] = dataclasses.field(repr=False)
     name: str
-    doc: str | None
+    doc: str | None = dataclasses.field(repr=False)
     fields: Annotated[
         dict["_FieldName", PydanticFieldWrapper],
         Doc(
             "Fields that belong to this model, not to its parents. I.e. The ones that were either defined or overriden "
         ),
-    ]
-    validators: dict[str, _PerFieldValidatorWrapper | _ValidatorWrapper]
-    other_attributes: dict[str, Any]
-    annotations: dict[str, Any]
-    _parents: list[Self] | None = dataclasses.field(init=False, default=None)
+    ] = dataclasses.field(repr=False)
+    validators: dict[str, _PerFieldValidatorWrapper | _ValidatorWrapper] = dataclasses.field(repr=False)
+    other_attributes: dict[str, Any] = dataclasses.field(repr=False)
+    annotations: dict[str, Any] = dataclasses.field(repr=False)
+    _parents: list[Self] | None = dataclasses.field(init=False, default=None, repr=False)
 
     def __post_init__(self):
         # This isn't actually supposed to run, it's just a precaution
@@ -291,7 +294,7 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
                 )
 
     def __deepcopy__(self, memo: dict[int, Any]):
-        result = _PydanticRuntimeModelWrapper(
+        result = _PydanticModelWrapper(
             self.cls,
             name=self.name,
             doc=self.doc,
@@ -303,6 +306,9 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
         memo[id(self)] = result
         return result
 
+    def __hash__(self) -> int:
+        return hash(id(self))
+
     def _get_parents(self, schemas: "dict[type, Self]"):
         if self._parents is not None:
             return self._parents
@@ -345,7 +351,7 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
         fields = {name: field.generate_field_copy(generator) for name, field in self.fields.items()}
         model_copy = type(self.cls)(
             self.name,
-            tuple(generator[base] for base in self.cls.__bases__),
+            tuple(generator[cast(type[BaseModel], base)] for base in self.cls.__bases__),
             self.other_attributes
             | per_field_validators
             | root_validators
@@ -599,9 +605,9 @@ class SchemaGenerator:
             for k, wrapper in (self.model_bundle.schemas | self.model_bundle.enums).items()
         }
 
-    def __getitem__(self, model: type, /) -> Any:
+    def __getitem__(self, model: type[_T_ANY_MODEL], /) -> type[_T_ANY_MODEL]:
         if not isinstance(model, type) or not issubclass(model, BaseModel | Enum) or model in (BaseModel, RootModel):
-            return model
+            return model  # pyright: ignore[reportReturnType]
         model = _unwrap_model(model)
 
         if model in self.concrete_models:
@@ -614,9 +620,14 @@ class SchemaGenerator:
         self.concrete_models[model] = model_copy
         return model_copy
 
+    @overload
+    def _get_wrapper_for_model(self, model: type[BaseModel]) -> "_PydanticModelWrapper[BaseModel]": ...
+    @overload
+    def _get_wrapper_for_model(self, model: type[Enum]) -> "_EnumWrapper[Enum]": ...
+
     def _get_wrapper_for_model(
         self, model: type[BaseModel | Enum]
-    ) -> "_PydanticRuntimeModelWrapper[BaseModel] | _EnumWrapper[Enum]":
+    ) -> "_PydanticModelWrapper[BaseModel] | _EnumWrapper[Enum]":
         model = _unwrap_model(model)
 
         if model in self.model_bundle.schemas:
@@ -660,7 +671,7 @@ def _create_model_bundle(versions: "VersionBundle"):
 
 
 def _migrate_classes(context: _RuntimeSchemaGenContext) -> None:
-    for version_change in context.current_version.version_changes:
+    for version_change in context.current_version.changes:
         _apply_alter_schema_instructions(
             context.models.schemas,
             version_change.alter_schema_instructions,
@@ -674,7 +685,7 @@ def _migrate_classes(context: _RuntimeSchemaGenContext) -> None:
 
 
 def _apply_alter_schema_instructions(
-    modified_schemas: dict[type, _PydanticRuntimeModelWrapper],
+    modified_schemas: dict[type, _PydanticModelWrapper],
     alter_schema_instructions: Sequence[AlterSchemaSubInstruction | SchemaHadInstruction],
     version_change_name: str,
 ) -> None:
@@ -747,7 +758,7 @@ def _apply_alter_enum_instructions(
 
 
 def _change_model(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: SchemaHadInstruction,
     version_change_name: str,
 ):
@@ -761,8 +772,8 @@ def _change_model(
 
 
 def _add_field_to_model(
-    model: _PydanticRuntimeModelWrapper,
-    schemas: "dict[type, _PydanticRuntimeModelWrapper]",
+    model: _PydanticModelWrapper,
+    schemas: "dict[type, _PydanticModelWrapper]",
     alter_schema_instruction: FieldExistedAsInstruction,
     version_change_name: str,
 ):
@@ -773,14 +784,16 @@ def _add_field_to_model(
             f'in "{version_change_name}" but there is already a field with that name.',
         )
 
-    field = PydanticFieldWrapper(alter_schema_instruction.field, alter_schema_instruction.field.annotation)
+    field = PydanticFieldWrapper(
+        alter_schema_instruction.field, alter_schema_instruction.field.annotation, alter_schema_instruction.name
+    )
     model.fields[alter_schema_instruction.name] = field
     model.annotations[alter_schema_instruction.name] = alter_schema_instruction.field.annotation
 
 
 def _change_field_in_model(
-    model: _PydanticRuntimeModelWrapper,
-    schemas: "dict[type, _PydanticRuntimeModelWrapper]",
+    model: _PydanticModelWrapper,
+    schemas: "dict[type, _PydanticModelWrapper]",
     alter_schema_instruction: FieldHadInstruction | FieldDidntHaveInstruction,
     version_change_name: str,
 ):
@@ -817,7 +830,7 @@ def _change_field_in_model(
 
 
 def _change_field(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: FieldHadInstruction,
     version_change_name: str,
     defined_annotations: dict[str, Any],
@@ -861,7 +874,7 @@ def _change_field(
 
 
 def _delete_field_attributes(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: FieldDidntHaveInstruction,
     version_change_name: str,
     field: PydanticFieldWrapper,
@@ -884,7 +897,7 @@ def _delete_field_attributes(
             )
 
 
-def _delete_field_from_model(model: _PydanticRuntimeModelWrapper, field_name: str, version_change_name: str):
+def _delete_field_from_model(model: _PydanticModelWrapper, field_name: str, version_change_name: str):
     if field_name not in model.fields:
         raise InvalidGenerationInstructionError(
             f'You tried to delete a field "{field_name}" from "{model.name}" '
@@ -906,10 +919,11 @@ class _DummyEnum(Enum):
 
 @final
 class _EnumWrapper(Generic[_T_ENUM]):
-    __slots__ = "cls", "members"
+    __slots__ = "cls", "members", "name"
 
     def __init__(self, cls: type[_T_ENUM]):
         self.cls = _unwrap_model(cls)
+        self.name = cls.__name__
         self.members = {member.name: member.value for member in cls}
 
     def __deepcopy__(self, memo: Any):
@@ -919,13 +933,13 @@ class _EnumWrapper(Generic[_T_ENUM]):
         return result
 
     def generate_model_copy(self, generator: "SchemaGenerator") -> type[_T_ENUM]:
-        enum_dict = Enum.__prepare__(self.cls.__name__, self.cls.__bases__)
+        enum_dict = Enum.__prepare__(self.name, self.cls.__bases__)
 
         raw_member_map = {k: v.value if isinstance(v, Enum) else v for k, v in self.members.items()}
         initialization_namespace = self._get_initialization_namespace_for_enum(self.cls) | raw_member_map
         for attr_name, attr in initialization_namespace.items():
             enum_dict[attr_name] = attr
-        model_copy = cast(type[_T_ENUM], type(self.cls.__name__, self.cls.__bases__, enum_dict))
+        model_copy = cast(type[_T_ENUM], type(self.name, self.cls.__bases__, enum_dict))
         model_copy.__cadwyn_original_model__ = self.cls  # pyright: ignore[reportAttributeAccessIssue]
         return model_copy
 

cadwyn/structure/common.py

@@ -1,5 +1,6 @@
 import datetime
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import ParamSpec, TypeAlias, TypeVar
 
 from pydantic import BaseModel
@@ -9,3 +10,8 @@ VersionDate = datetime.date
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
 Endpoint: TypeAlias = Callable[_P, _R]
+
+
+@dataclass(slots=True, kw_only=True)
+class _HiddenAttributeMixin:
+    is_hidden_from_changelog: bool = False

cadwyn/structure/endpoints.py

@@ -11,6 +11,7 @@ from starlette.routing import BaseRoute
 from cadwyn.exceptions import LintingError
 
 from .._utils import Sentinel
+from .common import _HiddenAttributeMixin
 
 HTTP_METHODS = {"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"}
 
@@ -44,7 +45,7 @@ class EndpointAttributesPayload:
     response_description: str
     responses: dict[int | str, dict[str, Any]]
     deprecated: bool
-    methods: list[str]
+    methods: set[str]
     operation_id: str
     include_in_schema: bool
     response_class: type[Response]
@@ -55,7 +56,7 @@ class EndpointAttributesPayload:
 
 
 @dataclass(slots=True)
-class EndpointHadInstruction:
+class EndpointHadInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
@@ -63,14 +64,14 @@ class EndpointHadInstruction:
 
 
 @dataclass(slots=True)
-class EndpointExistedInstruction:
+class EndpointExistedInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
 
 
 @dataclass(slots=True)
-class EndpointDidntExistInstruction:
+class EndpointDidntExistInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
@@ -135,7 +136,7 @@ class EndpointInstructionFactory:
                 response_description=response_description,
                 responses=responses,
                 deprecated=deprecated,
-                methods=methods,
+                methods=set(methods) if methods is not Sentinel else Sentinel,
                 operation_id=operation_id,
                 include_in_schema=include_in_schema,
                 response_class=response_class,

cadwyn/structure/enums.py

@@ -3,15 +3,17 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
+from .common import _HiddenAttributeMixin
+
 
 @dataclass(slots=True)
-class EnumHadMembersInstruction:
+class EnumHadMembersInstruction(_HiddenAttributeMixin):
     enum: type[Enum]
     members: Mapping[str, Any]
 
 
 @dataclass(slots=True)
-class EnumDidntHaveMembersInstruction:
+class EnumDidntHaveMembersInstruction(_HiddenAttributeMixin):
     enum: type[Enum]
     members: tuple[str, ...]
 

cadwyn/structure/schemas.py

@@ -10,6 +10,8 @@ from pydantic.fields import FieldInfo
 from cadwyn._utils import Sentinel, fully_unwrap_decorator
 from cadwyn.exceptions import CadwynStructureError
 
+from .common import _HiddenAttributeMixin
+
 if TYPE_CHECKING:
     from pydantic.typing import AbstractSetIntStr, MappingIntStrAny
 
@@ -21,24 +23,21 @@ PossibleFieldAttributes = Literal[
     "title",
     "description",
     "exclude",
-    "include",
     "const",
     "gt",
     "ge",
     "lt",
     "le",
+    "deprecated",
+    "fail_fast",
     "strict",
     "multiple_of",
     "allow_inf_nan",
     "max_digits",
     "decimal_places",
-    "min_items",
-    "max_items",
-    "unique_items",
     "min_length",
     "max_length",
     "allow_mutation",
-    "regex",
     "pattern",
     "discriminator",
     "repr",
@@ -53,8 +52,9 @@ class FieldChanges:
     title: str
     description: str
     exclude: "AbstractSetIntStr | MappingIntStrAny | Any"
-    include: "AbstractSetIntStr | MappingIntStrAny | Any"
     const: bool
+    deprecated: bool
+    fail_fast: bool
     gt: float
     ge: float
     lt: float
@@ -64,20 +64,16 @@ class FieldChanges:
     allow_inf_nan: bool
     max_digits: int
     decimal_places: int
-    min_items: int
-    max_items: int
-    unique_items: bool
     min_length: int
     max_length: int
     allow_mutation: bool
-    regex: str
     pattern: str
     discriminator: str
     repr: bool
 
 
 @dataclass(slots=True)
-class FieldHadInstruction:
+class FieldHadInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     type: type
@@ -86,20 +82,20 @@ class FieldHadInstruction:
 
 
 @dataclass(slots=True)
-class FieldDidntHaveInstruction:
+class FieldDidntHaveInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     attributes: tuple[str, ...]
 
 
 @dataclass(slots=True)
-class FieldDidntExistInstruction:
+class FieldDidntExistInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
 
 
 @dataclass(slots=True)
-class FieldExistedAsInstruction:
+class FieldExistedAsInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     field: FieldInfo
@@ -122,41 +118,25 @@ class AlterFieldInstructionFactory:
         title: str = Sentinel,
         description: str = Sentinel,
         exclude: "AbstractSetIntStr | MappingIntStrAny | Any" = Sentinel,
-        include: "AbstractSetIntStr | MappingIntStrAny | Any" = Sentinel,
         const: bool = Sentinel,
         gt: float = Sentinel,
         ge: float = Sentinel,
         lt: float = Sentinel,
         le: float = Sentinel,
         strict: bool = Sentinel,
+        deprecated: bool = Sentinel,
         multiple_of: float = Sentinel,
         allow_inf_nan: bool = Sentinel,
         max_digits: int = Sentinel,
         decimal_places: int = Sentinel,
-        min_items: int = Sentinel,
-        max_items: int = Sentinel,
-        unique_items: bool = Sentinel,
         min_length: int = Sentinel,
         max_length: int = Sentinel,
         allow_mutation: bool = Sentinel,
-        regex: str = Sentinel,
         pattern: str = Sentinel,
         discriminator: str = Sentinel,
         repr: bool = Sentinel,
+        fail_fast: bool = Sentinel,
     ) -> FieldHadInstruction:
-        if regex is not Sentinel:
-            raise CadwynStructureError("`regex` was removed in Pydantic 2. Use `pattern` instead")
-        if include is not Sentinel:
-            raise CadwynStructureError("`include` was removed in Pydantic 2. Use `exclude` instead")
-        if min_items is not Sentinel:
-            raise CadwynStructureError("`min_items` was removed in Pydantic 2. Use `min_length` instead")
-        if max_items is not Sentinel:
-            raise CadwynStructureError("`max_items` was removed in Pydantic 2. Use `max_length` instead")
-        if unique_items is not Sentinel:
-            raise CadwynStructureError(
-                "`unique_items` was removed in Pydantic 2. Use `Set` type annotation instead"
-                "(this feature is discussed in https://github.com/pydantic/pydantic-core/issues/296)",
-            )
         return FieldHadInstruction(
             schema=self.schema,
             name=self.name,
@@ -169,27 +149,24 @@ class AlterFieldInstructionFactory:
                 title=title,
                 description=description,
                 exclude=exclude,
-                include=include,
                 const=const,
                 gt=gt,
                 ge=ge,
                 lt=lt,
                 le=le,
+                deprecated=deprecated,
                 strict=strict,
                 multiple_of=multiple_of,
                 allow_inf_nan=allow_inf_nan,
                 max_digits=max_digits,
                 decimal_places=decimal_places,
-                min_items=min_items,
-                max_items=max_items,
-                unique_items=unique_items,
                 min_length=min_length,
                 max_length=max_length,
                 allow_mutation=allow_mutation,
-                regex=regex,
                 pattern=pattern,
                 discriminator=discriminator,
                 repr=repr,
+                fail_fast=fail_fast,
             ),
         )
 
@@ -266,7 +243,7 @@ AlterSchemaSubInstruction = (
 
 
 @dataclass(slots=True)
-class SchemaHadInstruction:
+class SchemaHadInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
 

cadwyn/structure/versions.py

@@ -23,7 +23,7 @@ from fastapi.routing import APIRoute, _prepare_response_content
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from starlette._utils import is_async_callable
-from typing_extensions import assert_never
+from typing_extensions import assert_never, deprecated
 
 from cadwyn._utils import classproperty
 from cadwyn.exceptions import (
@@ -64,6 +64,7 @@ IdentifierPythonPath = str
 
 class VersionChange:
     description: ClassVar[str] = Sentinel
+    is_hidden_from_changelog: bool = False
     instructions_to_migrate_to_previous_version: ClassVar[Sequence[PossibleInstructions]] = Sentinel
     alter_schema_instructions: ClassVar[list[AlterSchemaSubInstruction | SchemaHadInstruction]] = Sentinel
     alter_enum_instructions: ClassVar[list[AlterEnumSubInstruction]] = Sentinel
@@ -198,24 +199,29 @@ class VersionChangeWithSideEffects(VersionChange, _abstract=True):
 
 
 class Version:
-    def __init__(self, value: VersionDate | str, *version_changes: type[VersionChange]) -> None:
+    def __init__(self, value: VersionDate | str, *changes: type[VersionChange]) -> None:
         super().__init__()
 
         if isinstance(value, str):
             value = date.fromisoformat(value)
         self.value = value
-        self.version_changes = version_changes
+        self.changes = changes
+
+    @property
+    @deprecated("'version_changes' attribute is deprecated and will be removed in Cadwyn 5.x.x. Use 'changes' instead.")
+    def version_changes(self):  # pragma: no cover
+        return self.changes
 
     def __repr__(self) -> str:
         return f"Version('{self.value}')"
 
 
 class HeadVersion:
-    def __init__(self, *version_changes: type[VersionChange]) -> None:
+    def __init__(self, *changes: type[VersionChange]) -> None:
         super().__init__()
-        self.version_changes = version_changes
+        self.changes = changes
 
-        for version_change in version_changes:
+        for version_change in changes:
             if any(
                 [
                     version_change.alter_request_by_path_instructions,
@@ -228,6 +234,11 @@ class HeadVersion:
                     f"HeadVersion does not support request or response migrations but {version_change} contained one."
                 )
 
+    @property
+    @deprecated("'version_changes' attribute is deprecated and will be removed in Cadwyn 5.x.x. Use 'changes' instead.")
+    def version_changes(self):  # pragma: no cover
+        return self.changes
+
 
 def get_cls_pythonpath(cls: type) -> IdentifierPythonPath:
     return f"{cls.__module__}.{cls.__name__}"
@@ -260,7 +271,7 @@ class VersionBundle:
             )
         if not self.versions:
             raise CadwynStructureError("You must define at least one non-head version in a VersionBundle.")
-        if self.versions[-1].version_changes:
+        if self.versions[-1].changes:
             raise CadwynStructureError(
                 f'The first version "{self.versions[-1].value}" cannot have any version changes. '
                 "Version changes are defined to migrate to/from a previous version so you "
@@ -275,7 +286,7 @@ class VersionBundle:
                     f"You tried to define two versions with the same value in the same "
                     f"{VersionBundle.__name__}: '{version.value}'.",
                 )
-            for version_change in version.version_changes:
+            for version_change in version.changes:
                 if version_change._bound_version_bundle is not None:
                     raise CadwynStructureError(
                         f"You tried to bind version change '{version_change.__name__}' to two different versions. "
@@ -295,14 +306,14 @@ class VersionBundle:
         altered_schemas = {
             get_cls_pythonpath(instruction.schema): instruction.schema
             for version in self._all_versions
-            for version_change in version.version_changes
+            for version_change in version.changes
             for instruction in list(version_change.alter_schema_instructions)
         }
 
         migrated_schemas = {
             get_cls_pythonpath(schema): schema
             for version in self._all_versions
-            for version_change in version.version_changes
+            for version_change in version.changes
             for schema in list(version_change.alter_request_by_schema_instructions.keys())
         }
 
@@ -313,7 +324,7 @@ class VersionBundle:
         return {
             get_cls_pythonpath(instruction.enum): instruction.enum
             for version in self._all_versions
-            for version_change in version.version_changes
+            for version_change in version.changes
             for instruction in version_change.alter_enum_instructions
         }
 
@@ -327,9 +338,7 @@ class VersionBundle:
     def _version_changes_to_version_mapping(
         self,
     ) -> dict[type[VersionChange] | type[VersionChangeWithSideEffects], VersionDate]:
-        return {
-            version_change: version.value for version in self.versions for version_change in version.version_changes
-        }
+        return {version_change: version.value for version in self.versions for version_change in version.changes}
 
     async def _migrate_request(
         self,
@@ -347,7 +356,7 @@ class VersionBundle:
         for v in reversed(self.versions):
             if v.value <= current_version:
                 continue
-            for version_change in v.version_changes:
+            for version_change in v.changes:
                 if body_type is not None and body_type in version_change.alter_request_by_schema_instructions:
                     for instruction in version_change.alter_request_by_schema_instructions[body_type]:
                         instruction(request_info)
@@ -394,7 +403,7 @@ class VersionBundle:
         for v in self.versions:
             if v.value <= current_version:
                 break
-            for version_change in v.version_changes:
+            for version_change in v.changes:
                 migrations_to_apply: list[_BaseAlterResponseInstruction] = []
 
                 if head_response_model and head_response_model in version_change.alter_response_by_schema_instructions:

{cadwyn-4.1.0.dist-info → cadwyn-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 4.1.0
+Version: 4.2.1
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Home-page: https://github.com/zmievsa/cadwyn
 License: MIT
@@ -32,6 +32,7 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: cli
+Requires-Dist: backports-strenum (>=1.3.1,<2.0.0) ; python_version < "3.11"
 Requires-Dist: fastapi (>=0.110.0)
 Requires-Dist: issubclass (>=0.1.2,<0.2.0)
 Requires-Dist: jinja2 (>=3.1.2)