make concurrent renders configurable

Author: rmorshea

docs/source/about/changelog.rst

@@ -28,6 +28,14 @@ Unreleased
 - :pull:`1118` - `module_from_template` is broken with a recent release of `requests`
 - :pull:`1131` - `module_from_template` did not work when using Flask backend
 
+**Added**
+
+- :pull:`1093` - Better async effects (see :ref:`Async Effects`)
+- :pull:`1093` - Support concurrent renders - multiple components are now able to render
+  simultaneously. This is a significant change to the underlying rendering logic and
+  should be considered experimental. You can enable this feature by setting
+  ``REACTPY_FEATURE_CONCURRENT_RENDER=1`` when running ReactPy.
+
 
 v1.0.2
 ------

src/py/reactpy/reactpy/config.py

@@ -88,3 +88,11 @@ def boolean(value: str | bool | int) -> bool:
     validator=float,
 )
 """The default amount of time to wait for an effect to complete"""
+
+REACTPY_CONCURRENT_RENDERING = Option(
+    "REACTPY_CONCURRENT_RENDERING",
+    default=False,
+    mutable=True,
+    validator=boolean,
+)
+"""Whether to render components concurrently. This is currently an experimental feature."""

src/py/reactpy/reactpy/core/_life_cycle_hook.py

@@ -94,7 +94,6 @@ class LifeCycleHook:
         "_effect_funcs",
         "_effect_starts",
         "_effect_stops",
-        "_is_rendering",
         "_render_access",
         "_rendered_atleast_once",
         "_schedule_render_callback",
@@ -112,7 +111,6 @@ def __init__(
         self._context_providers: dict[Context[Any], ContextProviderType[Any]] = {}
         self._schedule_render_callback = schedule_render
         self._schedule_render_later = False
-        self._is_rendering = False
         self._rendered_atleast_once = False
         self._current_state_index = 0
         self._state: tuple[Any, ...] = ()
@@ -121,7 +119,7 @@ def __init__(
         self._render_access = Semaphore(1)  # ensure only one render at a time
 
     def schedule_render(self) -> None:
-        if self._is_rendering:
+        if self._is_rendering():
             self._schedule_render_later = True
         else:
             self._schedule_render()
@@ -153,14 +151,12 @@ async def affect_component_will_render(self, component: ComponentType) -> None:
         """The component is about to render"""
         await self._render_access.acquire()
         self.component = component
-        self._is_rendering = True
         self.set_current()
 
     async def affect_component_did_render(self) -> None:
         """The component completed a render"""
         self.unset_current()
         del self.component
-        self._is_rendering = False
         self._rendered_atleast_once = True
         self._current_state_index = 0
         self._render_access.release()
@@ -202,6 +198,9 @@ def unset_current(self) -> None:
         if _HOOK_STATE.get().pop() is not self:
             raise RuntimeError("Hook stack is in an invalid state")  # nocov
 
+    def _is_rendering(self) -> bool:
+        return self._render_access.value != 0
+
     def _schedule_render(self) -> None:
         try:
             self._schedule_render_callback()

src/py/reactpy/reactpy/core/layout.py

@@ -27,7 +27,11 @@
 from uuid import uuid4
 from weakref import ref as weakref
 
-from reactpy.config import REACTPY_CHECK_VDOM_SPEC, REACTPY_DEBUG_MODE
+from reactpy.config import (
+    REACTPY_CHECK_VDOM_SPEC,
+    REACTPY_CONCURRENT_RENDERING,
+    REACTPY_DEBUG_MODE,
+)
 from reactpy.core._life_cycle_hook import LifeCycleHook
 from reactpy.core.types import (
     ComponentType,
@@ -112,6 +116,26 @@ async def deliver(self, event: LayoutEventMessage) -> None:
             )
 
     async def render(self) -> LayoutUpdateMessage:
+        if REACTPY_CONCURRENT_RENDERING.current:
+            return await self._concurrent_render()
+        else:  # nocov
+            return await self._serial_render()
+
+    async def _serial_render(self) -> LayoutUpdateMessage:  # nocov
+        """Await the next available render. This will block until a component is updated"""
+        while True:
+            model_state_id = await self._rendering_queue.get()
+            try:
+                model_state = self._model_states_by_life_cycle_state_id[model_state_id]
+            except KeyError:
+                logger.debug(
+                    "Did not render component with model state ID "
+                    f"{model_state_id!r} - component already unmounted"
+                )
+            else:
+                return await self._create_layout_update(model_state)
+
+    async def _concurrent_render(self) -> LayoutUpdateMessage:
         """Await the next available render. This will block until a component is updated"""
         while True:
             render_completed = (

src/py/reactpy/tests/conftest.py

@@ -8,7 +8,7 @@
 from _pytest.config.argparsing import Parser
 from playwright.async_api import async_playwright
 
-from reactpy.config import REACTPY_TESTING_DEFAULT_TIMEOUT
+from reactpy.config import REACTPY_CONCURRENT_RENDERING, REACTPY_TESTING_DEFAULT_TIMEOUT
 from reactpy.testing import (
     BackendFixture,
     DisplayFixture,
@@ -27,6 +27,9 @@ def pytest_addoption(parser: Parser) -> None:
     )
 
 
+REACTPY_CONCURRENT_RENDERING.current = True
+
+
 @pytest.fixture
 async def display(server, page):
     async with DisplayFixture(server, page) as display: