rename Renderer to Dispatcher

Author: rmorshea

docs/source/api.rst

@@ -29,7 +29,7 @@ Layout
     :members:
 
 
-Renderer
+Dispatcher
 --------
 
 .. automodule:: idom.core.render

docs/source/core-concepts.rst

@@ -71,7 +71,7 @@ ever be removed from the model. Then you'll just need to call and await a
         patch = await layout.render()
 
 The layout also handles the triggering of event handlers. Normally this is done
-automatically by a :ref:`Renderer <Layout Renderer>`, but for now we'll do it manually.
+automatically by a :ref:`Dispatcher <Layout Dispatcher>`, but for now we'll do it manually.
 We can use a trick to hard-code the ``event_handler_id`` so we can pass it, and a fake
 event, to the layout's :meth:`~idom.core.layout.Layout.dispatch` method. Then we just
 have to re-render the layout and see what changed:
@@ -112,22 +112,22 @@ have to re-render the layout and see what changed:
         assert count_did_increment
 
 
-Layout Renderer
----------------
+Layout Dispatcher
+-----------------
 
-An :class:`~idom.core.render.AbstractRenderer` implementation is a relatively thin layer
+An :class:`~idom.core.dispatcher.AbstractDispatcher` implementation is a relatively thin layer
 of logic around a :class:`~idom.core.layout.Layout` which drives the triggering of
 events and layout updates by scheduling an asynchronous loop that will run forever -
-effectively animating the model. To execute the loop, the renderer's
-:meth:`~idom.core.render.AbstractRenderer.run` method accepts two callbacks. One is a
-"send" callback to which the renderer passes updates, while the other is "receive"
-callback that's called by the renderer to events it should execute.
+effectively animating the model. To execute the loop, the dispatcher's
+:meth:`~idom.core.dispatcher.AbstractDispatcher.run` method accepts two callbacks. One is a
+"send" callback to which the dispatcher passes updates, while the other is "receive"
+callback that's called by the dispatcher to events it should execute.
 
 .. testcode::
 
     import asyncio
 
-    from idom.core import SingleStateRenderer, EventHandler
+    from idom.core import SingleStateDispatcher, EventHandler
     from idom.core.layout import LayoutEvent
 
 
@@ -137,7 +137,7 @@ callback that's called by the renderer to events it should execute.
     async def send(patch):
         sent_patches.append(patch)
         if len(sent_patches) == 5:
-            # if we didn't cancel the renderer would continue forever
+            # if we didn't cancel the dispatcher would continue forever
             raise asyncio.CancelledError()
 
 
@@ -152,26 +152,26 @@ callback that's called by the renderer to events it should execute.
         return event
 
 
-    async with SingleStateRenderer(idom.Layout(ClickCount())) as renderer:
+    async with SingleStateDispatcher(idom.Layout(ClickCount())) as dispatcher:
         context = None  # see note below
-        await renderer.run(send, recv, context)
+        await dispatcher.run(send, recv, context)
 
     assert len(sent_patches) == 5
 
 
 .. note::
 
     ``context`` is information that's specific to the
-    :class:`~idom.core.render.AbstractRenderer` implementation. In the case of
-    the :class:`~idom.core.render.SingleStateRenderer` it doesn't require any
-    context. On the other hand the :class:`~idom.core.render.SharedStateRenderer`
+    :class:`~idom.core.dispatcher.AbstractDispatcher` implementation. In the case of
+    the :class:`~idom.core.render.SingleStateDispatcher` it doesn't require any
+    context. On the other hand the :class:`~idom.core.render.SharedStateDispatcher`
     requires a client ID as its piece of contextual information.
 
 
 Layout Server
 -------------
 
-The :ref:`Renderer <Layout Renderer>` allows you to animate the layout, but we still
+The :ref:`Dispatcher <Layout Dispatcher>` allows you to animate the layout, but we still
 need to get the models on the screen. One of the last steps in that journey is to send
 them over the wire. To do that you need an
 :class:`~idom.server.base.AbstractRenderServer` implementation. Right now we have a
