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

cadwyn/changelogs.py

@@ -2,7 +2,7 @@ import copy
 import sys
 from enum import auto
 from logging import getLogger
-from typing import Any, Literal, TypeVar, cast, get_args
+from typing import Any, Literal, TypeVar, Union, cast, get_args
 
 from fastapi._compat import (
     GenerateJsonSchema,
@@ -18,8 +18,8 @@ from fastapi.openapi.utils import (
 from fastapi.routing import APIRoute
 from pydantic import BaseModel, Field, RootModel
 
-from cadwyn._asts import GenericAliasUnion
-from cadwyn._utils import Sentinel
+from cadwyn._asts import GenericAliasUnionArgs
+from cadwyn._utils import ZIP_STRICT_FALSE, Sentinel
 from cadwyn.route_generation import _get_routes
 from cadwyn.routing import _RootCadwynAPIRouter
 from cadwyn.schema_generation import SchemaGenerator, _change_field_in_model, generate_versioned_models
@@ -48,12 +48,12 @@ else:  # pragma: no cover
 
 _logger = getLogger(__name__)
 
-T = TypeVar("T", bound=PossibleInstructions | type[VersionChange])
+T = TypeVar("T", bound=Union[PossibleInstructions, type[VersionChange]])
 
 
 def hidden(instruction_or_version_change: T) -> T:
     if isinstance(
-        instruction_or_version_change, staticmethod | ValidatorDidntExistInstruction | ValidatorExistedInstruction
+        instruction_or_version_change, (staticmethod, ValidatorDidntExistInstruction, ValidatorExistedInstruction)
     ):
         return instruction_or_version_change
 
@@ -64,7 +64,7 @@ def hidden(instruction_or_version_change: T) -> T:
 def _generate_changelog(versions: VersionBundle, router: _RootCadwynAPIRouter) -> "CadwynChangelogResource":
     changelog = CadwynChangelogResource()
     schema_generators = generate_versioned_models(versions)
-    for version, older_version in zip(versions, versions.versions[1:], strict=False):
+    for version, older_version in zip(versions, versions.versions[1:], **ZIP_STRICT_FALSE):
         routes_from_newer_version = router.versioned_routers[version.value].routes
         schemas_from_older_version = get_fields_from_routes(router.versioned_routers[older_version.value].routes)
         version_changelog = CadwynVersion(value=version.value)
@@ -83,7 +83,7 @@ def _generate_changelog(versions: VersionBundle, router: _RootCadwynAPIRouter) -
                 *version_change.alter_schema_instructions,
             ]:
                 if (
-                    isinstance(instruction, ValidatorDidntExistInstruction | ValidatorExistedInstruction)
+                    isinstance(instruction, (ValidatorDidntExistInstruction, ValidatorExistedInstruction))
                     or instruction.is_hidden_from_changelog
                 ):
                     continue
@@ -113,10 +113,12 @@ def _get_older_field_name(
 
 
 def _get_affected_model_names(
-    instruction: FieldExistedAsInstruction
-    | FieldDidntExistInstruction
-    | FieldHadInstruction
-    | FieldDidntHaveInstruction,
+    instruction: Union[
+        FieldExistedAsInstruction,
+        FieldDidntExistInstruction,
+        FieldHadInstruction,
+        FieldDidntHaveInstruction,
+    ],
     generator_from_newer_version: SchemaGenerator,
     schemas_from_last_version: list[ModelField],
 ):
@@ -139,7 +141,7 @@ def _get_affected_model_names(
 
 
 def _get_all_pydantic_models_from_generic(annotation: Any) -> list[type[BaseModel]]:
-    if not isinstance(annotation, GenericAliasUnion):
+    if not isinstance(annotation, GenericAliasUnionArgs):
         if isinstance(annotation, type) and issubclass(annotation, BaseModel):
             return [annotation]
         else:
@@ -209,7 +211,7 @@ class CadwynFieldAttributesWereChangedChangelogEntry(BaseModel):
 
 
 class CadwynModelModifiedAttributes(BaseModel):
-    name: str | None
+    name: Union[str, None]
 
 
 class CadwynSchemaWasChangedChangelogEntry(BaseModel):
@@ -294,15 +296,17 @@ class CadwynVersionChange(BaseModel):
 
 
 CadwynVersionChangeInstruction = RootModel[
-    CadwynEnumMembersWereAddedChangelogEntry
-    | CadwynEnumMembersWereChangedChangelogEntry
-    | CadwynEndpointWasAddedChangelogEntry
-    | CadwynEndpointWasRemovedChangelogEntry
-    | CadwynSchemaFieldWasRemovedChangelogEntry
-    | CadwynSchemaFieldWasAddedChangelogEntry
-    | CadwynFieldAttributesWereChangedChangelogEntry
-    | CadwynEndpointHadChangelogEntry
-    | CadwynSchemaWasChangedChangelogEntry
+    Union[
+        CadwynEnumMembersWereAddedChangelogEntry,
+        CadwynEnumMembersWereChangedChangelogEntry,
+        CadwynEndpointWasAddedChangelogEntry,
+        CadwynEndpointWasRemovedChangelogEntry,
+        CadwynSchemaFieldWasRemovedChangelogEntry,
+        CadwynSchemaFieldWasAddedChangelogEntry,
+        CadwynFieldAttributesWereChangedChangelogEntry,
+        CadwynEndpointHadChangelogEntry,
+        CadwynSchemaWasChangedChangelogEntry,
+    ]
 ]
 
 
@@ -314,185 +318,182 @@ def _convert_version_change_instruction_to_changelog_entry(  # noqa: C901
     schemas_from_older_version: list[ModelField],
     routes_from_newer_version: list[APIRoute],
 ):
-    match instruction:
-        case EndpointDidntExistInstruction():
-            return CadwynEndpointWasAddedChangelogEntry(
-                path=instruction.endpoint_path,
-                methods=cast(Any, instruction.endpoint_methods),
-            )
-        case EndpointExistedInstruction():
+    if isinstance(instruction, EndpointDidntExistInstruction):
+        return CadwynEndpointWasAddedChangelogEntry(
+            path=instruction.endpoint_path,
+            methods=cast(Any, instruction.endpoint_methods),
+        )
+    elif isinstance(instruction, EndpointExistedInstruction):
+        return CadwynEndpointWasRemovedChangelogEntry(
+            path=instruction.endpoint_path,
+            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),
             )
-        case EndpointHadInstruction():
-            if instruction.attributes.include_in_schema is not Sentinel:
-                return CadwynEndpointWasRemovedChangelogEntry(
-                    path=instruction.endpoint_path,
-                    methods=cast(Any, instruction.endpoint_methods),
-                )
 
-            renaming_map = {"operation_id": "operationId"}
+        renaming_map = {"operation_id": "operationId"}
 
-            attribute_changes = []
+        attribute_changes = []
 
-            for attr in ["path", "methods", "summary", "description", "tags", "deprecated", "operation_id"]:
-                attr_value = getattr(instruction.attributes, attr)
-                if attr_value is not Sentinel:
-                    attribute_changes.append(
-                        CadwynEndpointAttributeChange(name=renaming_map.get(attr, attr), new_value=attr_value)
-                    )
-            if instruction.attributes.name is not Sentinel and instruction.attributes.summary is Sentinel:
+        for attr in ["path", "methods", "summary", "description", "tags", "deprecated", "operation_id"]:
+            attr_value = getattr(instruction.attributes, attr)
+            if attr_value is not Sentinel:
                 attribute_changes.append(
-                    CadwynEndpointAttributeChange(name="summary", new_value=instruction.attributes.name)
-                )
-
-            if any(
-                getattr(instruction.attributes, attr) is not Sentinel
-                for attr in ["path", "methods", "summary", "description", "tags", "deprecated"]
-            ):
-                pass
-            if any(
-                attr is not Sentinel
-                for attr in [
-                    instruction.attributes.response_model,
-                    instruction.attributes.response_class,
-                    instruction.attributes.responses,
-                    instruction.attributes.status_code,
-                ]
-            ):
-                newer_routes = _get_routes(
-                    routes_from_newer_version,
-                    instruction.endpoint_path,
-                    instruction.endpoint_methods,
-                    instruction.endpoint_func_name,
-                    is_deleted=False,
+                    CadwynEndpointAttributeChange(name=renaming_map.get(attr, attr), new_value=attr_value)
                 )
-                newer_openapi = get_openapi(title="", version="", routes=newer_routes)
-                changed_responses = {
-                    method: route_openapi["responses"]
-                    for method, route_openapi in newer_openapi["paths"][instruction.endpoint_path].items()
-                }
-                attribute_changes.append(CadwynEndpointAttributeChange(name="responses", new_value=changed_responses))
-            return CadwynEndpointHadChangelogEntry(
-                path=instruction.endpoint_path,
-                methods=cast(Any, instruction.endpoint_methods),
-                changes=attribute_changes,
+        if instruction.attributes.name is not Sentinel and instruction.attributes.summary is Sentinel:
+            attribute_changes.append(
+                CadwynEndpointAttributeChange(name="summary", new_value=instruction.attributes.name)
             )
 
-        case FieldHadInstruction() | FieldDidntHaveInstruction():
-            old_field_name = _get_older_field_name(instruction.schema, instruction.name, generator_from_older_version)
-
-            if isinstance(instruction, FieldHadInstruction) and instruction.new_name is not Sentinel:
-                old_field_name_from_this_instruction = instruction.new_name
-                attribute_changes = [
-                    CadwynAttributeChange(
-                        name="name",
-                        status=CadwynAttributeChangeStatus.changed,
-                        old_value=old_field_name,
-                        new_value=instruction.name,
-                    )
-                ]
-            else:
-                old_field_name_from_this_instruction = instruction.name
-                attribute_changes = []
-            newer_model_wrapper = generator_from_newer_version._get_wrapper_for_model(instruction.schema)
-            newer_model_wrapper_with_migrated_field = copy.deepcopy(newer_model_wrapper)
-            _change_field_in_model(
-                newer_model_wrapper_with_migrated_field,
-                generator_from_newer_version.model_bundle.schemas,
-                alter_schema_instruction=instruction,
-                version_change_name=version_change.__name__,
+        if any(
+            getattr(instruction.attributes, attr) is not Sentinel
+            for attr in ["path", "methods", "summary", "description", "tags", "deprecated"]
+        ):
+            pass
+        if any(
+            attr is not Sentinel
+            for attr in [
+                instruction.attributes.response_model,
+                instruction.attributes.response_class,
+                instruction.attributes.responses,
+                instruction.attributes.status_code,
+            ]
+        ):
+            newer_routes = _get_routes(
+                routes_from_newer_version,
+                instruction.endpoint_path,
+                instruction.endpoint_methods,
+                instruction.endpoint_func_name,
+                is_deleted=False,
             )
+            newer_openapi = get_openapi(title="", version="", routes=newer_routes)
+            changed_responses = {
+                method: route_openapi["responses"]
+                for method, route_openapi in newer_openapi["paths"][instruction.endpoint_path].items()
+            }
+            attribute_changes.append(CadwynEndpointAttributeChange(name="responses", new_value=changed_responses))
+        return CadwynEndpointHadChangelogEntry(
+            path=instruction.endpoint_path,
+            methods=cast(Any, instruction.endpoint_methods),
+            changes=attribute_changes,
+        )
 
-            older_model = newer_model_wrapper_with_migrated_field.generate_model_copy(generator_from_newer_version)
-            newer_model = newer_model_wrapper.generate_model_copy(generator_from_newer_version)
-
-            newer_field_openapi = _get_openapi_representation_of_a_field(newer_model, instruction.name)
-            older_field_openapi = _get_openapi_representation_of_a_field(
-                older_model, old_field_name_from_this_instruction
-            )
+    elif isinstance(instruction, (FieldHadInstruction, FieldDidntHaveInstruction)):
+        old_field_name = _get_older_field_name(instruction.schema, instruction.name, generator_from_older_version)
 
-            attribute_changes += [
+        if isinstance(instruction, FieldHadInstruction) and instruction.new_name is not Sentinel:
+            old_field_name_from_this_instruction = instruction.new_name
+            attribute_changes = [
                 CadwynAttributeChange(
-                    name=key,
-                    status=CadwynAttributeChangeStatus.changed
-                    if key in newer_field_openapi
-                    else CadwynAttributeChangeStatus.removed,
-                    old_value=old_value,
-                    new_value=newer_field_openapi.get(key),
+                    name="name",
+                    status=CadwynAttributeChangeStatus.changed,
+                    old_value=old_field_name,
+                    new_value=instruction.name,
                 )
-                for key, old_value in older_field_openapi.items()
-                if old_value != newer_field_openapi.get(key)
-            ]
-            attribute_changes += [
-                CadwynAttributeChange(
-                    name=key,
-                    status=CadwynAttributeChangeStatus.added,
-                    old_value=None,
-                    new_value=new_value,
-                )
-                for key, new_value in newer_field_openapi.items()
-                if key not in older_field_openapi
             ]
+        else:
+            old_field_name_from_this_instruction = instruction.name
+            attribute_changes = []
+        newer_model_wrapper = generator_from_newer_version._get_wrapper_for_model(instruction.schema)
+        newer_model_wrapper_with_migrated_field = copy.deepcopy(newer_model_wrapper)
+        _change_field_in_model(
+            newer_model_wrapper_with_migrated_field,
+            generator_from_newer_version.model_bundle.schemas,
+            alter_schema_instruction=instruction,
+            version_change_name=version_change.__name__,
+        )
 
-            return CadwynFieldAttributesWereChangedChangelogEntry(
-                models=_get_affected_model_names(instruction, generator_from_newer_version, schemas_from_older_version),
-                field=old_field_name,
-                attribute_changes=attribute_changes,
-            )
-        case EnumDidntHaveMembersInstruction():
-            enum = generator_from_newer_version._get_wrapper_for_model(instruction.enum)
+        older_model = newer_model_wrapper_with_migrated_field.generate_model_copy(generator_from_newer_version)
+        newer_model = newer_model_wrapper.generate_model_copy(generator_from_newer_version)
 
-            return CadwynEnumMembersWereAddedChangelogEntry(
-                enum=enum.name,
-                members=[CadwynEnumMember(name=name, value=value) for name, value in enum.members.items()],
-            )
-        case EnumHadMembersInstruction():
-            new_enum = generator_from_newer_version[instruction.enum]
-            old_enum = generator_from_older_version[instruction.enum]
-
-            return CadwynEnumMembersWereChangedChangelogEntry(
-                enum=new_enum.__name__,
-                member_changes=[
-                    CadwynAttributeChange(
-                        name=name,
-                        old_value=old_enum.__members__.get(name),
-                        new_value=new_enum.__members__.get(name),
-                        status=CadwynAttributeChangeStatus.changed
-                        if name in new_enum.__members__
-                        else CadwynAttributeChangeStatus.removed,
-                    )
-                    for name in instruction.members
-                ],
-            )
-        case SchemaHadInstruction():
-            model = generator_from_newer_version._get_wrapper_for_model(instruction.schema)
+        newer_field_openapi = _get_openapi_representation_of_a_field(newer_model, instruction.name)
+        older_field_openapi = _get_openapi_representation_of_a_field(older_model, old_field_name_from_this_instruction)
 
-            return CadwynSchemaWasChangedChangelogEntry(
-                model=instruction.name, modified_attributes=CadwynModelModifiedAttributes(name=model.name)
-            )
-        case FieldExistedAsInstruction():
-            affected_model_names = _get_affected_model_names(
-                instruction, generator_from_newer_version, schemas_from_older_version
+        attribute_changes += [
+            CadwynAttributeChange(
+                name=key,
+                status=CadwynAttributeChangeStatus.changed
+                if key in newer_field_openapi
+                else CadwynAttributeChangeStatus.removed,
+                old_value=old_value,
+                new_value=newer_field_openapi.get(key),
             )
-            return CadwynSchemaFieldWasRemovedChangelogEntry(models=affected_model_names, field=instruction.name)
-        case FieldDidntExistInstruction():
-            model = generator_from_newer_version[instruction.schema]
-            affected_model_names = _get_affected_model_names(
-                instruction, generator_from_newer_version, schemas_from_older_version
+            for key, old_value in older_field_openapi.items()
+            if old_value != newer_field_openapi.get(key)
+        ]
+        attribute_changes += [
+            CadwynAttributeChange(
+                name=key,
+                status=CadwynAttributeChangeStatus.added,
+                old_value=None,
+                new_value=new_value,
             )
+            for key, new_value in newer_field_openapi.items()
+            if key not in older_field_openapi
+        ]
+
+        return CadwynFieldAttributesWereChangedChangelogEntry(
+            models=_get_affected_model_names(instruction, generator_from_newer_version, schemas_from_older_version),
+            field=old_field_name,
+            attribute_changes=attribute_changes,
+        )
+    elif isinstance(instruction, EnumDidntHaveMembersInstruction):
+        enum = generator_from_newer_version._get_wrapper_for_model(instruction.enum)
 
-            return CadwynSchemaFieldWasAddedChangelogEntry(
-                models=affected_model_names,
-                field=instruction.name,
-                field_info=_get_openapi_representation_of_a_field(model, instruction.name),
-            )
-        case _:  # pragma: no cover
-            _logger.warning(
-                "Encountered an unknown instruction. "
-                "This should not have happened. "
-                "Please, contact the author and show him this message and your version bundle: %s.",
-                instruction,
-            )
-            return None
+        return CadwynEnumMembersWereAddedChangelogEntry(
+            enum=enum.name,
+            members=[CadwynEnumMember(name=name, value=value) for name, value in enum.members.items()],
+        )
+    elif isinstance(instruction, EnumHadMembersInstruction):
+        new_enum = generator_from_newer_version[instruction.enum]
+        old_enum = generator_from_older_version[instruction.enum]
+
+        return CadwynEnumMembersWereChangedChangelogEntry(
+            enum=new_enum.__name__,
+            member_changes=[
+                CadwynAttributeChange(
+                    name=name,
+                    old_value=old_enum.__members__.get(name),
+                    new_value=new_enum.__members__.get(name),
+                    status=CadwynAttributeChangeStatus.changed
+                    if name in new_enum.__members__
+                    else CadwynAttributeChangeStatus.removed,
+                )
+                for name in instruction.members
+            ],
+        )
+    elif isinstance(instruction, SchemaHadInstruction):
+        model = generator_from_newer_version._get_wrapper_for_model(instruction.schema)
+
+        return CadwynSchemaWasChangedChangelogEntry(
+            model=instruction.name, modified_attributes=CadwynModelModifiedAttributes(name=model.name)
+        )
+    elif isinstance(instruction, FieldExistedAsInstruction):
+        affected_model_names = _get_affected_model_names(
+            instruction, generator_from_newer_version, schemas_from_older_version
+        )
+        return CadwynSchemaFieldWasRemovedChangelogEntry(models=affected_model_names, field=instruction.name)
+    elif isinstance(instruction, FieldDidntExistInstruction):
+        model = generator_from_newer_version[instruction.schema]
+        affected_model_names = _get_affected_model_names(
+            instruction, generator_from_newer_version, schemas_from_older_version
+        )
+
+        return CadwynSchemaFieldWasAddedChangelogEntry(
+            models=affected_model_names,
+            field=instruction.name,
+            field_info=_get_openapi_representation_of_a_field(model, instruction.name),
+        )
+    else:  # pragma: no cover
+        _logger.warning(
+            "Encountered an unknown instruction. "
+            "This should not have happened. "
+            "Please, contact the author and show him this message and your version bundle: %s.",
+            instruction,
+        )
+        return None

cadwyn/middleware.py

@@ -5,7 +5,7 @@ import inspect
 import re
 from collections.abc import Awaitable, Callable
 from contextvars import ContextVar
-from typing import Annotated, Any, Literal, Protocol
+from typing import Annotated, Any, Literal, Protocol, Union
 
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware, DispatchFunction, RequestResponseEndpoint
@@ -15,7 +15,7 @@ from cadwyn.structure.common import VersionType
 
 
 class VersionManager(Protocol):
-    def get(self, request: Request) -> str | None: ...
+    def get(self, request: Request) -> Union[str, None]: ...
 
 
 VersionValidatorC = Callable[[str], VersionType]
@@ -32,7 +32,7 @@ class HeaderVersionManager:
         super().__init__()
         self.api_version_parameter_name = api_version_parameter_name
 
-    def get(self, request: Request) -> str | None:
+    def get(self, request: Request) -> Union[str, None]:
         return request.headers.get(self.api_version_parameter_name)
 
 
@@ -44,7 +44,7 @@ class URLVersionManager:
         self.possible_version_values = possible_version_values
         self.url_version_regex = re.compile(f"/({'|'.join(re.escape(v) for v in possible_version_values)})/")
 
-    def get(self, request: Request) -> str | None:
+    def get(self, request: Request) -> Union[str, None]:
         if m := self.url_version_regex.search(request.url.path):
             return m.group(1)
         return None
@@ -81,10 +81,10 @@ class VersionPickingMiddleware(BaseHTTPMiddleware):
         app: ASGIApp,
         *,
         api_version_parameter_name: str,
-        api_version_default_value: str | None | Callable[[Request], Awaitable[str]],
-        api_version_var: ContextVar[VersionType | None],
+        api_version_default_value: Union[str, None, Callable[[Request], Awaitable[str]]],
+        api_version_var: ContextVar[Union[VersionType, None]],
         api_version_manager: VersionManager,
-        dispatch: DispatchFunction | None = None,
+        dispatch: Union[DispatchFunction, None] = None,
     ) -> None:
         super().__init__(app, dispatch)
 

cadwyn/route_generation.py

@@ -7,6 +7,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
+    Union,
     cast,
 )
 
@@ -21,7 +22,7 @@ from pydantic import BaseModel
 from starlette.routing import BaseRoute
 from typing_extensions import TypeVar, assert_never
 
-from cadwyn._utils import Sentinel
+from cadwyn._utils import DATACLASS_SLOTS, Sentinel
 from cadwyn.exceptions import (
     CadwynError,
     RouteAlreadyExistsError,
@@ -54,13 +55,13 @@ _RouteT = TypeVar("_RouteT", bound=BaseRoute)
 _DELETED_ROUTE_TAG = "_CADWYN_DELETED_ROUTE"
 
 
-@dataclass(slots=True, frozen=True, eq=True)
+@dataclass(**DATACLASS_SLOTS, frozen=True, eq=True)
 class _EndpointInfo:
     endpoint_path: str
     endpoint_methods: frozenset[str]
 
 
-@dataclass(slots=True, frozen=True)
+@dataclass(**DATACLASS_SLOTS, frozen=True)
 class GeneratedRouters(Generic[_R, _WR]):
     endpoints: dict[VersionType, _R]
     webhooks: dict[VersionType, _WR]
@@ -70,7 +71,7 @@ def generate_versioned_routers(
     router: _R,
     versions: VersionBundle,
     *,
-    webhooks: _WR | None = None,
+    webhooks: Union[_WR, None] = None,
 ) -> GeneratedRouters[_R, _WR]:
     if webhooks is None:
         webhooks = cast(_WR, APIRouter())
@@ -275,7 +276,7 @@ class _EndpointTransformer(Generic[_R, _WR]):
     # TODO (https://github.com/zmievsa/cadwyn/issues/28): Simplify
     def _apply_endpoint_changes_to_router(  # noqa: C901
         self,
-        routes: list[BaseRoute] | list[APIRoute],
+        routes: Union[list[BaseRoute], list[APIRoute]],
         version: Version,
     ):
         for version_change in version.changes:
@@ -409,8 +410,8 @@ def _validate_no_repetitions_in_routes(routes: list[fastapi.routing.APIRoute]):
 def _add_data_migrations_to_route(
     route: APIRoute,
     head_route: Any,
-    template_body_field: type[BaseModel] | None,
-    template_body_field_name: str | None,
+    template_body_field: Union[type[BaseModel], None],
+    template_body_field_name: Union[str, None],
     dependant_for_request_migrations: "Dependant",
     versions: VersionBundle,
 ):
@@ -469,7 +470,7 @@ def _get_routes(
     routes: Sequence[BaseRoute],
     endpoint_path: str,
     endpoint_methods: set[str],
-    endpoint_func_name: str | None = None,
+    endpoint_func_name: Union[str, None] = None,
     *,
     is_deleted: bool = False,
 ) -> list[fastapi.routing.APIRoute]:
@@ -490,7 +491,7 @@ def _get_routes(
 def _get_route_from_func(
     routes: Sequence[BaseRoute],
     endpoint: Endpoint,
-) -> fastapi.routing.APIRoute | None:
+) -> Union[fastapi.routing.APIRoute, None]:
     for route in routes:
         if isinstance(route, fastapi.routing.APIRoute) and (route.endpoint == endpoint):
             return route

cadwyn/routing.py

@@ -3,7 +3,7 @@ from collections.abc import Sequence
 from contextvars import ContextVar
 from functools import cached_property
 from logging import getLogger
-from typing import Any
+from typing import Any, Union
 
 from fastapi.routing import APIRouter
 from starlette.datastructures import URL
@@ -23,7 +23,7 @@ class _RootCadwynAPIRouter(APIRouter):
         self,
         *args: Any,
         api_version_parameter_name: str,
-        api_version_var: ContextVar[str | None],
+        api_version_var: ContextVar[Union[str, None]],
         api_version_format: APIVersionFormat,
         **kwargs: Any,
     ):