cadwyn 5.0.0a1__py3-none-any.whl → 5.1.0a1__py3-none-any.whl

cadwyn/_asts.py

@@ -2,10 +2,11 @@ import ast
 import inspect
 from collections.abc import Callable
 from enum import Enum, auto
-from types import GenericAlias, LambdaType, NoneType
+from types import GenericAlias, LambdaType
 from typing import (  # noqa: UP035
     Any,
     List,
+    Union,
     cast,
     get_args,
     get_origin,
@@ -17,6 +18,7 @@ from cadwyn._utils import PlainRepr, UnionType
 from cadwyn.exceptions import InvalidGenerationInstructionError
 
 _LambdaFunctionName = (lambda: None).__name__  # pragma: no branch
+NoneType = type(None)
 
 
 # A parent type of typing._GenericAlias
@@ -25,17 +27,18 @@ _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
 # instead of typing._GenericAlias.
-GenericAliasUnion = GenericAlias | _BaseGenericAlias
+GenericAliasUnion = Union[GenericAlias, _BaseGenericAlias]
+GenericAliasUnionArgs = get_args(GenericAliasUnion)
 
 
 def get_fancy_repr(value: Any) -> Any:
     if isinstance(value, annotated_types.GroupedMetadata) and hasattr(type(value), "__dataclass_fields__"):
         return transform_grouped_metadata(value)
-    if isinstance(value, list | tuple | set | frozenset):
+    if isinstance(value, (list, tuple, set, frozenset)):
         return transform_collection(value)
     if isinstance(value, dict):
         return transform_dict(value)
-    if isinstance(value, GenericAliasUnion):
+    if isinstance(value, GenericAliasUnionArgs):
         return transform_generic_alias(value)
     if value is None or value is NoneType:
         return transform_none(value)
@@ -46,7 +49,7 @@ def get_fancy_repr(value: Any) -> Any:
     if isinstance(value, auto):  # pragma: no cover # it works but we no longer use auto
         return transform_auto(value)
     if isinstance(value, UnionType):
-        return transform_union(value)
+        return transform_union(value)  # pragma: no cover
     if isinstance(value, LambdaType) and _LambdaFunctionName == value.__name__:
         return transform_lambda(value)
     if inspect.isfunction(value):
@@ -72,7 +75,7 @@ def transform_grouped_metadata(value: "annotated_types.GroupedMetadata"):
     )
 
 
-def transform_collection(value: list | tuple | set | frozenset) -> Any:
+def transform_collection(value: Union[list, tuple, set, frozenset]) -> Any:
     return PlainRepr(value.__class__(map(get_fancy_repr, value)))
 
 
@@ -102,7 +105,7 @@ def transform_auto(_: auto) -> Any:  # pragma: no cover # it works but we no lon
     return PlainRepr("auto()")
 
 
-def transform_union(value: UnionType) -> Any:
+def transform_union(value: UnionType) -> Any:  # pragma: no cover
     return "typing.Union[" + (", ".join(get_fancy_repr(a) for a in get_args(value))) + "]"
 
 

cadwyn/_render.py

@@ -2,7 +2,7 @@ import ast
 import inspect
 import textwrap
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 import typer
 from issubclass import issubclass as lenient_issubclass
@@ -30,7 +30,7 @@ def render_module_by_path(module_path: str, app_path: str, version: str):
     attributes_to_alter = [
         name
         for name, value in module.__dict__.items()
-        if lenient_issubclass(value, Enum | BaseModel) and value.__module__ == module.__name__
+        if lenient_issubclass(value, (Enum, BaseModel)) and value.__module__ == module.__name__
     ]
 
     try:
@@ -53,12 +53,12 @@ def render_module_by_path(module_path: str, app_path: str, version: str):
 
 def render_model_by_path(model_path: str, app_path: str, version: str) -> str:
     # cadwyn render model schemas:MySchema --app=run:app --version=2000-01-01
-    model: type[BaseModel | Enum] = import_attribute_from_string(model_path)
+    model: type[Union[BaseModel, Enum]] = import_attribute_from_string(model_path)
     app: Cadwyn = import_attribute_from_string(app_path)
     return render_model(model, app.versions, version)
 
 
-def render_model(model: type[BaseModel | Enum], versions: VersionBundle, version: str) -> str:
+def render_model(model: type[Union[BaseModel, Enum]], versions: VersionBundle, version: str) -> str:
     try:
         original_cls_node = ast.parse(textwrap.dedent(inspect.getsource(model))).body[0]
     except (OSError, SyntaxError, ValueError):  # pragma: no cover
@@ -71,7 +71,7 @@ def render_model(model: type[BaseModel | Enum], versions: VersionBundle, version
 
 
 def _render_model_from_ast(
-    model_ast: ast.ClassDef, model: type[BaseModel | Enum], versions: VersionBundle, version: str
+    model_ast: ast.ClassDef, model: type[Union[BaseModel, Enum]], versions: VersionBundle, version: str
 ):
     versioned_models = generate_versioned_models(versions)
     generator = versioned_models[version]
@@ -97,7 +97,7 @@ def _render_enum_model(wrapper: _EnumWrapper, original_cls_node: ast.ClassDef):
     ]
 
     old_body = [
-        n for n in original_cls_node.body if not isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)
+        n for n in original_cls_node.body if not isinstance(n, (ast.AnnAssign, ast.Assign, ast.Pass, ast.Constant))
     ]
     docstring = pop_docstring_from_cls_body(old_body)
 
@@ -130,7 +130,7 @@ def _render_pydantic_model(wrapper: _PydanticModelWrapper, original_cls_node: as
         n
         for n in original_cls_node.body
         if not (
-            isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)
+            isinstance(n, (ast.AnnAssign, ast.Assign, ast.Pass, ast.Constant))
             or (isinstance(n, ast.FunctionDef) and n.name in wrapper.validators)
         )
     ]

cadwyn/_utils.py

@@ -1,10 +1,11 @@
+import sys
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union
 
 from pydantic._internal._decorators import unwrap_wrapped_function
 
 Sentinel: Any = object()
-UnionType = type(int | str) | type(Union[int, str])
+
 _T = TypeVar("_T", bound=Callable)
 
 
@@ -12,6 +13,28 @@ _P_T = TypeVar("_P_T")
 _P_R = TypeVar("_P_R")
 
 
+if sys.version_info >= (3, 10):
+    UnionType = type(int | str) | type(Union[int, str])
+    DATACLASS_SLOTS: dict[str, Any] = {"slots": True}
+    ZIP_STRICT_TRUE: dict[str, Any] = {"strict": True}
+    ZIP_STRICT_FALSE: dict[str, Any] = {"strict": False}
+    DATACLASS_KW_ONLY: dict[str, Any] = {"kw_only": True}
+else:
+    UnionType = type(Union[int, str])
+    DATACLASS_SLOTS: dict[str, Any] = {}
+    DATACLASS_KW_ONLY: dict[str, Any] = {}
+    ZIP_STRICT_TRUE: dict[str, Any] = {}
+    ZIP_STRICT_FALSE: dict[str, Any] = {}
+
+
+def get_name_of_function_wrapped_in_pydantic_validator(func: Any) -> str:
+    if hasattr(func, "wrapped"):
+        return get_name_of_function_wrapped_in_pydantic_validator(func.wrapped)
+    if hasattr(func, "__func__"):
+        return get_name_of_function_wrapped_in_pydantic_validator(func.__func__)
+    return func.__name__
+
+
 class classproperty(Generic[_P_T, _P_R]):  # noqa: N801
     def __init__(self, func: Callable[[_P_T], _P_R]) -> None:
         super().__init__()
@@ -49,7 +72,7 @@ if TYPE_CHECKING:
 
 else:
 
-    def lenient_issubclass(cls: type, other: T | tuple[T, ...]) -> bool:
+    def lenient_issubclass(cls: type, other: Union[T, tuple[T, ...]]) -> bool:
         try:
             return issubclass(cls, other)
         except TypeError:  # pragma: no cover

cadwyn/applications.py

@@ -4,7 +4,7 @@ from collections.abc import Awaitable, Callable, Coroutine, Sequence
 from datetime import date
 from logging import getLogger
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Any, cast
+from typing import TYPE_CHECKING, Annotated, Any, Union, cast
 
 import fastapi
 from fastapi import APIRouter, FastAPI, HTTPException, routing
@@ -26,7 +26,7 @@ from starlette.routing import BaseRoute, Route
 from starlette.types import Lifespan
 from typing_extensions import Self, assert_never, deprecated
 
