refactoring

Author: Archmonger

src/reactpy/__init__.py

@@ -1,5 +1,4 @@
 from reactpy import backend, config, html, logging, sample, svg, types, web, widgets
-from reactpy.backend.utils import run
 from reactpy.core import hooks
 from reactpy.core.component import component
 from reactpy.core.events import event
@@ -36,7 +35,6 @@
     "html",
     "html_to_vdom",
     "logging",
-    "run",
     "sample",
     "svg",
     "types",

src/reactpy/backend/middleware.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 import re
 import traceback
 import urllib.parse
 from collections.abc import Coroutine, Iterable
-from concurrent.futures import Future
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable
 
@@ -18,17 +20,15 @@
 from reactpy.core.hooks import ConnectionContext
 from reactpy.core.layout import Layout
 from reactpy.core.serve import serve_layout
-from reactpy.core.types import ComponentType
+from reactpy.types import RootComponentConstructor
 
 _logger = logging.getLogger(__name__)
 
 
 class ReactPyMiddleware:
     _asgi_single_callable = True
-    servestatic_static: ServeStaticASGI | None = None
-    servestatic_web_modules: ServeStaticASGI | None = None
     single_root_component: bool = False
-    root_component: ComponentType | None = None
+    root_component: RootComponentConstructor | None = None
 
     def __init__(
         self,
@@ -40,7 +40,7 @@ def __init__(
         web_modules_dir: Path | None = None,
     ) -> None:
         """Configure the ASGI app. Anything initialized in this method will be shared across all future requests."""
-        # Configure class attributes
+        # URL path attributes
         self.path_prefix = normalize_url_path(path_prefix)
         self.dispatcher_path = f"/{self.path_prefix}/"
         self.web_modules_path = f"/{self.path_prefix}/modules/"
@@ -50,19 +50,27 @@ def __init__(
         )
         self.js_modules_pattern = re.compile(f"^{self.web_modules_path}.*")
         self.static_pattern = re.compile(f"^{self.static_path}.*")
-        self.web_modules_dir = web_modules_dir or REACTPY_WEB_MODULES_DIR.current
-        self.static_dir = Path(__file__).parent.parent / "static"
+
+        # Component attributes
         self.user_app = guarantee_single_callable(app)
         self.component_dotted_paths = set(root_components)
-        self.components: dict[str, ComponentType] = import_components(
+        self.components: dict[str, RootComponentConstructor] = import_components(
             self.component_dotted_paths
         )
 
+        # Directory attributes
+        self.web_modules_dir = web_modules_dir or REACTPY_WEB_MODULES_DIR.current
+        self.static_dir = Path(__file__).parent.parent / "static"
         if self.web_modules_dir != REACTPY_WEB_MODULES_DIR.current:
             REACTPY_WEB_MODULES_DIR.set_current(self.web_modules_dir)
 
-        # Validate the arguments
-        reason = check_path(self.path_prefix)
+        # Sub-applications
+        self.component_dispatch_app = ComponentDispatchApp(parent=self)
+        self.static_file_app = StaticFileApp(parent=self)
+        self.web_modules_app = WebModuleApp(parent=self)
+
+        # Validate the configuration
+        reason = check_path(path_prefix)
         if reason:
             raise ValueError(f"Invalid `path_prefix`. {reason}")
 
@@ -78,25 +86,39 @@ async def __call__(
         if scope["type"] == "websocket" and self.match_dispatch_path(scope):
             return await self.component_dispatch_app(scope, receive, send)
 
-        # URL routing for ReactPy web modules
-        if scope["type"] == "http" and re.match(self.js_modules_pattern, scope["path"]):
-            return await self.web_module_app(scope, receive, send)
-
         # URL routing for ReactPy static files
-        if scope["type"] == "http" and re.match(self.static_pattern, scope["path"]):
+        if scope["type"] == "http" and self.match_static_path(scope):
             return await self.static_file_app(scope, receive, send)
 
+        # URL routing for ReactPy web modules
+        if scope["type"] == "http" and self.match_web_modules_path(scope):
+            return await self.web_modules_app(scope, receive, send)
+
         # Serve the user's application
         await self.user_app(scope, receive, send)
 
-    async def component_dispatch_app(
+    def match_dispatch_path(self, scope: dict) -> bool:
+        return bool(re.match(self.dispatcher_pattern, scope["path"]))
+
+    def match_static_path(self, scope: dict) -> bool:
+        return bool(re.match(self.static_pattern, scope["path"]))
+
+    def match_web_modules_path(self, scope: dict) -> bool:
+        return bool(re.match(self.js_modules_pattern, scope["path"]))
+
+
+@dataclass
+class ComponentDispatchApp:
+    parent: ReactPyMiddleware
+
+    async def __call__(
         self,
         scope: dict[str, Any],
         receive: Callable[..., Coroutine],
         send: Callable[..., Coroutine],
     ) -> None:
         """ASGI app for rendering ReactPy Python components."""
-        dispatcher: Future | asyncio.Task | None = None
+        dispatcher: asyncio.Task | None = None
         recv_queue: asyncio.Queue = asyncio.Queue()
 
         # Start a loop that handles ASGI websocket events
@@ -117,52 +139,6 @@ async def component_dispatch_app(
                 queue_put_func = recv_queue.put(orjson.loads(event["text"]))
                 await queue_put_func
 
-    async def web_module_app(
-        self,
-        scope: dict[str, Any],
-        receive: Callable[..., Coroutine],
-        send: Callable[..., Coroutine],
-    ) -> None:
-        """ASGI app for ReactPy web modules."""
-        if not self.web_modules_dir:
-            await asyncio.to_thread(
-                _logger.info,
-                "Tried to serve web module without a configured directory.",
-            )
-            return await self.user_app(scope, receive, send)
-
-        if not self.servestatic_web_modules:
-            self.servestatic_web_modules = ServeStaticASGI(
-                self.user_app,
-                root=self.web_modules_dir,
-                prefix=self.web_modules_path,
-                autorefresh=True,
-            )
-
-        return await self.servestatic_web_modules(scope, receive, send)
-
-    async def static_file_app(
-        self,
-        scope: dict[str, Any],
-        receive: Callable[..., Coroutine],
-        send: Callable[..., Coroutine],
-    ) -> None:
-        """ASGI app for ReactPy static files."""
-        # If no static directory is configured, serve the user's application
-        if not self.static_dir:
-            await asyncio.to_thread(
-                _logger.info,
-                "Tried to serve static file without a configured directory.",
-            )
-            return await self.user_app(scope, receive, send)
-
-        if not self.servestatic_static:
-            self.servestatic_static = ServeStaticASGI(
-                self.user_app, root=self.static_dir, prefix=self.static_path
-            )
-
-        return await self.servestatic_static(scope, receive, send)
-
     async def run_dispatcher(
         self,
         scope: dict[str, Any],
@@ -172,20 +148,23 @@ async def run_dispatcher(
     ) -> None:
         # Get the component from the URL.
         try:
-            if not self.single_root_component:
-                url_match = re.match(self.dispatcher_pattern, scope["path"])
+            if not self.parent.single_root_component:
+                url_match = re.match(self.parent.dispatcher_pattern, scope["path"])
                 if not url_match:
                     raise RuntimeError("Could not find component in URL path.")
                 dotted_path = url_match[1]
-                component = self.components[dotted_path]
+                component = self.parent.components[dotted_path]
+            elif self.parent.root_component:
+                component = self.parent.root_component
             else:
-                component = self.root_component
+                raise RuntimeError("No root component provided.")
+
             parsed_url = urllib.parse.urlparse(scope["path"])
 
             await serve_layout(
                 Layout(  # type: ignore
                     ConnectionContext(
-                        component,
+                        component(),
                         value=Connection(
                             scope=scope,
                             location=Location(
@@ -200,24 +179,77 @@ async def run_dispatcher(
                         ),
                     )
                 ),
-                self.send_json_ws(send),
+                self.send_json(send),
                 recv_queue.get,
             )
         except Exception as error:
             await asyncio.to_thread(_logger.error, f"{error}\n{traceback.format_exc()}")
 
     @staticmethod
-    def send_json_ws(send: Callable) -> Callable[..., Coroutine]:
+    def send_json(send: Callable) -> Callable[..., Coroutine]:
         """Use orjson to send JSON over an ASGI websocket."""
 
         async def _send_json(value: Any) -> None:
             await send({"type": "websocket.send", "text": orjson.dumps(value).decode()})
 
         return _send_json
 
-    def match_dispatch_path(self, scope: dict) -> bool:
-        match = re.match(self.dispatcher_pattern, scope["path"])
-        return bool(
-            match
-            and match.groupdict().get("dotted_path") in self.component_dotted_paths
-        )
+
+@dataclass
+class StaticFileApp:
+    parent: ReactPyMiddleware
+    _static_file_server: ServeStaticASGI | None = None
+
+    async def __call__(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
+        """ASGI app for ReactPy static files."""
+        # If no static directory is configured, serve the user's application
+        if not self.parent.static_dir:
+            await asyncio.to_thread(
+                _logger.info,
+                "Tried to serve static file without a configured directory.",
+            )
+            return await self.parent.user_app(scope, receive, send)
+
+        if not self._static_file_server:
+            self._static_file_server = ServeStaticASGI(
+                self.parent.user_app,
+                root=self.parent.static_dir,
+                prefix=self.parent.static_path,
+            )
+
+        return await self._static_file_server(scope, receive, send)
+
+
+@dataclass
+class WebModuleApp:
+    parent: ReactPyMiddleware
+    _static_file_server: ServeStaticASGI | None = None
+
+    async def __call__(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
+        """ASGI app for ReactPy web modules."""
+        if not self.parent.web_modules_dir:
+            await asyncio.to_thread(
+                _logger.info,
+                "Tried to serve web module without a configured directory.",
+            )
+            return await self.parent.user_app(scope, receive, send)
+
+        if not self._static_file_server:
+            self._static_file_server = ServeStaticASGI(
+                self.parent.user_app,
+                root=self.parent.web_modules_dir,
+                prefix=self.parent.web_modules_path,
+                autorefresh=True,
+            )
+
+        return await self._static_file_server(scope, receive, send)

src/reactpy/backend/standalone.py

@@ -7,40 +7,46 @@
 from pathlib import Path
 from typing import Any, Callable
 
+from reactpy import html
 from reactpy.backend.middleware import ReactPyMiddleware
-from reactpy.backend.utils import dict_to_byte_list, find_and_replace
-from reactpy.core.types import ComponentType
+from reactpy.backend.utils import dict_to_byte_list, find_and_replace, vdom_head_to_html
+from reactpy.core.types import VdomDict
+from reactpy.types import RootComponentConstructor
 
 _logger = getLogger(__name__)
 
 
-class ReactPyStandalone(ReactPyMiddleware):
-    cached_index_html: str = ""
-    etag: str = ""
-    last_modified: str = ""
+class ReactPy(ReactPyMiddleware):
+    cached_index_html = ""
+    etag = ""
+    last_modified = ""
     templates_dir = Path(__file__).parent.parent / "templates"
     index_html_path = templates_dir / "index.html"
-    single_root_component: bool = True
+    single_root_component = True
 
     def __init__(
         self,
-        root_component: ComponentType,
+        root_component: RootComponentConstructor,
         *,
         path_prefix: str = "reactpy/",
         web_modules_dir: Path | None = None,
         http_headers: dict[str, str | int] | None = None,
+        html_head: VdomDict | None = None,
+        html_lang: str = "en",
     ) -> None:
         super().__init__(
-            app=self.standalone_app,
+            app=self.reactpy_app,
             root_components=[],
             path_prefix=path_prefix,
             web_modules_dir=web_modules_dir,
         )
         self.root_component = root_component
         self.extra_headers = http_headers or {}
         self.dispatcher_pattern = re.compile(f"^{self.dispatcher_path}?")
+        self.html_head = html_head or html.head()
+        self.html_lang = html_lang
 
-    async def standalone_app(
+    async def reactpy_app(
         self,
         scope: dict[str, Any],
         receive: Callable[..., Coroutine],
@@ -119,6 +125,8 @@ async def process_index_html(self):
             cached_index_html,
             {
                 'from "index.ts"': f'from "{self.static_path}index.js"',
+                '<html lang="en">': f'<html lang="{self.html_lang}">',
+                "<head></head>": vdom_head_to_html(self.html_head),
                 "{path_prefix}": self.path_prefix,
                 "{reconnect_interval}": "750",
                 "{reconnect_max_interval}": "60000",
@@ -131,9 +139,9 @@ async def process_index_html(self):
             self.cached_index_html.encode(), usedforsecurity=False
         ).hexdigest()
         self.etag = f'"{self.etag}"'
-
-        last_modified = os.stat(self.index_html_path).st_mtime
-        self.last_modified = formatdate(last_modified, usegmt=True)
+        self.last_modified = formatdate(
+            os.stat(self.index_html_path).st_mtime, usegmt=True
+        )
 
 
 async def http_response(