Use ensure_async instead of database_sync_to_async

Author: Archmonger

src/reactpy_django/forms/components.py

@@ -4,7 +4,6 @@
 from typing import TYPE_CHECKING, Any, Callable, Union, cast
 from uuid import uuid4
 
-from channels.db import database_sync_to_async
 from django.forms import Form, ModelForm
 from reactpy import component, hooks, html, utils
 from reactpy.core.events import event
@@ -79,7 +78,7 @@ def _django_form(
     async def render_form():
         """Forms must be rendered in an async loop to allow database fields to execute."""
         if submitted_data:
-            await database_sync_to_async(initialized_form.full_clean)()
+            await ensure_async(initialized_form.full_clean, thread_sensitive=thread_sensitive)()
             success = not initialized_form.errors.as_data()
             if success and on_success:
                 await ensure_async(on_success, thread_sensitive=thread_sensitive)(form_event)

src/reactpy_django/hooks.py

@@ -14,7 +14,6 @@
 
 import orjson
 from channels import DEFAULT_CHANNEL_LAYER
-from channels.db import database_sync_to_async
 from channels.layers import InMemoryChannelLayer, get_channel_layer
 from reactpy import use_callback, use_effect, use_memo, use_ref, use_state
 from reactpy import use_connection as _use_connection
@@ -34,7 +33,7 @@
     SyncPostprocessor,
     UserData,
 )
-from reactpy_django.utils import django_query_postprocessor, generate_obj_name, get_pk
+from reactpy_django.utils import django_query_postprocessor, ensure_async, generate_obj_name, get_pk
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Sequence
@@ -138,19 +137,13 @@ async def execute_query() -> None:
         """The main running function for `use_query`"""
         try:
             # Run the query
-            if asyncio.iscoroutinefunction(query):
-                new_data = await query(**kwargs)
-            else:
-                new_data = await database_sync_to_async(query, thread_sensitive=thread_sensitive)(**kwargs)
+            new_data = await ensure_async(query, thread_sensitive=thread_sensitive)(**kwargs)
 
             # Run the postprocessor
             if postprocessor:
-                if asyncio.iscoroutinefunction(postprocessor):
-                    new_data = await postprocessor(new_data, **postprocessor_kwargs)
-                else:
-                    new_data = await database_sync_to_async(postprocessor, thread_sensitive=thread_sensitive)(
-                        new_data, **postprocessor_kwargs
-                    )
+                new_data = await ensure_async(postprocessor, thread_sensitive=thread_sensitive)(
+                    new_data, **postprocessor_kwargs
+                )
 
         # Log any errors and set the error state
         except Exception as e:
@@ -240,12 +233,7 @@ def use_mutation(
     async def execute_mutation(exec_args, exec_kwargs) -> None:
         # Run the mutation
         try:
-            if asyncio.iscoroutinefunction(mutation):
-                should_refetch = await mutation(*exec_args, **exec_kwargs)
-            else:
-                should_refetch = await database_sync_to_async(mutation, thread_sensitive=thread_sensitive)(
-                    *exec_args, **exec_kwargs
-                )
+            should_refetch = await ensure_async(mutation, thread_sensitive=thread_sensitive)(*exec_args, **exec_kwargs)
 
         # Log any errors and set the error state
         except Exception as e:
@@ -444,10 +432,8 @@ async def _get_user_data(user: AbstractUser, default_data: None | dict, save_def
         for key, value in default_data.items():
             if key not in data:
                 new_value: Any = value
-                if asyncio.iscoroutinefunction(value):
-                    new_value = await value()
-                elif callable(value):
-                    new_value = value()
+                if callable(value):
+                    new_value = await ensure_async(value)()
                 data[key] = new_value
                 changed = True
         if changed:

src/reactpy_django/utils.py

@@ -82,17 +82,12 @@ async def render_view(
     if getattr(view, "as_view", None):
         view = view.as_view()
 
-    # Async function view
-    if iscoroutinefunction(view):
-        response = await view(request, *args, **kwargs)
+    # Sync/Async function view
+    response = await ensure_async(view)(request, *args, **kwargs)
 
-    # Sync function view
-    else:
-        response = await database_sync_to_async(view)(request, *args, **kwargs)
-
-    # TemplateView
+    # TemplateView needs an extra render step
     if getattr(response, "render", None):
-        response = await database_sync_to_async(response.render)()
+        response = await ensure_async(response.render)()
 
     return response
 
@@ -565,7 +560,7 @@ def ensure_async(
     def wrapper(*args, **kwargs):
         return (
             func(*args, **kwargs)
-            if inspect.iscoroutinefunction(func)
+            if iscoroutinefunction(func)
             else database_sync_to_async(func, thread_sensitive=thread_sensitive)(*args, **kwargs)
         )
 

src/reactpy_django/websocket/consumer.py

@@ -14,7 +14,6 @@
 import dill
 import orjson
 from channels.auth import login
-from channels.db import database_sync_to_async
 from channels.generic.websocket import AsyncJsonWebsocketConsumer
 from django.utils import timezone
 from reactpy.backend.hooks import ConnectionContext
@@ -23,6 +22,7 @@
 from reactpy.core.serve import serve_layout
 
 from reactpy_django.clean import clean
+from reactpy_django.utils import ensure_async
 
 if TYPE_CHECKING:
     from collections.abc import MutableMapping, Sequence
@@ -80,7 +80,7 @@ async def connect(self) -> None:
                     f"ReactPy websocket authentication has failed!\n{traceback.format_exc()}",
                 )
             try:
-                await database_sync_to_async(self.scope["session"].save)()
+                await ensure_async(self.scope["session"].save)()
             except Exception:
                 await asyncio.to_thread(
                     _logger.error,
@@ -116,7 +116,7 @@ async def disconnect(self, code: int) -> None:
         # Queue a cleanup, if needed
         if REACTPY_CLEAN_INTERVAL is not None:
             try:
-                await database_sync_to_async(clean)()
+                await ensure_async(clean)()
             except Exception:
                 await asyncio.to_thread(
                     _logger.error,