-from cadwyn._utils import same_definition_as_in
+from cadwyn._utils import DATACLASS_SLOTS, same_definition_as_in
 from cadwyn.changelogs import CadwynChangelogResource, _generate_changelog
 from cadwyn.exceptions import CadwynStructureError
 from cadwyn.middleware import (
@@ -48,7 +48,7 @@ CURR_DIR = Path(__file__).resolve()
 logger = getLogger(__name__)
 
 
-@dataclasses.dataclass(slots=True)
+@dataclasses.dataclass(**DATACLASS_SLOTS)
 class FakeDependencyOverridesProvider:
     dependency_overrides: dict[Callable[..., Any], Callable[..., Any]]
 
@@ -61,7 +61,7 @@ class Cadwyn(FastAPI):
         *,
         versions: VersionBundle,
         api_version_header_name: Annotated[
-            str | None,
+            Union[str, None],
             deprecated(
                 "api_version_header_name is deprecated and will be removed in the future. "
                 "Use api_version_parameter_name instead."
@@ -70,49 +70,51 @@ class Cadwyn(FastAPI):
         api_version_location: APIVersionLocation = "custom_header",
         api_version_format: APIVersionFormat = "date",
         api_version_parameter_name: str = "x-api-version",
-        api_version_default_value: str | None | Callable[[Request], Awaitable[str]] = None,
+        api_version_default_value: Union[str, None, Callable[[Request], Awaitable[str]]] = None,
         versioning_middleware_class: type[VersionPickingMiddleware] = VersionPickingMiddleware,
-        changelog_url: str | None = "/changelog",
+        changelog_url: Union[str, None] = "/changelog",
         include_changelog_url_in_schema: bool = True,
         debug: bool = False,
         title: str = "FastAPI",
-        summary: str | None = None,
+        summary: Union[str, None] = None,
         description: str = "",
         version: str = "0.1.0",
-        openapi_url: str | None = "/openapi.json",
-        openapi_tags: list[dict[str, Any]] | None = None,
-        servers: list[dict[str, str | Any]] | None = None,
-        dependencies: Sequence[Depends] | None = None,
+        openapi_url: Union[str, None] = "/openapi.json",
+        openapi_tags: Union[list[dict[str, Any]], None] = None,
+        servers: Union[list[dict[str, Union[str, Any]]], None] = None,
+        dependencies: Union[Sequence[Depends], None] = None,
         default_response_class: type[Response] = JSONResponse,
         redirect_slashes: bool = True,
-        routes: list[BaseRoute] | None = None,
-        docs_url: str | None = "/docs",
-        redoc_url: str | None = "/redoc",
-        swagger_ui_oauth2_redirect_url: str | None = "/docs/oauth2-redirect",
-        swagger_ui_init_oauth: dict[str, Any] | None = None,
-        middleware: Sequence[Middleware] | None = None,
+        routes: Union[list[BaseRoute], None] = None,
+        docs_url: Union[str, None] = "/docs",
+        redoc_url: Union[str, None] = "/redoc",
+        swagger_ui_oauth2_redirect_url: Union[str, None] = "/docs/oauth2-redirect",
+        swagger_ui_init_oauth: Union[dict[str, Any], None] = None,
+        middleware: Union[Sequence[Middleware], None] = None,
         exception_handlers: (
-            dict[
-                int | type[Exception],
-                Callable[[Request, Any], Coroutine[Any, Any, Response]],
+            Union[
+                dict[
+                    Union[int, type[Exception]],
+                    Callable[[Request, Any], Coroutine[Any, Any, Response]],
+                ],
+                None,
             ]
-            | None
         ) = None,
-        on_startup: Sequence[Callable[[], Any]] | None = None,
-        on_shutdown: Sequence[Callable[[], Any]] | None = None,
-        lifespan: Lifespan[Self] | None = None,
-        terms_of_service: str | None = None,
-        contact: dict[str, str | Any] | None = None,
-        license_info: dict[str, str | Any] | None = None,
+        on_startup: Union[Sequence[Callable[[], Any]], None] = None,
+        on_shutdown: Union[Sequence[Callable[[], Any]], None] = None,
+        lifespan: Union[Lifespan[Self], None] = None,
+        terms_of_service: Union[str, None] = None,
+        contact: Union[dict[str, Union[str, Any]], None] = None,
+        license_info: Union[dict[str, Union[str, Any]], None] = None,
         openapi_prefix: str = "",
         root_path: str = "",
         root_path_in_servers: bool = True,
-        responses: dict[int | str, dict[str, Any]] | None = None,
-        callbacks: list[BaseRoute] | None = None,
-        webhooks: APIRouter | None = None,
-        deprecated: bool | None = None,
+        responses: Union[dict[Union[int, str], dict[str, Any]], None] = None,
+        callbacks: Union[list[BaseRoute], None] = None,
+        webhooks: Union[APIRouter, None] = None,
+        deprecated: Union[bool, None] = None,
         include_in_schema: bool = True,
-        swagger_ui_parameters: dict[str, Any] | None = None,
+        swagger_ui_parameters: Union[dict[str, Any], None] = None,
         generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(  # noqa: B008
             generate_unique_id
         ),