initial work to move away from run func

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.prefab import run
+from .server.develop import develop
 from .utils import Ref, html_to_vdom
 from .widgets import hotswap, multiview
 
@@ -38,7 +38,6 @@
     "multiview",
     "Ref",
     "run_sample_app",
-    "run",
     "Stop",
     "types",
     "use_callback",

src/idom/sample.py

@@ -3,17 +3,15 @@
 import webbrowser
 from typing import Any
 
-from idom.server.types import ServerType
-
 from . import html
 from .core.component import component
 from .core.types import VdomDict
-from .server.utils import find_available_port, find_builtin_server_type
+from .server.develop import develop
 
 
 @component
 def App() -> VdomDict:
-    return html.div(
+    return html._(
         {"style": {"padding": "15px"}},
         html.h1("Sample Application"),
         html.p(
@@ -31,30 +29,12 @@ def run_sample_app(
     host: str = "127.0.0.1",
     port: int | None = None,
     open_browser: bool = False,
-    run_in_thread: bool | None = None,
-) -> ServerType[Any]:
+) -> None:
     """Run a sample application.
 
     Args:
         host: host where the server should run
         port: the port on the host to serve from
         open_browser: whether to open a browser window after starting the server
     """
-    port = port or find_available_port(host)
-    server_type = find_builtin_server_type("PerClientStateServer")
-    server = server_type(App)
-
-    run_in_thread = open_browser or run_in_thread
-
-    if not run_in_thread:  # pragma: no cover
-        server.run(host=host, port=port)
-        return server
-
-    thread = server.run_in_thread(host=host, port=port)
-    server.wait_until_started(5)
-
-    if open_browser:  # pragma: no cover
-        webbrowser.open(f"http://{host}:{port}")
-        thread.join()
-
-    return server
+    develop(App, None, host, port, open_browser=open_browser)

src/idom/server/develop.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import asyncio
+import warnings
+import webbrowser
+from importlib import import_module
+from typing import Any, Awaitable, 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 develop(
+    component: ComponentConstructor,
+    app: Any | None = None,
+    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,
+    )
+
+    implementation = _get_implementation(app)
+
+    if app is None:
+        app = implementation.create_development_app()
+
+    implementation.configure_development_view(component)
+
+    coros: list[Awaitable] = []
+
+    host = host
+    port = port or find_available_port(host)
+    server_did_start = asyncio.Event()
+
+    coros.append(
+        implementation.serve_development_app(
+            app,
+            host=host,
+            port=port,
+            did_start=server_did_start,
+        )
+    )
+
+    if open_browser:
+        coros.append(_open_browser_after_server(host, port, server_did_start))
+
+    asyncio.get_event_loop().run_forever(asyncio.gather(*coros))
+
+
+async def _open_browser_after_server(
+    host: str,
+    port: int,
+    server_did_start: asyncio.Event,
+) -> None:
+    await server_did_start.wait()
+    webbrowser.open(f"http://{host}:{port}")
+
+
+def _get_implementation(app: _App | None) -> _Implementation:
+    implementations = _all_implementations()
+
+    if app is None:
+        return next(iter(implementations.values()))
+
+    for cls in type(app).mro():
+        if cls in implementations:
+            return implementations[cls]
+    else:
+        raise TypeError(f"No built-in and installed implementation supports {app}")
+
+
+def _all_implementations() -> dict[type[Any], _Implementation]:
+    if not _INSTALLED_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")
+
+            _INSTALLED_IMPLEMENTATIONS[module.SERVER_TYPE] = module
+
+    if not _INSTALLED_IMPLEMENTATIONS:
+        raise RuntimeError("No built-in implementations are installed")
+
+    return _INSTALLED_IMPLEMENTATIONS
+
+
+_App = TypeVar("_App")
+
+
+@runtime_checkable
+class _Implementation(Protocol):
+
+    APP_TYPE = type[Any]
+
+    def create_development_app(self) -> Any:
+        ...
+
+    def configure_development_view(self, component: ComponentConstructor) -> None:
+        ...
+
+    async def serve_development_app(
+        self,
+        app: Any,
+        host: str,
+        port: int,
+        did_start: asyncio.Event,
+    ) -> None:
+        ...
+
+
+_INSTALLED_IMPLEMENTATIONS: dict[type[Any], _Implementation[Any]] = {}