litestar-vite 0.13.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

litestar_vite/inertia/helpers.py

@@ -1,25 +1,10 @@
-from __future__ import annotations
-
 import inspect
 from collections import defaultdict
-from collections.abc import Mapping
+from collections.abc import Coroutine, Generator, Iterable, Mapping
 from contextlib import contextmanager
 from functools import lru_cache
 from textwrap import dedent
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Coroutine,
-    Dict,
-    Generator,
-    Generic,
-    Iterable,
-    List,
-    TypeVar,
-    cast,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, TypeVar, Union, cast, overload
 
 from anyio.from_thread import BlockingPortal, start_blocking_portal
 from litestar.exceptions import ImproperlyConfiguredException
@@ -41,36 +26,43 @@ StaticT = TypeVar("StaticT", bound=object)
 
 
 @overload
-def lazy(key: str, value_or_callable: None) -> StaticProp[str, None]: ...
+def lazy(key: str, value_or_callable: "None") -> "StaticProp[str, None]": ...
 
 
 @overload
-def lazy(key: str, value_or_callable: T) -> StaticProp[str, T]: ...
+def lazy(key: str, value_or_callable: "T") -> "StaticProp[str, T]": ...
 
 
 @overload
-def lazy(key: str, value_or_callable: Callable[..., None] = ...) -> DeferredProp[str, None]: ...
+def lazy(key: str, value_or_callable: "Callable[..., None]" = ...) -> "DeferredProp[str, None]": ...
 
 
 @overload
-def lazy(key: str, value_or_callable: Callable[..., Coroutine[Any, Any, None]] = ...) -> DeferredProp[str, None]: ...
+def lazy(
+    key: str, value_or_callable: "Callable[..., Coroutine[Any, Any, None]]" = ...
+) -> "DeferredProp[str, None]": ...
 
 
 @overload
 def lazy(
     key: str,
-    value_or_callable: Callable[..., T | Coroutine[Any, Any, T]] = ...,  # pyright: ignore[reportInvalidTypeVarUse]
-) -> DeferredProp[str, T]: ...
+    value_or_callable: "Callable[..., Union[T, Coroutine[Any, Any, T]]]" = ...,  # pyright: ignore[reportInvalidTypeVarUse]
+) -> "DeferredProp[str, T]": ...
 
 
 def lazy(
     key: str,
-    value_or_callable: None
-    | Callable[T_ParamSpec, None | Coroutine[Any, Any, None]]
-    | T
-    | Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] = None,
-) -> StaticProp[str, None] | StaticProp[str, T] | DeferredProp[str, T] | DeferredProp[str, None]:
-    """Wrap an async function to return a DeferredProp."""
+    value_or_callable: "Optional[Union[T, Callable[..., Coroutine[Any, Any, None]], Callable[..., T], Callable[..., Union[T, Coroutine[Any, Any, T]]]]]" = None,
+) -> "Union[StaticProp[str, None], StaticProp[str, T], DeferredProp[str, T], DeferredProp[str, None]]":
+    """Wrap an async function to return a DeferredProp.
+
+    Args:
+        key: The key to store the value under.
+        value_or_callable: The value or callable to store.
+
+    Returns:
+        The wrapped value or callable.
+    """
     if value_or_callable is None:
         return StaticProp[str, None](key=key, value=None)
 
