hatch fmt

Author: Archmonger

pyproject.toml

@@ -244,6 +244,9 @@ lint.extend-ignore = [
   "S403",    # `dill` module is possibly insecure
   "S301",    # `dill` deserialization is possibly insecure unless using trusted data
   "RUF029",  # Function is declared async but doesn't contain await expression
+  "DOC201",  # `return` is not documented in docstring
+  "DOC501",  # `Exception` is not documented in docstring
+  "S308",    # Django `mark_safe` may expose cross-site scripting vulnerabilities
 ]
 lint.preview = true
 lint.isort.known-first-party = ["reactpy_django", "test_app", "example"]

src/build_scripts/copy_dir.py

@@ -1,9 +1,10 @@
-# ruff: noqa: INP001
 import logging
 import shutil
 import sys
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 
 def copy_files(source: Path, destination: Path) -> None:
     if destination.exists():
@@ -19,15 +20,15 @@ def copy_files(source: Path, destination: Path) -> None:
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
-        logging.error("Script used incorrectly!\nUsage: python copy_dir.py <source_dir> <destination>")
+        logger.error("Script used incorrectly!\nUsage: python copy_dir.py <source_dir> <destination>")
         sys.exit(1)
 
     root_dir = Path(__file__).parent.parent.parent
     src = Path(root_dir / sys.argv[1])
     dest = Path(root_dir / sys.argv[2])
 
     if not src.exists():
-        logging.error("Source directory %s does not exist", src)
+        logger.error("Source directory %s does not exist", src)
         sys.exit(1)
 
     copy_files(src, dest)

src/reactpy_django/checks.py

@@ -9,7 +9,6 @@
 from django.http import HttpRequest
 from django.urls import reverse
 from reactpy import component, hooks, html, utils
-from reactpy.types import Component, Key, VdomDict
 
 from reactpy_django.exceptions import ViewNotRegisteredError
 from reactpy_django.forms.components import _django_form
@@ -26,6 +25,7 @@
 
     from django.forms import Form, ModelForm
     from django.views import View
+    from reactpy.types import Component, Key, VdomDict
 
     from reactpy_django.types import AsyncFormEvent, SyncFormEvent, ViewToComponentConstructor, ViewToIframeConstructor
 
@@ -182,27 +182,27 @@ def _view_to_component(
     args: Sequence | None,
     kwargs: dict | None,
 ):
-    converted_view, set_converted_view = hooks.use_state(cast(Union[VdomDict, None], None))
-    _args: Sequence = args or ()
-    _kwargs: dict = kwargs or {}
+    converted_view, set_converted_view = hooks.use_state(cast("Union[VdomDict, None]", None))
+    args_: Sequence = args or ()
+    kwargs_: dict = kwargs or {}
     if request:
-        _request: HttpRequest = request
+        request_: HttpRequest = request
     else:
-        _request = HttpRequest()
-        _request.method = "GET"
+        request_ = HttpRequest()
+        request_.method = "GET"
     resolved_view: Callable = import_module(view) if isinstance(view, str) else view  # type: ignore
 
     # Render the view render within a hook
     @hooks.use_async_effect(
         dependencies=[
-            json.dumps(vars(_request), default=generate_obj_name),
-            json.dumps([_args, _kwargs], default=generate_obj_name),
+            json.dumps(vars(request_), default=generate_obj_name),
+            json.dumps([args_, kwargs_], default=generate_obj_name),
         ]
     )
     async def _render_view():
         """Render the view in an async hook to avoid blocking the main thread."""
         # Render the view
