fix 417 and 413

no more use of the id() function to generate unique
IDs for component and event handlers within the layout.

also includes a minor change to use a protocol (rather than
inheritance) for the component base-class. isinstance()
will not be a perfect check of type compatibility, but it
should be close enough

Author: rmorshea

docs/source/auto/api-reference.rst

@@ -58,9 +58,6 @@ API Reference
 Misc Modules
 ------------
 
-.. automodule:: idom.core.utils
-    :members:
-
 .. automodule:: idom.server.proto
     :members:
 

noxfile.py

@@ -122,7 +122,6 @@ def test_suite(session: Session) -> None:
         session.log("Coverage won't be checked")
         session.install(".[all]")
     else:
-        session.log("Coverage will be checked")
         posargs += ["--cov=src/idom", "--cov-report", "term"]
         install_idom_dev(session, extras="all")
 

src/idom/core/component.py

@@ -9,13 +9,15 @@
 import inspect
 from functools import wraps
 from typing import Any, Callable, Dict, Optional, Tuple, Union
+from uuid import uuid4
+
+from typing_extensions import Protocol, runtime_checkable
 
-from .utils import hex_id
 from .vdom import VdomDict
 
 
-ComponentConstructor = Callable[..., "AbstractComponent"]
-ComponentRenderFunction = Callable[..., Union["AbstractComponent", VdomDict]]
+ComponentConstructor = Callable[..., "ComponentType"]
+ComponentRenderFunction = Callable[..., Union["ComponentType", VdomDict]]
 
 
 def component(function: ComponentRenderFunction) -> Callable[..., "Component"]:
@@ -32,23 +34,22 @@ def constructor(*args: Any, key: Optional[Any] = None, **kwargs: Any) -> Compone
     return constructor
 
 
-class AbstractComponent(abc.ABC):
-
-    __slots__ = ["key"]
-    if not hasattr(abc.ABC, "__weakref__"):
-        __slots__.append("__weakref__")  # pragma: no cover
+@runtime_checkable
+class ComponentType(Protocol):
+    """The expected interface for all component-like objects"""
 
+    id: str
     key: Optional[Any]
 
     @abc.abstractmethod
     def render(self) -> VdomDict:
         """Render the component's :class:`VdomDict`."""
 
 
-class Component(AbstractComponent):
+class Component:
     """An object for rending component models."""
 
-    __slots__ = "_func", "_args", "_kwargs"
+    __slots__ = "__weakref__", "_func", "_args", "_kwargs", "id", "key"
 
     def __init__(
         self,
@@ -57,16 +58,17 @@ def __init__(
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
     ) -> None:
-        self.key = key
-        self._func = function
         self._args = args
+        self._func = function
         self._kwargs = kwargs
+        self.id = uuid4().hex
+        self.key = key
         if key is not None:
             kwargs["key"] = key
 
     def render(self) -> VdomDict:
         model = self._func(*self._args, **self._kwargs)
-        if isinstance(model, AbstractComponent):
+        if isinstance(model, ComponentType):
             model = {"tagName": "div", "children": [model]}
         return model
 
@@ -79,6 +81,6 @@ def __repr__(self) -> str:
         else:
             items = ", ".join(f"{k}={v!r}" for k, v in args.items())
             if items:
-                return f"{self._func.__name__}({hex_id(self)}, {items})"
+                return f"{self._func.__name__}({self.id}, {items})"
             else:
-                return f"{self._func.__name__}({hex_id(self)})"
+                return f"{self._func.__name__}({self.id})"

src/idom/core/events.py

@@ -14,6 +14,7 @@
     Optional,
     Union,
 )
+from uuid import uuid4
 
 from anyio import create_task_group
 
@@ -149,17 +150,19 @@ class EventHandler:
         "_func_handlers",
         "prevent_default",
         "stop_propagation",
+        "target",
     )
 
     def __init__(
         self,
         stop_propagation: bool = False,
         prevent_default: bool = False,
     ) -> None:
-        self.stop_propagation = stop_propagation
-        self.prevent_default = prevent_default
         self._coro_handlers: List[Callable[..., Coroutine[Any, Any, Any]]] = []
         self._func_handlers: List[Callable[..., Any]] = []
