fastapi-startkit 0.60.0__tar.gz → 0.62.0__tar.gz

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.60.0
+Version: 0.62.0
 Summary: A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console.
 Keywords: fastapi,framework,async,web,asgi,orm,sqlalchemy,pydantic,ioc-container,dependency-injection,service-provider,cli,console,configuration,microservices,starter-kit,boilerplate
 Author: Bedram Tamang
@@ -26,11 +26,13 @@ Requires-Dist: langgraph>=1.0.0 ; extra == 'ai'
 Requires-Dist: faker>=40.13.0 ; extra == 'database'
 Requires-Dist: sqlalchemy[asyncio]>=2.0.38 ; extra == 'database'
 Requires-Dist: fastapi[standard]>=0.124.4 ; extra == 'fastapi'
+Requires-Dist: httpx>=0.28.1 ; extra == 'fastapi'
 Requires-Dist: itsdangerous>=2.2.0 ; extra == 'fastapi'
 Requires-Dist: jinja2>=3.1 ; extra == 'inertia'
 Requires-Dist: markupsafe>=2.0 ; extra == 'inertia'
 Requires-Dist: aiomysql>=0.2.0 ; extra == 'mysql'
 Requires-Dist: asyncpg>=0.29.0 ; extra == 'postgres'
+Requires-Dist: redis>=5.0.1 ; extra == 'redis'
 Requires-Dist: aiosqlite>=0.22.1 ; extra == 'sqlite'
 Requires-Dist: jinja2>=3.1 ; extra == 'vite'
 Requires-Python: >=3.12, <4.0
@@ -45,6 +47,7 @@ Provides-Extra: fastapi
 Provides-Extra: inertia
 Provides-Extra: mysql
 Provides-Extra: postgres