@@ -188,7 +188,7 @@ starting to add support for asyncio like
     an `issue <https://github.com/rmorshea/idom/issues>`__.
 
 In the case of our :class:`~idom.server.sanic.SanicRenderServer` types we have one
-implementation per built in :ref:`Renderer <Layout Renderer>`:
+implementation per built in :ref:`Dispatcher <Layout Dispatcher>`:
 
 - :class:`idom.server.sanic.PerClientStateServer`
 

idom/core/__init__.py

@@ -1,13 +1,13 @@
 from .element import element, Element, AbstractElement, ElementConstructor
 from .events import event, Events, EventHandler
 from .layout import Layout, Layout
-from .render import AbstractRenderer, SharedStateRenderer, SingleStateRenderer
+from .dispatcher import AbstractDispatcher, SharedStateDispatcher, SingleStateDispatcher
 from .vdom import vdom
 
 __all__ = [
     "AbstractElement",
     "Layout",
-    "AbstractRenderer",
+    "AbstractDispatcher",
     "element",
     "Element",
     "EventHandler",
@@ -17,6 +17,6 @@
     "hooks",
     "Layout",
     "vdom",
-    "SharedStateRenderer",
-    "SingleStateRenderer",
+    "SharedStateDispatcher",
+    "SingleStateDispatcher",
 ]

idom/core/render.py renamed to idom/core/dispatcher.py

@@ -19,12 +19,8 @@
 RecvCoroutine = Callable[[], Awaitable[LayoutEvent]]
 
 
-class StopRendering(Exception):
-    """Raised to gracefully stop :meth:`AbstractRenderer.run`"""
-
-
-class AbstractRenderer(HasAsyncResources, abc.ABC):
-    """A base class for implementing :class:`~idom.core.layout.Layout` renderers."""
+class AbstractDispatcher(HasAsyncResources, abc.ABC):
+    """A base class for implementing :class:`~idom.core.layout.Layout` dispatchers."""
 
     __slots__ = "_layout"
 
@@ -73,11 +69,11 @@ async def _incoming(self, layout: Layout, context: Any, message: Any) -> None:
         ...
 
 
-class SingleStateRenderer(AbstractRenderer):
-    """Each client of the renderer will get its own model.
+class SingleStateDispatcher(AbstractDispatcher):
+    """Each client of the dispatcher will get its own model.
 
     ..note::
-        The ``context`` parameter of :meth:`SingleStateRenderer.run` should just
+        The ``context`` parameter of :meth:`SingleStateDispatcher.run` should just
         be ``None`` since it's not used.
     """
 
@@ -95,11 +91,11 @@ async def _incoming(self, layout: Layout, context: Any, event: LayoutEvent) -> N
         return None
 
 
-class SharedStateRenderer(SingleStateRenderer):
-    """Each client of the renderer shares the same model.
+class SharedStateDispatcher(SingleStateDispatcher):
+    """Each client of the dispatcher shares the same model.
 
     The client's ID is indicated by the ``context`` argument of
-    :meth:`SharedStateRenderer.run`
+    :meth:`SharedStateDispatcher.run`
     """
 
     __slots__ = "_update_queues", "_model_state"

idom/server/base.py

@@ -5,8 +5,8 @@
 
 from idom.core.element import ElementConstructor, AbstractElement
 from idom.core.layout import Layout, Layout