-        response = await render_view(resolved_view, _request, _args, _kwargs)
+        response = await render_view(resolved_view, request_, args_, kwargs_)
         set_converted_view(
             utils.string_to_reactpy(
                 response.content.decode("utf-8").strip(),

src/reactpy_django/components.py

@@ -56,7 +56,7 @@ def _django_form(
     top_children_count = hooks.use_ref(len(top_children))
     bottom_children_count = hooks.use_ref(len(bottom_children))
     submitted_data, set_submitted_data = hooks.use_state({} or None)
-    rendered_form, set_rendered_form = hooks.use_state(cast(Union[str, None], None))
+    rendered_form, set_rendered_form = hooks.use_state(cast("Union[str, None]", None))
 
     # Initialize the form with the provided data
     validate_form_args(top_children, top_children_count, bottom_children, bottom_children_count, form)
@@ -70,7 +70,7 @@ def _django_form(
     async def render_form():
         """Forms must be rendered in an async loop to allow database fields to execute."""
 
-        _logger.debug(f"Rendering form with submitted data: {submitted_data}")
+        _logger.debug("Rendering form with submitted data: %s", submitted_data)
         try:
             if submitted_data:
                 await ensure_async(initialized_form.full_clean, thread_sensitive=thread_sensitive)()
@@ -89,7 +89,6 @@ async def render_form():
         except Exception:
             _logger.exception("Error during form processing")
 
-
     async def on_submit_callback(new_data: dict[str, Any]):
         """Callback function provided directly to the client side listener. This is responsible for transmitting
         the submitted form data to the server for processing."""

src/reactpy_django/forms/components.py

@@ -3,7 +3,6 @@
 import asyncio
 import logging
 from collections import defaultdict
-from collections.abc import Awaitable
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -39,7 +38,7 @@
 from reactpy_django.utils import django_query_postprocessor, ensure_async, generate_obj_name, get_pk
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Awaitable, Sequence
 
     from channels_redis.core import RedisChannelLayer
     from django.contrib.auth.models import AbstractUser
@@ -124,9 +123,9 @@ def use_query(
     """
 
     should_execute, set_should_execute = use_state(True)
-    data, set_data = use_state(cast(Inferred, None))
+    data, set_data = use_state(cast("Inferred", None))
     loading, set_loading = use_state(True)
-    error, set_error = use_state(cast(Union[Exception, None], None))
+    error, set_error = use_state(cast("Union[Exception, None]", None))
     query_ref = use_ref(query)
     kwargs = kwargs or {}
     postprocessor_kwargs = postprocessor_kwargs or {}
@@ -140,14 +139,14 @@ async def execute_query() -> None:
         try:
             # Run the query
             query_async = cast(
-                Callable[..., Awaitable[Inferred]], ensure_async(query, thread_sensitive=thread_sensitive)
+                "Callable[..., Awaitable[Inferred]]", ensure_async(query, thread_sensitive=thread_sensitive)
             )
             new_data = await query_async(**kwargs)
 
             # Run the postprocessor
             if postprocessor:
                 async_postprocessor = cast(
-                    Callable[..., Awaitable[Any]], ensure_async(postprocessor, thread_sensitive=thread_sensitive)
+                    "Callable[..., Awaitable[Any]]", ensure_async(postprocessor, thread_sensitive=thread_sensitive)
                 )
                 new_data = await async_postprocessor(new_data, **postprocessor_kwargs)
 
@@ -227,7 +226,7 @@ def use_mutation(
     """
 
     loading, set_loading = use_state(False)
-    error, set_error = use_state(cast(Union[Exception, None], None))
+    error, set_error = use_state(cast("Union[Exception, None]", None))
     async_task_refs = use_ref(set())
 
     # The main "running" function for `use_mutation`
@@ -289,7 +288,7 @@ def use_user() -> AbstractUser:
 
 
 def use_user_data(
-    default_data: (None | dict[str, Callable[[], Any] | Callable[[], Awaitable[Any]] | Any]) = None,
+    default_data: (dict[str, Callable[[], Any] | Callable[[], Awaitable[Any]] | Any] | None) = None,
     save_default_data: bool = False,
 ) -> UserData:
     """Get or set user data stored within the REACTPY_DATABASE.
@@ -441,7 +440,7 @@ async def logout(rerender: bool = True) -> None:
     return UseAuthTuple(login=login, logout=logout)
 
 
-async def _get_user_data(user: AbstractUser, default_data: None | dict, save_default_data: bool) -> dict | None:
+async def _get_user_data(user: AbstractUser, default_data: dict | None, save_default_data: bool) -> dict | None:
     """The mutation function for `use_user_data`"""
     from reactpy_django.models import UserDataModel
 

src/reactpy_django/hooks.py

@@ -4,4 +4,4 @@
 CONVERTERS: dict[str, ConversionInfo] = {
     name: {"regex": converter.regex, "func": converter.to_python} for name, converter in get_converters().items()
 }
-CONVERTERS["any"] = {"regex": r".*", "func": str}
+CONVERTERS["any"] = {"regex": r".*", "func": str}

src/reactpy_django/router/converters.py

@@ -1,18 +1,10 @@
 from __future__ import annotations
 
-from django.urls.converters import get_converters
-
-from typing import TYPE_CHECKING
-
 from reactpy_router.resolvers import ReactPyResolver
 
 from reactpy_django.router.converters import CONVERTERS
 
-if TYPE_CHECKING:
-    from reactpy_router.types import Route
-
 
 class DjangoResolver(ReactPyResolver):
-    """A simple route resolver that uses regex to match paths"""
-    param_pattern=r"<(?P<type>\w+:)?(?P<name>\w+)>"
+    param_pattern = r"<(?P<type>\w+:)?(?P<name>\w+)>"
     converters = CONVERTERS

src/reactpy_django/router/resolvers.py

@@ -94,8 +94,8 @@ def component(
     class_ = kwargs.pop("class", "")
     has_args = bool(args or kwargs)
     user_component: ComponentConstructor | None = None
-    _prerender_html = ""
-    _offline_html = ""
+    prerender_html = ""
+    offline_html = ""
 
     # Validate the host
     if host and DJANGO_DEBUG:
@@ -151,7 +151,7 @@ def component(
             )
             _logger.error(msg)
             return failure_context(dotted_path, ComponentCarrierError(msg))
-        _prerender_html = prerender_component(user_component, args, kwargs, uuid, request)
+        prerender_html = prerender_component(user_component, args, kwargs, uuid, request)
 
     # Fetch the offline component's HTML, if requested
     if offline:
@@ -167,7 +167,7 @@ def component(
             )
             _logger.error(msg)
             return failure_context(dotted_path, ComponentCarrierError(msg))
-        _offline_html = prerender_component(offline_component, [], {}, uuid, request)
+        offline_html = prerender_component(offline_component, [], {}, uuid, request)
 
     # Return the template rendering context
     return {
@@ -181,10 +181,11 @@ def component(
         "reactpy_reconnect_max_interval": reactpy_config.REACTPY_RECONNECT_MAX_INTERVAL,
         "reactpy_reconnect_backoff_multiplier": reactpy_config.REACTPY_RECONNECT_BACKOFF_MULTIPLIER,
         "reactpy_reconnect_max_retries": reactpy_config.REACTPY_RECONNECT_MAX_RETRIES,
-        "reactpy_prerender_html": mark_safe(_prerender_html),
-        "reactpy_offline_html": mark_safe(_offline_html),
+        "reactpy_prerender_html": mark_safe(prerender_html),
+        "reactpy_offline_html": mark_safe(offline_html),
     }
 
+
 @register.inclusion_tag("reactpy/pyscript_component.html", takes_context=True)
 def pyscript_component(
     context: template.RequestContext,

src/reactpy_django/templatetags/reactpy.py

@@ -453,7 +453,7 @@ def save_component_params(args, kwargs, uuid) -> None:
 def validate_host(host: str) -> None:
     """Validates the host string to ensure it does not contain a protocol."""
     if "://" in host:
-        protocol = host.split("://")[0]
+        protocol = host.split("://", maxsplit=1)[0]
         msg = f"Invalid host provided to component. Contains a protocol '{protocol}://'."
         _logger.error(msg)
         raise InvalidHostError(msg)