cadwyn 5.3.3__tar.gz → 5.4.2__tar.gz

{cadwyn-5.3.3 → cadwyn-5.4.2}/.pre-commit-config.yaml

@@ -1,12 +1,13 @@
 default_language_version:
-  python: python3.10
+  python: python3
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v5.0.0
     hooks:
       - id: check-added-large-files
       - id: check-yaml
-        args: ["--unsafe"]
+        args:
+          - '--unsafe'
       - id: check-toml
       - id: end-of-file-fixer
       - id: trailing-whitespace
@@ -18,27 +19,34 @@ repos:
       - id: python-check-blanket-noqa
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.1
+    rev: v0.11.10
     hooks:
       - id: ruff
-        args: [--fix, --exit-non-zero-on-fix]
+        args:
+          - '--fix'
+          - '--exit-non-zero-on-fix'
       - id: ruff-format
 
   - repo: https://github.com/adamchainz/blacken-docs
-    rev: "1.19.1" # replace with latest tag on GitHub
+    rev: 1.19.1 # replace with latest tag on GitHub
     hooks:
       - id: blacken-docs
         additional_dependencies:
           - black==22.12.0
-        args: ["--line-length=80", "--target-version=py310", "--skip-errors"]
+        args:
+          - '--line-length=80'
+          - '--target-version=py310'
+          - '--skip-errors'
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.43.0
+    rev: v0.44.0
     hooks:
       - id: markdownlint
-        args: ["--disable", "MD013"]
+        args:
+          - '--disable'
+          - MD013
 
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.6.5
+    rev: 0.7.5
     hooks:
       - id: uv-lock

{cadwyn-5.3.3 → cadwyn-5.4.2}/CHANGELOG.md

@@ -5,6 +5,26 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+## [5.4.2]
+
+### Fixed
+
+* Added support for computed fields
+
+## [5.4.1]
+
+### Fixed
+
+* Fixed import error in python 3.9 when using typing_extensions==3.14.0
+
+## [5.4.0]
+
+### Added
+
+- `typing_inspection` dependency from pydantic team for complex isinstance checks that must be the same between `typing` and `typing_extensions`
+- Support for `pydantic>=2.12.0` FieldInfo refactoring from https://github.com/pydantic/pydantic/pull/11898
+
+
 ## [5.3.3]
 
 ### Fixed

{cadwyn-5.3.3 → cadwyn-5.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cadwyn
-Version: 5.3.3
+Version: 5.4.2
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Project-URL: Source code, https://github.com/zmievsa/cadwyn
 Project-URL: Documentation, https://docs.cadwyn.dev
@@ -37,9 +37,10 @@ Requires-Python: >=3.9
 Requires-Dist: backports-strenum<2,>=1.3.1; python_version < '3.11'
 Requires-Dist: fastapi>=0.112.4
 Requires-Dist: jinja2>=3.1.2
-Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic>=2.11.0
 Requires-Dist: starlette>=0.30.0
 Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: standard
 Requires-Dist: fastapi[standard]>=0.112.3; extra == 'standard'
 Requires-Dist: typer>=0.7.0; extra == 'standard'
@@ -71,12 +72,12 @@ Production-ready community-driven modern [Stripe-like](https://stripe.com/blog/a
 
 ## Who is this for?
 
-Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API versioning encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
+Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API backward compatibility encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
 
-Its [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) will be useful if you want to:
+This [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) may be useful if you want to:
 
 1. Support many API versions for a long time
-2. Effortlessly backport features and bugfixes to older API versions
+2. Have features and bugfixes automatically backported to older API versions
 
 Whether you are a newbie in API versioning, a pro looking for a sophisticated tool, an experimenter looking to build a similar framework, or even someone who just wants to learn about all approaches to API versioning -- Cadwyn has the functionality, theory, and documentation to cover all the mentioned use cases.
 
@@ -86,6 +87,4 @@ The [documentation](https://docs.cadwyn.dev) has everything you need to succeed.
 
 ## Sponsors
 
-These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one too!
-
-[![Monite](https://docs.cadwyn.dev/img/sponsor_logos/monite.png)](https://docs.monite.com/)
+These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one, too!

{cadwyn-5.3.3 → cadwyn-5.4.2}/README.md

@@ -24,12 +24,12 @@ Production-ready community-driven modern [Stripe-like](https://stripe.com/blog/a
 
 ## Who is this for?
 
-Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API versioning encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
+Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API backward compatibility encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
 
-Its [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) will be useful if you want to:
+This [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) may be useful if you want to:
 
 1. Support many API versions for a long time
-2. Effortlessly backport features and bugfixes to older API versions
+2. Have features and bugfixes automatically backported to older API versions
 
 Whether you are a newbie in API versioning, a pro looking for a sophisticated tool, an experimenter looking to build a similar framework, or even someone who just wants to learn about all approaches to API versioning -- Cadwyn has the functionality, theory, and documentation to cover all the mentioned use cases.
 
@@ -39,6 +39,4 @@ The [documentation](https://docs.cadwyn.dev) has everything you need to succeed.
 
 ## Sponsors
 
-These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one too!
-
-[![Monite](https://docs.cadwyn.dev/img/sponsor_logos/monite.png)](https://docs.monite.com/)
+These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one, too!

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/__main__.py

@@ -36,7 +36,7 @@ def version_callback(value: bool):
 def output_code(code: str, raw: bool):
     if raw:
         typer.echo(code)
-    else:
+    else:  # pragma: no cover
         _CONSOLE.print(Syntax(code, "python", line_numbers=True))
 
 

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/_asts.py

@@ -22,7 +22,7 @@ NoneType = type(None)
 
 
 # A parent type of typing._GenericAlias
-_BaseGenericAlias = cast(type, 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

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/applications.py

@@ -400,7 +400,7 @@ class Cadwyn(FastAPI):
                 init_oauth=self.swagger_ui_init_oauth,
                 swagger_ui_parameters=self.swagger_ui_parameters,
             )
-        return self._render_docs_dashboard(req, cast(str, self.docs_url))
+        return self._render_docs_dashboard(req, cast("str", self.docs_url))
 
     async def redoc_dashboard(self, req: Request) -> Response:
         version = req.query_params.get("version")
@@ -410,7 +410,7 @@ class Cadwyn(FastAPI):
             openapi_url = root_path + f"{self.openapi_url}?version={version}"
             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))
+        return self._render_docs_dashboard(req, docs_url=cast("str", self.redoc_url))
 
     def _extract_root_path(self, req: Request):
         return req.scope.get("root_path", "").rstrip("/")

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/changelogs.py

@@ -93,7 +93,7 @@ def _generate_changelog(versions: VersionBundle, router: _RootCadwynAPIRouter) -
                     generator_from_newer_version,
                     generator_from_older_version,
                     schemas_from_older_version,
-                    cast(list[APIRoute], routes_from_newer_version),
+                    cast("list[APIRoute]", routes_from_newer_version),
                 )
                 if changelog_entry is not None:  # pragma: no branch # This should never happen
                     version_change_changelog.instructions.append(CadwynVersionChangeInstruction(changelog_entry))
@@ -321,18 +321,18 @@ def _convert_version_change_instruction_to_changelog_entry(  # noqa: C901
     if isinstance(instruction, EndpointDidntExistInstruction):
         return CadwynEndpointWasAddedChangelogEntry(
             path=instruction.endpoint_path,
-            methods=cast(Any, instruction.endpoint_methods),
+            methods=cast("Any", instruction.endpoint_methods),
         )
     elif isinstance(instruction, EndpointExistedInstruction):
         return CadwynEndpointWasRemovedChangelogEntry(
             path=instruction.endpoint_path,
-            methods=cast(Any, instruction.endpoint_methods),
+            methods=cast("Any", instruction.endpoint_methods),
         )
     elif isinstance(instruction, EndpointHadInstruction):
         if instruction.attributes.include_in_schema is not Sentinel:
             return CadwynEndpointWasRemovedChangelogEntry(
                 path=instruction.endpoint_path,
-                methods=cast(Any, instruction.endpoint_methods),
+                methods=cast("Any", instruction.endpoint_methods),
             )
 
         renaming_map = {"operation_id": "operationId"}
@@ -379,7 +379,7 @@ def _convert_version_change_instruction_to_changelog_entry(  # noqa: C901
             attribute_changes.append(CadwynEndpointAttributeChange(name="responses", new_value=changed_responses))
         return CadwynEndpointHadChangelogEntry(
             path=instruction.endpoint_path,
-            methods=cast(Any, instruction.endpoint_methods),
+            methods=cast("Any", instruction.endpoint_methods),
             changes=attribute_changes,
         )
 

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/route_generation.py

@@ -78,7 +78,7 @@ def generate_versioned_routers(
     webhooks: Union[_WR, None] = None,
 ) -> GeneratedRouters[_R, _WR]:
     if webhooks is None:
-        webhooks = cast(_WR, APIRouter())
+        webhooks = cast("_WR", APIRouter())
     return _EndpointTransformer(router, versions, webhooks).transform()
 
 
@@ -167,7 +167,7 @@ class _EndpointTransformer(Generic[_R, _WR]):
 
                 # 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)
+                older_route = cast("APIRoute", older_route)
                 # Wait.. Why do we need this code again?
                 if older_route.body_field is not None and _route_has_a_simple_body_schema(older_route):
                     if hasattr(older_route.body_field.type_, "__cadwyn_original_model__"):

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/schema_generation.py

@@ -11,14 +11,20 @@ from collections.abc import Callable, Sequence
 from datetime import date
 from enum import Enum
 from functools import cache
-from typing import TYPE_CHECKING, Annotated, Generic, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Generic,
+    Union,
+    _BaseGenericAlias,  # pyright: ignore[reportAttributeAccessIssue]
+    cast,
+)
 
 import fastapi.params
 import fastapi.security.base
 import fastapi.utils
 import pydantic
 import pydantic._internal._decorators
-import typing_extensions
 from fastapi import Response
 from fastapi.dependencies.utils import is_async_gen_callable, is_coroutine_callable, is_gen_callable
 from fastapi.routing import APIRoute
@@ -32,12 +38,12 @@ from pydantic._internal._decorators import (
     RootValidatorDecoratorInfo,
     ValidatorDecoratorInfo,
 )
+from pydantic._internal._known_annotated_metadata import collect_known_metadata
 from pydantic._internal._typing_extra import try_eval_type as pydantic_try_eval_type
 from pydantic.fields import ComputedFieldInfo, FieldInfo
 from typing_extensions import (
     Any,
     Doc,
-    NewType,
     Self,
     TypeAlias,
     TypeAliasType,
@@ -80,11 +86,6 @@ if TYPE_CHECKING:
     from cadwyn.structure.versions import HeadVersion, Version, VersionBundle
 
 
-if sys.version_info >= (3, 10):
-    from typing import _BaseGenericAlias  # pyright: ignore[reportAttributeAccessIssue]
-else:
-    from typing_extensions import _BaseGenericAlias  # pyright: ignore[reportAttributeAccessIssue]
-
 _Call = TypeVar("_Call", bound=Callable[..., Any])
 
 _FieldName: TypeAlias = str
@@ -153,16 +154,12 @@ class PydanticFieldWrapper:
         )
 
 
-def _extract_passed_field_attributes(field_info: FieldInfo):
-    attributes = {
-        attr_name: field_info._attributes_set[attr_name]
-        for attr_name in _all_field_arg_names
-        if attr_name in field_info._attributes_set
+def _extract_passed_field_attributes(field_info: FieldInfo) -> dict[str, object]:
+    return {
+        k: v
+        for k, v in (field_info._attributes_set | collect_known_metadata(field_info.metadata)[0]).items()
+        if k in _all_field_arg_names and not (k == "frozen" and v is None)
     }
-    # PydanticV2 always adds frozen to _attributes_set but we don't want it if it wasn't explicitly set
-    if attributes.get("frozen", ...) is None:
-        attributes.pop("frozen")
-    return attributes
 
 
 @dataclasses.dataclass(**DATACLASS_SLOTS)
@@ -239,6 +236,11 @@ def _wrap_validator(func: Callable, is_pydantic_v1_style_validator: Any, decorat
         func = func.__func__
     kwargs = dataclasses.asdict(decorator_info)
     decorator_fields = kwargs.pop("fields", None)
+
+    # wrapped_property is not accepted by computed_field()
+    if isinstance(decorator_info, ComputedFieldInfo):
+        kwargs.pop("wrapped_property", None)
+
     actual_decorator = PYDANTIC_DECORATOR_TYPE_TO_DECORATOR_MAP[type(decorator_info)]
     if is_pydantic_v1_style_validator:
         # There's an inconsistency in their interfaces so we gotta resort to this
@@ -265,7 +267,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapp
     # For example, when "from __future__ import annotations" is used in the file with the schema
     if model is not BaseModel:
         model.model_rebuild(raise_errors=False)
-    model = cast(type[_T_PYDANTIC_MODEL], model)
+    model = cast("type[_T_PYDANTIC_MODEL]", model)
 
     decorators = _get_model_decorators(model)
     validators = {}
@@ -345,7 +347,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapp
 def _get_field_and_validator_names_from_model(cls: type) -> tuple[set[_FieldName], set[str]]:
     fields = cls.model_fields
     source = inspect.getsource(cls)
-    cls_ast = cast(ast.ClassDef, ast.parse(textwrap.dedent(source)).body[0])
+    cls_ast = cast("ast.ClassDef", ast.parse(textwrap.dedent(source)).body[0])
     validator_names = (
         _get_validator_info_or_none(node)
         for node in cls_ast.body
@@ -468,7 +470,7 @@ class _PydanticModelWrapper(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[cast(type[BaseModel], 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
@@ -587,9 +589,11 @@ class _AnnotationTransformer:
         self._remake_endpoint_dependencies(route)
 
     def _change_version_of_a_non_container_annotation(self, annotation: Any) -> Any:
-        if isinstance(annotation, (_BaseGenericAlias, types.GenericAlias)):
+        from typing_inspection.typing_objects import is_any, is_newtype, is_typealiastype
+
+        if isinstance(annotation, (types.GenericAlias, _BaseGenericAlias)):
             return get_origin(annotation)[tuple(self.change_version_of_annotation(arg) for arg in get_args(annotation))]
-        elif isinstance(annotation, TypeAliasType):
+        elif is_typealiastype(annotation):
             if (
                 annotation.__module__ is not None and (annotation.__module__.startswith("pydantic."))
             ) or annotation.__name__ in _PYDANTIC_ALL_EXPORTED_NAMES:
@@ -616,7 +620,7 @@ class _AnnotationTransformer:
             return getitem(
                 tuple(self.change_version_of_annotation(a) for a in get_args(annotation)),
             )
-        elif annotation is typing.Any or annotation is typing_extensions.Any or isinstance(annotation, NewType):
+        elif is_any(annotation) or is_newtype(annotation):
             return annotation
         elif isinstance(annotation, type):
             return self._change_version_of_type(annotation)
@@ -776,7 +780,7 @@ class SchemaGenerator:
         wrapper = self._get_wrapper_for_model(model)
         model_copy = wrapper.generate_model_copy(self)
         self.concrete_models[model] = model_copy
-        return cast(type[_T_ANY_MODEL], model_copy)
+        return cast("type[_T_ANY_MODEL]", model_copy)
 
     @overload
     def _get_wrapper_for_model(self, model: type[BaseModel]) -> "_PydanticModelWrapper[BaseModel]": ...
@@ -865,7 +869,7 @@ def _apply_alter_schema_instructions(
         elif isinstance(alter_schema_instruction, ValidatorExistedInstruction):
             validator_name = get_name_of_function_wrapped_in_pydantic_validator(alter_schema_instruction.validator)
             raw_validator = cast(
-                pydantic._internal._decorators.PydanticDescriptorProxy, alter_schema_instruction.validator
+                "pydantic._internal._decorators.PydanticDescriptorProxy", alter_schema_instruction.validator
             )
             schema_info.validators[validator_name] = _wrap_validator(
                 raw_validator.wrapped,
@@ -1041,15 +1045,19 @@ def _delete_field_attributes(
     annotation: Any,
 ) -> None:
     for attr_name in alter_schema_instruction.attributes:
+        deleted = False
+
         if attr_name in field.passed_field_attributes:
             field.delete_attribute(name=attr_name)
-        elif get_origin(annotation) == Annotated and any(  # pragma: no branch
+            deleted = True
+        if get_origin(annotation) == Annotated and any(  # pragma: no branch
             hasattr(sub_ann, attr_name) for sub_ann in get_args(annotation)
         ):
             for sub_ann in get_args(annotation):
                 if hasattr(sub_ann, attr_name):
                     object.__setattr__(sub_ann, attr_name, None)
-        else:
+                    deleted = True
+        if not deleted:
             raise InvalidGenerationInstructionError(
                 f'You tried to delete the attribute "{attr_name}" of field "{alter_schema_instruction.name}" '
                 f'from "{model.name}" in "{version_change_name}" '
@@ -1058,19 +1066,30 @@ def _delete_field_attributes(
 
 
 def _delete_field_from_model(model: _PydanticModelWrapper, field_name: str, version_change_name: str):
-    if field_name not in model.fields:
+    if field_name in model.fields:
+        model.fields.pop(field_name)
+        model.annotations.pop(field_name)
+        for validator_name, validator in model.validators.copy().items():
+            if isinstance(validator, _PerFieldValidatorWrapper) and field_name in validator.fields:
+                validator.fields.remove(field_name)
+                # TODO: This behavior doesn't feel natural
+                if not validator.fields:
+                    model.validators[validator_name].is_deleted = True
+
+    elif (
+        field_name in model.validators
+        and isinstance(model.validators[field_name], _ValidatorWrapper)
+        and hasattr(model.validators[field_name], "decorator")
+        and model.validators[field_name].decorator == pydantic.computed_field
+    ):
+        validator = model.validators[field_name]
+        model.validators[field_name].is_deleted = True
+        model.annotations.pop(field_name, None)
+    else:
         raise InvalidGenerationInstructionError(
             f'You tried to delete a field "{field_name}" from "{model.name}" '
             f'in "{version_change_name}" but it doesn\'t have such a field.',
         )
-    model.fields.pop(field_name)
-    model.annotations.pop(field_name)
-    for validator_name, validator in model.validators.copy().items():
-        if isinstance(validator, _PerFieldValidatorWrapper) and field_name in validator.fields:
-            validator.fields.remove(field_name)
-            # TODO: This behavior doesn't feel natural
-            if not validator.fields:
-                model.validators[validator_name].is_deleted = True
 
 
 class _DummyEnum(Enum):
@@ -1100,7 +1119,7 @@ class _EnumWrapper(Generic[_T_ENUM]):
         for attr_name, attr in initialization_namespace.items():
             enum_dict[attr_name] = attr
         enum_dict["__doc__"] = self.cls.__doc__
-        model_copy = cast(type[_T_ENUM], type(self.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-5.3.3 → cadwyn-5.4.2}/cadwyn/structure/data.py

@@ -140,7 +140,7 @@ def convert_request_to_next_version_for(
         if isinstance(schema_or_path, str):
             return _AlterRequestByPathInstruction(
                 path=schema_or_path,
-                methods=set(cast(list, methods_or_second_schema)),
+                methods=set(cast("list", methods_or_second_schema)),
                 transformer=transformer,
             )
         else:
@@ -214,7 +214,7 @@ def convert_response_to_previous_version_for(
             # The validation above checks that methods is not None
             return _AlterResponseByPathInstruction(
                 path=schema_or_path,
-                methods=set(cast(list, methods_or_second_schema)),
+                methods=set(cast("list", methods_or_second_schema)),
                 transformer=transformer,
                 migrate_http_errors=migrate_http_errors,
             )

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/structure/schemas.py

@@ -246,7 +246,7 @@ class AlterFieldInstructionFactory:
         info: Union[FieldInfo, Any, None] = None,
     ) -> FieldExistedAsInstruction:
         if info is None:
-            info = cast(FieldInfo, Field())
+            info = cast("FieldInfo", Field())
         info.annotation = type
         return FieldExistedAsInstruction(is_hidden_from_changelog=False, schema=self.schema, name=self.name, field=info)
 
@@ -317,7 +317,7 @@ class AlterSchemaInstructionFactory:
     def validator(
         self, func: "Union[Callable[..., Any], classmethod[Any, Any, Any], PydanticDescriptorProxy]", /
     ) -> AlterValidatorInstructionFactory:
-        func = cast(Union[Callable[..., Any], PydanticDescriptorProxy], unwrap_wrapped_function(func))
+        func = cast("Union[Callable[..., Any], PydanticDescriptorProxy]", unwrap_wrapped_function(func))
 
         if not isinstance(func, PydanticDescriptorProxy):
             if hasattr(func, "__self__"):

{cadwyn-5.3.3 → cadwyn-5.4.2}/cadwyn/structure/versions.py

@@ -620,7 +620,7 @@ class VersionBundle:
                     detail = response_info.body
                 if detail is None:
                     detail = http.HTTPStatus(response_info.status_code).phrase
-                raised_exception.detail = cast(str, detail)
+                raised_exception.detail = cast("str", detail)
                 raised_exception.headers = dict(response_info.headers)
                 raised_exception.status_code = response_info.status_code
 

{cadwyn-5.3.3 → cadwyn-5.4.2}/docs/concepts/version_changes.md

@@ -408,6 +408,31 @@ print(BulkCreateUsersRequestBody is BulkCreateUsersResponseBody)  # False
 
 or to specify migrations using [endpoint path](#path-based-migration-specification) instead of a schema.
 
+## Dependency re-execution warning
+
+Notice that whenever a request comes to Cadwyn, we first validate it against the request's version of the schema, then we migrate it to the latest version, and then validate again to prevent migrations from creating invalid requests.
+
+This means that if you have a dependency that is executed during the request validation, **it will be executed twice**. For example, if you have a dependency that checks whether a user exists in the database, it will be executed twice. This is not a problem if the dependency is idempotent but it is a problem if it is not.
+
+To solve this problem, you can use the `cadwyn.current_dependency_solver` dependency which tell you whether your dependency is getting called before or after the request is migrated. If you want to run it once we migrated the request to the latest version, you should only run it when `current_dependency_solver` is `"cadwyn"`. If you want your dependency to run at the very beginning of handling the request, you should only run it when `current_dependency_solver` is `"fastapi"`.
+
+```python
+from cadwyn import current_dependency_solver
+
+
+def my_dependency(
+    dependency_solver: Annotated[
+        Literal["fastapi", "cadwyn"], Depends(current_dependency_solver)
+    ]
+):
+    if dependency_solver == "fastapi":  # Before migration
+        ...
+    else:  # After migration
+        ...
+```
+
+but the majority of your dependencies will not need this as most dependencies should not have side effects or network calls within them.
+
 ## Version changes with side effects
 
 Sometimes you will use API versioning to handle a breaking change in your **business logic**, not in the schemas themselves. In such cases, it is tempting to add a version check and just follow the new business logic such as:

{cadwyn-5.3.3 → cadwyn-5.4.2}/docs/home/CONTRIBUTING.md

@@ -66,7 +66,7 @@ Then you can serve the documentation with `mkdocs serve`
 
 We welcome contributions that enhance / improve the content of the docs. Feel free to add examples, clarify text, restructure the docs, etc., but make sure to follow these guidelines:
 
-* Write text in idiomatic english, using simple language
+* Write text in idiomatic English, using simple language
 * Opt for [Oxford commas](https://en.wikipedia.org/wiki/Serial_comma) when listing a series of terms
 * Keep examples simple and self contained
 * Provide links where applicable

{cadwyn-5.3.3 → cadwyn-5.4.2}/docs/how_to/change_openapi_schemas/remove_field.md

@@ -83,7 +83,8 @@ Let's say that we had a nullable `middle_name` field but we decided that it does
             schema(BaseUser)
             .field("middle_name")
             .existed_as(
-                type=str | None, description="User's Middle Name", default=None
+                type=str | None,
+                info=Field(description="User's Middle Name", default=None),
             ),
         )
     ```

{cadwyn-5.3.3 → cadwyn-5.4.2}/docs/index.md

@@ -12,7 +12,7 @@ Production-ready community-driven modern [Stripe-like](https://stripe.com/blog/a
     <img src="https://img.shields.io/codecov/c/github/zmievsa/cadwyn?color=%2334D058&logo=codecov" alt="Coverage">
 </a>
 <a href="https://pypi.org/project/cadwyn/" target="_blank">
-    <img alt="PyPI" src="https://img.shields.io/pypi/v/cadwyn?color=%2334D058&logo=pypi&label=PyPI package" alt="Package version">
+    <img alt="PyPI" src="https://img.shields.io/pypi/v/cadwyn?color=%2334D058&logo=pypi&label=PyPI" alt="Package version">
 </a>
 <a href="https://pypi.org/project/cadwyn/" target="_blank">
     <img src="https://img.shields.io/pypi/pyversions/cadwyn?color=%2334D058&logo=python" alt="Supported Python versions">
@@ -24,21 +24,15 @@ Production-ready community-driven modern [Stripe-like](https://stripe.com/blog/a
 
 ## Who is this for?
 
-Cadwyn allows you to support a single version of your code while auto-generating the schemas and routes for older versions. You keep API versioning encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
+Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API backward compatibility encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
 
-Its [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) will be useful if you want to:
+This [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) may be useful if you want to:
 
 1. Support many API versions for a long time
-2. Effortlessly backport features and bugfixes to older API versions
+2. Have features and bugfixes automatically backported to older API versions
 
 Whether you are a newbie in API versioning, a pro looking for a sophisticated tool, an experimenter looking to build a similar framework, or even someone who just wants to learn about all approaches to API versioning -- Cadwyn has the functionality, theory, and documentation to cover all the mentioned use cases.
 
 ## Get started
 
 It is recommended to read the [quickstart tutorial](https://docs.cadwyn.dev/quickstart/setup/) first to get your feet wet with Cadwyn's approach
-
-## Sponsors
-
-These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one too!
-
-[![Monite](./img/sponsor_logos/monite.png)](https://docs.monite.com/)

cadwyn-5.4.2/docs/theory/how_to_build_versioning_framework.md

@@ -0,0 +1,24 @@
+# How to build a versioning framework
+
+## Questions to ask yourself when rating your framework
+
+### How easy is it to create a version?
+
+If it is too easy, it is probably a trap. The framework is probably hiding too much complexity from you and will shoot you in the back later. For example, early on we tried a simple "copy the entire business logic into a separate directory" approach which made it so simple to add new versions. We added too many of them in the end, thus it got hellishly hard to maintain or get rid of these versions.
+
+### How easy is it to delete an old version?
+
+Your framework must be able to let you clean up versions as simply as possible and cheaply whenever you need to. For example, if your framework tries to minimize the amount of code duplication in your repository by having new routes include old routes within them and new business logic inherit from classes from old business logic, then deleting an old version is going to be painful; oftentimes even dangerous as versions can quickly start interacting with each other in all sorts of ways, turning a single small application into a set of interconnected applications.
+
+### How easy is it to see the differences between versions?
+
+The easier it is, the better off our users are.
+
+### What exactly do you need to duplicate to create a new version?
+
+The less we duplicate and maintain by hand, the easier it is to support. However, the less we duplicate, the more chance there is to break the old versions with new releases.
+
+### How easy is it to notice accidental data versioning?
+
+Data versioning is an incredibly big issue when versioning your API.
+So if your framework makes it hard to version data -- it's really good!

{cadwyn-5.3.3 → cadwyn-5.4.2}/docs/theory/literature.md

@@ -1,6 +1,6 @@
 # Literature
 
-During Cadwyn's development, I went through countless resources on API Versioning. The following are the most unique and effective ones I could find.
+During Cadwyn's development, I went through countless resources on API Versioning. The following are the most unique and effective ones I managed to find.
 
 ## Cadwyn-like API Versioning