@@ -83,15 +75,15 @@ def lazy(
 class StaticProp(Generic[PropKeyT, StaticT]):
     """A wrapper for static property evaluation."""
 
-    def __init__(self, key: PropKeyT, value: StaticT) -> None:
+    def __init__(self, key: "PropKeyT", value: "StaticT") -> None:
         self._key = key
         self._result = value
 
     @property
-    def key(self) -> PropKeyT:
+    def key(self) -> "PropKeyT":
         return self._key
 
-    def render(self, portal: BlockingPortal | None = None) -> StaticT:
+    def render(self, portal: "Optional[BlockingPortal]" = None) -> "StaticT":
         return self._result
 
 
@@ -99,19 +91,20 @@ class DeferredProp(Generic[PropKeyT, T]):
     """A wrapper for deferred property evaluation."""
 
     def __init__(
-        self, key: PropKeyT, value: Callable[..., None | T | Coroutine[Any, Any, T | None]] | None = None
+        self, key: "PropKeyT", value: "Optional[Callable[..., Optional[Union[T, Coroutine[Any, Any, T]]]]]" = None
     ) -> None:
         self._key = key
         self._value = value
         self._evaluated = False
-        self._result: T | None = None
+        self._result: "Optional[T]" = None
 
     @property
-    def key(self) -> PropKeyT:
+    def key(self) -> "PropKeyT":
         return self._key
 
+    @staticmethod
     @contextmanager
-    def with_portal(self, portal: BlockingPortal | None = None) -> Generator[BlockingPortal, None, None]:
+    def with_portal(portal: "Optional[BlockingPortal]" = None) -> "Generator[BlockingPortal, None, None]":
         if portal is None:
             with start_blocking_portal() as p:
                 yield p
@@ -120,11 +113,11 @@ class DeferredProp(Generic[PropKeyT, T]):
 
     @staticmethod
     def _is_awaitable(
-        v: Callable[..., T | Coroutine[Any, Any, T]],
-    ) -> TypeGuard[Coroutine[Any, Any, T]]:
+        v: "Callable[..., Union[T, Coroutine[Any, Any, T]]]",
+    ) -> "TypeGuard[Coroutine[Any, Any, T]]":
         return inspect.iscoroutinefunction(v)
 
-    def render(self, portal: BlockingPortal | None = None) -> T | None:
+    def render(self, portal: "Optional[BlockingPortal]" = None) -> "Union[T, None]":
         if self._evaluated:
             return self._result
         if self._value is None or not callable(self._value):
@@ -141,7 +134,7 @@ class DeferredProp(Generic[PropKeyT, T]):
             return self._result
 
 
-def is_lazy_prop(value: Any) -> TypeGuard[DeferredProp[Any, Any]]:
+def is_lazy_prop(value: "Any") -> "TypeGuard[Union[DeferredProp[Any, Any], StaticProp[Any, Any]]]":
     """Check if value is a deferred property.
 
     Args:
@@ -153,7 +146,7 @@ def is_lazy_prop(value: Any) -> TypeGuard[DeferredProp[Any, Any]]:
     return isinstance(value, (DeferredProp, StaticProp))
 
 
-def should_render(value: Any, partial_data: set[str] | None = None) -> bool:
+def should_render(value: "Any", partial_data: "Optional[set[str]]" = None) -> "bool":
     """Check if value should be rendered.
 
     Args:
@@ -169,7 +162,7 @@ def should_render(value: Any, partial_data: set[str] | None = None) -> bool:
     return True
 
 
-def is_or_contains_lazy_prop(value: Any) -> bool:
+def is_or_contains_lazy_prop(value: "Any") -> "bool":
     """Check if value is or contains a deferred property.
 
     Args:
@@ -189,13 +182,16 @@ def is_or_contains_lazy_prop(value: Any) -> bool:
     return False
 
 
-def lazy_render(value: T, partial_data: set[str] | None = None, portal: BlockingPortal | None = None) -> T:
+def lazy_render(
+    value: "T", partial_data: "Optional[set[str]]" = None, portal: "Optional[BlockingPortal]" = None
+) -> "T":
     """Filter deferred properties from the value based on partial data.
 
     Args:
         value: The value to filter
         partial_data: Keys for partial rendering
         portal: Optional portal to use for async rendering
+
     Returns:
         The filtered value
     """
@@ -225,9 +221,9 @@ def lazy_render(value: T, partial_data: set[str] | None = None, portal: Blocking
 
 
 def get_shared_props(
-    request: ASGIConnection[Any, Any, Any, Any],
-    partial_data: set[str] | None = None,
-) -> dict[str, Any]:
+    request: "ASGIConnection[Any, Any, Any, Any]",
+    partial_data: "Optional[set[str]]" = None,
+) -> "dict[str, Any]":
     """Return shared session props for a request.
 
     Args:
