initial work converting to new server interface

Author: rmorshea

src/idom/__init__.py

@@ -16,7 +16,7 @@
 from .core.layout import Layout
 from .core.vdom import vdom
 from .sample import run_sample_app
-from .server.develop import develop
+from .server.any import run
 from .utils import Ref, html_to_vdom
 from .widgets import hotswap, multiview
 
@@ -38,6 +38,7 @@
     "multiview",
     "Ref",
     "run_sample_app",
+    "run",
     "Stop",
     "types",
     "use_callback",

src/idom/sample.py

@@ -6,7 +6,7 @@
 from . import html
 from .core.component import component
 from .core.types import VdomDict
-from .server.develop import develop
+from .server.any import run
 
 
 @component
@@ -37,4 +37,4 @@ def run_sample_app(
         port: the port on the host to serve from
         open_browser: whether to open a browser window after starting the server
     """
-    develop(App, None, host, port, open_browser=open_browser)
+    run(App, host, port, open_browser=open_browser)

src/idom/server/any.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import asyncio
+import warnings
+import webbrowser
+from importlib import import_module
+from typing import Any, Awaitable, Iterator, TypeVar, runtime_checkable
+
+from typing_extensions import Protocol
+
+from idom.types import ComponentConstructor
+
+from .utils import find_available_port
+
+
+SUPPORTED_PACKAGES = (
+    "starlette",
+    "fastapi",
+    "sanic",
+    "flask",
+    "tornado",
+)
+
+
+def run(
+    component: ComponentConstructor,
+    host: str = "127.0.0.1",
+    port: int | None = None,
+    open_browser: bool = True,
+) -> None:
+    """Run a component with a development server"""
+
+    warnings.warn(
+        "You are running a development server, be sure to change this before deploying in production!",
+        UserWarning,
+        stacklevel=2,
+    )
+
+    try:
+        implementation = next(all_implementations())
+    except StopIteration:
+        raise RuntimeError(  # pragma: no cover
+            f"Found no built-in server implementation installed {SUPPORTED_PACKAGES}"
+        )
+
+    app = implementation.create_development_app()
+    implementation.configure(app, component)
+
+    coros: list[Awaitable] = []
+
+    host = host
+    port = port or find_available_port(host)
+    started = asyncio.Event()
+
+    coros.append(implementation.serve_development_app(app, host, port, started))
+
+    if open_browser:
+
+        async def _open_browser_after_server() -> None:
+            await started.wait()
+            webbrowser.open(f"http://{host}:{port}")
+
+        coros.append(_open_browser_after_server())
+
+    asyncio.get_event_loop().run_forever(asyncio.gather(*coros))
+
+
+def configure(app: Any, component: ComponentConstructor) -> None:
+    return get_implementation().configure(app, component)
+
+
+def create_development_app() -> Any:
+    return get_implementation().create_development_app()
+
+
+async def serve_development_app(
+    app: Any, host: str, port: int, started: asyncio.Event
+) -> None:
+    return await get_implementation().serve_development_app(app, host, port, started)
+
+
+def get_implementation() -> Implementation:
+    """Get the first available server implementation"""
+    try:
+        return next(all_implementations())
+    except StopIteration:
+        raise RuntimeError("No built-in server implementation installed.")
+
+
+def all_implementations() -> Iterator[Implementation]:
+    """Yield all available server implementations"""
+    for name in SUPPORTED_PACKAGES:
+        try:
+            module = import_module(f"idom.server.{name}")
+        except ImportError:  # pragma: no cover
+            continue
+
+        if not isinstance(module, Implementation):
+            raise TypeError(f"{module.__name__!r} is an invalid implementation")
+
+        yield module
+
+
+_App = TypeVar("_App")
+
+
+@runtime_checkable
+class Implementation(Protocol):
+    """Common interface for IDOM's builti-in server implementations"""
+
+    def configure(self, app: _App, component: ComponentConstructor) -> None:
+        """Configure the given app instance to display the given component"""
+
+    def create_development_app(self) -> _App:
+        """Create an application instance for development purposes"""
+
+    async def serve_development_app(
+        self, app: _App, host: str, port: int, started: asyncio.Event
+    ) -> None:
+        """Run an application using a development server"""

src/idom/server/develop.py

@@ -1,54 +1,39 @@
-from typing import Optional
+from __future__ import annotations
 
 from fastapi import FastAPI
 
+from idom.config import IDOM_DEBUG_MODE
 from idom.core.types import ComponentConstructor
 
 from .starlette import (
-    Config,
-    StarletteServer,
+    Options,
     _setup_common_routes,
-    _setup_config_and_app,
-    _setup_shared_view_dispatcher_route,
+    _setup_options,
     _setup_single_view_dispatcher_route,
+    serve_development_app,
 )
 
 
-def PerClientStateServer(
-    constructor: ComponentConstructor,
-    config: Optional[Config] = None,
-    app: Optional[FastAPI] = None,
-) -> StarletteServer:
-    """Return a :class:`StarletteServer` where each client has its own state.
-
-    Implements the :class:`~idom.server.proto.ServerFactory` protocol
+__all__ = "configure", "serve_development_app", "create_development_app"
 
-    Parameters:
-        constructor: A component constructor
-        config: Options for configuring server behavior
-        app: An application instance (otherwise a default instance is created)
-    """
-    config, app = _setup_config_and_app(config, app, FastAPI)
-    _setup_common_routes(config, app)
-    _setup_single_view_dispatcher_route(config["url_prefix"], app, constructor)
-    return StarletteServer(app)
 
-
-def SharedClientStateServer(
+def configure(
+    app: FastAPI,
     constructor: ComponentConstructor,
-    config: Optional[Config] = None,
-    app: Optional[FastAPI] = None,
-) -> StarletteServer:
-    """Return a :class:`StarletteServer` where each client shares state.
-
-    Implements the :class:`~idom.server.proto.ServerFactory` protocol
+    options: Options | None = None,
+) -> None:
+    """Prepare a :class:`FastAPI` server to serve the given component
 
     Parameters:
+        app: An application instance
         constructor: A component constructor
         config: Options for configuring server behavior
-        app: An application instance (otherwise a default instance is created)
+
     """
-    config, app = _setup_config_and_app(config, app, FastAPI)
-    _setup_common_routes(config, app)
-    _setup_shared_view_dispatcher_route(config["url_prefix"], app, constructor)
-    return StarletteServer(app)
+    options = _setup_options(options)
+    _setup_common_routes(options, app)
+    _setup_single_view_dispatcher_route(options["url_prefix"], app, constructor)
+
+
+def create_development_app() -> FastAPI:
+    return FastAPI(debug=IDOM_DEBUG_MODE.current)