more refactoring to standalone mode

Author: Archmonger

src/reactpy/backend/standalone.py

@@ -1,7 +1,7 @@
 import hashlib
 import os
 import re
-from collections.abc import Coroutine, Sequence
+from collections.abc import Coroutine
 from dataclasses import dataclass
 from email.utils import formatdate
 from logging import getLogger
@@ -10,7 +10,12 @@
 
 from reactpy import html
 from reactpy.backend.middleware import ReactPyMiddleware
-from reactpy.backend.utils import dict_to_byte_list, replace_many, vdom_head_to_html
+from reactpy.backend.utils import (
+    dict_to_byte_list,
+    http_response,
+    replace_many,
+    vdom_head_to_html,
+)
 from reactpy.core.types import VdomDict
 from reactpy.types import RootComponentConstructor
 
@@ -45,6 +50,9 @@ def __init__(
 
 @dataclass
 class ReactPyApp:
+    """ASGI app for ReactPy's standalone mode. This is utilized by `ReactPyMiddleware` as an alternative
+    to a user provided ASGI app."""
+
     parent: ReactPy
     _cached_index_html = ""
     _etag = ""
@@ -58,7 +66,6 @@ async def __call__(
         receive: Callable[..., Coroutine],
         send: Callable[..., Coroutine],
     ) -> None:
-        """ASGI app for ReactPy standalone mode."""
         if scope["type"] != "http":
             if scope["type"] != "lifespan":
                 msg = (
@@ -74,47 +81,41 @@ async def __call__(
         if not self._cached_index_html:
             self.process_index_html()
 
-        # Return headers for all HTTP responses
+        # Response headers for `index.html` responses
         request_headers = dict(scope["headers"])
         response_headers: dict[str, str | int] = {
             "etag": self._etag,
             "last-modified": self._last_modified,
             "access-control-allow-origin": "*",
             "cache-control": "max-age=60, public",
             "content-length": len(self._cached_index_html),
+            "content-type": "text/html; charset=utf-8",
             **self.parent.extra_headers,
         }
 
         # Browser is asking for the headers
         if scope["method"] == "HEAD":
             return await http_response(
-                scope["method"],
-                send,
-                200,
-                "",
-                content_type=b"text/html",
+                send=send,
+                method=scope["method"],
                 headers=dict_to_byte_list(response_headers),
             )
 
         # Browser already has the content cached
         if request_headers.get(b"if-none-match") == self._etag.encode():
             response_headers.pop("content-length")
             return await http_response(
-                scope["method"],
-                send,
-                304,
-                "",
-                content_type=b"text/html",
+                send=send,
+                method=scope["method"],
+                code=304,
                 headers=dict_to_byte_list(response_headers),
             )
 
         # Send the index.html
         await http_response(
-            scope["method"],
-            send,
-            200,
-            self._cached_index_html,
-            content_type=b"text/html",
+            send=send,
+            method=scope["method"],
+            message=self._cached_index_html,
             headers=dict_to_byte_list(response_headers),
         )
 
@@ -145,33 +146,3 @@ def process_index_html(self):
         self._last_modified = formatdate(
             os.stat(self._index_html_path).st_mtime, usegmt=True
         )
-
-
-async def http_response(
-    method: str,
-    send: Callable[..., Coroutine],
-    code: int,
-    message: str,
-    content_type: bytes = b"text/plain",
-    headers: Sequence = (),
-) -> None:
-    """Sends a HTTP response using the ASGI `send` API."""
-    # Head requests don't need body content
-    if method == "HEAD":
-        await send(
-            {
-                "type": "http.response.start",
-                "status": code,
-                "headers": [*headers],
-            }
-        )
-        await send({"type": "http.response.body"})
-    else:
-        await send(
-            {
-                "type": "http.response.start",
-                "status": code,
-                "headers": [(b"content-type", content_type), *headers],
-            }
-        )
-        await send({"type": "http.response.body", "body": message.encode()})

src/reactpy/backend/utils.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
 import logging
-import re
-from collections.abc import Iterable
+from collections.abc import Coroutine, Iterable, Sequence
 from importlib import import_module
-from typing import Any
+from typing import Any, Callable
 
 from reactpy.core.types import ComponentType, VdomDict
 from reactpy.utils import vdom_to_html
@@ -86,3 +85,23 @@ def vdom_head_to_html(head: VdomDict) -> str:
     raise ValueError(
         "Invalid head element! Element must be either `html.head` or a string."
     )
+
+
+async def http_response(
+    *,
+    send: Callable[[dict[str, Any]], Coroutine],
+    method: str,
+    code: int = 200,
+    message: str = "",
+    headers: Sequence = (),
+) -> None:
+    """Sends a HTTP response using the ASGI `send` API."""
+    start_msg = {"type": "http.response.start", "status": code, "headers": [*headers]}
+    body_msg: dict[str, str | bytes] = {"type": "http.response.body"}
+
+    # Add the content type and body to everything other than a HEAD request
+    if method != "HEAD":
+        body_msg["body"] = message.encode()
+
+    await send(start_msg)
+    await send(body_msg)