cadwyn 3.12.0__tar.gz → 3.13.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 3.12.0
+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.0 → cadwyn-3.13.0}/cadwyn/__main__.py

@@ -115,8 +115,7 @@ def _get_version_bundle(possibly_version_bundle: Any) -> VersionBundle:
 @app.callback()
 def main(
     version: bool = typer.Option(None, "-V", "--version", callback=version_callback, is_eager=True),
-):
-    ...
+): ...
 
 
 if __name__ == "__main__":

{cadwyn-3.12.0 → 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.0 → 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.0 → cadwyn-3.13.0}/cadwyn/codegen/_main.py

@@ -53,8 +53,7 @@ def generate_code_for_versioned_packages(
     codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
     migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
     extra_context: dict[str, Any] | None = None,
-):
-    ...
+): ...
 
 
 @overload
@@ -70,8 +69,7 @@ def generate_code_for_versioned_packages(
     codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
     migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
     extra_context: dict[str, Any] | None = None,
-):
-    ...
+): ...
 
 
 def generate_code_for_versioned_packages(

{cadwyn-3.12.0 → 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.0 → 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]:
@@ -95,8 +90,7 @@ class InternalRepresentationOf:
 def generate_versioned_routers(
     router: _R,
     versions: VersionBundle,
-) -> dict[VersionDate, _R]:
-    ...
+) -> dict[VersionDate, _R]: ...
 
 
 @overload
@@ -105,8 +99,7 @@ def generate_versioned_routers(
     router: _R,
     versions: VersionBundle,
     latest_schemas_package: ModuleType | None,
-) -> dict[VersionDate, _R]:
-    ...
+) -> dict[VersionDate, _R]: ...
 
 
 def generate_versioned_routers(
@@ -163,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)
 
@@ -196,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,
@@ -226,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,
@@ -424,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.
@@ -539,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
 
@@ -552,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. '
@@ -727,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__
@@ -770,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.0 → cadwyn-3.13.0}/cadwyn/routing.py

@@ -67,15 +67,14 @@ class _RootHeaderAPIRouter(APIRouter):
         if self.min_routes_version > request_header_value:
             # then the request version is older that the oldest route we have
             _logger.info(
-                f"Request version {request_version} "
-                f"is older than the oldest "
-                f"version {self.min_routes_version.isoformat()} ",
+                "Request version is older than the oldest version. No route can match this version",
+                extra={"oldest_version": self.min_routes_version.isoformat(), "request_version": request_version},
             )
             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}",
+            "Partial match. The endpoint with a lower version was selected for the API call",
+            extra={"version_chosen": version_chosen, "request_version": request_version},
         )
         return self.versioned_routers[version_chosen].routes
 

{cadwyn-3.12.0 → 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,26 +97,25 @@ 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
 def convert_request_to_next_version_for(
     first_schema: type, /, *additional_schemas: type
-) -> "type[staticmethod[_P, None]]":
-    ...
+) -> "type[staticmethod[_P, None]]": ...
 
 
 @overload
-def convert_request_to_next_version_for(path: str, methods: list[str], /) -> "type[staticmethod[_P, None]]":
-    ...
+def convert_request_to_next_version_for(path: str, methods: list[str], /) -> "type[staticmethod[_P, None]]": ...
 
 
 def convert_request_to_next_version_for(
@@ -128,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,
@@ -138,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,
             )
@@ -158,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
@@ -174,8 +175,7 @@ def convert_response_to_previous_version_for(
     /,
     *schemas: type,
     migrate_http_errors: bool = False,
-) -> "type[staticmethod[_P, None]]":
-    ...
+) -> "type[staticmethod[_P, None]]": ...
 
 
 @overload
@@ -185,8 +185,7 @@ def convert_response_to_previous_version_for(
     /,
     *,
     migrate_http_errors: bool = False,
-) -> "type[staticmethod[_P, None]]":
-    ...
+) -> "type[staticmethod[_P, None]]": ...
 
 
 def convert_response_to_previous_version_for(
@@ -201,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,
@@ -212,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,
@@ -223,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.0 → 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.0 → cadwyn-3.13.0}/cadwyn/structure/versions.py

@@ -20,7 +20,7 @@ from fastapi.concurrency import run_in_threadpool
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import solve_dependencies
 from fastapi.exceptions import RequestValidationError
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.routing import APIRoute, _prepare_response_content
 from pydantic import BaseModel
 from starlette._utils import is_async_callable
@@ -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]]
-    ] = 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_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
     _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",
@@ -245,8 +245,7 @@ class VersionBundle:
         *other_versions: Version,
         api_version_var: APIVersionVarType | None = None,
         head_schemas_package: ModuleType | None = None,
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @overload
     @deprecated("Pass head_version_package instead of latest_schemas_package.")
