no need for raw coro to set/unset current hook

since element updates are processed sequentially and not
in parallel we don't need the dynamic setting/unsetting
or the current hook. in the future we may need to return
to that approach, but for now sequential updates are
simpler, more performant when processing individual updates
(since no logic between each yield), and maybe more aligned
with how React works.

Author: rmorshea

idom/core/layout.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-from types import coroutine
 from typing import (
     List,
     Dict,
@@ -125,8 +124,11 @@ async def _create_layout_update(self, element: AbstractElement) -> LayoutUpdate:
 
     async def _render_element(self, element_state: ElementState) -> Dict[str, Any]:
         try:
-            # BUG: https://github.com/python/mypy/issues/9256
-            raw_model = await _render_with_life_cycle_hook(element_state)  # type: ignore
+            element_state.life_cycle_hook.set_current()
+            try:
+                raw_model = await element_state.element_obj.render()
+            finally:
+                element_state.life_cycle_hook.unset_current()
 
             if isinstance(raw_model, AbstractElement):
                 raw_model = {"tagName": "div", "children": [raw_model]}
@@ -209,10 +211,6 @@ def _create_element_state(
             life_cycle_hook=LifeCycleHook(element, self.update),
         )
 
-    def _reset_element_state(self, element_state: ElementState) -> None:
-        self._clear_element_state_event_handlers(element_state)
-        self._delete_element_state_children(element_state)
-
     def _delete_element_state(self, element_state: ElementState) -> None:
         self._clear_element_state_event_handlers(element_state)
         self._delete_element_state_children(element_state)
@@ -252,26 +250,6 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}({self.root})"
 
 
-@coroutine
-def _render_with_life_cycle_hook(element_state: ElementState) -> Iterator[None]:
-    """Render an element which may use hooks.
-
-    We use a coroutine here because we need to know when control is yielded
-    back to the event loop since it might switch to render a different element.
-    """
-    gen = element_state.element_obj.render().__await__()
-    try:
-        while True:
-            element_state.life_cycle_hook.set_current()
-            value = next(gen)
-            element_state.life_cycle_hook.unset_current()
-            yield value
-    except StopIteration as error:
-        return error.value
-    finally:
-        element_state.life_cycle_hook.unset_current()
-
-
 class _ElementQueue:
 
     __slots__ = "_queue", "_pending"

tests/test_core/test_hooks.py

@@ -1,4 +1,3 @@
-from idom.core.element import element
 import re
 
 import pytest

tests/test_core/test_layout.py

@@ -1,5 +1,6 @@
 import asyncio
 import gc
+import re
 from weakref import finalize
 
 import pytest
@@ -26,6 +27,21 @@ def test_layout_expects_abstract_element():
         idom.Layout(idom.html.div())
 
 
+def test_not_open_layout_update_logs_error(caplog):
+    @idom.element
+    async def Element():
+        ...
+
+    element = Element()
+    layout = idom.Layout(element)
+    layout.update(element)
+
+    assert re.match(
+        "Did not update .*? - resources of .*? are closed",
+        next(iter(caplog.records)).msg,
+    )
+
+
 async def test_simple_layout():
     set_state_hook = idom.Ref(None)
 

tests/test_core/test_render.py

@@ -9,17 +9,6 @@
 from idom.core.render import SharedStateRenderer, AbstractRenderer
 
 
-import asyncio
-from asyncio.exceptions import CancelledError
-
-import pytest
-from anyio.exceptions import ExceptionGroup
-
-import idom
-from idom.core.layout import Layout, LayoutEvent
-from idom.core.render import SharedStateRenderer, AbstractRenderer
-
-
 async def test_shared_state_renderer():
     done = asyncio.Event()
     changes_1 = []
@@ -37,14 +26,14 @@ async def recv_1():
             return events_to_inject.pop(0)
         except IndexError:
             done.set()
-            raise CancelledError()
+            raise asyncio.CancelledError()
 
     async def send_2(patch):
         changes_2.append(patch.changes)
 
     async def recv_2():
         await done.wait()
-        raise CancelledError()
+        raise asyncio.CancelledError()
 
     @idom.element
     async def Clickable():