@@ -240,14 +236,14 @@ def get_shared_props(
     Note:
         Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
     """
-    props: dict[str, Any] = {}
-    flash: dict[str, list[str]] = defaultdict(list)
-    errors: dict[str, Any] = {}
+    props: "dict[str, Any]" = {}
+    flash: "dict[str, list[str]]" = defaultdict(list)
+    errors: "dict[str, Any]" = {}
     error_bag = request.headers.get("X-Inertia-Error-Bag", None)
 
     try:
         errors = request.session.pop("_errors", {})
-        shared_props = cast("Dict[str,Any]", request.session.pop("_shared", {}))
+        shared_props = cast("dict[str,Any]", request.session.pop("_shared", {}))
         inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
 
         # Handle deferred props
@@ -258,7 +254,7 @@ def get_shared_props(
             if should_render(value, partial_data):
                 props[key] = value
 
-        for message in cast("List[Dict[str,Any]]", request.session.pop("_messages", [])):
+        for message in cast("list[dict[str,Any]]", request.session.pop("_messages", [])):
             flash[message["category"]].append(message["message"])
 
         props.update(inertia_plugin.config.extra_static_page_props)
@@ -277,10 +273,10 @@ def get_shared_props(
 
 
 def share(
-    connection: ASGIConnection[Any, Any, Any, Any],
-    key: str,
-    value: Any,
-) -> None:
+    connection: "ASGIConnection[Any, Any, Any, Any]",
+    key: "str",
+    value: "Any",
+) -> "None":
     """Share a value in the session.
 
     Args:
@@ -296,10 +292,10 @@ def share(
 
 
 def error(
-    connection: ASGIConnection[Any, Any, Any, Any],
-    key: str,
-    message: str,
-) -> None:
+    connection: "ASGIConnection[Any, Any, Any, Any]",
+    key: "str",
+    message: "str",
+) -> "None":
     """Set an error message in the session.
 
     Args:
@@ -314,9 +310,9 @@ def error(
         connection.logger.warning(msg)
 
 
-def js_routes_script(js_routes: Routes) -> Markup:
+def js_routes_script(js_routes: "Routes") -> "Markup":
     @lru_cache
-    def _markup_safe_json_dumps(js_routes: str) -> Markup:
+    def _markup_safe_json_dumps(js_routes: "str") -> "Markup":
         js = js_routes.replace("<", "\\u003c").replace(">", "\\u003e").replace("&", "\\u0026").replace("'", "\\u0027")
         return Markup(js)
 

litestar_vite/inertia/middleware.py

@@ -1,6 +1,4 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 
 from litestar import Request
 from litestar.middleware import AbstractMiddleware
@@ -18,7 +16,7 @@ if TYPE_CHECKING:
     from litestar.types import ASGIApp, Receive, Scope, Send
 
 
-async def redirect_on_asset_version_mismatch(request: Request[UserT, AuthT, StateT]) -> InertiaRedirect | None:
+def redirect_on_asset_version_mismatch(request: "Request[UserT, AuthT, StateT]") -> "Optional[InertiaRedirect]":
     if getattr(request, "is_inertia", None) is None:
         return None
     inertia_version = request.headers.get("X-Inertia-Version")
@@ -32,7 +30,7 @@ async def redirect_on_asset_version_mismatch(request: Request[UserT, AuthT, Stat
 
 
 class InertiaMiddleware(AbstractMiddleware):
-    def __init__(self, app: ASGIApp) -> None:
+    def __init__(self, app: "ASGIApp") -> None:
         super().__init__(app)
         self.app = app
 
@@ -43,7 +41,7 @@ class InertiaMiddleware(AbstractMiddleware):
         send: "Send",
     ) -> None:
         request = Request[Any, Any, Any](scope=scope)
-        redirect = await redirect_on_asset_version_mismatch(request)
+        redirect = redirect_on_asset_version_mismatch(request)
         if redirect is not None:
             response = redirect.to_asgi_response(app=None, request=request)  # pyright: ignore[reportUnknownMemberType]
             await response(scope, receive, send)

litestar_vite/inertia/plugin.py

@@ -1,12 +1,12 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, AsyncGenerator
+from typing import TYPE_CHECKING
 
 from anyio.from_thread import start_blocking_portal
 from litestar.plugins import InitPluginProtocol
 
 if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
     from anyio.from_thread import BlockingPortal
     from litestar import Litestar
     from litestar.config.app import AppConfig
@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     from litestar_vite.inertia.config import InertiaConfig
 
 
-def set_js_routes(app: Litestar) -> None:
+def set_js_routes(app: "Litestar") -> "None":
     """Generate the route structure of the application on startup."""
     from litestar_vite.inertia.routes import generate_js_routes
 
@@ -27,7 +27,7 @@ class InertiaPlugin(InitPluginProtocol):
 
     __slots__ = ("_portal", "config")
 
-    def __init__(self, config: InertiaConfig) -> None:
+    def __init__(self, config: "InertiaConfig") -> "None":
         """Initialize ``Inertia``.
 
         Args:
@@ -36,23 +36,36 @@ class InertiaPlugin(InitPluginProtocol):
         self.config = config
 
     @asynccontextmanager
-    async def lifespan(self, app: Litestar) -> AsyncGenerator[None, None]:
-        """Lifespan to ensure the event loop is available."""
+    async def lifespan(self, app: "Litestar") -> "AsyncGenerator[None, None]":
+        """Lifespan to ensure the event loop is available.
+
+        Args:
+            app: The :class:`Litestar <litestar.app.Litestar>` instance.
+
+        Yields:
+            An asynchronous context manager.
+        """
 
         with start_blocking_portal() as portal:
             self._portal = portal
             yield
 
     @property
-    def portal(self) -> BlockingPortal:
+    def portal(self) -> "BlockingPortal":
         """Get the portal."""
         return self._portal
 
-    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+    def on_app_init(self, app_config: "AppConfig") -> "AppConfig":
         """Configure application for use with Vite.
 
         Args:
             app_config: The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
+
+        Raises:
+            ImproperlyConfiguredException: If the Inertia plugin is not properly configured.
+
+        Returns:
+            The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
         """
 
         from litestar.exceptions import ImproperlyConfiguredException

litestar_vite/inertia/request.py

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 from urllib.parse import unquote
 
 from litestar import Request
@@ -25,14 +23,20 @@ if TYPE_CHECKING:
 class InertiaDetails:
     """InertiaDetails holds all the values sent by Inertia client in headers and provide convenient properties."""
 
-    def __init__(self, request: Request[UserT, AuthT, StateT]) -> None:
+    def __init__(self, request: "Request[UserT, AuthT, StateT]") -> None:
         """Initialize :class:`InertiaDetails`"""
         self.request = request
 
-    def _get_header_value(self, name: InertiaHeaders) -> str | None:
+    def _get_header_value(self, name: "InertiaHeaders") -> "Optional[str]":
         """Parse request header
 
         Check for uri encoded header and unquotes it in readable format.
+
+        Args:
+            name: The header name.
+
+        Returns:
+            The header value.
         """
 
         if value := self.request.headers.get(name.value.lower()):
@@ -40,10 +44,16 @@ class InertiaDetails:
             return unquote(value) if is_uri_encoded else value
         return None
 
-    def _get_route_component(self) -> str | None:
+    def _get_route_component(self) -> "Optional[str]":
         """Get the route component.
 
-        Checks for the `component` key within the route  configuration.
+        Checks for the `component` key within the route handler configuration.
+
+        Args:
+            request: The request object.
+
+        Returns:
+            The route component.
         """
         rh = self.request.scope.get("route_handler")  # pyright: ignore[reportUnknownMemberType]
         if rh:
@@ -51,37 +61,65 @@ class InertiaDetails:
         return None
 
     def __bool__(self) -> bool:
-        """Check if request is sent by an Inertia client."""
+        """Check if request is sent by an Inertia client.
+
+        Returns:
+            True if the request is sent by an Inertia client, False otherwise.
+        """
         return self._get_header_value(InertiaHeaders.ENABLED) == "true"
 
     @cached_property
-    def route_component(self) -> str | None:
-        """Partial Data Reload."""
+    def route_component(self) -> "Optional[str]":
+        """Get the route component.
+
+        Returns:
+            The route component.
+        """
         return self._get_route_component()
 
     @cached_property
-    def partial_component(self) -> str | None:
-        """Partial Data Reload."""
+    def partial_component(self) -> "Optional[str]":
+        """Get the partial component.
+
+        Returns:
+            The partial component.
+        """
         return self._get_header_value(InertiaHeaders.PARTIAL_COMPONENT)
 
     @cached_property
-    def partial_data(self) -> str | None:
-        """Partial Data Reload."""
+    def partial_data(self) -> "Optional[str]":
+        """Get the partial data.
+
+        Returns:
+            The partial data.
+        """
         return self._get_header_value(InertiaHeaders.PARTIAL_DATA)
 
     @cached_property
-    def referer(self) -> str | None:
-        """Partial Data Reload."""
+    def referer(self) -> "Optional[str]":
+        """Get the referer.
+
+        Returns:
+            The referer.
+        """
         return self._get_header_value(InertiaHeaders.REFERER)
 
     @cached_property
     def is_partial_render(self) -> bool:
-        """Is Partial Data Reload."""
+        """Check if the request is a partial render.
+
+        Returns:
+            True if the request is a partial render, False otherwise.
+        """
         return bool(self.partial_component == self.route_component and self.partial_data)
 
     @cached_property
     def partial_keys(self) -> list[str]:
-        """Is Partial Data Reload."""
+        """Get the partial keys.
+
+        Returns:
+            The partial keys.
+        """
         return self.partial_data.split(",") if self.partial_data is not None else []
 
 
@@ -90,7 +128,7 @@ class InertiaRequest(Request[UserT, AuthT, StateT]):
 
     __slots__ = ("inertia",)
 
-    def __init__(self, scope: Scope, receive: Receive = empty_receive, send: Send = empty_send) -> None:
+    def __init__(self, scope: "Scope", receive: "Receive" = empty_receive, send: "Send" = empty_send) -> None:
         """Initialize :class:`InertiaRequest`"""
         super().__init__(scope=scope, receive=receive, send=send)
         self.inertia = InertiaDetails(self)
@@ -111,6 +149,6 @@ class InertiaRequest(Request[UserT, AuthT, StateT]):
         return self.inertia.is_partial_render
 
     @property
-    def partial_keys(self) -> set[str]:
+    def partial_keys(self) -> "set[str]":
         """True if the route handler contains an inertia enabled configuration."""
         return set(self.inertia.partial_keys)

litestar_vite/inertia/response.py

@@ -1,14 +1,13 @@
-from __future__ import annotations
-
 import itertools
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from mimetypes import guess_type
 from pathlib import PurePath
 from typing import (
     TYPE_CHECKING,
     Any,
-    Iterable,
+    Optional,
     TypeVar,
+    Union,
     cast,
 )
 from urllib.parse import quote, urlparse, urlunparse
@@ -54,16 +53,16 @@ class InertiaResponse(Response[T]):
         self,
         content: T,
         *,
-        template_name: str | None = None,
-        template_str: str | None = None,
-        background: BackgroundTask | BackgroundTasks | None = None,
-        context: dict[str, Any] | None = None,
-        cookies: ResponseCookies | None = None,
-        encoding: str = "utf-8",
-        headers: ResponseHeaders | None = None,
-        media_type: MediaType | str | None = None,
-        status_code: int = HTTP_200_OK,
-        type_encoders: TypeEncodersMap | None = None,
+        template_name: "Optional[str]" = None,
+        template_str: "Optional[str]" = None,
+        background: "Optional[BackgroundTask | BackgroundTasks]" = None,
+        context: "Optional[dict[str, Any]]" = None,
+        cookies: "Optional[ResponseCookies]" = None,
+        encoding: "str" = "utf-8",
+        headers: "Optional[ResponseHeaders]" = None,
+        media_type: "Optional[Union[MediaType, str]]" = None,
+        status_code: "int" = HTTP_200_OK,
+        type_encoders: "Optional[TypeEncodersMap]" = None,
     ) -> None:
         """Handle the rendering of a given template into a bytes string.
 
@@ -83,6 +82,9 @@ class InertiaResponse(Response[T]):
                 the media type based on the template name. If this fails, fall back to ``text/plain``.
             status_code: A value for the response HTTP status code.
             type_encoders: A mapping of types to callables that transform them into types supported for serialization.
+
+        Raises:
+            ValueError: If both template_name and template_str are provided.
         """
         if template_name and template_str:
             msg = "Either template_name or template_str must be provided, not both."