@@ -257,8 +256,7 @@ class VersionBundle:
         *other_versions: Version,
         api_version_var: APIVersionVarType | None = None,
         latest_schemas_package: ModuleType | None = None,
-    ) -> None:
-        ...
+    ) -> None: ...
 
     def __init__(
         self,
@@ -387,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 "
@@ -399,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.
@@ -413,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)
 
@@ -457,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
@@ -509,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:
@@ -620,7 +621,10 @@ class VersionBundle:
             if isinstance(response_or_response_body, StreamingResponse | FileResponse):
                 body = None
             elif response_or_response_body.body:
-                body = json.loads(response_or_response_body.body)
+                if isinstance(response_or_response_body, JSONResponse) or raised_exception is not None:
+                    body = json.loads(response_or_response_body.body)
+                else:
+                    body = response_or_response_body.body.decode(response_or_response_body.charset)
             else:
                 body = None
                 # TODO (https://github.com/zmievsa/cadwyn/issues/51): Only do this if there are migrations
@@ -666,16 +670,25 @@ class VersionBundle:
             # that do not have it. We don't support it too.
             if response_info.body is not None and hasattr(response_info._response, "body"):
                 # TODO (https://github.com/zmievsa/cadwyn/issues/51): Only do this if there are migrations
-                response_info._response.body = json.dumps(response_info.body).encode()
+                if isinstance(response_info.body, str):
+                    response_info._response.body = response_info.body.encode(response_info._response.charset)
+                else:
+                    response_info._response.body = json.dumps(
+                        response_info.body,
+                        ensure_ascii=False,
+                        allow_nan=False,
+                        indent=None,
+                        separators=(",", ":"),
+                    ).encode("utf-8")
+                # It makes sense to re-calculate content length because the previously calculated one
+                # might slightly differ. If it differs -- uvicorn will break.
+                response_info.headers["content-length"] = str(len(response_info._response.body))
 
             if raised_exception is not None and response_info.status_code >= 400:
                 if isinstance(response_info.body, dict) and "detail" in response_info.body:
                     detail = response_info.body["detail"]
                 else:
                     detail = response_info.body