-from idom.core.render import (
-    AbstractRenderer,
+from idom.core.dispatcher import (
+    AbstractDispatcher,
     SendCoroutine,
     RecvCoroutine,
 )
@@ -31,7 +31,7 @@ class AbstractRenderServer(Generic[_App, _Config]):
     """
 
     _loop: AbstractEventLoop
-    _renderer_type: Type[AbstractRenderer]
+    _dispatcher_type: Type[AbstractDispatcher]
     _layout_type: Type[Layout] = Layout
 
     def __init__(
@@ -113,7 +113,7 @@ def _run_application(
         raise NotImplementedError()
 
     @abc.abstractmethod
-    async def _run_renderer(
+    async def _run_dispatcher(
         self,
         send: SendCoroutine,
         recv: RecvCoroutine,
@@ -131,12 +131,12 @@ def _update_config(self, old: _Config, new: _Config) -> _Config:  # pragma: no c
         """
         raise NotImplementedError()
 
-    def _make_renderer(
+    def _make_dispatcher(
         self,
         parameters: Dict[str, Any],
         loop: Optional[AbstractEventLoop] = None,
-    ) -> AbstractRenderer:
-        return self._renderer_type(self._make_layout(parameters, loop))
+    ) -> AbstractDispatcher:
+        return self._dispatcher_type(self._make_layout(parameters, loop))
 
     def _make_layout(
         self,

idom/server/sanic.py

@@ -9,9 +9,9 @@
 from mypy_extensions import TypedDict
 from websockets import WebSocketCommonProtocol
 
-from idom.core.render import (
-    SingleStateRenderer,
-    SharedStateRenderer,
+from idom.core.dispatcher import (
+    SingleStateDispatcher,
+    SharedStateDispatcher,
     SendCoroutine,
     RecvCoroutine,
 )
@@ -55,7 +55,7 @@ def _setup_application(self, app: Sanic, config: Config) -> None:
             cors_params = cors_config if isinstance(cors_config, dict) else {}
             CORS(app, **cors_params)
 
-        bp = Blueprint(f"idom_renderer_{id(self)}", url_prefix=config["url_prefix"])
+        bp = Blueprint(f"idom_dispatcher_{id(self)}", url_prefix=config["url_prefix"])
         self._setup_blueprint_routes(bp, config)
         app.blueprint(bp)
 
@@ -75,7 +75,7 @@ async def sock_recv() -> LayoutEvent:
                 return LayoutEvent(event["target"], event["data"])
 
             param_dict = {k: request.args.get(k) for k in request.args}
-            await self._run_renderer(sock_send, sock_recv, param_dict)
+            await self._run_dispatcher(sock_send, sock_recv, param_dict)
 
         def handler_name(function: Any) -> str:
             return f"{blueprint.name}.{function.__name__}"
@@ -135,43 +135,43 @@ def _run_application(
 class PerClientStateServer(SanicRenderServer):
     """Each client view will have its own state."""
 
-    _renderer_type = SingleStateRenderer
+    _dispatcher_type = SingleStateDispatcher
 
-    async def _run_renderer(
+    async def _run_dispatcher(
         self,
         send: SendCoroutine,
         recv: RecvCoroutine,
         parameters: Dict[str, Any],
         loop: Optional[asyncio.AbstractEventLoop] = None,
     ) -> None:
-        async with self._make_renderer(parameters, loop) as renderer:
-            await renderer.run(send, recv, None)
+        async with self._make_dispatcher(parameters, loop) as dispatcher:
+            await dispatcher.run(send, recv, None)
 
 
 class SharedClientStateServer(SanicRenderServer):
     """All connected client views will have shared state."""
 
-    _renderer_type = SharedStateRenderer
-    _renderer: SharedStateRenderer
+    _dispatcher_type = SharedStateDispatcher
+    _dispatcher: SharedStateDispatcher
 
     def _setup_application(self, app: Sanic, config: Config) -> None:
-        app.listener("before_server_start")(self._activate_renderer)
-        app.listener("before_server_stop")(self._deactivate_renderer)
+        app.listener("before_server_start")(self._activate_dispatcher)
+        app.listener("before_server_stop")(self._deactivate_dispatcher)
         super()._setup_application(app, config)
 
-    async def _activate_renderer(
+    async def _activate_dispatcher(
         self, app: Sanic, loop: asyncio.AbstractEventLoop
     ) -> None:
-        self._renderer = cast(SharedStateRenderer, self._make_renderer({}, loop))
-        await self._renderer.__aenter__()
+        self._dispatcher = cast(SharedStateDispatcher, self._make_dispatcher({}, loop))
+        await self._dispatcher.__aenter__()
 
-    async def _deactivate_renderer(
+    async def _deactivate_dispatcher(
         self, app: Sanic, loop: asyncio.AbstractEventLoop
     ) -> None:  # pragma: no cover
         # this doesn't seem to get triffered during testing for some reason
-        await self._renderer.__aexit__(None, None, None)
+        await self._dispatcher.__aexit__(None, None, None)
 
-    async def _run_renderer(
+    async def _run_dispatcher(
         self,
         send: SendCoroutine,
         recv: RecvCoroutine,
@@ -181,4 +181,4 @@ async def _run_renderer(
         if parameters:
             msg = f"SharedClientState server does not support per-client view parameters {parameters}"
             raise ValueError(msg)
-        await self._renderer.run(send, recv, uuid.uuid4().hex, join=True)
+        await self._dispatcher.run(send, recv, uuid.uuid4().hex, join=True)

tests/conftest.py

@@ -220,10 +220,10 @@ def fixturized_server_type(server_type):
     class ServerSavesLastError(server_type):
         """A per-client-state server that updates the ``last_server_error`` fixture"""
 
-        async def _run_renderer(self, *args, **kwargs):
+        async def _run_dispatcher(self, *args, **kwargs):
             self._config["last_server_error"].current = None
             try:
-                await super()._run_renderer(*args, **kwargs)
+                await super()._run_dispatcher(*args, **kwargs)
             except Exception as e:
                 self._config["last_server_error"].current = e
 

tests/test_core/test_render.py renamed to tests/test_core/test_dispatcher.py

@@ -6,10 +6,10 @@
 
 import idom
 from idom.core.layout import Layout, LayoutEvent
-from idom.core.render import SharedStateRenderer, AbstractRenderer
+from idom.core.dispatcher import SharedStateDispatcher, AbstractDispatcher
 
 
-async def test_shared_state_renderer():
+async def test_shared_state_dispatcher():
     done = asyncio.Event()
     changes_1 = []
     changes_2 = []
@@ -45,9 +45,9 @@ async def an_event():
 
         return idom.html.div({"anEvent": an_event, "count": count})
 
-    async with SharedStateRenderer(Layout(Clickable())) as renderer:
-        await renderer.run(send_1, recv_1, "1")
-        await renderer.run(send_2, recv_2, "2")
+    async with SharedStateDispatcher(Layout(Clickable())) as dispatcher:
+        await dispatcher.run(send_1, recv_1, "1")
+        await dispatcher.run(send_2, recv_2, "2")
 
     expected_changes = [
         [
@@ -76,8 +76,8 @@ async def an_event():
     assert changes_1 == changes_2
 
 
-async def test_renderer_run_does_not_supress_non_cancel_errors():
-    class RendererWithBug(AbstractRenderer):
+async def test_dispatcher_run_does_not_supress_non_cancel_errors():
+    class DispatcherWithBug(AbstractDispatcher):
         async def _outgoing(self, layout, context):
             raise ValueError("this is a bug")
 
@@ -95,12 +95,12 @@ async def recv():
         return {}
 
     with pytest.raises(ExceptionGroup, match="this is a bug"):
-        async with RendererWithBug(idom.Layout(AnyElement())) as renderer:
-            await renderer.run(send, recv, None)
+        async with DispatcherWithBug(idom.Layout(AnyElement())) as dispatcher:
+            await dispatcher.run(send, recv, None)
 
 
-async def test_renderer_run_does_not_supress_non_stop_rendering_errors():
-    class RendererWithBug(AbstractRenderer):
+async def test_dispatcher_run_does_not_supress_non_stop_rendering_errors():
+    class DispatcherWithBug(AbstractDispatcher):
         async def _outgoing(self, layout, context):
             raise ValueError("this is a bug")
 
@@ -118,5 +118,5 @@ async def recv():
         return {}
 
     with pytest.raises(ExceptionGroup, match="this is a bug"):
-        async with RendererWithBug(idom.Layout(AnyElement())) as renderer:
-            await renderer.run(send, recv, None)
+        async with DispatcherWithBug(idom.Layout(AnyElement())) as dispatcher:
+            await dispatcher.run(send, recv, None)