@@ -107,10 +109,10 @@ class InertiaResponse(Response[T]):
 
     def create_template_context(
         self,
-        request: Request[UserT, AuthT, StateT],
-        page_props: PageProps[T],
-        type_encoders: TypeEncodersMap | None = None,
-    ) -> dict[str, Any]:
+        request: "Request[UserT, AuthT, StateT]",
+        page_props: "PageProps[T]",
+        type_encoders: "Optional[TypeEncodersMap]" = None,
+    ) -> "dict[str, Any]":
         """Create a context object for the template.
 
         Args:
@@ -131,20 +133,20 @@ class InertiaResponse(Response[T]):
             "csrf_input": f'<input type="hidden" name="_csrf_token" value="{csrf_token}" />',
         }
 
-    def to_asgi_response(  # noqa: C901, PLR0912
+    def to_asgi_response(  # noqa: C901
         self,
-        app: Litestar | None,
-        request: Request[UserT, AuthT, StateT],
+        app: "Optional[Litestar]",
+        request: "Request[UserT, AuthT, StateT]",
         *,
-        background: BackgroundTask | BackgroundTasks | None = None,
-        cookies: Iterable[Cookie] | None = None,
-        encoded_headers: Iterable[tuple[bytes, bytes]] | None = None,
-        headers: dict[str, str] | None = None,
-        is_head_response: bool = False,
-        media_type: MediaType | str | None = None,
-        status_code: int | None = None,
-        type_encoders: TypeEncodersMap | None = None,
-    ) -> ASGIResponse:
+        background: "Optional[Union[BackgroundTask, BackgroundTasks]]" = None,
+        cookies: "Optional[Iterable[Cookie]]" = None,
+        encoded_headers: "Optional[Iterable[tuple[bytes, bytes]]]" = None,
+        headers: "Optional[dict[str, str]]" = None,
+        is_head_response: "bool" = False,
+        media_type: "Optional[Union[MediaType, str]]" = None,
+        status_code: "Optional[int]" = None,
+        type_encoders: "Optional[TypeEncodersMap]" = None,
+    ) -> "ASGIResponse":
         if app is not None:
             warn_deprecation(
                 version="2.1",
@@ -262,9 +264,9 @@ class InertiaExternalRedirect(Response[Any]):
 
     def __init__(
         self,
-        request: Request[Any, Any, Any],
-        redirect_to: str,
-        **kwargs: Any,
+        request: "Request[Any, Any, Any]",
+        redirect_to: "str",
+        **kwargs: "Any",
     ) -> None:
         """Initialize external redirect, Set status code to 409 (required by Inertia),
         and pass redirect url.
