simplify server constructor

the constructor simply exects a root element that takes no arguments
unless view parameters are passed by a query to the endpoint. in that
case the element must accept an parameter passed in by the query.

Author: rmorshea

Diff for: docs/main.py

@@ -69,11 +69,11 @@ def prod():
     )
 
 
-def local():
+def local(path=""):
     import webbrowser
 
     thread = server.daemon("127.0.0.1", 5000)
-    webbrowser.open("http://127.0.0.1:5000/")
+    webbrowser.open(f"http://127.0.0.1:5000/{path}")
     thread.join()
 
 

Diff for: idom/core/element.py

@@ -79,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__}:{id(self)}({items})"
+            return f"{self._function.__name__}({id(self)}, {items})"
         else:
-            return f"{self._function.__name__}:{id(self)}()"
+            return f"{self._function.__name__}({id(self)})"

Diff for: idom/core/layout.py

@@ -8,7 +8,6 @@
     NamedTuple,
     Any,
     Set,
-    Optional,
     Iterator,
     AsyncIterator,
     Union,
@@ -64,9 +63,7 @@ class Layout(HasAsyncResources):
     if not hasattr(abc.ABC, "__weakref__"):  # pragma: no cover
         __slots__.append("__weakref__")
 
-    def __init__(
-        self, root: "AbstractElement", loop: Optional[asyncio.AbstractEventLoop] = None
-    ) -> None:
+    def __init__(self, root: "AbstractElement") -> None:
         super().__init__()
         if not isinstance(root, AbstractElement):
             raise TypeError("Expected an AbstractElement, not %r" % root)

Diff for: idom/server/base.py

@@ -3,7 +3,7 @@
 from typing import TypeVar, Dict, Any, Tuple, Type, Optional, Generic, TypeVar
 from threading import Thread
 
-from idom.core.element import ElementConstructor, AbstractElement
+from idom.core.element import ElementConstructor
 from idom.core.layout import Layout, Layout
 from idom.core.dispatcher import (
     AbstractDispatcher,
@@ -34,11 +34,17 @@ class AbstractRenderServer(Generic[_App, _Config]):
     _dispatcher_type: Type[AbstractDispatcher]
     _layout_type: Type[Layout] = Layout
 
-    def __init__(self, constructor: ElementConstructor) -> None:
+    def __init__(
+        self,
+        constructor: ElementConstructor,
+        config: Optional[_Config] = None,
+    ) -> None:
         self._app: Optional[_App] = None
-        self._root_element_constructor = constructor
+        self._make_root_element = constructor
         self._daemonized = False
         self._config = self._init_config()
+        if config is not None:
+            self._config = self._update_config(self._config, config)
 
     @property
     def loop(self) -> AbstractEventLoop:
@@ -78,15 +84,12 @@ def register(self: _Self, app: Optional[_App]) -> _Self:
         self._app = app
         return self
 
-    def configure(self: _Self, config: Optional[_Config] = None) -> _Self:
-        """Configure this extension."""
-        if config is not None:
-            self._config = self._update_config(self._config, config)
-        return self
-
-    @abc.abstractmethod
     def stop(self) -> None:
         """Stop the running application"""
+        self.loop.call_soon_threadsafe(self._stop)
+
+    @abc.abstractmethod
+    def _stop(self):
         raise NotImplementedError()
 
     @abc.abstractmethod
@@ -109,15 +112,6 @@ def _run_application(
         raise NotImplementedError()
 
     @abc.abstractmethod
-    async def _run_dispatcher(
-        self,
-        send: SendCoroutine,
-        recv: RecvCoroutine,
-        parameters: Dict[str, Any],
-        loop: Optional[AbstractEventLoop] = None,
-    ) -> None:
-        raise NotImplementedError()
-
     def _update_config(self, old: _Config, new: _Config) -> _Config:  # pragma: no cover
         """Return the new configuration options
 
@@ -127,19 +121,23 @@ def _update_config(self, old: _Config, new: _Config) -> _Config:  # pragma: no c
         """
         raise NotImplementedError()
 
+    async def _run_dispatcher(
+        self,
+        send: SendCoroutine,
+        recv: RecvCoroutine,
+        params: Dict[str, Any],
+    ) -> None:
+        async with self._make_dispatcher(params) as dispatcher:
+            await dispatcher.run(send, recv, None)
+
     def _make_dispatcher(
         self,
-        parameters: Dict[str, Any],
-        loop: Optional[AbstractEventLoop] = None,
+        params: Dict[str, Any],
     ) -> AbstractDispatcher:
-        return self._dispatcher_type(self._make_layout(parameters, loop))
+        return self._dispatcher_type(self._make_layout(params))
 
     def _make_layout(
         self,
-        parameters: Dict[str, Any],
-        loop: Optional[AbstractEventLoop] = None,
+        params: Dict[str, Any],
     ) -> Layout:
-        return self._layout_type(self._make_root_element(parameters), loop)
-
-    def _make_root_element(self, parameters: Dict[str, Any]) -> AbstractElement:
-        return self._root_element_constructor(**parameters)
+        return self._layout_type(self._make_root_element(**params))

Diff for: idom/server/sanic.py

@@ -31,7 +31,7 @@ class Config(TypedDict, total=False):
 class SanicRenderServer(AbstractRenderServer[Sanic, Config]):
     """Base ``sanic`` extension."""
 
-    def stop(self) -> None:
+    def _stop(self) -> None:
         self.application.stop()
 
     def _init_config(self) -> Config:
@@ -74,8 +74,8 @@ async def sock_recv() -> LayoutEvent:
                 event = message["body"]["event"]
                 return LayoutEvent(event["target"], event["data"])
 
-            param_dict = {k: request.args.get(k) for k in request.args}
-            await self._run_dispatcher(sock_send, sock_recv, param_dict)
+            element_params = {k: request.args.get(k) for k in request.args}
+            await self._run_dispatcher(sock_send, sock_recv, element_params)
 
         def handler_name(function: Any) -> str:
             return f"{blueprint.name}.{function.__name__}"
@@ -141,16 +141,6 @@ class PerClientStateServer(SanicRenderServer):
 
     _dispatcher_type = SingleViewDispatcher
 
-    async def _run_dispatcher(
-        self,
-        send: SendCoroutine,
-        recv: RecvCoroutine,
-        parameters: Dict[str, Any],
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> 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."""
@@ -166,7 +156,7 @@ def _setup_application(self, app: Sanic, config: Config) -> None:
     async def _activate_dispatcher(
         self, app: Sanic, loop: asyncio.AbstractEventLoop
     ) -> None:
-        self._dispatcher = cast(SharedViewDispatcher, self._make_dispatcher({}, loop))
+        self._dispatcher = cast(SharedViewDispatcher, self._make_dispatcher({}))
         await self._dispatcher.start()
 
     async def _deactivate_dispatcher(
@@ -179,10 +169,9 @@ async def _run_dispatcher(
         self,
         send: SendCoroutine,
         recv: RecvCoroutine,
-        parameters: Dict[str, Any],
-        loop: Optional[asyncio.AbstractEventLoop] = None,
+        params: Dict[str, Any],
     ) -> None:
-        if parameters:
-            msg = f"SharedClientState server does not support per-client view parameters {parameters}"
+        if params:
+            msg = f"SharedClientState server does not support per-client view parameters {params}"
             raise ValueError(msg)
         await self._dispatcher.run(send, recv, uuid.uuid4().hex, join=True)

Diff for: idom/server/utils.py

@@ -20,38 +20,56 @@ def _find_default_server_type() -> Optional[Type[AbstractRenderServer[Any, Any]]
             pass
         else:
             return getattr(module, server_name)
-    else:
+    else:  # pragma: no cover
         return None
 
 
 def run(
     element: ElementConstructor,
-    server: Optional[
-        Type[AbstractRenderServer[Any, Any]]
-    ] = _find_default_server_type(),
+    server_type: Optional[Type[_S]] = _find_default_server_type(),
     host: Optional[str] = "127.0.0.1",
     port: Optional[int] = None,
+    server_options: Optional[Any] = None,
     run_options: Optional[Dict[str, Any]] = None,
-) -> None:
-    """A utility for quickly running a view with minimal boilerplat"""
-    if server is None:
+    daemon: bool = False,
+    app: Optional[Any] = None,
+) -> _S:
+    """A utility for quickly running a render server with minimal boilerplate
+
+    Parameters:
+        element: The root of the view.
+        server_type: What server to run. Defaults to a builtin implementation if available.
+        host: The host string.
+        port: The port number. Defaults to a dynamically discovered available port.
+        server_options: Options passed to configure the server.
+        run_options: Options passed to the server to run it.
+        daemon: Whether the server should be run in a daemon thread.
+        app: Register the server to an existing application and run that.
+
+    Returns:
+        The server instance. This isn't really useful unless the server is spawned
+        as a daemon. Otherwise this function blocks until the server has stopped.
+    """
+    if server_type is None:  # pragma: no cover
         raise ValueError("No default server available.")
-    if port is None:
+    if port is None:  # pragma: no cover
         port = find_available_port(host)
-    server(element).run(host, port, **(run_options or {}))
 
+    server = server_type(element, server_options)
 
-def find_available_port(host: str) -> int:
-    """Get a port that's available for the given host"""
-    sock = socket()
-    sock.bind((host, 0))
-    return cast(int, sock.getsockname()[1])
+    if app is not None:
+        server.register(app)
+
+    run_server = server.run if not daemon else server.daemon
+    run_server(host, port, **(run_options or {}))
+
+    return server
 
 
 def multiview_server(
-    server: Type[_S],
-    host: str,
-    port: int,
+    server_type: Type[_S],
+    host: Optional[str] = "127.0.0.1",
+    port: Optional[int] = None,
     server_options: Optional[Any] = None,
     run_options: Optional[Dict[str, Any]] = None,
     app: Optional[Any] = None,
@@ -75,18 +93,25 @@ def multiview_server(
         See :func:`idom.widgets.common.multiview` for details.
     """
     mount, element = multiview()
-    server_instance = server(element)
-    server_instance.configure(server_options)
-    if app is not None:
-        server_instance.register(app)
-    server_instance.daemon(host, port, **(run_options or {}))
-    return mount, server_instance
+
+    server = run(
+        element,
+        server_type,
+        host,
+        port,
+        server_options=server_options,
+        run_options=run_options,
+        daemon=True,
+        app=app,
+    )
+
+    return mount, server
 
 
 def hotswap_server(
-    server: Type[_S],
-    host: str,
-    port: int,
+    server_type: Type[_S],
+    host: Optional[str] = "127.0.0.1",
+    port: Optional[int] = None,
     server_options: Optional[Any] = None,
     run_options: Optional[Dict[str, Any]] = None,
     sync_views: bool = True,
@@ -112,9 +137,23 @@ def hotswap_server(
         See :func:`idom.widgets.common.hotswap` for details.
     """
     mount, element = hotswap(shared=sync_views)
-    server_instance = server(element)
-    server_instance.configure(server_options)
-    if app is not None:
-        server_instance.register(app)
-    server_instance.daemon(host, port, **(run_options or {}))
-    return mount, server_instance
+
+    server = run(
+        element,
+        server_type,
+        host,
+        port,
+        server_options=server_options,
+        run_options=run_options,
+        daemon=True,
+        app=app,
+    )
+
+    return mount, server
+
+
+def find_available_port(host: str) -> int:
+    """Get a port that's available for the given host"""
+    sock = socket()
+    sock.bind((host, 0))
+    return cast(int, sock.getsockname()[1])