remove shared dispatchers and rename to serve module

Author: rmorshea

src/idom/__init__.py

@@ -1,7 +1,6 @@
 from . import config, html, log, types, web
 from .core import hooks
 from .core.component import component
-from .core.dispatcher import Stop
 from .core.events import event
 from .core.hooks import (
     create_context,
@@ -14,6 +13,7 @@
     use_state,
 )
 from .core.layout import Layout
+from .core.serve import Stop
 from .core.vdom import vdom
 from .sample import run_sample_app
 from .server.any import run

src/idom/core/dispatcher.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from asyncio import Future, Queue, ensure_future
+from asyncio.tasks import FIRST_COMPLETED, ensure_future, gather, wait
+from contextlib import asynccontextmanager
+from logging import getLogger
+from typing import (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    NamedTuple,
+    Sequence,
+    Tuple,
+    cast,
+)
+from weakref import WeakSet
+
+from anyio import create_task_group
+
+from idom.utils import Ref
+
+from ._fixed_jsonpatch import apply_patch, make_patch  # type: ignore
+from .layout import LayoutEvent, LayoutUpdate
+from .types import LayoutType, VdomJson
+
+
+logger = getLogger(__name__)
+
+
+SendCoroutine = Callable[["VdomJsonPatch"], Awaitable[None]]
+"""Send model patches given by a dispatcher"""
+
+RecvCoroutine = Callable[[], Awaitable[LayoutEvent]]
+"""Called by a dispatcher to return a :class:`idom.core.layout.LayoutEvent`
+
+The event will then trigger an :class:`idom.core.proto.EventHandlerType` in a layout.
+"""
+
+
+class Stop(BaseException):
+    """Stop serving changes and events
+
+    Raising this error will tell dispatchers to gracefully exit. Typically this is
+    called by code running inside a layout to tell it to stop rendering.
+    """
+
+
+async def serve_json_patch(
+    layout: LayoutType[LayoutUpdate, LayoutEvent],
+    send: SendCoroutine,
+    recv: RecvCoroutine,
+) -> None:
+    """Run a dispatch loop for a single view instance"""
+    with layout:
+        try:
+            async with create_task_group() as task_group:
+                task_group.start_soon(_single_outgoing_loop, layout, send)
+                task_group.start_soon(_single_incoming_loop, layout, recv)
+        except Stop:
+            logger.info("Stopped dispatch task")
+
+
+async def render_json_patch(layout: LayoutType[LayoutUpdate, Any]) -> VdomJsonPatch:
+    """Render a class:`VdomJsonPatch` from a layout"""
+    return VdomJsonPatch.create_from(await layout.render())
+
+
+class VdomJsonPatch(NamedTuple):
+    """An object describing an update to a :class:`Layout` in the form of a JSON patch"""
+
+    path: str
+    """The path where changes should be applied"""
+
+    changes: List[Dict[str, Any]]
+    """A list of JSON patches to apply at the given path"""
+
+    def apply_to(self, model: VdomJson) -> VdomJson:
+        """Return the model resulting from the changes in this update"""
+        return cast(
+            VdomJson,
+            apply_patch(
+                model, [{**c, "path": self.path + c["path"]} for c in self.changes]
+            ),
+        )
+
+    @classmethod
+    def create_from(cls, update: LayoutUpdate) -> VdomJsonPatch:
+        """Return a patch given an layout update"""
+        return cls(update.path, make_patch(update.old or {}, update.new).patch)
+
+
+async def _single_outgoing_loop(
+    layout: LayoutType[LayoutUpdate, LayoutEvent], send: SendCoroutine
+) -> None:
+    while True:
+        await send(await render_json_patch(layout))
+
+
+async def _single_incoming_loop(
+    layout: LayoutType[LayoutUpdate, LayoutEvent], recv: RecvCoroutine
+) -> None:
+    while True:
+        # We need to fire and forget here so that we avoid waiting on the completion
+        # of this event handler before receiving and running the next one.
+        ensure_future(layout.deliver(await recv()))

src/idom/core/serve.py

@@ -0,0 +1 @@
+from .any import all_implementations

src/idom/server/__init__.py

@@ -19,8 +19,8 @@
 
 import idom
 from idom.config import IDOM_DEBUG_MODE, IDOM_WEB_MODULES_DIR
-from idom.core.dispatcher import dispatch_single_view
 from idom.core.layout import LayoutEvent, LayoutUpdate
+from idom.core.serve import serve_json_patch
 from idom.core.types import ComponentType, RootComponentConstructor
 
 from .utils import CLIENT_BUILD_DIR
@@ -168,7 +168,7 @@ def recv() -> Optional[LayoutEvent]:
             else:
                 return None
 
-        dispatch_single_view_in_thread(constructor(**_get_query_params(ws)), send, recv)
+        dispatch_in_thread(constructor(**_get_query_params(ws)), send, recv)
 
 
 def _get_query_params(ws: WebSocket) -> Dict[str, Any]:
@@ -178,7 +178,7 @@ def _get_query_params(ws: WebSocket) -> Dict[str, Any]:
     }
 
 
-def dispatch_single_view_in_thread(
+def dispatch_in_thread(
     component: ComponentType,
     send: Callable[[Any], None],
     recv: Callable[[], Optional[LayoutEvent]],
@@ -200,7 +200,7 @@ async def recv_coro() -> Any:
             return await async_recv_queue.get()
 
         async def main() -> None:
-            await dispatch_single_view(idom.Layout(component), send_coro, recv_coro)
+            await serve_json_patch(idom.Layout(component), send_coro, recv_coro)
 
         main_future = asyncio.ensure_future(main())