add use_connection hook

Author: rmorshea

src/idom/__init__.py

@@ -1,4 +1,5 @@
 from . import backend, config, html, logging, sample, types, web
+from .backend.hooks import use_connection, use_location, use_scope
 from .backend.utils import run
 from .core import hooks
 from .core.component import component
@@ -25,6 +26,7 @@
 __version__ = "0.40.2"  # DO NOT MODIFY
 
 __all__ = [
+    "backend",
     "component",
     "config",
     "create_context",
@@ -38,16 +40,18 @@
     "Ref",
     "run",
     "sample",
-    "backend",
     "Stop",
     "types",
     "use_callback",
+    "use_connection",
     "use_context",
     "use_debug_value",
     "use_effect",
+    "use_location",
     "use_memo",
     "use_reducer",
     "use_ref",
+    "use_scope",
     "use_state",
     "vdom",
     "web",

src/idom/backend/default.py

@@ -5,7 +5,7 @@
 
 from idom.types import RootComponentConstructor
 
-from .types import BackendImplementation, Location
+from .types import BackendImplementation
 from .utils import all_implementations
 
 
@@ -35,16 +35,6 @@ async def serve_development_app(
     )
 
 
-def use_scope() -> Any:
-    """Return the current ASGI/WSGI scope"""
-    return _default_implementation().use_scope()
-
-
-def use_location() -> Location:
-    """Return the current route as a string"""
-    return _default_implementation().use_location()
-
-
 _DEFAULT_IMPLEMENTATION: BackendImplementation[Any] | None = None
 
 

src/idom/backend/fastapi.py

@@ -8,16 +8,10 @@
 serve_development_app = starlette.serve_development_app
 """Alias for :func:`idom.backend.starlette.serve_development_app`"""
 
-# see: https://github.com/idom-team/flake8-idom-hooks/issues/12
-use_location = starlette.use_location  # noqa: ROH101
+use_connection = starlette.use_connection
 """Alias for :func:`idom.backend.starlette.use_location`"""
 
-# see: https://github.com/idom-team/flake8-idom-hooks/issues/12
-use_scope = starlette.use_scope  # noqa: ROH101
-"""Alias for :func:`idom.backend.starlette.use_scope`"""
-
-# see: https://github.com/idom-team/flake8-idom-hooks/issues/12
-use_websocket = starlette.use_websocket  # noqa: ROH101
+use_websocket = starlette.use_websocket
 """Alias for :func:`idom.backend.starlette.use_websocket`"""
 
 Options = starlette.Options

src/idom/backend/flask.py

@@ -22,11 +22,13 @@
 from flask_cors import CORS
 from flask_sock import Sock
 from simple_websocket import Server as WebSocket
+from werkzeug.local import LocalProxy
 from werkzeug.serving import BaseWSGIServer, make_server
 
 import idom
-from idom.backend.types import Location
-from idom.core.hooks import Context, create_context, use_context
+from idom.backend.hooks import ConnectionContext
+from idom.backend.hooks import use_connection as _use_connection
+from idom.backend.types import Connection, Location
 from idom.core.layout import LayoutEvent, LayoutUpdate
 from idom.core.serve import serve_json_patch
 from idom.core.types import ComponentType, RootComponentConstructor
@@ -37,8 +39,6 @@
 
 logger = logging.getLogger(__name__)
 
-ConnectionContext: Context[Connection | None] = create_context(None)
-
 
 def configure(
     app: Flask, component: RootComponentConstructor, options: Options | None = None
@@ -107,45 +107,25 @@ def run_server() -> None:
             raise RuntimeError("Failed to shutdown server.")
 
 
-def use_location() -> Location:
-    """Get the current route as a string"""
-    conn = use_connection()
-    search = conn.request.query_string.decode()
-    return Location(pathname="/" + conn.path, search="?" + search if search else "")
-
-
-def use_scope() -> dict[str, Any]:
-    """Get the current WSGI environment"""
-    return use_request().environ
+def use_websocket() -> WebSocket:
+    """A handle to the current websocket"""
+    return use_connection().carrier.websocket
 
 
-def use_request() -> Request:
+def use_request() -> LocalProxy[Request]:
     """Get the current ``Request``"""
-    return use_connection().request
+    return use_connection().carrier.request
 
 
-def use_connection() -> Connection:
+def use_connection() -> Connection[_FlaskCarrier]:
     """Get the current :class:`Connection`"""
-    connection = use_context(ConnectionContext)
-    if connection is None:
-        raise RuntimeError(  # pragma: no cover
-            "No connection. Are you running with a Flask server?"
+    conn = _use_connection()
+    if not isinstance(conn.carrier, _FlaskCarrier):
+        raise TypeError(  # pragma: no cover
+            f"Connection has unexpected carrier {conn.carrier}. "
+            "Are you running with a Flask server?"
         )
-    return connection
-
-
-@dataclass
-class Connection:
-    """A simple wrapper for holding connection information"""
-
-    request: Request
-    """The current request object"""
-
-    websocket: WebSocket
-    """A handle to the current websocket"""
-
-    path: str
-    """The current path being served"""
+    return conn
 
 
 @dataclass
@@ -230,11 +210,20 @@ async def recv_coro() -> Any:
             return await async_recv_queue.get()
 
         async def main() -> None:
+            search = request.query_string.decode()
             await serve_json_patch(
                 idom.Layout(
                     ConnectionContext(
-                        component, value=Connection(request, websocket, path)
-                    )
+                        component,
+                        value=Connection(
+                            scope=request.environ,
+                            location=Location(
+                                pathname=f"/{path}",
+                                search=f"?{search}" if search else "",
+                            ),
+                            carrier=_FlaskCarrier(request, websocket),
+                        ),
+                    ),
                 ),
                 send_coro,
                 recv_coro,
@@ -283,3 +272,14 @@ class _DispatcherThreadInfo(NamedTuple):
     dispatch_future: "asyncio.Future[Any]"
     thread_send_queue: "ThreadQueue[LayoutUpdate]"
     async_recv_queue: "AsyncQueue[LayoutEvent]"
+
+
+@dataclass
+class _FlaskCarrier:
+    """A simple wrapper for holding a Flask request and WebSocket"""
+
+    request: Request
+    """The current request object"""
+
+    websocket: WebSocket
+    """A handle to the current websocket"""

src/idom/backend/hooks.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any, MutableMapping
+
+from idom.core.hooks import Context, create_context, use_context
+
+from .types import Connection, Location
+
+
+# backend implementations should establish this context at the root of an app
+ConnectionContext: Context[Connection[Any] | None] = create_context(None)
+
+
+def use_connection() -> Connection[Any]:
+    conn = use_context(ConnectionContext)
+    if conn is None:
+        raise RuntimeError("No backend established a connection.")  # pragma: no cover
+    return conn
+
+
+def use_scope() -> MutableMapping[str, Any]:
+    return use_connection().scope
+
+
+def use_location() -> Location:
+    return use_connection().location

src/idom/backend/sanic.py

@@ -4,18 +4,17 @@
 import json
 import logging
 from dataclasses import dataclass
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, MutableMapping, Tuple, Union
 from urllib import parse as urllib_parse
 from uuid import uuid4
 
 from sanic import Blueprint, Sanic, request, response
 from sanic.config import Config
 from sanic.models.asgi import ASGIScope
+from sanic.server.websockets.connection import WebSocketConnection
 from sanic_cors import CORS
-from websockets.legacy.protocol import WebSocketCommonProtocol
 
-from idom.backend.types import Location
-from idom.core.hooks import Context, create_context, use_context
+from idom.backend.types import Connection, Location
 from idom.core.layout import Layout, LayoutEvent
 from idom.core.serve import (
     RecvCoroutine,
@@ -27,13 +26,13 @@
 from idom.core.types import RootComponentConstructor
 
 from ._asgi import serve_development_asgi
+from .hooks import ConnectionContext
+from .hooks import use_connection as _use_connection
 from .utils import safe_client_build_dir_path, safe_web_modules_dir_path
 
 
 logger = logging.getLogger(__name__)
 
-ConnectionContext: Context[Connection | None] = create_context(None)
-
 
 def configure(
     app: Sanic, component: RootComponentConstructor, options: Options | None = None
@@ -65,50 +64,25 @@ async def serve_development_app(
     await serve_development_asgi(app, host, port, started)
 
 
-def use_location() -> Location:
-    """Get the current route as a string"""
-    conn = use_connection()
-    search = conn.request.query_string
-    return Location(pathname="/" + conn.path, search="?" + search if search else "")
-
-
-def use_scope() -> ASGIScope:
-    """Get the current ASGI scope"""
-    app = use_request().app
-    try:
-        asgi_app = app._asgi_app
-    except AttributeError:  # pragma: no cover
-        raise RuntimeError("No scope. Sanic may not be running with an ASGI server")
-    return asgi_app.transport.scope
-
-
 def use_request() -> request.Request:
     """Get the current ``Request``"""
-    return use_connection().request
-
-
-def use_connection() -> Connection:
-    """Get the current :class:`Connection`"""
-    connection = use_context(ConnectionContext)
-    if connection is None:
-        raise RuntimeError(  # pragma: no cover
-            "No connection. Are you running with a Sanic server?"
-        )
-    return connection
+    return use_connection().carrier.request
 
 
-@dataclass
-class Connection:
-    """A simple wrapper for holding connection information"""
+def use_websocket() -> WebSocketConnection:
+    """Get the current websocket"""
+    return use_connection().carrier.websocket
 
-    request: request.Request
-    """The current request object"""
 
-    websocket: WebSocketCommonProtocol
-    """A handle to the current websocket"""
-
-    path: str
-    """The current path being served"""
+def use_connection() -> Connection[_SanicCarrier]:
+    """Get the current :class:`Connection`"""
+    conn = _use_connection()
+    if not isinstance(conn.carrier, _SanicCarrier):
+        raise TypeError(  # pragma: no cover
+            f"Connection has unexpected carrier {conn.carrier}. "
+            "Are you running with a Sanic server?"
+        )
+    return conn
 
 
 @dataclass
@@ -165,12 +139,36 @@ def _setup_single_view_dispatcher_route(
     blueprint: Blueprint, constructor: RootComponentConstructor
 ) -> None:
     async def model_stream(
-        request: request.Request, socket: WebSocketCommonProtocol, path: str = ""
+        request: request.Request, socket: WebSocketConnection, path: str = ""
     ) -> None:
+        app = request.app
+        try:
+            asgi_app = app._asgi_app
+        except AttributeError:  # pragma: no cover
+            logger.warning("No scope. Sanic may not be running with an ASGI server")
+            scope: MutableMapping[str, Any] = {}
+        else:
+            scope = asgi_app.transport.scope
+
         send, recv = _make_send_recv_callbacks(socket)
-        conn = Connection(request, socket, path)
         await serve_json_patch(
-            Layout(ConnectionContext(constructor(), value=conn)),
+            Layout(
+                ConnectionContext(
+                    constructor(),
+                    value=Connection(
+                        scope=scope,
+                        location=Location(
+                            pathname=f"/{path}",
+                            search=(
+                                f"?{request.query_string}"
+                                if request.query_string
+                                else ""
+                            ),
+                        ),
+                        carrier=_SanicCarrier(request, socket),
+                    ),
+                )
+            ),
             send,
             recv,
         )
@@ -180,7 +178,7 @@ async def model_stream(
 
 
 def _make_send_recv_callbacks(
-    socket: WebSocketCommonProtocol,
+    socket: WebSocketConnection,
 ) -> Tuple[SendCoroutine, RecvCoroutine]:
     async def sock_send(value: VdomJsonPatch) -> None:
         await socket.send(json.dumps(value))
@@ -192,3 +190,14 @@ async def sock_recv() -> LayoutEvent:
         return LayoutEvent(**json.loads(data))
 
     return sock_send, sock_recv
+
+
+@dataclass
+class _SanicCarrier:
+    """A simple wrapper for holding connection information"""
+
+    request: request.Request
+    """The current request object"""
+
+    websocket: WebSocketConnection
+    """A handle to the current websocket"""