AbstractElement.id is not needed

Author: rmorshea

idom/core/element.py

@@ -1,6 +1,5 @@
 import abc
 import inspect
-from uuid import uuid4
 from functools import wraps
 from typing import TYPE_CHECKING, Dict, Callable, Any, Tuple, Union
 
@@ -30,20 +29,7 @@ def constructor(*args: Any, **kwargs: Any) -> Element:
 
 class AbstractElement(abc.ABC):
 
-    __slots__ = ["_id"]
-
-    if not hasattr(abc.ABC, "__weakref__"):  # pragma: no cover
-        __slots__.append("__weakref__")
-
-    def __init__(self) -> None:
-        # we can't use `id(self)` because IDs are regularly re-used and the layout
-        # relies on unique IDs to determine which elements have been deleted
-        self._id = uuid4().hex
-
-    @property
-    def id(self) -> str:
-        """The unique ID of the element."""
-        return self._id
+    __slots__ = [] if hasattr(abc.ABC, "__weakref__") else ["__weakref__"]
 
     @abc.abstractmethod
     def render(self) -> "VdomDict":
@@ -81,7 +67,6 @@ def __init__(
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
     ) -> None:
-        super().__init__()
         self._function = function
         self._args = args
         self._kwargs = kwargs
@@ -94,6 +79,6 @@ def __repr__(self) -> str:
         args = sig.bind(*self._args, **self._kwargs).arguments
         items = ", ".join(f"{k}={v!r}" for k, v in args.items())
         if items:
-            return f"{self._function.__name__}({self.id}, {items})"
+            return f"{self._function.__name__}:{id(self)}({items})"
         else:
-            return f"{self._function.__name__}({self.id})"
+            return f"{self._function.__name__}:{id(self)}()"

idom/core/layout.py

@@ -40,9 +40,10 @@ class LayoutEvent(NamedTuple):
 class ElementState(NamedTuple):
     model: Dict[str, Any]
     path: str
+    element_id: int
     element_obj: AbstractElement
     event_handler_ids: Set[str]
-    child_elements_ids: List[str]
+    child_elements_ids: List[int]
     life_cycle_hook: LifeCycleHook
 
 
@@ -80,7 +81,7 @@ async def dispatch(self, event: LayoutEvent) -> None:
     async def render(self) -> LayoutUpdate:
         while True:
             element = await self._rendering_queue.get()
-            if element.id in self._element_states:
+            if self._has_element_state(element):
                 return self._create_layout_update(element)
 
     @async_resource
@@ -90,15 +91,15 @@ async def _rendering_queue(self) -> AsyncIterator["_ElementQueue"]:
         yield queue
 
     @async_resource
-    async def _element_states(self) -> AsyncIterator[Dict[str, ElementState]]:
-        root_element_state = self._create_element_state(self.root, "")
+    async def _element_states(self) -> AsyncIterator[Dict[int, ElementState]]:
+        root_element_state = self._create_element_state(self.root, "", save=False)
         try:
-            yield {self.root.id: root_element_state}
+            yield {root_element_state.element_id: root_element_state}
         finally:
             self._delete_element_state(root_element_state)
 
     def _create_layout_update(self, element: AbstractElement) -> LayoutUpdate:
-        element_state = self._element_states[element.id]
+        element_state = self._get_element_state(element)
 
         element_state.life_cycle_hook.element_will_render()
 
@@ -169,10 +170,9 @@ def _render_model_children(
                 resolved_children.append(self._render_model(element_state, child))
             elif isinstance(child, AbstractElement):
                 child_path = f"{element_state.path}/children/{index}"
-                child_state = self._create_element_state(child, child_path)
-                self._element_states[child.id] = child_state
+                child_state = self._create_element_state(child, child_path, save=True)
                 resolved_children.append(self._render_element(child_state))
-                element_state.child_elements_ids.append(child.id)
+                element_state.child_elements_ids.append(id(child))
             else:
                 resolved_children.append(str(child))
         return resolved_children
@@ -201,22 +201,36 @@ def _render_model_event_targets(
 
         return {e: h.serialize() for e, h in handlers.items()}
 
+    def _get_element_state(self, element: AbstractElement) -> ElementState:
+        return self._element_states[id(element)]
+
+    def _has_element_state(self, element: AbstractElement) -> bool:
+        return id(element) in self._element_states
+
     def _create_element_state(
-        self, element: AbstractElement, path: str
+        self,
+        element: AbstractElement,
+        path: str,
+        save: bool,
     ) -> ElementState:
-        return ElementState(
+        element_id = id(element)
+        state = ElementState(
             model={},
             path=path,
+            element_id=element_id,
             element_obj=element,
             event_handler_ids=set(),
             child_elements_ids=[],
             life_cycle_hook=LifeCycleHook(element, self.update),
         )
+        if save:
+            self._element_states[element_id] = state
+        return 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)
-        del self._element_states[element_state.element_obj.id]
+        del self._element_states[element_state.element_id]
 
     def _clear_element_state_event_handlers(self, element_state: ElementState) -> None:
         for handler_id in element_state.event_handler_ids:
@@ -258,15 +272,16 @@ class _ElementQueue:
 
     def __init__(self) -> None:
         self._queue: "asyncio.Queue[AbstractElement]" = asyncio.Queue()
-        self._pending: Set[str] = set()
+        self._pending: Set[int] = set()
 
     def put(self, element: AbstractElement) -> None:
-        if element.id not in self._pending:
-            self._pending.add(element.id)
+        element_id = id(element)
+        if element_id not in self._pending:
+            self._pending.add(element_id)
             self._queue.put_nowait(element)
         return None
 
     async def get(self) -> AbstractElement:
         element = await self._queue.get()
-        self._pending.remove(element.id)
+        self._pending.remove(id(element))
         return element

tests/test_core/test_element.py

@@ -8,7 +8,7 @@ def MyElement(a, *b, **c):
 
     m_e = MyElement(1, 2, 3, x=4, y=5)
 
-    expected = f"MyElement({m_e.id}, a=1, b=(2, 3), c={{'x': 4, 'y': 5}})"
+    expected = f"MyElement:{id(m_e)}(a=1, b=(2, 3), c={{'x': 4, 'y': 5}})"
     assert repr(m_e) == expected
 
 

tests/test_core/test_layout.py

@@ -17,7 +17,7 @@ def MyElement():
 
     my_element = MyElement()
     layout = idom.Layout(my_element)
-    assert str(layout) == f"Layout(MyElement({my_element.id}))"
+    assert str(layout) == f"Layout(MyElement:{id(my_element)}())"
 
 
 def test_layout_expects_abstract_element():
@@ -171,8 +171,8 @@ async def test_elements_are_garbage_collected():
     @outer_element_hook.capture
     def Outer():
         element = idom.hooks.current_hook().element
-        live_elements.add(element.id)
-        finalize(element, live_elements.remove, element.id)
+        live_elements.add(id(element))
+        finalize(element, live_elements.remove, id(element))
 
         hook = idom.hooks.current_hook()
 
@@ -185,8 +185,8 @@ async def force_update():
     @idom.element
     def Inner():
         element = idom.hooks.current_hook().element
-        live_elements.add(element.id)
-        finalize(element, live_elements.remove, element.id)
+        live_elements.add(id(element))
+        finalize(element, live_elements.remove, id(element))
         return idom.html.div()
 
     async with idom.Layout(Outer()) as layout: