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

litestar_vite/__init__.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from litestar_vite import inertia
 from litestar_vite.config import ViteConfig
 from litestar_vite.loader import ViteAssetLoader

litestar_vite/__metadata__.py

@@ -1,7 +1,5 @@
 """Metadata for the Project."""
 
-from __future__ import annotations
-
 from importlib.metadata import PackageNotFoundError, metadata, version
 
 __all__ = ("__project__", "__version__")

litestar_vite/cli.py

@@ -1,14 +1,9 @@
-from __future__ import annotations
-
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from click import Context, group, option
 from click import Path as ClickPath
-from litestar.cli._utils import (
-    LitestarEnv,
-    LitestarGroup,
-)
+from litestar.cli._utils import LitestarEnv, LitestarGroup  # pyright: ignore[reportPrivateImportUsage]
 
 if TYPE_CHECKING:
     from litestar import Litestar
@@ -89,18 +84,18 @@ def vite_group() -> None:
     is_flag=True,
 )
 def vite_init(
-    ctx: Context,
-    vite_port: int | None,
-    enable_ssr: bool | None,
-    asset_url: str | None,
-    root_path: Path | None,
-    bundle_path: Path | None,
-    resource_path: Path | None,
-    public_path: Path | None,
-    overwrite: bool,
-    verbose: bool,
-    no_prompt: bool,
-    no_install: bool,
+    ctx: "Context",
+    vite_port: "Optional[int]",
+    enable_ssr: "Optional[bool]",
+    asset_url: "Optional[str]",
+    root_path: "Optional[Path]",
+    bundle_path: "Optional[Path]",
+    resource_path: "Optional[Path]",
+    public_path: "Optional[Path]",
+    overwrite: "bool",
+    verbose: "bool",
+    no_prompt: "bool",
+    no_install: "bool",
 ) -> None:  # sourcery skip: low-code-quality
     """Run vite build."""
     import os
@@ -108,9 +103,7 @@ def vite_init(
     from importlib.util import find_spec
     from pathlib import Path
 
-    from litestar.cli._utils import (
-        console,
-    )
+    from litestar.cli._utils import console  # pyright: ignore[reportPrivateImportUsage]
     from rich.prompt import Confirm
 
     from litestar_vite import VitePlugin
@@ -175,7 +168,6 @@ def vite_init(
             )
             install_dir = os.environ.get("VIRTUAL_ENV", sys.prefix)
             console.rule("[yellow]Starting Nodeenv installation process[/]", align="left")
-            console.print(f"Installing Node environment into {install_dir}")
             execute_command(command_to_run=[nodeenv_command, install_dir, "--force", "--quiet"], cwd=root_path)
 
         console.rule("[yellow]Starting package installation process[/]", align="left")
@@ -188,14 +180,14 @@ def vite_init(
     help="Install frontend packages.",
 )
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
-def vite_install(app: Litestar, verbose: bool) -> None:
+def vite_install(app: "Litestar", verbose: "bool") -> None:
     """Run vite build."""
     import os
     import sys
     from importlib.util import find_spec
     from pathlib import Path
 
-    from litestar.cli._utils import console
+    from litestar.cli._utils import console  # pyright: ignore[reportPrivateImportUsage]
 
     from litestar_vite.commands import execute_command
     from litestar_vite.plugin import VitePlugin
@@ -213,7 +205,6 @@ def vite_install(app: Litestar, verbose: bool) -> None:
         )
         install_dir = os.environ.get("VIRTUAL_ENV", sys.prefix)
         console.rule("[yellow]Starting Nodeenv installation process[/]", align="left")
-        console.print("Installing Node environment to %s:", install_dir)
         execute_command(command_to_run=[nodeenv_command, install_dir, "--force", "--quiet"], cwd=plugin.config.root_dir)
 
     console.rule("[yellow]Starting package installation process[/]", align="left")
@@ -226,11 +217,9 @@ def vite_install(app: Litestar, verbose: bool) -> None:
     help="Building frontend assets with Vite.",
 )
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
-def vite_build(app: Litestar, verbose: bool) -> None:
+def vite_build(app: "Litestar", verbose: "bool") -> None:
     """Run vite build."""
