misc pylint refactoring

Author: Archmonger

src/reactpy_django/hooks.py

@@ -103,8 +103,8 @@ def use_connection() -> ConnectionType:
 
 def use_query(
     query: Callable[FuncParams, Awaitable[Inferred]] | Callable[FuncParams, Inferred],
-    *,
     kwargs: dict[str, Any] | None = None,
+    *,
     thread_sensitive: bool = True,
     postprocessor: (
         AsyncPostprocessor | SyncPostprocessor | None
@@ -116,6 +116,8 @@ def use_query(
 
     Args:
         query: A callable that returns a Django `Model` or `QuerySet`.
+
+    Kwargs:
         kwargs: Keyword arguments to passed into the `query` function.
         thread_sensitive: Whether to run the query in thread-sensitive mode. \
             This setting only applies to sync query functions.
@@ -153,8 +155,7 @@ async def execute_query() -> None:
                 new_data = await query(**kwargs)
             else:
                 new_data = await database_sync_to_async(
-                    query,
-                    thread_sensitive=thread_sensitive,
+                    query, thread_sensitive=thread_sensitive
                 )(**kwargs)
 
             # Run the postprocessor
@@ -171,7 +172,7 @@ async def execute_query() -> None:
             set_data(cast(Inferred, None))
             set_loading(False)
             set_error(e)
-            _logger.exception(f"Failed to execute query: {generate_obj_name(query)}")
+            _logger.exception("Failed to execute query: %s", generate_obj_name(query))
             return
 
         # Query was successful
@@ -228,6 +229,8 @@ def use_mutation(
         mutation: A callable that performs Django ORM create, update, or delete \
             functionality. If this function returns `False`, then your `refetch` \
             function will not be used.
+
+    Kwargs:
         thread_sensitive: Whether to run the mutation in thread-sensitive mode. \
             This setting only applies to sync mutation functions.
         refetch:  A query function (the function you provide to your `use_query` \
@@ -259,7 +262,7 @@ async def execute_mutation(exec_args, exec_kwargs) -> None:
             set_loading(False)
             set_error(e)
             _logger.exception(
-                f"Failed to execute mutation: {generate_obj_name(mutation)}"
+                "Failed to execute mutation: %s", generate_obj_name(mutation)
             )
 
         # Mutation was successful

src/reactpy_django/utils.py

@@ -29,19 +29,19 @@
 )
 
 _logger = logging.getLogger(__name__)
-_component_tag = r"(?P<tag>component)"
-_component_path = r"""(?P<path>"[^"'\s]+"|'[^"'\s]+')"""
-_component_offline_kwarg = (
-    rf"""(\s*offline\s*=\s*{_component_path.replace(r"<path>", r"<offline_path>")})"""
+_TAG_PATTERN = r"(?P<tag>component)"
+_PATH_PATTERN = r"""(?P<path>"[^"'\s]+"|'[^"'\s]+')"""
+_OFFLINE_KWARG_PATTERN = (
+    rf"""(\s*offline\s*=\s*{_PATH_PATTERN.replace(r"<path>", r"<offline_path>")})"""
 )
-_component_generic_kwarg = r"""(\s*.*?)"""
+_GENERIC_KWARG_PATTERN = r"""(\s*.*?)"""
 COMMENT_REGEX = re.compile(r"<!--[\s\S]*?-->")
 COMPONENT_REGEX = re.compile(
     r"{%\s*"
-    + _component_tag
+    + _TAG_PATTERN
     + r"\s*"
-    + _component_path
-    + rf"({_component_offline_kwarg}|{_component_generic_kwarg})*?"
+    + _PATH_PATTERN
+    + rf"({_OFFLINE_KWARG_PATTERN}|{_GENERIC_KWARG_PATTERN})*?"
     + r"\s*%}"
 )
 
@@ -380,4 +380,4 @@ def strtobool(val):
     elif val in ("n", "no", "f", "false", "off", "0"):
         return 0
     else:
-        raise ValueError("invalid truth value %r" % (val,))
+        raise ValueError(f"invalid truth value {val}")

src/reactpy_django/websocket/consumer.py

@@ -29,6 +29,8 @@
 if TYPE_CHECKING:
     from django.contrib.auth.models import AbstractUser
 
+    from reactpy_django import models
+
 _logger = logging.getLogger(__name__)
 BACKHAUL_LOOP = asyncio.new_event_loop()
 
@@ -47,9 +49,18 @@ def start_backhaul_loop():
 class ReactpyAsyncWebsocketConsumer(AsyncJsonWebsocketConsumer):
     """Communicates with the browser to perform actions on-demand."""
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # New WebsocketConsumer attributes created by ReactPy
+        self.dispatcher: Future | asyncio.Task
+        self.threaded: bool
+        self.recv_queue: asyncio.Queue
+        self.dotted_path: str
+        self.component_session: "models.ComponentSession" | None = None
+
     async def connect(self) -> None:
         """The browser has connected."""
-        from reactpy_django import models
         from reactpy_django.config import (
             REACTPY_AUTH_BACKEND,
             REACTPY_AUTO_RELOGIN,
@@ -79,9 +90,7 @@ async def connect(self) -> None:
                 )
 
         # Start the component dispatcher
-        self.dispatcher: Future | asyncio.Task
         self.threaded = REACTPY_BACKHAUL_THREAD
-        self.component_session: models.ComponentSession | None = None
         if self.threaded:
             if not BACKHAUL_THREAD.is_alive():
                 await asyncio.to_thread(
@@ -149,14 +158,14 @@ async def run_dispatcher(self):
         )
 
         scope = self.scope
-        self.dotted_path = dotted_path = scope["url_route"]["kwargs"]["dotted_path"]
+        self.dotted_path = scope["url_route"]["kwargs"]["dotted_path"]
         uuid = scope["url_route"]["kwargs"].get("uuid")
         has_args = scope["url_route"]["kwargs"].get("has_args")
         scope["reactpy"] = {"id": str(uuid)}
         query_string = parse_qs(scope["query_string"].decode(), strict_parsing=True)
         http_pathname = query_string.get("http_pathname", [""])[0]
         http_search = query_string.get("http_search", [""])[0]
-        self.recv_queue: asyncio.Queue = asyncio.Queue()
+        self.recv_queue = asyncio.Queue()
         connection = Connection(  # For `use_connection`
             scope=scope,
             location=Location(pathname=http_pathname, search=http_search),
@@ -168,11 +177,11 @@ async def run_dispatcher(self):
 
         # Verify the component has already been registered
         try:
-            root_component_constructor = REACTPY_REGISTERED_COMPONENTS[dotted_path]
+            root_component_constructor = REACTPY_REGISTERED_COMPONENTS[self.dotted_path]
         except KeyError:
             await asyncio.to_thread(
                 _logger.warning,
-                f"Attempt to access invalid ReactPy component: {dotted_path!r}",
+                f"Attempt to access invalid ReactPy component: {self.dotted_path!r}",
             )
             return
 
@@ -194,7 +203,7 @@ async def run_dispatcher(self):
         except models.ComponentSession.DoesNotExist:
             await asyncio.to_thread(
                 _logger.warning,
-                f"Component session for '{dotted_path}:{uuid}' not found. The "
+                f"Component session for '{self.dotted_path}:{uuid}' not found. The "
                 "session may have already expired beyond REACTPY_SESSION_MAX_AGE. "
                 "If you are using a custom `host`, you may have forgotten to provide "
                 "args/kwargs.",