use starlette for static files

Author: Archmonger

src/py/reactpy/reactpy/backend/asgi.py

@@ -1,37 +1,37 @@
 import asyncio
 import logging
-import mimetypes
-import os
 import re
 import urllib.parse
 from collections.abc import Coroutine, Sequence
+from concurrent.futures import Future
+from importlib import import_module
 from pathlib import Path
 from threading import Thread
+from typing import Any, Callable
 
 import aiofiles
 import orjson
 from asgiref.compatibility import guarantee_single_callable
+from starlette.staticfiles import StaticFiles
 
 from reactpy.backend._common import (
     CLIENT_BUILD_DIR,
-    safe_join_path,
     vdom_head_elements_to_html,
 )
 from reactpy.backend.hooks import ConnectionContext
-from reactpy.backend.mimetypes import MIME_TYPES
 from reactpy.backend.types import Connection, Location
 from reactpy.config import REACTPY_WEB_MODULES_DIR
 from reactpy.core.layout import Layout
 from reactpy.core.serve import serve_layout
 from reactpy.core.types import ComponentConstructor, VdomDict
-from concurrent.futures import Future
 
 _logger = logging.getLogger(__name__)
 _backhaul_loop = asyncio.new_event_loop()
 
 
 def start_backhaul_loop():
-    """Starts the asyncio event loop that will perform component rendering tasks."""
+    """Starts the asyncio event loop that will perform component rendering
+    tasks."""
     asyncio.set_event_loop(_backhaul_loop)
     _backhaul_loop.run_forever()
 
@@ -42,7 +42,7 @@ def start_backhaul_loop():
 class ReactPy:
     def __init__(
         self,
-        app_or_component: ComponentConstructor | Coroutine,
+        app_or_component: ComponentConstructor | Callable[..., Coroutine],
         *,
         dispatcher_path: str = "^reactpy/([^/]+)/?",
         js_modules_path: str | None = "^reactpy/modules/([^/]+)/?",
@@ -62,35 +62,43 @@ def __init__(
         self.block_size = block_size
 
         # Internal attributes (not using the same name as a kwarg)
-        self.component: re.Pattern = (
-            app_or_component
-            if isinstance(app_or_component, ComponentConstructor)
-            else None
-        )
-        self.user_app: re.Pattern = (
+        self.user_app: Callable[..., Coroutine] | None = (
             guarantee_single_callable(app_or_component)
-            if not self.component and asyncio.iscoroutinefunction(app_or_component)
+            if asyncio.iscoroutinefunction(app_or_component)
             else None
         )
+        self.component: ComponentConstructor | None = (
+            None if self.user_app else app_or_component
+        )
         self.all_paths: re.Pattern = re.compile(
             "|".join(
                 path for path in [dispatcher_path, js_modules_path, static_path] if path
             )
         )
         self.dispatcher: Future | asyncio.Task | None = None
         self._cached_index_html: str = ""
+        self._static_file_server: StaticFiles | None = None
+        self._js_module_server: StaticFiles | None = None
         self.connected: bool = False
+        # TODO: Remove this setting from ReactPy config
+        self.js_modules_dir: Path | None = REACTPY_WEB_MODULES_DIR.current
 
         # Validate the arguments
         if not self.component and not self.user_app:
             raise TypeError(
-                "The first argument to ReactPy(...) must be a component or an ASGI application."
+                "The first argument to ReactPy(...) must be a component or an "
+                "ASGI application."
             )
         if self.backhaul_thread and not _backhaul_thread.is_alive():
             _backhaul_thread.start()
 
-    async def __call__(self, scope, receive, send) -> None:
-        """The ASGI callable. This determines whether ReactPy should route the the
+    async def __call__(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
+        """The ASGI callable. This determines whether ReactPy should route the
         request to ourselves or to the user application."""
         # Determine if ReactPy should handle the request
         if not self.user_app or re.match(self.all_paths, scope["path"]):
@@ -100,10 +108,14 @@ async def __call__(self, scope, receive, send) -> None:
         # Serve the user's application
         await self.user_app(scope, receive, send)
 
-    async def reactpy_app(self, scope, receive, send) -> None:
-        """Determine what type of request this is and route it to the appropriate
-        ReactPy ASGI sub-application."""
-
+    async def reactpy_app(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
+        """Determine what type of request this is and route it to the
+        appropriate ReactPy ASGI sub-application."""
         # Only HTTP and WebSocket requests are supported
         if scope["type"] not in {"http", "websocket"}:
             return
@@ -120,7 +132,7 @@ async def reactpy_app(self, scope, receive, send) -> None:
 
         # JS modules app
         if self.js_modules_path and re.match(self.js_modules_path, scope["path"]):
-            await self.js_modules_app(scope, receive, send)
+            await self.js_module_app(scope, receive, send)
             return
 
         # Static file app
@@ -133,7 +145,12 @@ async def reactpy_app(self, scope, receive, send) -> None:
             await self.standalone_app(scope, receive, send)
             return
 
-    async def component_dispatch_app(self, scope, receive, send) -> None:
+    async def component_dispatch_app(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
         """ASGI app for rendering ReactPy Python components."""
         while True:
             event = await receive()
@@ -161,45 +178,50 @@ async def component_dispatch_app(self, scope, receive, send) -> None:
                 else:
                     await recv_queue_put
 
-    async def js_modules_app(self, scope, receive, send) -> None:
+    async def js_module_app(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
         """ASGI app for ReactPy web modules."""
-        if not REACTPY_WEB_MODULES_DIR.current:
+        if not self.js_modules_dir:
             raise RuntimeError("No web modules directory configured.")
-
-        # Make sure the user hasn't tried to escape the web modules directory
-        try:
-            abs_file_path = safe_join_path(
-                REACTPY_WEB_MODULES_DIR.current,
-                re.match(self.js_modules_path, scope["path"])[1],
+        if not self.js_modules_path:
+            raise RuntimeError(
+                "Web modules cannot be served without defining `js_module_path`."
             )
-        except ValueError:
-            await http_response(scope, send, 403, "Forbidden")
-            return
+        if not self._js_module_server:
+            self._js_module_server = StaticFiles(directory=self.js_modules_dir)
 
-        # Serve the file
-        await file_response(scope, send, abs_file_path, self.block_size)
+        await self._js_module_server(scope, receive, send)
 
-    async def static_file_app(self, scope, receive, send) -> None:
+    async def static_file_app(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
         """ASGI app for ReactPy static files."""
         if not self.static_dir:
             raise RuntimeError(
                 "Static files cannot be served without defining `static_dir`."
             )
-
-        # Make sure the user hasn't tried to escape the static directory
-        try:
-            abs_file_path = safe_join_path(
-                self.static_dir,
-                re.match(self.static_path, scope["path"])[1],
+        if not self.static_path:
+            raise RuntimeError(
+                "Static files cannot be served without defining `static_path`."
             )
-        except ValueError:
-            await http_response(scope, send, 403, "Forbidden")
-            return
+        if not self._static_file_server:
+            self._static_file_server = StaticFiles(directory=self.static_dir)
 
-        # Serve the file
-        await file_response(scope, send, abs_file_path, self.block_size)
+        await self._static_file_server(scope, receive, send)
 
-    async def standalone_app(self, scope, receive, send) -> None:
+    async def standalone_app(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
         """ASGI app for ReactPy standalone mode."""
         file_path = CLIENT_BUILD_DIR / "index.html"
         if not self._cached_index_html:
@@ -221,10 +243,23 @@ async def standalone_app(self, scope, receive, send) -> None:
             ],
         )
 
-    async def run_dispatcher(self, scope, receive, send):
+    async def run_dispatcher(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[..., Coroutine],
+        send: Callable[..., Coroutine],
+    ) -> None:
         # If in standalone mode, serve the user provided component.
         # In middleware mode, get the component from the URL.
-        component = self.component or re.match(self.dispatch_path, scope["path"])[1]
+        component = self.component
+        if not component:
+            url_path = re.match(self.dispatch_path, scope["path"])
+            if not url_path:
+                raise RuntimeError("Could not find component in URL path.")
+            dotted_path = url_path[1]
+            module_str, component_str = dotted_path.rsplit(".", 1)
+            module = import_module(module_str)
+            component = getattr(module, component_str)
         parsed_url = urllib.parse.urlparse(scope["path"])
         self.recv_queue: asyncio.Queue = asyncio.Queue()
 
@@ -251,18 +286,18 @@ async def run_dispatcher(self, scope, receive, send):
         )
 
 
-def send_json(send) -> None:
+def send_json(send: Callable) -> Callable[..., Coroutine]:
     """Use orjson to send JSON over an ASGI websocket."""
 
-    async def _send_json(value) -> None:
+    async def _send_json(value: Any) -> None:
         await send({"type": "websocket.send", "text": orjson.dumps(value)})
 
     return _send_json
 
 
 async def http_response(
-    scope,
-    send,
+    scope: dict[str, Any],
+    send: Callable[..., Coroutine],
     code: int,
     message: str,
     content_type: bytes = b"text/plain",
@@ -279,79 +314,3 @@ async def http_response(
     # Head requests don't need a body
     if scope["method"] != "HEAD":
         await send({"type": "http.response.body", "body": message.encode()})
-
-
-async def file_response(scope, send, file_path: Path, block_size: int) -> None:
-    """Send a file in chunks."""
-    # Make sure the file exists
-    if not await asyncio.to_thread(os.path.exists, file_path):
-        await http_response(scope, send, 404, "File not found.")
-        return
-
-    # Make sure it's a file
-    if not await asyncio.to_thread(os.path.isfile, file_path):
-        await http_response(scope, send, 400, "Not a file.")
-        return
-
-    # Check if the file is already cached by the client
-    etag = await header_val(scope, b"etag")
-    modification_time = await asyncio.to_thread(os.path.getmtime, file_path)
-    if etag and etag != modification_time:
-        await http_response(scope, send, 304, "Not modified.")
-        return
-
-    # Get the file's MIME type
-    mime_type = (
-        MIME_TYPES.get(file_path.rsplit(".")[1], None)
-        # Fallback to guess_type to allow for the user to define custom MIME types on their system
-        or (await asyncio.to_thread(mimetypes.guess_type, file_path, strict=False))[0]
-    )
-    if mime_type is None:
-        mime_type = "text/plain"
-        _logger.error(
-            f"Could not determine MIME type for {file_path}. Defaulting to 'text/plain'."
-        )
-
-    # Send the file in chunks
-    file_size = await asyncio.to_thread(os.path.getsize, file_path)
-    async with aiofiles.open(file_path, "rb") as file_handle:
-        await send(
-            {
-                "type": "http.response.start",
-                "status": 200,
-                "headers": [
-                    (b"content-type", mime_type.encode()),
-                    (b"etag", modification_time),
-                    (b"content-length", file_size),
-                ],
-            }
-        )
-
-        # Head requests don't need a body
-        if scope["method"] != "HEAD":
-            while True:
-                chunk = await file_handle.read(block_size)
-                more_body = bool(chunk)
-                await send(
-                    {
-                        "type": "http.response.body",
-                        "body": chunk,
-                        "more_body": more_body,
-                    }
-                )
-                if not more_body:
-                    break
-
-
-async def header_val(
-    scope: dict, key: str, default: str | int | None = None
-) -> str | int | None:
-    """Get a value from a scope's headers."""
-    return await anext(
-        (
-            value.decode()
-            for header_key, value in scope["headers"]
-            if header_key == key.encode()
-        ),
-        default,
-    )

src/py/reactpy/reactpy/backend/mimetypes.py

@@ -2,6 +2,11 @@
 We ship our own mime types to ensure consistent behavior across platforms.
 This dictionary is based on: https://github.com/micnic/mime.json
 """
+import mimetypes
+import os
+import typing
+
+from starlette import responses
 
 MIME_TYPES = {
     "123": "application/vnd.lotus-1-2-3",
@@ -1206,3 +1211,18 @@
     "zirz": "application/vnd.zul",
     "zmm": "application/vnd.handheld-entertainment+xml",
 }
+
+
+def guess_type(
+    url: typing.Union[str, "os.PathLike[str]"],
+    strict: bool = True,
+):
+    """Mime type checker that prefers our predefined types over the built-in
+    mimetypes module."""
+    mime_type, encoding = mimetypes.guess_type(url, strict)
+
+    return (MIME_TYPES.get(str(url).rsplit(".")[1]) or mime_type, encoding)
+
+
+# Monkey patch starlette's mime types
+responses.guess_type = guess_type