-    from litestar.cli._utils import (
-        console,
-    )
+    from litestar.cli._utils import console  # pyright: ignore[reportPrivateImportUsage]
 
     from litestar_vite.commands import execute_command
     from litestar_vite.plugin import VitePlugin, set_environment
@@ -253,11 +242,9 @@ def vite_build(app: Litestar, verbose: bool) -> None:
     help="Serving frontend assets with Vite.",
 )
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
-def vite_serve(app: Litestar, verbose: bool) -> None:
+def vite_serve(app: "Litestar", verbose: "bool") -> None:
     """Run vite serve."""
-    from litestar.cli._utils import (
-        console,
-    )
+    from litestar.cli._utils import console  # pyright: ignore[reportPrivateImportUsage]
 
     from litestar_vite.commands import execute_command
     from litestar_vite.plugin import VitePlugin, set_environment
@@ -289,13 +276,19 @@ def vite_serve(app: Litestar, verbose: bool) -> None:
     show_default=True,
 )
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
-def generate_js_routes(app: Litestar, output: Path, verbose: bool) -> None:
-    """Run vite serve."""
+def generate_js_routes(app: "Litestar", output: "Path", verbose: "bool") -> None:
+    """Run vite serve.
+
+    Args:
+        app: The Litestar application instance.
+        output: The path to the output file.
+        verbose: Whether to enable verbose output.
+
+    Raises:
+        LitestarCLIException: If the output file cannot be written.
+    """
     import msgspec
-    from litestar.cli._utils import (
-        LitestarCLIException,
-        console,
-    )
+    from litestar.cli._utils import LitestarCLIException, console  # pyright: ignore[reportPrivateImportUsage]
     from litestar.serialization import encode_json, get_serializer
 
     from litestar_vite.plugin import VitePlugin, set_environment

litestar_vite/commands.py

@@ -1,26 +1,27 @@
-from __future__ import annotations
-
 import platform
 import subprocess
+from collections.abc import MutableMapping
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, MutableMapping
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
     from jinja2 import Environment, Template
     from litestar import Litestar
 
