get sanic and flask to work

still need to rework how modules are accessed

Author: rmorshea

requirements/pkg-extras.txt

@@ -11,10 +11,10 @@ fastapi >=0.63.0
 uvicorn[standard] >=0.13.4
 
 # extra=flask
-flask<2.0
+flask
 markupsafe<2.1
 flask-cors
-flask-sockets
+flask-sock
 
 # extra=tornado
 tornado

src/idom/server/flask.py

@@ -22,10 +22,10 @@
     url_for,
 )
 from flask_cors import CORS
-from flask_sockets import Sockets
+from flask_sock import Sock
 from gevent import pywsgi
 from geventwebsocket.handler import WebSocketHandler
-from geventwebsocket.websocket import WebSocket
+from simple_websocket import Server as WebSocket
 
 import idom
 from idom.config import IDOM_WEB_MODULES_DIR
@@ -185,9 +185,10 @@ def redirect_to_index() -> Any:
 def _setup_single_view_dispatcher_route(
     app: Flask, options: Options, constructor: RootComponentConstructor
 ) -> None:
-    sockets = Sockets(app)
+    sockets = Sock(app)
 
-    @sockets.route(_join_url_paths(options.url_prefix, "/app<path:path>/_stream"))  # type: ignore
+    @sockets.route(_join_url_paths(options.url_prefix, "/app/_stream"))
+    @sockets.route(_join_url_paths(options.url_prefix, "/app/<path:path>/_stream"))
     def model_stream(ws: WebSocket) -> None:
         def send(value: Any) -> None:
             ws.send(json.dumps(value))

src/idom/server/sanic.py

@@ -25,12 +25,12 @@
 from idom.core.types import RootComponentConstructor
 
 from ._asgi import serve_development_asgi
-from .utils import CLIENT_BUILD_DIR
+from .utils import CLIENT_BUILD_DIR, client_build_dir_path
 
 
 logger = logging.getLogger(__name__)
 
-RequestContext: type[Context[request.Request | None]] = create_context(
+ConnectionContext: type[Context[request.Request | None]] = create_context(
     None, "RequestContext"
 )
 
@@ -65,9 +65,9 @@ async def serve_development_app(
     await serve_development_asgi(app, host, port, started)
 
 
-def use_request() -> request.Request:
+def use_connection() -> Connection:
     """Get the current ``Request``"""
-    request = use_context(RequestContext)
+    request = use_context(ConnectionContext)
     if request is None:
         raise RuntimeError(  # pragma: no cover
             "No request. Are you running with a Sanic server?"
@@ -77,7 +77,7 @@ def use_request() -> request.Request:
 
 def use_scope() -> ASGIScope:
     """Get the current ASGI scope"""
-    app = use_request().app
+    app = use_connection().request.app
     try:
         asgi_app = app._asgi_app
     except AttributeError:  # pragma: no cover
@@ -112,7 +112,16 @@ def _setup_common_routes(blueprint: Blueprint, options: Options) -> None:
         CORS(blueprint, **cors_params)
 
     if options.serve_static_files:
-        blueprint.static("/app", str(CLIENT_BUILD_DIR))
+
+        @blueprint.route("/app")
+        @blueprint.route("/app/<path:path>")
+        async def single_page_app_files(
+            request: request.Request, path: str = ""
+        ) -> response.HTTPResponse:
+            return await response.file(
+                str(CLIENT_BUILD_DIR / client_build_dir_path(path))
+            )
+
         blueprint.static("/modules", str(IDOM_WEB_MODULES_DIR.current))
 
         if options.redirect_root:
@@ -121,26 +130,44 @@ def _setup_common_routes(blueprint: Blueprint, options: Options) -> None:
             def redirect_to_index(
                 request: request.Request,
             ) -> response.HTTPResponse:
-                return response.redirect(
-                    f"{blueprint.url_prefix}/client/index.html?{request.query_string}"
-                )
+                if request.query_string:
+                    path = f"{blueprint.url_prefix}/app?{request.query_string}"
+                else:
+                    path = f"{blueprint.url_prefix}/app"
+                return response.redirect(path)
 
 
 def _setup_single_view_dispatcher_route(
     blueprint: Blueprint, constructor: RootComponentConstructor
 ) -> None:
-    @blueprint.websocket("/app<path:path>/_stream")  # type: ignore
+    @blueprint.websocket("/app/_stream")
+    @blueprint.websocket("/app/<path:path>/_stream")  # type: ignore
     async def model_stream(
-        request: request.Request, socket: WebSocketCommonProtocol
+        request: request.Request, socket: WebSocketCommonProtocol, path: str = ""
     ) -> None:
         send, recv = _make_send_recv_callbacks(socket)
+        conn = Connection(request, socket, path)
         await serve_json_patch(
-            Layout(RequestContext(constructor(), value=request)),
+            Layout(ConnectionContext(constructor(), value=conn)),
             send,
             recv,
         )
 
 
+@dataclass
+class Connection:
+    """A simple wrapper for holding"""
+
+    request: request.Request
+    """The current request object"""
+
+    socket: WebSocketCommonProtocol
+    """A handle to the current websocket"""
+
+    path: str
+    """The current path being served"""
+
+
 def _make_send_recv_callbacks(
     socket: WebSocketCommonProtocol,
 ) -> Tuple[SendCoroutine, RecvCoroutine]:

src/idom/server/starlette.py

@@ -4,7 +4,7 @@
 import json
 import logging
 from dataclasses import dataclass
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Awaitable, Callable, Dict, Tuple, Union
 
 from starlette.applications import Starlette
 from starlette.middleware.cors import CORSMiddleware
@@ -122,7 +122,7 @@ def _setup_common_routes(options: Options, app: Starlette) -> None:
 
     if options.serve_static_files:
 
-        mount_serve_single_page_app_files(app, url_prefix)
+        app.mount(url_prefix + "/app", single_page_app_files())
 
         app.mount(
             f"{url_prefix}/modules",
@@ -145,7 +145,7 @@ def redirect_to_index(request: Request) -> RedirectResponse:
                 return RedirectResponse(redirect_url)
 
 
-def mount_serve_single_page_app_files(app: Starlette, url_prefix: str) -> None:
+def single_page_app_files() -> Callable[..., Awaitable[None]]:
     asgi_app = StaticFiles(
         directory=CLIENT_BUILD_DIR,
         html=True,
@@ -159,14 +159,18 @@ async def spa_app(scope: Scope, receive: Receive, send: Send) -> None:
             send,
         )
 
-    app.mount(url_prefix + "/app", spa_app)
+    return spa_app
 
 
 def _setup_single_view_dispatcher_route(
     url_prefix: str, app: Starlette, constructor: RootComponentConstructor
 ) -> None:
-    @app.websocket_route(url_prefix + "/app{path:path}/_stream")
+    @app.websocket_route(url_prefix + "/app/_stream")
+    @app.websocket_route(url_prefix + "/app/{path:path}/_stream")
     async def model_stream(socket: WebSocket) -> None:
+        path_params: dict[str, str] = socket.scope["path_params"]
+        path_params.setdefault("path", "")
+
         await socket.accept()
         send, recv = _make_send_recv_callbacks(socket)
         try:

temp.py

@@ -1,5 +1,5 @@
 import idom
-from idom.server import tornado as server
+from idom.server import sanic as server
 
 
 @idom.component