@@ -283,16 +285,16 @@ class InertiaRedirect(Redirect):
 
     def __init__(
         self,
-        request: Request[Any, Any, Any],
-        redirect_to: str,
-        **kwargs: Any,
+        request: "Request[Any, Any, Any]",
+        redirect_to: "str",
+        **kwargs: "Any",
     ) -> None:
         """Initialize external redirect, Set status code to 409 (required by Inertia),
         and pass redirect url.
         """
         referer = urlparse(request.headers.get("Referer", str(request.base_url)))
         redirect_to = urlunparse(urlparse(redirect_to)._replace(scheme=referer.scheme))
-        super().__init__(
+        super().__init__(  # pyright: ignore[reportUnknownMemberType]
             path=redirect_to,
             status_code=HTTP_307_TEMPORARY_REDIRECT if request.method == "GET" else HTTP_303_SEE_OTHER,
             cookies=request.cookies,
@@ -305,13 +307,13 @@ class InertiaBack(Redirect):
 
     def __init__(
         self,
-        request: Request[Any, Any, Any],
-        **kwargs: Any,
+        request: "Request[Any, Any, Any]",
+        **kwargs: "Any",
     ) -> None:
         """Initialize external redirect, Set status code to 409 (required by Inertia),
         and pass redirect url.
         """
-        super().__init__(
+        super().__init__(  # pyright: ignore[reportUnknownMemberType]
             path=request.headers.get("Referer", str(request.base_url)),
             status_code=HTTP_307_TEMPORARY_REDIRECT if request.method == "GET" else HTTP_303_SEE_OTHER,
             cookies=request.cookies,