-VITE_INIT_TEMPLATES: set[str] = {"package.json.j2", "tsconfig.json.j2", "vite.config.ts.j2"}
-DEFAULT_RESOURCES: set[str] = {"styles.css.j2", "main.ts.j2"}
-DEFAULT_DEV_DEPENDENCIES: dict[str, str] = {
-    "typescript": "^5.7.2",
-    "vite": "^6.0.6",
-    "litestar-vite-plugin": "^0.13.0",
-    "@types/node": "^22.10.2",
+VITE_INIT_TEMPLATES: "set[str]" = {"package.json.j2", "tsconfig.json.j2", "vite.config.ts.j2"}
+DEFAULT_RESOURCES: "set[str]" = {"styles.css.j2", "main.ts.j2"}
+DEFAULT_DEV_DEPENDENCIES: "dict[str, str]" = {
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "litestar-vite-plugin": "^0.13.2",
+    "@types/node": "^22.15.3",
 }
-DEFAULT_DEPENDENCIES: dict[str, str] = {"axios": "^1.7.9"}
+DEFAULT_DEPENDENCIES: "dict[str, str]" = {"axios": "^1.9.0"}
 
 
-def to_json(value: Any) -> str:
+def to_json(value: "Any") -> str:
     """Serialize JSON field values.
 
     Args:
@@ -35,15 +36,15 @@ def to_json(value: Any) -> str:
 
 
 def init_vite(
-    app: Litestar,
-    root_path: Path,
-    resource_path: Path,
-    asset_url: str,
-    public_path: Path,
-    bundle_path: Path,
-    enable_ssr: bool,
+    app: "Litestar",
+    root_path: "Path",
+    resource_path: "Path",
+    asset_url: "str",
+    public_path: "Path",
+    bundle_path: "Path",
+    enable_ssr: "bool",
     vite_port: int,
-    hot_file: Path,
+    hot_file: "Path",
     litestar_port: int,
 ) -> None:
     """Initialize a new Vite project.
@@ -61,7 +62,7 @@ def init_vite(
         litestar_port: Port for Litestar server.
     """
     from jinja2 import Environment, FileSystemLoader, select_autoescape
-    from litestar.cli._utils import console
+    from litestar.cli._utils import console  # pyright: ignore[reportPrivateImportUsage]
     from litestar.utils import module_loader
 
     template_path = module_loader.module_to_os_path("litestar_vite.templates")
@@ -70,11 +71,11 @@ def init_vite(
         autoescape=select_autoescape(),
     )
 
-    enabled_templates: set[str] = VITE_INIT_TEMPLATES
-    enabled_resources: set[str] = DEFAULT_RESOURCES
-    dependencies: dict[str, str] = DEFAULT_DEPENDENCIES
-    dev_dependencies: dict[str, str] = DEFAULT_DEV_DEPENDENCIES
-    templates: dict[str, Template] = {
+    enabled_templates: "set[str]" = VITE_INIT_TEMPLATES
+    enabled_resources: "set[str]" = DEFAULT_RESOURCES
+    dependencies: "dict[str, str]" = DEFAULT_DEPENDENCIES
+    dev_dependencies: "dict[str, str]" = DEFAULT_DEV_DEPENDENCIES
+    templates: "dict[str, Template]" = {
         template_name: get_template(environment=vite_template_env, name=template_name)
         for template_name in enabled_templates
     }
@@ -82,7 +83,7 @@ def init_vite(
     # Prepare root_path
     root_path.mkdir(parents=True, exist_ok=True)
     for template_name, template in templates.items():
-        target_file_name = template_name[:-3] if template_name.endswith(".j2") else template_name
+        target_file_name = template_name.removesuffix(".j2")
         target_file_path = root_path / target_file_name
         with target_file_path.open(mode="w") as file:
             console.print(f" * Writing {target_file_name} to {target_file_path!s}")
@@ -90,8 +91,7 @@ def init_vite(
             file.write(
                 template.render(
                     entry_point=[
-                        f"{resource_path!s}/{resource_name[:-3] if resource_name.endswith('.j2') else resource_name}"
-                        for resource_name in enabled_resources
+                        f"{resource_path!s}/{resource_name.removesuffix('.j2')}" for resource_name in enabled_resources
                     ],
                     enable_ssr=enable_ssr,
                     asset_url=asset_url,
@@ -112,27 +112,37 @@ def init_vite(
     (root_path / resource_path).mkdir(parents=True, exist_ok=True)
     for resource_name in enabled_resources:
         template = get_template(environment=vite_template_env, name=resource_name)
-        target_file_name = f"{resource_name[:-3] if resource_name.endswith('.j2') else resource_name}"
+        target_file_name = f"{resource_name.removesuffix('.j2')}"
         target_file_path = root_path / resource_path / target_file_name
         with target_file_path.open(mode="w") as file:
             console.print(
-                f" * Writing {resource_name[:-3] if resource_name.endswith('.j2') else resource_name} to {target_file_path!s}",
+                f" * Writing {resource_name.removesuffix('.j2')} to {target_file_path!s}",
             )
             file.write(template.render())
     console.print("[yellow]Vite initialization completed.[/]")
 
 
 def get_template(
-    environment: Environment,
-    name: str | Template,
-    parent: str | None = None,
-    globals: MutableMapping[str, Any] | None = None,  # noqa: A002
-) -> Template:
+    environment: "Environment",
+    name: "Union[str, Template]",
+    parent: "Optional[str]" = None,
+    globals: "Optional[MutableMapping[str, Any]]" = None,  # noqa: A002
+) -> "Template":
     return environment.get_template(name=name, parent=parent, globals=globals)
 
 
-def execute_command(command_to_run: list[str], cwd: str | Path | None = None) -> subprocess.CompletedProcess[bytes]:
-    """Run Vite in a subprocess."""
+def execute_command(
+    command_to_run: "list[str]", cwd: "Optional[Union[str, Path]]" = None
+) -> "subprocess.CompletedProcess[bytes]":
+    """Run Vite in a subprocess.
+
+    Args:
+        command_to_run: The command to run.
+        cwd: The current working directory.
+
+    Returns:
+        The completed process.
+    """
     kwargs = {}
     if cwd is not None:
         kwargs["cwd"] = Path(cwd)

litestar_vite/config.py

@@ -1,8 +1,7 @@
-from __future__ import annotations
-
 import os
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Union
 
 __all__ = ("ViteConfig",)
 TRUE_VALUES = {"True", "true", "1", "yes", "Y", "T"}
@@ -17,17 +16,17 @@ class ViteConfig:
     'plugins' key.
     """
 
-    bundle_dir: Path | str = field(default="public")
+    bundle_dir: "Union[Path, str]" = field(default="public")
     """Location of the compiled assets from  Vite.
 
     The manifest file will also be found here.
     """
-    resource_dir: Path | str = field(default="resources")
+    resource_dir: "Union[Path, str]" = field(default="resources")
     """The directory where all typescript/javascript source are written.
 
     In a standalone Vue or React application, this would be equivalent to the ``./src`` directory.
     """
-    public_dir: Path | str = field(default="public")
+    public_dir: "Union[Path, str]" = field(default="public")
     """The optional public directory Vite serves assets from.
 
     In a standalone Vue or React application, this would be equivalent to the ``./public`` directory.
@@ -45,9 +44,9 @@ class ViteConfig:
     """Enable HMR for Vite development server."""
     ssr_enabled: bool = False
     """Enable SSR."""
-    ssr_output_dir: Path | str | None = None
+    ssr_output_dir: "Union[Path, str, None]" = None
     """SSR Output path"""
-    root_dir: Path | str | None = None
+    root_dir: "Union[Path, str, None]" = None
     """The is the base path to your application.
 
    In a standalone Vue or React application, this would be equivalent to the top-level project folder containing the ``./src`` directory.

litestar_vite/inertia/_utils.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable
 
@@ -18,43 +16,81 @@ class InertiaHeaders(str, Enum):
     REFERER = "Referer"
 
 
-def get_enabled_header(enabled: bool = True) -> dict[str, Any]:
-    """True if inertia is enabled."""
+def get_enabled_header(enabled: bool = True) -> "dict[str, Any]":
+    """True if inertia is enabled.
+
+    Args:
+        enabled: Whether inertia is enabled.
+
+    Returns:
+        The headers for inertia.
+    """
 
     return {InertiaHeaders.ENABLED.value: "true" if enabled else "false"}
 
 
-def get_version_header(version: str) -> dict[str, Any]:
-    """Return headers for change swap method response."""
+def get_version_header(version: str) -> "dict[str, Any]":
+    """Return headers for change swap method response.
+
+    Args:
+        version: The version of the inertia.
+
+    Returns:
+        The headers for inertia.
+    """
     return {InertiaHeaders.VERSION.value: version}
 
 
-def get_partial_data_header(partial: str) -> dict[str, Any]:
-    """Return headers for a partial data response."""
+def get_partial_data_header(partial: str) -> "dict[str, Any]":
+    """Return headers for a partial data response.
+
+    Args:
+        partial: The partial data.
+
+    Returns:
+        The headers for inertia.
+    """
     return {InertiaHeaders.PARTIAL_DATA.value: partial}
 
 
-def get_partial_component_header(partial: str) -> dict[str, Any]:
-    """Return headers for a partial data response."""
+def get_partial_component_header(partial: str) -> "dict[str, Any]":
+    """Return headers for a partial data response.
+
+    Args:
+        partial: The partial data.
+
+    Returns:
+        The headers for inertia.
+    """
     return {InertiaHeaders.PARTIAL_COMPONENT.value: partial}
 
 
-def get_headers(inertia_headers: InertiaHeaderType) -> dict[str, Any]:
-    """Return headers for Inertia responses."""
+def get_headers(inertia_headers: "InertiaHeaderType") -> "dict[str, Any]":
+    """Return headers for Inertia responses.
+
+    Args:
+        inertia_headers: The inertia headers.
+
+    Raises:
+        ValueError: If the inertia headers are None.
+
+    Returns:
+        The headers for inertia.
+    """
     if not inertia_headers:
         msg = "Value for inertia_headers cannot be None."
         raise ValueError(msg)
-    inertia_headers_dict: dict[str, Callable[..., dict[str, Any]]] = {
+    inertia_headers_dict: "dict[str, Callable[..., dict[str, Any]]]" = {
         "enabled": get_enabled_header,
         "partial_data": get_partial_data_header,
         "partial_component": get_partial_component_header,
         "version": get_version_header,
     }
 
-    header: dict[str, Any] = {}
-    response: dict[str, Any]
-    key: str
-    value: Any
+    header: "dict[str, Any]" = {}
+    response: "dict[str, Any]"
+    key: "str"
+    value: "Any"
 
     for key, value in inertia_headers.items():
         if value is not None:

litestar_vite/inertia/config.py

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, Optional
 
 __all__ = ("InertiaConfig",)
 
@@ -19,11 +17,11 @@ class InertiaConfig:
     """An identifier to use on routes to get the inertia component to render."""
     exclude_from_js_routes_key: str = "exclude_from_routes"
     """An identifier to use on routes to exclude a route from the generated routes typescript file."""
-    redirect_unauthorized_to: str | None = None
+    redirect_unauthorized_to: "Optional[str]" = None
     """Optionally supply a path where unauthorized requests should redirect."""
-    redirect_404: str | None = None
+    redirect_404: "Optional[str]" = None
     """Optionally supply a path where 404 requests should redirect."""
-    extra_static_page_props: dict[str, Any] = field(default_factory=dict)
+    extra_static_page_props: "dict[str, Any]" = field(default_factory=dict)  # pyright: ignore
     """A dictionary of values to automatically add in to page props on every response."""
-    extra_session_page_props: set[str] = field(default_factory=set)
+    extra_session_page_props: "set[str]" = field(default_factory=set)  # pyright: ignore
     """A set of session keys for which the value automatically be added (if it exists) to the response."""

litestar_vite/inertia/exception_handler.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import re
 from typing import TYPE_CHECKING, Any, cast
 
@@ -54,8 +52,16 @@ class _HTTPConflictException(HTTPException):
     status_code: int = HTTP_409_CONFLICT
 
 
-def exception_to_http_response(request: Request[UserT, AuthT, StateT], exc: Exception) -> Response[Any]:
-    """Handler for all exceptions subclassed from HTTPException."""
+def exception_to_http_response(request: "Request[UserT, AuthT, StateT]", exc: "Exception") -> "Response[Any]":
+    """Handler for all exceptions subclassed from HTTPException.
+
+    Args:
+        request: The request object.
+        exc: The exception to handle.
+
+    Returns:
+        The response object.
+    """
     inertia_enabled = getattr(request, "inertia_enabled", False) or getattr(request, "is_inertia", False)
 
     if not inertia_enabled:
@@ -65,14 +71,22 @@ def exception_to_http_response(request: Request[UserT, AuthT, StateT], exc: Exce
             http_exc = _HTTPConflictException  # type: ignore[assignment]
         else:
             http_exc = InternalServerException  # type: ignore[assignment]
-        if request.app.debug and http_exc not in (PermissionDeniedException, NotFoundError):
+        if request.app.debug and http_exc not in {PermissionDeniedException, NotFoundError}:
             return cast("Response[Any]", create_debug_response(request, exc))
         return cast("Response[Any]", create_exception_response(request, http_exc(detail=str(exc.__cause__))))  # pyright: ignore[reportUnknownArgumentType]
     return create_inertia_exception_response(request, exc)
 
 
-def create_inertia_exception_response(request: Request[UserT, AuthT, StateT], exc: Exception) -> Response[Any]:
-    """Create the inertia exception response"""
+def create_inertia_exception_response(request: "Request[UserT, AuthT, StateT]", exc: "Exception") -> "Response[Any]":
+    """Create the inertia exception response.
+
+    Args:
+        request: The request object.
+        exc: The exception to handle.
+
+    Returns:
+        The response object.
+    """
     is_inertia = getattr(request, "is_inertia", False)
     status_code = getattr(exc, "status_code", HTTP_500_INTERNAL_SERVER_ERROR)
     preferred_type = MediaType.HTML if not is_inertia else MediaType.JSON
@@ -94,7 +108,7 @@ def create_inertia_exception_response(request: Request[UserT, AuthT, StateT], ex
         match = FIELD_ERR_RE.search(error_detail)
         field = match.group(1) if match else default_field
         if isinstance(message, dict):
-            error(request, field, error_detail if error_detail else detail)
+            error(request, field, error_detail or detail)
     if status_code in {HTTP_422_UNPROCESSABLE_ENTITY, HTTP_400_BAD_REQUEST}:
         return InertiaBack(request)
     if isinstance(exc, PermissionDeniedException):