+Provides-Extra: redis
 Provides-Extra: sqlite
 Provides-Extra: vite
 Description-Content-Type: text/markdown

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.60.0"
+version = "0.62.0"
 description = "A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console."
 readme = "README.md"
 keywords = [
@@ -56,6 +56,7 @@ Changelog = "https://github.com/fastapi-startkit/fastapi-startkit-framework/rele
 [project.optional-dependencies]
 fastapi = [
     "fastapi[standard]>=0.124.4",
+    "httpx>=0.28.1",
     "itsdangerous>=2.2.0",
 ]
 database = [
@@ -89,6 +90,9 @@ ai = [
     "langchain-core>=1.0.0",
     "langgraph>=1.0.0",
 ]
+redis = [
+    "redis>=5.0.1",
+]
 
 [dependency-groups]
 dev = [
@@ -110,6 +114,8 @@ dev = [
     "basedpyright>=1.31.4",
     "pyright>=1.1.411",
     "pytest-benchmark>=5.2.3",
+    "redis>=5.0.1",
+    "fakeredis[lua]>=2.26.0",
 ]
 
 

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/src/fastapi_startkit/application.py

@@ -225,10 +225,10 @@ class Application(Container, Generic[TConfig]):
     def add_commands(self, commands: List):
         self.commands.extend(commands)
 
-    def handle_command(self):
+    def handle_command(self) -> int:
         from fastapi_startkit.console import ConsoleApplication
 
-        ConsoleApplication(self).handle()
+        return ConsoleApplication(self).handle()
 
     def run(self, command: str, args: "str | list[str] | None" = None) -> int:
         from cleo.io.inputs.string_input import StringInput

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/src/fastapi_startkit/config/__init__.py

@@ -1 +1,3 @@
 from .app import AppConfig
+
+__all__ = ["AppConfig"]

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/src/fastapi_startkit/console/application.py

@@ -26,5 +26,5 @@ class ConsoleApplication(BaseApplication):
         self.app.exception_manager.report(error)
         super().render_error(error, io)
 
-    def handle(self):
-        self.run()
+    def handle(self) -> int:
+        return self.run()

fastapi_startkit-0.62.0/src/fastapi_startkit/facades/Redis.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Redis(metaclass=Facade):
+    key = "redis"

fastapi_startkit-0.62.0/src/fastapi_startkit/facades/Redis.pyi

@@ -0,0 +1,27 @@
+from collections.abc import Awaitable, Callable, Iterable
+from typing import Any, overload
+
+from redis.asyncio.client import Pipeline
+from redis.asyncio.client import Redis as AsyncRedis
+
+from fastapi_startkit.redis import Connection, RedisManager
+
+class RedisFacade(AsyncRedis):
+    def connection(self, name: str | None = None) -> Connection: ...  # pyright: ignore[reportIncompatibleVariableOverride]
+    def connections(self) -> dict[str, Connection]: ...
+    def extend(self, client: str, factory: Callable[[dict[str, Any]], Any]) -> RedisManager: ...
+    async def purge(self, name: str | None = None) -> None: ...
+    async def disconnect(self) -> None: ...
+    async def command(self, method: str, parameters: Iterable[Any] | None = None) -> Any: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    @overload
+    def pipeline(self, callback: None = None) -> Pipeline: ...
+    @overload
+    def pipeline(self, callback: Callable[[Pipeline], Any]) -> Awaitable[list[Any]]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    @overload
+    def transaction(self, callback: None = None) -> Pipeline: ...
+    @overload
+    def transaction(self, callback: Callable[[Pipeline], Any]) -> Awaitable[list[Any]]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    async def subscribe(self, channels: str | Iterable[str], callback: Callable[[Any, Any], Any]) -> None: ...
+    async def psubscribe(self, patterns: str | Iterable[str], callback: Callable[[Any, Any], Any]) -> None: ...
+
+Redis: RedisFacade

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/src/fastapi_startkit/facades/__init__.py

@@ -15,3 +15,4 @@ from .Dump import Dump
 from .Queue import Queue
 from .Cache import Cache
 from .RateLimiter import RateLimiter
+from .Redis import Redis

{fastapi_startkit-0.60.0 → fastapi_startkit-0.62.0}/src/fastapi_startkit/fastapi/exceptions.py

@@ -64,7 +64,6 @@ class ValidationExceptionHandler:
 
         from starlette.responses import RedirectResponse
 
-        return RedirectResponse(
-            url=request.headers.get("referer", "/"),
-            status_code=303,
-        )
+        from fastapi_startkit.fastapi.referer import same_origin_referer
+
+        return RedirectResponse(url=same_origin_referer(request), status_code=303)

fastapi_startkit-0.62.0/src/fastapi_startkit/fastapi/referer.py

@@ -0,0 +1,17 @@
+from typing import Optional
+from urllib.parse import urlsplit
+
+from starlette.requests import Request
+
+
+def same_origin_referer(request: Optional[Request], fallback: str = "/") -> str:
+    referer = request.headers.get("referer") if request is not None else None
+    if not referer or request is None:
+        return fallback
+    target = urlsplit(referer)
+    if not target.scheme and not target.netloc:
+        return referer if referer.startswith("/") and not referer.startswith("//") else fallback
+    origin = urlsplit(str(request.base_url))
+    if (target.scheme, target.netloc) == (origin.scheme, origin.netloc):
+        return referer
+    return fallback

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/__init__.py

@@ -0,0 +1,21 @@
+from .errors import ValidationErrors
+from .inertia import Inertia
+from .middleware import InertiaMiddleware
+from .props.props import Prop
+from .props.scroll import ScrollMetadata
+from .provider import InertiaProvider
+from .redirect import InertiaRedirect
+from .ssr import HttpSSRGateway, SSRGateway, ViteHotFileGateway
+
+__all__ = [
+    "Inertia",
+    "InertiaMiddleware",
+    "InertiaProvider",
+    "InertiaRedirect",
+    "HttpSSRGateway",
+    "Prop",
+    "SSRGateway",
+    "ScrollMetadata",
+    "ValidationErrors",
+    "ViteHotFileGateway",
+]

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/constant.py

@@ -0,0 +1,13 @@
+class Header:
+    INERTIA = "X-Inertia"
+    INERTIA_VERSION = "X-Inertia-Version"
+    INERTIA_PARTIAL_COMPONENT = "X-Inertia-Partial-Component"
+    INERTIA_LOCATION = "X-Inertia-Location"
+    INERTIA_REDIRECT = "X-Inertia-Redirect"
+    ERROR_BAG = "X-Inertia-Error-Bag"
+    PURPOSE = "Purpose"
+    INERTIA_PARTIAL_DATA = "X-Inertia-Partial-Data"
+    INERTIA_PARTIAL_EXCEPT = "X-Inertia-Partial-Except"
+    INERTIA_RESET = "X-Inertia-Reset"
+    INERTIA_EXCEPT_ONCE_PROPS = "X-Inertia-Except-Once-Props"
+    INERTIA_INFINITE_SCROLL_MERGE_INTENT = "X-Inertia-Infinite-Scroll-Merge-Intent"

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/context.py

@@ -0,0 +1,21 @@
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+from fastapi import Request
+
+current_request: ContextVar[Optional[Request]] = ContextVar("inertia_request", default=None)
+
+
+@dataclass
+class InertiaRequestState:
+    shared_props: dict[str, Any] = field(default_factory=dict)
+    root_view: Optional[str] = None
+    version: Optional[Callable[[], Optional[str]]] = None
+    resolved_version: Optional[str] = None
+    version_resolved: bool = False
+    encrypt_history: Optional[bool] = None
+    session: dict[str, Any] = field(default_factory=dict)
+
+
+current_state: ContextVar[Optional[InertiaRequestState]] = ContextVar("inertia_state", default=None)

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/encoding.py

@@ -0,0 +1,8 @@
+import json
+from typing import Any
+
+HTML_UNSAFE_CHARACTERS = str.maketrans({"<": "\\u003c", ">": "\\u003e", "&": "\\u0026"})
+
+
+def html_safe_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=True).translate(HTML_UNSAFE_CHARACTERS)

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/errors.py

@@ -0,0 +1,60 @@
+from collections.abc import Iterable, Mapping
+from typing import Any, Optional, Self, Union
+
+from fastapi.exceptions import RequestValidationError
+from pydantic import ValidationError
+
+Messages = Union[str, Iterable[str]]
+ErrorsInput = Union["ValidationErrors", Mapping[str, Messages], ValidationError, RequestValidationError]
+
+
+class ValidationErrors:
+    def __init__(self, messages: Optional[Mapping[str, Messages]] = None):
+        self.messages: dict[str, list[str]] = {}
+        if messages:
+            self.merge(messages)
+
+    def add(self, field: str, message: str) -> Self:
+        self.messages.setdefault(field, []).append(message)
+        return self
+
+    def has(self, field: str) -> bool:
+        return bool(self.messages.get(field))
+
+    def first(self, field: str) -> Optional[str]:
+        messages = self.messages.get(field)
+        return messages[0] if messages else None
+
+    def get(self, field: str) -> list[str]:
+        return list(self.messages.get(field, []))
+
+    def merge(self, errors: Union["ValidationErrors", Mapping[str, Messages]]) -> Self:
+        source = errors.messages if isinstance(errors, ValidationErrors) else errors
+        for field, messages in source.items():
+            for message in [messages] if isinstance(messages, str) else messages:
+                self.add(field, message)
+        return self
+
+    def all(self) -> dict[str, list[str]]:
+        return {field: list(messages) for field, messages in self.messages.items()}
+
+    def firsts(self) -> dict[str, str]:
+        return {field: messages[0] for field, messages in self.messages.items() if messages}
+
+    def __bool__(self) -> bool:
+        return any(self.messages.values())
+
+    @classmethod
+    def make(cls, errors: ErrorsInput) -> "ValidationErrors":
+        if isinstance(errors, RequestValidationError):
+            return cls.from_error_list(errors.errors(), skip=1)
+        if isinstance(errors, ValidationError):
+            return cls.from_error_list(errors.errors(), skip=0)
+        return cls(errors.messages if isinstance(errors, ValidationErrors) else errors)
+
+    @classmethod
+    def from_error_list(cls, errors: Iterable[Mapping[str, Any]], skip: int) -> "ValidationErrors":
+        result = cls()
+        for error in errors:
+            result.add(".".join(str(part) for part in error["loc"][skip:]), error["msg"])
+        return result

fastapi_startkit-0.62.0/src/fastapi_startkit/inertia/inertia.py

@@ -0,0 +1,382 @@
+import logging
+from typing import Any, Dict, Iterable, Optional, Union
+from urllib.parse import urlparse
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from starlette.responses import RedirectResponse, Response
+
+from fastapi_startkit.inertia import session
+from fastapi_startkit.inertia.errors import ErrorsInput
+from fastapi_startkit.fastapi.referer import same_origin_referer
+from fastapi_startkit.inertia.redirect import InertiaRedirect
+from fastapi_startkit.inertia.ssr import HttpSSRGateway, SSRGateway, ViteHotFileGateway, is_excepted
+
+from fastapi_startkit.inertia.props.props import OptionalProp, Prop
+from fastapi_startkit.inertia.props.resolver import PropsResolver
+from fastapi_startkit.inertia.props.scroll import ScrollMetadata
+from fastapi_startkit.inertia.constant import Header
+from fastapi_startkit.inertia.context import current_request, current_state
+
+logger = logging.getLogger("fastapi_startkit.inertia")
+
+
+class ResponseFactory:
+    """Holds all Inertia state: app container, root view, shared props, version."""
+
+    def __init__(self):
+        self.root_view: str = "index.html"
+        self.shared_props: dict = {}
+        self.version = None
+        self.ssr_gateway: Optional[SSRGateway] = None
+        self.ssr_enabled: bool = False
+        self.ssr_except_paths: tuple[str, ...] = ()
+        self.encrypt_history_enabled: bool = False
+        self.expose_shared_prop_keys: bool = True
+
+    def set_root_view(self, view: str):
+        self.root_view = view
+
+    def share(self, key: Union[str, Dict[str, Any]], value: Any = None):
+        state = current_state.get()
+        props = state.shared_props if state is not None else self.shared_props
+        if isinstance(key, dict):
+            props.update(key)
+        else:
+            props[key] = value
+
+    def shared(self) -> dict:
+        state = current_state.get()
+        request_props = state.shared_props if state is not None else {}
+        return {**self.shared_props, **request_props}
+
+    def set_version(self, version):
+        self.version = version
+
+    def get_version(self) -> Optional[str]:
+        state = current_state.get()
+        if state is None:
+            return self.resolve_version(self.version)
+        if not state.version_resolved:
+            state.resolved_version = self.resolve_version(self.version if self.version is not None else state.version)
+            state.version_resolved = True
+        return state.resolved_version
+
+    @staticmethod
+    def resolve_version(version) -> Optional[str]:
+        v = version() if callable(version) else version
+        return str(v) if v is not None else None
+
+    def get_root_view(self) -> str:
+        state = current_state.get()
+        if state is not None and state.root_view:
+            return state.root_view
+        return self.root_view
+
+    def set_encrypt_history(self, enabled: bool = True):
+        state = current_state.get()
+        if state is not None:
+            state.encrypt_history = enabled
+        else:
+            self.encrypt_history_enabled = enabled
+
+    def should_encrypt_history(self) -> bool:
+        state = current_state.get()
+        if state is not None and state.encrypt_history is not None:
+            return state.encrypt_history
+        return self.encrypt_history_enabled
+
+    def set_ssr(self, url: Optional[str], timeout: float = 1.0, enabled: bool = True, except_paths: Iterable[str] = ()):
+        gateway = HttpSSRGateway(url, timeout) if url else None
+        self.set_ssr_gateway(gateway, enabled, except_paths)
+
+    def set_ssr_gateway(self, gateway: Optional[SSRGateway], enabled: bool = True, except_paths: Iterable[str] = ()):
+        self.ssr_gateway = gateway
+        self.ssr_enabled = enabled and gateway is not None
+        self.ssr_except_paths = tuple(except_paths)
+
+    async def ssr_healthy(self) -> bool:
+        if not self.ssr_enabled or self.ssr_gateway is None:
+            return False
+        return await self.ssr_gateway.healthy()
+
+    def render(self, component: str, props: dict) -> "InertiaResponse":
+        return InertiaResponse(
+            component=component,
+            shared_props=self.shared(),
+            props=props,
+            root_view=self.get_root_view(),
+            version=self.get_version() or "",
+            ssr_gateway=self.ssr_gateway if self.ssr_enabled else None,
+            ssr_except_paths=self.ssr_except_paths,
+            encrypt_history=self.should_encrypt_history(),
+            expose_shared_prop_keys=self.expose_shared_prop_keys,
+        )
+
+
+class InertiaResponse(Response):
+    def __init__(
+        self,
+        component: str,
+        shared_props: dict,
+        props: dict,
+        root_view: str = "index.html",
+        version: str = "",
+        ssr_gateway: Optional[SSRGateway] = None,
+        ssr_except_paths: Iterable[str] = (),
+        encrypt_history: bool = False,
+        expose_shared_prop_keys: bool = True,
+    ):
+        # Do not call supper().__init__() — body is built lazily in __call__
+        self.background = None  # required by FastAPI's response handling
+        self.component = component
+        self.shared_props = shared_props
+        self.props = props
+        self.root_view = root_view
+        self.version = version
+        self.ssr_gateway = ssr_gateway
+        self.ssr_except_paths = tuple(ssr_except_paths)
+        self.encrypt_history_enabled = encrypt_history
+        self.flash_data: dict = {}
+        self.expose_shared_prop_keys = expose_shared_prop_keys
+
+    def with_(self, key: Union[str, Dict[str, Any]], value: Any = None) -> "InertiaResponse":
+        if isinstance(key, dict):
+            self.props = {**self.props, **key}
+        else:
+            self.props[key] = value
+        return self
+
+    def with_root_view(self, root_view: str) -> "InertiaResponse":
+        self.root_view = root_view
+        return self
+
+    def flash(self, key: Union[str, Dict[str, Any]], value: Any = None) -> "InertiaResponse":
+        self.flash_data.update(key if isinstance(key, dict) else {key: value})
+        return self
+
+    def encrypt_history(self, enabled: bool = True) -> "InertiaResponse":
+        self.encrypt_history_enabled = enabled
+        return self
+
+    def session_metadata(self, request: Request) -> dict:
+        flash = {**(session.pull(request, session.FLASH) or {}), **self.flash_data}
+        metadata: dict = {
+            "encryptHistory": self.encrypt_history_enabled,
+            "clearHistory": bool(session.pull(request, session.CLEAR_HISTORY, False)),
+        }
+        if session.pull(request, session.PRESERVE_FRAGMENT, False):
+            metadata["preserveFragment"] = True
+        if flash:
+            metadata["flash"] = flash
+        return metadata
+
+    async def to_response(self, request: Request):
+        props, metadata = await PropsResolver(request, self.component).resolve(
+            self.shared_props, self.props, self.expose_shared_prop_keys
+        )
+
+        page = {
+            "component": self.component,
+            "props": props,
+            "url": self._get_url(request),
+            "version": self.version,
+            **metadata,
+        }
+        page.update(self.session_metadata(request))
+
+        gateway = self._ssr_gateway_for(request)
+        if gateway is not None:
+            rendered = await self._render_ssr(gateway, page)
+            if rendered:
+                page["ssr"] = rendered
+
+        if request.headers.get(Header.INERTIA):
+            return JSONResponse(
+                content=page,
+                headers={Header.INERTIA: "true"},
+            )
+
+        from fastapi_startkit.application import app as container
+
+        if not container().has("templates"):
+            raise RuntimeError("Inertia requires 'templates' to be bound in the container for initial rendering.")
+
+        return (
+            container()
+            .make("templates")
+            .TemplateResponse(
+                request,
+                self.root_view,
+                {"page": page},
+            )
+        )
+
+    def _ssr_gateway_for(self, request: Request) -> Optional[SSRGateway]:
+        if request.headers.get(Header.INERTIA):
+            return None
+        if is_excepted(urlparse(str(request.url)).path or "/", self.ssr_except_paths):
+            return None
+        return self.ssr_gateway
+
+    async def _render_ssr(self, gateway: SSRGateway, page: dict) -> Optional[dict]:
+        try:
+            return await gateway.render(page)
+        except Exception:
+            logger.warning("Inertia SSR failed, falling back to client-side rendering.", exc_info=True)
+            return None
+
+    def _get_url(self, request: Request) -> str:
+        parsed = urlparse(str(request.url))
+        url = parsed.path
+        if parsed.query:
+            url = f"{url}?{parsed.query}"
+        return url or "/"
+
+    async def __call__(self, scope, receive, send):
+        request = current_request.get()
+        if request is None:
+            raise RuntimeError(
+                "InertiaResponse requires InertiaMiddleware to be registered. "
+                "Add app.add_middleware(InertiaMiddleware) to your bootstrap."
+            )
+        actual_response = await self.to_response(request)
+        await actual_response(scope, receive, send)
+
+
+class Inertia:
+    _instance: Optional[ResponseFactory] = None
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            cls._instance = ResponseFactory()
+        return cls._instance
+
+    @staticmethod
+    def set_root_view(root_view: str):
+        Inertia.instance().set_root_view(root_view)
+
+    @staticmethod
+    def share(key: Union[str, Dict[str, Any]], value: Any = None):
+        Inertia.instance().share(key, value)
+
+    @staticmethod
+    def shared() -> dict:
+        return Inertia.instance().shared()
+
+    @staticmethod
+    def version(version):
+        Inertia.instance().set_version(version)
+
+    @staticmethod
+    def ssr(
+        url: Optional[str] = "http://127.0.0.1:13714",
+        timeout: float = 1.0,
+        enabled: bool = True,
+        except_paths: Iterable[str] = (),
+    ):
+        Inertia.instance().set_ssr(url, timeout, enabled, except_paths)
+
+    @staticmethod
+    def ssr_hot(hot_file: str, timeout: float = 1.0, enabled: bool = True, except_paths: Iterable[str] = ()):
+        Inertia.instance().set_ssr_gateway(ViteHotFileGateway(hot_file, timeout), enabled, except_paths)
+
+    @staticmethod
+    def ssr_gateway(gateway: SSRGateway, enabled: bool = True, except_paths: Iterable[str] = ()):
+        Inertia.instance().set_ssr_gateway(gateway, enabled, except_paths)
+
+    @staticmethod
+    async def ssr_healthy() -> bool:
+        return await Inertia.instance().ssr_healthy()
+
+    @staticmethod
+    def encrypt_history(enabled: bool = True):
+        Inertia.instance().set_encrypt_history(enabled)
+
+    @staticmethod
+    def clear_history():
+        session.clear_history()
+
+    @staticmethod
+    def preserve_fragment():
+        session.preserve_fragment()
+
+    @staticmethod
+    def flash(key: Union[str, Dict[str, Any]], value: Any = None):
+        session.flash(key, value)
+
+    @staticmethod
+    def with_errors(errors: ErrorsInput):
+        session.with_errors(errors)
+
+    @staticmethod
+    def with_errors_in(bag: str, errors: ErrorsInput):
+        session.with_errors(errors, bag)
+
+    @staticmethod
+    def location(url: str) -> Response:
+        request = current_request.get()
+        if request is not None and request.headers.get(Header.INERTIA):
+            return Response(status_code=409, headers={Header.INERTIA_LOCATION: url})
+        return RedirectResponse(url, status_code=302)
+
+    @staticmethod
+    def redirect(url: str, status_code: int = 302) -> InertiaRedirect:
+        return InertiaRedirect(url, status_code=status_code)
+
+    @staticmethod
+    def back(status_code: int = 302) -> InertiaRedirect:
+        return InertiaRedirect(same_origin_referer(current_request.get()), status_code=status_code)
+
+    @staticmethod
+    def back_with_errors(errors: ErrorsInput, bag: Optional[str] = None) -> InertiaRedirect:
+        return Inertia.back().with_errors_in(bag or session.DEFAULT_BAG, errors)
+
+    @staticmethod
+    def get_version() -> Optional[str]:
+        return Inertia.instance().get_version()
+
+    @staticmethod
+    def expose_shared_prop_keys(expose: bool = True):
+        Inertia.instance().expose_shared_prop_keys = expose
+
+    @staticmethod
+    def optional(callback) -> OptionalProp:
+        return OptionalProp(callback)
+
+    @staticmethod
+    def lazy(callback) -> Prop:
+        return Prop(callback)
+
+    @staticmethod
+    def defer(callback, group: str = "default") -> Prop:
+        return Prop(callback).defer(group)
+
+    @staticmethod
+    def always(value) -> Prop:
+        return Prop(value).always()
+
+    @staticmethod
+    def merge(value) -> Prop:
+        return Prop(value).merge()
+
+    @staticmethod
+    def deep_merge(value) -> Prop:
+        return Prop(value).deep_merge()
+
+    @staticmethod
+    def once(callback) -> Prop:
+        return Prop(callback).once()
+
+    @staticmethod
+    def scroll(page, metadata: Optional[ScrollMetadata] = None) -> Prop:
+        return Prop(page).scroll(metadata)
+
+    @staticmethod
+    def scroll_with(callback) -> Prop:
+        return Prop(callback).scroll()
+
+    @staticmethod
+    def render(component: str, props: Optional[Dict[str, Any]] = None) -> InertiaResponse:
+        return Inertia.instance().render(component, props or {})