+        self.prevent_default = prevent_default
+        self.stop_propagation = stop_propagation
+        self.target = uuid4().hex
 
     def add(self, function: Callable[..., Any]) -> "EventHandler":
         """Add a callback function or coroutine to the event handler.
@@ -205,3 +208,8 @@ def __contains__(self, function: Any) -> bool:
             return function in self._coro_handlers
         else:
             return function in self._func_handlers
+
+    def __repr__(self) -> str:
+        public_names = [name for name in self.__slots__ if not name.startswith("_")]
+        items = ", ".join([f"{n}={getattr(self, n)!r}" for n in public_names])
+        return f"{type(self).__name__}({items})"

src/idom/core/hooks.py

@@ -31,7 +31,7 @@
 import idom
 from idom.utils import Ref
 
-from .component import AbstractComponent
+from .component import ComponentType
 
 
 __all__ = [
@@ -393,7 +393,7 @@ class LifeCycleHook:
     def __init__(
         self,
         layout: idom.core.layout.Layout,
-        component: AbstractComponent,
+        component: ComponentType,
     ) -> None:
         self.component = component
         self._layout = weakref.ref(layout)

src/idom/core/layout.py

@@ -17,10 +17,9 @@
 
 from idom.config import IDOM_DEBUG_MODE, IDOM_FEATURE_INDEX_AS_DEFAULT_KEY
 
-from .component import AbstractComponent
+from .component import ComponentType
 from .events import EventHandler
 from .hooks import LifeCycleHook
-from .utils import hex_id
 from .vdom import validate_vdom
 
 
@@ -67,24 +66,24 @@ class Layout:
     if not hasattr(abc.ABC, "__weakref__"):  # pragma: no cover
         __slots__.append("__weakref__")
 
-    def __init__(self, root: "AbstractComponent") -> None:
+    def __init__(self, root: "ComponentType") -> None:
         super().__init__()
-        if not isinstance(root, AbstractComponent):
-            raise TypeError("Expected an AbstractComponent, not %r" % root)
+        if not isinstance(root, ComponentType):
+            raise TypeError("Expected an ComponentType, not %r" % root)
         self.root = root
 
     def __enter__(self: _Self) -> _Self:
         # create attributes here to avoid access before entering context manager
         self._event_handlers: Dict[str, EventHandler] = {}
         self._rendering_queue = _ComponentQueue()
-        self._model_state_by_component_id: Dict[int, _ModelState] = {
-            id(self.root): _ModelState(None, -1, "", LifeCycleHook(self, self.root))
+        self._model_state_by_component_id: Dict[str, _ModelState] = {
+            self.root.id: _ModelState(None, -1, "", LifeCycleHook(self, self.root))
         }
         self._rendering_queue.put(self.root)
         return self
 
     def __exit__(self, *exc: Any) -> None:
-        root_state = self._model_state_by_component_id[id(self.root)]
+        root_state = self._model_state_by_component_id[self.root.id]
         self._unmount_model_states([root_state])
 
         # delete attributes here to avoid access after exiting context manager
@@ -94,7 +93,7 @@ def __exit__(self, *exc: Any) -> None:
 
         return None
 
-    def update(self, component: "AbstractComponent") -> None:
+    def update(self, component: "ComponentType") -> None:
         """Schedule a re-render of a component in the layout"""
         self._rendering_queue.put(component)
         return None
@@ -121,7 +120,7 @@ async def render(self) -> LayoutUpdate:
         """Await the next available render. This will block until a component is updated"""
         while True:
             component = await self._rendering_queue.get()
-            if id(component) in self._model_state_by_component_id:
+            if component.id in self._model_state_by_component_id:
                 return self._create_layout_update(component)
             else:
                 logger.info(
@@ -139,11 +138,11 @@ async def render(self) -> LayoutUpdate:
         async def render(self) -> LayoutUpdate:
             # Ensure that the model is valid VDOM on each render
             result = await self._debug_render()
-            validate_vdom(self._model_state_by_component_id[id(self.root)].model)
+            validate_vdom(self._model_state_by_component_id[self.root.id].model)
             return result
 
-    def _create_layout_update(self, component: AbstractComponent) -> LayoutUpdate:
-        old_state = self._model_state_by_component_id[id(component)]
+    def _create_layout_update(self, component: ComponentType) -> LayoutUpdate:
+        old_state = self._model_state_by_component_id[component.id]
         new_state = old_state.new(None, component)
 
         self._render_component(old_state, new_state, component)
@@ -160,7 +159,7 @@ def _render_component(
         self,
         old_state: Optional[_ModelState],
         new_state: _ModelState,
-        component: AbstractComponent,
+        component: ComponentType,
     ) -> None:
         life_cycle_hook = new_state.life_cycle_hook
         life_cycle_hook.component_will_render()
@@ -176,8 +175,8 @@ def _render_component(
             new_state.model = {"tagName": "__error__", "children": [str(error)]}
 
         if old_state is not None and old_state.component is not component:
-            del self._model_state_by_component_id[id(old_state.component)]
-        self._model_state_by_component_id[id(component)] = new_state
+            del self._model_state_by_component_id[old_state.component.id]
+        self._model_state_by_component_id[component.id] = new_state
 
         try:
             parent = new_state.parent
@@ -249,7 +248,7 @@ def _render_model_attributes(
 
         model_event_handlers = new_state.model["eventHandlers"] = {}
         for event, handler in handlers_by_event.items():
-            target = old_state.targets_by_event.get(event, hex_id(handler))
+            target = old_state.targets_by_event.get(event, handler.target)
             new_state.targets_by_event[event] = target
             self._event_handlers[target] = handler
             model_event_handlers[event] = {
@@ -270,7 +269,7 @@ def _render_model_event_handlers_without_old_state(
 
         model_event_handlers = new_state.model["eventHandlers"] = {}
         for event, handler in handlers_by_event.items():
-            target = hex_id(handler)
+            target = handler.target
             new_state.targets_by_event[event] = target
             self._event_handlers[target] = handler
             model_event_handlers[event] = {
@@ -362,7 +361,7 @@ def _unmount_model_states(self, old_states: List[_ModelState]) -> None:
             if hasattr(state, "life_cycle_hook"):
                 hook = state.life_cycle_hook
                 hook.component_will_unmount()
-                del self._model_state_by_component_id[id(hook.component)]
+                del self._model_state_by_component_id[hook.component.id]
             to_unmount.extend(state.children_by_key.values())
 
     def __repr__(self) -> str:
@@ -387,7 +386,7 @@ class _ModelState:
     model: _ModelVdom
     life_cycle_hook: LifeCycleHook
     patch_path: str
-    component: AbstractComponent
+    component: ComponentType
 
     def __init__(
         self,
@@ -423,7 +422,7 @@ def parent(self) -> _ModelState:
     def new(
         self,
         new_parent: Optional[_ModelState],
-        component: Optional[AbstractComponent],
+        component: Optional[ComponentType],
     ) -> _ModelState:
         if new_parent is None:
             new_parent = getattr(self, "parent", None)
@@ -452,19 +451,19 @@ class _ComponentQueue:
 
     def __init__(self) -> None:
         self._loop = asyncio.get_event_loop()
-        self._queue: "asyncio.Queue[AbstractComponent]" = asyncio.Queue()
-        self._pending: Set[int] = set()
+        self._queue: "asyncio.Queue[ComponentType]" = asyncio.Queue()
+        self._pending: Set[str] = set()
 
-    def put(self, component: AbstractComponent) -> None:
-        component_id = id(component)
+    def put(self, component: ComponentType) -> None:
+        component_id = component.id
         if component_id not in self._pending:
             self._pending.add(component_id)
             self._loop.call_soon_threadsafe(self._queue.put_nowait, component)
         return None
 
-    async def get(self) -> AbstractComponent:
+    async def get(self) -> ComponentType:
         component = await self._queue.get()
-        self._pending.remove(id(component))
+        self._pending.remove(component.id)
         return component
 
 
@@ -475,7 +474,7 @@ def _process_child_type_and_key(
         if isinstance(child, dict):
             child_type = _DICT_TYPE
             key = child.get("key")
-        elif isinstance(child, AbstractComponent):
+        elif isinstance(child, ComponentType):
             child_type = _COMPONENT_TYPE
             key = getattr(child, "key", None)
         else:

src/idom/core/utils.py

@@ -198,16 +198,18 @@ def constructor(
             raise TypeError(f"{tag!r} nodes cannot have children.")
         return model
 
-    module = _get_module_name_by_frame_index(1)
-    if module is None:
-        qualname = None
-    else:
-        qualname = module + "." + tag
-
+    # replicate common function attributes
     constructor.__name__ = tag
-    constructor.__module__ = module
-    constructor.__qualname__ = qualname
     constructor.__doc__ = f"Return a new ``<{tag}/>`` :class:`VdomDict` element"
+
+    frame = inspect.currentframe()
+    if frame is not None and frame.f_back is not None and frame.f_back is not None:
+        module = frame.f_back.f_globals.get("__name__")  # module in outer frame
+        if module is not None:
+            qualname = module + "." + tag
+            constructor.__module__ = module
+            constructor.__qualname__ = qualname
+
     return constructor
 
 
@@ -260,7 +262,7 @@ def _is_single_child(value: Any) -> bool:
         if _debug_is_single_child(value):
             return True
 
-        from .component import AbstractComponent
+        from .component import ComponentType
 
         if hasattr(value, "__iter__") and not hasattr(value, "__len__"):
             logger.error(
@@ -269,19 +271,9 @@ def _is_single_child(value: Any) -> bool:
             )
         else:
             for child in value:
-                if (isinstance(child, AbstractComponent) and child.key is None) or (
+                if (isinstance(child, ComponentType) and child.key is None) or (
                     isinstance(child, Mapping) and "key" not in child
                 ):
                     logger.error(f"Key not specified for dynamic child {child}")
 
         return False
-
-
-def _get_module_name_by_frame_index(index: int) -> Optional[str]:
-    frame = inspect.currentframe()
-    for i in range(index + 1):  # add one to ignore this frame
-        if frame is None:
-            return None
-        else:
-            frame = frame.f_back
-    return frame.f_globals.get("__name__")