-                # It makes more sense to re-calculate content length because the previously calculated one
-                # might slightly differ.
-                del response_info.headers["content-length"]
 
                 raise HTTPException(
                     status_code=response_info.status_code,
@@ -713,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.13.0/pyproject.toml

@@ -0,0 +1,135 @@
+[tool.poetry]
+name = "cadwyn"
+version = "3.13.0"
+description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
+authors = ["Stanislav Zmiev <zmievsa@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/zmievsa/cadwyn"
+documentation = "https://docs.cadwyn.dev"
+keywords = [
+    "python",
+    "api",
+    "json-schema",
+    "stripe",
+    "versioning",
+    "code-generation",
+    "hints",
+    "api-versioning",
+    "pydantic",
+    "fastapi",
+    "python310",
+    "python311",
+    "python312",
+]
+classifiers = [
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: FastAPI",
+    "Framework :: Pydantic",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+typing-extensions = "*"
+fastapi = ">=0.110.0"
+starlette = ">=0.36.3"
+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"]
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=7.2.1"
+pytest-cov = ">=4.0.0"
+uvicorn = "*"
+devtools = "*"
+pdbpp = "^0.10.3"
+httpx = "*"
+pytest-fixture-classes = ">=1.0.3"
+dirty-equals = ">=0.6.0"
+mkdocs = ">=1.5.2"
+mkdocs-material = ">=9.3.1"
+python-multipart = ">=0.0.6"
+mkdocs-simple-hooks = ">=0.1.5"
+pytest-sugar = "^1.0.0"
+
+[tool.poetry.scripts]
+cadwyn = "cadwyn.__main__:app"
+
+[tool.coverage.report]
+skip_covered = true
+skip_empty = true
+# Taken from https://coverage.readthedocs.io/en/7.1.0/excluding.html#advanced-exclusion
+exclude_lines = [
+    "pragma: no cover",
+    "assert_never\\(",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if False:",
+    "assert_never",
+    "if 0:",
+    "class .*\\bProtocol\\):",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@(abc\\.)?abstractmethod",
+    "@(typing\\.)?overload",
+    "__rich_repr__",
+    "__repr__",
+]
+omit = ["./docs/plugin.py", "./site/plugin.py", "./tests/_data/_temp/**/*", "tests/tutorial/data/**/*", "scripts/*.py"]
+
+[tool.pyright]
+reportMissingImports = true
+strictListInference = true
+strictDictionaryInference = true
+strictSetInference = true
+reportPropertyTypeMismatch = true
+reportImportCycles = true
+reportUntypedFunctionDecorator = "warning"
+reportUntypedClassDecorator = "warning"
+reportUntypedBaseClass = "warning"
+reportDeprecated = "warning"
+reportInvalidTypeVarUse = true
+reportUnnecessaryCast = true
+reportUnnecessaryComparison = true
+reportUnnecessaryContains = true
+reportAssertAlwaysTrue = true
+reportUnsupportedDunderAll = true
+reportUnnecessaryTypeIgnoreComment = true
+reportMissingSuperCall = true
+reportFunctionMemberAccess = false
+reportCircularImports = true
+reportInvalidTypeForm = false
+
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

cadwyn-3.12.0/pyproject.toml

@@ -1,247 +0,0 @@
-[tool.poetry]
-name = "cadwyn"
-version = "3.12.0"
-description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
-authors = ["Stanislav Zmiev <zmievsa@gmail.com>"]
-license = "MIT"
-readme = "README.md"
-repository = "https://github.com/zmievsa/cadwyn"
-documentation = "https://docs.cadwyn.dev"
-keywords = [
-    "python",
-    "api",
-    "json-schema",
-    "stripe",
-    "versioning",
-    "code-generation",
-    "hints",
-    "api-versioning",
-    "pydantic",
-    "fastapi",
-    "python310",
-    "python311",
-    "python312",
-]
-classifiers = [
-    "Intended Audience :: Information Technology",
-    "Intended Audience :: System Administrators",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Internet",
-    "Topic :: Software Development :: Libraries :: Application Frameworks",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Software Development :: Libraries",
-    "Topic :: Software Development",
-    "Typing :: Typed",
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Web Environment",
-    "Framework :: AsyncIO",
-    "Framework :: FastAPI",
-    "Framework :: Pydantic",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
-    "Topic :: Internet :: WWW/HTTP",
-]
-
-
-[tool.poetry.dependencies]
-python = "^3.10"
-typing-extensions = "*"
-fastapi = ">=0.110.0"
-starlette = ">=0.36.3"
-pydantic = ">=1.0.0"
-typer = {version = ">=0.7.0", optional = true}
-better-ast-comments = "~1.2.1"
-jinja2 = ">=3.1.2"
-
-[tool.poetry.extras]
-cli = ["typer"]
-
-
-[tool.poetry.group.dev.dependencies]
-ruff = "*"
-pytest = ">=7.2.1"
-pytest-cov = ">=4.0.0"
-uvicorn = "*"
-devtools = "*"
-pdbpp = "^0.10.3"
-httpx = "*"
-pytest-fixture-classes = ">=1.0.3"
-pre-commit = ">=3.4.0"
-dirty-equals = ">=0.6.0"
-mkdocs = ">=1.5.2"
-mkdocs-material = ">=9.3.1"
-python-multipart = ">=0.0.6"
-mkdocs-simple-hooks = ">=0.1.5"
-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
-# Taken from https://coverage.readthedocs.io/en/7.1.0/excluding.html#advanced-exclusion
-exclude_lines = [
-    "pragma: no cover",
-    "assert_never\\(",
-    "if self.debug:",
-    "if settings.DEBUG",
-    "raise AssertionError",
-    "raise NotImplementedError",
-    "if False:",
-    "assert_never",
-    "if 0:",
-    "class .*\\bProtocol\\):",
-    "if __name__ == .__main__.:",
-    "if TYPE_CHECKING:",
-    "@(abc\\.)?abstractmethod",
-    "@(typing\\.)?overload",
-    "__rich_repr__",
-    "__repr__",
-]
-omit = ["./docs/plugin.py", "./site/plugin.py", "./tests/_data/_temp/**/*", "tests/tutorial/data/**/*", "scripts/*.py"]
-
-[tool.pyright]
-reportMissingImports = true
-strictListInference = true
-strictDictionaryInference = true
-strictSetInference = true
-reportPropertyTypeMismatch = true
-reportImportCycles = true
-reportUntypedFunctionDecorator = "warning"
-reportUntypedClassDecorator = "warning"
-reportUntypedBaseClass = "warning"
-reportDeprecated = "warning"
-reportInvalidTypeVarUse = true
-reportUnnecessaryCast = true
-reportUnnecessaryComparison = true
-reportUnnecessaryContains = true
-reportAssertAlwaysTrue = true
-reportUnsupportedDunderAll = true
-reportUnnecessaryTypeIgnoreComment = true
-reportMissingSuperCall = true
-reportFunctionMemberAccess = false
-reportCircularImports = true
-
-
-[tool.ruff]
-target-version = "py310"
-line-length = 120
-extend-exclude = ["scripts/*.py"]
-
-[tool.ruff.lint]
-select = [
-    "F",       # pyflakes
-    "E",       # pycodestyle errors
-    "W",       # pycodestyle warnings
-    "C90",     # mccabe
-    "I",       # isort
-    "N",       # pep8-naming
-    "UP",      # pyupgrade
-    "YTT",     # flake8-2020
-    "S",       # flake8-bandit
-    "BLE",     # flake8-blind-except
-    "FBT003",  # flake8-boolean-trap
-    "B",       # flake8-bugbear
-    "COM",     # flake8-commas
-    "C4",      # flake8-comprehensions
-    "T10",     # flake8-debugger
-    "ISC",     # flake8-implicit-str-concat
-    "G010",    # Logging statement uses warn instead of warning
-    "G201",    # Logging .exception(...) should be used instead of .error(..., exc_info=True)
-    "G202",    # Logging statement has redundant exc_info
-    "INP",     # flake8-no-pep420
-    "PIE",     # flake8-pie
-    "T20",     # flake8-print
-    "PYI",     # flake8-pyi
-    "PT",      # flake8-pytest-style
-    "Q",       # flake8-quotes
-    "RSE",     # flake8-raise
-    "RET",     # flake8-return
-    "SIM",     # flake8-simplify
-    "TCH",     # flake8-type-checking
-    "ARG",     # flake8-unused-arguments
-    "PTH",     # flake8-use-pathlib
-    "ERA",     # flake8-eradicate
-    "PGH",     # pygrep-hooks
-    "PLC0414", # Import alias does not rename original package
-    "PLE",     # Error
-    "PLW",     # Warning
-    "TRY",     # tryceratops
-    "FLY",     # flynt
-    "RUF",     # ruff-specific rules
-    "ANN001",  # missing type annotation for arguments
-    "ANN002",  # missing type annotation for *args
-    "ANN003",  # missing type annotation for **kwargs
-]
-unfixable = [
-    "ERA001", # eradicate: found commented out code (can be dangerous if fixed automatically)
-]
-ignore = [
-    "D203",   # 1 blank line required before class docstring
-    "ARG001", # Unused first argument
-    "ARG002", # Unused method argument
-    "TRY003", # Avoid specifying long messages outside the exception class
-    "TRY300", # Consider moving statement into the else clause
-    "PT019",  # Fixture without value is injected as parameter, use @pytest.mark.usefixtures instead
-              # (usefixtures doesn't play well with IDE features such as auto-renaming)
-    "SIM108", # Use ternary operator instead of if-else block (ternaries lie to coverage)
-    "RET505", # Unnecessary `else` after `return` statement
-    "N805",   # First argument of a method should be named `self` (pydantic validators don't play well with this)
-    "UP007",  # Use `X | Y` for type annotations (we need this for testing and our runtime logic)
-
-    # The following rules are recommended to be ignored by ruff when using ruff format
-    "ISC001", # Checks for implicitly concatenated strings on a single line
-    "ISC002", # Checks for implicitly concatenated strings that span multiple lines
-    "W191",   # Checks for indentation that uses tabs
-    "E111",   # Checks for indentation with a non-multiple of 4 spaces
-    "E114",   # Checks for indentation of comments with a non-multiple of 4 spaces
-    "E117",   # Checks for over-indented code
-    "D206",   # Checks for docstrings that are indented with tabs
-    "D300",   # Checks for docstrings that use '''single quotes''' instead of """double quotes"""
-    "Q000",   # Checks for inline strings that use single quotes or double quotes
-    "Q001",   # Checks for multiline strings that use single quotes or double quotes
-    "Q002",   # Checks for docstrings that use single quotes or double quotes
-    "Q003",   # Checks for strings that include escaped quotes
-    "COM812", # Checks for the absence of trailing commas
-    "COM819", # Checks for the presence of prohibited trailing commas
-    "RET506", # Unnecessary `elif` after `raise` statement
-]
-
-
-[tool.ruff.lint.per-file-ignores]
-"tests/*" = [
-    "S",      # ignore bandit security issues in tests
-    "B018",   # ignore useless expressions in tests
-    "PT012",  # ignore complex with pytest.raises clauses
-    "RUF012", # ignore mutable class attributes ClassVar typehint requirement
-    "ANN001", # Missing type annotation for function argument
-    "ANN002", # Missing type annotation for *args
-    "ANN003", # Missing type annotation for **kwargs
-    "PGH003", # Use specific rule codes when ignoring type issues
-    "B008",   # Do not perform function call in argument defaults
-]
-"cadwyn/_utils.py" = [
-    "ERA001", # Found commented-out code (it's not actually commented out. It's just comments)
-]
-
-[tool.ruff.lint.mccabe]
-max-complexity = 14
-
-[tool.ruff.format]
-quote-style = "double"
-indent-style = "space"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"